| import tkinter as tk
|
| from tkinter import ttk, messagebox
|
| import json
|
| import os
|
| import logging
|
| from translator_factory import TranslatorFactory
|
| from appearance import appearance_manager
|
| from advance_ui import AdvanceUI
|
|
|
|
|
| def is_valid_hotkey(hotkey):
|
| hotkey = hotkey.lower()
|
| valid_keys = set("abcdefghijklmnopqrstuvwxyz0123456789")
|
| valid_functions = set(
|
| ["f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12"]
|
| )
|
| valid_modifiers = set(["ctrl", "alt", "shift"])
|
|
|
| parts = hotkey.split("+")
|
|
|
| if len(parts) == 1:
|
| return parts[0] in valid_functions or parts[0] in valid_keys
|
|
|
| if len(parts) > 1:
|
| modifiers = parts[:-1]
|
| key = parts[-1]
|
| return all(mod in valid_modifiers for mod in modifiers) and (
|
| key in valid_keys or key in valid_functions
|
| )
|
|
|
| return False
|
|
|
|
|
| class HotkeyUI:
|
| def __init__(self, parent, settings, update_hotkeys_callback):
|
| self.parent = parent
|
| self.settings = settings
|
| self.update_hotkeys_callback = update_hotkeys_callback
|
| self.hotkey_window = None
|
| self.toggle_ui_var = tk.StringVar()
|
| self.start_stop_var = tk.StringVar()
|
|
|
| def show(self):
|
| if self.hotkey_window is None or not self.hotkey_window.winfo_exists():
|
| self.create_hotkey_window()
|
| self.hotkey_window.deiconify()
|
| self.load_current_hotkeys()
|
| return self.hotkey_window
|
|
|
| def create_hotkey_window(self):
|
| self.hotkey_window = tk.Toplevel(self.parent)
|
| self.hotkey_window.title("Hotkey Settings")
|
| self.hotkey_window.geometry("240x240")
|
| self.hotkey_window.overrideredirect(True)
|
| self.hotkey_window.resizable(False, False)
|
| appearance_manager.apply_style(self.hotkey_window)
|
|
|
| tk.Label(
|
| self.hotkey_window,
|
| text="\n ตั้งค่าปุ่ม Hotkey\nที่ต้องการด้วยการ 'พิมพ์ตัวอักษร'\nแล้วกด save",
|
| bg=appearance_manager.bg_color,
|
| fg=appearance_manager.fg_color,
|
| justify=tk.LEFT,
|
| ).pack(pady=10, padx=10)
|
|
|
| toggle_frame = tk.Frame(self.hotkey_window, bg=appearance_manager.bg_color)
|
| toggle_frame.pack(fill=tk.X, padx=10, pady=5)
|
| tk.Label(
|
| toggle_frame,
|
| text="Toggle UI:",
|
| bg=appearance_manager.bg_color,
|
| fg=appearance_manager.fg_color,
|
| ).pack(side=tk.LEFT)
|
| self.toggle_ui_entry = tk.Entry(toggle_frame, textvariable=self.toggle_ui_var)
|
| self.toggle_ui_entry.pack(side=tk.RIGHT, expand=True, fill=tk.X)
|
|
|
| start_stop_frame = tk.Frame(self.hotkey_window, bg=appearance_manager.bg_color)
|
| start_stop_frame.pack(fill=tk.X, padx=10, pady=5)
|
| tk.Label(
|
| start_stop_frame,
|
| text="Start/Stop Translate:",
|
| bg=appearance_manager.bg_color,
|
| fg=appearance_manager.fg_color,
|
| ).pack(side=tk.LEFT)
|
| self.start_stop_entry = tk.Entry(
|
| start_stop_frame, textvariable=self.start_stop_var
|
| )
|
| self.start_stop_entry.pack(side=tk.RIGHT, expand=True, fill=tk.X)
|
|
|
| self.save_button = appearance_manager.create_styled_button(
|
| self.hotkey_window, "Save", self.save_hotkeys
|
| )
|
| self.save_button.pack(pady=10)
|
|
|
| close_button = appearance_manager.create_styled_button(
|
| self.hotkey_window, "X", self.close
|
| )
|
| close_button.place(x=5, y=5, width=20, height=20)
|
|
|
| self.hotkey_window.bind("<Button-1>", self.start_move)
|
| self.hotkey_window.bind("<ButtonRelease-1>", self.stop_move)
|
| self.hotkey_window.bind("<B1-Motion>", self.do_move)
|
|
|
| def load_current_hotkeys(self):
|
| self.toggle_ui_var.set(self.settings.get_shortcut("toggle_ui"))
|
| self.start_stop_var.set(self.settings.get_shortcut("start_stop_translate"))
|
|
|
| def save_hotkeys(self):
|
| toggle_ui = self.toggle_ui_var.get().lower()
|
| start_stop = self.start_stop_var.get().lower()
|
|
|
| if is_valid_hotkey(toggle_ui) and is_valid_hotkey(start_stop):
|
| self.settings.set_shortcut("toggle_ui", toggle_ui)
|
| self.settings.set_shortcut("start_stop_translate", start_stop)
|
| self.save_button.config(text="Saved!")
|
| print(
|
| f"New hotkeys saved: Toggle UI: {toggle_ui}, Start/Stop Translate: {start_stop}"
|
| )
|
| self.update_hotkeys_callback()
|
| else:
|
| messagebox.showerror("Invalid Hotkey", "Please enter valid hotkeys.")
|
|
|
| def close(self):
|
| if self.hotkey_window and self.hotkey_window.winfo_exists():
|
| self.save_button.config(text="Save")
|
| self.hotkey_window.withdraw()
|
|
|
| def start_move(self, event):
|
| self.x = event.x
|
| self.y = event.y
|
|
|
| def stop_move(self, event):
|
| self.x = None
|
| self.y = None
|
|
|
| def do_move(self, event):
|
| deltax = event.x - self.x
|
| deltay = event.y - self.y
|
| x = self.hotkey_window.winfo_x() + deltax
|
| y = self.hotkey_window.winfo_y() + deltay
|
| self.hotkey_window.geometry(f"+{x}+{y}")
|
|
|
|
|
| class Settings:
|
| VALID_MODELS = {
|
| "gpt-4o": {"display_name": "gpt-4o", "type": "gpt"},
|
| "gpt-4o-mini": {"display_name": "gpt-4o-mini", "type": "gpt"},
|
| "claude-3-5-haiku-20241022": {
|
| "display_name": "claude-3.5-haiku",
|
| "type": "claude",
|
| },
|
| }
|
|
|
| DEFAULT_API_PARAMETERS = {
|
|
|
| "model": "gpt-4o",
|
| "displayed_model": "gpt-4o",
|
| "max_tokens": 500,
|
| "temperature": 0.7,
|
| "top_p": 0.9,
|
|
|
| "ocr_settings": {
|
| "languages": ["en", "ko"],
|
| "confidence_threshold": 0.65,
|
| "image_preprocessing": {
|
| "resize_factor": 2.0,
|
| "contrast": 1.5,
|
| "sharpness": 1.3,
|
| "threshold": 128,
|
| },
|
| },
|
|
|
| "translation_settings": {
|
| "source_languages": ["en", "ko"],
|
| "target_language": "th",
|
| "preserve_names": True,
|
| "modern_style": True,
|
| "flirty_tone": True,
|
| "use_emojis": True,
|
| },
|
|
|
| "special_chars": {
|
| "korean_range": ["\u3130-\u318F", "\uAC00-\uD7AF"],
|
| "thai_range": ["\u0E00-\u0E7F"],
|
| "allowed_symbols": ["...", "—", "!", "?", "💕", "✨", "🥺", "😏"],
|
| },
|
| }
|
|
|
| def __init__(self):
|
| self.default_settings = {
|
| "api_parameters": self.DEFAULT_API_PARAMETERS.copy(),
|
| "transparency": 0.8,
|
| "font_size": 24,
|
| "font": "IBM Plex Sans Thai Medium.ttf",
|
| "width": 960,
|
| "height": 240,
|
| "enable_force_translate": True,
|
| "enable_auto_hide": True,
|
| "enable_ui_toggle": True,
|
| "bg_color": appearance_manager.bg_color,
|
| "translate_areas": {
|
| "A": {"start_x": 0, "start_y": 0, "end_x": 0, "end_y": 0},
|
| "B": {"start_x": 0, "start_y": 0, "end_x": 0, "end_y": 0},
|
| "C": {"start_x": 0, "start_y": 0, "end_x": 0, "end_y": 0},
|
| },
|
| "current_area": "A+B",
|
| "display_scale": None,
|
| }
|
| self.load_settings()
|
| self.ensure_default_values()
|
|
|
| def validate_model_parameters(self, params):
|
| """Validate the given parameters."""
|
| if not isinstance(params, dict):
|
| raise ValueError("Parameters must be a dictionary")
|
|
|
|
|
| if "model" in params:
|
| if params["model"] not in self.VALID_MODELS:
|
| valid_models = list(self.VALID_MODELS.keys())
|
| raise ValueError(f"Invalid model. Must be one of: {valid_models}")
|
|
|
|
|
| if "max_tokens" in params:
|
| max_tokens = int(params["max_tokens"])
|
| if not (100 <= max_tokens <= 2000):
|
| raise ValueError("max_tokens must be between 100 and 2000")
|
|
|
| if "temperature" in params:
|
| temp = float(params["temperature"])
|
| if not (0.1 <= temp <= 1.0):
|
| raise ValueError("temperature must be between 0.1 and 1.0")
|
|
|
| return True
|
|
|
| def get_display_scale(self):
|
| """Return the stored display scale or None if not set."""
|
| return self.settings.get("display_scale")
|
|
|
| def set_display_scale(self, scale):
|
| """Save the display scale if valid."""
|
| try:
|
| scale = float(scale)
|
| if 0.5 <= scale <= 3.0:
|
| self.settings["display_scale"] = scale
|
| self.save_settings()
|
| print(f"Display scale saved: {int(scale * 100)}%")
|
| return True
|
| else:
|
| print(f"Invalid scale value: {scale}")
|
| return False
|
| except Exception as e:
|
| print(f"Error saving display scale: {e}")
|
| return False
|
|
|
| def validate_display_scale(self, scale):
|
| """Validate the display scale value."""
|
| try:
|
| scale = float(scale)
|
| if 0.5 <= scale <= 3.0:
|
| return {
|
| "is_valid": True,
|
| "message": "Valid scale value",
|
| "value": scale,
|
| }
|
| return {
|
| "is_valid": False,
|
| "message": f"Scale must be between 50% and 300%, got {int(scale * 100)}%",
|
| "value": None,
|
| }
|
| except (ValueError, TypeError):
|
| return {
|
| "is_valid": False,
|
| "message": "Invalid scale value type",
|
| "value": None,
|
| }
|
|
|
| def set_bg_color(self, color):
|
| """Set and save the background color."""
|
| self.settings["bg_color"] = color
|
| self.save_settings()
|
| appearance_manager.update_bg_color(color)
|
|
|
| def get(self, key, default=None):
|
| if key == "bg_color":
|
| return self.settings.get("bg_color", appearance_manager.bg_color)
|
| return self.settings.get(key, default)
|
|
|
| def set(self, key, value):
|
| self.settings[key] = value
|
| self.save_settings()
|
|
|
| def load_settings(self):
|
| try:
|
| with open("settings.json", "r") as f:
|
| self.settings = json.load(f)
|
| except FileNotFoundError:
|
| self.settings = {
|
| "transparency": 0.8,
|
| "font_size": 24,
|
| "font": "IBM Plex Sans Thai Medium.ttf",
|
| "width": 960,
|
| "height": 240,
|
| "enable_force_translate": True,
|
| "enable_auto_hide": True,
|
| "enable_ui_toggle": True,
|
| "translate_areas": {
|
| "A": {"start_x": 0, "start_y": 0, "end_x": 0, "end_y": 0},
|
| "B": {"start_x": 0, "start_y": 0, "end_x": 0, "end_y": 0},
|
| "C": {"start_x": 0, "start_y": 0, "end_x": 0, "end_y": 0},
|
| },
|
| "api_parameters": {
|
| "model": "gpt-4o",
|
| "max_tokens": 500,
|
| "temperature": 0.7,
|
| "top_p": 0.9,
|
| },
|
| "use_gpu_for_ocr": False,
|
| "shortcuts": {"toggle_ui": "alt+h", "start_stop_translate": "f9"},
|
| "logs_ui": {
|
| "width": 480,
|
| "height": 320,
|
| "font_size": 16,
|
| "visible": True,
|
| },
|
| }
|
|
|
| def save_settings(self):
|
| """Save all current settings to file."""
|
| try:
|
|
|
| if "api_parameters" in self.settings:
|
| api_params = self.settings["api_parameters"]
|
| if api_params.get("model") == "claude-3-5-haiku-20241022":
|
| api_params.pop("top_p", None)
|
| if "temperature" in api_params:
|
| api_params["temperature"] = (
|
| round(api_params["temperature"] * 10) / 10
|
| )
|
| if "top_p" in api_params:
|
| api_params["top_p"] = round(api_params["top_p"] * 10) / 10
|
|
|
|
|
| if "current_area" in self.settings:
|
| current_areas = self.settings["current_area"]
|
| if isinstance(current_areas, list):
|
| self.settings["current_area"] = "+".join(current_areas)
|
|
|
|
|
| if "area_presets" not in self.settings:
|
| self.settings["area_presets"] = [
|
| {"name": "Preset 1", "areas": "A+B"},
|
| {"name": "Preset 2", "areas": "C"},
|
| {"name": "Preset 3", "areas": "A"},
|
| {"name": "Preset 4", "areas": "B"},
|
| {"name": "Preset 5", "areas": "A+B+C"},
|
| ]
|
|
|
|
|
| with open("settings.json", "w") as f:
|
| json.dump(self.settings, f, indent=4)
|
|
|
| except Exception as e:
|
| logging.error(f"Error saving settings: {e}")
|
| raise
|
|
|
| def ensure_default_values(self):
|
| """Add default values if missing."""
|
| if "bg_color" not in self.settings:
|
| self.settings["bg_color"] = appearance_manager.bg_color
|
| if "api_parameters" not in self.settings:
|
| self.settings["api_parameters"] = self.DEFAULT_API_PARAMETERS.copy()
|
| if "display_scale" not in self.settings:
|
| self.settings["display_scale"] = None
|
| if "area_presets" not in self.settings:
|
|
|
| self.settings["area_presets"] = [
|
| {"name": "Preset 1", "areas": "A+B"},
|
| {"name": "Preset 2", "areas": "C"},
|
| {"name": "Preset 3", "areas": "A"},
|
| {"name": "Preset 4", "areas": "B"},
|
| {"name": "Preset 5", "areas": "A+B+C"},
|
| ]
|
|
|
|
|
| current_params = self.settings.get("api_parameters", {})
|
| for key, value in self.DEFAULT_API_PARAMETERS.items():
|
| if key not in current_params:
|
| current_params[key] = value
|
|
|
| if "model" in current_params:
|
| if current_params["model"] == "claude-3-5-haiku-20241022":
|
| current_params.pop("top_p", None)
|
| if "displayed_model" not in current_params:
|
| current_params["displayed_model"] = self.VALID_MODELS.get(
|
| current_params["model"], {}
|
| ).get("display_name", current_params["model"])
|
|
|
| self.save_settings()
|
|
|
| def get_preset(self, preset_number):
|
| """รับค่า preset ตามหมายเลข"""
|
| presets = self.settings.get("area_presets", [])
|
| if 1 <= preset_number <= len(presets):
|
| return presets[preset_number - 1]
|
| return None
|
|
|
| def validate_coordinates(self, coordinates):
|
| """ตรวจสอบความถูกต้องของพิกัดสำหรับแต่ละพื้นที่
|
| Args:
|
| coordinates (dict): Dictionary ของพิกัดแต่ละพื้นที่
|
| เช่น: {
|
| 'A': {'start_x': 100, 'start_y': 100, 'end_x': 200, 'end_y': 200},
|
| 'B': {'start_x': 300, 'start_y': 300, 'end_x': 400, 'end_y': 400}
|
| }
|
| Returns:
|
| bool: True ถ้าพิกัดถูกต้อง, False ถ้าไม่ถูกต้อง
|
| """
|
| required_keys = {"start_x", "start_y", "end_x", "end_y"}
|
|
|
| try:
|
| for area, coords in coordinates.items():
|
|
|
| if not all(key in coords for key in required_keys):
|
| logging.error(f"Missing required coordinate keys for area {area}")
|
| return False
|
|
|
|
|
| if not all(
|
| isinstance(coords[key], (int, float)) for key in required_keys
|
| ):
|
| logging.error(f"Invalid coordinate values for area {area}")
|
| return False
|
|
|
|
|
| if (
|
| coords["end_x"] <= coords["start_x"]
|
| or coords["end_y"] <= coords["start_y"]
|
| ):
|
| logging.error(f"Invalid coordinate ranges for area {area}")
|
| return False
|
|
|
|
|
| if any(coords[key] < 0 for key in required_keys):
|
| logging.error(f"Negative coordinates found for area {area}")
|
| return False
|
|
|
| return True
|
|
|
| except Exception as e:
|
| logging.error(f"Error validating coordinates: {e}")
|
| return False
|
|
|
| def save_preset(self, preset_number, areas, coordinates):
|
| """บันทึก preset พร้อมพิกัด
|
| Args:
|
| preset_number: หมายเลข preset (1-5)
|
| areas: สตริงของพื้นที่ เช่น "A+B"
|
| coordinates: dict ของพิกัดแต่ละพื้นที่
|
| """
|
| try:
|
|
|
| if not self.validate_coordinates(coordinates):
|
| raise ValueError("Invalid coordinates provided")
|
|
|
|
|
| presets = self.settings.get("area_presets", [])
|
|
|
|
|
| preset_data = {
|
| "name": f"Preset {preset_number}",
|
| "areas": areas,
|
| "coordinates": coordinates,
|
| }
|
|
|
|
|
| index = preset_number - 1
|
| if 0 <= index < len(presets):
|
| presets[index] = preset_data
|
| else:
|
|
|
| while len(presets) <= index:
|
| presets.append(
|
| {
|
| "name": f"Preset {len(presets) + 1}",
|
| "areas": "A+B",
|
| "coordinates": {},
|
| }
|
| )
|
| presets[index] = preset_data
|
|
|
|
|
| self.settings["area_presets"] = presets
|
| self.save_settings()
|
|
|
| logging.info(f"Saved preset {preset_number} with areas: {areas}")
|
|
|
| except Exception as e:
|
| logging.error(f"Error saving preset: {e}")
|
| raise
|
|
|
| def get_all_presets(self):
|
| """รับค่า presets ทั้งหมด"""
|
| return self.settings.get("area_presets", [])
|
|
|
| def validate_preset(self, preset_number, preset_data):
|
| """ตรวจสอบความถูกต้องของข้อมูล preset
|
| Args:
|
| preset_number: หมายเลข preset (1-5)
|
| preset_data: ข้อมูล preset ที่จะบันทึก
|
| Returns:
|
| bool: True ถ้าข้อมูลถูกต้อง
|
| """
|
| try:
|
| if not 1 <= preset_number <= 5:
|
| return False
|
|
|
| if not isinstance(preset_data, dict):
|
| return False
|
|
|
| required_keys = {"name", "areas", "coordinates"}
|
| if not all(key in preset_data for key in required_keys):
|
| return False
|
|
|
|
|
| areas = preset_data["areas"].split("+")
|
| if not all(area in ["A", "B", "C"] for area in areas):
|
| return False
|
|
|
|
|
| if not self.validate_coordinates(preset_data["coordinates"]):
|
| return False
|
|
|
| return True
|
|
|
| except Exception as e:
|
| logging.error(f"Error validating preset: {e}")
|
| return False
|
|
|
| def set_current_preset(self, preset_number):
|
| """ตั้งค่า preset ปัจจุบัน
|
| Args:
|
| preset_number: int ระหว่าง 1-5
|
| """
|
| if not 1 <= preset_number <= 5:
|
| raise ValueError("Invalid preset number")
|
| self.settings["current_preset"] = preset_number
|
| self.save_settings()
|
|
|
| def get_current_preset(self):
|
| """รับค่า preset ปัจจุบัน
|
| Returns:
|
| int: หมายเลข preset ปัจจุบัน (1-5)
|
| """
|
| return self.settings.get("current_preset", 1)
|
|
|
| def get_logs_settings(self):
|
| """Return the settings for the logs UI."""
|
| return self.settings.get(
|
| "logs_ui", {"width": 480, "height": 320, "font_size": 16, "visible": True}
|
| )
|
|
|
| def set_logs_settings(self, width=None, height=None, font_size=None, visible=None):
|
| """Update the logs UI settings."""
|
| if "logs_ui" not in self.settings:
|
| self.settings["logs_ui"] = {}
|
|
|
| if width is not None:
|
| self.settings["logs_ui"]["width"] = width
|
| if height is not None:
|
| self.settings["logs_ui"]["height"] = height
|
| if font_size is not None:
|
| self.settings["logs_ui"]["font_size"] = font_size
|
| if visible is not None:
|
| self.settings["logs_ui"]["visible"] = visible
|
|
|
| self.save_settings()
|
|
|
| def get_shortcut(self, action, default=None):
|
| return self.settings.get("shortcuts", {}).get(action, default)
|
|
|
| def set_shortcut(self, action, shortcut):
|
| if "shortcuts" not in self.settings:
|
| self.settings["shortcuts"] = {}
|
| self.settings["shortcuts"][action] = shortcut
|
| self.save_settings()
|
|
|
| def set_screen_size(self, size):
|
| self.settings["screen_size"] = size
|
| self.save_settings()
|
|
|
| def set_gpu_for_ocr(self, use_gpu):
|
| self.settings["use_gpu_for_ocr"] = use_gpu
|
| self.save_settings()
|
| current_mode = "GPU" if use_gpu else "CPU"
|
| logging.info(f"Switched OCR to [{current_mode}]")
|
| print(f"Switched OCR to [{current_mode}]")
|
|
|
| def set_current_area(self, area):
|
| self.settings["current_area"] = area
|
| self.save_settings()
|
|
|
| def get_current_area(self):
|
| return self.settings.get("current_area", "A")
|
|
|
| def set_translate_area(self, start_x, start_y, end_x, end_y, area):
|
| """Save the translation area without brush points."""
|
| self.settings["translate_areas"] = self.settings.get("translate_areas", {})
|
| self.settings["translate_areas"][area] = {
|
| "start_x": start_x,
|
| "start_y": start_y,
|
| "end_x": end_x,
|
| "end_y": end_y,
|
| }
|
| self.save_settings()
|
|
|
| def get_translate_area(self, area):
|
| """Return the translation area data."""
|
| translate_areas = self.settings.get("translate_areas", {})
|
| return translate_areas.get(area, None)
|
|
|
| def set_api_parameters(
|
| self, model=None, max_tokens=None, temperature=None, top_p=None
|
| ):
|
| try:
|
| if "api_parameters" not in self.settings:
|
| self.settings["api_parameters"] = {}
|
|
|
| api_params = self.settings["api_parameters"]
|
| changes = []
|
|
|
| if model is not None:
|
| if model not in self.VALID_MODELS:
|
| raise ValueError(f"Invalid model: {model}")
|
| old_model = api_params.get("model")
|
| model_info = self.VALID_MODELS[model]
|
| api_params.update(
|
| {"model": model, "displayed_model": model_info["display_name"]}
|
| )
|
| if model_info["type"] == "claude":
|
| api_params.pop("top_p", None)
|
| changes.append(f"Model: {old_model} -> {model}")
|
|
|
| if max_tokens is not None:
|
| if not (100 <= max_tokens <= 1000):
|
| raise ValueError("Max tokens must be between 100 and 1000")
|
| old_tokens = api_params.get("max_tokens")
|
| api_params["max_tokens"] = max_tokens
|
| changes.append(f"Max tokens: {old_tokens} -> {max_tokens}")
|
|
|
| if temperature is not None:
|
| if not (0.1 <= temperature <= 0.9):
|
| raise ValueError("Temperature must be between 0.1 and 0.9")
|
| old_temp = api_params.get("temperature")
|
| api_params["temperature"] = round(temperature * 10) / 10
|
| changes.append(f"Temperature: {old_temp} -> {temperature}")
|
|
|
| if (
|
| self.VALID_MODELS.get(model or api_params.get("model", ""), {}).get(
|
| "type"
|
| )
|
| == "gpt"
|
| ):
|
| if top_p is not None:
|
| if not (0.1 <= top_p <= 0.9):
|
| raise ValueError("Top P must be between 0.1 and 0.9")
|
| old_top_p = api_params.get("top_p")
|
| api_params["top_p"] = round(top_p * 10) / 10
|
| changes.append(f"Top P: {old_top_p} -> {top_p}")
|
|
|
| self.save_settings()
|
|
|
| if changes:
|
| logging.info("\n=== API Parameters Updated ===")
|
| for change in changes:
|
| logging.info(change)
|
| logging.info(f"Current Settings: {api_params}")
|
| logging.info("============================\n")
|
|
|
| return True, None
|
| except Exception as e:
|
| logging.error(f"Error setting API parameters: {str(e)}")
|
| return False, str(e)
|
|
|
| def get_displayed_model(self):
|
| """Return the model name for UI display."""
|
| api_params = self.get_api_parameters()
|
| return api_params.get("displayed_model", api_params.get("model", "gpt-4o"))
|
|
|
| def get_api_parameters(self):
|
| """Return the current API parameters."""
|
| default_params = {
|
| "model": "gpt-4o",
|
| "displayed_model": "gpt-4o",
|
| "max_tokens": 500,
|
| "temperature": 0.7,
|
| "top_p": 0.9,
|
| }
|
| params = self.settings.get("api_parameters", default_params).copy()
|
|
|
| if params.get("model") == "claude-3-5-haiku-20241022":
|
| params["displayed_model"] = "claude-3.5-haiku"
|
| params.pop("top_p", None)
|
|
|
| if "temperature" in params:
|
| params["temperature"] = round(params["temperature"] * 10) / 10
|
| if "top_p" in params:
|
| params["top_p"] = round(params["top_p"] * 10) / 10
|
|
|
| return params
|
|
|
|
|
| class SettingsUI:
|
| def __init__(
|
| self, parent, settings, apply_settings_callback, update_hotkeys_callback
|
| ):
|
| self.parent = parent
|
| self.settings = settings
|
| self.apply_settings_callback = apply_settings_callback
|
| self.update_hotkeys_callback = update_hotkeys_callback
|
| self.settings_window = None
|
| self.settings_visible = False
|
| self.ocr_toggle_callback = None
|
| self.create_settings_window()
|
| self.advance_ui = None
|
| self.hotkey_ui = None
|
|
|
| def create_settings_window(self):
|
| self.settings_window = tk.Toplevel(self.parent)
|
| self.settings_window.overrideredirect(True)
|
| appearance_manager.apply_style(self.settings_window)
|
| self.create_settings_ui()
|
| self.settings_window.withdraw()
|
|
|
| def set_ocr_toggle_callback(self, callback):
|
| self.ocr_toggle_callback = callback
|
| if self.advance_ui:
|
| self.advance_ui.settings_ui.ocr_toggle_callback = callback
|
|
|
| def open_settings(self, parent_x, parent_y, parent_width):
|
| """Open settings window at specified position relative to parent"""
|
|
|
| x = parent_x + parent_width + 20
|
| y = parent_y
|
| self.settings_window.geometry(f"+{x}+{y}")
|
|
|
|
|
| self.transparency_scale.set(int(self.settings.get("transparency") * 100))
|
| self.font_size_var.set(str(self.settings.get("font_size")))
|
| self.font_var.set(self.settings.get("font"))
|
| self.width_entry.delete(0, tk.END)
|
| self.width_entry.insert(0, str(self.settings.get("width")))
|
| self.height_entry.delete(0, tk.END)
|
| self.height_entry.insert(0, str(self.settings.get("height")))
|
| self.force_translate_var.set(self.settings.get("enable_force_translate"))
|
| self.auto_hide_var.set(self.settings.get("enable_auto_hide"))
|
| self.ui_toggle_var.set(self.settings.get("enable_ui_toggle"))
|
|
|
|
|
| self.settings_window.deiconify()
|
| self.settings_window.lift()
|
| self.settings_window.attributes("-topmost", True)
|
| self.settings_visible = True
|
|
|
|
|
| if hasattr(self, "advance_button"):
|
| self.advance_button.config(text="Screen/API")
|
| if hasattr(self, "hotkey_button"):
|
| self.hotkey_button.config(text="HotKey")
|
|
|
| def open(self):
|
| """Toggle the advance window visibility"""
|
| if self.advance_window is None or not self.advance_window.winfo_exists():
|
| self.create_advance_window()
|
|
|
| if self.advance_window.winfo_viewable():
|
| self.close()
|
| if hasattr(self.parent, "advance_button"):
|
| self.parent.advance_button.config(text="Screen/API")
|
| else:
|
|
|
| parent_x = self.parent.winfo_x()
|
| parent_y = self.parent.winfo_y()
|
| parent_width = self.parent.winfo_width()
|
|
|
|
|
| x = parent_x + parent_width + 5
|
| y = parent_y
|
|
|
| self.advance_window.geometry(f"+{x}+{y}")
|
| self.advance_window.deiconify()
|
| self.advance_window.lift()
|
| self.advance_window.attributes("-topmost", True)
|
|
|
| self.load_current_settings()
|
| self.is_changed = False
|
| self.update_save_button()
|
|
|
| if hasattr(self.parent, "advance_button"):
|
| self.parent.advance_button.config(text="Close Advanced")
|
|
|
| def close_settings(self):
|
| self.settings_window.withdraw()
|
| self.settings_visible = False
|
| if self.advance_ui:
|
| self.advance_ui.close()
|
| if self.hotkey_ui:
|
| self.hotkey_ui.close()
|
| self.hotkey_button.config(text="HotKey")
|
|
|
| def validate_window_size(self, event=None):
|
| """Validate and update window size from entries"""
|
| try:
|
| width = int(self.width_entry.get())
|
| height = int(self.height_entry.get())
|
|
|
|
|
| width = max(300, min(2000, width))
|
| height = max(200, min(1000, height))
|
|
|
|
|
| self.width_entry.delete(0, tk.END)
|
| self.width_entry.insert(0, str(width))
|
| self.height_entry.delete(0, tk.END)
|
| self.height_entry.insert(0, str(height))
|
|
|
|
|
| self.settings.set("width", width)
|
| self.settings.set("height", height)
|
|
|
| return True
|
|
|
| except ValueError:
|
| messagebox.showerror(
|
| "Invalid Input", "Please enter valid numbers for width and height"
|
| )
|
|
|
|
|
| self.width_entry.delete(0, tk.END)
|
| self.width_entry.insert(0, str(self.settings.get("width")))
|
| self.height_entry.delete(0, tk.END)
|
| self.height_entry.insert(0, str(self.settings.get("height")))
|
|
|
| return False
|
|
|
| def create_settings_ui(self):
|
|
|
| appearance_manager.create_styled_label(
|
| self.settings_window, text="Transparency:"
|
| ).pack(pady=5)
|
| transparency_frame, self.transparency_scale = (
|
| appearance_manager.create_styled_scale(
|
| self.settings_window, from_=0, to=100, orient=tk.HORIZONTAL
|
| )
|
| )
|
| transparency_frame.pack(pady=5, padx=10, fill=tk.X)
|
|
|
|
|
| appearance_manager.create_styled_label(
|
| self.settings_window, text="Font Size:"
|
| ).pack(pady=5)
|
| font_sizes = [16, 20, 24, 28, 32, 36]
|
| self.font_size_var = tk.StringVar()
|
| self.font_size_dropdown = appearance_manager.create_styled_combobox(
|
| self.settings_window, values=font_sizes, textvariable=self.font_size_var
|
| )
|
| self.font_size_dropdown.pack(pady=5, padx=10, fill=tk.X)
|
|
|
| self.transparency_value = self.transparency_scale.get()
|
|
|
|
|
| appearance_manager.create_styled_label(self.settings_window, text="Font:").pack(
|
| pady=5
|
| )
|
| thai_fonts = [
|
| "FC Minimal",
|
| "Nicalization Rg",
|
| "แบบบริการ TrueType",
|
| "Bai Jamjuree Light",
|
| "Bai Jamjuree Regular",
|
| "Bai Jamjuree SemiBold",
|
| "FC Minimal Medium",
|
| "IBM Plex Sans Thai Medium",
|
| "JetBrains Mono NL Bold",
|
| "JetBrains Mono NL Light",
|
| "JetBrains MonoNL Light Italic",
|
| "MaliThin",
|
| "Noto Sans Thai Looped Light",
|
| "Noto Sans Thai Looped",
|
| "PK Nakhon Sawan Regular Demo",
|
| "Sarabun",
|
| ]
|
|
|
| self.font_var = tk.StringVar()
|
| self.font_dropdown = appearance_manager.create_styled_combobox(
|
| self.settings_window, values=thai_fonts, textvariable=self.font_var
|
| )
|
| self.font_dropdown.pack(pady=5, padx=10, fill=tk.X)
|
|
|
|
|
| def on_font_change(*args):
|
| font_name = self.font_var.get()
|
| is_italic = "Italic" in font_name
|
| font_style = "italic" if is_italic else "roman"
|
| current_size = self.settings.get("font_size", 24)
|
|
|
|
|
| self.settings.set("font", font_name)
|
| self.settings.set("font_style", font_style)
|
|
|
|
|
| if hasattr(self, "translated_ui") and self.translated_ui:
|
| self.translated_ui.canvas.itemconfig(
|
| self.translated_ui.text_container,
|
| font=(font_name, current_size),
|
| slant=font_style,
|
| )
|
|
|
|
|
| if hasattr(self.translated_ui, "outline_container"):
|
| for outline in self.translated_ui.outline_container:
|
| self.translated_ui.canvas.itemconfig(
|
| outline, font=(font_name, current_size), slant=font_style
|
| )
|
|
|
| self.font_var.trace_add("write", on_font_change)
|
|
|
|
|
| appearance_manager.create_styled_label(
|
| self.settings_window, text="Window Width (px):"
|
| ).pack(pady=5)
|
| self.width_entry = tk.Entry(self.settings_window, width=10)
|
| self.width_entry.pack(pady=5, padx=10, fill=tk.X)
|
| self.width_entry.bind("<FocusOut>", self.validate_window_size)
|
| self.width_entry.bind("<Return>", self.validate_window_size)
|
|
|
| appearance_manager.create_styled_label(
|
| self.settings_window, text="Window Height (px):"
|
| ).pack(pady=5)
|
| self.height_entry = tk.Entry(self.settings_window, width=10)
|
| self.height_entry.pack(pady=5, padx=10, fill=tk.X)
|
| self.height_entry.bind("<FocusOut>", self.validate_window_size)
|
| self.height_entry.bind("<Return>", self.validate_window_size)
|
|
|
|
|
| apply_button = appearance_manager.create_styled_button(
|
| self.settings_window, "Apply", self.apply_settings
|
| )
|
| apply_button.pack(pady=20)
|
|
|
|
|
| self.force_translate_var = tk.BooleanVar()
|
| self.auto_hide_var = tk.BooleanVar()
|
| self.ui_toggle_var = tk.BooleanVar()
|
|
|
|
|
| self.create_toggle_switch(
|
| "Enable 'R-click' to Force Translate", self.force_translate_var
|
| )
|
| self.create_toggle_switch("Enable Auto-hide on Movement", self.auto_hide_var)
|
| self.create_toggle_switch("Enable UI Toggle", self.ui_toggle_var)
|
|
|
|
|
| button_container = tk.Frame(
|
| self.settings_window, bg=appearance_manager.bg_color
|
| )
|
| button_container.pack(pady=10)
|
|
|
|
|
| self.display_button = appearance_manager.create_styled_button(
|
| button_container, "Screen/CPU", self.toggle_advance_ui, hover_bg="#404040"
|
| )
|
| self.display_button.pack(side=tk.LEFT, padx=5)
|
|
|
|
|
| self.model_button = appearance_manager.create_styled_button(
|
| button_container, "Model", self.toggle_model_settings, hover_bg="#404040"
|
| )
|
| self.model_button.pack(side=tk.LEFT, padx=5)
|
|
|
|
|
| self.hotkey_button = appearance_manager.create_styled_button(
|
| button_container, "HotKey", self.toggle_hotkey_ui, hover_bg="#404040"
|
| )
|
| self.hotkey_button.pack(side=tk.LEFT, padx=5)
|
|
|
|
|
| self.shortcut_label = tk.Label(
|
| self.settings_window,
|
| text="Shortcuts:\nALT+H: Toggle UI\nF9: Start/Stop Translation",
|
| bg=appearance_manager.bg_color,
|
| fg=appearance_manager.fg_color,
|
| font=("IBM Plex Sans Thai Medium", 8, "bold"),
|
| justify=tk.LEFT,
|
| )
|
| self.shortcut_label.pack(side=tk.BOTTOM, pady=10)
|
|
|
| self.credit_label = tk.Label(
|
| self.settings_window,
|
| text="Magicite-Babel v5.0 beta, \nDeveloped by iarcanar",
|
| bg=appearance_manager.bg_color,
|
| fg=appearance_manager.fg_color,
|
| font=("IBM Plex Sans Thai Medium", 10, "normal"),
|
| justify=tk.CENTER,
|
| )
|
| self.credit_label.pack(side=tk.BOTTOM, pady=5)
|
|
|
|
|
| close_button = appearance_manager.create_styled_button(
|
| self.settings_window, "X", self.close_settings
|
| )
|
| close_button.place(x=5, y=5, width=20, height=20)
|
|
|
|
|
| self.settings_window.bind("<Button-1>", self.start_move_settings)
|
| self.settings_window.bind("<ButtonRelease-1>", self.stop_move_settings)
|
| self.settings_window.bind("<B1-Motion>", self.do_move_settings)
|
|
|
| def toggle_advance_ui(self):
|
| """Toggle Advanced UI window"""
|
| if (
|
| self.advance_ui is None
|
| or not hasattr(self.advance_ui, "advance_window")
|
| or not self.advance_ui.advance_window.winfo_exists()
|
| ):
|
| self.advance_ui = AdvanceUI(
|
| self.settings_window,
|
| self.settings,
|
| self.apply_settings_callback,
|
| self.ocr_toggle_callback,
|
| )
|
|
|
| if self.advance_ui.advance_window.winfo_viewable():
|
| self.advance_ui.close()
|
| self.display_button.config(text="Screen/CPU")
|
| else:
|
| self.advance_ui.open()
|
| self.display_button.config(text="Close Screen")
|
|
|
| def toggle_model_settings(self):
|
| """Toggle Model Settings window"""
|
| if not hasattr(self, "model_settings"):
|
| from model import ModelSettings
|
|
|
| self.model_settings = ModelSettings(
|
| self.settings_window, self.settings, self.apply_settings_callback
|
| )
|
|
|
| if (
|
| self.model_settings.model_window
|
| and self.model_settings.model_window.winfo_exists()
|
| and self.model_settings.model_window.winfo_viewable()
|
| ):
|
| self.model_settings.close()
|
| self.model_button.config(text="Model")
|
| else:
|
| self.model_settings.open()
|
| self.model_button.config(text="Close Model")
|
|
|
| def toggle_hotkey_ui(self):
|
| if self.hotkey_ui is None:
|
| self.hotkey_ui = HotkeyUI(
|
| self.settings_window, self.settings, self.update_hotkeys_callback
|
| )
|
|
|
| if (
|
| self.hotkey_ui.hotkey_window
|
| and self.hotkey_ui.hotkey_window.winfo_viewable()
|
| ):
|
| self.hotkey_ui.close()
|
| self.hotkey_button.config(text="HotKey")
|
| else:
|
| hotkey_window = self.hotkey_ui.show()
|
| if hotkey_window:
|
| settings_x = self.settings_window.winfo_x()
|
| settings_y = self.settings_window.winfo_y()
|
| settings_height = self.settings_window.winfo_height()
|
|
|
|
|
| hotkey_window.update_idletasks()
|
|
|
| hotkey_x = settings_x - hotkey_window.winfo_width() - 5
|
| hotkey_y = settings_y + settings_height - hotkey_window.winfo_height()
|
|
|
| hotkey_window.geometry(f"+{hotkey_x}+{hotkey_y}")
|
| self.hotkey_button.config(text="Close m.Hotkeys")
|
|
|
| def open_hotkey_ui(self):
|
| if self.hotkey_ui is None:
|
| self.hotkey_ui = HotkeyUI(
|
| self.settings_window, self.settings, self.update_hotkeys_callback
|
| )
|
|
|
| settings_x = self.settings_window.winfo_x()
|
| settings_y = self.settings_window.winfo_y()
|
| settings_height = self.settings_window.winfo_height()
|
|
|
| hotkey_x = settings_x
|
| hotkey_y = settings_y + settings_height + 5
|
|
|
| hotkey_window = self.hotkey_ui.show()
|
| if hotkey_window:
|
| hotkey_window.geometry(f"+{hotkey_x}+{hotkey_y}")
|
|
|
| def create_toggle_switch(self, text, variable):
|
| frame = tk.Frame(self.settings_window, bg=appearance_manager.bg_color)
|
| frame.pack(pady=5, padx=10, fill=tk.X)
|
|
|
| label = tk.Label(
|
| frame,
|
| text=text,
|
| bg=appearance_manager.bg_color,
|
| fg=appearance_manager.fg_color,
|
| )
|
| label.pack(side=tk.LEFT)
|
|
|
| switch = ttk.Checkbutton(frame, style="Switch.TCheckbutton", variable=variable)
|
| switch.pack(side=tk.RIGHT)
|
|
|
| def apply_settings(self, settings_dict=None):
|
| try:
|
| if settings_dict is None:
|
|
|
| settings_dict = {
|
| "transparency": max(
|
| 0.1, min(1.0, float(self.transparency_scale.get()) / 100)
|
| ),
|
| "font_size": int(self.font_size_var.get()),
|
| "font": str(self.font_var.get()),
|
| "font_style": (
|
| "italic" if "Italic" in self.font_var.get() else "roman"
|
| ),
|
| "width": max(300, min(2000, int(self.width_entry.get()))),
|
| "height": max(200, min(1000, int(self.height_entry.get()))),
|
| "enable_force_translate": bool(self.force_translate_var.get()),
|
| "enable_auto_hide": bool(self.auto_hide_var.get()),
|
| "enable_ui_toggle": bool(self.ui_toggle_var.get()),
|
| }
|
|
|
|
|
| for key, value in settings_dict.items():
|
| if key != "font_style":
|
| self.settings.set(key, value)
|
|
|
|
|
| if hasattr(self, "translated_ui") and self.translated_ui:
|
| if "transparency" in settings_dict:
|
| self.translated_ui.update_transparency(
|
| settings_dict["transparency"]
|
| )
|
| if "font_size" in settings_dict:
|
| font_name = settings_dict.get("font", self.settings.get("font"))
|
| font_style = settings_dict.get("font_style", "roman")
|
| self.translated_ui.canvas.itemconfig(
|
| self.translated_ui.text_container,
|
| font=(font_name, settings_dict["font_size"]),
|
| slant=font_style,
|
| )
|
| if "font" in settings_dict:
|
| font_size = self.settings.get("font_size", 24)
|
| font_style = settings_dict.get("font_style", "roman")
|
| self.translated_ui.canvas.itemconfig(
|
| self.translated_ui.text_container,
|
| font=(settings_dict["font"], font_size),
|
| slant=font_style,
|
| )
|
|
|
|
|
| if hasattr(self.translated_ui, "outline_container"):
|
| for outline in self.translated_ui.outline_container:
|
| if "font" in settings_dict or "font_size" in settings_dict:
|
| font_name = settings_dict.get(
|
| "font", self.settings.get("font")
|
| )
|
| font_size = settings_dict.get(
|
| "font_size", self.settings.get("font_size")
|
| )
|
| font_style = settings_dict.get("font_style", "roman")
|
| self.translated_ui.canvas.itemconfig(
|
| outline, font=(font_name, font_size), slant=font_style
|
| )
|
|
|
|
|
| if self.apply_settings_callback:
|
| self.apply_settings_callback(settings_dict)
|
|
|
| return True
|
|
|
| except Exception as e:
|
| error_msg = f"Error applying settings: {e}"
|
| logging.error(error_msg)
|
| messagebox.showerror("Error", error_msg)
|
| return False
|
|
|
| def start_move_settings(self, event):
|
| self.settings_x = event.x
|
| self.settings_y = event.y
|
|
|
| def stop_move_settings(self, event):
|
| self.settings_x = None
|
| self.settings_y = None
|
|
|
| def do_move_settings(self, event):
|
| deltax = event.x - self.settings_x
|
| deltay = event.y - self.settings_y
|
| x = self.settings_window.winfo_x() + deltax
|
| y = self.settings_window.winfo_y() + deltay
|
| self.settings_window.geometry(f"+{x}+{y}")
|
|
|
| if (
|
| self.hotkey_ui
|
| and self.hotkey_ui.hotkey_window
|
| and self.hotkey_ui.hotkey_window.winfo_exists()
|
| ):
|
| hotkey_window = self.hotkey_ui.hotkey_window
|
| hotkey_window.update_idletasks()
|
| settings_height = self.settings_window.winfo_height()
|
| hotkey_x = x - hotkey_window.winfo_width() - 5
|
| hotkey_y = y + settings_height - hotkey_window.winfo_height()
|
| hotkey_window.geometry(f"+{hotkey_x}+{hotkey_y}")
|
|
|
| def open_advance_ui(self):
|
|
|
| if (
|
| self.advance_ui is None
|
| or not hasattr(self.advance_ui, "advance_window")
|
| or not self.advance_ui.advance_window.winfo_exists()
|
| ):
|
| self.advance_ui = AdvanceUI(
|
| self.settings_window, self.settings, self.apply_settings_callback, None
|
| )
|
|
|
|
|
| self.advance_ui.open()
|
|
|
