| import tkinter as tk
|
| from tkinter import ttk, messagebox
|
| import logging
|
| from appearance import appearance_manager
|
| from advance_ui import AdvanceUI
|
| from settings import Settings, is_valid_hotkey
|
|
|
|
|
| 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 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.advance_ui = None
|
| self.hotkey_ui = None
|
| self.create_settings_window()
|
|
|
| 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 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 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 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 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",
|
| "Bai Jamjuree SemiBold",
|
| "PK Nakhon Sawan Regular Demo",
|
| "MaliThin",
|
| "Sarabun",
|
| "Noto Sans Thai Looped",
|
| "IBM Plex Sans Thai Medium",
|
| ]
|
| 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)
|
|
|
| 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)
|
|
|
| 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)
|
|
|
| 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)
|
|
|
| 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 v3.1 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)
|
|
|
| self.advance_button = appearance_manager.create_styled_button(
|
| self.settings_window, "Screen/API", self.open_advance_ui
|
| )
|
| self.advance_button.pack(pady=16)
|
|
|
| self.hotkey_button = appearance_manager.create_styled_button(
|
| self.settings_window, "HotKey", self.toggle_hotkey_ui
|
| )
|
| self.hotkey_button.pack(pady=16)
|
|
|
| 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 apply_settings(self, new_settings=None):
|
| """Apply settings with validation"""
|
| try:
|
|
|
| if new_settings is None:
|
| try:
|
| 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()).strip()
|
| width = max(100, min(2000, int(self.width_entry.get())))
|
| height = max(100, min(1000, int(self.height_entry.get())))
|
|
|
| enable_force = bool(self.force_translate_var.get())
|
| enable_auto_hide = bool(self.auto_hide_var.get())
|
| enable_ui_toggle = bool(self.ui_toggle_var.get())
|
|
|
| settings_dict = {
|
| "transparency": transparency,
|
| "font_size": font_size,
|
| "font": font,
|
| "width": width,
|
| "height": height,
|
| "enable_force_translate": enable_force,
|
| "enable_auto_hide": enable_auto_hide,
|
| "enable_ui_toggle": enable_ui_toggle,
|
| }
|
|
|
| for key, value in settings_dict.items():
|
| self.settings.set(key, value)
|
|
|
| if self.apply_settings_callback:
|
| self.apply_settings_callback(self.settings)
|
| logging.info("Settings applied successfully")
|
|
|
| return True, None
|
|
|
| except ValueError as e:
|
| raise ValueError(f"Invalid input value: {str(e)}")
|
|
|
|
|
| else:
|
| logging.info("Applying advanced settings")
|
| if not isinstance(new_settings, dict):
|
| raise ValueError("New settings must be a dictionary")
|
|
|
| old_model = self.settings.get("api_parameters", {}).get("model", "")
|
| new_model = new_settings.get("api_parameters", {}).get("model", "")
|
|
|
| if self.apply_settings_callback:
|
| self.apply_settings_callback(new_settings)
|
|
|
|
|
| if old_model != new_model:
|
| print(f"\n=== API Model Changed ===")
|
| print(f"Previous model: {old_model}")
|
| print(f"New model: {new_model}")
|
| print(f"Parameters: {self.settings.get_api_parameters()}")
|
| print("=====================\n")
|
| logging.info(f"API model changed from {old_model} to {new_model}")
|
|
|
| return True, None
|
|
|
| except Exception as e:
|
| error_msg = f"Error applying settings: {str(e)}"
|
| logging.error(error_msg)
|
| return False, error_msg
|
|
|
| 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()
|
|
|
| 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):
|
| if hasattr(self, "settings_x") and hasattr(self, "settings_y"):
|
| 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}")
|
|
|
