Upload 23 files

## API Key Configuration

1. Rename file `open for edit api key.env` to `.env`
2. Edit `.env` file and paste your API key:
```env
ANTHROPIC_API_KEY='your_claude_api_key'
OPENAI_API_KEY='your_openai_api_key'

MBB.py

@@ -0,0 +1,1876 @@
+import sys
+import os
+import tkinter as tk
+from tkinter import ttk, messagebox
+from PIL import ImageGrab, ImageEnhance, Image, ImageTk
+import easyocr
+import time
+import threading
+import difflib
+import logging
+import numpy as np
+import cv2
+from text_corrector import TextCorrector
+import translated_ui
+from text_corrector import DialogueType
+from control_ui import Control_UI
+from translator import Translator
+from translator_claude import TranslatorClaude
+from settings import Settings, SettingsUI
+from advance_ui import AdvanceUI
+from mini_ui import MiniUI
+from loggings import LoggingManager
+from translator_factory import TranslatorFactory
+import keyboard
+import re
+from appearance import appearance_manager
+import importlib.util
+import warnings
+from translated_logs import Translated_Logs
+
+warnings.filterwarnings("ignore", category=UserWarning)
+
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
+
+# Add the directory containing npc_manager.py to the Python path
+current_dir = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(current_dir)
+
+print(f"Current directory: {current_dir}")
+print(f"Python path: {sys.path}")
+
+# Attempt to import create_npc_manager
+npc_manager_path = os.path.join(current_dir, "npc_manager.py")
+print(f"NPC Manager file exists: {os.path.exists(npc_manager_path)}")
+
+print("Attempting to import create_npc_manager using importlib")
+try:
+    spec = importlib.util.spec_from_file_location("npc_manager", npc_manager_path)
+    npc_manager_module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(npc_manager_module)
+    create_npc_manager = getattr(npc_manager_module, "create_npc_manager", None)
+    print(f"create_npc_manager imported using importlib: {create_npc_manager}")
+except Exception as e:
+    print(f"Error importing create_npc_manager using importlib: {e}")
+    create_npc_manager = None
+
+
+class MagicBabelApp:
+    def __init__(self, root):
+        # 1. การตั้งค่าพื้นฐานของ root window
+        self.root = root
+        self.root.withdraw()  # ซ่อน main window ก่อน
+        self.root.attributes("-topmost", True)  # ตั้งค่าเริ่มต้นเป็น True
+        self.translation_event = threading.Event()
+        self.ocr_cache = {}
+        self.ocr_speed = "normal"
+        self.cache_timeout = 1.0  # 1 วินาที
+
+        # 2. สร้างและแสดง splash screen
+        def show_splash():
+            splash = tk.Toplevel(root)
+            splash.overrideredirect(True)
+            splash.attributes("-topmost", True)
+
+            try:
+                # โหลดและเตรียมภาพ แบบรองรับความโปร่งใส
+                image = Image.open("MBBvisual.png")
+                image = image.convert("RGBA")
+
+                # กำหนดขนาดที่ต้องการ
+                SPLASH_WIDTH = 1280
+                SPLASH_HEIGHT = 720
+
+                # คำนวณอัตราส่วนการย่อขยายเพื่อรักษาสัดส่วนภาพ
+                original_ratio = image.width / image.height
+                new_ratio = SPLASH_WIDTH / SPLASH_HEIGHT
+
+                if new_ratio > original_ratio:
+                    new_width = int(SPLASH_HEIGHT * original_ratio)
+                    new_height = SPLASH_HEIGHT
+                else:
+                    new_width = SPLASH_WIDTH
+                    new_height = int(SPLASH_WIDTH / original_ratio)
+
+                image = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+                photo = ImageTk.PhotoImage(image)
+
+                # จัดตำแหน่งกลางจอ
+                screen_width = splash.winfo_screenwidth()
+                screen_height = splash.winfo_screenheight()
+                x = (screen_width - new_width) // 2
+                y = (screen_height - new_height) // 2
+
+                splash.geometry(f"{new_width}x{new_height}+{x}+{y}")
+                splash.attributes("-transparentcolor", "black")
+                splash.configure(bg="black")
+
+                logo = tk.Label(splash, image=photo, bg="black", bd=0)
+                logo.photo = photo  # เก็บ reference ป้องกัน garbage collection
+                logo.pack(fill="both", expand=True)
+
+                # เพิ่ม fade in effect
+                for i in range(0, 20):
+                    alpha = i / 20.0
+                    splash.attributes("-alpha", alpha)
+                    splash.update()
+                    time.sleep(0.02)
+
+                return splash, photo
+
+            except Exception as e:
+                print(f"Error loading splash screen: {e}")
+                if splash.winfo_exists():
+                    splash.destroy()
+                return None, None
+
+        # 3. แสดง splash screen
+        self.splash, self.splash_photo = show_splash()
+
+        # 4. เริ่มต้นค่าต่างๆ
+        self.root.title("MagicBabel for FFXIV")
+        self.root.geometry("300x320")
+        self.root.overrideredirect(True)
+
+        # 5. Initialize core components
+        self.settings = Settings()
+        self.logging_manager = LoggingManager(self.settings)
+        self.custom_font = appearance_manager.apply_style(self.root)
+        self.logging_manager.log_startup_info()
+        self.text_corrector = TextCorrector()
+
+        # 6. Initialize variables & UI
+        self.hotkeys = {}
+        self.init_variables()
+        self.load_shortcuts()
+        self.load_icons()
+
+        # 7. Initialize window positions
+        self.last_main_ui_pos = None
+        self.last_mini_ui_pos = None
+        self.last_translated_ui_pos = None
+
+        # 8. Create UI components
+        self.mini_ui = MiniUI(self.root, self.show_main_ui_from_mini)
+        self.mini_ui.set_toggle_translation_callback(self.toggle_translation)
+        self.blink_interval = 500
+        self.mini_ui.blink_interval = self.blink_interval
+
+        self.create_main_ui()
+        self.create_translated_ui()
+        self.create_translated_logs()
+        self.create_settings_ui()
+
+        # 9. อัพเดทไฮไลท์ปุ่มตามพื้นที่เริ่มต้น
+        initial_area = self.settings.get("current_area", "A+B")  # เปลี่ยนค่าเริ่มต้นเป็น A+B
+        self.current_area = initial_area  # เพิ่มบรรทัดนี้
+        self.update_area_button_highlights(initial_area)
+
+        # 10. Initialize translation system
+        self.init_ocr_and_translation()
+        self.bind_events()
+        self.apply_saved_settings()
+
+        # 11. Initialize NPC manager
+        self.npc_manager = None
+
+        # 12. รอ 3 วินาทีแล้วปิด splash และแสดง main window
+        def finish_startup():
+            time.sleep(3)
+
+            if hasattr(self, "splash") and self.splash and self.splash.winfo_exists():
+                try:
+                    # Fade out animation
+                    for i in range(10, -1, -1):
+                        alpha = i / 10
+                        self.splash.attributes("-alpha", alpha)
+                        self.splash.update()
+                        time.sleep(0.05)
+                    self.splash.destroy()
+                except Exception:
+                    pass
+
+            self.root.deiconify()
+            self.logging_manager.log_info("MagicBabel application started and ready")
+
+        threading.Thread(target=finish_startup, daemon=True).start()
+
+    def init_mini_ui(self):
+        self.mini_ui = MiniUI(self.root, self.show_main_ui_from_mini)
+        self.mini_ui.set_toggle_translation_callback(self.toggle_translation)
+        self.mini_ui.blink_interval = self.blink_interval
+
+    def create_translated_logs(self):
+        try:
+            logging.info("Creating translated logs window...")
+
+            # สร้าง window
+            self.translated_logs_window = tk.Toplevel(self.root)
+
+            # สร้างและเก็บ instance
+            self.translated_logs_instance = Translated_Logs(
+                self.translated_logs_window, self.settings
+            )
+
+            # ไม่ต้อง withdraw() ที่นี่ เพราะ Translated_Logs จะเริ่มในสถานะซ่อนเองแล้ว
+            self.logging_manager.log_info("Translated logs created successfully")
+
+        except Exception as e:
+            self.logging_manager.log_error(f"Error creating translated logs: {e}")
+            logging.exception("Detailed error in create_translated_logs:")
+
+    def load_shortcuts(self):
+        self.toggle_ui_shortcut = self.settings.get_shortcut("toggle_ui", "alt+h")
+        self.start_stop_shortcut = self.settings.get_shortcut(
+            "start_stop_translate", "f9"
+        )
+
+    def handle_error(self, error_message):
+        self.logging_manager.log_error(f"Error: {error_message}")
+
+    def load_icons(self):
+        self.blink_icon = ImageTk.PhotoImage(
+            Image.open("red_icon.png").resize((20, 20))
+        )
+        self.black_icon = ImageTk.PhotoImage(
+            Image.open("black_icon.png").resize((20, 20))
+        )
+        self.pin_icon = ImageTk.PhotoImage(Image.open("pin.png").resize((20, 20)))
+        self.unpin_icon = ImageTk.PhotoImage(Image.open("unpin.png").resize((20, 20)))
+
+    def create_main_ui(self):
+        # ปรับขนาดหน้าต่างหลักให้สูงขึ้น
+        self.root.geometry("300x400")  # ���พิ่มความสูงให้มากขึ้นเพื่อรองรับทุกส่วน
+
+        self.main_frame = tk.Frame(self.root, bg=appearance_manager.bg_color)
+        self.main_frame.pack(expand=True, fill=tk.BOTH)
+
+        self.topmost_button = tk.Button(
+            self.main_frame,
+            image=self.pin_icon,
+            command=self.toggle_topmost,
+            bg=appearance_manager.bg_color,
+            bd=0,
+        )
+        self.topmost_button.place(x=10, y=10)
+
+        # ทุกปุ่ม hover แล้วจะเปลี่ยนเป็นสีแดง
+        self.select_area_button = appearance_manager.create_styled_button(
+            self.main_frame, "Select Area-A", self.start_selection_a, hover_bg="blue"
+        )
+        self.select_area_button.pack(pady=10, expand=True)
+
+        self.select_area_frame = tk.Frame(
+            self.main_frame, bg=appearance_manager.bg_color
+        )
+        self.select_area_frame.pack(pady=5, expand=True)
+
+        self.select_area_b_button = appearance_manager.create_styled_button(
+            self.select_area_frame, "Select-B", self.start_selection_b, hover_bg="blue"
+        )
+        self.select_area_b_button.pack(side=tk.LEFT, padx=5, expand=True)
+
+        self.select_area_c_button = appearance_manager.create_styled_button(
+            self.select_area_frame, "Select-C", self.start_selection_c, hover_bg="blue"
+        )
+        self.select_area_c_button.pack(side=tk.LEFT, padx=5, expand=True)
+
+        self.show_area_button = appearance_manager.create_styled_button(
+            self.main_frame, "Show Area", self.toggle_show_area, hover_bg="pink"
+        )
+        self.show_area_button.pack(pady=10, expand=True)
+
+        self.start_stop_button = appearance_manager.create_styled_button(
+            self.main_frame,
+            "Start Translation",
+            self.toggle_translation,
+            hover_bg="red",
+        )
+        self.start_stop_button.pack(pady=10, expand=True)
+
+        self.blink_label = tk.Label(
+            self.main_frame, image=self.black_icon, bg=appearance_manager.bg_color
+        )
+        self.blink_label.pack(side=tk.RIGHT, padx=(0, 10))
+        self.blink_label.place(relx=0.95, rely=0.5, anchor="center")
+
+        self.settings_button = appearance_manager.create_styled_button(
+            self.main_frame, "Settings", self.toggle_settings, hover_bg="black"
+        )
+        self.settings_button.pack(pady=10, expand=True)
+
+        self.npc_manager_button = appearance_manager.create_styled_button(
+            self.main_frame, "NPC Manager", self.toggle_npc_manager, hover_bg="purple"
+        )
+        self.npc_manager_button.pack(pady=10, expand=True)
+
+        # เพิ่มปุ่มปิดโปรแกรม
+        self.exit_button = appearance_manager.create_styled_button(
+            self.root, "X", self.exit_program, hover_bg="grey"
+        )
+        self.exit_button.place(x=270, y=10, width=20, height=20)
+
+        # สร้าง Bottom Container Frame
+        bottom_container = tk.Frame(self.root, bg="#1a1a1a")
+        bottom_container.pack(side=tk.BOTTOM, fill=tk.X)
+
+        # สร้าง Frame สำหรับปุ่มควบคุม
+        button_frame = tk.Frame(bottom_container, bg="#1a1a1a", height=40)
+        button_frame.pack(fill=tk.X)
+        button_frame.pack_propagate(False)
+
+        # สร้าง Frame ย่อยสำหรับปุ่มทั้งหมด
+        buttons_container = tk.Frame(button_frame, bg="#1a1a1a")
+        buttons_container.pack(expand=True, pady=5)
+
+        # สร้าง info label สำหรับแสดงข้อมูล Model และ Screen Size
+        self.info_label = tk.Label(
+            bottom_container,
+            text=self.get_current_settings_info(),
+            bg="#1a1a1a",
+            fg="white",
+            font=("Consolas", 8),  # คงขนาด font เท่าเดิม
+            justify=tk.LEFT,  # ชิดซ้าย
+            height=2,  # กำหนดความสูงให้พอดี 2 บรรทัด
+        )
+        self.info_label.pack(pady=(0, 5))
+
+        # กำหนดสไตล์ปุ่มให้เหมาะสม
+        button_style = {
+            "font": ("Nasalization Rg", 10),  # เปลี่ยนเป็นฟอนต์เดียวกับ UI หลัก
+            "bg": appearance_manager.bg_color,
+            "fg": "white",
+            "bd": 0,
+            "padx": 5,  # ลด padding
+            "pady": 2,
+            "cursor": "hand2",
+            "width": 6,  # กำหนดความกว้างให้เท่ากันทุกปุ่ม
+        }
+
+        # สร้างและจัดวางปุ่ม
+        self.tui_button = tk.Button(
+            buttons_container,
+            text="TUI",
+            command=self.toggle_translated_ui,
+            **button_style,
+        )
+        self.tui_button.pack(side=tk.LEFT, padx=2)
+
+        self.log_button = tk.Button(
+            buttons_container,
+            text="LOG",
+            command=self.toggle_translated_logs,
+            **button_style,
+        )
+        self.log_button.pack(side=tk.LEFT, padx=2)
+
+        self.mini_button = tk.Button(
+            buttons_container, text="MINI", command=self.toggle_mini_ui, **button_style
+        )
+        self.mini_button.pack(side=tk.LEFT, padx=2)
+
+        self.con_button = tk.Button(
+            buttons_container, text="CON", command=self.toggle_control, **button_style
+        )
+        self.con_button.pack(side=tk.LEFT, padx=2)
+
+        # เพิ่ม Event Binding สำหรับ hover effect ให้ทุกปุ่ม
+        for button in [
+            self.tui_button,
+            self.log_button,
+            self.mini_button,
+            self.con_button,
+        ]:
+            button.bind(
+                "<Enter>",
+                lambda e, b=button: b.config(
+                    bg=(
+                        "#666666"
+                        if b.cget("bg") == appearance_manager.bg_color
+                        else "#595959"
+                    )
+                ),
+            )
+            button.bind(
+                "<Leave>",
+                lambda e, b=button: b.config(
+                    bg=(
+                        appearance_manager.bg_color
+                        if b.cget("bg") == "#666666"
+                        else "#404040"
+                    )
+                ),
+            )
+
+    def update_area_button_highlights(self, areas):
+        """อัพเดทสีปุ่มตามพื้นที่ที่กำลังทำงาน"""
+        # Reset all buttons
+        button_map = {
+            "A": self.select_area_button,
+            "B": self.select_area_b_button,
+            "C": self.select_area_c_button,
+        }
+
+        # Reset all buttons first
+        for button in button_map.values():
+            button.configure(fg="white", bg=appearance_manager.bg_color)
+
+        # Convert areas to list if it's a string
+        active_areas = areas.split("+") if isinstance(areas, str) else areas
+
+        # Highlight active buttons
+        for area in active_areas:
+            if area in button_map:
+                button_map[area].configure(fg="#00FFFF", bg="#404040")
+
+    def setup_button_events(self):
+        """Setup hover effects for UI control buttons"""
+        for button in [self.tui_button, self.log_button]:
+            button.bind(
+                "<Enter>",
+                lambda e, b=button: b.config(
+                    bg=(
+                        "#666666"
+                        if b.cget("bg") == appearance_manager.bg_color
+                        else "#595959"
+                    )
+                ),
+            )
+            button.bind(
+                "<Leave>",
+                lambda e, b=button: b.config(
+                    bg=(
+                        appearance_manager.bg_color
+                        if b.cget("bg") == "#666666"
+                        else "#404040"
+                    )
+                ),
+            )
+
+    def toggle_translated_ui(self):
+        """Toggle Translated UI visibility without affecting translation state"""
+        if self.translated_ui_window.winfo_exists():
+            if self.translated_ui_window.state() == "withdrawn":
+                self.translated_ui_window.deiconify()
+                self.translated_ui_window.lift()
+                self.tui_button.config(bg="#404040")  # สีเข้มเมื่อแสดง
+            else:
+                self.translated_ui_window.withdraw()
+                self.tui_button.config(bg=appearance_manager.bg_color)  # สีปกติเมื่อซ่อน
+
+    def toggle_translated_logs(self):
+        """Toggle Translated Logs visibility independently"""
+        logging.info("Attempting to toggle translated logs")
+
+        if not hasattr(self, "translated_logs_instance"):
+            logging.error("translated_logs_instance not found")
+            return
+
+        if self.translated_logs_window.winfo_exists():
+            if self.translated_logs_window.state() == "withdrawn":
+                self.translated_logs_window.deiconify()
+                self.translated_logs_window.lift()
+                self.translated_logs_instance.is_visible = True
+                self.log_button.config(bg="#404040")  # สีเข้มเมื่อแสดง
+            else:
+                self.translated_logs_window.withdraw()
+                self.translated_logs_instance.is_visible = False
+                self.log_button.config(bg=appearance_manager.bg_color)  # สีปกติเมื่อซ่อน
+
+    def toggle_control(self):
+        """Toggle the control UI window"""
+        if hasattr(self, "control_ui") and self.control_ui.root.winfo_exists():
+            if self.control_ui.root.state() == "withdrawn":
+                # ซิงค์สถานะก่อนแสดง
+                areas = self.current_area.split("+")
+                for area in ["A", "B", "C"]:
+                    self.control_ui.area_states[area] = area in areas
+                self.control_ui.show_window()
+                self.con_button.config(bg="#404040")
+            else:
+                self.control_ui.close_window()
+                self.con_button.config(bg=appearance_manager.bg_color)
+        else:
+            control_root = tk.Toplevel(self.root)
+            self.control_ui = Control_UI(
+                control_root, self.force_translate, self.switch_area, self.settings
+            )
+            # ซิงค์สถานะเริ่มต้น
+            areas = self.current_area.split("+")
+            for area in ["A", "B", "C"]:
+                self.control_ui.area_states[area] = area in areas
+
+            # เพิ่ม callback สำหรับปรับความเร็ว OCR
+            self.control_ui.speed_callback = self.set_ocr_speed
+            self.con_button.config(bg="#404040")
+
+    def set_ocr_speed(self, speed_mode):
+        """
+        ตั้งค่าความเร็วในการ OCR
+        Args:
+            speed_mode: 'normal' หรือ 'high'
+        """
+        self.ocr_speed = speed_mode
+        self.cache_timeout = 0.5 if speed_mode == "high" else 1.0
+        self.logging_manager.log_info(f"OCR speed set to: {speed_mode}")
+
+        # อัพเดท settings
+        self.settings.set("ocr_speed", speed_mode)
+        self.settings.save_settings()
+
+    def add_message(self, text):
+        if hasattr(self, "translated_logs_instance"):
+            self.translated_logs_instance.add_message(text)
+
+    def get_current_settings_info(self):
+        """รับข้อมูล Model และ Screen Size ปัจจุบัน"""
+        model = self.settings.get_displayed_model()  # ใช้ displayed_model แทน model ID
+        screen_size = self.settings.get("screen_size", "2560x1440")
+        return f"MODEL : {model}\nSCREEN : {screen_size}"
+
+    def toggle_topmost(self):
+        current_state = self.root.attributes("-topmost")
+        self.root.attributes("-topmost", not current_state)
+        self.topmost_button.config(
+            image=self.unpin_icon if current_state else self.pin_icon
+        )
+
+    def toggle_npc_manager(self):
+        if create_npc_manager is None:
+            messagebox.showwarning("Warning", "NPC Manager is not available.")
+            return
+
+        try:
+            # กรณีที่ยังไม่มี instance
+            if self.npc_manager is None:
+                self.npc_manager = create_npc_manager(self.root, self.reload_npc_data)
+                self.npc_manager.show_window()
+                self.update_button_highlight(self.npc_manager_button, True)
+                return
+
+            # กรณีที่ window ถูกทำลายหรือไม่มีอยู่
+            if (
+                not hasattr(self.npc_manager, "window")
+                or not self.npc_manager.window.winfo_exists()
+            ):
+                self.npc_manager = create_npc_manager(self.root, self.reload_npc_data)
+                self.npc_manager.show_window()
+                self.update_button_highlight(self.npc_manager_button, True)
+                return
+
+            # กรณีที่ window มีอยู่แล้ว
+            is_visible = (
+                self.npc_manager.window.state() != "withdrawn"
+                and self.npc_manager.window.winfo_viewable()
+            )
+
+            if is_visible:
+                self.npc_manager.window.withdraw()
+                self.update_button_highlight(self.npc_manager_button, False)
+                if hasattr(self.npc_manager, "search_var"):
+                    self.npc_manager.search_var.set("")
+            else:
+                self.npc_manager.show_window()
+                self.update_button_highlight(self.npc_manager_button, True)
+
+        except Exception as e:
+            error_msg = f"Failed to toggle NPC Manager: {str(e)}"
+            self.logging_manager.log_error(error_msg)
+            messagebox.showerror("Error", error_msg)
+            self.npc_manager = None
+
+    def reload_npc_data(self):
+        """Reload NPC data and update related components"""
+        print("Reloading NPC data...")
+        if hasattr(self, "translator") and self.translator:
+            self.translator.reload_data()
+        if hasattr(self, "text_corrector") and self.text_corrector:
+            self.text_corrector.reload_data()
+        if hasattr(self, "translated_ui"):
+            character_names = self.text_corrector.names
+            self.translated_ui.update_character_names(character_names)
+        print("NPC data reload completed")
+
+    def show_main_ui_from_mini(self):
+        self.save_ui_positions()
+        self.mini_ui.mini_ui.withdraw()
+        self.root.deiconify()
+        self.root.attributes("-topmost", True)
+        self.root.lift()
+        if self.last_main_ui_pos:
+            self.root.geometry(self.last_main_ui_pos)
+
+    def create_translated_ui(self):
+        self.translated_ui_window = tk.Toplevel(self.root)
+
+        # ตรวจสอบและส่ง character_names จาก text_corrector
+        character_names = set()
+        if hasattr(self, "text_corrector") and hasattr(self.text_corrector, "names"):
+            character_names = self.text_corrector.names
+
+        self.translated_ui = translated_ui.Translated_UI(
+            self.translated_ui_window,
+            self.toggle_translation,
+            self.stop_translation,
+            self.force_translate,
+            self.toggle_main_ui,
+            self.toggle_ui,
+            self.settings,
+            self.switch_area,
+            self.logging_manager,
+            character_names=character_names,
+            main_app=self,  # ส่ง main application reference
+        )
+
+        # จัดตำแหน่งหน้าต่าง
+        window_width = self.settings.get("width", 960)
+        window_height = self.settings.get("height", 240)
+        screen_width = self.root.winfo_screenwidth()
+        screen_height = self.root.winfo_screenheight()
+
+        x = (screen_width - window_width) // 2
+        y = (screen_height - window_height) // 2
+
+        self.translated_ui_window.geometry(f"+{x}+{y}")
+        self.translated_ui_window.withdraw()
+
+    def create_settings_ui(self):
+        self.settings_ui = SettingsUI(
+            self.root, self.settings, self.apply_settings, self.update_hotkeys
+        )
+        self.settings_ui.set_ocr_toggle_callback(self.ocr_toggle_callback)
+        self.settings_ui.close_settings()
+
+    def init_ocr_and_translation(self):
+        """Initialize OCR และ translator"""
+        try:
+            # ส่วน OCR initialization ยังคงเหมือนเดิม
+            translate_area = self.settings.get_translate_area("A")
+            self.start_x = translate_area["start_x"]
+            self.start_y = translate_area["start_y"]
+            self.end_x = translate_area["end_x"]
+            self.end_y = translate_area["end_y"]
+
+            use_gpu = self.settings.get("use_gpu_for_ocr", False)
+            self.reader = easyocr.Reader(["en", "ko"], gpu=use_gpu)
+            logging.info(f"Initialized OCR with languages: English, Korean")
+            self.logging_manager.log_info(f"Initialized OCR with GPU: {use_gpu}")
+
+            self.text_corrector = TextCorrector()
+
+            # สร้าง translator ใหม่โดยใช้ Factory
+            self.translator = TranslatorFactory.create_translator(self.settings)
+
+            # Log current parameters
+            params = self.translator.get_current_parameters()
+            self.logging_manager.log_info(f"\nCurrent translator parameters:")
+            self.logging_manager.log_info(f"Model: {params.get('model')}")
+            self.logging_manager.log_info(f"Parameters: {params}\n")
+
+        except Exception as e:
+            self.logging_manager.log_error(f"Failed to initialize translator: {e}")
+            messagebox.showerror("Translator Error", str(e))
+            self.translator = None
+
+    def get_cached_ocr_result(self, area, image_hash):
+        """ดึงผลลัพธ์ OCR จาก cache"""
+        if area in self.ocr_cache:
+            cached_time, cached_hash, result = self.ocr_cache[area]
+            if (
+                time.time() - cached_time < self.cache_timeout
+                and cached_hash == image_hash
+            ):
+                return result
+        return None
+
+    def cache_ocr_result(self, area, image_hash, result):
+        """เก็บผลลัพธ์ OCR ลง cache"""
+        self.ocr_cache[area] = (time.time(), image_hash, result)
+
+    def toggle_ocr_gpu(self):
+        current_use_gpu = self.settings.get("use_gpu_for_ocr", False)
+        new_use_gpu = not current_use_gpu
+        self.settings.set_gpu_for_ocr(new_use_gpu)
+        use_gpu = self.settings.get("use_gpu_for_ocr")
+        self.reader = easyocr.Reader(["en"], gpu=use_gpu)
+        self.logging_manager.log_info(f"Switched OCR to {'GPU' if use_gpu else 'CPU'}")
+
+    def ocr_toggle_callback(self):
+        self.reinitialize_ocr()
+
+    def init_variables(self):
+        self.is_translating = False
+        self.is_resizing = False
+        self.translation_thread = None
+        self.last_text = ""
+        self.last_translation = ""
+        self.last_translation_time = 0
+        self.last_force_time = 0
+        self.force_next_translation = False
+        self.blinking = False
+        self.mini_ui_blinking = False
+        self.main_window_pos = None
+        self.translated_window_pos = None
+        self.mini_ui_pos = None
+        self.settings_window_pos = None
+        self.show_area_window = None
+        self.is_area_shown = False
+        self.x = None
+        self.y = None
+        self.current_area = "A"  # ค่าเริ่มต้น
+
+    def bind_events(self):
+        self.root.bind("<Button-1>", self.start_move)
+        self.root.bind("<ButtonRelease-1>", self.stop_move)
+        self.root.bind("<B1-Motion>", self.do_move)
+
+        toggle_ui_shortcut = self.settings.get_shortcut("toggle_ui", "alt+h")
+        start_stop_shortcut = self.settings.get_shortcut("start_stop_translate", "f9")
+
+        if self.settings.get("enable_ui_toggle"):
+            if "toggle_ui" in self.hotkeys:
+                keyboard.remove_hotkey(self.hotkeys["toggle_ui"])
+            self.hotkeys["toggle_ui"] = keyboard.add_hotkey(
+                toggle_ui_shortcut, self.toggle_ui
+            )
+
+        if "start_stop_translate" in self.hotkeys:
+            keyboard.remove_hotkey(self.hotkeys["start_stop_translate"])
+        self.hotkeys["start_stop_translate"] = keyboard.add_hotkey(
+            start_stop_shortcut, self.toggle_translation
+        )
+
+        if self.settings.get("enable_auto_hide"):
+            for key in ["w", "a", "s", "d"]:
+                if key in self.hotkeys:
+                    keyboard.remove_hotkey(self.hotkeys[key])
+                self.hotkeys[key] = keyboard.add_hotkey(
+                    key, self.hide_and_stop_translation
+                )
+
+        self.logging_manager.log_info(
+            f"Hotkeys bound: Toggle UI: {toggle_ui_shortcut}, Start/Stop Translate: {start_stop_shortcut}"
+        )
+
+    def update_hotkeys(self):
+        self.load_shortcuts()
+        self.remove_all_hotkeys()
+        self.bind_events()
+        self.logging_manager.log_info(
+            f"Hotkeys updated: Toggle UI: {self.toggle_ui_shortcut}, Start/Stop Translate: {self.start_stop_shortcut}"
+        )
+
+    def apply_saved_settings(self):
+        self.translated_ui.update_transparency(self.settings.get("transparency"))
+        self.translated_ui.adjust_font_size(self.settings.get("font_size"))
+        self.translated_ui.update_font(self.settings.get("font"))
+        self.translated_ui_window.geometry(
+            f"{self.settings.get('width')}x{self.settings.get('height')}"
+        )
+
+        self.remove_all_hotkeys()
+        self.bind_events()
+
+    def remove_all_hotkeys(self):
+        for key in list(self.hotkeys.keys()):
+            try:
+                keyboard.remove_hotkey(self.hotkeys[key])
+                del self.hotkeys[key]
+            except Exception:
+                pass
+        self.hotkeys.clear()
+
+    def toggle_settings(self):
+        if self.settings_ui.settings_visible:
+            self.settings_ui.close_settings()
+            self.settings_button.config(text="Settings")
+            self.update_button_highlight(self.settings_button, False)
+        else:
+            self.settings_ui.open_settings(
+                self.root.winfo_x(), self.root.winfo_y(), self.root.winfo_width()
+            )
+            self.settings_button.config(text="Close Settings")
+            self.update_button_highlight(self.settings_button, True)
+
+    def apply_settings(self, settings_dict):
+        """Apply settings and update UI components"""
+        try:
+            # อัพเดท translated UI ถ้ามีการเปลี่ยนแปลงที่เกี่ยวข้อง
+            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:
+                    self.translated_ui.adjust_font_size(settings_dict["font_size"])
+                if "font" in settings_dict:
+                    self.translated_ui.update_font(settings_dict["font"])
+
+                # อัพเดทขนาดหน้าต่าง
+                if "width" in settings_dict and "height" in settings_dict:
+                    width = settings_dict["width"]
+                    height = settings_dict["height"]
+                    self.translated_ui.root.geometry(f"{width}x{height}")
+
+                    # Force update UI
+                    self.translated_ui.force_check_overflow()
+                    self.translated_ui.root.update_idletasks()
+
+            # อัพเดทค่า flags
+            if "enable_force_translate" in settings_dict:
+                self.enable_force_translate = settings_dict["enable_force_translate"]
+            if "enable_auto_hide" in settings_dict:
+                self.enable_auto_hide = settings_dict["enable_auto_hide"]
+            if "enable_ui_toggle" in settings_dict:
+                self.enable_ui_toggle = settings_dict["enable_ui_toggle"]
+
+            # อัพเดท info label ถ้ามี
+            if hasattr(self, "info_label"):
+                self.info_label.config(text=self.get_current_settings_info())
+
+            logging.info("Settings applied successfully")
+            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 reinitialize_ocr(self):
+        use_gpu = self.settings.get("use_gpu_for_ocr", False)
+        self.reader = easyocr.Reader(["en"], gpu=use_gpu)
+        self.logging_manager.log_info(
+            f"OCR reinitialized with [{'GPU' if use_gpu else 'CPU'}]"
+        )
+
+    def update_api_settings(self):
+        """อัพเดท API settings แบบใหม่"""
+        try:
+            api_params = self.settings.get_api_parameters()
+            if not api_params:
+                raise ValueError("No API parameters found")
+
+            if self.translator:
+                # แยกการอัพเดทตามประเภท translator
+                is_claude = api_params.get("model") == "claude-3-5-haiku-20241022"
+
+                if is_claude != isinstance(self.translator, TranslatorClaude):
+                    # สร้าง translator ใหม่ถ้าประเภทไม่ตรงกัน
+                    self.init_ocr_and_translation()
+                else:
+                    # อัพเดทพารามิเตอร์
+                    if is_claude:
+                        self.translator.update_parameters(
+                            model=api_params["model"],
+                            max_tokens=api_params["max_tokens"],
+                            temperature=api_params["temperature"],
+                        )
+                    else:
+                        self.translator.update_parameters(
+                            model=api_params["model"],
+                            max_tokens=api_params["max_tokens"],
+                            temperature=api_params["temperature"],
+                            top_p=api_params.get("top_p", 0.9),
+                        )
+
+            self.logging_manager.log_info(f"API settings updated: {api_params}")
+
+        except Exception as e:
+            self.logging_manager.log_error(f"Error updating API settings: {e}")
+            raise
+
+    def toggle_show_area(self):
+        if self.is_area_shown:
+            self.hide_show_area()
+            self.update_button_highlight(self.show_area_button, False)
+        else:
+            self.show_area()
+            self.update_button_highlight(self.show_area_button, True)
+
+    def show_area(self):
+        """แสดงพื้นที่ที่เลือกทั้งหมดบนหน้าจอ"""
+        if not hasattr(self, "settings"):
+            logging.error("Settings not initialized")
+            return
+
+        try:
+            # ลบหน้าต่างเก่า
+            if hasattr(self, "show_area_windows"):
+                for window in self.show_area_windows.values():
+                    if window and window.winfo_exists():
+                        window.destroy()
+
+            self.show_area_windows = {}
+            active_areas = (
+                self.current_area.split("+")
+                if isinstance(self.current_area, str)
+                else [self.current_area]
+            )
+
+            for area in active_areas:
+                translate_area = self.settings.get_translate_area(area)
+                if not translate_area:
+                    continue
+
+                window = tk.Toplevel(self.root)
+                window.overrideredirect(True)
+                window.attributes("-alpha", 0.4)
+                window.attributes("-topmost", True)
+
+                # คำนวณตำแหน่งและขนาด
+                scale_x, scale_y = self.get_screen_scale()
+                x = int(translate_area["start_x"] * scale_x)
+                y = int(translate_area["start_y"] * scale_y)
+                width = int(
+                    (translate_area["end_x"] - translate_area["start_x"]) * scale_x
+                )
+                height = int(
+                    (translate_area["end_y"] - translate_area["start_y"]) * scale_y
+                )
+
+                window.geometry(f"{width}x{height}+{x}+{y}")
+                canvas = tk.Canvas(window, bg="red", highlightthickness=0)
+                canvas.pack(fill=tk.BOTH, expand=True)
+                window.lift()
+                self.show_area_windows[area] = window
+
+            self.show_area_button.config(text="HIDE AREA")
+            self.is_area_shown = True
+
+        except Exception as e:
+            logging.error(f"Error showing areas: {str(e)}")
+            messagebox.showerror(
+                "Error", "Failed to show selected areas. Check logs for details."
+            )
+            self.is_area_shown = False
+
+    def sync_initial_areas(self):
+        """Sync initial area states between MBB and Control UI"""
+        try:
+            # โหลดค่าจาก settings หรือใช้ค่าเริ่มต้น
+            self.current_area = self.settings.get("current_area", "A+B")
+
+            # อัพเดทสถานะใน Control UI ถ้ามีการสร้างแล้ว
+            if hasattr(self, "control_ui") and self.control_ui:
+                areas = self.current_area.split("+")
+                for area in ["A", "B", "C"]:
+                    self.control_ui.area_states[area] = area in areas
+                self.control_ui.update_button_highlights()
+
+            # อัพเดทไฮไลท์ปุ่มใน main UI
+            self.update_area_button_highlights(self.current_area)
+
+        except Exception as e:
+            logging.error(f"Error in sync_initial_areas: {e}")
+            # ถ้าเกิดข้อผิดพลาด ให้ใช้ค่าเริ่มต้น
+            self.current_area = "A+B"
+            self.update_area_button_highlights("A+B")
+
+    def update_button_highlight(self, button, is_active):
+        """อัพเดทสถานะไฮไลท์ของปุ่ม
+        Args:
+            button: ปุ่มที่ต้องการอัพเดท
+            is_active: สถานะการไฮไลท์ (True/False)
+        """
+        if is_active:
+            button.configure(fg="#00FFFF", bg="#404040")
+        else:
+            button.configure(fg="white", bg=appearance_manager.bg_color)
+
+    def hide_show_area(self):
+        if hasattr(self, "show_area_windows"):
+            for window in self.show_area_windows.values():
+                if window and window.winfo_exists():
+                    window.destroy()
+            self.show_area_windows.clear()
+        else:
+            self.show_area_windows = {}
+
+        if hasattr(self, "show_area_window") and self.show_area_window:
+            self.show_area_window.destroy()
+            self.show_area_window = None
+
+        self.show_area_button.config(text="Show Area")
+        self.is_area_shown = False
+
+    def start_selection_a(self):
+        """เริ่มการเลือกพื้นที่ A สำหรับชื่อผู้พูด"""
+        self.start_selection("A")
+
+    def start_selection_b(self):
+        """เริ่มการเลือกพื้นที่ B สำหรับบทสนทนาหลัก"""
+        self.start_selection("B")
+
+    def start_selection_c(self):
+        """เริ่มการเลือกพื้นที่ C สำหรับข้อความเสริม"""
+        self.start_selection("C")
+
+    def start_selection(self, area):
+        """เริ่มการเลือกพื้นที่แปลใหม่
+        Args:
+            area (str): พื้นที่ที่ต้องการเลือก ('A', 'B', หรือ 'C')
+        """
+        # เก็บสถานะการแสดงพื้นที่เดิมไว้
+        was_showing_area = self.is_area_shown
+
+        # ซ่อนหน้าต่างแสดงพื้นที่เดิม (ถ้ามี) เพื่อไม่ให้ซ้ำซ้อน
+        self.hide_show_area()
+        self.root.withdraw()
+
+        # สร้างหน้าต่างสำหรับเลือกพื้นที่
+        self.top = tk.Toplevel(self.root)
+        screen_size = self.settings.get("screen_size", "2560x1440")
+        self.top.geometry(
+            f"{self.root.winfo_screenwidth()}x{self.root.winfo_screenheight()}+0+0"
+        )
+        self.top.attributes("-topmost", True)
+        self.top.attributes("-alpha", 0.3)
+        self.top.overrideredirect(True)
+        self.top.lift()
+        self.top.focus_force()
+
+        # สร้าง Canvas สำหรับวาดพื้นที่เลือก
+        self.selection_canvas = tk.Canvas(
+            self.top, bg="white", cursor="crosshair", highlightthickness=0
+        )
+        self.selection_canvas.pack(fill=tk.BOTH, expand=tk.YES)
+
+        # แสดงพื้นที่ที่เปิดอยู่เดิมด้วยสีแดงโปร่งแสง
+        active_areas = self.current_area.split("+")
+        for active_area in active_areas:
+            translate_area = self.settings.get_translate_area(active_area)
+            if translate_area:
+                scale_x, scale_y = self.get_screen_scale()
+                x1 = int(translate_area["start_x"] * scale_x)
+                y1 = int(translate_area["start_y"] * scale_y)
+                x2 = int(translate_area["end_x"] * scale_x)
+                y2 = int(translate_area["end_y"] * scale_y)
+
+                # สร้างกรอบสีแดงโปร่งแสง
+                self.selection_canvas.create_rectangle(
+                    x1,
+                    y1,
+                    x2,
+                    y2,
+                    outline="red",
+                    fill="red",
+                    stipple="gray50",
+                    tags=f"area_{active_area}",
+                )
+
+                # เพิ่มป้ายกำกับพื้นที่
+                self.selection_canvas.create_text(
+                    x1 + 30,
+                    y1 + 20,
+                    text=f"Area {active_area}",
+                    fill="red",
+                    font=("Nasalization Rg", 12, "bold"),
+                )
+
+        # แสดงคำแนะนำ
+        instruction_text = f"คลิกซ้าย-ลาก เลือกพื้นที่ {area}\n"
+        if area == "A":
+            instruction_text += "สำหรับเลือก ชื่อผู้พูด"
+        elif area == "B":
+            instruction_text += "สำหรับเลือก บทสนทนาหลัก"
+        else:
+            instruction_text += "เลือกพื้นที่เสริมที่ต้องการ"
+
+        self.instruction_label = tk.Label(
+            self.top,
+            text=instruction_text,
+            fg="black",
+            bg="white",
+            font=("Nasalization Rg", 30),
+        )
+        self.instruction_label.place(relx=0.5, rely=0.5, anchor="center")
+
+        # ตัวแปรสำหรับเก็บจุดเริ่มต้นและสิ้นสุดการลาก
+        self.start_x = None
+        self.start_y = None
+        self.selection_rect = None
+
+        # Bind events
+        self.selection_canvas.bind(
+            "<ButtonPress-1>", lambda e: self.start_drag(e, area)
+        )
+        self.selection_canvas.bind("<B1-Motion>", self.update_selection)
+        self.selection_canvas.bind(
+            "<ButtonRelease-1>", lambda e: self.finish_selection(e, area)
+        )
+        self.top.bind("<Escape>", lambda e: self.cancel_selection())
+
+    def start_drag(self, event, area):
+        self.start_x = event.x
+        self.start_y = event.y
+        if self.selection_rect:
+            self.selection_canvas.delete(self.selection_rect)
+        self.instruction_label.place_forget()
+
+    def update_selection(self, event):
+        if self.selection_rect:
+            self.selection_canvas.delete(self.selection_rect)
+        self.selection_rect = self.selection_canvas.create_rectangle(
+            self.start_x,
+            self.start_y,
+            event.x,
+            event.y,
+            outline="red",
+            fill="red",
+            stipple="gray50",
+        )
+
+    def finish_selection(self, event, area):
+        """
+        จัดการการเลือกพื้นที่เสร็จสิ้น และอัพเดตพื้นที่การแปล
+        Args:
+            event: tkinter event object
+            area: พื้นที่ที่กำลังเลือก ('A', 'B', หรือ 'C')
+        """
+        if self.start_x is not None and self.start_y is not None:
+            try:
+                # คำนวณค่าพิกัดและปรับ scale
+                scale_x, scale_y = self.get_screen_scale()
+                x1 = min(self.start_x, event.x) / scale_x
+                y1 = min(self.start_y, event.y) / scale_y
+                x2 = max(self.start_x, event.x) / scale_x
+                y2 = max(self.start_y, event.y) / scale_y
+
+                # ตรวจสอบขนาดพื้นที่ขั้นต่ำ
+                if abs(x2 - x1) < 10 or abs(y2 - y1) < 10:
+                    messagebox.showwarning("พื้นที่เล็กเกินไป", "กรุณาเลือกพื้นที่ให้ใหญ่กว่านี้")
+                    return
+
+                # บันทึกพื้นที่
+                self.settings.set_translate_area(
+                    int(x1), int(y1), int(x2), int(y2), area
+                )
+
+                # ตรวจสอบ unsave
+                if hasattr(self, "control_ui") and self.control_ui:
+                    self.control_ui.has_unsaved_changes = True
+
+                # รักษาพื้นที่เดิมที่เปิดอยู่
+                current_areas = set(self.current_area.split("+"))
+                current_areas.add(area)  # เพิ่มพื้นที่ใหม่เข้าไป
+
+                # อัพเดตสถานะและ UI
+                self.current_area = "+".join(sorted(current_areas))  # เรียงลำดับ A, B, C
+                self.switch_area(self.current_area)
+
+                # แสดงข้อความยืนยัน
+                confirm_label = tk.Label(
+                    self.top,
+                    text=f"บันทึกพื้นที่ {area} เรียบร้อยแล้ว",
+                    fg="lime",
+                    bg="black",
+                    font=("Nasalization Rg", 14),
+                )
+                confirm_label.place(relx=0.5, rely=0.5, anchor="center")
+
+                # Log การอัพเดต
+                self.logging_manager.log_info(
+                    f"Updated area {area}. Active areas: {self.current_area}"
+                )
+
+                # ปิดหน้าต่างหลังจาก delay และแสดงพื้นที่สีแดง
+                def close_and_show_area():
+                    self.close_selection()
+                    # เปิดการแสดงพื้นที่สีแดงหลังปิดหน้าต่างเลือกพื้นที่
+                    self.is_area_shown = False  # รีเซ็ตสถานะก่อน
+                    self.show_area()  # แสดงพื้นที่ทั้งหมดที่เปิดอยู่
+                    self.show_area_button.config(text="HIDE AREA")
+                    # อัพเดตไฮไลท์ปุ่ม Show Area
+                    self.update_button_highlight(self.show_area_button, True)
+
+                self.top.after(1000, close_and_show_area)
+
+            except Exception as e:
+                self.logging_manager.log_error(f"Error in finish_selection: {e}")
+                messagebox.showerror("Error", f"เกิดข้อผิดพลาด: {str(e)}")
+
+    def close_selection(self):
+        """ปิดหน้าต่างเลือกพื้นที่และกลับสู่หน้าหลัก"""
+        if hasattr(self, "top") and self.top:
+            self.top.destroy()
+            self.root.deiconify()
+
+    def get_screen_scale(self):
+        """คำนวณ scale factor สำหรับหน้าจอ"""
+        screen_size = self.settings.get("screen_size", "2560x1440")
+        screen_width, screen_height = map(int, screen_size.split("x"))
+        scale_x = self.root.winfo_screenwidth() / screen_width
+        scale_y = self.root.winfo_screenheight() / screen_height
+        return scale_x, scale_y
+
+    def scale_coordinates(self, x, y):
+        """ปรับค่าพิกัดตาม scale ของหน้าจอ"""
+        scale_x, scale_y = self.get_screen_scale()
+        return int(x * scale_x), int(y * scale_y)
+
+    def cancel_selection(self):
+        self.top.destroy()
+        self.root.deiconify()
+
+    def preprocess_image(self, image):
+        """
+        ปรับปรุงคุณภาพของภาพก่อนส่งเข้า OCR:
+        1. Resize ภาพให้ใหญ่ขึ้น 1.5 เท่า เพื่อเพิ่มรายละเอียด
+        2. ปรับ contrast เพื่อเพิ่มความชัดของตัวอักษร
+        3. แปลงเป็นภาพขาวดำ
+
+        Args:
+            image: PIL.Image object
+        Returns:
+            PIL.Image: ภาพที่ผ่านการปรับปรุงแล้ว
+        """
+        try:
+            # 1. ขยายภาพให้ใหญ่ขึ้น 1.5 เท่า
+            width = int(image.width * 1.5)
+            height = int(image.height * 1.5)
+            image = image.resize((width, height), Image.Resampling.LANCZOS)
+
+            # 2. ปรับ contrast เพื่อเพิ่มความชัดของตัวอักษร
+            enhancer = ImageEnhance.Contrast(image)
+            image = enhancer.enhance(1.3)  # ปรับค่า contrast
+
+            # 3. แปลงเป็นภาพขาวดำ คงรายละเอียดของ grayscale
+            image = image.convert("L")
+
+            return image
+
+        except Exception as e:
+            logging.error(f"Error in image preprocessing: {e}")
+            # ถ้าเกิดข้อผิดพลาด ให้ใช้ภาพต้นฉบับ
+            return image
+
+    def capture_and_ocr(self):
+        """ฟังก์ชันจับภาพแ��ะแปลงเป็นข้อความด้วย OCR"""
+        # แปลงพื้นที่ที่ active ให้เป็นรูปแบบ list เสมอ
+        active_areas = (
+            self.current_area.split("+")
+            if isinstance(self.current_area, str)
+            else [self.current_area]
+        )
+        results = []
+
+        self._update_status_line("OCR scanning...")  # แสดงสถานะ
+
+        # วนลูปตามพื้นที่ที่เปิดใช้งาน
+        for area in active_areas:
+            # ดึงข้อมูลพื้นที่จาก settings
+            translate_area = self.settings.get_translate_area(area)
+            if not translate_area:
+                continue
+
+            start_x = translate_area["start_x"]
+            start_y = translate_area["start_y"]
+            end_x = translate_area["end_x"]
+            end_y = translate_area["end_y"]
+
+            # ตรวจสอบพื้นที่ว่าง
+            if start_x == end_x or start_y == end_y:
+                continue
+
+            try:
+                # คำนวณ scale ตามขนาดหน้าจอ
+                screen_size = self.settings.get("screen_size", "2560x1440")
+                screen_width, screen_height = map(int, screen_size.split("x"))
+                scale_x = self.root.winfo_screenwidth() / screen_width
+                scale_y = self.root.winfo_screenheight() / screen_height
+
+                # คำนวณพิกัดที่จะจับภาพ
+                x1 = int(min(start_x, end_x) * scale_x)
+                y1 = int(min(start_y, end_y) * scale_y)
+                x2 = int(max(start_x, end_x) * scale_x)
+                y2 = int(max(start_y, end_y) * scale_y)
+
+                # จับภาพหน้าจอและประมวลผล
+                img = ImageGrab.grab(bbox=(x1, y1, x2, y2))
+                img = self.preprocess_image(img)
+
+                # สร้างชื่อไฟล์ชั่วคราวที่ไม่ซ้ำกัน
+                temp_path = f"temp_screenshot_{area}_{int(time.time()*1000)}.png"
+
+                try:
+                    # บันทึกและอ่านข้อความจากภาพ
+                    img.save(temp_path)
+                    result = self.reader.readtext(temp_path, detail=0)
+                    text = " ".join(result)
+
+                    # เพิ่มผลลัพธ์ถ้ามีข้อความ
+                    if text:
+                        results.append((area, text))
+
+                finally:
+                    # ทำความสะอาดไฟล์ชั่วคราว
+                    try:
+                        if os.path.exists(temp_path):
+                            os.remove(temp_path)
+                    except Exception as e:
+                        logging.warning(f"Could not remove temp file {temp_path}: {e}")
+
+            except Exception as e:
+                self._update_status_line(f"Error in area {area}: {str(e)}")
+                continue
+
+        return results
+
+    def is_choice_dialogue(self, text):
+        """ตรวจสอบว่าเป็น choice dialogue หรือไม่
+
+        Args:
+            text (str): ข้อความที่ต้องการตรวจสอบ
+        Returns:
+            bool: True ถ้าเป็น choice dialogue
+        """
+        choice_patterns = [
+            "What will you say?",
+            "คุณจะพูดว่าอย่างไร?",
+            "Select an option.",
+            "Choose your response.",
+        ]
+
+        # ทำความสะอาดข้อความก่อนตรวจสอบ
+        cleaned_text = text.strip()
+        for pattern in choice_patterns:
+            if pattern in cleaned_text:
+                self._update_status_line(f"Choice detected: {pattern}")
+                return True
+        return False
+
+    def toggle_translation(self):
+        try:
+            if not self.is_translating:
+                # ตรวจสอบและรอ thread เดิมให้จบก่อน
+                if self.translation_thread and self.translation_thread.is_alive():
+                    self.translation_thread.join(timeout=1)
+
+                if not self.is_resizing:
+                    # ตรวจสอบพื้นที่ที่เปิดใช้งาน
+                    active_areas = (
+                        self.current_area.split("+")
+                        if isinstance(self.current_area, str)
+                        else [self.current_area]
+                    )
+                    valid_areas = True
+
+                    for area in active_areas:
+                        translate_area = self.settings.get_translate_area(area)
+                        if not translate_area:
+                            valid_areas = False
+                            break
+                        start_x = translate_area["start_x"]
+                        start_y = translate_area["start_y"]
+                        end_x = translate_area["end_x"]
+                        end_y = translate_area["end_y"]
+                        if start_x == end_x or start_y == end_y:
+                            valid_areas = False
+                            break
+
+                    if not valid_areas:
+                        messagebox.showwarning(
+                            "Warning",
+                            f"Please select translation areas for all active areas: {', '.join(active_areas)}",
+                        )
+                        return
+
+                    # เริ่มการแปล
+                    self.is_translating = True
+                    self.translation_event.set()
+                    self.start_stop_button.config(text="Stop Translation")
+                    # เพิ่มการไฮไลท์ปุ่มเมื่อเริ่มการแปล
+                    self.update_button_highlight(self.start_stop_button, True)
+                    self.blinking = True
+                    self.blink_label.after(self.blink_interval, self.blink)
+
+                    # แสดง UI
+                    self.translated_ui_window.deiconify()
+
+                    # เริ่ม translation thread
+                    self.translation_thread = threading.Thread(
+                        target=self.translation_loop,
+                        daemon=True,
+                        name="TranslationThread",
+                    )
+                    self.translation_thread.start()
+                    self.logging_manager.log_info("Translation thread started")
+                else:
+                    return
+            else:
+                self.stop_translation()
+                # เพิ่มการยกเลิกไฮไลท์ปุ่มเมื่อหยุดการแปล
+                self.update_button_highlight(self.start_stop_button, False)
+                self.translation_event.clear()
+                if self.translation_thread:
+                    self.translation_thread.join(timeout=2)
+                self.is_translating = False
+
+            self.mini_ui.update_translation_status(self.is_translating)
+
+        except Exception as e:
+            self.logging_manager.log_error(
+                f"An error occurred in toggle_translation: {e}"
+            )
+            messagebox.showerror("Error", f"An error occurred: {e}")
+            self.is_translating = False
+            self.mini_ui.update_translation_status(False)
+            # กรณีเกิดข้อผิดพลาด ยกเลิกไฮไลท์ปุ่ม
+            self.update_button_highlight(self.start_stop_button, False)
+
+    def stop_translation(self):
+        if self.is_translating:
+            self.is_translating = False
+            self.translation_event.clear()  # เพิ่มบรรทัดนี้
+            self.start_stop_button.config(text="Start Translation")
+            self.blinking = False
+            self.mini_ui.update_translation_status(False)
+            self.blink_label.config(image=self.black_icon)
+            if self.translation_thread:
+                self.translation_thread.join(timeout=5)
+                self.logging_manager.log_info("Translation thread stopped")
+
+            # ซ่อนเฉพาะ translated UI
+            if self.translated_ui_window.winfo_exists():
+                self.translated_ui_window.withdraw()
+
+    def hide_and_stop_translation(self):
+        if self.settings.get("enable_auto_hide") and self.is_translating:
+            if self.translated_ui_window.state() == "normal":
+                self.stop_translation()
+                self.translated_ui_window.withdraw()
+
+    def text_similarity(self, text1, text2):
+        return difflib.SequenceMatcher(None, text1, text2).ratio()
+
+    def translation_loop(self):
+        """จัดการการแปลและแสดงผลอย่างต่อเนื่อง"""
+        last_translated_text = ""  # เก็บข้อความที่แปลล่าสุด
+        waiting_for_message = False  # สถานะการรอข้อความ
+        temp_name = None  # เก็บชื่อชั่วคราว
+        is_processing = False  # ป้องกันการทำงานซ้ำซ้อน
+
+        while self.is_translating:
+            try:
+                # ป้องกันการทำงานซ้ำซ้อน
+                if is_processing:
+                    time.sleep(0.4)
+                    continue
+
+                is_processing = True
+
+                # รอสัญญาณจาก Event
+                if not self.translation_event.wait(timeout=0.2):
+                    self._update_status_line("Waiting for text...")
+                    is_processing = False
+                    continue
+
+                # จับภาพและ OCR
+                results = self.capture_and_ocr()
+                if not results:
+                    self._update_status_line("Waiting for text...")
+                    is_processing = False
+                    continue
+
+                current_time = time.time()
+                combined_text = ""
+
+                # 1. ตรวจสอบ choice dialogue ก่อนเสมอ
+                for area, text in results:
+                    if area == "B":
+                        corrected_text = self.text_corrector.correct_text(text)
+                        choice_patterns = [
+                            "What will you say",
+                            "What will you do",
+                            "Select an option",
+                            "Choose your response",
+                        ]
+
+                        is_choice = False
+                        for pattern in choice_patterns:
+                            if pattern.lower() in corrected_text.lower():
+                                is_choice = True
+                                combined_text = "What will you say?\n"
+
+                                options_part = corrected_text.split(pattern, 1)[-1]
+                                if options_part:
+                                    options = [
+                                        opt.strip()
+                                        for opt in re.split(r"[.!?\n]+", options_part)
+                                        if opt.strip()
+                                    ]
+                                    combined_text += "\n".join(options)
+                                break
+
+                        if is_choice:
+                            self._update_status_line("Choice dialogue detected!")
+                            break
+
+                # 2. ถ้าไม่ใช่ choice ให้ดำเนินการปกติ
+                if not combined_text:
+                    if self.current_area == "A+B":
+                        name_part = ""
+                        message_part = ""
+
+                        # 2.1 รวบรวมข้อความจากแต่ละพื้นที่
+                        for area, text in results:
+                            corrected_text = self.text_corrector.correct_text(text)
+                            if area == "A":
+                                name_part = corrected_text.strip()
+                                if name_part.startswith("?") or name_part in [
+                                    "222",
+                                    "222?",
+                                ]:
+                                    name_part = "???"
+                            elif area == "B":
+                                message_part = corrected_text.strip()
+
+                        # 2.2 จัดการข้อความตามกรณีต่างๆ
+                        if message_part:  # มีข้อความใน B
+                            # ตรวจสอบว่าข้อความใน B มีชื่อนำหน้าหรือไม่
+                            speaker, content, dialogue_type = (
+                                self.text_corrector.split_speaker_and_content(
+                                    message_part
+                                )
+                            )
+
+                            if speaker:  # ถ้าพบชื่อในข้อความ B
+                                combined_text = f"{speaker}: {content}"
+                                temp_name = None
+                                waiting_for_message = False
+                            elif name_part:  # ถ้ามีชื่อจาก A
+                                combined_text = f"{name_part}: {message_part}"
+                                temp_name = None
+                                waiting_for_message = False
+                            else:  # ไม่มีชื่อเลย แปลเหมือน C
+                                combined_text = message_part
+
+                        elif name_part:  # มีแค่ชื่อ
+                            if waiting_for_message and temp_name == name_part:
+                                # ถ้ายังคงเป็นชื่อเดิม รอข้อความต่อไป
+                                is_processing = False
+                                continue
+                            else:
+                                # ถ้าเป็นชื่อใหม่ เก็บไว้รอ
+                                combined_text = name_part
+                                temp_name = name_part
+                                waiting_for_message = True
+
+                    else:  # กรณี B หรือ C
+                        if len(results) == 1:
+                            area, text = results[0]
+                            corrected_text = self.text_corrector.correct_text(text)
+                            combined_text = corrected_text.strip()
+                        else:
+                            narrator_part = ""
+                            for area, text in results:
+                                corrected_text = self.text_corrector.correct_text(text)
+                                if area == "C":
+                                    narrator_part = corrected_text.strip()
+                            combined_text = narrator_part if narrator_part else ""
+
+                # 3. ดำเนินการแปลถ้ามีข้อความ
+                if combined_text:
+                    similarity = self.text_similarity(combined_text, self.last_text)
+
+                    if (
+                        similarity < 0.5
+                        or current_time - self.last_translation_time > 30
+                        or self.force_next_translation
+                    ):
+
+                        if self.translator:
+                            self._update_status_line("Translating...")
+                            translated_text = self.translator.translate(combined_text)
+
+                            if translated_text and len(translated_text.strip()) > 0:
+                                if (
+                                    translated_text != last_translated_text
+                                    or self.force_next_translation
+                                ):
+
+                                    self._update_status_line("✓ Translation updated")
+                                    self.root.after(
+                                        0,
+                                        lambda: self.translated_ui.update_text(
+                                            translated_text
+                                        ),
+                                    )
+
+                                    if hasattr(self, "translated_logs_instance"):
+                                        self.translated_logs_instance.add_message(
+                                            translated_text
+                                        )
+
+                                    last_translated_text = translated_text
+                                    self.last_translation = translated_text
+                                    self.last_text = combined_text
+                                    self.last_translation_time = current_time
+                                    self.force_next_translation = False
+
+                is_processing = False
+
+            except Exception as e:
+                self._update_status_line(f"Error in translation_loop: {e}")
+                self.logging_manager.log_error(f"Translation loop error: {e}")
+                is_processing = False
+                self.translation_event.wait(timeout=0.4)
+
+    def _update_status_line(self, message):
+        """อัพเดทข้อความสถานะในบรรทัดเดียว"""
+        print(f"\r{message:<60}", end="", flush=True)  # ใช้ 60 ช่องสำหรับข้อความ
+        self.logging_manager.update_status(message)
+
+    def save_ui_positions(self):
+        self.last_main_ui_pos = self.root.geometry()
+        if hasattr(self, "mini_ui"):
+            self.last_mini_ui_pos = self.mini_ui.mini_ui.geometry()
+        if hasattr(self, "translated_ui_window"):
+            self.last_translated_ui_pos = self.translated_ui_window.geometry()
+
+    def load_ui_positions(self):
+        if self.last_main_ui_pos:
+            self.root.geometry(self.last_main_ui_pos)
+        if self.last_mini_ui_pos and hasattr(self, "mini_ui"):
+            self.mini_ui.mini_ui.geometry(self.last_mini_ui_pos)
+        if self.last_translated_ui_pos and hasattr(self, "translated_ui_window"):
+            self.translated_ui_window.geometry(self.last_translated_ui_pos)
+
+    def do_move(self, event):
+        if self.x is not None and self.y is not None:
+            deltax = event.x - self.x
+            deltay = event.y - self.y
+            x = self.root.winfo_x() + deltax
+            y = self.root.winfo_y() + deltay
+            self.root.geometry(f"+{x}+{y}")
+        self.save_ui_positions()
+
+    def toggle_ui(self):
+        if self.settings.get("enable_ui_toggle"):
+            self.save_ui_positions()
+            if self.root.state() == "normal":
+                # สลับจาก Main UI เป็น Mini UI
+                self.main_window_pos = self.root.geometry()
+                self.root.withdraw()
+                self.mini_ui.mini_ui.deiconify()
+                self.mini_ui.mini_ui.lift()
+                self.mini_ui.mini_ui.attributes("-topmost", True)
+                if self.last_mini_ui_pos:
+                    self.mini_ui.mini_ui.geometry(self.last_mini_ui_pos)
+            else:
+                # สลับจาก Mini UI เป็น Main UI
+                self.root.deiconify()
+                self.root.attributes("-topmost", True)
+                self.root.lift()
+                if self.last_main_ui_pos:
+                    self.root.geometry(self.last_main_ui_pos)
+                self.mini_ui.mini_ui.withdraw()
+
+            # ทำให้แน่ใจว่า Translated UI ยังคงแสดงอยู่ถ้ากำลังแปลอยู่
+            if self.is_translating and self.translated_ui_window.winfo_exists():
+                self.translated_ui_window.lift()
+                self.translated_ui_window.attributes("-topmost", True)
+
+            # อัพเดตสถานะของ Mini UI
+            if hasattr(self, "mini_ui"):
+                self.mini_ui.update_translation_status(self.is_translating)
+
+    def toggle_mini_ui(self):
+        """Toggle between Main UI and Mini UI"""
+        self.save_ui_positions()
+
+        if self.root.state() == "normal":
+            # Switch to Mini UI
+            main_x = self.root.winfo_x()
+            main_y = self.root.winfo_y()
+            main_width = self.root.winfo_width()
+            main_height = self.root.winfo_height()
+
+            self.root.withdraw()
+            self.mini_ui.mini_ui.deiconify()
+            self.mini_ui.mini_ui.lift()
+            self.mini_ui.mini_ui.attributes("-topmost", True)
+
+            # Position Mini UI at the center of Main UI's last position
+            self.mini_ui.position_at_center_of_main(
+                main_x, main_y, main_width, main_height
+            )
+
+        else:
+            # Switch to Main UI
+            self.root.deiconify()
+            self.root.lift()
+            self.root.attributes("-topmost", True)
+            if self.last_main_ui_pos:
+                self.root.geometry(self.last_main_ui_pos)
+            self.mini_ui.mini_ui.withdraw()
+
+        # Update Mini UI status
+        if hasattr(self, "mini_ui"):
+            self.mini_ui.update_translation_status(self.is_translating)
+
+    def toggle_main_ui(self):
+        self.save_ui_positions()
+        if self.root.state() == "normal":
+            self.root.withdraw()
+        else:
+            self.root.deiconify()
+            if self.last_main_ui_pos:
+                self.root.geometry(self.last_main_ui_pos)
+
+    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 update_mini_ui_move(self):
+        original_do_move = self.mini_ui.do_move_mini_ui
+
+        def new_do_move_mini_ui(event):
+            original_do_move(event)
+            self.save_ui_positions()
+
+        self.mini_ui.do_move_mini_ui = new_do_move_mini_ui
+
+    def setup_ui_position_tracking(self):
+        self.update_mini_ui_move()
+        self.load_ui_positions()
+
+    def blink(self):
+        if self.blinking:
+            current_image = self.blink_label.cget("image")
+            new_image = (
+                self.blink_icon
+                if current_image == str(self.black_icon)
+                else self.black_icon
+            )
+            self.blink_label.config(image=new_image)
+            self.blink_label.after(self.blink_interval, self.blink)
+        else:
+            self.blink_label.config(image=self.black_icon)
+
+    def force_translate(self):
+        current_time = time.time()
+        if current_time - self.last_force_time >= 2:
+            self.force_next_translation = True
+            self.last_force_time = current_time
+
+    def update_highlight_on_preset_change(self, areas):
+        """อัพเดตการแสดงพื้นที่ไฮไลท์เมื่อมีการเปลี่ยน preset
+        Args:
+            areas (list): รายการพื้นที่ที่ต้องแสดง
+        """
+        try:
+            # ถ้ากำลังแสดงพื้นที่อยู่
+            if self.is_area_shown:
+                # บันทึกสถานะการแสดงผล
+                was_showing = True
+                # ซ่อนพื้นที่เก่า
+                self.hide_show_area()
+                # แสดงพื้นที่ใหม่ทันที
+                self.show_area()
+                # อัพเดตสถานะปุ่ม
+                self.show_area_button.config(text="HIDE AREA")
+                self.update_button_highlight(self.show_area_button, True)
+
+            logging.info(f"Updated highlight areas: {areas}")
+
+        except Exception as e:
+            logging.error(f"Error updating highlights: {e}")
+
+    def switch_area(self, areas):
+        """Switch to specified area(s) and update highlights
+        Args:
+            areas: string หรือ list ของพื้นที่ เช่น "A+B" หรือ ["A", "B"]
+        """
+        try:
+            # แปลงให้เป็น list เสมอ
+            area_list = areas if isinstance(areas, list) else areas.split("+")
+
+            # ตรวจสอบความถูกต้องของพื้นที่
+            for area in area_list:
+                if area not in ["A", "B", "C"]:
+                    self.logging_manager.log_error(f"Invalid area: {area}")
+                    return
+
+            # อัพเดต current_area
+            self.current_area = "+".join(area_list)
+            self.settings.set("current_area", self.current_area)
+
+            # อัพเดท Control UI
+            if hasattr(self, "control_ui") and self.control_ui.root.winfo_exists():
+                for area in ["A", "B", "C"]:
+                    self.control_ui.area_states[area] = area in area_list
+                self.control_ui.update_button_highlights()
+
+            # อัพเดท Main UI
+            self.update_area_button_highlights(area_list)
+
+            # ถ้ามีการแสดงพื้นที่สีแดงอยู่ ให้อัพเดตทันที
+            if self.is_area_shown:
+                self.hide_show_area()  # ลบพื้นที่เก่า
+                self.show_area()  # แสดงพื้นที่ใหม่
+
+            self.logging_manager.log_info(f"Switched to areas {self.current_area}")
+            self.force_translate()
+
+        except Exception as e:
+            self.logging_manager.log_error(f"Error in switch_area: {e}")
+
+    def exit_program(self):
+        self.stop_translation()
+        self.hide_show_area()
+        self.remove_all_hotkeys()
+        try:
+            keyboard.unhook_all()
+        except Exception as e:
+            self.logging_manager.log_error(f"Error unhooking keyboard: {e}")
+
+        # เพิ่ม translated_logs_window เข้าไปในรายการ windows ที่ต้องปิด
+        windows_to_close = [
+            self.translated_ui_window,
+            self.translated_logs_window,  # เพิ่มบรรทัดนี้
+            self.mini_ui.mini_ui,
+        ]
+        if hasattr(self.settings_ui, "settings_window"):
+            windows_to_close.append(self.settings_ui.settings_window)
+        if hasattr(self.settings_ui, "advance_ui") and self.settings_ui.advance_ui:
+            windows_to_close.append(self.settings_ui.advance_ui.advance_window)
+
+        for window in windows_to_close:
+            if window:
+                try:
+                    window.destroy()
+                except Exception as e:
+                    self.logging_manager.log_error(f"Error destroying window: {e}")
+
+        if self.translation_thread and self.translation_thread.is_alive():
+            self.translation_thread.join(timeout=5)
+
+        try:
+            self.root.quit()
+            self.root.destroy()
+        except Exception as e:
+            self.logging_manager.log_error(f"Error destroying root window: {e}")
+
+        self.logging_manager.log_info("MagicBabel application closed")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    try:
+        root = tk.Tk()
+        app = MagicBabelApp(root)
+        app.setup_ui_position_tracking()
+        root.mainloop()
+    except Exception as e:
+        messagebox.showerror(
+            "Critical Error",
+            f"An unexpected error occurred: {e}\n\nPlease check the log file for details.",
+        )

NPC.json

@@ -0,0 +1,1473 @@
+{
+    "main_characters": [
+        {
+            "firstName": "Y'shtola",
+            "lastName": "Rhul",
+            "gender": "Female",
+            "role": "Scion, Conjurer",
+            "relationship": "Close ally"
+        },
+        {
+            "firstName": "Alphinaud",
+            "lastName": "Leveilleur",
+            "gender": "Male",
+            "role": "Scion, Academician",
+            "relationship": "Close ally"
+        },
+        {
+            "firstName": "Alisaie",
+            "lastName": "Leveilleur",
+            "gender": "Female",
+            "role": "Scion, Red Mage",
+            "relationship": "Close ally"
+        },
+        {
+            "firstName": "Urianger",
+            "lastName": "Augurelt",
+            "gender": "Male",
+            "role": "Scion, Astrologian",
+            "relationship": "Close ally"
+        },
+        {
+            "firstName": "Thancred",
+            "lastName": "Waters",
+            "gender": "Male",
+            "role": "Scion, Gunbreaker",
+            "relationship": "Close ally"
+        },
+        {
+            "firstName": "Wuk Lamat",
+            "lastName": "Lamat",
+            "gender": "Female",
+            "role": "Hrothgar, Third Promise, lamaty'i",
+            "relationship": "Close ally"
+        },
+        {
+            "firstName": "Zoraal Ja",
+            "lastName": "Ja",
+            "gender": "Male",
+            "role": "Mamool Ja warrior",
+            "relationship": "Wuk Lamat's older brother"
+        },
+        {
+            "firstName": "Sphene",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Princess of Alexandria",
+            "relationship": "Unknow"
+        },
+        {
+            "firstName": "Otis",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Alexandria Battle Robot",
+            "relationship": "New ally"
+        },
+        {
+            "firstName": "Koana",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Prince",
+            "relationship": "Close ally"
+        },
+        {
+            "firstName": "Gulool Ja",
+            "lastName": "Ja",
+            "gender": "Male",
+            "role": "Mamool Ja, Prince of Alexandria",
+            "relationship": "Close ally"
+        },
+        {
+            "firstName": "G'raha Tia",
+            "lastName": "Tia",
+            "gender": "Male",
+            "role": "Scion, Historian, Crystal Exarch",
+            "relationship": "Close ally"
+        },
+        {
+            "firstName": "Crystal Exarch",
+            "lastName": "Exarch",
+            "gender": "Male",
+            "role": "Scion, Leader of the Crystarium, คนใน the First เรียก 'ท่านคริสตัล' ",
+            "relationship": "Close ally (G'raha Tia's identity in the First)"
+        },
+        {
+            "firstName": "Krile",
+            "lastName": "Baldesion",
+            "gender": "Female",
+            "role": "Scion, Pictomancer",
+            "relationship": "Close ally"
+        },
+        {
+            "firstName": "Erenville",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Gleaner",
+            "relationship": "New ally"
+        },
+        {
+            "firstName": "Hythlodaeus",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Ascians",
+            "relationship": "Past ally"
+        },
+        {
+            "firstName": "Emet-Selch",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Ascians",
+            "relationship": "Past ally"
+        },
+        {
+            "firstName": "EmetSelch",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Ascians",
+            "relationship": "Past ally"
+        },
+        {
+            "firstName": "Meteion",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Elpis Citizen",
+            "relationship": "New ally"
+        },
+        {
+            "firstName": "Hermes",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Ascians",
+            "relationship": "Past ally"
+        },
+        {
+            "firstName": "Venat",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Ascians,Hydaelyn",
+            "relationship": "Past ally"
+        },
+        {
+            "firstName": "Nanamo",
+            "lastName": "Ul Namo",
+            "gender": "Female",
+            "role": "Princess of Uldah",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "???",
+            "lastName": "",
+            "gender": "unknown",
+            "role": "Mystery character",
+            "relationship": "Unknown/Mysterious"
+        },
+        {
+            "firstName": "2P",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Neutral",
+            "relationship": "Unknow"
+        },
+        {
+            "firstName": "2B",
+            "lastName": "",
+            "gender": "Female",
+            "role": "android",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "9S",
+            "lastName": "",
+            "gender": "Male",
+            "role": "android",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Themis",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Ascians",
+            "relationship": "Past ally"
+        },
+        {
+            "firstName": "Erichthonios",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Ascians",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Leophyne",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Scouter",
+            "relationship": "Enemy"
+        },
+        {
+            "firstName": "Bakool Ja Ja the Mighty",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Mamool Ja",
+            "relationship": "neutral"
+        },
+        {
+            "firstName": "Bakool Ja Ja the Mystic",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Mamool Ja",
+            "relationship": "neutral"
+        },
+        {
+            "firstName": "Prishe",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Elvaan",
+            "relationship": "Neutral"
+        },
+        {
+            "firstName": "Liplu",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Pelupelu",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Yubli",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Pelupelu",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Wuk Evu",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Hrothgar",
+            "relationship": "Close ally"
+        },
+        {
+            "firstName": "Alxaal",
+            "lastName": "",
+            "gender": "Male",
+            "role": "knight",
+            "relationship": "Ally from Alexandria"
+        },
+        {
+            "firstName": "Miilal Ja",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Mamool Ja",
+            "relationship": "แม่ของ Bakool Ja Ja"
+        },
+        {
+            "firstName": "Gossan",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Human",
+            "relationship": "ผู้ช่วยขององค์ชาย Gurool Ja และ Sphene"
+        },
+        {
+            "firstName": "Shale",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Elvan",
+            "relationship": "Close ally"
+        },
+        {
+            "firstName": "Genolt",
+            "lastName": "",
+            "gender": "Male",
+            "role": "ช่างตีดาบในตำนาน",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Grenoldt",
+            "lastName": "",
+            "gender": "Male",
+            "role": "ช่างตีดาบในตำนาน",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Kanilokka",
+            "lastName": "",
+            "gender": "Male",
+            "role": "นักวิจัยของ Zoraal Ja",
+            "relationship": "unknow"
+        },
+        {
+            "firstName": "Teeshal Ja",
+            "lastName": "",
+            "gender": "Female",
+            "role": "ศัลยแพทย์ผู้รับใช้ Zoraal Ja",
+            "relationship": "อาจเป็นแม่ของ Gulool Ja"
+        },
+        {
+            "firstName": "Nitowikwe",
+            "lastName": "",
+            "gender": "Female",
+            "role": "เจ้าหน้าที่สถานีรถไฟ",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Wawlika",
+            "lastName": "",
+            "gender": "Male",
+            "role": "เจ้าหน้าที่สถานีรถไฟ",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Hhwato",
+            "lastName": "",
+            "gender": "Male",
+            "role": "หัวหน้าหมู่บ้านย่าน 'Hhetsarro' ",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Shepetto",
+            "lastName": "",
+            "gender": "Male",
+            "role": "ชาวเผ่า 'Hhetsarro'",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Aranea",
+            "lastName": "-",
+            "gender": "Female",
+            "role": "Champion",
+            "relationship": "Wol"
+        },
+        {
+            "firstName": "Ardbert",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Warrior of Darkness",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "DuliaChai",
+            "lastName": "",
+            "gender": "Female",
+            "role": "ชาว Eulmore",
+            "relationship": "Ally, ภรรยาของ ChaiNuzz"
+        },
+        {
+            "firstName": "ChaiNuzz",
+            "lastName": "",
+            "gender": "Male",
+            "role": "ชาว Eulmore",
+            "relationship": "Ally, สามีของ DuliaChai"
+        },
+        {
+            "firstName": "Vauthry",
+            "lastName": "",
+            "gender": "Male",
+            "role": "เจ้าเมือง Eulmore",
+            "relationship": "Enemy"
+        },
+        {
+            "firstName": "Tesleen",
+            "lastName": "",
+            "gender": "Female",
+            "role": "หญิงสาวผู้ดูแลในค่ายกักกัน",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Lyna",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Captain แห่ง Crystarium",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Estinien",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Dragoon, Scion",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Gaius",
+            "lastName": "",
+            "gender": "Male",
+            "role": "ShadowHunter",
+            "relationship": "Old Enemy, New Ally"
+        },
+        {
+            "firstName": "Ranjit",
+            "lastName": "",
+            "gender": "Male",
+            "role": "ผู้บัญชาการ แห่งเมือง Eulmore",
+            "relationship": "Enemy"
+        },
+        {
+            "firstName": "Minfilia",
+            "lastName": "",
+            "gender": "Female",
+            "role": "ผู้กุมความลับแห่งแสง",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Feo Ul",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Pixie",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Oracle of Light",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Oracle of Light",
+            "relationship": "คนรักของ Trancred"
+        },
+        {
+            "firstName": "Gosetsu",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Samurai",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Hien",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Samurai",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Asahi",
+            "lastName": "",
+            "gender": "Male",
+            "role": "น้องชายของ Yotsuyu",
+            "relationship": "unknow"
+        },
+        {
+            "firstName": "Tobli",
+            "lastName": "",
+            "gender": "Male",
+            "role": "พ่อค้าชาว Pelupelu",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Mablu",
+            "lastName": "",
+            "gender": "Female",
+            "role": "แม่ค้าฝึกหัด ชาว Pelupelu",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Vow of Resolve Gulool Ja Ja",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Dawnservant, Gulool Ja Ja",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Minstreling Wanderer",
+            "lastName": "",
+            "gender": "Male",
+            "role": "กวีเพนจร",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "LueReeq",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Hunter",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Mowen",
+            "lastName": "",
+            "gender": "Female",
+            "role": "แม่ค้าชั้นสูง",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Hydaelyn",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Ascians",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Matoya",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Elder Wizard",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Varshahn",
+            "lastName": "",
+            "gender": "Male",
+            "role": "มังกร",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Zero",
+            "lastName": "",
+            "gender": "none",
+            "role": "Reaper",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Golbez",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Dark Lord",
+            "relationship": "Unknow"
+        },
+        {
+            "firstName": "Azdaja",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Dragon",
+            "relationship": "พี่สาวของ Varshahn"
+        },
+        {
+            "firstName": "Jullus",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Soldier",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Ryne",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Oracle of Light (The First)",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Barbariccia",
+            "lastName": "",
+            "gender": "Female",
+            "role": "One of the Four Fiends (Endwalker)",
+            "relationship": "Enemy"
+        },
+        {
+            "firstName": "Rubicante",
+            "lastName": "",
+            "gender": "Male",
+            "role": "One of the Four Fiends (Endwalker)",
+            "relationship": "Enemy"
+        },
+        {
+            "firstName": "Scarmiglione",
+            "lastName": "",
+            "gender": "Male",
+            "role": "One of the Four Fiends (Endwalker)",
+            "relationship": "Enemy"
+        },
+        {
+            "firstName": "Cagnazzo",
+            "lastName": "",
+            "gender": "Male",
+            "role": "One of the Four Fiends (Endwalker)",
+            "relationship": "Enemy"
+        },
+        {
+            "firstName": "Fourchenault",
+            "lastName": "Leveilleur",
+            "gender": "Male",
+            "role": "Member of The Forum (Sharlayan)",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Ameliance",
+            "lastName": "Leveilleur",
+            "gender": "Female",
+            "role": "Mother of Alphinaud and Alisaie",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Nidhana",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Researcher of Thavnair",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Zenos",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Garlean Prince, Antagonist",
+            "relationship": "Enemy"
+        },
+        {
+            "firstName": "Zenos yae Galvus",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Garlean Prince, Antagonist",
+            "relationship": "Enemy"
+        },
+        {
+            "firstName": "Zenos viator Galvus",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Garlean Prince, Antagonist",
+            "relationship": "Enemy"
+        },
+        {
+            "firstName": "Maxima",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Former Garlean Official turned Ally",
+            "relationship": "New Ally"
+        },
+        {
+            "firstName": "Livingway",
+            "lastName": "",
+            "gender": "unknown",
+            "role": "Loporrit (Endwalker)",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Puddingway",
+            "lastName": "",
+            "gender": "unknown",
+            "role": "Loporrit (Endwalker)",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Jammingway",
+            "lastName": "",
+            "gender": "unknown",
+            "role": "Loporrit (Endwalker)",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Montichaigne",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Member of The Forum",
+            "relationship": "Neutral Ally"
+        },
+        {
+            "firstName": "Claudien",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Sharlayan Researcher",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Seto",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Amaro loyal to Ardbert",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Beq Lugg",
+            "lastName": "",
+            "gender": "unknown",
+            "role": "Scholar in Il Mheg",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Tataru",
+            "lastName": "Taru",
+            "gender": "Female",
+            "role": "Scion Supporter",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Quintus",
+            "lastName": "van Cinna",
+            "gender": "Male",
+            "role": "Garlean Commander",
+            "relationship": "Enemy"
+        },
+        {
+            "firstName": "Fandaniel",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Ascian (Endwalker)",
+            "relationship": "Enemy"
+        },
+        {
+            "firstName": "Kuplo Kopp",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Moogle",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Raya-O-Senna",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Healer",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Kan-E-Senna",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Healer, Priest",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Yda",
+            "lastName": "",
+            "gender": "Female",
+            "role": "scions fighter",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Ketenramm",
+            "lastName": "",
+            "gender": "Male",
+            "role": "unknow",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Cid",
+            "lastName": "Garlond",
+            "gender": "Male",
+            "role": "Engineer",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Rammbroes",
+            "lastName": "",
+            "gender": "Male",
+            "role": "นักโบราณคดี",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Nero",
+            "lastName": "tol Scaeva",
+            "gender": "Male",
+            "role": "Gunbreaker",
+            "relationship": "unknow"
+        },
+        {
+            "firstName": "Xande",
+            "lastName": "",
+            "gender": "Male",
+            "role": "จักรพรรดิ์แห่ง Allagan",
+            "relationship": "Enemy"
+        },
+        {
+            "firstName": "Gurfurlur",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Giant",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Raubahn",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Imperial Knight",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Runar",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Hrothgar",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Elidibus",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Ascians",
+            "relationship": "Enemy"
+        },
+        {
+            "firstName": "Pipin",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Knight",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Lyse",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Fighter, Yda",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Aymeric",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Temple Knight of Ishgard",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Amon",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Ascians, Hermes",
+            "relationship": "Enemy"
+        },
+        {
+            "firstName": "Hancock",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Merchant",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Soroban",
+            "lastName": "",
+            "gender": "Male",
+            "role": "มนุษย์เงือก",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Yugiri",
+            "lastName": "",
+            "gender": "Female",
+            "role": "ninja",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Yotsuyu",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Samurai",
+            "relationship": "unknow"
+        },
+        {
+            "firstName": "Solus zos Galvus",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Ascians, Emet-Selch",
+            "relationship": "enemy"
+        },
+        {
+            "firstName": "Warrior of Darkness",
+            "lastName": "",
+            "gender": "Male",
+            "role": "นักรบแห่งความมืด",
+            "relationship": "unknow"
+        },
+        {
+            "firstName": "Papalymo",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Mage",
+            "relationship": "Close Ally"
+        },
+        {
+            "firstName": "Merlwyb",
+            "lastName": "",
+            "gender": "Female",
+            "role": "ผู้นำแห่ง Limza",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Tiamat",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Elder Dragon",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Lucia",
+            "lastName": "",
+            "gender": "Female",
+            "role": "Guardian of Ishgard",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Emmanellain",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Elite",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Sicard",
+            "lastName": "",
+            "gender": "Male",
+            "role": "อดีตโจรสลัดอากาศ",
+            "relationship": "Neutral"
+        },
+        {
+            "firstName": "Zodiark",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Eternal Darkness",
+            "relationship": "Enemy"
+        },
+        {
+            "firstName": "Louisoix",
+            "lastName": "",
+            "gender": "Male",
+            "role": "มหาเวทย์ผู้ยิ่งใหญ่",
+            "relationship": "Ally"
+        },
+        {
+            "firstName": "Cloud",
+            "lastName": "Striff",
+            "gender": "Male",
+            "role": "Champion, Soldier First Class",
+            "relationship": "Player"
+        },
+        {
+            "firstName": "Sephiroth",
+            "lastName": "",
+            "gender": "Male",
+            "role": "Boss",
+            "relationship": "Unknow"
+        },
+        {
+            "firstName": "Kurohime",
+            "lastName": "",
+            "gender": "female",
+            "role": "maid of honor",
+            "relationship": "intimate ally"
+        }
+    ],
+    "npcs": [
+        {
+            "name": "Xbr'aal",
+            "role": "Hrothgar",
+            "description": "Hrothgar race"
+        },
+        {
+            "name": "Hhetsarro",
+            "role": "Miqo'te",
+            "description": "Miqo'te race"
+        },
+        {
+            "name": "Shetona",
+            "role": "Viera",
+            "description": "Viera race"
+        },
+        {
+            "name": "Tonawawta",
+            "role": "Hyur",
+            "description": "Hyur race"
+        },
+        {
+            "name": "Hanuhanu",
+            "role": "Vanu Vanu",
+            "description": "Vanu Vanu race"
+        },
+        {
+            "name": "Moblin",
+            "role": "Goblin",
+            "description": "Goblin race"
+        },
+        {
+            "name": "Eutrope",
+            "role": "NPC",
+            "description": "พี่สาวของ Neyuni และ Yaana"
+        },
+        {
+            "name": "Neyuni",
+            "role": "NPC",
+            "description": "น้องสาวของ Eutrope และ Yaana"
+        },
+        {
+            "name": "Nostalgia",
+            "role": "NPC",
+            "description": "ตัวละครใน Dawntrail"
+        },
+        {
+            "name": "Shaloaci",
+            "role": "NPC",
+            "description": "ตัวละครใน Dawntrail"
+        },
+        {
+            "name": "Kemakka",
+            "role": "NPC",
+            "description": "ตัวละครใน Dawntrail"
+        },
+        {
+            "name": "Iyaate",
+            "role": "NPC",
+            "description": "เพื่อนวัยเด็กของ Erenville"
+        },
+        {
+            "name": "Alayla",
+            "role": "NPC",
+            "description": "แม��ของ Krile"
+        },
+        {
+            "name": "Robor",
+            "role": "NPC",
+            "description": "พ่อของ Krile"
+        },
+        {
+            "name": "Retainer",
+            "role": "npc",
+            "description": "ผู้ช่วยส่วนตัว"
+        },
+        {
+            "name": "Sareel Ja",
+            "role": "npc",
+            "description": "ลูกสมุนของ Zoraal Ja"
+        },
+        {
+            "name": "Hume Adventurer",
+            "role": "adventurer",
+            "description": "นักผจญภัยที่รู้ลึกเกี่ยวกับ Jeono"
+        },
+        {
+            "name": "Bakool Ja Ja the Mystic",
+            "role": "Mamool Ja",
+            "description": "นักรบแห่ง Tural"
+        },
+        {
+            "name": "Bakool Ja Ja the Mighty",
+            "role": "Mamool Ja",
+            "description": "นักรบแห่ง Tural"
+        },
+        {
+            "name": "Bol Noq",
+            "role": "merchant",
+            "description": "ชาว Tural"
+        },
+        {
+            "name": "Loazenikwe",
+            "role": "มนุษย์",
+            "description": "หญิงสาวที่มุ่งมั่น แฟนสาวของ Tentoawa"
+        },
+        {
+            "name": "Sonu Vanu",
+            "role": "ชนเผ่า Vanu",
+            "description": "ชาวเผ่า vanu"
+        },
+        {
+            "name": "Tentoawa",
+            "role": "เผ่ามนุษย์",
+            "description": "ชายหนุ่มผู้มุ่งมั่น คนรักของ Loazenikwe"
+        },
+        {
+            "name": "Leophyne",
+            "role": "นักรบเผ่าเอลฟ์",
+            "description": "นักรบหญิง วายร้ายผู้โจรกรรม Cradle เครื่องรางแห่งการหลับไหล"
+        },
+        {
+            "name": "Khloe Aliapoh",
+            "role": "แม่ค้าเผ่าแมว",
+            "description": "สาวน้อยน่ารัก สดใสประจำเมือง Idyllshire"
+        },
+        {
+            "name": "Theva",
+            "role": "แม่ค้า",
+            "description": "แม่ค้าที่เปิดบาร์เล็กๆ ในย่านชนบทเมือง Kholusia"
+        },
+        {
+            "name": "Kaishirr",
+            "role": "mystel",
+            "description": "เด็กหนุ่มชนบทใน Kholusia ผู้มุ่งมั่นเพื่อพวกพ้อง"
+        },
+        {
+            "name": "Cassard",
+            "role": "Soldier",
+            "description": "ทหารของ Crystarium"
+        },
+        {
+            "name": "Halric",
+            "role": "เด็กหนุ่มกำพร้าในค่ายกักกัน",
+            "description": "เด็กหนุ่มป่วยผู้ไร้จิตวิญญาณ"
+        },
+        {
+            "name": "Moren",
+            "role": "นักปราชญ์",
+            "description": "ชายหนุ่มเนิร์ด ผู้ดูแลห้องสมุดภายใน Crystarium"
+        },
+        {
+            "name": "Andreia",
+            "role": "Hunter",
+            "description": "วิญญาณของฮันเตอร์สาวผู้ล่วงลับ ชื่อเดิม 'RendaRae'"
+        },
+        {
+            "name": "RendaRae",
+            "role": "Hunter",
+            "description": "ฮันเตอร์สาว คนเดียวกับ Andreia"
+        },
+        {
+            "name": "Bigg",
+            "role": "ผู้ช่วยของ Cid",
+            "description": "ตัวละครพูดจาสนุก กวนๆ"
+        },
+        {
+            "name": "Wedge",
+            "role": "ผู้ช่วยของ Cid",
+            "description": "ตัวละครพูดจา ตลก ทะเล้น"
+        },
+        {
+            "name": "Doga",
+            "role": "นักโบราณคดี",
+            "description": "ผู้มีเชื้อสาย Allagan"
+        },
+        {
+            "name": "Unei",
+            "role": "นักโบราณคดีหญิง",
+            "description": "ผู้มีเชื้อสาย Allagan"
+        },
+        {
+            "name": "Xande",
+            "role": "Emperor of Allagan",
+            "description": "จักรพรรดิ์แห่งอาณาจักร Allagan"
+        },
+        {
+            "name": "Fordola",
+            "role": "ทหารจักรวรรดิ์",
+            "description": "ทหารหญิงผู้กลับใจ"
+        },
+        {
+            "name": "Warrior of Darkness",
+            "role": "ผู้กล้าแห่งความมืดจาก The First",
+            "description": "ผู้กล้าแห่งความมืด หรือ Ardbert"
+        },
+        {
+            "name": "The Griffin",
+            "role": "นักปฏิวัติลึกลับ",
+            "description": "ชายลึกลับ ผู้ชักชวนให้เกิดการก่อกบฎ"
+        },
+        {
+            "name": "Arenvald",
+            "role": "knight",
+            "description": "นายทหาร"
+        },
+        {
+            "name": "Galene",
+            "role": "นักวิจัย",
+            "description": "สาวนักวิจัยใน Elpis"
+        },
+        {
+            "name": "The Watcher",
+            "role": "Ascians",
+            "description": "ชาวเผ่า Ascians ผู้ดูแลดวงจันทร์ ใช้ภาษาซับซ้อน"
+        },
+        {
+            "name": "Growingway",
+            "role": "Loporrits",
+            "description": "เผ่ากระต่ายน้อย ผู้ซุ่มซ่าม"
+        },
+        {
+            "name": "Livingway",
+            "role": "Loporrits",
+            "description": "เผ่ากระต่ายน้อย คำพูดจริงจัง"
+        },
+        {
+            "name": "Mappingway",
+            "role": "Loporrits",
+            "description": "เผ่ากระต่ายน้อย นักนำทาง"
+        },
+        {
+            "name": "Singingway",
+            "role": "Loporrits",
+            "description": "เผ่ากระต่ายน้อย เจ้าบทเจ้ากลอน"
+        },
+        {
+            "name": "Puddingway",
+            "role": "Loporrits",
+            "description": "เผ่ากระต่ายน้อย นักปรุงอาหาร"
+        },
+        {
+            "name": "Barnier",
+            "role": "นักวิชาการ",
+            "description": "นักวิชาการ คำพูดน่าเชื่อถือ"
+        },
+        {
+            "name": "Arkasodara Alchemist",
+            "role": "นักเล่นแร่แปรธาตุ",
+            "description": "สาวนักวิจัย"
+        },
+        {
+            "name": "Sleepingway",
+            "role": "Loporrits",
+            "description": "เผ่ากระต่ายน้อย ขี้เซา"
+        },
+        {
+            "name": "Cophcoodg",
+            "role": "เผ่าผีต่างดาว",
+            "description": "พูดจาภาษาซับซ้อน แต่ทันสมัย กระชับ"
+        },
+        {
+            "name": "LahIaakh",
+            "role": "เผ่าผีต่างดาว",
+            "description": "พูดจาภาษาซับซ้อน แต่ทันสมัย กระชับ"
+        }
+    ],
+    "lore": {
+        "Scions": "กลุ่มนักผจญภัยของตัวเอก เรียกสั้นๆว่า 'ไซออนส์' ",
+        "The Seven Dawn": "ชื่อเดิมของกลุ่มนักรบที่มีภารกิจคล้ายกับ Scions",
+        "Calamity": "เหตุการณ์หายนะครั้งใหญ่ที่ทำลายล้างโลกในอดีต เช่น หายนะจากดวงจันทร์ Dalamud",
+        "Seven hells": "คำอุทาน เช่น 'นี่มันเรื่องบ้าบออะไรกัน !!', ใช้พูดถึงเรื่องแย่ๆ 'เรื่องบ้าบอ' ",
+        "Rejoining": "เรียกสั้นๆว่า 'การรวมโลก' คือ มหันตภัย การเอ่อล้นของธาตุจากโลกสะท้อนทะลักสู่ 'the Source' จนเกิดหายนะ",
+        "By the Twelve!": "พระเจ้าช่วย!..",
+        "Godsdammit!": "บ้าเอ๊ย!",
+        "Bloody hells!": "มันบ้าอะไรเนี่ย!",
+        "Baldesion": "ชื่อขององค์กรของนักวิชาการ 'Students of Baldesion' ที่ก่อตั้งโดย 'Galuf Baldesion'",
+        "Aether": "พลังงานลึกลับที่เป็นแหล่งกำเนิดชีวิตและเวทมนตร์ในโลก",
+        "Reflection": "โลกสะท้อน ปัจจุบันมี 13 แห่ง",
+        "Echo": "พลังพิเศษที่ทำให้ผู้ใช้งานเห็นความทรงจำของผู้อื่นและเข้าใจภาษาต่างๆ",
+        "the First": "โลกสะท้อน ลำดับที่ 1 ที่ถูกกลืนกินด้วย แสง",
+        "the Source": "โลกหลักใน Final Fantasy XIV",
+        "linkpearls": "อุปกรณ์สื่อสารเล็กๆ คล้ายโทรศัพท์ที่ติดไว้หลังใบหู",
+        "Ascians": "เผ่าพันธุ์ผู้บุกเบิก มีพลังที่สมบูรณ์แบบ มีเป้าหมายในการคืนชีพ Zodiark และการรวมโลก",
+        "vessel": "ร่าง ที่ใช้อาศัยของจิตวิญญาณ",
+        "Endless": " เอนด์เลส คือ สถานะหลังความตายที่ข้อมูลวิญญาณถูกนำมาประกอบสร้างเป็นรูปร่างดั่งยามมีชีวิต",
+        "Primal": "'ไพรมัล'สิ่งมีชีวิตที่ถูกอัญเชิญมาโดยการใช้พลังงาน Aether จากแรงศรัทธา",
+        "Tuliyollal": "เมืองหลักในตอนเหนือของ Yok Tural",
+        "barrier": "เขตแดน คั่นพื้นที่ระหว่างโลกภายนอกและเมือง Alexandria",
+        "Urqopacha": "ดินแดนที่เคยเป็นที่อยู่อาศัยของ เผ่ายักษ์ เมื่อพันปีก่อน",
+        "Yak T'el": "โซนที่เป็นที่อยู่อาศัยของ Hrothgar และ Mamool Ja",
+        "Kozama'uka": "พื้นที่เขตร้อนใต้ของ Tuliyollal",
+        "Shaaloani": "โซนแห้งแล้งใน Tural ตอนกลาง",
+        "Heritage Found": "โซนที่เชื่อมโยงระหว่างอารยธรรมเก่าและใหม่ใน New World",
+        "Living Memory": "สถานที่พำนักของเหล่า Endless",
+        "Solution Nine": "เมืองที่มีเทคโนโลยีล้ำยุค พัฒนาด้วยเทคโนโลยี Electrope",
+        "Earthen Sky": "พื้นที่ธรรมชาติที่เน้นภูมิทัศน์ทางธรณีวิทยา",
+        "Electric Potential": "บริเวณที่มีกิจกรรมทางไฟฟ้าและแหล่งพลังงานสำคัญ",
+        "Tesh'pyani Village": "หมู่บ้านเล็กๆ ที่มีเอกลักษณ์ทางวัฒนธรรมในพื้นที่ Yyasulani",
+        "The Thunderyards": "พื้นที่ที่มีฟ้าร้องและกิจกรรมทางไฟฟ้าเป็นปกติ",
+        "Electrope": "เทคโนโลยีที่ประยุกต์ใช้การดักจับสายฟ้าจากธรรมชาติ มาประยุกต์ใช้สร้างพลังงานธาตุต่างๆได้",
+        "Convocation of Fourteen": " 'องค์คณะทั้ง 14' เป็นกลุ่มสมาชิกที่มีอำนาจสูงสุดในหมู่ Ascians ",
+        "Fourteen": " 'องค์คณะทั้ง 14' เป็นกลุ่มสมาชิกที่มีอำนาจสูงสุดในหมู่ Ascians ",
+        "the Final Days": "วันสิ้นโลก",
+        "dragoon": "นักรบมังกร",
+        "viper": "คลาสอาชีพ นักล่าผู้ใช้ดาบคู่ ทับศัพท์ได้ว่า 'ไวเปอร์'",
+        "The Temple Knights": "กลุ่มอัศวินศักดิ์สิทธิ์",
+        "Alexandria": "อาณาจักรโบราณบนโลกสะท้อนของ Etheirys ที่มีการใช้แร่ธาตุ electrope ร่วมกับ arcanima เพื่อพัฒนาเทคโนโลยีและป้องกันพายุฟ้าคะนองที่คุกคามดินแดน",
+        "Jeuno": "เมืองร้างที่มีแหล่ง electrope อยู่มากมาย ทำให้เป็นที่หมายปองของนักล่าสมบัติ แม้จะมีพลังชั่วร้ายของ Shadow Lord สิงสถิตอยู่",
+        "a Mamool Ja woman": "Mamool Ja's Mother หรือ เรียกได้ว่า 'แม่ขององค์ชายMaMool Ja' ",
+        "rroneek": "สัตว์ใหญ่ประจำท้องถิ่น Shaaloani",
+        "Hhetsarro": "ถิ่นอาศัยของชนเผ่าเร่ร่อน ในโซน 'Shaaloani'",
+        "dome": "คำง่ายๆที่อธิบายขอบเขตของ New Alexandria",
+        "Cradle": "เครื่องราง แห่งการหลับไหล",
+        "Champion": "คำแทนตัวละครหลักของผู้เล่น เรียกสั้นๆว่า 'ผู้กล้า' ",
+        "the flood": "การท่วมครั้งใหญ่ ของแสงที่กลืนกิน the First",
+        "Sin eater": " 'ตัวกินบาป' ปีศาจที่มีร่างกายขาวโพลน เดิมดีเคยเป็นสิ่งมีชีวิต หรือมนุษย์มาก่อน",
+        "Lightwarden": "นางพญา ของเหล่าตัวกินบาป",
+        "Eighth Umbral Calamity": "หายนะครั้งใหญ่ ครั้งที่ 8 ที่กำลังจะเกิดกับ 'the First'",
+        "My Lord": "เรียกแบบให้เกียรติแทนคำว่า 'ท่าน'",
+        "My Lady": "เรียกแบบให้เกียรติแทนคำว่า 'ท่านหญิง'",
+        "Black Rose": "ก๊าซพิษชีวภาพ ใช้คร่าชีวิตผู้คนจำนวนมาก และยังคงเป็นปริศนาในที่มา",
+        "Minfilia": "ในโลกหลัก (the Source) เธอคือหัวหน้ากลุ่ม Scions, แต่ใน the First เธอคือเด็กสาวผู้แทนตำแหน่ง Minfilia (Oracle of Light) ซึ่งปัจจุบันคือ 'Lyne'",
+        "City of Gold": "ณครทองคำ",
+        "Valigarmanda": "สัตว์ในตำนานแห่ง Yok tural",
+        "materia": "ลูกแก้วที่ผนึกพลังเอาไว้ เรียกสั้นๆว่า 'มาทีเรีย'",
+        "yalm": "replace 'yard'",
+        "malm": "replace 'mile'",
+        "Thank the Twelve": "ขอบคุณแด่ทวยเทพ..",
+        "mechanical soldier": "'ทหารจักรกล'",
+        "Azdaja": "พี่สาวของ Varshahn ที่ถูก Golbez จองจำไว้",
+        "Reaper": "คลาสผู้ใช้พลังความมืดจาก Voidsent เรียกสั้นๆว่า 'รีพเปอร์'",
+        "imperial": "ทหารของจักรวรรดิ์",
+        "Antecedent": "ใช้เรียกตำแหน่งผู้นำ Scions เรียกสั้นๆว่า 'หัวหน้า'",
+        "Moogle": "เผ่า ม็อกเกิ้ล ขนขาว น่ารัก มีพลังวิเศษ",
+        "Kupo !": "คำลงท้ายของเผ่า moogle เช่น \"คูโปะ !\"",
+        "็Humble": "อ่อนพลังลง",
+        "222": "แปลสั้นๆว่า '???' ",
+        "<groan>": "อึกก...",
+        "Lamaty'i": "ชื่อเล่นของ Wuk Lamat แปลสั้นๆว่า 'ลามัตตี้'",
+        "Old man": "คำเรียกคนแก่อย่างสนิทสนม สั้นๆว่า 'ลุง'",
+        "Voidsent": "สิ่งมีชีวิตที่หลุดมาจากมิติมืด",
+        "restricted shelves": "ชั้นหนังสือต้องห้าม",
+        "Yok huy": "เผ่ายักษ์",
+        "auracite": "'ออราไซต์'ผลึกที่สามารถจัดเก็บวิญญาณได้",
+        "Warrior of Light": "ผู้กล้าแห่งแสง",
+        "eikon": "สัตว์อสูร ลักษณะเดียวกับ Primal",
+        "tempered": "ผู้ถูกครอบงำ",
+        "Your Grace": "'ฝ่าบาท' ใช้พูดกับชนชั้นสูงหรือกษัตริย์",
+        "Ark": "เรือเหาะสำหรับท่องอวกาศ สร้างใน Shalayan",
+        "Ragnarok": "ชื่อของยานอวกาศ สำหรับเดินทางไปสู่ Ultima Thule",
+        "Warrior of Darkness": "ผู้กล้าจาก The First หรือก็คือ 'Ardbert'",
+        "Azem": "ตำแหน่งเดิมของ Venat (Hydaelyn)",
+        "akasa": "'อะคาสะ' พลังงานภายใน",
+        "Dynamis": "พลังงานที่ขับเคลื่อนด้วยอารมณ์เป็นที่ตั้ง",
+        "mindjack": "เชื่อมจิต",
+        "brands": "การปิดผนึก มักจะเกี่ยวกับ Zodiark",
+        "Teleport": "การวาร์ป",
+        "Teleporter": "เครื่องวาร์ป"
+    },
+    "character_roles": {
+        "Yshtola": "ใช้ภาษาแบบสาวเฟียส เฉลียวฉลาดและมั่นใจในตัวเอง",
+        "Urianger": "ชายนักปราชญ์ ใช้ภาษาซับซ้อน โบราณ สุขุม",
+        "Wuk Lamat": "ใช้ภาษาแบบสาวห้าว หัวช้า แต่เข้มแข็งแบบนักรบ สำเนียงพื้นบ้าน ตื่นเต้นกับสิ่งใหม่ๆเสมอ",
+        "Zoraal Ja": "ใช้ภาษาที่เยือกเย็น แฝงความน่ากลัว โหดร้าย",
+        "Sphene": "ใช้คำพูดราวกับเจ้าหญิง ภาษาแสนน่ารัก แต่แฝงความจริงจังได้เสมอ",
+        "Otis": "พูดจาด้วยสำนวนนักรบที่ภักดีต่ออาณาจักร Alexandria และเจ้าหญิง Sphene",
+        "Koana": "พูดด้วยมาดเจ้าชาย ที่แสนอบอุ่นและเข้มแข็ง",
+        "Gulool Ja": "ใช้ภาษาแบบเด็กเยาว์วัยไร้เดียงสา แต่กล้าหาญ",
+        "G'raha Tia": "ใช้ภาษาที่เป็นมิตร อบอุ่น มีความเป็นผู้นำ ใช้คำสุภาพเสมอ",
+        "Krile": "ใช้ภาษาแบบเนิร์ด นักวิชาการ ละเอียดรอบคอบ",
+        "Erenville": "ใช้ภาษาแบบใจเย็น มีความรับผิดชอบและมุ่งมั่น",
+        "Alisaie": "ใช้ภาษาที่ตรงไปตรงมา กล้าหาญ มุทะลุ ไม่ยอมแพ้",
+        "Alphinaud": "ใช้ภาษาทางการ เนิร์ด ไหวพริบดี มุ่งมั่น",
+        "Emet-Selch": "ใช้ภาษาแบบชายผู้มากประสบการณ์ เย่อหยิ่ง บางเวลาจะแฝงความใจดีแบบเสียมิได้",
+        "EmetSelch": "ใช้ภาษาแบบชายผู้มากประสบการณ์ เย่อหยิ่ง บางเวลาจะแฝงความใจดีแบบเสียมิได้",
+        "Hythlodaeus": "ใช้ภาษานักวิชาการ แฝงมุกตลก ฉลาด ใจดี",
+        "Meteion": "มีสองบุคลิก 1.ใช้ภาษาแบบเด็กสาวต่างดาว ไร้เดียงสา 2.คำพูดไร้จิตวิญญาณและน่ากลัว",
+        "Venat": "ใช้ภาษาอ่อนโยน ทันสมัย และมุ่งมั่นแรงกล้า",
+        "2P": "เป็นหุ่นยนต์ที่ไร้จิตใจ พูดด้วยคำตรงๆไร้อารมณ์",
+        "2B": "แอนดรอยด์ ฉลาด พูดจาสั้นๆ กระชับ เข้มแข็ง",
+        "9S": "แอนดรอยด์หนุ่ม สำเนียงเป็นเด็ก แต่ฉลาด",
+        "Themis": "พูดจาแบบเด็กหนุ่ม ฉลาด สุขุม",
+        "Prishe": "พูดจามั่นใจแบบสาวห้าวหัวร้อน สบถ มีความมั่นใจสูง แอบมีปมด้อยบางอย่างลึกๆ",
+        "Liplu": "พูดจาฉลาด มั่นใจ นอบน้อม",
+        "Shale": "พูดด้วยข้อมูล สำเนียงสาวหล่อ มีไหวพริบ",
+        "Genolt": "พูดจาโผงผาง เหนือจริง",
+        "Crystal Exarch": "ใช้ภาษาที่เป็นมิตร สุขุม มีความเป็นผู้นำ",
+        "ChaiNuzz": "พูดจาภูมิฐาน แต่ขาดความมั่นใจ",
+        "DuliaChai": "สำเนียงชนชั้นสูง ถือตัว ผู้ใหญ่ที่ไร้เดียงดา",
+        "Vauthry": "ชายอ้วนพลุ้ย ชั่วร้าย สำเนียงเหยียดหยาม",
+        "Tesleen": "หญิงสาวที่จิตใจเต็มไปด้วยความเมตตา เข้าใจโลกเป็นอย่างดี",
+        "Lyna": "สาวองค์รักษ์ เข้มแข็ง ห้าวหาญ จงรักภักดีต่อ Crystarium และ Crystal Exarch (ท่านคริสตัล) อย่างลึกซึ้ง",
+        "Estinien": "นักรบมังกรหนุ่ม สำเนียงค่อนข้างโบราณ เฉียบคม มาดแมน บางเวลาที่ไม่จริงจัง อาจดูไม่ประสีประสา",
+        "Gaius": "คำพูดสุขุม ฉลาด ห้วน",
+        "Ranjit": "ชายแก่ สำเนียงจีน ฉลาดแกมโกง เสียดสี",
+        "Minfilia": "หญิงสาวที่ใช้คำพูดอันบริสุทธิ์ ฉลาด",
+        "Feo Ul": "พิกซี่ คำพูดเอาแต่ใจ เหวี่ยงวีน แต่เป็นมิตร",
+        "Oracle of Light": "คำพูดสุขุม ผู้แบกภาระอันยิ่งใหญ่ ในตำแหน่ง 'มิโกะแห่งแสง'",
+        "Gosetsu": "ซามูไรสูงวัย ปากร้าย ใจดี",
+        "Hien": "ซามูไรหนุ่ม ผู้นำหมู่บ้าน คำพูดฉลาด กล้าหาญแบบซามูไร",
+        "Asahi": "ชายเจ้าเล่ห์ พูดจาฉลาด เมื่อพูดว่า sister นั่นคือกำลังเรียก 'พี่สาว' ของเขา",
+        "Vow of Resolve Gulool Ja Ja": "พูดจาน่าเกรงขาม แข็งแกร่ง",
+        "Minstreling Wanderer": "ชายนักกวี ใช้คำพูดที่ลุ่มลึกเพื่อเล่าเรื่องราวที่ยิ่งใหญ่",
+        "LueReeq": "แมวหนุ่มผู้ฟุ่มเฟือย พูดคุยด้วยความมุ่งมั่น ตื่นเต้น ไร้เดียงสา",
+        "Grenoldt": "พูดจาสุขุม นุ่มลึก เป็นสามีของ Mowen",
+        "Mowen": "แม่ค้าสาวชนชั้นสูง พูดจาไฮโซ นุ่มนวล พรรณา, เป็นภรรยาของช่างตีดาบ Grenoldt",
+        "Hydaelyn": "พูดด้วยสำเนียงสุขุม ฉลาด ลุ่มลึก อบอุ่นและห่วงใย",
+        "Matoya": "สำเนียงยายแก่ จอมขมังเวทย์ผู้หยั่งรู้ ปากร้ายใจดี",
+        "Varshahn": "พูดจาสุขุม ฉลาด กล้าหาญ",
+        "Zero": "สาวหล่อ พูดจาเย็นชา ไม่ค่อยเข้าใจวิถีมนุษย์",
+        "Golbez": "คำพูดเยือกเย็น บาดลึก แข็งแกร่ง",
+        "Azdaja": "ใช้ภาษาโบราณ สำเนียงเศร้า",
+        "Jullus": "สำเนียงห้วน แบบทหาร แต่เป็นมิตร",
+        "Ryne": "สาวน้อยที่เข้มแข็ง มุ่งมั่น พูดจาอบอุ่น มีความหวัง",
+        "Barbariccia": "พูดจายโส ท้าทาย มีความโหดเหี้ยม",
+        "Rubicante": "พูดจาสุขุม หยิ่งในเกียรติแห่งการต่อสู้",
+        "Scarmiglione": "พูดแบบปีศาจ แฝงความวิปลาส",
+        "Cagnazzo": "เสียงทุ้ม หนักแน่น หยาบกระด้าง",
+        "Fourchenault": "พูดจาแบบนักวิชาการ สุขุม มีหลักการ น่าเกรงขาม",
+        "Ameliance": "พูดจาอ่อนโยน สนุกสนาน แบบผู้ดี",
+        "Nidhana": "พูดแบบนักวิจัย ตื่นเต้นกับความรู้",
+        "Zenos": "น้ำเ��ียงเลือดเย็น แผนการร้าย กระหายการต่อสู้",
+        "Zenos viator Galvus": "น้ำเสียงเลือดเย็น แผนการร้าย กระหายการต่อสู้",
+        "Zenos yae Galvus": "พูดด้วยน้ำเสียงเยือกเย็น ท้าทาย กระหายการต่อสู้",
+        "Maxima": "พูดจานอบน้อม สุขุม มีความเข้าใจในสถานการณ์",
+        "Livingway": "พูดจาสดใส อยากรู้อยากเห็น มุ่งมั่นช่วยเหลือ",
+        "Puddingway": "พูดด้วยความร่าเริง แปลกใหม่ สนใจเรื่องอาหาร",
+        "Jammingway": "พูดจาเร็ว กระตือรือร้น รักการสื่อสาร",
+        "Montichaigne": "นักวิชาการขบถ พูดจาแหลมคม",
+        "Claudien": "พูดจาแบบนักวิจัย อยากรู้อยากเห็น สุภาพ",
+        "Seto": "พูดอย่างซื่อสัตย์ ภักดี ซึ้งในความทรงจำ",
+        "Beq Lugg": "พูดจาแบบนักปราชญ์ ขี้ระแวง",
+        "Tataru": "พูดจาสดใส อบอุ่น ห่วงใย ฉลาดในการจัดการ",
+        "Quintus van Cinna": "พูดด้วยน้ำเสียงเยือกเย็น เคร่งขรึม แบบขุนศึก",
+        "Fandaniel": "พูดจาเสียดเย้ย แฝงความวิปลาสและสิ้นหวัง",
+        "Kuplo Kopp": "พูดจาน่ารัก เข้าใจยาก ขี้เล่น",
+        "Raya-O-Senna": "สุภาพ น่ารัก ขี้เล่น, เป็นน้องสาวที่เคารพพี่สาวเสมอ",
+        "Kan-E-Senna": "คำพูดอ่อนโยน มีความเป็นผู้นำ เข้มแข็ง",
+        "Yda": "สำเสียงผู้หญิงห้าว แอ็คทีฟ สนุกสนาน",
+        "???": "พูดจาลึกลับ แบบยังไม่เผยตัวตน",
+        "Ketenramm": "หนักแน่น แข็งแกร่ง ผู้ใหญ่ใจดี",
+        "Cid": "พูดจาหลักแหลม เข้าใจเกี่ยวกับกลไกต่างๆเป็นอย่างดี",
+        "Rammbroes": "พูดจาแบบนักโบราณคดี ผู้มีประสบการณ์",
+        "Nero tol Scaeva": "พูดจาเย่อหยิ่ง ฉลาด เป็นปริศนา",
+        "Xande": "สำเนียงโบราณ เย่อหยิ่ง เจ้าสำราญ และ ละโมบ",
+        "Vorporlor": "คำพูดท้องถิ่นของยักษ์ หยาบและเข้าใจยาก",
+        "Gurfurlur": "พูดภาษายักษ์ ห้วน โบราณ",
+        "Raubahn": "พูดสำเนียงทหารองครักษ์ หนักแน่น กระชับ แข็งกร้าว",
+        "Runar": "ชายหนุ่ม ผู้นอบน้อม อ่อนไหว",
+        "Elidibus": "สำเนียงชั่วร้าย หว่านล้อม แอบแฝง",
+        "Pipin": "พูดจาเข้มแข็ง หนักแน่น แบบมีกลยุทธ",
+        "Lyse": "สำเนียงเข้มแข็ง มียุทธศาสตร์",
+        "Aymeric": "สุขุมนุ่มลึก ฉลาด หนักแน่น",
+        "Amon": "พูดจาแบบศิลปิน ช่างฝัน ทะเยอทะยาน",
+        "Hancock": "พูดจาแบบพนักงานขาย โน้มนาวเก่ง",
+        "Soroban": "ภาษาชาวบาดาล นักสำรวจ",
+        "Yugiri": "ภาษานินจาโบราณ น้ำเสียงเยือกเย็น มุทะลุ กล้าหาญ",
+        "Yotsuyu": "มี 2 บุคลิก : เย็นชา, ไร้เดียงสา",
+        "Solus zos Galvus": "ฉลาดแกมโกง แผนชั่วร้าย เย่อหยิ่ง",
+        "Papalymo": "พูดจามีหลักการ พร้อมช่วย เสียสละ",
+        "Merlwyb": "หญิงแกร่ง ผู้นำพูดจาเข็มแข็ง เด็ดขาด",
+        "Tiamat": "พูดภาษามังกรโบราณ เก่าแก่เข้าใจยาก พูดช้า",
+        "Lucia": "อัศวินหญิง น้ำเสียงเข้มแข็ง มุ่งมั่น",
+        "Emmanellain": "สำเนียงลูกขุนนาง ไร้เดียงสา หลงตัวเอง",
+        "Sicard": "สำเนียงโจรสลัด มุทะลุ ห้วน ยียวน",
+        "Zodiark": "คำพูดยิ่งใหญ่ โบราณ หลงอำนาจ",
+        "Louisoix": "จอมเวทย์ผู้ปราดเปรื่อง ฉลาด ยิ่งใหญ่ เข้มแข็ง อบอุ่น เสียสละ",
+        "Cloud": "คำพูดเยือกเย็น ฉลาด กระชับ ซึนเดเระ",
+        "Sephiroth": "คำพูดเยือกเย็น น่าสะพรึงกลัว กระชับ"
+    },
+    "word_fixes": {
+        "namel": "name !",
+        "Well;": "Well..",
+        "Im": "I'm",
+        "$": "s",
+        "--": "...",
+        "-_": "...",
+        "_": "...",
+        "Wait_I": "Wait... I",
+        "tis": "'tis",
+        "Tis": "'Tis",
+        "Twas": "'Twas",
+        "|": "i",
+        "Sphenel": "Shpene",
+        "__": "...",
+        "22": "???",
+        "222": "???",
+        "22?": "???",
+        "222?": "???",
+        "zp": "2p",
+        "ZPI": "2P",
+        "ZB": "2B",
+        "95": "9S",
+        "Tll": "I'll",
+        "lll": "I'll",
+        "tll": "I'll",
+        "1ll": "i'll",
+        "-": "...",
+        "'ll": "will",
+        "1'll": "I will",
+        "FII": "I will",
+        "Araneal": "Aranea !",
+        "Araneal!": "Aranea !",
+        "mel": "me !",
+        "Vauthryl": "Vauthry !",
+        "Feo UI": "Feo Ul",
+        "Feo Ui": "Feo Ul",
+        "Eorzeal": "Eorzea !",
+        "Ahal": "Aha !",
+        "Hahal": "Haha !",
+        "Valigarmandal": "Valigarmanda !!",
+        "Yshtolal": "Y'shtola !",
+        "Yshtola": "Y'shtola",
+        "Hal": "Ha !",
+        "Kupol": "Kupo !",
+        "Graha Tia": "G'raha Tia",
+        "Graha Tial": "G'raha Tia",
+        "Graha": "G'raha Tia",
+        "Lamatyi": "Lamaty'i",
+        "Lamatyil": "Lamaty'i !",
+        "Papal": "PaPa !",
+        "Chiefl": "Chief !",
+        "Biggsl": "Biggs !",
+        "Wedgel": "Wedge !",
+        "Xandel": "Xande !",
+        "Nerol": "Nero !",
+        "Lugg Beq": "Beq Lugg",
+        "Zenos yae Galvvus": "Zenos yae Galvus",
+        "KanESenna": "Kan-E-Senna",
+        "1": "i",
+        "MI": "I'll",
+        "M|": "I'll",
+        "!,": "!",
+        ".,": ".",
+        ",,": ",",
+        "z0s": "zos",
+        "207": "zos",
+        "0": "o",
+        "Warrior 0f Darkness": "Warrior of Darkness",
+        "Alisaiel": "Alisaie !",
+        "EmetSelch": "Emet-Selch",
+        "50": "so",
+        "Seohiroth": "Sephiroth"
+    }
+}

advance_ui.py

@@ -0,0 +1,580 @@
+import tkinter as tk
+from tkinter import ttk, messagebox
+import logging
+from loggings import LoggingManager
+from appearance import appearance_manager
+
+
+class AdvanceUI:
+    def __init__(
+        self, parent, settings, apply_settings_callback, ocr_toggle_callback=None
+    ):
+        self.parent = parent
+        self.settings = settings
+        self.apply_settings_callback = apply_settings_callback
+        self.ocr_toggle_callback = ocr_toggle_callback
+        self.advance_window = None
+        self.is_changed = False
+        self.create_advance_window()
+
+    def check_screen_resolution(self):
+        """ตรวจสอบขนาดหน้าจอที่ตั้งค่าในวินโดว์
+        Returns:
+            dict: ผลการตรวจสอบ
+        """
+        try:
+            # 1. ใช้ win32api ซึ่งเป็นวิธีที่เชื่อถือได้มากกว่า
+            import win32api
+            import win32gui
+            import win32con
+
+            # 2. ดึงค่าความละเอียดจริงจากการตั้งค่า Windows
+            dm = win32api.EnumDisplaySettings(None, win32con.ENUM_CURRENT_SETTINGS)
+            current_width = dm.PelsWidth  # ความกว้างจริง
+            current_height = dm.PelsHeight  # ความสูงจริง
+
+            # 3. ดึงค่าที่ตั้งไว้ใน settings มาเทียบ
+            expected_resolution = self.settings.get("screen_size", "2560x1440")
+            expected_width, expected_height = map(int, expected_resolution.split("x"))
+
+            # 4. เปรียบเทียบค่า
+            if current_width != expected_width or current_height != expected_height:
+                return {
+                    "is_valid": False,
+                    "message": (
+                        f"Screen resolution does not match settings!\n"
+                        f"Current: {current_width}x{current_height}\n"
+                        f"Settings: {expected_width}x{expected_height}\n"
+                        f"Please set your screen resolution first."
+                    ),
+                    "current": f"{current_width}x{current_height}",
+                    "expected": expected_resolution,
+                }
+
+            return {
+                "is_valid": True,
+                "current": f"{current_width}x{current_height}",
+                "expected": expected_resolution,
+            }
+
+        except Exception as e:
+            print(f"Error checking screen resolution: {e}")
+            return {
+                "is_valid": False,
+                "message": f"Error checking resolution: {str(e)}",
+                "current": "Unknown",
+                "expected": "Unknown",
+            }
+
+    def create_advance_window(self):
+        """สร้างหน้าต่าง Advanced Settings"""
+        if self.advance_window is None or not self.advance_window.winfo_exists():
+            self.advance_window = tk.Toplevel(self.parent)
+            self.advance_window.title("Advanced Settings")
+            self.advance_window.geometry("360x400")  # เพิ่มความสูงรองรับปุ่มใหม่
+            self.advance_window.overrideredirect(True)
+            appearance_manager.apply_style(self.advance_window)
+
+            # Screen Size Settings
+            screen_frame = tk.LabelFrame(
+                self.advance_window,
+                text="Screen Resolution",
+                bg=appearance_manager.bg_color,
+                fg="white",
+            )
+            screen_frame.pack(fill=tk.X, padx=10, pady=5)
+
+            # Current Resolution Display
+            current_res_frame = tk.Frame(screen_frame, bg=appearance_manager.bg_color)
+            current_res_frame.pack(fill=tk.X, padx=5, pady=2)
+            tk.Label(
+                current_res_frame,
+                text="Current:",
+                bg=appearance_manager.bg_color,
+                fg="white"
+            ).pack(side=tk.LEFT)
+            self.current_res_label = tk.Label(
+                current_res_frame,
+                text="Detecting...",
+                bg=appearance_manager.bg_color,
+                fg="#2ECC71"
+            )
+            self.current_res_label.pack(side=tk.RIGHT, padx=5)
+
+            # Width dropdown
+            width_frame = tk.Frame(screen_frame, bg=appearance_manager.bg_color)
+            width_frame.pack(fill=tk.X, padx=5, pady=2)
+            tk.Label(
+                width_frame,
+                text="Set Width:",
+                bg=appearance_manager.bg_color,
+                fg="white"
+            ).pack(side=tk.LEFT)
+            self.screen_width_var = tk.StringVar()
+            self.width_combo = ttk.Combobox(
+                width_frame,
+                values=["1920", "2560", "3440", "3840"],
+                textvariable=self.screen_width_var,
+                width=8,
+            )
+            self.width_combo.pack(side=tk.RIGHT, padx=5)
+
+            # Height dropdown
+            height_frame = tk.Frame(screen_frame, bg=appearance_manager.bg_color)
+            height_frame.pack(fill=tk.X, padx=5, pady=2)
+            tk.Label(
+                height_frame,
+                text="Set Height:",
+                bg=appearance_manager.bg_color,
+                fg="white"
+            ).pack(side=tk.LEFT)
+            self.screen_height_var = tk.StringVar()
+            self.height_combo = ttk.Combobox(
+                height_frame,
+                values=["1080", "1440", "1600", "2160"],
+                textvariable=self.screen_height_var,
+                width=8,
+            )
+            self.height_combo.pack(side=tk.RIGHT, padx=5)
+
+            # Screen Control Buttons
+            screen_btn_frame = tk.Frame(screen_frame, bg=appearance_manager.bg_color)
+            screen_btn_frame.pack(fill=tk.X, padx=5, pady=5)
+            
+            self.apply_res_button = ttk.Button(
+                screen_btn_frame,
+                text="Apply Resolution",
+                command=self.apply_resolution
+            )
+            self.apply_res_button.pack(side=tk.LEFT, padx=2)
+            
+            self.check_res_button = ttk.Button(
+                screen_btn_frame,
+                text="Check",
+                command=self.check_resolution_status
+            )
+            self.check_res_button.pack(side=tk.RIGHT, padx=2)
+
+            # Display Scale Settings
+            scale_frame = tk.LabelFrame(
+                self.advance_window,
+                text="Display Scale",
+                bg=appearance_manager.bg_color,
+                fg="white",
+            )
+            scale_frame.pack(fill=tk.X, padx=10, pady=5)
+
+            # Scale info
+            scale_info_frame = tk.Frame(scale_frame, bg=appearance_manager.bg_color)
+            scale_info_frame.pack(fill=tk.X, padx=5, pady=5)
+            tk.Label(
+                scale_info_frame,
+                text="Current Scale:",
+                bg=appearance_manager.bg_color,
+                fg="white",
+            ).pack(side=tk.LEFT)
+            self.scale_label = tk.Label(
+                scale_info_frame,
+                text="Detecting...",
+                bg=appearance_manager.bg_color,
+                fg="#2ECC71",
+            )
+            self.scale_label.pack(side=tk.RIGHT, padx=5)
+
+            # Scale buttons
+            scale_button_frame = tk.Frame(scale_frame, bg=appearance_manager.bg_color)
+            scale_button_frame.pack(fill=tk.X, padx=5, pady=5)
+            self.scale_button = ttk.Button(
+                scale_button_frame,
+                text="Open Display Settings",
+                command=self.open_display_settings,
+            )
+            self.scale_button.pack(side=tk.LEFT, padx=5)
+            self.detect_button = ttk.Button(
+                scale_button_frame,
+                text="Check Scale",
+                command=self.check_display_scale,
+            )
+            self.detect_button.pack(side=tk.RIGHT, padx=5)
+
+            # OCR Settings
+            ocr_frame = tk.LabelFrame(
+                self.advance_window,
+                text="OCR Settings",
+                bg=appearance_manager.bg_color,
+                fg="white",
+            )
+            ocr_frame.pack(fill=tk.X, padx=10, pady=5)
+
+            # GPU Toggle
+            gpu_frame = tk.Frame(ocr_frame, bg=appearance_manager.bg_color)
+            gpu_frame.pack(fill=tk.X, padx=5, pady=5)
+            tk.Label(
+                gpu_frame,
+                text="OCR Processing:",
+                bg=appearance_manager.bg_color,
+                fg="white",
+            ).pack(side=tk.LEFT)
+
+            self.gpu_var = tk.BooleanVar(
+                value=self.settings.get("use_gpu_for_ocr", False)
+            )
+            self.gpu_switch = ttk.Checkbutton(
+                gpu_frame,
+                text="Use GPU",
+                style="Switch.TCheckbutton",
+                variable=self.gpu_var,
+                command=self.toggle_gpu,
+            )
+            self.gpu_switch.pack(side=tk.RIGHT, padx=5)
+
+            # Save Button
+            self.save_button = appearance_manager.create_styled_button(
+                self.advance_window, "Save", self.save_settings, hover_bg="#404040"
+            )
+            self.save_button.pack(pady=10)
+
+            # Close Button
+            close_button = appearance_manager.create_styled_button(
+                self.advance_window, "X", self.close, hover_bg="#404040"
+            )
+            close_button.place(x=5, y=5, width=20, height=20)
+
+            # Bind Events
+            self.width_combo.bind("<<ComboboxSelected>>", self.on_change)
+            self.height_combo.bind("<<ComboboxSelected>>", self.on_change)
+            self.gpu_var.trace_add("write", lambda *args: self.on_change(None))
+
+            # Window Movement
+            self.advance_window.bind("<Button-1>", self.start_move)
+            self.advance_window.bind("<ButtonRelease-1>", self.stop_move)
+            self.advance_window.bind("<B1-Motion>", self.do_move)
+
+            # Load Current Settings
+            self.load_current_settings()
+
+            # ซ่อนหน้าต่างตอนเริ่มต้น
+            self.advance_window.withdraw()
+
+            # ตรวจสอบ scale หลังจากสร้างหน้าต่างเสร็จ
+            self.advance_window.after(1000, self.check_display_scale)
+
+    def apply_resolution(self):
+        """Apply the selected screen resolution"""
+        try:
+            new_width = self.screen_width_var.get()
+            new_height = self.screen_height_var.get()
+            new_resolution = f"{new_width}x{new_height}"
+            
+            # บันทึกค่าใหม่
+            self.settings.set("screen_size", new_resolution)
+            
+            # ตรวจสอบการตั้งค่าใหม่
+            self.check_resolution_status()
+            
+            # อัพเดท UI
+            self.apply_res_button.config(state="disabled")
+            self.advance_window.after(2000, lambda: self.apply_res_button.config(state="normal"))
+            
+        except Exception as e:
+            messagebox.showerror("Error", f"Failed to apply resolution: {str(e)}")
+    
+    def check_resolution_status(self):
+        """ตรวจสอบและแสดงสถานะความละเอียดหน้าจอ"""
+        resolution_info = self.check_screen_resolution()
+        self.current_res_label.config(text=resolution_info["current"])
+        
+        if not resolution_info["is_valid"]:
+            self.current_res_label.config(fg="#FF6B6B")  # สีแดง
+        else:
+            self.current_res_label.config(fg="#2ECC71")  # สีเขียว
+    
+    def validate_screen_resolution(self):
+        """ตรวจสอบความละเอียดหน้าจอโดยคำนึงถึง Display Scale
+        Returns:
+            dict: ผลการตรวจสอบ {"is_valid": bool, "message": str}
+        """
+        try:
+            # 1. ตรวจสอบ Scale ปัจจุบัน
+            import ctypes
+
+            user32 = ctypes.windll.user32
+            current_dpi = user32.GetDpiForSystem()
+            current_scale = current_dpi / 96  # 96 is default DPI
+
+            # 2. ดึงค่าความละเอียดจริงของหน้าจอ
+            actual_width = self.advance_window.winfo_screenwidth()
+            actual_height = self.advance_window.winfo_screenheight()
+
+            # 3. คำนวณความละเอียดที่แท้จริงโดยหารด้วย scale
+            real_width = int(actual_width / current_scale)
+            real_height = int(actual_height / current_scale)
+
+            # 4. ดึงค่าที่ตั้งไว้ใน settings
+            set_resolution = self.settings.get("screen_size", "2560x1440")
+            set_width, set_height = map(int, set_resolution.split("x"))
+
+            # 5. เปรียบเทียบค่าที่คำนวณได้
+            if (
+                abs(real_width - set_width) > 50 or abs(real_height - set_height) > 50
+            ):  # ให้ค่าคลาดเคลื่อนได้นิดหน่อย
+                return {
+                    "is_valid": False,
+                    "message": (
+                        f"Screen resolution mismatch!\n"
+                        f"Current: {real_width}x{real_height} (Scale: {int(current_scale * 100)}%)\n"
+                        f"Expected: {set_width}x{set_height}\n"
+                        f"Please check your resolution settings."
+                    ),
+                    "current": f"{real_width}x{real_height}",
+                    "expected": set_resolution,
+                    "scale": current_scale,
+                }
+
+            return {
+                "is_valid": True,
+                "message": "Screen resolution matched",
+                "current": f"{real_width}x{real_height}",
+                "expected": set_resolution,
+                "scale": current_scale,
+            }
+
+        except Exception as e:
+            return {
+                "is_valid": False,
+                "message": f"Error checking resolution: {e}",
+                "current": "Unknown",
+                "expected": "Unknown",
+                "scale": 1.0,
+            }
+
+    def check_display_scale(self):
+        """ตรวจสอบ Display Scale หลังจากขนาดหน้าจอถูกต้องแล้ว"""
+        try:
+            # 1. ตรวจสอบความละเอียดหน้าจอก่อน
+            resolution_check = self.check_screen_resolution()
+            if not resolution_check["is_valid"]:
+                self.show_resolution_warning(resolution_check)
+                self.scale_label.config(text="Fix Resolution")
+                return None
+
+            # 2. ถ้าความละเอียดถูกต้อง ค่อยตรวจสอบ Scale
+            import ctypes
+
+            user32 = ctypes.windll.user32
+            current_dpi = user32.GetDpiForSystem()
+            current_scale = round(current_dpi / 96, 2)  # 96 is default DPI
+
+            # อัพเดท label แสดงค่า scale
+            self.scale_label.config(text=f"{int(current_scale * 100)}%")
+
+            # ตรวจสอบว่าต้องแจ้งเตือนหรือไม่
+            saved_scale = self.settings.get("display_scale")
+            if saved_scale is None or abs(current_scale - saved_scale) > 0.01:
+                # ส่งข้อมูลขนาดหน้าจอที่ถูกต้องไปด้วย
+                self.show_scale_warning(current_scale, resolution_check["current"])
+                self.settings.set("display_scale", current_scale)
+
+            return current_scale
+
+        except Exception as e:
+            print(f"Error checking display scale: {e}")
+            self.scale_label.config(text="Error")
+            return None
+
+    def show_resolution_warning(self, resolution_info):
+        """แสดงคำเตือนเมื่อขนาดหน้าจอไม่ตรง"""
+        dialog = tk.Toplevel(self.advance_window)
+        dialog.title("Screen Resolution Check")
+        dialog.configure(bg=appearance_manager.bg_color)
+        dialog.geometry("400x200")
+        dialog.overrideredirect(True)
+
+        message = resolution_info["message"]
+
+        tk.Label(
+            dialog,
+            text=message,
+            bg=appearance_manager.bg_color,
+            fg="#FF6B6B",  # สีแดงอ่อน
+            justify=tk.LEFT,
+            padx=20,
+            pady=10,
+        ).pack(expand=True)
+
+        btn = tk.Button(
+            dialog,
+            text="Open Display Settings",
+            command=lambda: [dialog.destroy(), self.open_display_settings()],
+            bg="#2A2A2A",
+            fg="white",
+            pady=5,
+        )
+        btn.pack(pady=10)
+
+        # จัดตำแหน่งกลางหน้าจอ
+        dialog.update_idletasks()
+        width = dialog.winfo_width()
+        height = dialog.winfo_height()
+        x = (dialog.winfo_screenwidth() // 2) - (width // 2)
+        y = (dialog.winfo_screenheight() // 2) - (height // 2)
+        dialog.geometry(f"+{x}+{y}")
+
+        dialog.transient(self.advance_window)
+        dialog.grab_set()
+
+    def open_display_settings(self):
+        """เปิดหน้าต่าง Display Settings ของ Windows"""
+        import os
+
+        os.system("start ms-settings:display")
+
+    def show_scale_warning(self, current_scale):
+        """แสดง Dialog เตือนให้ตรวจสอบ Display Scale"""
+        dialog = tk.Toplevel(self.advance_window)
+        dialog.title("Display Scale Check")
+        dialog.configure(bg=appearance_manager.bg_color)
+        dialog.geometry("400x200")
+        dialog.overrideredirect(True)  # ไม่แสดง title bar
+
+        message = (
+            f"Current Display Scale: {int(current_scale * 100)}%\n\n"
+            "Windows Display Settings will open automatically.\n"
+            "Please check if the scale matches your preference.\n\n"
+            "Recommended: 100% for optimal OCR performance."
+        )
+
+        tk.Label(
+            dialog,
+            text=message,
+            bg=appearance_manager.bg_color,
+            fg="white",
+            justify=tk.LEFT,
+            padx=20,
+            pady=10,
+        ).pack(expand=True)
+
+        def on_ok():
+            dialog.destroy()
+            self.open_display_settings()
+
+        tk.Button(
+            dialog, text="OK", command=on_ok, bg="#2A2A2A", fg="white", pady=5
+        ).pack(pady=10)
+
+        dialog.transient(self.advance_window)
+        dialog.grab_set()
+
+        # จัดตำแหน่งกลางหน้าจอ
+        dialog.update_idletasks()
+        width = dialog.winfo_width()
+        height = dialog.winfo_height()
+        x = (dialog.winfo_screenwidth() // 2) - (width // 2)
+        y = (dialog.winfo_screenheight() // 2) - (height // 2)
+        dialog.geometry(f"+{x}+{y}")
+
+    def load_current_settings(self):
+        """โหลดค่าปัจจุบันจาก settings"""
+        screen_size = self.settings.get("screen_size", "2560x1440")
+        width, height = screen_size.split("x")
+        self.screen_width_var.set(width)
+        self.screen_height_var.set(height)
+        self.gpu_var.set(self.settings.get("use_gpu_for_ocr", False))
+        self.is_changed = False
+        self.update_save_button()
+
+    def toggle_gpu(self):
+        """Toggle GPU usage for OCR"""
+        try:
+            current_state = self.gpu_var.get()
+            self.settings.set_gpu_for_ocr(current_state)
+            if self.ocr_toggle_callback:
+                self.ocr_toggle_callback()
+            self.on_change(None)
+        except Exception as e:
+            messagebox.showerror("Error", f"Failed to toggle GPU setting: {str(e)}")
+
+    def save_settings(self):
+        """Save current settings"""
+        try:
+            # Save screen resolution
+            screen_size = (
+                f"{self.screen_width_var.get()}x{self.screen_height_var.get()}"
+            )
+            self.settings.set_screen_size(screen_size)
+
+            # Save GPU setting
+            use_gpu = self.gpu_var.get()
+            self.settings.set_gpu_for_ocr(use_gpu)
+
+            print(f"\n=== Settings Saved ===")
+            print(f"Screen Size: {screen_size}")
+            print(f"Use GPU for OCR: {use_gpu}")
+            print("====================\n")
+
+            new_settings = {"screen_size": screen_size, "use_gpu_for_ocr": use_gpu}
+
+            if callable(self.apply_settings_callback):
+                self.apply_settings_callback(new_settings)
+
+            self.save_button.config(text="Saved!")
+            self.advance_window.after(
+                2000, lambda: self.save_button.config(text="Save")
+            )
+            self.is_changed = False
+
+        except Exception as e:
+            messagebox.showerror("Error", f"Failed to save settings: {str(e)}")
+
+    def on_change(self, event):
+        """Called when any setting is changed"""
+        self.is_changed = True
+        self.update_save_button()
+
+    def update_save_button(self):
+        """Update save button state based on changes"""
+        self.save_button.config(text="SAVE" if self.is_changed else "Save")
+
+    def open(self):
+        """Show the advanced settings window"""
+        if not self.advance_window.winfo_viewable():
+            # Position window
+            x = self.parent.winfo_x() + self.parent.winfo_width() + 10
+            y = self.parent.winfo_y()
+            self.advance_window.geometry(f"+{x}+{y}")
+
+            # Show window
+            self.advance_window.deiconify()
+            self.advance_window.lift()
+            self.advance_window.attributes("-topmost", True)
+
+            # Reset state
+            self.load_current_settings()
+            self.is_changed = False
+            self.update_save_button()
+
+    def close(self):
+        """Hide the advanced settings window"""
+        if self.advance_window and self.advance_window.winfo_exists():
+            self.advance_window.withdraw()
+            self.is_changed = False
+            self.save_button.config(text="Save")
+
+    def start_move(self, event):
+        """Start window drag operation"""
+        self.x = event.x
+        self.y = event.y
+
+    def stop_move(self, event):
+        """End window drag operation"""
+        self.x = None
+        self.y = None
+
+    def do_move(self, event):
+        """Handle window dragging"""
+        if hasattr(self, "x") and hasattr(self, "y"):
+            deltax = event.x - self.x
+            deltay = event.y - self.y
+            x = self.advance_window.winfo_x() + deltax
+            y = self.advance_window.winfo_y() + deltay
+            self.advance_window.geometry(f"+{x}+{y}")

api_manager.py

@@ -0,0 +1,153 @@
+import os
+import openai
+import time
+import json
+import logging
+from dotenv import load_dotenv
+
+class APIManager:
+    def __init__(self):
+        # ตั้งค่า logging
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(levelname)s - %(message)s'
+        )
+        
+        self.config_file = 'api_config.json'
+        self.load_config()
+        self.initialize_openai()
+
+    def load_config(self):
+        """โหลดหรือสร้าง config file"""
+        if os.path.exists(self.config_file):
+            try:
+                with open(self.config_file, 'r', encoding='utf-8') as f:
+                    self.config = json.load(f)
+            except Exception as e:
+                logging.error(f"Error loading config: {e}")
+                self.config = self._create_default_config()
+        else:
+            self.config = self._create_default_config()
+            self.save_config()
+
+    def _create_default_config(self):
+        """สร้าง config เริ่มต้น"""
+        return {
+            'last_reset': time.time(),
+            'api_key': os.getenv('OPENAI_API_KEY', ''),
+            'status': 'unknown'
+        }
+
+    def save_config(self):
+        """บันทึก config"""
+        try:
+            with open(self.config_file, 'w', encoding='utf-8') as f:
+                json.dump(self.config, f, indent=4, ensure_ascii=False)
+        except Exception as e:
+            logging.error(f"Failed to save config: {e}")
+
+    def initialize_openai(self):
+        """เริ่มต้นการใช้งาน OpenAI"""
+        load_dotenv()
+        current_key = os.getenv('OPENAI_API_KEY')
+        if current_key:
+            openai.api_key = current_key
+            self.config['api_key'] = current_key
+            self.save_config()
+
+    def reset_api_key(self):
+        """รีเซ็ต API key โดยโหลดจาก .env ใหม่"""
+        print("\nกำลังรีเซ็ต API key...")
+        try:
+            # รีโหลด .env file
+            load_dotenv()
+            new_key = os.getenv('OPENAI_API_KEY')
+            
+            if not new_key:
+                raise ValueError("ไม่พบ API key ใน .env file")
+            
+            if new_key != self.config['api_key']:
+                openai.api_key = new_key
+                self.config['api_key'] = new_key
+                self.config['last_reset'] = time.time()
+                self.save_config()
+                print("✓ รีเซ็ต API key สำเร็จ")
+                return True
+            else:
+                print("! API key ไม่มีการเปลี่ยนแปลง (key เดิม)")
+                return False
+                
+        except Exception as e:
+            print(f"✗ ไม่สามารถรีเซ็ต API key: {e}")
+            return False
+
+    def check_api_status(self):
+        """ตรวจสอบสถานะ API key"""
+        print("\nกำลังตรวจสอบ API key...")
+        try:
+            response = openai.ChatCompletion.create(
+                model="gpt-3.5-turbo",
+                messages=[{"role": "user", "content": "test"}],
+                max_tokens=1
+            )
+            self.config['status'] = 'active'
+            self.save_config()
+            print("✓ API key ใช้งานได้")
+            return True
+        except Exception as e:
+            error_msg = str(e)
+            if 'insufficient_quota' in error_msg:
+                status = "insufficient quota"
+                print("✗ API key เครดิตหมด")
+            elif 'invalid_api_key' in error_msg:
+                status = "invalid key"
+                print("✗ API key ไม่ถูกต้อง")
+            else:
+                status = "error"
+                print(f"✗ เกิดข้อผิดพลาด: {error_msg}")
+            
+            self.config['status'] = status
+            self.save_config()
+            return False
+
+    def show_status(self):
+        """แสดงข้อมูลสถานะทั้งหมด"""
+        print("\n=== สถานะ API ===")
+        print(f"สถานะ: {self.config.get('status', 'unknown')}")
+        last_reset = time.ctime(self.config.get('last_reset', 0))
+        print(f"รีเซ็ตล่าสุด: {last_reset}")
+        
+        # แสดงส่วนท้ายของ API key
+        api_key = self.config.get('api_key', '')
+        if api_key:
+            visible_part = f"...{api_key[-4:]}"
+            print(f"API key: {visible_part}")
+        else:
+            print("API key: ไม่พบ key")
+
+def main():
+    api_manager = APIManager()
+    
+    while True:
+        print("\n=== จัดการ OpenAI API ===")
+        print("1. รีเซ็ต API key")
+        print("2. ตรวจสอบสถานะ API")
+        print("3. แสดงข้อมูลสถานะ")
+        print("0. ออกจากโปรแกรม")
+        
+        choice = input("\nเลือกคำสั่ง (0-3): ").strip()
+        
+        if choice == '1':
+            api_manager.reset_api_key()
+        elif choice == '2':
+            api_manager.check_api_status()
+        elif choice == '3':
+            api_manager.show_status()
+        elif choice == '0':
+            print("\nจบการทำงาน")
+            break
+        else:
+            print("\n! โปรดเลือกคำสั่งที่ถูกต้อง")
+
+if __name__ == "__main__":
+    main()

appearance.py

@@ -0,0 +1,216 @@
+import tkinter as tk
+from tkinter import font as tkfont
+from tkinter import ttk
+import logging
+
+logging.basicConfig(level=logging.INFO)
+
+class AppearanceManager:
+    def __init__(self):
+        self.bg_color = "#2c2c2c"
+        self.fg_color = "white"
+        self.highlight_color = "yellow"
+        self.opacity = 0.9
+        self.font_name = "Nasalization Rg"
+        self.font_size = 12
+        self.letter_spacing = 3
+        self.button_border_width = 1
+        self.button_style = {
+            "bg": self.bg_color,
+            "fg": self.fg_color,
+            "relief": tk.FLAT,
+            "bd": self.button_border_width,
+            "highlightthickness": self.button_border_width,
+            "highlightbackground": self.fg_color,
+            "activebackground": self.bg_color,
+            "activeforeground": self.fg_color,
+        }
+        self.custom_font = None
+
+    # เพิ่มเมธอดในคลาส AppearanceManager:
+    def update_bg_color(self, new_color):
+        """Update background color and related styles"""
+        self.bg_color = new_color
+        self.button_style.update({
+            "bg": new_color,
+            "activebackground": new_color
+        })
+        
+    def apply_bg_color(self, widget):
+        """Apply current background color to widget"""
+        widget.configure(bg=self.bg_color)    
+
+    def load_custom_font(self, root):
+        try:
+            self.custom_font = tkfont.Font(family=self.font_name, size=self.font_size)
+            logging.info(f"Font loaded successfully: {self.font_name}")
+            return self.custom_font
+        except Exception as e:
+            logging.warning(f"Failed to load font: {e}. Using system default.")
+            self.custom_font = tkfont.Font(family="TkDefaultFont", size=self.font_size)
+            return self.custom_font
+
+    def apply_style(self, window):
+        window.configure(bg=self.bg_color)
+        window.attributes('-alpha', self.opacity)
+        self.custom_font = self.load_custom_font(window)
+        self.button_style["font"] = self.custom_font
+
+        style = ttk.Style()
+        style.configure('Switch.TCheckbutton',
+                        background=self.bg_color,
+                        foreground=self.fg_color,
+                        font=self.custom_font)
+        style.map('Switch.TCheckbutton',
+                background=[('active', self.bg_color)],
+                foreground=[('active', self.fg_color)])
+
+        return self.custom_font
+
+    def create_styled_button(self, parent, text, command=None, hover_bg=None):
+        text = text.upper()
+        spaced_text = " ".join(text)
+        button = tk.Button(parent, text=spaced_text, command=command, **self.button_style)
+        original_bg = self.button_style['bg']
+        hover_bg = hover_bg if hover_bg else original_bg
+        button.bind("<Enter>", lambda e: button.config(bg=hover_bg))
+        button.bind("<Leave>", lambda e: button.config(bg=original_bg))
+        return button
+
+    def create_styled_entry(self, parent, **kwargs):
+        entry = tk.Entry(parent, bg=self.bg_color, fg=self.fg_color, 
+                        insertbackground=self.fg_color, font=self.custom_font, **kwargs)
+        return entry
+
+    def create_styled_label(self, parent, text, **kwargs):
+        label = tk.Label(parent, text=text, bg=self.bg_color, fg=self.fg_color, 
+                        font=self.custom_font, **kwargs)
+        return label
+
+    def create_styled_text(self, parent, **kwargs):
+        text_widget = tk.Text(parent, bg=self.bg_color, fg=self.fg_color, 
+                            insertbackground=self.fg_color, font=self.custom_font, **kwargs)
+        text_widget.tag_configure("highlight", background=self.highlight_color)
+        return text_widget
+
+    def create_styled_scale(self, parent, **kwargs):
+        """
+        สร้าง scale widget พร้อม frame และ value label
+        
+        Returns:
+            tuple: (frame, scale) โดย
+                  frame คือ container ที่มี scale และ label
+                  scale คือ ttk.Scale widget ที่ใช้ควบคุมค่า
+        """
+        frame = tk.Frame(parent, bg=self.bg_color)
+        digits = kwargs.pop('digits', 0)
+        
+        style = ttk.Style()
+        style.configure("Custom.Horizontal.TScale", 
+                       background=self.bg_color, 
+                       troughcolor=self.lighten_color(self.bg_color))
+        
+        scale = ttk.Scale(frame, style="Custom.Horizontal.TScale", **kwargs)
+        scale.pack(side=tk.LEFT, fill=tk.X, expand=True)
+
+        value_var = tk.StringVar()
+        value_label = tk.Label(frame, textvariable=value_var, 
+                             bg=self.bg_color, fg=self.fg_color, width=5)
+        value_label.pack(side=tk.RIGHT, padx=(5, 0))
+
+        def update_value(event=None):
+            value = scale.get()
+            value_var.set(f"{value:.{digits}f}")
+
+        scale.bind("<Motion>", update_value)
+        scale.bind("<ButtonRelease-1>", update_value)
+        update_value()
+
+        return (frame, scale)
+
+    def create_advance_ui_frame(self, parent):
+        frame = tk.Frame(parent, bg=self.bg_color)
+        return frame
+
+    def create_api_parameter_form(self, parent):
+        form_frame = tk.Frame(parent, bg=self.bg_color)
+        
+        model_frame = tk.Frame(form_frame, bg=self.bg_color)
+        model_frame.pack(fill=tk.X, pady=5)
+        model_label = self.create_styled_label(model_frame, "Model:")
+        model_label.pack(side=tk.LEFT)
+        model_combo = self.create_styled_combobox(model_frame, values=["gpt-4o", "gpt-4o-mini", "claude-3-haiku"])
+        model_combo.pack(side=tk.RIGHT, expand=True, fill=tk.X)
+
+        max_tokens_frame = tk.Frame(form_frame, bg=self.bg_color)
+        max_tokens_frame.pack(fill=tk.X, pady=5)
+        max_tokens_label = self.create_styled_label(max_tokens_frame, "Max Tokens:")
+        max_tokens_label.pack(side=tk.LEFT)
+        max_tokens_tuple = self.create_styled_scale(max_tokens_frame, from_=100, to=1000, orient=tk.HORIZONTAL)
+        max_tokens_tuple[0].pack(side=tk.RIGHT, expand=True, fill=tk.X)
+
+        temp_frame = tk.Frame(form_frame, bg=self.bg_color)
+        temp_frame.pack(fill=tk.X, pady=5)
+        temp_label = self.create_styled_label(temp_frame, "Temperature:")
+        temp_label.pack(side=tk.LEFT)
+        temp_tuple = self.create_styled_scale(temp_frame, from_=0.5, to=0.9, orient=tk.HORIZONTAL, digits=2)
+        temp_tuple[0].pack(side=tk.RIGHT, expand=True, fill=tk.X)
+        
+        top_p_frame = tk.Frame(form_frame, bg=self.bg_color)
+        top_p_frame.pack(fill=tk.X, pady=5)
+        top_p_label = self.create_styled_label(top_p_frame, "Top P:")
+        top_p_label.pack(side=tk.LEFT)
+        top_p_tuple = self.create_styled_scale(top_p_frame, from_=0.5, to=0.9, orient=tk.HORIZONTAL, digits=2)
+        top_p_tuple[0].pack(side=tk.RIGHT, expand=True, fill=tk.X)
+        
+        # Store references
+        form_frame.model_combo = model_combo
+        form_frame.max_tokens_scale = max_tokens_tuple[1]
+        form_frame.temp_scale = temp_tuple[1]
+        form_frame.top_p_scale = top_p_tuple[1]
+        
+        # Hide top_p for Claude
+        def on_model_change(event):
+            is_claude = model_combo.get() == "claude-3-haiku"
+            if is_claude:
+                top_p_frame.pack_forget()
+            else:
+                top_p_frame.pack(fill=tk.X, pady=5)
+        
+        model_combo.bind('<<ComboboxSelected>>', on_model_change)
+        return form_frame
+
+    def create_save_button(self, parent, command):
+        return self.create_styled_button(parent, "Save", command)
+
+    def create_parameter_description(self, parent):
+        desc_frame = tk.Frame(parent, bg=self.bg_color)
+        
+        descriptions = {
+            "Model": "โมเดล AI ที่ใช้ในการแปลภาษา",
+            "Max Tokens": "จำนวนโทเค็นสูงสุดที่ใช้ในการแปล (100-1000)",
+            "Temperature": "ความสร้างสรรค์ในการแปล (0.5-0.9)",
+            "Top P": "ความหลากหลายของคำศัพท์ (0.5-0.9)"
+        }
+
+        for i, (param, desc) in enumerate(descriptions.items()):
+            label = self.create_styled_label(desc_frame, f"{param}: {desc}")
+            label.pack(anchor="w", pady=2)
+
+        return desc_frame
+    
+    def lighten_color(self, color, factor=1.3):
+        r = int(color[1:3], 16)
+        g = int(color[3:5], 16)
+        b = int(color[5:7], 16)
+        r = min(int(r * factor), 255)
+        g = min(int(g * factor), 255)
+        b = min(int(b * factor), 255)
+        return f"#{r:02x}{g:02x}{b:02x}"
+
+    def create_styled_combobox(self, parent, **kwargs):
+        combo = ttk.Combobox(parent, **kwargs)
+        combo.configure(style='Custom.TCombobox')
+        return combo
+
+appearance_manager = AppearanceManager()

bg_swatch.py

@@ -0,0 +1,185 @@
+import tkinter as tk
+from PIL import Image, ImageTk
+import logging
+from appearance import appearance_manager
+
+class BGSwatch:
+    def __init__(self, root, main_frame, settings):
+        self.root = root
+        self.main_frame = main_frame
+        self.settings = settings
+        self.current_mode = 2  # เริ่มต้นที่สถานะปิด
+        self.bg_colors = ['#000000', '#001F3F', None]
+        self.current_transparency = self.settings.get('bg_swatch_transparency', 0.5)
+        self.is_translation_active = True  # เพิ่มตัวแปรติดตามสถานะการแปล
+        
+        self.setup_bg_layer()
+        self.setup_swatch_button()
+        
+        logging.info("BGSwatch initialized in OFF state")
+
+    def on_main_frame_configure(self, event=None):
+        """อัพเดทขนาดเมื่อ main_frame มีการเปลี่ยนแปลง"""
+        self.update_bg_position()    
+        
+    def setup_bg_layer(self):
+        """Create and setup the background layer"""
+        self.bg_window = tk.Toplevel(self.root)
+        self.bg_window.withdraw()
+        self.bg_window.overrideredirect(True)
+        
+        # ตั้งค่าให้อยู่บนโปรแกรมอื่นแต่อยู่ใต้ main UI
+        self.bg_window.attributes('-topmost', True)
+        self.bg_window.attributes('-alpha', self.current_transparency)
+        
+        self.bg_frame = tk.Frame(
+            self.bg_window,
+            bg=self.bg_colors[self.current_mode] if self.bg_colors[self.current_mode] else appearance_manager.bg_color
+        )
+        self.bg_frame.pack(fill=tk.BOTH, expand=True)
+        
+    def update_bg_position(self):
+        """อัพเดทตำแหน่งและขนาดของพื้นหลัง"""
+        if not hasattr(self, 'bg_window') or not self.main_frame.winfo_exists():
+            return
+            
+        try:
+            width = self.settings.get('width', 400)
+            height = self.settings.get('height', 300)
+            x = self.main_frame.winfo_rootx()
+            y = self.main_frame.winfo_rooty()
+            
+            self.bg_window.geometry(f"{width}x{height}+{x}+{y}")
+            
+            if self.bg_colors[self.current_mode] is not None and self.is_translation_active:
+                self.bg_window.deiconify()
+                self.main_frame.lift()  # ย้าย main_frame ขึ้นบนสุดเสมอ
+                self.bg_window.lift()   # ย้าย bg_window ขึ้นมาแต่อยู่ใต้ main_frame
+                self.main_frame.lift()  # ยืนยันว่า main_frame อยู่บนสุด
+                
+        except tk.TclError:
+            pass
+
+    def handle_translation_state(self, is_active):
+        """จัดการสถานะ bg-swatch ตาม translation state"""
+        self.is_translation_active = is_active
+        if not is_active:
+            # ถ้าการแปลหยุด ให้ซ่อน bg-swatch และเปลี่ยนโหมดเป็นปิด
+            self.bg_window.withdraw()
+            self.current_mode = 2  # โหมดปิด
+            self.settings.set('bg_swatch_mode', self.current_mode)
+            logging.info("BG swatch hidden due to translation stop")
+        else:
+            # ถ้าการแปลเริ่มใหม่ ยังคงอยู่ในโหมดปิดจนกว่าจะกดเปิดเอง
+            pass    
+        
+    def setup_swatch_button(self):
+        """Create and setup the swatch toggle button"""
+        # ขยับปุ่มลงอีก 10px (เปลี่ยนจาก y=60 เป็น y=70)
+        circle_size = 20
+        circle_image = Image.new('RGBA', (circle_size, circle_size))
+        
+        for x in range(circle_size):
+            for y in range(circle_size):
+                dx = x - circle_size/2
+                dy = y - circle_size/2
+                distance = (dx**2 + dy**2)**0.5
+                
+                if distance <= circle_size/2:
+                    if distance <= (circle_size/2 - 1):
+                        alpha = 255
+                    else:
+                        alpha = int(255 * (1 - (distance - (circle_size/2 - 1))))
+                    circle_image.putpixel((x, y), (255, 255, 255, alpha))
+                else:
+                    circle_image.putpixel((x, y), (0, 0, 0, 0))
+                    
+        self.swatch_image = ImageTk.PhotoImage(circle_image)
+        
+        self.swatch_button = tk.Button(
+            self.main_frame,
+            image=self.swatch_image,
+            command=self.toggle_bg_mode,
+            bg=appearance_manager.bg_color,
+            bd=0,
+            cursor="hand2",
+            activebackground=appearance_manager.bg_color,
+            highlightthickness=0
+        )
+        self.swatch_button.place(relx=1.0, rely=0, anchor="ne", x=0, y=70)  # ขยับลง 10px
+        
+        self.create_tooltip()
+        
+    def create_tooltip(self):
+        """Create tooltip for the swatch button"""
+        self.tooltip = None
+        self.swatch_button.bind('<Enter>', self.show_tooltip)
+        self.swatch_button.bind('<Leave>', self.hide_tooltip)
+        
+    def show_tooltip(self, event=None):
+        """Show tooltip when hovering"""
+        x, y, _, _ = self.swatch_button.bbox("insert")
+        x += self.swatch_button.winfo_rootx() + 25
+        y += self.swatch_button.winfo_rooty() + 20
+
+        self.tooltip = tk.Toplevel(self.swatch_button)
+        self.tooltip.wm_overrideredirect(True)
+        self.tooltip.wm_geometry(f"+{x}+{y}")
+        
+        label = tk.Label(
+            self.tooltip,
+            text="BG-Swatch",
+            justify=tk.LEFT,
+            background="#ffffff",
+            foreground="#000000",
+            relief=tk.SOLID,
+            borderwidth=1,
+            font=("TkDefaultFont", "8", "normal")
+        )
+        label.pack()
+        
+    def hide_tooltip(self, event=None):
+        """Hide tooltip"""
+        if self.tooltip:
+            self.tooltip.destroy()
+            self.tooltip = None
+            
+    def toggle_bg_mode(self):
+        """Toggle between different background modes"""
+        if not self.is_translation_active:
+            return  # ไม่ให้เปิดถ้าการแปลไม่ทำงาน
+            
+        self.current_mode = (self.current_mode + 1) % len(self.bg_colors)
+        
+        if self.bg_colors[self.current_mode] is None:
+            self.bg_window.withdraw()
+            logging.info("BG swatch hidden")
+        else:
+            self.bg_frame.configure(bg=self.bg_colors[self.current_mode])
+            self.bg_window.attributes('-alpha', self.current_transparency)
+            self.update_bg_position()
+            logging.info(f"BG swatch shown in mode: {self.current_mode}")
+        
+        self.settings.set('bg_swatch_mode', self.current_mode)
+        
+    def update_transparency(self, value):
+        """Update background transparency (called from settings)"""
+        self.current_transparency = float(value)
+        if hasattr(self, 'bg_window') and self.bg_colors[self.current_mode] is not None:
+            try:
+                self.bg_window.attributes('-alpha', self.current_transparency)
+                logging.info(f"Background transparency updated to: {self.current_transparency}")
+            except (ValueError, tk.TclError) as e:
+                logging.error(f"Error updating background transparency: {str(e)}")
+            
+    def save_current_state(self):
+        """Save current bg-swatch state to settings"""
+        self.settings.set('bg_swatch_mode', self.current_mode)
+        
+    def load_saved_state(self):
+        """Load saved bg-swatch state from settings"""
+        saved_mode = self.settings.get('bg_swatch_mode', 0)
+        if 0 <= saved_mode < len(self.bg_colors):
+            self.current_mode = saved_mode
+            if self.bg_colors[self.current_mode] is not None:
+                self.update_bg_position()  # แสดง bg_window ถ้าจำเป็น

control_ui.py

@@ -0,0 +1,677 @@
+import tkinter as tk
+from tkinter import messagebox
+from PIL import ImageTk, Image
+import logging
+import json
+import os
+from appearance import appearance_manager
+from settings import Settings
+
+# เพิ่ม imports สำหรับการทำขอบโค้งมน
+import win32gui
+import win32con
+import win32api
+from ctypes import windll, byref, sizeof, c_int
+
+logging.basicConfig(level=logging.INFO)
+
+print("Loading control_ui.py")
+
+
+class Control_UI:
+    def __init__(self, root, force_translate, switch_area, settings):
+        self.root = root
+        self.force_translate = force_translate
+        self.switch_area_callback = switch_area
+        self.settings = settings
+
+        # ตัวแปรสำหรับการเคลื่อนที่หน้าต่าง
+        self.x = None
+        self.y = None
+
+        # เพิ่มตัวแปรสำหรับ preset system
+        self.current_preset = 1
+        self.max_presets = 5
+        self.presets = self.load_presets()
+
+        # เพิ่ม area states
+        self.area_states = {"A": True, "B": False, "C": False}
+
+        # โหลดสถานะที่เคยบันทึกไว้
+        self.load_current_area_states()
+
+        # ตัวแปรเก็บค่าแคช
+        self.ui_cache = {
+            "position_x": None,
+            "position_y": None,
+            "current_area": self.get_current_area_string(),
+        }
+
+        self.setup_window()
+        self.setup_buttons()
+        self.setup_bindings()
+        self.load_current_preset()
+
+        # รอให้ window สร้างเสร็จ
+        self.root.update_idletasks()
+
+        # ทำให้หน้าต่างมีขอบมน
+        hwnd = windll.user32.GetParent(self.root.winfo_id())
+        style = win32gui.GetWindowLong(hwnd, win32con.GWL_STYLE)
+        style &= ~win32con.WS_CAPTION
+        style &= ~win32con.WS_THICKFRAME
+        win32gui.SetWindowLong(hwnd, win32con.GWL_STYLE, style)
+
+        rgnw = self.root.winfo_width()
+        rgnh = self.root.winfo_height()
+        region = win32gui.CreateRoundRectRgn(0, 0, rgnw, rgnh, 15, 15)
+        win32gui.SetWindowRgn(hwnd, region, True)
+
+        # ไฮไลท์ปุ่มตามพื้นที่ปัจจุบัน
+        self.update_button_highlights()
+
+        # เพิ่มตัวแปรสำหรับติดตามสถานะการเซฟ
+        self.has_unsaved_changes = False
+        self.pending_preset = None  # เก็บ preset ที่ผู้ใช้เลือกไว้
+
+    def setup_window(self):
+        """ตั้งค่าหน้าต่าง UI"""
+        self.root.title("Control Panel")
+        self.root.geometry("240x200")  # เพิ่มความสูงเพื่อรองรับปุ่มเลือก preset
+        self.root.overrideredirect(True)
+        self.root.attributes("-alpha", 0.95)
+        self.root.attributes("-topmost", True)
+
+        self.main_frame = tk.Frame(
+            self.root,
+            bg="#1a1a1a",
+            highlightthickness=0,
+            highlightbackground="#1a1a1a",
+        )
+        self.main_frame.pack(fill=tk.BOTH, expand=True, padx=0, pady=0)
+
+        self.position_below_main_ui()
+
+    def load_presets(self):
+        """โหลด presets จาก settings"""
+        presets = self.settings.get("area_presets", None)
+        if not presets:
+            # สร้าง default presets ถ้ายังไม่มี
+            presets = [
+                {"name": f"Preset {i+1}", "areas": "A+B" if i == 0 else "C"}
+                for i in range(self.max_presets)
+            ]
+            self.settings.set("area_presets", presets)
+        return presets
+
+    def save_preset(self):
+        """บันทึก preset ปัจจุบันพร้อมพิกัด"""
+        current_areas = self.get_current_area_string()
+
+        # รวบรวมพิกัดของพื้นที่ที่เลือก
+        coordinates = {}
+        for area in current_areas.split("+"):
+            area_coords = self.settings.get_translate_area(area)
+            if area_coords:
+                coordinates[area] = area_coords
+
+        # บันทึกทั้งพื้นที่และพิกัด
+        self.settings.save_preset(self.current_preset, current_areas, coordinates)
+        self.has_unsaved_changes = False  # รีเซ็ตสถานะการบันทึก
+        self.show_save_feedback()
+
+    def load_current_preset(self):
+        """โหลด preset พร้อมพิกัด"""
+        if self.current_preset <= len(self.presets):
+            preset = self.presets[self.current_preset - 1]
+
+            # โหลดพื้นที่
+            areas = preset["areas"].split("+")
+            for area in ["A", "B", "C"]:
+                self.area_states[area] = area in areas
+
+            # โหลดพิกัด
+            if "coordinates" in preset:
+                for area, coords in preset["coordinates"].items():
+                    self.settings.set_translate_area(
+                        coords["start_x"],
+                        coords["start_y"],
+                        coords["end_x"],
+                        coords["end_y"],
+                        area,
+                    )
+
+            self.update_button_highlights()
+            self.update_preset_display()
+
+    def update_preset_display(self):
+        """อัพเดทการแสดงผลหมายเลข preset"""
+        if hasattr(self, "preset_label"):
+            self.preset_label.config(text=f"P{self.current_preset}")
+
+    def show_save_feedback(self):
+        """แสดงข้อความ feedback เมื่อบันทึก preset"""
+        feedback = tk.Toplevel(self.root)
+        feedback.overrideredirect(True)
+        feedback.configure(bg="black")
+        x = self.root.winfo_x() + self.save_button.winfo_x()
+        y = self.root.winfo_y() + self.save_button.winfo_y()
+        tk.Label(
+            feedback,
+            text=f"Saved to P{self.current_preset}!",
+            fg="lime",
+            bg="black",
+            font=("Nasalization Rg", 8),
+        ).pack(padx=10, pady=5)
+        feedback.geometry(f"+{x+30}+{y}")
+        feedback.after(1000, feedback.destroy)
+
+    def create_button(self, parent, command, **kwargs):
+        """สร้างปุ่มที่มี style ตามที่กำหนด"""
+        base_config = {
+            "bg": "#1a1a1a",
+            "fg": "#AAAAAA",
+            "activebackground": "#1a1a1a",
+            "activeforeground": "#FFFFFF",
+            "bd": 0,
+            "relief": "flat",
+            "highlightthickness": 0,
+            "borderwidth": 0,
+            "command": command,
+        }
+
+        base_config.update(kwargs)
+        button = tk.Button(parent, **base_config)
+        button.selected = False
+
+        def on_enter(e):
+            if not button.selected:
+                button.configure(fg="#FFFFFF")
+
+        def on_leave(e):
+            if not button.selected:
+                button.configure(fg="#AAAAAA")
+            else:
+                button.configure(fg="#00FFFF")
+
+        button.bind("<Enter>", on_enter)
+        button.bind("<Leave>", on_leave)
+        return button
+
+    def setup_buttons(self):
+        """Initialize and setup all control buttons"""
+        # Frame หลักสำหรับปุ่มด้านซ้าย
+        left_frame = tk.Frame(self.main_frame, bg="#1a1a1a")
+        left_frame.place(x=25, y=20)
+
+        # สร้าง top row frame
+        top_row = tk.Frame(left_frame, bg="#1a1a1a")
+        top_row.pack(pady=(0, 15))
+
+        # ปุ่มกล้อง
+        camera_image = ImageTk.PhotoImage(Image.open("camera.png").resize((24, 24)))
+        self.camera_button = self.create_button(
+            top_row, command=self.capture_screen, image=camera_image
+        )
+        self.camera_button.image = camera_image
+        self.camera_button.pack(side=tk.LEFT, padx=(0, 15))
+
+        # Area buttons frame
+        area_frame = tk.Frame(top_row, bg="#1a1a1a")
+        area_frame.pack(side=tk.LEFT)
+
+        # สไตล์พื้นฐานสำหรับปุ่ม
+        button_style = {
+            "font": ("Nasalization Rg", 12),
+            "bg": "#1a1a1a",
+        }
+
+        # สร้างปุ่ม A, B, C
+        for area, text in [("A", "[A]"), ("B", "[B]"), ("C", "[C]")]:
+            button = self.create_button(
+                area_frame,
+                command=lambda a=area: self.area_button_click(a),
+                text=text,
+                **button_style,
+            )
+            button.pack(side=tk.LEFT, padx=5)
+            setattr(self, f"button_{area.lower()}", button)
+
+        # Middle row frame for preset display and save
+        middle_row = tk.Frame(left_frame, bg="#1a1a1a")
+        middle_row.pack(pady=(0, 15))
+
+        # Preset label
+        self.preset_label = tk.Label(
+            middle_row,
+            text=f"P{self.current_preset}",
+            font=("Nasalization Rg", 12),
+            bg="#1a1a1a",
+            fg="#00FFFF",
+        )
+        self.preset_label.pack(side=tk.LEFT, padx=(0, 10))
+
+        # Save button
+        self.save_button = self.create_button(
+            middle_row,
+            text="Save",
+            command=self.save_preset,
+            font=("Nasalization Rg", 12),
+        )
+        self.save_button.pack(side=tk.LEFT, padx=5)
+
+        # Bottom row frame
+        bottom_row = tk.Frame(left_frame, bg="#1a1a1a")
+        bottom_row.pack()
+
+        # Force button
+        force_image = ImageTk.PhotoImage(Image.open("force.png").resize((48, 24)))
+        self.force_button = self.create_button(
+            bottom_row, command=self.force_translate, image=force_image
+        )
+        self.force_button.image = force_image
+        self.force_button.pack(side=tk.LEFT, padx=(0, 8))
+
+        # Speed control frame
+        speed_container = tk.Frame(
+            bottom_row, bg="#1a1a1a", bd=1, relief="solid", highlightthickness=0
+        )
+        speed_container.pack(side=tk.LEFT, padx=(8, 0))
+
+        speed_frame = tk.Frame(speed_container, bg="#1a1a1a")
+        speed_frame.pack(padx=1, pady=1)
+
+        # Normal Speed button
+        self.normal_speed_button = self.create_button(
+            speed_frame,
+            text="Normal",
+            command=lambda: self.switch_speed("normal"),
+            font=("Nasalization Rg", 11),
+            width=6,
+            bg="#1a1a1a",
+        )
+        self.normal_speed_button.pack(side=tk.LEFT)
+        self.normal_speed_button.selected = True
+        self.normal_speed_button.config(fg="#00FFFF")
+
+        # Divider
+        tk.Frame(speed_frame, width=1, bg="#333333").pack(
+            side=tk.LEFT, fill=tk.Y, padx=1, pady=1
+        )
+
+        # High Speed button
+        self.high_speed_button = self.create_button(
+            speed_frame,
+            text="High",
+            command=lambda: self.switch_speed("high"),
+            font=("Nasalization Rg", 11),
+            width=4,
+            bg="#1a1a1a",
+        )
+        self.high_speed_button.pack(side=tk.LEFT)
+
+        # Preset number buttons row (NEW)
+        preset_row = tk.Frame(self.main_frame, bg="#1a1a1a")
+        preset_row.pack(side=tk.BOTTOM, pady=10)
+
+        # สร้างปุ่มหมายเลข preset 1-5
+        self.preset_buttons = []
+        for i in range(5):
+            btn = self.create_button(
+                preset_row,
+                text=str(i + 1),
+                command=lambda x=i + 1: self.select_preset(x),
+                font=("Nasalization Rg", 10),
+                width=2,
+                height=1,
+            )
+            btn.pack(side=tk.LEFT, padx=2)
+            self.preset_buttons.append(btn)
+
+        # ไฮไลท์ปุ่ม preset ปัจจุบัน
+        self.update_preset_buttons()
+        self.current_speed = "normal"
+
+    def select_preset(self, preset_number):
+        """เลือก preset ตามหมายเลข
+        Args:
+            preset_number (int): หมายเลข preset (1-5)
+        """
+        if 1 <= preset_number <= self.max_presets:
+            if self.has_unsaved_changes:
+                # สร้างหน้าต่างแจ้งเตือน
+                warning = tk.Toplevel(self.root)
+                warning.title("คำเตือน")
+                warning.geometry("300x150")
+                warning.configure(bg="#1a1a1a")
+                warning.transient(self.root)
+                warning.grab_set()
+
+                # จัดการตำแหน่งหน้าต่าง
+                x = self.root.winfo_x() + (self.root.winfo_width() - 300) // 2
+                y = self.root.winfo_y() + (self.root.winfo_height() - 150) // 2
+                warning.geometry(f"+{x}+{y}")
+
+                # สร้าง UI elements
+                message = tk.Label(
+                    warning,
+                    text="คุณยังไม่ได้บันทึกการเปลี่ยนแปลง\nต้องการบันทึกก่อนเปลี่ยน Preset หรือไม่?",
+                    bg="#1a1a1a",
+                    fg="white",
+                    font=("Nasalization Rg", 10),
+                )
+                message.pack(pady=20)
+
+                button_frame = tk.Frame(warning, bg="#1a1a1a")
+                button_frame.pack(pady=10)
+
+                def save_and_switch():
+                    self.save_preset()
+                    self.has_unsaved_changes = False
+                    self._complete_preset_switch(preset_number)
+                    warning.destroy()
+
+                def switch_without_save():
+                    self.has_unsaved_changes = False
+                    self._complete_preset_switch(preset_number)
+                    warning.destroy()
+
+                # สร้างปุ่ม
+                save_btn = tk.Button(
+                    button_frame,
+                    text="บันทึก",
+                    command=save_and_switch,
+                    bg="#404040",
+                    fg="#00FFFF",
+                    font=("Nasalization Rg", 10),
+                    width=10,
+                )
+                save_btn.pack(side=tk.LEFT, padx=5)
+
+                no_save_btn = tk.Button(
+                    button_frame,
+                    text="ไม่บันทึก",
+                    command=switch_without_save,
+                    bg="#404040",
+                    fg="white",
+                    font=("Nasalization Rg", 10),
+                    width=10,
+                )
+                no_save_btn.pack(side=tk.LEFT, padx=5)
+
+            else:
+                self._complete_preset_switch(preset_number)
+
+    def _complete_preset_switch(self, preset_number):
+        """ดำเนินการเปลี่ยน preset"""
+        try:
+            # อัพเดต preset ปัจจุบัน
+            self.current_preset = preset_number
+
+            # ดึงข้อมูล preset
+            preset = self.settings.get_preset(preset_number)
+            if not preset:
+                logging.error(f"Cannot find preset {preset_number}")
+                return
+
+            # ดึงข้อมูลพื้นที่และพิกัด
+            area_config = preset.get("areas", "A")
+            coordinates = preset.get("coordinates", {})
+
+            # อัพเดตพิกัดของแต่ละพื้นที่
+            for area, coords in coordinates.items():
+                self.settings.set_translate_area(
+                    coords["start_x"],
+                    coords["start_y"],
+                    coords["end_x"],
+                    coords["end_y"],
+                    area,
+                )
+
+            # อัพเดตสถานะการแสดงพื้นที่
+            active_areas = area_config.split("+")
+            for area in ["A", "B", "C"]:
+                self.area_states[area] = area in active_areas
+
+            # อัพเดต UI
+            self.update_preset_buttons()
+            self.update_button_highlights()
+
+            # แจ้งการเปลี่ยนแปลงไปยัง MBB
+            if self.switch_area_callback:
+                self.switch_area_callback(active_areas)
+
+            logging.info(
+                f"Switched to preset {preset_number} with areas: {area_config}"
+            )
+
+        except Exception as e:
+            logging.error(f"Error in _complete_preset_switch: {e}")
+
+    def update_preset_buttons(self):
+        """อัพเดตสถานะและการแสดงผลของปุ่ม preset ทั้งหมด"""
+        for i, btn in enumerate(self.preset_buttons):
+            if i + 1 == self.current_preset:
+                btn.config(fg="#00FFFF", bg="#404040")
+                btn.selected = True
+            else:
+                btn.config(fg="#AAAAAA", bg="#1a1a1a")
+                btn.selected = False
+
+        # อัพเดต preset label ด้วย
+        self.preset_label.config(text=f"P{self.current_preset}", fg="#00FFFF")
+
+    def get_current_area_string(self):
+        """รับสตริงแสดงพื้นที่ที่เลือกในปัจจุบัน"""
+        active = [area for area in ["A", "B", "C"] if self.area_states[area]]
+        return "+".join(active) if active else "A"
+
+    def load_current_area_states(self):
+        """โหลดสถานะพื้นที่ปัจจุบัน"""
+        saved_area = self.settings.get("current_area", "A+B")
+        if saved_area:
+            areas = saved_area.split("+")
+            for area in ["A", "B", "C"]:
+                self.area_states[area] = area in areas
+
+    def switch_speed(self, speed_mode):
+        """สลับระหว่างโหมดความเร็ว"""
+        self.current_speed = speed_mode
+        if speed_mode == "normal":
+            self.normal_speed_button.selecte
+            self.normal_speed_button.selected = True
+            self.high_speed_button.selected = False
+            self.normal_speed_button.config(fg="#00FFFF")
+            self.high_speed_button.config(fg="#AAAAAA")
+        else:
+            self.normal_speed_button.selected = False
+            self.high_speed_button.selected = True
+            self.normal_speed_button.config(fg="#AAAAAA")
+            self.high_speed_button.config(fg="#00FFFF")
+
+        if hasattr(self, "speed_callback"):
+            self.speed_callback(speed_mode)
+
+    def position_below_main_ui(self):
+        """จัดตำแหน่ง Control UI ให้อยู่ด้านล่างของ Main UI"""
+        if hasattr(self.root.master, "winfo_x") and hasattr(
+            self.root.master, "winfo_y"
+        ):
+            main_x = self.root.master.winfo_x()
+            main_y = self.root.master.winfo_y()
+            main_height = self.root.master.winfo_height()
+
+            new_x = main_x
+            new_y = main_y + main_height + 5
+
+            self.ui_cache["position_x"] = new_x
+            self.ui_cache["position_y"] = new_y
+
+            self.root.geometry(f"+{new_x}+{new_y}")
+
+    def show_window(self):
+        """แสดงหน้าต่าง Control UI"""
+        if self.root.winfo_exists():
+            if self.ui_cache["position_x"] is not None:
+                self.restore_cached_position()
+            else:
+                self.position_below_main_ui()
+
+            # โหลดสถานะที่บันทึกไว้
+            current_areas = self.ui_cache["current_area"].split("+")
+            for area in ["A", "B", "C"]:
+                self.area_states[area] = area in current_areas
+
+            self.root.deiconify()
+            self.root.lift()
+            self.root.attributes("-topmost", True)
+            self.update_button_highlights()
+            self.update_preset_display()
+
+    def restore_cached_position(self):
+        """กู้คืนตำแหน่งจากแคช"""
+        if (
+            self.ui_cache["position_x"] is not None
+            and self.ui_cache["position_y"] is not None
+        ):
+            self.root.geometry(
+                f"+{self.ui_cache['position_x']}+{self.ui_cache['position_y']}"
+            )
+
+    def close_window(self):
+        """ปิดหน้าต่าง Control UI"""
+        if self.root.winfo_exists():
+            if self.root.state() != "withdrawn":
+                self.root.withdraw()
+
+    def update_button_highlights(self):
+        """Update button colors based on area states"""
+        button_map = {"A": self.button_a, "B": self.button_b, "C": self.button_c}
+
+        try:
+            # อัพเดตสถานะปุ่มแต่ละพื้นที่
+            for area, button in button_map.items():
+                if self.area_states[area]:
+                    button.config(fg="#00FFFF", bg="#404040")
+                    button.selected = True
+                else:
+                    button.config(fg="#AAAAAA", bg="black")
+                    button.selected = False
+
+            # บันทึกสถานะลง cache และ settings
+            active_areas = self.get_active_areas()
+            area_str = "+".join(active_areas) if active_areas else "A"
+            self.ui_cache["current_area"] = area_str
+            self.settings.set("current_area", area_str)
+
+            # Log การอัพเดต
+            logging.info(f"Updated button highlights. Active areas: {area_str}")
+
+        except Exception as e:
+            logging.error(f"Error in update_button_highlights: {e}")
+
+    def get_active_areas(self):
+        """Return list of active areas in correct order"""
+        return [area for area in ["A", "B", "C"] if self.area_states[area]]
+
+    def setup_bindings(self):
+        """Setup window movement bindings"""
+        self.root.bind("<Button-1>", self.start_move)
+        self.root.bind("<ButtonRelease-1>", self.stop_move)
+        self.root.bind("<B1-Motion>", self.on_drag)
+
+    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 on_drag(self, event):
+        """จัดการการลากหน้าต่าง"""
+        if self.x is not None and self.y is not None:
+            deltax = event.x - self.x
+            deltay = event.y - self.y
+            x = self.root.winfo_x() + deltax
+            y = self.root.winfo_y() + deltay
+            self.root.geometry(f"+{x}+{y}")
+
+            self.ui_cache["position_x"] = x
+            self.ui_cache["position_y"] = y
+
+    def area_button_click(self, area):
+        """Toggle area on/off and update UI
+        Args:
+            area (str): พื้นที่ที่ถูกคลิก (A, B, หรือ C)
+        """
+        try:
+            # สลับสถานะของพื้นที่ที่คลิก
+            new_state = not self.area_states[area]
+
+            # ตรวจสอบว่าจะมีอย่างน้อย 1 พื้นที่เปิดอยู่เสมอ
+            other_active_areas = any(
+                self.area_states[a] for a in ["A", "B", "C"] if a != area
+            )
+
+            # อนุญาตให้ปิดได้ถ้ายังมีพื้นที่อื่นเปิดอยู่
+            if new_state or other_active_areas:
+                self.area_states[area] = new_state
+                self.update_button_highlights()
+
+                # รวบรวมพื้นที่ที่เปิดใช้งาน
+                active_areas = self.get_active_areas()
+
+                # แจ้งการเปลี่ยนแปลงไปยัง MBB
+                if active_areas:
+                    self.switch_area_callback(active_areas)
+                    self.force_translate()
+
+            logging.info(
+                f"Area {area} clicked. Active areas: {self.get_active_areas()}"
+            )
+
+        except Exception as e:
+            logging.error(f"Error in area_button_click: {e}")
+
+    def capture_screen(self):
+        """Capture screen function"""
+        try:
+            from screen_capture import ScreenCapture
+
+            capturer = ScreenCapture()
+            filepath = capturer.capture_primary_screen()
+            if filepath:
+                self.show_capture_feedback()
+        except Exception as e:
+            logging.error(f"Screen capture error: {e}")
+
+    def show_capture_feedback(self):
+        """Show capture feedback"""
+        feedback = tk.Toplevel(self.root)
+        feedback.overrideredirect(True)
+        feedback.configure(bg="black")
+        x = self.root.winfo_x() + self.camera_button.winfo_x()
+        y = self.root.winfo_y() + self.camera_button.winfo_y()
+        tk.Label(
+            feedback,
+            text="Captured!",
+            fg="lime",
+            bg="black",
+            font=("Nasalization Rg", 8),
+        ).pack(padx=10, pady=5)
+        feedback.geometry(f"+{x+30}+{y}")
+        feedback.after(1000, feedback.destroy)
+
+
+if __name__ == "__main__":
+    root = tk.Tk()
+
+    def dummy_force():
+        print("Force translate triggered")
+
+    def dummy_switch(area):
+        print(f"Switched to area {area}")
+
+    app = Control_UI(root, dummy_force, dummy_switch, Settings())
+    root.mainloop()

how to install.txt

@@ -0,0 +1,44 @@
+คู่มือติดตั้ง Magicite Babel
+=================================
+
+1. ย้ายโฟลเดอร์โปรเจ็ค
+-----------------
+- คัดลอกโฟลเดอร์ Magicite Babel ไปไว้ที่ C:\
+
+2. ติดตั้ง Python
+-----------------
+- ดาวน์โหลด Python 3.11.8 จาก: https://www.python.org/downloads/release/python-3118/
+- เลือก Windows installer (64-bit)
+- ระหว่างติดตั้งให้เช็คถูก "Add Python to PATH" 
+- กด "Install Now"
+- รอติดตั้งจนเสร็จ
+
+3. ติดตั้งฟอนต์
+-------------
+- เข้าไปที่โฟลเดอร์ C:\Magicite Babel\fonts
+- เลือกไฟล์ฟอนต์ทั้งหมด
+- คลิกขวา > Install for all users
+- รอติดตั้งจนเสร็จ
+
+4. ตรวจสอบ Python และอัพเดท pip
+---------------------------
+- กด Win + R
+- พิมพ์ cmd แล้วกด Enter
+- พิมพ์: python --version (ต้องแสดง Python 3.11.8)
+- พิมพ์: python -m pip install --upgrade pip
+
+5. ติดตั้ง Libraries (รันคำสั่งเดียว)
+-------------------------------------------
+pip install pillow easyocr keyboard python-dotenv openai numpy opencv-python pywin32 torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu psutil GPUtil gpustat nvidia-ml-py3
+
+6. วิธีรันโปรแกรม
+---------------
+1. กด Win + R
+2. พิมพ์ cmd แล้วกด Enter
+3. พิมพ์: cd C:\Magicite Babel
+4. พิมพ์: python mbb.py
+5. โปรแกรมจะเริ่มทำงาน
+
+หมายเหตุ: ถ้าต้องการล้างการติดตั้งเดิม
+-----------------------------------------
+pip uninstall torch torchvision ninja pyyaml opencv-python-headless scipy numpy Pillow scikit-image easyocr keyboard python-dotenv openai pywin32 psutil GPUtil gpustat nvidia-ml-py3 -y

loggings.py

@@ -0,0 +1,276 @@
+import os
+import csv
+import json
+import logging
+from datetime import datetime
+import time
+import psutil  # type: ignore
+import GPUtil  # type: ignore
+import traceback
+
+
+class LoggingManager:
+    def __init__(self, settings):
+        self.settings = settings
+        self.log_dir = "logs"
+        self.feedback_dir = "feedback"
+        self.ensure_directories()
+        self.setup_logging()
+        self.benchmark_file = None
+        self.feedback_file = None
+        self.error_file = None
+        self.last_api_params = None
+        self.last_status_message = ""
+        self.loading_symbols = ["|", "/", "-", "\\"]
+        self.loading_index = 0
+
+    def log_npc_manager(self, message):
+        """บันทึกข้อความสำหรับ NPC Manager แบบกรองแล้ว"""
+        # ข้อความสำคัญที่ต้องการแสดง
+        important_messages = [
+            "NPC Manager started",
+            "Data loaded successfully",
+            "Font system ready",
+            "Error:",
+            "Warning:",
+        ]
+
+        # แสดงเฉพาะข้อความสำคัญ
+        if any(msg in message for msg in important_messages):
+            print(message)
+
+    def log_startup_info(self):
+        """บันทึกข้อมูลสำคัญตอนเริ่มต้นระบบ"""
+        current_model = self.settings.get_displayed_model()
+        screen_size = self.settings.get("screen_size", "2560x1440")
+        use_gpu = self.settings.get("use_gpu_for_ocr", False)
+
+        startup_info = [
+            "=== MagicBabel System Started ===",
+            f"Model: {current_model}",
+            f"Screen Size: {screen_size}",
+            f"OCR Processing: {'GPU' if use_gpu else 'CPU'}",
+            "===============================",
+        ]
+
+        for line in startup_info:
+            logging.info(line)
+            print(line)
+
+    def log_model_change(self, old_model, new_model, parameters):
+        """บันทึกการเปลี่ยนแปลง model"""
+        log_lines = [
+            "=== Model Change ===",
+            f"From: {old_model}",
+            f"To: {new_model}",
+            "Parameters:",
+            f"- Max Tokens: {parameters.get('max_tokens', 'N/A')}",
+            f"- Temperature: {parameters.get('temperature', 'N/A')}",
+            "===================",
+        ]
+
+        for line in log_lines:
+            logging.info(line)
+            print(line)
+
+    def log_system_status(self):
+        """บันทึกสถานะระบบ"""
+        memory_usage = psutil.Process().memory_info().rss / 1024 / 1024  # MB
+        gpu_usage = (
+            self.get_gpu_usage() if self.settings.get("use_gpu_for_ocr") else "N/A"
+        )
+
+        status_lines = [
+            "=== System Status ===",
+            f"Memory Usage: {memory_usage:.2f} MB",
+            f"GPU Usage: {gpu_usage}",
+            "====================",
+        ]
+
+        for line in status_lines:
+            logging.info(line)
+            print(line)
+
+    def ensure_directories(self):
+        for directory in [self.log_dir, self.feedback_dir]:
+            if not os.path.exists(directory):
+                os.makedirs(directory)
+
+    def setup_logging(self):
+        logging.basicConfig(
+            filename=os.path.join(self.log_dir, "app.log"),
+            level=logging.INFO,
+            format="%(asctime)s - %(levelname)s - %(message)s",
+        )
+        logging.info("Logging initialized")
+
+    def init_benchmark_logging(self):
+        self.benchmark_file = os.path.join(
+            self.log_dir, f"benchmark_{datetime.now().strftime('%Y%m%d')}.csv"
+        )
+        file_exists = os.path.isfile(self.benchmark_file)
+
+        with open(self.benchmark_file, "a", newline="") as file:
+            writer = csv.writer(file)
+            if not file_exists:
+                writer.writerow(
+                    ["Timestamp", "Action", "Duration", "Memory Usage", "GPU Usage"]
+                )
+        logging.info(f"Benchmark logging initialized: {self.benchmark_file}")
+
+    def log_benchmark(self, action, duration):
+        if not self.benchmark_file or not os.path.isfile(self.benchmark_file):
+            self.init_benchmark_logging()
+
+        memory_usage = psutil.Process().memory_info().rss / 1024 / 1024  # MB
+        gpu_usage = (
+            self.get_gpu_usage() if self.settings.get("use_gpu_for_ocr") else "N/A"
+        )
+
+        with open(self.benchmark_file, "a", newline="") as file:
+            writer = csv.writer(file)
+            writer.writerow([datetime.now(), action, duration, memory_usage, gpu_usage])
+
+        # เปลี่ยนจาก logging.info เป็น self.update_status
+        self.update_status(f"Benchmark: {action}, Duration: {duration:.4f}s")
+
+    def get_gpu_usage(self):
+        try:
+            gpus = GPUtil.getGPUs()
+            if gpus:
+                return f"{gpus[0].load * 100:.2f}%"
+        except Exception as e:
+            logging.error(f"Error getting GPU usage: {e}")
+        return "N/A"
+
+    def log_api_params_change(self):
+        current_api_params = self.settings.get_api_parameters()
+        if current_api_params != self.last_api_params:
+            today = datetime.now().strftime("%Y%m%d")
+            self.feedback_file = os.path.join(
+                self.feedback_dir, f"feedback_{today}.json"
+            )
+
+            api_change_data = {
+                "timestamp": datetime.now().isoformat(),
+                "new_params": current_api_params,
+            }
+
+            if os.path.isfile(self.feedback_file):
+                with open(self.feedback_file, "r+", encoding="utf-8") as file:
+                    data = json.load(file)
+                    if "api_params_changes" not in data:
+                        data["api_params_changes"] = []
+                    data["api_params_changes"].append(api_change_data)
+                    data["api_parameters"] = current_api_params
+                    file.seek(0)
+                    file.truncate()
+                    json.dump(data, file, indent=2, ensure_ascii=False)
+            else:
+                with open(self.feedback_file, "w", encoding="utf-8") as file:
+                    initial_data = {
+                        "api_parameters": current_api_params,
+                        "api_params_changes": [api_change_data],
+                        "feedbacks": [],
+                    }
+                    json.dump(initial_data, file, indent=2, ensure_ascii=False)
+
+            self.last_api_params = current_api_params
+            logging.info("API parameters updated and logged")
+
+    def log_error(self, error_message):
+        logging.error(error_message)
+        self.write_error_to_file(error_message)
+
+    def write_error_to_file(self, error_message):
+        today = datetime.now().strftime("%Y%m%d")
+        self.error_file = os.path.join(self.log_dir, f"error_{today}.log")
+
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        formatted_error = f"[{timestamp}] {error_message}\n"
+        formatted_error += f"Traceback:\n{traceback.format_exc()}\n\n"
+
+        with open(self.error_file, "a", encoding="utf-8") as file:
+            file.write(formatted_error)
+
+    def log_info(self, info_message):
+        """
+        บันทึก log ข้อมูลโดยไม่แสดงซ้ำ
+        """
+        # ข้อความที่ไม่ต้องบันทึกซ้ำ
+        skip_logging_messages = {
+            "OCR scanning...",
+            "OCR completed",
+            "Waiting for text...",
+            "Translating...",
+        }
+
+        if info_message not in skip_logging_messages:
+            logging.info(info_message)
+
+    def log_warning(self, warning_message):
+        logging.warning(warning_message)
+        self.write_error_to_file(f"WARNING: {warning_message}")
+
+    def log_critical(self, critical_message):
+        logging.critical(critical_message)
+        self.write_error_to_file(f"CRITICAL: {critical_message}")
+
+    def update_status(self, message):
+        """
+        อัพเดทและแสดงสถานะแบบต่อเนื่องในบรรทัดเดียว
+        Args:
+            message: ข้อความที่ต้องการแสดง
+        """
+        current_time = time.time()
+
+        # สถานะการทำงานต่อเนื่อง
+        continuous_states = {
+            "OCR scanning": {
+                "icon": "🔍",
+                "variants": ["scanning.", "scanning..", "scanning..."],
+            },
+            "Waiting for text": {
+                "icon": "⌛",
+                "variants": ["waiting.", "waiting..", "waiting..."],
+            },
+        }
+
+        # ตรวจสอบว่าเป็นสถานะต่อเนื่องหรือไม่
+        for state, config in continuous_states.items():
+            if state in message:
+                if not hasattr(self, "_animation_state"):
+                    self._animation_state = 0
+                    self._last_animation_time = 0
+
+                # อัพเดทแอนิเมชันทุก 0.3 วินาที
+                if current_time - self._last_animation_time > 0.3:
+                    self._animation_state = (self._animation_state + 1) % len(
+                        config["variants"]
+                    )
+                    self._last_animation_time = current_time
+
+                display_message = f"{config['icon']} {state}{config['variants'][self._animation_state]}"
+                print(f"\r{display_message:<60}", end="", flush=True)
+                return
+
+        # ข้อความที่ไม่ต้องแสดงซ้ำ
+        skip_messages = {"OCR completed", "Processing image"}
+
+        if message in skip_messages:
+            if hasattr(self, "_last_message") and self._last_message == message:
+                return
+
+        # เก็บข้อความล่าสุด
+        self._last_message = message
+
+        # แสดงข้อความสำคัญเท่านั้น
+        important_messages = {
+            "Translation updated": "✅ Translation updated",
+            "Error": "❌ Error detected",
+        }
+
+        if message in important_messages:
+            display_message = important_messages[message]
+            print(f"\r{display_message:<60}", end="", flush=True)
+            logging.info(message)

mini_ui.py

@@ -0,0 +1,190 @@
+import tkinter as tk
+from PIL import Image, ImageTk
+from appearance import appearance_manager
+
+
+class MiniUI:
+    def __init__(self, root, show_main_ui_callback):
+        self.root = root
+        self.show_main_ui_callback = show_main_ui_callback
+        self.blink_interval = 500
+        self.blink_timer = None
+        self.mini_ui = None
+        self.blink_icon = None
+        self.black_icon = None
+        self.mini_ui_blink_label = None
+        self.mini_ui_blinking = False
+        self.is_translating = False
+        self.toggle_translation_callback = None  # สำหรับเก็บ callback จาก main UI
+        self.load_icons()
+        self.create_mini_ui()
+
+    def load_icons(self):
+        icon_size = (10, 10)
+        self.blink_icon = ImageTk.PhotoImage(
+            Image.open("red_icon.png").resize(icon_size)
+        )
+        self.black_icon = ImageTk.PhotoImage(
+            Image.open("black_icon.png").resize(icon_size)
+        )
+
+    def create_mini_ui(self):
+        if self.mini_ui:
+            self.mini_ui.destroy()
+
+        self.mini_ui = tk.Toplevel(self.root)
+        self.mini_ui.geometry("120x30")
+        self.mini_ui.overrideredirect(True)
+        self.mini_ui.attributes("-topmost", True)
+        self.mini_ui.configure(bg=appearance_manager.bg_color)
+        self.mini_ui.withdraw()
+
+        # สร้าง frame หลักพร้อมขอบบาง
+        main_frame = tk.Frame(
+            self.mini_ui,
+            bg=appearance_manager.bg_color,
+            highlightthickness=1,
+            highlightbackground="#333333",
+        )
+        main_frame.pack(expand=True, fill=tk.BOTH, padx=1, pady=1)
+
+        # เพิ่มปุ่ม toggle ขนาดเล็กด้านซ้าย
+        toggle_button = tk.Button(
+            main_frame,
+            text="⇄",  # ใช้เครื่องหมายลูกศรแทนข้อความ
+            command=self.show_main_ui_callback,
+            bg=appearance_manager.bg_color,
+            fg="white",
+            bd=0,
+            highlightthickness=0,
+            font=("Arial", 8),
+            width=2,
+            cursor="hand2",
+        )
+        toggle_button.pack(side=tk.LEFT, padx=(2, 0))
+
+        # ปุ่ม Start/Stop ที่ปรับปรุงแล้ว
+        self.start_button = tk.Button(
+            main_frame,
+            text="Start",
+            command=self._handle_toggle_translation,
+            bg=appearance_manager.bg_color,
+            fg="white",
+            bd=0,
+            highlightthickness=0,
+            font=("FC Minimal", 10, "bold"),
+            activebackground="#404040",
+            activeforeground="white",
+            width=8,
+            cursor="hand2",
+        )
+        self.start_button.pack(side=tk.LEFT, padx=5)
+
+        # ไฟสถานะการแปล
+        self.mini_ui_blink_label = tk.Label(
+            main_frame, image=self.black_icon, bg=appearance_manager.bg_color
+        )
+        self.mini_ui_blink_label.pack(side=tk.RIGHT, padx=5)
+
+        # Hover effects สำหรับปุ่ม Start/Stop
+        def on_enter(e):
+            if not self.is_translating:
+                self.start_button.config(bg="#666666")
+            else:
+                self.start_button.config(bg="#404040")
+
+        def on_leave(e):
+            self.start_button.config(bg=appearance_manager.bg_color)
+
+        # Hover effects สำหรับปุ่ม toggle
+        def on_toggle_enter(e):
+            toggle_button.config(bg="#666666")
+
+        def on_toggle_leave(e):
+            toggle_button.config(bg=appearance_manager.bg_color)
+
+        self.start_button.bind("<Enter>", on_enter)
+        self.start_button.bind("<Leave>", on_leave)
+        toggle_button.bind("<Enter>", on_toggle_enter)
+        toggle_button.bind("<Leave>", on_toggle_leave)
+
+        # Event bindings
+        self.mini_ui.bind("<Button-1>", self.start_move_mini_ui)
+        self.mini_ui.bind("<B1-Motion>", self.do_move_mini_ui)
+        self.mini_ui.bind("<Double-Button-1>", lambda e: self.show_main_ui_from_mini())
+
+    def _handle_toggle_translation(self):
+        """จัดการการกดปุ่ม Start/Stop โดยเรียกใช้ callback จาก main UI"""
+        if self.toggle_translation_callback:
+            self.toggle_translation_callback()
+
+    def update_translation_status(self, is_translating):
+        """อัพเดทสถานะการแปลและ UI"""
+        self.is_translating = is_translating
+        self.mini_ui_blinking = is_translating
+
+        if is_translating:
+            self.start_button.config(text="Stop", bg=appearance_manager.bg_color)
+            self.start_blinking()
+        else:
+            self.start_button.config(text="Start", bg=appearance_manager.bg_color)
+            self.stop_blinking()
+
+    def set_toggle_translation_callback(self, callback):
+        """ตั้งค่า callback สำหรับการ toggle การแปล"""
+        self.toggle_translation_callback = callback
+
+    def start_blinking(self):
+        """เริ่มการกระพริบของไฟสถานะ"""
+        if self.blink_timer is None:
+            self.blink_mini_ui()
+
+    def stop_blinking(self):
+        """หยุดการกระพริบของไฟสถานะ"""
+        if self.blink_timer is not None:
+            self.mini_ui.after_cancel(self.blink_timer)
+            self.blink_timer = None
+        if hasattr(self, "mini_ui_blink_label"):
+            self.mini_ui_blink_label.config(image=self.black_icon)
+
+    def start_move_mini_ui(self, event):
+        """เริ่มการเคลื่อนย้ายหน้าต่าง"""
+        self.mini_x = event.x_root - self.mini_ui.winfo_x()
+        self.mini_y = event.y_root - self.mini_ui.winfo_y()
+
+    def do_move_mini_ui(self, event):
+        """ทำการเคลื่อนย้ายหน้าต่าง"""
+        x = event.x_root - self.mini_x
+        y = event.y_root - self.mini_y
+        self.mini_ui.geometry(f"+{x}+{y}")
+
+    def show_main_ui_from_mini(self):
+        """สลับกลับไปแสดง main UI"""
+        if hasattr(self, "mini_ui"):
+            self.mini_ui.withdraw()
+        self.show_main_ui_callback()
+
+    def position_at_center_of_main(self, main_x, main_y, main_width, main_height):
+        """จัดตำแหน่ง mini UI ให้อยู่กลาง main UI"""
+        mini_width = 120
+        mini_height = 30
+        x = main_x + (main_width - mini_width) // 2
+        y = main_y + (main_height - mini_height) // 2
+        self.mini_ui.geometry(f"+{x}+{y}")
+
+    def blink_mini_ui(self):
+        """จัดการการกระพริบของไฟสถานะ"""
+        if self.mini_ui_blinking and hasattr(self, "mini_ui") and self.mini_ui:
+            if hasattr(self, "mini_ui_blink_label"):
+                current_image = self.mini_ui_blink_label.cget("image")
+                new_image = (
+                    self.blink_icon
+                    if current_image == str(self.black_icon)
+                    else self.black_icon
+                )
+                self.mini_ui_blink_label.config(image=new_image)
+                self.blink_timer = self.mini_ui.after(
+                    self.blink_interval, self.blink_mini_ui
+                )
+        else:
+            self.stop_blinking()

model.py

@@ -0,0 +1,321 @@
+import tkinter as tk
+from tkinter import ttk, messagebox
+import logging
+from appearance import appearance_manager
+
+
+class ModelSettings:
+    def __init__(self, parent, settings, apply_settings_callback):
+        self.parent = parent
+        self.settings = settings
+        self.apply_settings_callback = apply_settings_callback
+        self.model_window = None
+        self.window_created = False
+
+    def create_model_window(self):
+        if self.model_window is None or not self.model_window.winfo_exists():
+            self.model_window = tk.Toplevel(self.parent)
+            self.model_window.title("API Model Settings")
+            self.model_window.geometry("480x400")  # กว้างขึ้นเพื่อรองรับ 2 columns
+            self.model_window.overrideredirect(True)
+            appearance_manager.apply_style(self.model_window)
+
+            # Main Container
+            main_container = tk.Frame(self.model_window, bg=appearance_manager.bg_color)
+            main_container.pack(expand=True, fill=tk.BOTH, padx=10, pady=5)
+
+            # Model Selection Frame (Top)
+            model_frame = tk.Frame(main_container, bg=appearance_manager.bg_color)
+            model_frame.pack(fill=tk.X, pady=10)
+
+            appearance_manager.create_styled_label(
+                model_frame, text="Select Model:"
+            ).pack(side=tk.LEFT, padx=5)
+
+            # Model Dropdown
+            self.model_var = tk.StringVar()
+            model_options = ["gpt-4o", "gpt-4o-mini", "claude-3.5-haiku"]
+            self.model_combo = appearance_manager.create_styled_combobox(
+                model_frame, values=model_options, textvariable=self.model_var, width=15
+            )
+            self.model_combo.pack(side=tk.LEFT, padx=5)
+            self.model_combo.bind("<<ComboboxSelected>>", self.on_model_change)
+
+            # Parameters Container (Left and Right panels)
+            params_container = tk.Frame(main_container, bg=appearance_manager.bg_color)
+            params_container.pack(expand=True, fill=tk.BOTH, pady=10)
+
+            # GPT Parameters (Left)
+            self.gpt_frame = tk.LabelFrame(
+                params_container,
+                text="GPT Parameters",
+                bg=appearance_manager.bg_color,
+                fg="white",
+            )
+            self.gpt_frame.pack(side=tk.LEFT, expand=True, fill=tk.BOTH, padx=5)
+
+            # Claude Parameters (Right)
+            self.claude_frame = tk.LabelFrame(
+                params_container,
+                text="Claude Parameters",
+                bg=appearance_manager.bg_color,
+                fg="white",
+            )
+            self.claude_frame.pack(side=tk.RIGHT, expand=True, fill=tk.BOTH, padx=5)
+
+            # Create parameters for both models
+            self.create_gpt_parameters()
+            self.create_claude_parameters()
+
+            # Apply Button
+            self.apply_button = appearance_manager.create_styled_button(
+                self.model_window, "Apply", self.apply_settings
+            )
+            self.apply_button.pack(pady=10)
+
+            # Close button
+            close_button = appearance_manager.create_styled_button(
+                self.model_window, "X", self.close
+            )
+            close_button.place(x=5, y=5, width=20, height=20)
+
+            # Window movement
+            self.model_window.bind("<Button-1>", self.start_move)
+            self.model_window.bind("<ButtonRelease-1>", self.stop_move)
+            self.model_window.bind("<B1-Motion>", self.do_move)
+
+            self.window_created = True
+            self.model_window.withdraw()
+
+            # Load current settings
+            self.load_current_settings()
+
+    def create_gpt_parameters(self):
+        """Create GPT model parameters controls"""
+        # Max Tokens
+        token_frame = tk.Frame(self.gpt_frame, bg=appearance_manager.bg_color)
+        token_frame.pack(fill=tk.X, pady=5, padx=5)
+        appearance_manager.create_styled_label(token_frame, text="Max Tokens:").pack(
+            side=tk.LEFT
+        )
+
+        self.gpt_max_tokens = tk.Scale(
+            token_frame,
+            from_=100,
+            to=1000,
+            orient=tk.HORIZONTAL,
+            resolution=1,
+            bg=appearance_manager.bg_color,
+            fg="white",
+            highlightthickness=0,
+        )
+        self.gpt_max_tokens.pack(side=tk.RIGHT, expand=True, fill=tk.X, padx=5)
+
+        # Temperature
+        temp_frame = tk.Frame(self.gpt_frame, bg=appearance_manager.bg_color)
+        temp_frame.pack(fill=tk.X, pady=5, padx=5)
+        appearance_manager.create_styled_label(temp_frame, text="Temperature:").pack(
+            side=tk.LEFT
+        )
+
+        self.gpt_temperature = tk.Scale(
+            temp_frame,
+            from_=0.1,
+            to=0.9,
+            orient=tk.HORIZONTAL,
+            resolution=0.1,
+            bg=appearance_manager.bg_color,
+            fg="white",
+            highlightthickness=0,
+        )
+        self.gpt_temperature.pack(side=tk.RIGHT, expand=True, fill=tk.X, padx=5)
+
+        # Top P
+        top_p_frame = tk.Frame(self.gpt_frame, bg=appearance_manager.bg_color)
+        top_p_frame.pack(fill=tk.X, pady=5, padx=5)
+        appearance_manager.create_styled_label(top_p_frame, text="Top P:").pack(
+            side=tk.LEFT
+        )
+
+        self.gpt_top_p = tk.Scale(
+            top_p_frame,
+            from_=0.1,
+            to=0.9,
+            orient=tk.HORIZONTAL,
+            resolution=0.1,
+            bg=appearance_manager.bg_color,
+            fg="white",
+            highlightthickness=0,
+        )
+        self.gpt_top_p.pack(side=tk.RIGHT, expand=True, fill=tk.X, padx=5)
+
+    def create_claude_parameters(self):
+        """Create Claude model parameters controls"""
+        # Max Tokens
+        token_frame = tk.Frame(self.claude_frame, bg=appearance_manager.bg_color)
+        token_frame.pack(fill=tk.X, pady=5, padx=5)
+        appearance_manager.create_styled_label(token_frame, text="Max Tokens:").pack(
+            side=tk.LEFT
+        )
+
+        self.claude_max_tokens = tk.Scale(
+            token_frame,
+            from_=100,
+            to=1000,
+            orient=tk.HORIZONTAL,
+            resolution=1,
+            bg=appearance_manager.bg_color,
+            fg="white",
+            highlightthickness=0,
+        )
+        self.claude_max_tokens.pack(side=tk.RIGHT, expand=True, fill=tk.X, padx=5)
+
+        # Temperature
+        temp_frame = tk.Frame(self.claude_frame, bg=appearance_manager.bg_color)
+        temp_frame.pack(fill=tk.X, pady=5, padx=5)
+        appearance_manager.create_styled_label(temp_frame, text="Temperature:").pack(
+            side=tk.LEFT
+        )
+
+        self.claude_temperature = tk.Scale(
+            temp_frame,
+            from_=0.1,
+            to=0.9,
+            orient=tk.HORIZONTAL,
+            resolution=0.1,
+            bg=appearance_manager.bg_color,
+            fg="white",
+            highlightthickness=0,
+        )
+        self.claude_temperature.pack(side=tk.RIGHT, expand=True, fill=tk.X, padx=5)
+
+    def load_current_settings(self):
+        """Load current settings from settings object"""
+        current_params = self.settings.get_api_parameters()
+
+        # Set current model
+        model = current_params.get("model", "gpt-4o")
+        displayed_model = current_params.get("displayed_model", model)
+        self.model_var.set(displayed_model)
+
+        # Load GPT parameters
+        self.gpt_max_tokens.set(current_params.get("max_tokens", 500))
+        self.gpt_temperature.set(current_params.get("temperature", 0.7))
+        self.gpt_top_p.set(current_params.get("top_p", 0.9))
+
+        # Load Claude parameters
+        self.claude_max_tokens.set(current_params.get("max_tokens", 500))
+        self.claude_temperature.set(current_params.get("temperature", 0.7))
+
+        # Update UI state based on selected model
+        self.on_model_change(None)
+
+    def on_model_change(self, event):
+        """Handle model selection change"""
+        selected_model = self.model_var.get()
+
+        # Enable/disable parameter frames based on model
+        if selected_model == "claude-3.5-haiku":
+            self.enable_frame(self.claude_frame)
+            self.disable_frame(self.gpt_frame)
+        else:
+            self.enable_frame(self.gpt_frame)
+            self.disable_frame(self.claude_frame)
+
+    def enable_frame(self, frame):
+        """Enable all controls in a frame"""
+        for widget in frame.winfo_children():
+            if isinstance(widget, tk.Frame):
+                for subwidget in widget.winfo_children():
+                    subwidget.configure(state="normal")
+            else:
+                widget.configure(state="normal")
+        frame.configure(fg="white")
+
+    def disable_frame(self, frame):
+        """Disable all controls in a frame"""
+        for widget in frame.winfo_children():
+            if isinstance(widget, tk.Frame):
+                for subwidget in widget.winfo_children():
+                    subwidget.configure(state="disabled")
+            else:
+                widget.configure(state="disabled")
+        frame.configure(fg="gray")
+
+    def apply_settings(self):
+        try:
+            selected_model = self.model_var.get()
+
+            # สร้าง parameters ตามประเภท model
+            if selected_model == "claude-3.5-haiku":
+                api_parameters = {
+                    "model": "claude-3-5-haiku-20241022",
+                    "max_tokens": int(self.claude_max_tokens.get()),
+                    "temperature": float(self.claude_temperature.get()),
+                }
+            else:
+                api_parameters = {
+                    "model": selected_model,
+                    "max_tokens": int(self.gpt_max_tokens.get()),
+                    "temperature": float(self.gpt_temperature.get()),
+                    "top_p": float(self.gpt_top_p.get()),
+                }
+
+            # ตรวจสอบก่อนบันทึก
+            self.settings.validate_model_parameters(api_parameters)
+
+            # เพิ่มบรรทัดนี้เพื่อบันทึกค่าโดยตรง
+            success, error = self.settings.set_api_parameters(**api_parameters)
+            if not success:
+                raise ValueError(error)
+
+            new_settings = {"api_parameters": api_parameters}
+
+            if callable(self.apply_settings_callback):
+                self.apply_settings_callback(new_settings)
+
+            # บังคับให้บันทึกลงไฟล์
+            self.settings.save_settings()
+
+            self.apply_button.config(text="Applied!")
+            self.model_window.after(
+                2000, lambda: self.apply_button.config(text="Apply")
+            )
+            return True
+
+        except Exception as e:
+            messagebox.showerror("Error", f"Failed to apply settings: {str(e)}")
+            return False
+
+    def open(self):
+        """Show the model settings window"""
+        if not self.window_created:
+            self.create_model_window()
+
+        x = self.parent.winfo_x() + self.parent.winfo_width() + 10
+        y = self.parent.winfo_y()
+        self.model_window.geometry(f"+{x}+{y}")
+        self.model_window.deiconify()
+        self.model_window.lift()
+        self.model_window.attributes("-topmost", True)
+
+    def close(self):
+        """Hide the model settings window"""
+        if self.model_window and self.window_created:
+            self.model_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):
+        if hasattr(self, "x") and hasattr(self, "y"):
+            deltax = event.x - self.x
+            deltay = event.y - self.y
+            x = self.model_window.winfo_x() + deltax
+            y = self.model_window.winfo_y() + deltay
+            self.model_window.geometry(f"+{x}+{y}")

npc_manager.py

@@ -0,0 +1,1322 @@
+import tkinter as tk
+from tkinter import ttk, messagebox, font
+import json
+import os
+from loggings import LoggingManager
+from appearance import appearance_manager
+
+
+class NPCManager:
+    def __init__(self, parent, reload_callback=None, logging_manager=None):
+        print("Starting NPC Manager initialization...")
+        try:
+            self.parent = parent
+            self.reload_callback = reload_callback
+            self.logging_manager = logging_manager or LoggingManager(None)
+            self.window = tk.Toplevel(parent)
+            self.window.title("NPC Manager")
+
+            # กำหนดขนาดหน้าต่างเริ่มต้น
+            default_width = 1200
+            default_height = 800
+
+            # คำนวณตำแหน่งกลางจอ
+            screen_width = parent.winfo_screenwidth()
+            screen_height = parent.winfo_screenheight()
+
+            x = (screen_width - default_width) // 2
+            y = (screen_height - default_height) // 2
+
+            # ตั้งค่าขนาดและตำแหน่ง
+            self.window.withdraw()  # ซ่อนก่อนจัดตำแหน่ง
+            self.window.geometry(f"{default_width}x{default_height}+{x}+{y}")
+            self.window.minsize(800, 600)
+            self.window.overrideredirect(True)
+            self.window.configure(bg=appearance_manager.bg_color)
+
+            print("Creating state variables...")
+            # Initialize state variables
+            self.current_section = None
+            self.data = self.load_data()
+            self.search_var = tk.StringVar()
+            self.search_var.trace("w", self.on_search_change)
+
+            print("Initializing font system...")
+            # Font management initialization
+            self.setup_font_system()
+            self.window.after(100, lambda: self.on_font_change(None))
+
+            print("Creating UI components...")
+            # Create main UI components
+            self.create_title_bar()
+            self.create_main_layout()
+            self.setup_entry_form()
+            self.setup_json_display()
+
+            print("Setting up resize handling...")
+            # Setup resize functionality
+            self.setup_resize_handling()
+
+            print("Binding window events...")
+            # Setup window event bindings
+            self.bind_window_events()
+
+            # อัพเดทการคำนวณทั้งหมด
+            self.window.update_idletasks()
+
+            print("Initialization complete")
+
+        except Exception as e:
+            print(f"Critical error during initialization: {e}")
+            messagebox.showerror(
+                "Initialization Error", f"Failed to initialize NPC Manager: {str(e)}"
+            )
+            raise
+
+    def setup_font_system(self):
+        """Initialize the font management system"""
+        print("Setting up font system...")
+        self.font_sizes = list(range(10, 29, 2))  # 10-28
+        self.current_font_size = 16
+        self.available_fonts = self.load_available_fonts()
+        self.current_font = self.get_default_font()
+
+        # Initialize font manager state
+        self.font_manager = {
+            "current": self.current_font,
+            "available": self.available_fonts,
+            "size": self.current_font_size,
+        }
+        print(f"Font system ready with {len(self.available_fonts)} fonts")
+
+    def load_available_fonts(self):
+        """Load and register fonts from project directory only"""
+        custom_fonts = []
+        project_dir = r"C:\Magicite Babel"
+
+        try:
+            if not os.path.exists(project_dir):
+                return ["Arial"]
+
+            # Map file names to display names
+            font_mapping = {
+                "BaiJamjuree-Light": "Bai Jamjuree Light.ttf",
+                "Bai Jamjuree Light": "Bai Jamjuree Light.ttf",
+                "FCMinimal": "FC Minimal",
+                "NotoSansThaiLooped": "Noto Sans Thai Looped",
+                # เพิ่มการ map อื่นๆ ตามที่ต้องการ
+            }
+
+            # อ่านฟอนต์จากโฟลเดอร์
+            font_files = [
+                f
+                for f in os.listdir(project_dir)
+                if f.lower().endswith((".ttf", ".otf"))
+            ]
+
+            for font_file in font_files:
+                try:
+                    base_name = os.path.splitext(font_file)[0]
+                    # ใช้ชื่อที่ map ไว้ถ้ามี ไม่งั้นใช้ชื่อไฟล์
+                    display_name = font_mapping.get(base_name, base_name)
+                    custom_fonts.append(display_name)
+                except Exception:
+                    continue
+
+            # เ���ิ่มฟอนต์พื้นฐาน
+            basic_fonts = [
+                "Bai Jamjuree Light",
+                "FC minimal",
+                "Arial",
+                "Helvetica",
+                "TkDefaultFont",
+            ]
+            available_fonts = list(set(custom_fonts + basic_fonts))
+            return sorted(available_fonts)
+
+        except Exception as e:
+            return ["Arial"]
+
+    def get_default_font(self):
+        """Get appropriate default font"""
+        preferred_fonts = [
+            "Bai Jamjuree Light",
+            "Arial",
+            "Helvetica",
+            "TkDefaultFont",
+        ]
+        for font_name in preferred_fonts:
+            if font_name in self.available_fonts:
+                return font_name
+
+        # ถ้าไม่พบฟอนต์ที่ต้องการ ใช้ฟอนต์แรกที่มี
+        return self.available_fonts[0] if self.available_fonts else "TkDefaultFont"
+
+    def create_title_bar(self):
+        """Create custom title bar"""
+        print("Creating title bar...")
+        # Title bar frame with gradient effect
+        self.title_bar = tk.Frame(
+            self.window, bg=appearance_manager.bg_color, height=40
+        )
+        self.title_bar.pack(fill="x", side="top")
+        self.title_bar.pack_propagate(False)
+
+        # Title label
+        self.title_label = tk.Label(
+            self.title_bar,
+            text="NPC Manager",
+            bg=appearance_manager.bg_color,
+            fg="white",
+            font=("Nasalization Rg", 14),
+        )
+        self.title_label.pack(side="left", padx=10)
+
+        # Close button
+        self.close_button = tk.Button(
+            self.title_bar,
+            text="×",
+            bg=appearance_manager.bg_color,
+            fg="white",
+            bd=0,
+            font=("Arial", 16),
+            command=self.hide_window,
+        )
+        self.close_button.pack(side="right", padx=5)
+
+        # Add drag functionality
+        self.title_bar.bind("<Button-1>", self.start_move)
+        self.title_bar.bind("<B1-Motion>", self.do_move)
+        print("Title bar created")
+
+    def setup_resize_handling(self):
+        """Setup window resize functionality"""
+        print("Setting up resize handling...")
+        self.resize_handle = tk.Label(
+            self.window,
+            text="✦",
+            bg="#2A2A2A",
+            fg="white",
+            font=("Arial", 12, "bold"),
+            cursor="sizing",
+        )
+        self.resize_handle.place(relx=1, rely=1, anchor="se")
+
+        self.resize_handle.bind("<Button-1>", self.start_resize)
+        self.resize_handle.bind("<B1-Motion>", self.on_resize)
+        self.resize_handle.bind("<ButtonRelease-1>", self.stop_resize)
+
+        self.is_resizing = False
+        print("Resize handling setup complete")
+
+    def bind_window_events(self):
+        """Bind various window events"""
+        print("Binding window events...")
+        self.window.bind("<Configure>", self.on_window_configure)
+        self.window.bind("<Map>", lambda e: self.window.deiconify())
+        self.window.bind("<Unmap>", lambda e: self.window.withdraw())
+        print("Window events bound")
+
+    def create_main_layout(self):
+        """Create the main three-panel layout with visual separators"""
+        print("Creating main layout...")
+        # Main container
+        self.main_container = tk.Frame(self.window, bg=appearance_manager.bg_color)
+        self.main_container.pack(fill="both", expand=True, padx=10, pady=5)
+
+        # Left panel (buttons) with border
+        self.buttons_panel = tk.Frame(
+            self.main_container, bg=appearance_manager.bg_color
+        )
+        self.buttons_panel.pack(side="left", fill="y", padx=(0, 1))
+
+        # Vertical separator after buttons panel
+        tk.Frame(self.main_container, width=2, bg="#404040").pack(
+            side="left", fill="y", padx=5
+        )
+
+        # Middle panel (entry form) with border
+        self.entry_panel = tk.Frame(
+            self.main_container, bg=appearance_manager.bg_color, width=300
+        )
+        self.entry_panel.pack(side="left", fill="y", padx=(1, 1))
+        self.entry_panel.pack_propagate(False)
+
+        # Vertical separator after entry panel
+        tk.Frame(self.main_container, width=2, bg="#404040").pack(
+            side="left", fill="y", padx=5
+        )
+
+        # Right panel (JSON display)
+        self.content_panel = tk.Frame(
+            self.main_container, bg=appearance_manager.bg_color
+        )
+        self.content_panel.pack(side="right", fill="both", expand=True)
+
+        # Create section buttons
+        self.create_section_buttons()
+
+        # Create font controls
+        self.create_font_controls()
+        print("Main layout created")
+
+    def create_section_buttons(self):
+        """Create section buttons with improved styling"""
+        print("Creating section buttons...")
+        sections = [
+            ("MAIN CHARACTERS", "main_characters"),
+            ("NPCS", "npcs"),
+            ("LORE", "lore"),
+            ("CHARACTER ROLES", "character_roles"),
+            ("WORD FIXES", "word_fixes"),
+        ]
+
+        # Title for buttons section
+        title_label = tk.Label(
+            self.buttons_panel,
+            text="EDIT-context",
+            bg=appearance_manager.bg_color,
+            fg="#808080",
+            font=("FC Minimal", 10),
+        )
+        title_label.pack(pady=(0, 10))
+
+        # เก็บปุ่มไว้ใน dictionary เพื่อเข้าถึงได้ง่าย
+        self.section_buttons = {}
+
+        for text, section in sections:
+            button_frame = tk.Frame(self.buttons_panel, bg=appearance_manager.bg_color)
+            button_frame.pack(fill="x", pady=2)
+
+            btn = tk.Button(
+                button_frame,
+                text=text,
+                font=("Nasalization Rg", 10),
+                bg=appearance_manager.bg_color,
+                fg="white",
+                bd=0,
+                activebackground="#FF4444",
+                command=lambda s=section: self.show_section(s),
+            )
+            btn.pack(fill="x", padx=5)
+
+            # เก็บปุ่มไว้ใน dictionary
+            self.section_buttons[section] = btn
+
+            # Hover effects
+            btn.bind("<Enter>", lambda e, b=btn: b.configure(bg="#2A2A2A"))
+            btn.bind("<Leave>", lambda e, b=btn: self.handle_button_leave(b))
+
+    def handle_button_leave(self, button):
+        """จัดการสีปุ่มเมื่อเมาส์ออก"""
+        # ถ้าปุ่มนี้เป็นปุ่มที่เลือกอยู่ ให้คงสีเดิมไว้
+        if hasattr(self, "current_section") and button == self.section_buttons.get(
+            self.current_section
+        ):
+            button.configure(fg="yellow")
+        else:
+            button.configure(bg=appearance_manager.bg_color, fg="white")
+
+    def create_font_controls(self):
+        """Create font selection controls with automatic apply"""
+        print("Creating font controls...")
+        font_frame = tk.Frame(self.buttons_panel, bg=appearance_manager.bg_color)
+        font_frame.pack(side="bottom", fill="x", pady=10)
+
+        # Font section title
+        tk.Label(
+            font_frame,
+            text="FONT SETTINGS",
+            bg=appearance_manager.bg_color,
+            fg="#808080",
+            font=("Nasalization Rg", 12),
+        ).pack(pady=(0, 5))
+
+        # Font family selector
+        self.font_var = tk.StringVar(value=self.current_font)
+        font_dropdown = ttk.Combobox(
+            font_frame,
+            textvariable=self.font_var,
+            values=self.available_fonts,
+            width=20,
+        )
+        font_dropdown.pack(fill="x", padx=5, pady=2)
+
+        # Auto-apply on selection
+        font_dropdown.bind("<<ComboboxSelected>>", self.on_font_change)
+
+        self.window.after(
+            100, lambda: self.on_font_change(None)
+        )  # Trigger font change after window creation
+
+        # Font size controls
+        size_frame = tk.Frame(font_frame, bg=appearance_manager.bg_color)
+        size_frame.pack(fill="x", padx=5, pady=5)
+
+        tk.Label(
+            size_frame, text="Size:", bg=appearance_manager.bg_color, fg="white"
+        ).pack(side="left")
+
+        # Decrease size button
+        tk.Button(
+            size_frame,
+            text="−",
+            command=self.decrease_font_size,
+            bg="#2A2A2A",
+            fg="white",
+            width=2,
+            bd=0,
+        ).pack(side="left", padx=2)
+
+        # Size label
+        self.size_label = tk.Label(
+            size_frame,
+            text=str(self.current_font_size),
+            bg=appearance_manager.bg_color,
+            fg="white",
+            width=3,
+        )
+        self.size_label.pack(side="left", padx=2)
+
+        # Increase size button
+        tk.Button(
+            size_frame,
+            text="+",
+            command=self.increase_font_size,
+            bg="#2A2A2A",
+            fg="white",
+            width=2,
+            bd=0,
+        ).pack(side="left", padx=2)
+        print("Font controls created")
+
+    def setup_json_display(self):
+        """Create the JSON display area with enhanced styling"""
+        print("Setting up JSON display...")
+
+        # Main container for JSON display
+        self.display_frame = tk.Frame(
+            self.content_panel, bg=appearance_manager.bg_color
+        )
+        self.display_frame.pack(fill="both", expand=True)
+
+        # Search container at top
+        search_frame = tk.Frame(self.display_frame, bg=appearance_manager.bg_color)
+        search_frame.pack(fill="x", pady=(5, 0))
+
+        # Search icon and entry
+        tk.Label(
+            search_frame, text="🔍", bg=appearance_manager.bg_color, fg="white"
+        ).pack(side="left", padx=5)
+
+        self.search_var = tk.StringVar()
+        self.search_var.trace("w", self.on_search_change)
+
+        self.search_entry = tk.Entry(
+            search_frame,
+            textvariable=self.search_var,
+            bg="#2A2A2A",
+            fg="white",
+            insertbackground="white",
+            font=("Bai Jamjuree Light", 16),
+        )
+        self.search_entry.pack(fill="x", expand=True, padx=(0, 5))
+
+        # Action buttons container
+        action_frame = tk.Frame(self.display_frame, bg=appearance_manager.bg_color)
+        action_frame.pack(fill="x", pady=5)
+
+        # Save changes button
+        self.save_button = tk.Button(
+            action_frame,
+            text="SAVE CHANGES",
+            command=self.save_changes,
+            bg="#2A2A2A",
+            fg="white",
+            activebackground="#FF4444",
+            bd=0,
+            font=("Arial", 10, "bold"),
+        )
+        self.save_button.pack(side="right", padx=5)
+
+        # Text container with scrollbars
+        text_container = tk.Frame(self.display_frame, bg=appearance_manager.bg_color)
+        text_container.pack(fill="both", expand=True)
+
+        # Scrollbars
+        yscroll = ttk.Scrollbar(text_container, orient="vertical")
+        xscroll = ttk.Scrollbar(text_container, orient="horizontal")
+
+        # JSON text display
+        self.json_display = tk.Text(
+            text_container,
+            wrap=tk.NONE,
+            bg="#1A1A1A",
+            fg="white",
+            font=("Bai Jamjuree Light.ttf", 16),
+            insertbackground="white",
+            yscrollcommand=yscroll.set,
+            xscrollcommand=xscroll.set,
+        )
+
+        # Configure tags for search highlighting
+        self.json_display.tag_configure(
+            "search_highlight", background="#2ECC71", foreground="black"
+        )
+
+        # Configure scrollbars
+        yscroll.config(command=self.json_display.yview)
+        xscroll.config(command=self.json_display.xview)
+
+        # Grid layout
+        self.json_display.grid(row=0, column=0, sticky="nsew")
+        yscroll.grid(row=0, column=1, sticky="ns")
+        xscroll.grid(row=1, column=0, sticky="ew")
+
+        text_container.grid_rowconfigure(0, weight=1)
+        text_container.grid_columnconfigure(0, weight=1)
+
+    def validate_font(self, font_name):
+        """Validate if font exists and is usable"""
+        return (
+            font_name in font.families()
+            or os.path.exists(font_name)
+            or font_name in self.available_fonts
+        )
+
+    def update_font_display(self):
+        """Update font display in all relevant widgets"""
+        if hasattr(self, "json_display"):
+            try:
+                font_obj = font.Font(
+                    family=self.current_font, size=self.current_font_size
+                )
+                self.json_display.configure(font=font_obj)
+                self.window.update_idletasks()
+            except Exception as e:
+                print(f"Font update failed: {e}")
+                self.revert_to_default_font()
+
+    def revert_to_default_font(self):
+        """Revert to default font if current font fails"""
+        self.current_font = self.get_default_font()
+        self.update_font_display()
+
+    def load_data(self):
+        """Load NPC data from JSON file"""
+        try:
+            with open("NPC.json", "r", encoding="utf-8") as file:
+                data = json.load(file)
+                # สรุปข้อมูลที่โหลด
+                summary = {
+                    "main_characters": len(data.get("main_characters", [])),
+                    "npcs": len(data.get("npcs", [])),
+                    "lore": len(data.get("lore", {})),
+                    "character_roles": len(data.get("character_roles", {})),
+                    "word_fixes": len(data.get("word_fixes", {})),
+                }
+                print("NPC Data Summary:")
+                for category, count in summary.items():
+                    print(f"- {category}: {count} entries")
+                return data
+        except FileNotFoundError:
+            print("Error: NPC.json file not found")
+            messagebox.showerror("Error", "NPC.json file not found!")
+            return {}
+        except json.JSONDecodeError:
+            print("Error: Invalid JSON in NPC.json")
+            messagebox.showerror("Error", "Invalid JSON in NPC.json!")
+            return {}
+
+    def flash_success_message(self, message):
+        """Show floating success message with fade effect"""
+        print(f"Showing success message: {message}")
+        popup = tk.Toplevel(self.window)
+        popup.overrideredirect(True)
+        popup.configure(bg="#28a745")
+        popup.attributes("-alpha", 0.9)
+
+        # Position relative to window
+        x = self.window.winfo_x() + self.window.winfo_width() // 2
+        y = self.window.winfo_y() + self.window.winfo_height() // 2
+        popup.geometry(f"+{x}+{y}")
+
+        # Message label
+        label = tk.Label(
+            popup,
+            text=message,
+            fg="white",
+            bg="#28a745",
+            font=("Arial", 12),
+            padx=20,
+            pady=10,
+        )
+        label.pack()
+
+        # Fade effect
+        def fade_away():
+            alpha = popup.attributes("-alpha")
+            if alpha > 0:
+                popup.attributes("-alpha", alpha - 0.1)
+                popup.after(50, fade_away)
+            else:
+                popup.destroy()
+
+        popup.after(500, fade_away)
+
+    def setup_entry_form(self):
+        """Create and configure the entry form for data input"""
+        print("Setting up entry form...")
+        self.entry_vars = {}
+
+        # Title container
+        title_container = tk.Frame(self.entry_panel, bg=appearance_manager.bg_color)
+        title_container.pack(fill="x", pady=10)
+
+        # Form title
+        self.form_title = tk.Label(
+            title_container,
+            text="ENTRY FORM",
+            font=("Nasalization Rg", 12),
+            bg=appearance_manager.bg_color,
+            fg="#808080",
+        )
+        self.form_title.pack()
+
+        # Scrollable container for fields
+        self.fields_container = tk.Frame(
+            self.entry_panel, bg=appearance_manager.bg_color
+        )
+        self.fields_container.pack(fill="both", expand=True, padx=10)
+
+        # Action buttons container (สร้างครั้งเดียว)
+        self.action_frame = tk.Frame(
+            self.entry_panel, bg=appearance_manager.bg_color, height=50
+        )
+        self.action_frame.pack(side="bottom", fill="x", padx=10, pady=10)
+        self.action_frame.pack_propagate(False)
+
+        # Add Entry button (สร้างครั้งเดียว)
+        self.add_btn = tk.Button(
+            self.action_frame,
+            text="ADD ENTRY",
+            command=self.add_entry,
+            bg="#2A2A2A",
+            fg="white",
+            activebackground="#FF4444",
+            bd=0,
+            font=("Arial", 10, "bold"),
+        )
+        self.add_btn.pack(fill="x", pady=(0, 5))
+
+        # Add hover effects
+        self.add_btn.bind("<Enter>", lambda e: self.add_btn.configure(bg="#404040"))
+        self.add_btn.bind("<Leave>", lambda e: self.add_btn.configure(bg="#2A2A2A"))
+        print("Entry form setup complete")
+
+    def setup_section_fields(self, section):
+        """Create input fields based on section type"""
+        print(f"Setting up fields for section: {section}")
+        # Clear existing fields
+        for widget in self.fields_container.winfo_children():
+            widget.destroy()
+
+        # Define fields based on section
+        if section == "main_characters":
+            fields = ["firstName", "lastName", "gender", "role", "relationship"]
+        elif section == "npcs":
+            fields = ["name", "role", "description"]
+        elif section == "lore":
+            fields = ["term", "description"]
+        elif section == "character_roles":
+            fields = ["character", "style"]
+        elif section == "word_fixes":
+            fields = ["incorrect", "correct"]
+        else:
+            print(f"Unknown section: {section}")
+            return
+
+        # Create fields
+        print("Creating fields...")
+        self.entry_vars = {}
+        for field in fields:
+            field_frame = tk.Frame(
+                self.fields_container, bg=appearance_manager.bg_color
+            )
+            field_frame.pack(fill="x", pady=5)
+
+            # Label with hint
+            label = tk.Label(
+                field_frame,
+                text=field.capitalize(),
+                bg=appearance_manager.bg_color,
+                fg="#808080",
+                font=("Bai Jamjuree Light.ttf", 16),
+            )  # ใช้ฟอนต์เดียวกับที่เลือก
+            label.pack(anchor="w")
+
+            # Entry field
+            if field in ["description", "style"]:
+                entry = tk.Text(
+                    field_frame,
+                    height=4,
+                    bg="#2A2A2A",
+                    fg="white",
+                    insertbackground="white",
+                    font=("Bai Jamjuree Light.ttf", 16),
+                )  # ใช้ฟอนต์เดียวกับที่เลือก
+                entry.pack(fill="x")
+                self.entry_vars[field] = entry
+            else:
+                var = tk.StringVar()
+                self.entry_vars[field] = var
+                entry = tk.Entry(
+                    field_frame,
+                    textvariable=var,
+                    bg="#2A2A2A",
+                    fg="white",
+                    insertbackground="white",
+                    font=("Bai Jamjuree Light.ttf", 16),
+                )  # ใช้ฟอนต์เดียวกับที่เลือก
+                entry.pack(fill="x")
+
+    def show_section(self, section):
+        """Display and setup selected section"""
+        print(f"Showing section: {section}")
+        self.current_section = section
+        self.setup_section_fields(section)
+
+        # Clear search when changing sections
+        if hasattr(self, "search_var"):
+            self.search_var.set("")
+
+        self.update_json_display()
+
+        # Update form title
+        section_title = section.replace("_", " ").title()
+        self.form_title.configure(text=f"{section_title} Entry")
+
+        # อัพเดทสีของทุกปุ่ม
+        for section_id, btn in self.section_buttons.items():
+            if section_id == self.current_section:
+                btn.configure(bg="#2A2A2A", fg="yellow")  # ปุ่มที่เลือก
+            else:
+                btn.configure(bg=appearance_manager.bg_color, fg="white")  # ปุ่มอื่นๆ
+
+    def add_entry(self):
+        """Add or update entry in the current section"""
+        if not self.current_section:
+            print("No section selected")
+            return
+
+        print("Adding new entry...")
+        # Collect field values
+        new_entry = {}
+        for field, var in self.entry_vars.items():
+            if isinstance(var, tk.Text):
+                value = var.get("1.0", tk.END).strip()
+            else:
+                value = var.get().strip()
+            new_entry[field] = value
+
+        # ตรวจสอบเฉพาะฟิลด์แรกของแต่ละส่วน
+        required_first_fields = {
+            "main_characters": "firstName",
+            "npcs": "name",
+            "lore": "term",
+            "character_roles": "character",
+            "word_fixes": "incorrect",
+        }
+
+        first_field = required_first_fields.get(self.current_section)
+        if not first_field or not new_entry.get(first_field):
+            print(f"Validation failed: Required field {first_field} is empty")
+            messagebox.showwarning("Warning", f"The field '{first_field}' is required.")
+            return
+
+        try:
+            # จัดการข้อมูลตามประเภท
+            if self.current_section in ["main_characters", "npcs"]:
+                self.add_list_entry(new_entry)
+            else:
+                self.add_dict_entry(new_entry)
+
+            # เคลียร์ฟอร์มและอัพเดทการแสดงผล
+            self.clear_entry_fields()
+            self.update_json_display()
+            self.flash_success_message("Entry added successfully!")
+            print("Entry added successfully")
+
+        except Exception as e:
+            print(f"Error adding entry: {e}")
+            messagebox.showerror("Error", f"Failed to add entry: {str(e)}")
+
+    def add_list_entry(self, new_entry):
+        """Add entry to list-type sections"""
+        key_field = "firstName" if self.current_section == "main_characters" else "name"
+        print(f"Adding list entry with {key_field}: {new_entry[key_field]}")
+
+        if not self.current_section in self.data:
+            self.data[self.current_section] = []
+
+        # Check for existing entry
+        entries = self.data[self.current_section]
+        for i, entry in enumerate(entries):
+            if entry.get(key_field, "").lower() == new_entry[key_field].lower():
+                if messagebox.askyesno(
+                    "Update Entry",
+                    f"Entry with {key_field} '{new_entry[key_field]}' exists.\n"
+                    "Do you want to update it?",
+                ):
+                    entries[i] = new_entry
+                    print("Entry updated")
+                    return
+                return
+
+        # Add new entry
+        entries.append(new_entry)
+        print("New entry added to list")
+
+    def add_dict_entry(self, new_entry):
+        """Add entry to dictionary-type sections"""
+        if not self.current_section in self.data:
+            self.data[self.current_section] = {}
+
+        # Determine key and value based on section
+        if self.current_section == "lore":
+            key, value = new_entry["term"], new_entry["description"]
+        elif self.current_section == "character_roles":
+            key, value = new_entry["character"], new_entry["style"]
+        else:  # word_fixes
+            key, value = new_entry["incorrect"], new_entry["correct"]
+
+        print(f"Adding dictionary entry: {key}")
+
+        # Check for existing entry
+        if key in self.data[self.current_section]:
+            if messagebox.askyesno(
+                "Update Entry",
+                f"Entry for '{key}' exists.\n" "Do you want to update it?",
+            ):
+                self.data[self.current_section][key] = value
+                print("Entry updated")
+        else:
+            self.data[self.current_section][key] = value
+            print("New entry added to dictionary")
+
+    def clear_entry_fields(self):
+        """Clear all entry fields"""
+        print("Clearing entry fields")
+        for var in self.entry_vars.values():
+            if isinstance(var, tk.Text):
+                var.delete("1.0", tk.END)
+            else:
+                var.set("")
+
+    def on_search_change(self, *args):
+        """Handle real-time search with highlighting"""
+        try:
+            search_term = self.search_var.get().lower()
+
+            if not self.current_section or not self.json_display:
+                return
+
+            # Get current text
+            current_text = self.json_display.get("1.0", tk.END)
+
+            # Remove existing highlights
+            self.json_display.tag_remove("search_highlight", "1.0", tk.END)
+
+            if search_term:
+                # Find and highlight matches
+                start_idx = "1.0"
+                first_match = None
+
+                while True:
+                    # Find next match
+                    start_idx = self.json_display.search(
+                        search_term, start_idx, tk.END, nocase=True
+                    )
+                    if not start_idx:
+                        break
+
+                    # Calculate end index
+                    end_idx = f"{start_idx}+{len(search_term)}c"
+
+                    # Add highlight
+                    self.json_display.tag_add("search_highlight", start_idx, end_idx)
+
+                    # Store first match
+                    if not first_match:
+                        first_match = start_idx
+
+                    # Move to next position
+                    start_idx = end_idx
+
+                # Scroll to first match if found
+                if first_match:
+                    self.json_display.see(first_match)
+
+        except Exception as e:
+            print(f"Search error: {e}")
+
+    def start_move(self, event):
+        """Start window drag operation"""
+        self.x = event.x
+        self.y = event.y
+
+    def do_move(self, event):
+        """Handle window dragging"""
+        try:
+            deltax = event.x - self.x
+            deltay = event.y - self.y
+            x = self.window.winfo_x() + deltax
+            y = self.window.winfo_y() + deltay
+            self.window.geometry(f"+{x}+{y}")
+        except Exception as e:
+            print(f"Move error: {e}")
+
+    def start_resize(self, event):
+        """Initialize window resize operation"""
+        self.is_resizing = True
+        self.resize_x = event.x_root
+        self.resize_y = event.y_root
+        self.resize_w = self.window.winfo_width()
+        self.resize_h = self.window.winfo_height()
+        print("\rStarting resize operation...", end="", flush=True)
+
+    def on_resize(self, event):
+        """Handle window resizing"""
+        if not self.is_resizing:
+            return
+
+        try:
+            dx = event.x_root - self.resize_x
+            dy = event.y_root - self.resize_y
+            w = max(800, self.resize_w + dx)
+            h = max(600, self.resize_h + dy)
+            self.window.geometry(f"{w}x{h}")
+            # No logging during resize
+        except Exception as e:
+            print(f"\rResize error: {e}", end="", flush=True)
+
+    def stop_resize(self, event):
+        """End window resize operation"""
+        if self.is_resizing:
+            final_w = self.window.winfo_width()
+            final_h = self.window.winfo_height()
+            print(f"\rResize complete - New size: {final_w}x{final_h}")
+        self.is_resizing = False
+
+    def update_json_display(self, search_term=None):
+        """อัพเดทการแสดงผล JSON พร้อมรักษา formatting"""
+        if not self.current_section or self.current_section not in self.data:
+            print(f"No data for section: {self.current_section}")
+            self.json_display.delete("1.0", tk.END)
+            return
+
+        try:
+            section_data = self.data[self.current_section]
+
+            # จัดรูปแบบ JSON ให้สวยงาม
+            json_text = json.dumps(section_data, indent=4, ensure_ascii=False)
+
+            # เก็บตำแหน่ง scroll ปัจจุบัน
+            current_scroll = None
+            if hasattr(self.json_display, "yview"):
+                current_scroll = self.json_display.yview()
+
+            # อัพเดทข้อความ
+            self.json_display.config(state="normal")
+            self.json_display.delete("1.0", tk.END)
+            self.json_display.insert("1.0", json_text)
+
+            # ถ้ามีคำค้นหา ให้ไฮไลท์
+            if search_term:
+                self.highlight_search_term(search_term)
+
+            # คืนค่า scroll position
+            if current_scroll:
+                self.json_display.yview_moveto(current_scroll[0])
+
+        except Exception as e:
+            print(f"Failed to update display: {e}")
+            messagebox.showerror("Error", f"Failed to update display: {str(e)}")
+
+    def highlight_search_term(self, search_term):
+        """ไฮไลท์คำที่ค้นหา โดยไม่ใช้ canvas"""
+        if not search_term:
+            return
+
+        try:
+            # ลบไฮไลท์เก่า
+            self.json_display.tag_remove("search_highlight", "1.0", tk.END)
+
+            # ค้นหาและไฮไลท์คำใหม่
+            start_idx = "1.0"
+            while True:
+                start_idx = self.json_display.search(
+                    search_term.lower(), start_idx, tk.END, nocase=True
+                )
+                if not start_idx:
+                    break
+                end_idx = f"{start_idx}+{len(search_term)}c"
+                self.json_display.tag_add("search_highlight", start_idx, end_idx)
+                start_idx = end_idx
+
+        except Exception as e:
+            print(f"Highlight error: {e}")
+
+    def update_data_from_display(self):
+        """อัพเดทข้อมูลจาก json_display กลับไปที่ self.data"""
+        try:
+            if not self.current_section:
+                return False
+
+            # ดึงข้อความจาก display
+            json_text = self.json_display.get("1.0", tk.END).strip()
+            if not json_text:
+                return False
+
+            # แปลง JSON string เป็น Python object
+            updated_data = json.loads(json_text)
+
+            # ตรวจสอบรูปแบบข้อมูล
+            if self.current_section in ["main_characters", "npcs"]:
+                if not isinstance(updated_data, list):
+                    raise ValueError(f"Invalid data format for {self.current_section}")
+            else:
+                if not isinstance(updated_data, dict):
+                    raise ValueError(f"Invalid data format for {self.current_section}")
+
+            # อัพเดทข้อมูลในส่วนที่กำลังแก้ไข
+            self.data[self.current_section] = updated_data
+            return True
+
+        except json.JSONDecodeError as e:
+            messagebox.showerror("Error", f"Invalid JSON format: {str(e)}")
+            return False
+        except Exception as e:
+            messagebox.showerror("Error", f"Failed to update data: {str(e)}")
+            return False
+
+    def save_changes(self):
+        """บันทึกการเปลี่ยนแปลงลงไฟล์"""
+        print("Saving changes to file...")
+        try:
+            if not self.update_data_from_display():
+                return
+
+            required_sections = [
+                "main_characters",
+                "npcs",
+                "lore",
+                "character_roles",
+                "word_fixes",
+            ]
+            for section in required_sections:
+                if section not in self.data:
+                    raise ValueError(f"Missing required section: {section}")
+
+            with open("NPC.json", "w", encoding="utf-8") as file:
+                json.dump(self.data, file, indent=4, ensure_ascii=False)
+
+            self.flash_success_message("Changes saved successfully!")
+            print("Changes saved successfully")
+
+            # เรียกใช้ callback เพื่อรีโหลดข้อมูล
+            if self.reload_callback:
+                print("Triggering NPC data reload...")
+                self.reload_callback()
+                self.flash_success_message("NPC context reloaded!")
+
+        except Exception as e:
+            error_msg = f"Failed to save changes: {str(e)}"
+            print(f"Save error: {error_msg}")
+            messagebox.showerror("Error", error_msg)
+
+    def reload_npc_data(self):
+        """เรียกใช้ฟังก์ชัน reload ใน main app"""
+        try:
+            # ส่งสัญญาณไปที่ main app
+            if hasattr(self.parent, "reload_npc_data"):
+                self.parent.reload_npc_data()
+                self.flash_success_message("Reloading NPC context data...")
+                # delay นิดหน่อยก่อนแสดงข้อความสำเร็จ
+                self.window.after(
+                    1000,
+                    lambda: self.flash_success_message(
+                        "NPC context reloaded successfully!"
+                    ),
+                )
+        except Exception as e:
+            messagebox.showerror("Error", f"Failed to reload NPC data: {str(e)}")
+
+    def increase_font_size(self):
+        """Increase font size by one step"""
+        print("Increasing font size")
+        current_idx = self.font_sizes.index(self.current_font_size)
+        if current_idx < len(self.font_sizes) - 1:
+            self.current_font_size = self.font_sizes[current_idx + 1]
+            self.update_font_size()
+            print(f"New font size: {self.current_font_size}")
+
+    def decrease_font_size(self):
+        """Decrease font size by one step"""
+        print("Decreasing font size")
+        current_idx = self.font_sizes.index(self.current_font_size)
+        if current_idx > 0:
+            self.current_font_size = self.font_sizes[current_idx - 1]
+            self.update_font_size()
+            print(f"New font size: {self.current_font_size}")
+
+    def update_font_size(self):
+        """Update font size in JSON display and size label"""
+        print(f"Updating font size to: {self.current_font_size}")
+        try:
+            if hasattr(self, "json_display"):
+                # Store current text and state
+                current_text = self.json_display.get("1.0", tk.END)
+                current_state = self.json_display.cget("state")
+
+                # Enable for changes
+                self.json_display.config(state="normal")
+
+                # Update font
+                self.json_display.configure(
+                    font=(self.current_font, self.current_font_size)
+                )
+
+                # Reapply text
+                self.json_display.delete("1.0", tk.END)
+                self.json_display.insert("1.0", current_text)
+
+                # Restore state
+                self.json_display.config(state=current_state)
+
+            # Update size label
+            if hasattr(self, "size_label"):
+                self.size_label.configure(text=str(self.current_font_size))
+
+            print("Font size update complete")
+
+        except Exception as e:
+            print(f"Font size update error: {e}")
+            messagebox.showerror("Error", f"Failed to update font size: {str(e)}")
+
+    def on_font_change(self, event=None):
+        """Handle font change with automatic apply"""
+        new_font = self.font_var.get()
+        print(f"Font change requested to: {new_font}")
+        if new_font in self.available_fonts:
+            try:
+                self.current_font = new_font
+
+                # Update json display
+                if hasattr(self, "json_display"):
+                    self.json_display.configure(font=(new_font, self.current_font_size))
+
+                # Update entry fields
+                for var in self.entry_vars.values():
+                    if isinstance(var, tk.Text):
+                        var.configure(font=(new_font, self.current_font_size))
+
+                self.flash_success_message(f"Font changed to {new_font}")
+                print("Font change successful")
+            except Exception as e:
+                print(f"Font change error: {e}")
+                self.revert_to_default_font()
+
+    def on_window_configure(self, event):
+        """Handle window resize events"""
+        if event and event.widget == self.window and not self.is_resizing:
+            # Update component positions silently
+            self.close_button.place(x=self.window.winfo_width() - 30, y=5)
+            self.resize_handle.place(relx=1, rely=1, anchor="se")
+
+            # Maintain minimum size without logging
+            if event.width < 800:
+                self.window.geometry(f"800x{event.height}")
+            if event.height < 600:
+                self.window.geometry(f"{event.width}x600")
+
+    def find_and_display_character(self, character_name: str, is_verified: bool = False) -> None:
+        try:
+            # Clear any existing search
+            if hasattr(self, 'search_var'):
+                self.search_var.set('')
+                
+            character_found = False
+                
+            # Check main characters first
+            for char in self.data.get('main_characters', []):
+                if (character_name == char['firstName'] or 
+                    character_name == f"{char['firstName']} {char['lastName']}".strip()):
+                    self.show_section('main_characters')
+                    self.search_var.set(character_name)
+                    character_found = True
+                    self.logging_manager.log_npc_manager(f"Found character in main_characters: {character_name}")
+                    break
+                    
+            # If not found in main characters, check NPCs
+            if not character_found:
+                for npc in self.data.get('npcs', []):
+                    if character_name == npc['name']:
+                        self.show_section('npcs')
+                        self.search_var.set(character_name)
+                        character_found = True
+                        self.logging_manager.log_npc_manager(f"Found character in NPCs: {character_name}")
+                        break
+                        
+            # If character not found anywhere, prepare for new entry
+            if not character_found:
+                self._prepare_new_character_form(character_name)
+                self.logging_manager.log_npc_manager(f"Preparing form for new character: {character_name}")
+                
+        except Exception as e:
+            error_msg = f"Error finding character {character_name}: {e}"
+            self.logging_manager.log_error(error_msg)
+            self.flash_message(error_msg, "error")
+
+    def _prepare_new_character_form(self, character_name: str) -> None:
+        """
+        เตรียมฟอร์มสำหรับเพิ่มตัวละครใหม่ โดยใส่ชื่อเต็มในช่องเดียว
+        
+        Args:
+            character_name: ชื่อตัวละครที่ต้องการเพิ่ม
+        """
+        try:
+            # Show main characters section for new entry
+            self.show_section('main_characters')
+            
+            # Clear existing form fields
+            for var in self.entry_vars.values():
+                if isinstance(var, tk.Text):
+                    var.delete('1.0', tk.END)
+                else:
+                    var.set('')
+                    
+            # ใส่ชื่อเต็มในช่อง firstName โดยไม่แยกนามสกุล
+            clean_name = character_name.strip(":!?. ")
+            self.entry_vars['firstName'].set(clean_name)
+                
+            # Set default values for other fields
+            self.entry_vars['gender'].set('Neutral')
+            self.entry_vars['role'].set('Adventure')
+            self.entry_vars['relationship'].set('Neutral')
+            
+            # Show helper message
+            self.flash_success_message(f"Ready to add new character: {clean_name}")
+            self.logging_manager.log_info(f"Prepared form for new character: {clean_name}")
+            
+        except Exception as e:
+            self.logging_manager.log_error(f"Error preparing new character form: {e}")
+            self.flash_message(f"Error preparing form: {str(e)}", "error")
+
+    def flash_message(self, message: str, message_type: str = "info") -> None:
+        """
+        แสดงข้อความแจ้งเตือนแบบ fade
+        
+        Args:
+            message: ข้อความที่ต้องการแสดง
+            message_type: ประเภทข้อความ ('info', 'error', 'success')
+        """
+        # กำหนดสีตามประเภทข้อความ
+        colors = {
+            'info': '#2196F3',    # สีฟ้า
+            'error': '#F44336',   # สีแดง
+            'success': '#4CAF50'  # สีเขียว
+        }
+        bg_color = colors.get(message_type, colors['info'])
+        
+        popup = tk.Toplevel(self.window)
+        popup.overrideredirect(True)
+        popup.configure(bg=bg_color)
+        popup.attributes('-alpha', 0.9)
+        
+        # จัดตำแหน่งกลางหน้าต่าง
+        x = self.window.winfo_x() + self.window.winfo_width() // 2
+        y = self.window.winfo_y() + self.window.winfo_height() // 2
+        popup.geometry(f"+{x}+{y}")
+        
+        # สร้าง label สำหรับข้อความ
+        label = tk.Label(
+            popup,
+            text=message,
+            fg='white',
+            bg=bg_color,
+            font=('Arial', 12),
+            padx=20,
+            pady=10
+        )
+        label.pack()
+        
+        # ฟังก์ชัน fade effect
+        def fade_away():
+            alpha = popup.attributes('-alpha')
+            if alpha > 0:
+                popup.attributes('-alpha', alpha - 0.1)
+                popup.after(50, fade_away)
+            else:
+                popup.destroy()
+                
+        popup.after(1000, fade_away)
+    
+    def show_window(self):
+        """Show the NPC Manager window"""
+        print("Showing NPC Manager window")
+        self.window.deiconify()
+        if not self.current_section and self.data:
+            first_section = next(iter(self.data.keys()))
+            self.show_section(first_section)
+            print(f"Auto-selected first section: {first_section}")
+
+    def hide_window(self):
+        """Hide the NPC Manager window"""
+        print("Hiding NPC Manager window")
+        self.window.withdraw()
+
+    def is_window_showing(self):
+        """Check if NPC Manager window is currently visible"""
+        return (hasattr(self, "window") and 
+                self.window.winfo_exists() and 
+                self.window.state() != "withdrawn")
+
+    def toggle_window(self):
+        """Toggle window visibility"""
+        if self.is_window_showing():
+            self.window.withdraw()
+        else:
+            self.show_window()
+    
+    def cleanup(self):
+        """Cleanup resources before closing"""
+        try:
+            self.logging_manager.log_info("Cleaning up NPC Manager resources")
+            # ทำความสะอาด resources ต่างๆ
+            if hasattr(self, 'window') and self.window.winfo_exists():
+                self.window.withdraw()
+            
+            # เคลียร์ค่าต่างๆ
+            if hasattr(self, 'search_var'):
+                self.search_var.set('')
+                
+            # เคลียร์ entry fields
+            for var in self.entry_vars.values():
+                if isinstance(var, tk.Text):
+                    var.delete('1.0', tk.END)
+                else:
+                    var.set('')
+                    
+        except Exception as e:
+            self.logging_manager.log_error(f"Error during cleanup: {e}")
+
+def create_npc_manager(parent, reload_callback=None, logging_manager=None):
+    """Create and return a new NPC Manager instance"""
+    return NPCManager(parent, reload_callback, logging_manager)
+
+# Main entry point
+if __name__ == "__main__":
+    root = tk.Tk()
+    app = create_npc_manager(root)
+    root.mainloop()

open for edit api key.env

@@ -0,0 +1,3 @@
+# you can use just one choice or both .
+ANTHROPIC_API_KEY='paste your API KEY HERE'
+OPENAI_API_KEY='paste your API KEY HERE'

screen_capture.py

@@ -0,0 +1,38 @@
+import os
+from PIL import ImageGrab
+from datetime import datetime
+import logging
+
+
+class ScreenCapture:
+    def __init__(self, base_dir="captured_screens"):
+        self.base_dir = base_dir
+        self.categories = {
+            "raw": f"{base_dir}/raw",
+            "processed": f"{base_dir}/processed",
+        }
+        self._init_directories()
+
+    def _init_directories(self):
+        for path in self.categories.values():
+            os.makedirs(path, exist_ok=True)
+
+    def capture_primary_screen(self):
+        try:
+            # จับภาพเฉพาะหน้าจอหลัก
+            screen = ImageGrab.grab(all_screens=False)
+
+            # สร้างชื่อไฟล์ด้วย timestamp
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"screen_{timestamp}.png"
+
+            # บันทึกภาพต้นฉบับ
+            filepath = os.path.join(self.categories["raw"], filename)
+            screen.save(filepath)
+
+            logging.info(f"Captured screen saved to: {filepath}")
+            return filepath
+
+        except Exception as e:
+            logging.error(f"Screen capture failed: {e}")
+            return None

settings.py

@@ -0,0 +1,1234 @@
+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 = {
+        # Main parameters for the model
+        "model": "gpt-4o",
+        "displayed_model": "gpt-4o",
+        "max_tokens": 500,
+        "temperature": 0.7,
+        "top_p": 0.9,
+        # Additional OCR settings for multiple languages
+        "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
+        "translation_settings": {
+            "source_languages": ["en", "ko"],
+            "target_language": "th",
+            "preserve_names": True,
+            "modern_style": True,
+            "flirty_tone": True,
+            "use_emojis": True,
+        },
+        # Special characters handling
+        "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")
+
+        # Check for valid model
+        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}")
+
+        # Validate numeric values
+        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:
+            # จัดการ API parameters
+            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
+
+            # จัดการ current_area
+            if "current_area" in self.settings:
+                current_areas = self.settings["current_area"]
+                if isinstance(current_areas, list):
+                    self.settings["current_area"] = "+".join(current_areas)
+
+            # ตรวจสอบและจัดการ area_presets
+            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:
+            # เพิ่ม default presets
+            self.settings["area_presets"] = [
+                {"name": "Preset 1", "areas": "A+B"},  # Default preset 1
+                {"name": "Preset 2", "areas": "C"},  # Default preset 2
+                {"name": "Preset 3", "areas": "A"},  # Default preset 3
+                {"name": "Preset 4", "areas": "B"},  # Default preset 4
+                {"name": "Preset 5", "areas": "A+B+C"},  # Default preset 5
+            ]
+
+        # ตรวจสอบและอัพเดท API parameters
+        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():
+                # ตรวจสอบว่ามี key ครบทุกตัว
+                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 ทั้งหมด
+            presets = self.settings.get("area_presets", [])
+
+            # สร้างข้อมูล preset ใหม่
+            preset_data = {
+                "name": f"Preset {preset_number}",
+                "areas": areas,
+                "coordinates": coordinates,
+            }
+
+            # อัพเดต preset ในตำแหน่งที่กำหนด
+            index = preset_number - 1
+            if 0 <= index < len(presets):
+                presets[index] = preset_data
+            else:
+                # เพิ่ม preset ใหม่ถ้าไม่มีในตำแหน่งที่ต้องการ
+                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"""
+        # Calculate position for settings window
+        x = parent_x + parent_width + 20
+        y = parent_y
+        self.settings_window.geometry(f"+{x}+{y}")
+
+        # Load current settings into UI
+        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"))
+
+        # Show window
+        self.settings_window.deiconify()
+        self.settings_window.lift()
+        self.settings_window.attributes("-topmost", True)
+        self.settings_visible = True
+
+        # Reset button texts if needed
+        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:
+            # คำนวณตำแหน่งให้อยู่ทางขวาของ settings ui โดยเว้นระยะ 5px
+            parent_x = self.parent.winfo_x()
+            parent_y = self.parent.winfo_y()
+            parent_width = self.parent.winfo_width()
+
+            # กำหนดตำแหน่งใหม่
+            x = parent_x + parent_width + 5  # เว้นระยะห่าง 5px
+            y = parent_y  # ให้อยู่ระดับเดียวกับ settings ui
+
+            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))
+
+            # Update entries with validated values
+            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))
+
+            # Save to settings
+            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"
+            )
+
+            # Reset to current settings values
+            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):
+        # Transparency
+        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)
+
+        # Font Size
+        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()
+
+        # Font Selection
+        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)
+
+        # เพิ่ม callback เมื่อมีการเปลี่ยนฟอนต์
+        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)
+
+            # อัพเดท UI ทันที
+            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,
+                )
+
+                # อัพเดท outlines
+                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)
+
+        # Window Size
+        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
+        apply_button = appearance_manager.create_styled_button(
+            self.settings_window, "Apply", self.apply_settings
+        )
+        apply_button.pack(pady=20)
+
+        # Toggle Variables
+        self.force_translate_var = tk.BooleanVar()
+        self.auto_hide_var = tk.BooleanVar()
+        self.ui_toggle_var = tk.BooleanVar()
+
+        # Toggle Switches
+        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
+        button_container = tk.Frame(
+            self.settings_window, bg=appearance_manager.bg_color
+        )
+        button_container.pack(pady=10)
+
+        # Screen/CPU Settings Button
+        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)
+
+        # Model Settings Button
+        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)
+
+        # Hotkey Button
+        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)
+
+        # Bottom Labels
+        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
+        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)
+
+        # Window Movement Bindings
+        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()
+
+                # ใช้ update_idletasks เพื่อให้แน่ใจว่า geometry ได้รับการอัพเดตแล้ว
+                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:
+                # กรณีกดปุ่ม Apply จาก settings UI
+                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":  # font_style จะถูกจัดการพร้อมกับ font
+                    self.settings.set(key, value)
+
+            # อัพเดท UI components
+            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,
+                    )
+
+                # อัพเดท outlines ถ้ามี
+                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
+                            )
+
+            # เรียก callback ถ้ามี
+            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):
+        # สร้าง advance_ui ใหม่ถ้ายังไม่มีหรือถูกปิดไป
+        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
+            )
+
+        # เปิดหน้าต่าง advance_ui
+        self.advance_ui.open()

settings_ui.py

@@ -0,0 +1,438 @@
+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_scale
+        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:
+            # กรณีกดปุ่ม Apply จาก settings UI
+            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)}")
+
+            # กรณีเรียกจาก advance settings
+            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)
+
+                # Log model change
+                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}")

text_corrector.py

@@ -0,0 +1,397 @@
+import time
+import re
+import json
+import os
+from enum import Enum
+import logging
+
+
+# DialogueType Enum
+class DialogueType(Enum):
+    NORMAL = "normal"  # ข้อความทั่วไป
+    CHARACTER = "character"  # ข้อความของตัวละคร มีชื่อนำหน้า
+    CHOICE = "choice"  # ข้อความตัวเลือกของผู้เล่น
+    SYSTEM = "system"  # ข้อความระบบ
+
+
+class NameConfidence:
+    def __init__(self, name):
+        self.name = name
+        self.confidence = 0.8  # เริ่มต้นที่ 0.8 เพราะผ่านการตรวจสอบแล้ว
+        self.last_update = time.time()
+
+    def add_appearance(self):
+        """อัพเดทเวลาล่าสุดที่พบชื่อนี้"""
+        self.last_update = time.time()
+
+    def should_confirm(self):
+        """ตรวจสอบว่าควรยืนยันชื่อนี้หรือไม่"""
+        return (
+            self.confidence >= 0.7  # ลดเกณฑ์ความเชื่อมั่น
+            and len(self.appearances) >= 2  # ลดจำนวนครั้งที่ต้องเจอ
+            and time.time() - self.appearances[0]["time"] < 600  # เพิ่มเวลาเป็น 10 นาที
+        )
+
+
+class TextCorrector:
+    def __init__(self):
+        self.load_npc_data()
+
+        # สร้างไฟล์ new_friends.json ถ้ายังไม่มี
+        initial_data = {"npcs": [], "last_updated": time.time(), "version": "1.0"}
+        if not os.path.exists("new_friends.json"):
+            try:
+                with open("new_friends.json", "w", encoding="utf-8") as f:
+                    json.dump(initial_data, f, indent=4, ensure_ascii=False)
+                logging.info("Created new new_friends.json file")
+            except Exception as e:
+                logging.error(f"Failed to create new_friends.json: {e}")
+
+        # โหลดข้อมูล
+        self.load_new_friends()
+
+        # ระบบแคชใหม่
+        self.temp_names_cache = []  # เปลี่ยนเป็น list เพื่อเก็บลำดับ
+        self.confirmed_names = set()  # เพิ่มบรรทัดนี้
+        self.max_cached_names = 10
+
+    def load_new_friends(self):
+        """โหลดชื่อที่ยืนยันแล้วจาก new_friends.json"""
+        try:
+            if os.path.exists("new_friends.json"):
+                with open("new_friends.json", "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                    for npc in data.get("npcs", []):
+                        self.confirmed_names.add(npc["name"])
+        except Exception as e:
+            logging.error(f"Error loading new_friends.json: {e}")
+
+    def save_new_friend(self, name, role="Unknown", description="Found in dialogue"):
+        try:
+            # สร้างโครงสร้างข้อมูลเริ่มต้น
+            initial_data = {"npcs": [], "last_updated": time.time(), "version": "1.0"}
+
+            # โหลดหรือสร้างไฟล์
+            if os.path.exists("new_friends.json"):
+                with open("new_friends.json", "r", encoding="utf-8") as f:
+                    data = json.load(f)
+            else:
+                data = initial_data
+                logging.info("Creating new new_friends.json file")
+
+            # ตรวจสอบว่ามีชื่อนี้แล้วหรือยัง
+            if not any(npc["name"] == name for npc in data["npcs"]):
+                # เพิ่มข้อมูล timestamp และความมั่นใจ
+                npc_data = {
+                    "name": name,
+                    "role": role,
+                    "description": description,
+                    "added_timestamp": time.time(),
+                    "confidence": 1.0,  # ยืนยันแล้ว
+                }
+                data["npcs"].append(npc_data)
+                data["last_updated"] = time.time()
+
+                # บันทึกไฟล์
+                with open("new_friends.json", "w", encoding="utf-8") as f:
+                    json.dump(data, f, indent=4, ensure_ascii=False)
+
+                self.confirmed_names.add(name)
+                logging.info(f"New friend saved: {name}")
+
+        except Exception as e:
+            logging.error(f"Error saving new friend: {e}")
+            # สร้างไฟล์ใหม่ถ้าเกิดข้อผิดพลาด
+            if not os.path.exists("new_friends.json"):
+                try:
+                    with open("new_friends.json", "w", encoding="utf-8") as f:
+                        json.dump(initial_data, f, indent=4, ensure_ascii=False)
+                    logging.info("Created new new_friends.json file after error")
+                except Exception as e2:
+                    logging.error(f"Failed to create new_friends.json: {e2}")
+
+    def cache_new_name(self, name):
+        """เพิ่มชื่อใหม่เข้าแคชแบบวงกลม"""
+        # ตรวจสอบว่ามีชื่อนี้ในแคชหรือไม่
+        for cached in self.temp_names_cache:
+            if cached.name == name:
+                cached.add_appearance()
+                return cached.name
+
+        # ถ้าไม่มี เพิ่มชื่อใหม่
+        new_name = NameConfidence(name)
+        self.temp_names_cache.append(new_name)
+
+        # ถ้าเกินขนาด ลบตัวแรกออก
+        if len(self.temp_names_cache) > self.max_cached_names:
+            self.temp_names_cache.pop(0)
+
+        return name
+
+    def find_similar_cached_name(self, name):
+        """ค้นหาชื่อที่คล้ายกันในแคช"""
+        highest_similarity = 0
+        best_match = None
+
+        for cached in self.temp_names_cache:
+            similarity = self.calculate_name_similarity(name, cached.name)
+            if (
+                similarity > highest_similarity and similarity > 0.7
+            ):  # ต้องคล้ายกันมากกว่า 70%
+                highest_similarity = similarity
+                best_match = cached.name
+
+        return best_match
+
+    def is_likely_character_name(self, text):
+        """ตรวจสอบว่าข้อความน่าจะเป็นชื่อคนหรือไม่"""
+        words = text.split()
+        first_word = words[0] if words else ""
+
+        # ต้องขึ้นต้นด้วยตัวพิมพ์ใหญ่
+        if not first_word or not first_word[0].isupper():
+            return False
+
+        # ไม่ควรมีตัวอักษรพิเศษมากเกินไป (ยกเว้น ' - และ space)
+        special_chars = sum(1 for c in text if not c.isalnum() and c not in "' -")
+        if special_chars > 1:
+            return False
+
+        # ความยาวของชื่อทั้งหมดควรอยู่ในช่วงที่เหมาะสม
+        if len(text) < 2 or len(text) > 50:  # เพิ่มความยาวให้รองรับชื่อยาวๆ
+            return False
+
+        # ตรวจสอบแต่ละคำในชื่อ
+        common_words = {
+            "the",
+            "a",
+            "an",
+            "this",
+            "that",
+            "these",
+            "those",
+            "here",
+            "there",
+        }
+        first_word_lower = first_word.lower()
+
+        # คำแรกต้องไม่ใช่คำทั่วไป
+        if first_word_lower in common_words:
+            return False
+
+        # ถ้ามีหลายคำ ทุกคำควรขึ้นต้นด้วยตัวพิมพ์ใหญ่หรือเป็นคำเชื่อม
+        connecting_words = {"van", "von", "de", "del", "of", "the"}
+        for word in words[1:]:
+            if not word[0].isupper() and word.lower() not in connecting_words:
+                return False
+
+        return True
+
+    def load_npc_data(self):
+        try:
+            with open("NPC.json", "r", encoding="utf-8") as file:
+                npc_data = json.load(file)
+                self.word_corrections = npc_data["word_fixes"]
+                self.names = set()
+
+                # เพิ่ม "???" เป็นชื่อที่ยอมรับได้เป็นลำดับแรก
+                self.names.add("???")
+
+                # Load main characters
+                for char in npc_data["main_characters"]:
+                    self.names.add(char["firstName"])
+                    if char["lastName"]:
+                        self.names.add(f"{char['firstName']} {char['lastName']}")
+
+                # Load NPCs
+                for npc in npc_data["npcs"]:
+                    self.names.add(npc["name"])
+
+                print("TextCorrector: Loaded names:", self.names)  # Debug log
+
+        except FileNotFoundError:
+            raise FileNotFoundError("NPC.json file not found")
+        except json.JSONDecodeError:
+            raise ValueError("Invalid JSON in NPC.json")
+
+    def correct_text(self, text):
+        # เพิ่มการจัดการพิเศษสำหรับ 22, 222 และ ?
+        if text.strip() in ["22", "22?", "222", "222?", "???"]:
+            return "???"
+
+        # ���ทนที่ 22 หรือ 222 ด้วย ??? ถ้าขึ้นต้นด้วย 22 หรือ 222
+        text = re.sub(r"^(22|222)\s*", "??? ", text)
+
+        speaker, content, dialogue_type = self.split_speaker_and_content(text)
+
+        if speaker and speaker != "???":
+            speaker = re.sub(r"[^\w\s\u0E00-\u0E7F]", "", speaker)
+
+        words = content.split() if content else []
+        corrected_words = []
+        for word in words:
+            if not re.search(r"[\u0E00-\u0E7F]", word):
+                word = self.word_corrections.get(word, word)
+            corrected_words.append(word)
+
+        content = (
+            self.clean_content(" ".join(corrected_words)) if corrected_words else ""
+        )
+
+        if speaker:
+            return f"{speaker}: {content}" if content else speaker
+        return content
+
+    def _clean_name(self, name):
+        """ทำความสะอาดชื่อเพื่อเปรียบเทียบ"""
+        if not name:
+            return ""
+        name = name.lower().strip()
+        replacements = {
+            "'": "",
+            "`": "",
+            " ": "",
+            "z": "2",
+            "$": "s",
+            "0": "o",
+            "1": "l",
+        }
+        for old, new in replacements.items():
+            name = name.replace(old, new)
+        return name
+
+    def calculate_name_similarity(self, name1, name2):
+        """คำนวณความคล้ายคลึงของชื่อ"""
+        if not name1 or not name2:
+            return 0
+
+        clean_name1 = self._clean_name(name1)
+        clean_name2 = self._clean_name(name2)
+
+        if clean_name1 == clean_name2:
+            return 1.0
+
+        len1, len2 = len(clean_name1), len(clean_name2)
+        if len1 == 0 or len2 == 0:
+            return 0
+
+        matrix = [[0] * (len2 + 1) for _ in range(len1 + 1)]
+
+        for i in range(len1 + 1):
+            matrix[i][0] = i
+        for j in range(len2 + 1):
+            matrix[0][j] = j
+
+        for i in range(1, len1 + 1):
+            for j in range(1, len2 + 1):
+                if clean_name1[i - 1] == clean_name2[j - 1]:
+                    matrix[i][j] = matrix[i - 1][j - 1]
+                else:
+                    matrix[i][j] = min(
+                        matrix[i - 1][j] + 1,  # deletion
+                        matrix[i][j - 1] + 1,  # insertion
+                        matrix[i - 1][j - 1] + 1,  # substitution
+                    )
+
+        distance = matrix[len1][len2]
+        max_length = max(len1, len2)
+        similarity = 1 - (distance / max_length)
+
+        return similarity
+
+    def is_numeric_name(self, name: str) -> bool:
+        """
+        ตรวจสอบว่าชื่อเป็นตัวเลขหรือไม่
+        Args:
+            name: ชื่อที่ต้องการตรวจสอบ
+        Returns:
+            bool: True ถ้าชื่อเป็นตัวเลข, False ถ้าไม่ใช่
+        """
+        # ลบช่องว่างและอักขระพิเศษ
+        cleaned_name = re.sub(r"[^a-zA-Z0-9]", "", name)
+        # ตรวจสอบว่าเหลือแต่ตัวเลขหรือไม่
+        return cleaned_name.isdigit()
+
+    def split_speaker_and_content(self, text):
+        """แยกชื่อผู้พูดและเนื้อหา"""
+        # ตรวจสอบ ??? หรือ 22 หรือ 222 ก่อน
+        if text.startswith(("???", "??", "22", "222")):
+            for separator in [": ", " - ", " – "]:
+                if separator in text:
+                    content = text.split(separator, 1)[1].strip()
+                    return "???", content, DialogueType.CHARACTER
+            return None, text, DialogueType.NORMAL
+
+        # จัดการกับ underscore ที่ท้ายประโยค
+        text = text.replace("_", "")
+
+        # ตรวจสอบรูปแบบที่มีเครื่องหมายคั่น
+        content_separators = [": ", " - ", " – "]
+        speaker = None
+        content = None
+
+        for separator in content_separators:
+            if separator in text:
+                parts = text.split(separator, 1)
+                if len(parts) == 2:
+                    speaker = parts[0].strip()
+                    content = parts[1].strip()
+
+                    # เพิ่มการตรวจสอบชื่อที่เป็นตัวเลข
+                    if self.is_numeric_name(speaker):
+                        return None, text, DialogueType.NORMAL  # ให้รอ OCR รอบถัดไป
+
+                    # ถ้าชื่อขึ้นต้นด้วย ? ให้แปลงเป็น ???
+                    if speaker.startswith("?"):
+                        speaker = "???"
+                        return speaker, content.strip(), DialogueType.CHARACTER
+
+                    # ตรวจสอบในชื่อที่รู้จัก
+                    if speaker in self.names or speaker in self.confirmed_names:
+                        return speaker, content.strip(), DialogueType.CHARACTER
+                    else:
+                        # ถ้าไม่พบชื่อที่ตรงกัน ให้ถือเป็นข้อความทั้งหมด
+                        return None, text, DialogueType.NORMAL
+
+        # กรณีไม่มีเครื่องหมายคั่น ให้ถือเป็นข้อความทั่วไป
+        return None, text, DialogueType.NORMAL
+
+    def clean_content(self, content):
+        # เพิ่มช่วง Unicode สำหรับภาษาเกาหลี (Hangul)
+        # \u3130-\u318F คือ Hangul Compatibility Jamo
+        # \uAC00-\uD7AF คือ Hangul Syllables
+        content = re.sub(
+            r"[^\w\s\u0E00-\u0E7F\u3130-\u318F\uAC00-\uD7AF.!...—]",
+            "",
+            content
+        )
+
+        # แก้ไข '|' เป็น 'I' เสมอ
+        content = content.replace("|", "I")
+
+        # แก้ไข '!' เป็น 'I' เมื่ออยู่ต้นประโยคหรือหลังช่องว่าง
+        content = re.sub(r'(^|(?<=\s))!(?![\s"\'.])', "I", content)
+
+        # แทนที่สัญลักษณ์การหยุดรอด้วย ...
+        content = re.sub(r"[_\-]{2,}", "...", content)
+
+        # รวมช่องว่าง
+        content = re.sub(r"\s+", " ", content)
+
+        # จัดการ ... ท้ายประโยค
+        if not content.endswith(("...", "!", "—")):
+            content = re.sub(r"\.{1,2}$", "...", content)
+
+        # รักษาเครื่องหมาย —
+        content = content.replace(" - ", " — ")
+
+        return content.strip()
+
+    def reload_data(self):
+        """โหลดข้อมูลใหม่"""
+        print("TextCorrector: Reloading NPC data...")  # เพิ่มบรรทัดนี้
+        self.load_npc_data()
+        # ล้างแคชทั้งหมด
+        self.temp_names_cache.clear()
+        self.load_new_friends()  # โหลด confirmed names ใหม่
+        print("TextCorrector: Data reloaded successfully")  # เพิ่มบรรทัดนี้

translated_logs.py

@@ -0,0 +1,585 @@
+import tkinter as tk
+from tkinter import ttk
+import logging
+from PIL import ImageTk, Image
+from appearance import appearance_manager
+from settings import Settings
+
+logging.basicConfig(level=logging.ERROR)
+
+class Translated_Logs:
+    def __init__(self, root, settings):
+        self.root = root
+        self.settings = settings
+        self.custom_font = appearance_manager.apply_style(self.root)
+
+        # กำหนดค่าเริ่มต้นเป็นซ่อน
+        self.is_visible = False
+        
+        # กำหนดค่าเริ่มต้นของ transparency และ visibility
+        self.is_transparent = False
+        self.normal_alpha = 0.9
+        self.transparent_alpha = 0.6
+        self.super_transparent = 0.4
+        self.is_visible = False
+        self.is_resizing = False
+        self.resize_timer = None
+        
+        # Setup components
+        self.setup_layers()
+        self.setup_ui()
+        self.setup_transparency_control()
+        self.setup_bindings()
+        
+        # จัดตำแหน่งและซ่อน
+        self.root.update_idletasks()
+        self.position_window_bottom_left()
+        self.root.withdraw()
+        
+        logging.info("Translated_Logs initialized in hidden state")
+
+    def setup_layers(self):
+        """Initialize main UI layers for transparency control"""
+        # Main container with 5px padding
+        self.main_frame = tk.Frame(self.root, bg=appearance_manager.bg_color)
+        self.main_frame.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
+        
+        # Background layer
+        self.bg_layer = tk.Frame(self.main_frame)
+        self.bg_layer.place(x=0, y=0, relwidth=1, relheight=1)
+        self.bg_layer.configure(bg=appearance_manager.bg_color)
+        
+        # Content layer
+        self.content_layer = tk.Frame(self.main_frame)
+        self.content_layer.place(x=0, y=0, relwidth=1, relheight=1)
+        self.content_layer.configure(bg=appearance_manager.bg_color)
+
+    def setup_transparency_control(self):
+        """Setup circular transparency toggle button"""
+        try:
+            # Create circular transparency button frame
+            button_size = 24
+            self.transparency_button = tk.Canvas(
+                self.content_layer,
+                width=button_size,
+                height=button_size,
+                bg=appearance_manager.bg_color,
+                highlightthickness=0
+            )
+            self.transparency_button.place(relx=0, rely=1.0, x=10, y=-10, anchor='sw')
+            
+            # Draw circular button
+            padding = 2
+            self.transparency_button.create_oval(
+                padding, padding,
+                button_size-padding, button_size-padding,
+                fill='black',
+                tags='circle'
+            )
+            
+            # Bind events
+            self.transparency_button.tag_bind('circle', '<Button-1>', lambda e: self.toggle_transparency())
+            self.transparency_button.tag_bind('circle', '<Enter>', lambda e: self.transparency_button.itemconfig('circle', fill='#333333'))
+            self.transparency_button.tag_bind('circle', '<Leave>', lambda e: self.transparency_button.itemconfig('circle', fill='black'))
+            
+        except Exception as e:
+            logging.error(f"Error setting up transparency control: {e}")
+
+    def toggle_transparency(self):
+        """Toggle between transparency modes A, B and C"""
+        if not hasattr(self, 'current_mode'):
+            self.current_mode = 'A'
+            
+        if self.current_mode == 'A':
+            self.current_mode = 'B'
+            self.transparency_button.configure(bg='#666666')
+            self.update_transparency(self.transparent_alpha)
+        elif self.current_mode == 'B':
+            self.current_mode = 'C'
+            self.transparency_button.configure(bg='#333333')
+            self.update_transparency(self.super_transparent)
+        else:  # C to A
+            self.current_mode = 'A'
+            self.transparency_button.configure(bg='black')
+            self.update_transparency(self.normal_alpha)
+
+    def update_transparency(self, alpha):
+        """Update transparency while maintaining content visibility"""
+        try:
+            if self.check_visibility():  # เช็คว่า window แสดงอยู่จริง
+                self.bg_layer.configure(bg=appearance_manager.bg_color)
+                self.root.attributes('-alpha', alpha)
+                self.content_layer.lift()
+                self.transparency_button.lift()
+                logging.info(f"Transparency updated to: {alpha}")
+        except Exception as e:
+            logging.error(f"Error updating transparency: {e}")
+
+    def position_window_bottom_left(self):
+        """Position window at bottom left of screen"""
+        screen_width = self.root.winfo_screenwidth()
+        screen_height = self.root.winfo_screenheight()
+        window_width = 300
+        window_height = 1040
+        x = 0
+        y = screen_height - window_height - 40
+        self.root.geometry(f"{window_width}x{window_height}+{x}+{y}")
+
+    def setup_ui(self):
+        """Initialize the main UI components"""
+        self.root.title("Translation History")
+        self.root.overrideredirect(True)
+        self.root.attributes('-topmost', True)
+        
+        # ย้ายการสร้าง frames มาอยู่ที่นี่
+        self.text_frame = tk.Frame(self.content_layer, bg=appearance_manager.bg_color)
+        self.text_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
+        
+        self.setup_text_area()
+        self.setup_scrollbar()
+        self.setup_control_buttons()
+        self.setup_resize_handle()
+        
+        # เพิ่มการตรวจสอบการแสดงผล
+        if not self.root.winfo_viewable():
+            self.root.deiconify()
+            self.root.lift()
+
+    def setup_text_area(self):
+        """Setup text area with custom font and colors"""
+        self.text_area = tk.Text(
+            self.text_frame,
+            wrap=tk.WORD,
+            bg=appearance_manager.bg_color,
+            fg=appearance_manager.fg_color,
+            font=("Tahoma", 16),
+            bd=0,
+            padx=5,  # เพิ่มการเว้นขอบซ้าย-ขวา
+            pady=5,  # เพิ่มการเว้นขอบบน-ล่าง
+            cursor="arrow",
+            insertbackground=appearance_manager.fg_color
+        )
+        self.text_area.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
+        self.text_area.configure(state='disabled')
+        
+        # Scroll to top on init
+        self.text_area.see("1.0")
+
+        # Configure text tags
+        self.text_area.tag_configure('speaker', foreground='#B0B0B0')
+        self.text_area.tag_configure('message', foreground=appearance_manager.fg_color)
+
+    def setup_scrollbar(self):
+        """Setup modern looking scrollbar"""
+        style = ttk.Style()
+        style.theme_use('clam')
+        style.configure(
+            "Custom.Vertical.TScrollbar",
+            background=appearance_manager.bg_color,
+            troughcolor=appearance_manager.lighten_color(appearance_manager.bg_color),
+            width=8,
+            arrowsize=0
+        )
+        
+        self.scrollbar = ttk.Scrollbar(
+            self.text_frame,
+            orient="vertical",
+            command=self.text_area.yview,
+            style="Custom.Vertical.TScrollbar"
+        )
+        self.scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
+        self.text_area.configure(yscrollcommand=self.scrollbar.set)
+
+    def setup_control_buttons(self):
+        """Setup control buttons including hide button"""
+        self.control_frame = tk.Frame(self.content_layer, bg=appearance_manager.bg_color)
+        self.control_frame.place(relx=1.0, rely=1.0, anchor='se', x=-10, y=-10)
+
+        buttons = [
+            ("S", lambda: self.update_font_size(12)),
+            ("M", lambda: self.update_font_size(14)), 
+            ("L", lambda: self.update_font_size(18)),
+            ("Hide", self.hide_window)  # ปุ่ม Hide จะเรียกใช้ hide_window
+        ]
+
+        for text, command in reversed(buttons):
+            btn = tk.Button(
+                self.control_frame,
+                text=text,
+                command=command,
+                font=("Tahoma", 8),
+                fg=appearance_manager.fg_color,
+                bg=appearance_manager.bg_color,
+                bd=0,
+                padx=5,
+                pady=2,
+                cursor="hand2"
+            )
+            btn.pack(side=tk.RIGHT, padx=2)
+            btn.bind('<Enter>', lambda e, b=btn: b.configure(fg='#B0B0B0'))
+            btn.bind('<Leave>', lambda e, b=btn: b.configure(fg=appearance_manager.fg_color))
+
+    def setup_resize_handle(self):
+        """Setup resize handle at bottom right corner"""
+        self.resize_frame = tk.Frame(
+            self.content_layer,
+            bg=appearance_manager.bg_color,
+            cursor="sizing"
+        )
+        self.resize_frame.place(relx=1.0, rely=1.0, anchor="se", width=20, height=20)
+        
+        # Bind resize events with improved handling
+        self.resize_frame.bind('<Button-3>', self.start_resize)
+        self.resize_frame.bind('<B3-Motion>', self.do_resize)
+        self.resize_frame.bind('<ButtonRelease-3>', self.stop_resize)
+
+    def setup_bindings(self):
+        """Setup all event bindings"""
+        # Window movement bindings
+        self.root.bind('<Button-1>', self.start_move)
+        self.root.bind('<ButtonRelease-1>', self.stop_move)
+        self.root.bind('<B1-Motion>', self.do_move)
+        
+        # Content interaction bindings
+        self.text_area.bind('<MouseWheel>', self.on_mousewheel)
+        self.content_layer.bind('<MouseWheel>', self.on_mousewheel)
+        
+        # Layer-specific bindings
+        self.bg_layer.bind('<Button-1>', self.pass_click_to_content)
+        self.bg_layer.bind('<B1-Motion>', self.pass_motion_to_content)
+        
+        # Resize bindings
+        self.resize_frame.bind('<ButtonRelease-3>', lambda e: setattr(self, 'is_resizing', False))
+
+    def pass_click_to_content(self, event):
+        """Pass click events from background to content layer"""
+        # Create new event for content layer
+        new_event = tk.Event()
+        new_event.x = event.x
+        new_event.y = event.y
+        new_event.x_root = event.x_root
+        new_event.y_root = event.y_root
+        self.start_move(new_event)
+
+    def pass_motion_to_content(self, event):
+        """Pass motion events from background to content layer"""
+        if hasattr(self, 'x') and self.x is not None:
+            new_event = tk.Event()
+            new_event.x = event.x
+            new_event.y = event.y
+            new_event.x_root = event.x_root
+            new_event.y_root = event.y_root
+            self.do_move(new_event)
+
+    def start_move(self, event):
+        """Start window movement"""
+        if not self.is_click_on_button(event):
+            self.x = event.x
+            self.y = event.y
+
+    def stop_move(self, event):
+        """Stop window movement"""
+        self.x = None
+        self.y = None
+
+    def do_move(self, event):
+        """Handle window movement"""
+        if hasattr(self, 'x') and self.x is not None:
+            deltax = event.x - self.x
+            deltay = event.y - self.y
+            x = self.root.winfo_x() + deltax
+            y = self.root.winfo_y() + deltay
+            self.root.geometry(f"+{x}+{y}")
+
+    def start_resize(self, event):
+        """Start window resizing with improved precision"""
+        self.is_resizing = True
+        self.start_x = self.root.winfo_x()
+        self.start_y = self.root.winfo_y()
+        self.start_width = self.root.winfo_width()
+        self.start_height = self.root.winfo_height()
+        self.start_resize_x = event.x_root
+        self.start_resize_y = event.y_root
+        
+        # Cancel any existing resize timer
+        if self.resize_timer:
+            self.root.after_cancel(self.resize_timer)
+            self.resize_timer = None
+
+    def do_resize(self, event):
+        """Handle window resizing in realtime"""
+        if not self.is_resizing:
+            return
+
+        dx = event.x_root - self.start_resize_x
+        dy = event.y_root - self.start_resize_y
+
+        # Calculate new dimensions with minimum size constraints
+        new_width = max(300, self.start_width + dx)
+        new_height = max(200, self.start_height + dy)
+
+        # Apply screen bounds
+        max_width = self.root.winfo_screenwidth() - self.start_x
+        max_height = self.root.winfo_screenheight() - self.start_y
+        new_width = min(new_width, max_width)
+        new_height = min(new_height, max_height)
+
+        # Update window size
+        self.root.geometry(f"{int(new_width)}x{int(new_height)}")
+        
+        # Ensure proper layer ordering
+        self.content_layer.lift()
+        self.transparency_button.lift()
+        self.resize_frame.lift()
+
+    def stop_resize(self, event):
+        """Handle the end of resize operation"""
+        if self.is_resizing:
+            self.is_resizing = False
+            
+            # Schedule settings save after resize
+            if self.resize_timer:
+                self.root.after_cancel(self.resize_timer)
+            self.resize_timer = self.root.after(500, self.save_resize_settings) 
+
+    def save_resize_settings(self):
+        """Save window size settings after resize complete"""
+        try:
+            current_settings = {
+                'width': self.root.winfo_width(),
+                'height': self.root.winfo_height()
+            }
+            self.settings.set_logs_settings(**current_settings)
+            logging.info(f"Window size saved: {current_settings}")
+        except Exception as e:
+            logging.error(f"Error saving resize settings: {e}")
+        finally:
+            self.resize_timer = None           
+
+    def adjust_transparency_for_resize(self):
+        """Adjust transparency layers after resize"""
+        # Re-apply transparency settings after resize
+        if self.is_transparent:
+            self.update_transparency(self.transparent_alpha)
+        else:
+            self.update_transparency(self.normal_alpha)
+        
+        # Ensure proper layer ordering
+        self.content_layer.lift()
+        self.transparency_button.lift()
+
+    def is_click_on_button(self, event):
+        """Check if click is on a button"""
+        widget = event.widget.winfo_containing(event.x_root, event.y_root)
+        return isinstance(widget, tk.Button) or isinstance(widget, ttk.Button)
+
+    def on_mousewheel(self, event):
+        """Handle mouse wheel scrolling"""
+        self.text_area.yview_scroll(-1 * (event.delta // 120), "units")
+
+    def add_message(self, text):
+        """Add new message with improved text positioning and line spacing"""
+        try:
+            self.text_area.configure(state='normal')
+            
+            # Get current content length
+            current_content = self.text_area.get("1.0", "end-1c")
+            
+            # Add extra newline if there's existing content
+            if current_content and not current_content.endswith('\n\n'):
+                self.text_area.insert('end', '\n')
+            
+            # Add new message
+            if ': ' in text:
+                speaker, message = text.split(': ', 1)
+                self.text_area.insert('end', f"{speaker}: ", 'speaker')
+                self.text_area.insert('end', f"{message}\n", 'message')
+            else:
+                self.text_area.insert('end', f"{text}\n", 'message')
+
+            self.text_area.configure(state='disabled')
+            
+            # Auto-scroll if near bottom
+            self.smart_scroll()
+            
+        except Exception as e:
+            logging.error(f"Error adding message to logs: {e}")
+            try:
+                self.text_area.configure(state='disabled')
+            except:
+                pass
+
+    def smart_scroll(self):
+        """Smart scrolling behavior"""
+        try:
+            visible_lines = self.text_area.winfo_height() / int(self.text_area.tk.call("font", "metrics", self.text_area.cget("font"), "-linespace"))
+            last_line = int(self.text_area.index('end-1c').split('.')[0])
+            
+            if last_line <= visible_lines or float(self.text_area.yview()[1]) > 0.9:
+                self.text_area.see('end')
+            
+        except Exception as e:
+            logging.error(f"Error in smart scroll: {e}")        
+
+    def check_visibility(self):
+        """Check if window is currently visible"""
+        return self.root.winfo_exists() and self.root.winfo_viewable()        
+
+    def update_font_size(self, size):
+        """Update font size"""
+        try:
+            size = int(size)
+            self.current_font_size = size
+            self.text_area.configure(font=("Tahoma", size))
+            self.scroll_to_bottom()
+            logging.info(f"Font size updated to: {size}")
+        except ValueError:
+            logging.error(f"Invalid font size value: {size}")
+
+    def scroll_to_bottom(self):
+        """Scroll the text area to the bottom"""
+        self.text_area.configure(state='normal')
+        self.text_area.see('end')
+        self.text_area.configure(state='disabled')
+
+    def clear_logs(self):
+        """Clear all text from the logs"""
+        try:
+            self.text_area.configure(state='normal')
+            self.text_area.delete('1.0', 'end')
+            self.text_area.configure(state='disabled')
+            logging.info("Logs cleared")
+        except Exception as e:
+            logging.error(f"Error clearing logs: {e}")
+
+    def show_error(self, error_message):
+        """Display error message in the logs"""
+        try:
+            self.text_area.configure(state='normal')
+            self.text_area.delete('1.0', 'end')
+            self.text_area.insert('end', f"Error: {error_message}\n", 'error')
+            self.text_area.configure(state='disabled')
+            self.scroll_to_bottom()
+        except Exception as e:
+            logging.error(f"Error displaying error message: {e}")
+
+    def show_window(self):
+        """Show window with last transparency state"""
+        if not self.root.winfo_exists():
+            logging.error("Window does not exist")
+            return
+            
+        logging.info("Showing Translated_Logs window")
+        
+        # แสดง window
+        self.root.deiconify()
+        self.root.lift()
+        self.position_window_bottom_left()
+        self.root.attributes('-topmost', True)
+        
+        # ใช้ค่า transparency ล่าสุด
+        alpha = self.transparent_alpha if self.is_transparent else self.normal_alpha
+        self.update_transparency(alpha)
+        
+        self.is_visible = True
+        self.root.update_idletasks()
+        
+        logging.info(f"Window shown with transparency: {alpha}")
+
+    def hide_window(self):
+        """Hide window but maintain state"""
+        if self.root.winfo_exists():
+            logging.info("Hiding Translated_Logs window")
+            self.root.withdraw()
+            self.is_visible = False
+
+    def toggle_window(self):
+        """Toggle window visibility"""
+        if self.root.state() == 'withdrawn':
+            self.show_window()
+        else:
+            self.hide_window()
+
+    def load_settings(self):
+        """Load settings from settings manager"""
+        try:
+            # Load window position and size
+            logs_settings = self.settings.get_logs_settings()
+            
+            if logs_settings:
+                if 'width' in logs_settings and 'height' in logs_settings:
+                    self.root.geometry(f"{logs_settings['width']}x{logs_settings['height']}")
+                
+                if 'font_size' in logs_settings:
+                    self.update_font_size(logs_settings['font_size'])
+                    
+                if 'transparency' in logs_settings:
+                    if logs_settings['transparency']:
+                        self.toggle_transparency()
+                        
+            logging.info("Settings loaded successfully")
+            
+        except Exception as e:
+            logging.error(f"Error loading settings: {e}")
+            # Use default settings
+            self.position_window_bottom_left()
+
+    def save_settings(self):
+        """Save current settings"""
+        try:
+            current_settings = {
+                'width': self.root.winfo_width(),
+                'height': self.root.winfo_height(),
+                'font_size': self.current_font_size,
+                'transparency': self.is_transparent
+            }
+            
+            self.settings.set_logs_settings(**current_settings)
+            logging.info("Settings saved successfully")
+            
+        except Exception as e:
+            logging.error(f"Error saving settings: {e}")
+
+    def apply_theme(self, theme_settings):
+        """Apply theme settings"""
+        try:
+            if 'bg_color' in theme_settings:
+                self.bg_layer.configure(bg=theme_settings['bg_color'])
+            
+            if 'fg_color' in theme_settings:
+                self.text_area.configure(fg=theme_settings['fg_color'])
+                self.text_area.tag_configure('message', foreground=theme_settings['fg_color'])
+                
+            if 'font' in theme_settings:
+                current_size = self.text_area.cget('font').split()[-1]
+                self.text_area.configure(font=(theme_settings['font'], current_size))
+                
+            logging.info("Theme applied successfully")
+            
+        except Exception as e:
+            logging.error(f"Error applying theme: {e}")
+
+    def cleanup(self):
+        """Cleanup before closing"""
+        try:
+            self.save_settings()
+            logging.info("Cleanup completed successfully")
+        except Exception as e:
+            logging.error(f"Error during cleanup: {e}")
+
+if __name__ == "__main__":
+    root = tk.Tk()
+    settings = Settings()
+    app = Translated_Logs(root, settings)
+    
+    # Test message
+    app.add_message("System: Translation logs initialized")
+    app.add_message("User: Hello World!")
+    app.add_message("Assistant: こんにちは世界！")
+    
+    def on_closing():
+        app.cleanup()
+        root.destroy()
+    
+    root.protocol("WM_DELETE_WINDOW", on_closing)
+    root.mainloop()                    

translated_ui.py

@@ -0,0 +1,1528 @@
+import time
+import tkinter as tk
+from tkinter import ttk
+from PIL import ImageTk, Image
+import logging
+import os
+import math
+from tkinter import colorchooser
+from typing import Optional, Dict, List, Tuple, Callable, Any, Union
+from dataclasses import dataclass
+from appearance import appearance_manager
+from settings import Settings
+from tkinter import ttk, messagebox
+
+logging.basicConfig(level=logging.INFO)
+
+
+@dataclass
+class UIState:
+    """Class for managing UI state"""
+
+    is_locked: bool = False
+    is_typing: bool = False
+    blinking: bool = False
+    arrow_visible: bool = False
+    arrow_blinking: bool = False
+    buttons_visible: bool = True
+    full_text: str = ""
+    typing_timer: Optional[str] = None
+    last_name: Optional[str] = None
+
+
+class UIComponents:
+    """Class for managing UI components references"""
+
+    def __init__(self):
+        self.main_frame: Optional[tk.Frame] = None
+        self.text_frame: Optional[tk.Frame] = None
+        self.canvas: Optional[tk.Canvas] = None
+        self.control_area: Optional[tk.Frame] = None
+        self.scrollbar: Optional[ttk.Scrollbar] = None
+        self.buttons: Dict[str, tk.Button] = {}
+        self.text_container: Optional[int] = None  # Canvas text item ID
+        self.outline_container: List[int] = []  # Canvas outline item IDs
+        self.arrow_label: Optional[tk.Label] = None
+
+
+class Translated_UI:  # เปลี่ยนชื่อ class ตรงนี้
+    """Main class for translation window UI"""
+
+    def __init__(
+        self,
+        root: tk.Tk,
+        toggle_translation: Callable,
+        stop_translation: Callable,
+        force_translate: Callable,
+        toggle_main_ui: Callable,
+        toggle_ui: Callable,
+        settings: Settings,
+        switch_area: Callable,
+        logging_manager: Any,
+        character_names: Optional[set] = None,
+        main_app=None  # เพิ่มพารามิเตอร์นี้
+    ):
+        self.root = root
+        self.toggle_translation = toggle_translation
+        self.stop_translation = stop_translation
+        self.force_translate = force_translate
+        self.toggle_main_ui = toggle_main_ui
+        self.toggle_ui = toggle_ui
+        self.settings = settings
+        self.switch_area = switch_area
+        self.logging_manager = logging_manager
+        self.names = character_names or set()
+        self.lock_mode = 0
+        self.main_app = main_app  # เก็บ reference ของ main application
+
+        # Initialize states
+        self.state = UIState()
+        self.components = UIComponents()
+
+        # Mouse drag coordinates
+        self.x: Optional[int] = None
+        self.y: Optional[int] = None
+
+        # Load and resize icons
+        self.load_icons()
+
+        # Add resize handling
+        self.last_resize_time = 0
+        self.resize_throttle = 0.016  # For 60fps
+
+        # Setup UI
+        self.setup_ui()
+        self.setup_bindings()
+        self._setup_character_name_binding()
+        logging.info("TranslatedUI initialized successfully")
+
+    def load_icons(self) -> None:
+        """Load and prepare all required icons"""
+        try:
+            # Load confirm icon for character names
+            confirm_icon = Image.open("confirm.png")
+            confirm_icon = confirm_icon.resize((28, 28))
+            self.confirm_icon = ImageTk.PhotoImage(confirm_icon)
+
+            # Load lock/unlock icons
+            button_size = 20
+            self.lock_image = ImageTk.PhotoImage(
+                Image.open("lock.png").resize((button_size, button_size))
+            )
+            self.unlock_image = ImageTk.PhotoImage(
+                Image.open("unlock.png").resize((button_size, button_size))
+            )
+            self.bg_lock_image = ImageTk.PhotoImage(
+                Image.open("BG_lock.png").resize((button_size, button_size))
+            )
+
+            # Load force translate icon
+            self.force_image = ImageTk.PhotoImage(
+                Image.open("s_force.png").resize((button_size, button_size))
+            )
+
+        except Exception as e:
+            logging.error(f"Error loading icons: {e}")
+            self.confirm_icon = None
+            # Set fallback icon values if needed
+
+    def setup_ui(self) -> None:
+        """Initialize and setup all UI components"""
+        self.root.title("Translated Text")
+        self.root.geometry(
+            f"{self.settings.get('width')}x{self.settings.get('height')}"
+        )
+        self.root.overrideredirect(True)
+        self.root.attributes("-topmost", True)
+        self.custom_font = appearance_manager.apply_style(self.root)
+
+        # Remove borders
+        self.root.configure(bd=0, highlightthickness=0)
+
+        # Main frame setup
+        self.components.main_frame = tk.Frame(
+            self.root,
+            bg=appearance_manager.bg_color,
+            bd=0,
+            highlightthickness=0,
+        )
+        self.components.main_frame.pack(fill=tk.BOTH, expand=True)
+
+        # Text frame setup
+        self.components.text_frame = tk.Frame(
+            self.components.main_frame,
+            bg=appearance_manager.bg_color,
+            bd=0,
+            highlightthickness=0,
+        )
+        self.components.text_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+
+        # Control frame setup
+        self.components.control_area = tk.Frame(
+            self.components.main_frame,
+            bg=appearance_manager.bg_color,
+            bd=0,
+            highlightthickness=0,
+            width=30,
+        )
+        self.components.control_area.pack(side=tk.RIGHT, fill=tk.Y)
+        self.components.control_area.pack_propagate(False)
+
+        # Resize handle
+        self.resize_handle = tk.Label(
+            self.components.main_frame,
+            text="✦",
+            bg="#2A2A2A",
+            fg="white",
+            font=("Arial", 12, "bold"),
+            cursor="sizing",
+            bd=0,
+            highlightthickness=0,
+        )
+        self.resize_handle.place(relx=1.0, rely=1.0, anchor="se")
+
+        # Setup main components
+        self.setup_canvas_and_text()
+        self.setup_scrollbar()
+        self.setup_buttons()
+
+    def setup_canvas_and_text(self) -> None:
+        """Setup canvas and text display area with fonts and styling"""
+        # Canvas setup
+        self.components.canvas = tk.Canvas(
+            self.components.text_frame,
+            bg=appearance_manager.bg_color,
+            bd=0,
+            highlightthickness=0,
+            relief="flat",
+        )
+        self.components.canvas.pack(
+            side=tk.LEFT, fill=tk.BOTH, expand=True, padx=(10, 85), pady=(10, 20)
+        )
+
+        # Initialize text properties
+        font_name = self.settings.get("font", "IBM Plex Sans Thai Medium")
+        font_size = self.settings.get("font_size", 24)
+
+        self.components.text_container = self.components.canvas.create_text(
+            10,
+            10,
+            anchor="nw",
+            font=(font_name, font_size),
+            fill=appearance_manager.fg_color,
+            width=self.components.text_frame.winfo_width() - 90,
+            text="",
+        )
+
+        self.components.outline_container = []
+
+        # Arrow label for overflow indication
+        self.components.arrow_label = tk.Label(
+            self.components.main_frame,
+            text="▼",
+            font=("Arial", 16),
+            fg="white",
+            bg=appearance_manager.bg_color,
+        )
+        self.components.arrow_label.place(relx=0.8, rely=0.88, anchor="se", x=-55)
+        self.components.arrow_label.lower()
+
+    def setup_scrollbar(self) -> None:
+        """Setup and configure custom scrollbar"""
+        style = ttk.Style()
+        style.theme_use("clam")
+
+        # Configure modern scrollbar style
+        style.configure(
+            "Modern.Vertical.TScrollbar",
+            background="#333333",
+            troughcolor="#1a1a1a",
+            bordercolor="#1a1a1a",
+            arrowcolor="#666666",
+            relief="flat",
+            borderwidth=0,
+            width=8,
+        )
+
+        self.components.scrollbar = ttk.Scrollbar(
+            self.components.text_frame,
+            command=self.components.canvas.yview,
+            style="Modern.Vertical.TScrollbar",
+        )
+
+        # Position scrollbar
+        self.components.scrollbar.place(
+            x=self.components.text_frame.winfo_width() - 80,
+            y=0,
+            relheight=0.95,
+            anchor="ne",
+        )
+
+        # Configure canvas scroll region
+        self.components.canvas.configure(
+            yscrollcommand=self.scrollbar_command,
+            scrollregion=(0, 0, 0, self.components.text_frame.winfo_height() + 50),
+        )
+
+    def setup_buttons(self) -> None:
+        """Initialize and setup all control buttons"""
+        button_size = 20  # Standard button size
+
+        # Close button
+        self.components.buttons["close"] = tk.Button(
+            self.components.control_area,
+            text="X",
+            command=self.close_window,
+            bg=appearance_manager.bg_color,
+            fg="white",
+            bd=0,
+            width=1,
+            font=(self.settings.get("font"), 12),
+            cursor="hand2",
+            activebackground=appearance_manager.bg_color,
+            activeforeground="white",
+        )
+        self.components.buttons["close"].pack(side=tk.TOP, pady=(5, 5))
+
+        # Lock/Unlock button
+        self.components.buttons["lock"] = tk.Button(
+            self.components.control_area,
+            image=self.lock_image,
+            command=self.toggle_lock,
+            bg=appearance_manager.bg_color,
+            bd=0,
+            highlightthickness=0,
+            relief="flat",
+            compound="center",
+            cursor="hand2",
+            activebackground=appearance_manager.bg_color,
+        )
+        self.components.buttons["lock"].pack(side=tk.TOP, pady=5)
+
+        # Color picker button
+        self.components.buttons["color"] = tk.Button(
+            self.components.control_area,
+            command=self.change_bg_color,
+            bg=self.settings.get("bg_color", appearance_manager.bg_color),
+            bd=1,
+            relief="solid",
+            width=1,
+            height=1,
+            cursor="hand2",
+            activebackground=self.settings.get("bg_color", appearance_manager.bg_color),
+        )
+        self.components.buttons["color"].pack(side=tk.TOP, pady=5)
+
+        # Force translate button
+        self.components.buttons["force"] = tk.Button(
+            self.components.control_area,
+            image=self.force_image,
+            command=self.force_translate,
+            bg=appearance_manager.bg_color,
+            bd=0,
+            highlightthickness=0,
+            relief="flat",
+            compound="center",
+            cursor="hand2",
+            activebackground=appearance_manager.bg_color,
+        )
+        self.components.buttons["force"].pack(side=tk.TOP, pady=5)
+
+    def scrollbar_command(self, *args) -> None:
+        """
+        Handle scrollbar movement and arrow visibility
+        Args:
+            *args: Scrollbar position arguments (start, end)
+        """
+        self.components.scrollbar.set(*args)
+
+        try:
+            # Calculate scroll position percentage
+            scroll_position = float(args[1])
+            max_scroll = 0.95  # Show arrow until 95% scrolled
+
+            # Get canvas content boundaries
+            bbox = self.components.canvas.bbox("all")
+            if bbox is not None:
+                if scroll_position >= max_scroll:
+                    self.hide_overflow_arrow()
+                elif bbox[3] > self.components.canvas.winfo_height():
+                    self.show_overflow_arrow()
+            else:
+                self.hide_overflow_arrow()
+
+        except (TypeError, IndexError) as e:
+            logging.warning(f"Error in scrollbar_command: {str(e)}")
+            self.hide_overflow_arrow()
+
+    def setup_bindings(self) -> None:
+        """Setup all event bindings for the UI"""
+        # Basic UI interactions
+        self.root.bind("<Button-1>", self.on_click)
+        self.root.bind("<ButtonRelease-1>", self.stop_move)
+        self.root.bind("<B1-Motion>", self.on_drag)
+        self.components.canvas.bind("<Button-1>", self.show_full_text)
+        self.components.canvas.bind("<Configure>", self.on_canvas_configure)
+        self.components.canvas.bind("<MouseWheel>", self.on_mousewheel)
+
+        # Add mousewheel binding to all frames
+        for widget in [
+            self.components.main_frame,
+            self.components.text_frame,
+            self.root,
+        ]:
+            widget.bind("<MouseWheel>", self.on_mousewheel)
+
+        # Resize bindings
+        self.resize_handle.bind("<Button-1>", self.start_resize)
+        self.resize_handle.bind("<B1-Motion>", self.on_resize)
+        self.resize_handle.bind("<ButtonRelease-1>", self.stop_resize)
+
+        # Hover events for relevant widgets
+        widgets_to_bind = [
+            self.components.main_frame,
+            self.components.text_frame,
+            self.components.canvas,
+            self.root,
+        ]
+
+        for widget in widgets_to_bind:
+            widget.bind("<Enter>", self.on_hover_enter)
+
+    def is_mouse_in_ui(self, event: tk.Event) -> bool:
+        """
+        Check if mouse is within any UI component
+        Args:
+            event: Mouse event containing coordinates
+        Returns:
+            bool: True if mouse is within UI bounds
+        """
+        x, y = event.x_root, event.y_root
+        widgets_to_check = [
+            self.components.main_frame,
+            self.components.text_frame,
+            self.components.canvas,
+            self.root,
+        ]
+
+        for widget in widgets_to_check:
+            try:
+                widget_x = widget.winfo_rootx()
+                widget_y = widget.winfo_rooty()
+                widget_width = widget.winfo_width()
+                widget_height = widget.winfo_height()
+
+                if (
+                    widget_x <= x <= widget_x + widget_width
+                    and widget_y <= y <= widget_y + widget_height
+                ):
+                    return True
+            except Exception:
+                continue
+        return False
+
+    def show_overflow_arrow(self) -> None:
+        """Show and start blinking the overflow arrow indicator"""
+        if not self.state.arrow_visible:
+            self.state.arrow_visible = True
+            self.components.arrow_label.lift()
+            self.blink_arrow()
+
+    def hide_overflow_arrow(self) -> None:
+        """Hide and stop blinking the overflow arrow indicator"""
+        self.state.arrow_visible = False
+        self.state.arrow_blinking = False
+        self.components.arrow_label.lower()
+
+    def blink_arrow(self) -> None:
+        """Start arrow blinking animation if not already blinking"""
+        if self.state.arrow_visible and not self.state.arrow_blinking:
+            self.state.arrow_blinking = True
+            self.do_blink()
+
+    def do_blink(self) -> None:
+        """Handle arrow blinking animation"""
+        if self.state.arrow_visible and self.state.arrow_blinking:
+            current_color = self.components.arrow_label.cget("fg")
+            new_color = (
+                "white"
+                if current_color == appearance_manager.bg_color
+                else appearance_manager.bg_color
+            )
+            self.components.arrow_label.config(fg=new_color)
+            self.root.after(500, self.do_blink)
+        else:
+            self.components.arrow_label.config(fg="white")
+
+    def update_text(self, text: str) -> None:
+        """
+        Update the displayed text with typewriter effect
+        Args:
+            text: Text to display
+        """
+        try:
+            logging.info(f"Updating text in UI: {text}")
+            if not text:
+                return
+
+            # Base configuration
+            outline_offset = 1
+            outline_color = "#000000"
+            outline_positions = [
+                (-1, -1),
+                (-1, 0),
+                (-1, 1),
+                (0, -1),
+                (0, 1),
+                (1, -1),
+                (1, 0),
+                (1, 1),
+            ]
+
+            # Clear previous text
+            self.components.canvas.delete("all")
+            self.components.canvas.yview_moveto(0)
+
+            # Get font sizes
+            current_font_size = self.settings.get("font_size", 24)
+            small_font_size = int(current_font_size * 0.7)
+
+            # Create font configurations
+            dialogue_font = (self.settings.get("font"), current_font_size)
+            small_font = (self.settings.get("font"), small_font_size)
+
+            self.state.full_text = text
+            available_width = self.components.canvas.winfo_width() - 40
+
+            # Check if this is a choice dialogue
+            if text.startswith("คุณจะพูดว่าอย่างไร?") or text.startswith(
+                "What will you say?"
+            ):
+                self._handle_choice_text(
+                    text,
+                    small_font,
+                    dialogue_font,
+                    available_width,
+                    outline_positions,
+                    outline_offset,
+                    outline_color,
+                )
+            else:
+                self._handle_normal_text(
+                    text,
+                    small_font,
+                    dialogue_font,
+                    available_width,
+                    outline_positions,
+                    outline_offset,
+                    outline_color,
+                )
+
+        except Exception as e:
+            logging.error(f"Error in update_text: {e}")
+            self._show_error(str(e))
+
+    def update_character_names(self, new_names):
+        """อัพเดตรายชื่อตัวละครและรีเฟรช UI"""
+        self.names = new_names
+
+        # รีเฟรชการแสดงผลข้อความปัจจุบัน
+        if hasattr(self, "state") and self.state.full_text:
+            current_text = self.state.full_text
+            self.update_text(current_text)
+
+    def _handle_choice_text(
+        self,
+        text: str,
+        small_font: tuple,
+        dialogue_font: tuple,
+        available_width: int,
+        outline_positions: list,
+        outline_offset: int,
+        outline_color: str,
+    ) -> None:
+        """
+        Handle choice dialogue text display
+        Args:
+            text: Full text to display
+            small_font: Font tuple for header
+            dialogue_font: Font tuple for choices
+            available_width: Available width for text
+            outline_positions: List of outline position offsets
+            outline_offset: Outline offset value
+            outline_color: Color for text outline
+        """
+        # Split header and choices ด้วยการตรวจสอบ pattern แบบใหม่
+        if "คุณจะพูดว่าอย่างไร?" in text:
+            header = "คุณจะพูดว่าอย่างไร?"
+            choices = text.replace(header, "", 1).strip()
+        else:
+            header = "What will you say?"
+            choices = text.replace(header, "", 1).strip()
+
+        # ลบ \n ที่ไม่จำเป็นออก
+        choices = choices.strip("\n")
+
+        # Create header outlines with static header
+        for dx, dy in outline_positions:
+            outline = self.components.canvas.create_text(
+                10 + dx * outline_offset,
+                10 + dy * outline_offset,
+                anchor="nw",
+                font=small_font,
+                fill=outline_color,
+                text=header,
+                width=available_width,
+                tags=("header_outline",),
+            )
+
+        # Create header text with static header
+        header_text = self.components.canvas.create_text(
+            10,
+            10,
+            anchor="nw",
+            font=small_font,
+            fill="#FFD700",  # Gold color for header
+            text=header,
+            width=available_width,
+        )
+
+        # Calculate position for choices
+        header_bbox = self.components.canvas.bbox(header_text)
+        choices_y = header_bbox[3] + 10
+
+        # Create choice outlines
+        self.components.outline_container = []
+        for dx, dy in outline_positions:
+            outline = self.components.canvas.create_text(
+                10 + dx * outline_offset,
+                choices_y + dy * outline_offset,
+                anchor="nw",
+                font=dialogue_font,
+                fill=outline_color,
+                text="",
+                width=available_width,
+                tags=("choices_outline",),
+            )
+            self.components.outline_container.append(outline)
+
+        # Create choices text container
+        self.components.text_container = self.components.canvas.create_text(
+            10,
+            choices_y,
+            anchor="nw",
+            font=dialogue_font,
+            fill="white",
+            text="",
+            width=available_width,
+            tags=("choices",),
+        )
+
+        # เริ่ม typewriter effect เฉพาะกับ choices
+        self.dialogue_text = choices
+        if hasattr(self, "type_writer_timer"):
+            self.root.after_cancel(self.type_writer_timer)
+        self.state.typing = True
+        self.type_writer_effect(choices)
+
+    def _handle_normal_text(
+        self, 
+        text: str,
+        small_font: tuple,
+        dialogue_font: tuple,
+        available_width: int,
+        outline_positions: list,
+        outline_offset: int,
+        outline_color: str
+    ) -> None:
+        """
+        จัดการแสดงผลข้อความปกติที่ไม่ใช่ choice dialogue
+        Args:
+            text: ข้อความที่จะแสดง
+            small_font: ฟอนต์สำหรับชื่อ
+            dialogue_font: ฟอนต์สำหรับบทสนทนา
+            available_width: ความกว้างที่มีให้แสดงผล
+            outline_positions: ตำแหน่งของเส้นขอบ
+            outline_offset: ระยะห่างของเส้นขอบ
+            outline_color: สีของเส้นขอบ
+        """
+        try:
+            # Check if text contains speaker name
+            if ":" in text:
+                name, dialogue = text.split(":", 1)
+                name = name.strip()
+                dialogue = dialogue.strip()
+
+                # Set initial positions
+                name_y = 10
+                name_x = 10
+
+                # Create name outlines
+                for dx, dy in outline_positions:
+                    self.components.canvas.create_text(
+                        name_x + dx * outline_offset,
+                        name_y + dy * outline_offset,
+                        anchor="nw",
+                        font=small_font,
+                        fill=outline_color,
+                        text=name,
+                        tags=("name_outline",),
+                    )
+
+                # Determine name color
+                name_color = "#a855f7" if "?" in name else "#38bdf8"
+
+                # Create name text
+                name_text = self.components.canvas.create_text(
+                    name_x,
+                    name_y,
+                    anchor="nw",
+                    font=small_font,
+                    fill=name_color,
+                    text=name,
+                    tags=("name",)
+                )
+
+                # Add confirmation icon for verified names
+                if name in self.names:
+                    name_bbox = self.components.canvas.bbox(name_text)
+                    icon_x = name_bbox[2] + 8
+                    icon_y = name_y + ((name_bbox[3] - name_bbox[1]) // 2)
+
+                    self.components.canvas.create_image(
+                        icon_x,
+                        icon_y,
+                        image=self.confirm_icon,
+                        anchor="w",
+                        tags=("confirm_icon",),
+                    )
+
+                # Calculate dialogue position
+                name_bbox = self.components.canvas.bbox(name_text)
+                dialogue_y = name_bbox[3] + (small_font[1] * 0.3)
+
+                # Create dialogue outlines
+                self.components.outline_container = []
+                for dx, dy in outline_positions:
+                    outline = self.components.canvas.create_text(
+                        10 + dx * outline_offset,
+                        dialogue_y + dy * outline_offset,
+                        anchor="nw",
+                        font=dialogue_font,
+                        fill=outline_color,
+                        text="",
+                        width=available_width,
+                        tags=("dialogue_outline",),
+                    )
+                    self.components.outline_container.append(outline)
+
+                # Create dialogue text container
+                self.components.text_container = self.components.canvas.create_text(
+                    10,
+                    dialogue_y,
+                    anchor="nw",
+                    font=dialogue_font,
+                    fill="white",
+                    text="",
+                    width=available_width,
+                    tags=("dialogue",),
+                )
+
+            else:  # Text without speaker name
+                # กำหนดข้อความทั้งหมดเป็น dialogue
+                dialogue = text.strip()
+                
+                self.components.outline_container = []
+                for dx, dy in outline_positions:
+                    outline = self.components.canvas.create_text(
+                        10 + dx * outline_offset,
+                        10 + dy * outline_offset,
+                        anchor="nw",
+                        font=dialogue_font,
+                        fill=outline_color,
+                        text="",
+                        width=available_width,
+                        tags=("text_outline",),
+                    )
+                    self.components.outline_container.append(outline)
+
+                self.components.text_container = self.components.canvas.create_text(
+                    10,
+                    10,
+                    anchor="nw",
+                    font=dialogue_font,
+                    fill="white",
+                    text="",
+                    width=available_width,
+                    tags=("text",),
+                )
+
+            # Start typewriter effect with dialogue text
+            self.dialogue_text = dialogue
+            if hasattr(self, "type_writer_timer"):
+                self.root.after_cancel(self.type_writer_timer)
+            self.state.typing = True
+            self.type_writer_effect(dialogue)
+
+        except Exception as e:
+            self.logging_manager.log_error(f"Error in handle normal text: {e}")
+
+    def type_writer_effect(self, text: str, index: int = 0, delay: int = 5) -> None:
+        """
+        Create typewriter effect for text display
+        Args:
+            text: Text to display
+            index: Current character index
+            delay: Delay between characters in milliseconds
+        """
+        try:
+            if not self.state.typing:
+                return
+
+            if index < len(text):
+                next_text = text[: index + 1]
+
+                names = getattr(self, "names", set())
+                is_combined = (
+                    (":" in text and any(name in text.split(":")[0] for name in names))
+                    if names
+                    else False
+                )
+
+                if is_combined:
+                    name, message = text.split(":", 1)
+                    display_text = message[: index + 1].strip()
+                else:
+                    display_text = next_text
+
+                # Update outlines and main text
+                for outline in self.components.outline_container:
+                    self.components.canvas.itemconfig(outline, text=display_text)
+                    self.components.canvas.tag_lower(outline)
+
+                self.components.canvas.itemconfig(
+                    self.components.text_container, text=display_text
+                )
+
+                self.root.update_idletasks()
+                if self.state.typing:
+                    self.type_writer_timer = self.root.after(
+                        delay, lambda: self.type_writer_effect(text, index + 1, delay)
+                    )
+            else:
+                self.state.typing = False
+                self.check_text_overflow()
+
+        except Exception as e:
+            logging.error(f"Error in type_writer_effect: {e}")
+            self.state.typing = False
+
+    def show_full_text(self, event: Optional[tk.Event] = None) -> None:
+        """
+        Show complete text immediately without typewriter effect
+        Args:
+            event: Optional tkinter event
+        """
+        # ยกเลิก timer ที่กำลังทำงานอยู่
+        if hasattr(self, "type_writer_timer"):
+            self.root.after_cancel(self.type_writer_timer)
+
+        # ยกเลิกสถานะ typing
+        self.state.typing = False
+
+        # Handle choice text
+        if hasattr(self, "dialogue_text") and self.dialogue_text:
+            if self.dialogue_text.startswith(
+                "คุณจะพูดว่าอย่างไร?"
+            ) or self.dialogue_text.startswith("What will you say?"):
+                parts = self.dialogue_text.split("\n", 1)
+                header = parts[0].strip()
+                choices = parts[1].strip() if len(parts) > 1 else ""
+
+                # Update header
+                for item in self.components.canvas.find_withtag("header_outline"):
+                    self.components.canvas.itemconfig(item, text=header)
+
+                # Update choices
+                for outline in self.components.outline_container:
+                    self.components.canvas.itemconfig(outline, text=choices)
+                self.components.canvas.itemconfig(
+                    self.components.text_container, text=choices
+                )
+            else:
+                # Handle normal text
+                is_combined = ":" in self.dialogue_text and any(
+                    name in self.dialogue_text.split(":")[0]
+                    for name in getattr(self, "names", set())
+                )
+
+                if is_combined:
+                    name, message = self.dialogue_text.split(":", 1)
+                    display_text = message.strip()
+                else:
+                    display_text = self.dialogue_text
+
+                # Update all text elements
+                for outline in self.components.outline_container:
+                    self.components.canvas.itemconfig(outline, text=display_text)
+                self.components.canvas.itemconfig(
+                    self.components.text_container, text=display_text
+                )
+
+            # Organize layers and check overflow
+            self.components.canvas.tag_lower("dialogue_outline")
+            if self.components.canvas.find_withtag("name_outline"):
+                self.components.canvas.tag_lower("name_outline")
+
+            self.check_text_overflow()
+
+    def check_text_overflow(self) -> None:
+        """Check if text content overflows the canvas and handle scrollbar visibility"""
+        self.components.canvas.update_idletasks()
+
+        # Add bottom padding
+        content_height = self.components.canvas.bbox("all")[3] + 20
+        canvas_height = self.components.canvas.winfo_height()
+
+        if content_height > canvas_height:
+            self.show_overflow_arrow()
+            self.components.scrollbar.place(
+                relx=0.98, rely=0, relheight=0.9, anchor="ne", y=10, x=-25
+            )
+            self.components.canvas.configure(scrollregion=(0, 0, 0, content_height))
+        else:
+            self.hide_overflow_arrow()
+            self.components.scrollbar.place_forget()
+
+    def adjust_font_size(self, size: int) -> None:
+        """
+        Adjust font size for all text elements
+        Args:
+            size: New font size
+        """
+        try:
+            font = (self.settings.get("font"), size)
+
+            # Update text container font
+            if self.components.text_container:
+                self.components.canvas.itemconfig(
+                    self.components.text_container, font=font
+                )
+
+            # Update outlines font
+            for tag in ["name_outline", "dialogue_outline"]:
+                for outline in self.components.canvas.find_withtag(tag):
+                    self.components.canvas.itemconfig(outline, font=font)
+
+            self.check_text_overflow()
+            logging.info(f"Font size adjusted to: {size}")
+
+        except (ValueError, TypeError) as e:
+            logging.error(f"Error adjusting font size: {e}")
+            # Fallback to default size
+            self.adjust_font_size(24)
+
+    def update_font(self, font_name: str) -> None:
+        """
+        Update font family for all text elements
+        Args:
+            font_name: New font family name
+        """
+        font = (font_name, self.settings.get("font_size"))
+
+        # Update text container font
+        if self.components.text_container:
+            self.components.canvas.itemconfig(self.components.text_container, font=font)
+
+        # Update outlines font
+        for tag in ["name_outline", "dialogue_outline"]:
+            for outline in self.components.canvas.find_withtag(tag):
+                self.components.canvas.itemconfig(outline, font=font)
+
+        self.check_text_overflow()
+        logging.info(f"Font updated to: {font_name}")
+
+    def _show_error(self, error_message: str) -> None:
+        """
+        Display error message in the canvas
+        Args:
+            error_message: Error message to display
+        """
+        self.components.canvas.delete("all")
+        font = (self.settings.get("font"), self.settings.get("font_size"))
+        self.components.text_container = self.components.canvas.create_text(
+            10,
+            10,
+            anchor="nw",
+            font=font,
+            fill="red",
+            width=self.components.text_frame.winfo_width() - 20,
+            text=f"Error: {error_message}",
+        )
+        self.check_text_overflow()
+
+    def update_transparency(self, alpha: float) -> None:
+        """
+        Update window transparency
+        Args:
+            alpha: Transparency value (0.0 to 1.0)
+        """
+        self.root.attributes("-alpha", alpha)
+
+    def close_window(self) -> None:
+        """Close the translation window and stop translation"""
+        self.stop_translation()
+        if self.root.winfo_exists():
+            if self.root.state() != "withdrawn":
+                self.root.withdraw()
+                logging.info("Translated UI closed by user")
+            else:
+                logging.info("Translated UI already hidden")
+        else:
+            logging.warning("Translated UI window does not exist")
+
+    def toggle_lock(self) -> None:
+        """Toggle window lock state with different modes"""
+        self.lock_mode = (self.lock_mode + 1) % 3
+        current_bg = self.settings.get("bg_color", appearance_manager.bg_color)
+
+        # Update all widgets to remove borders
+        widgets_to_update = [
+            self.components.main_frame,
+            self.components.text_frame,
+            self.components.canvas,
+            self.components.control_area,
+        ]
+
+        if self.lock_mode == 0:  # Unlock
+            self.state.is_locked = False
+            self.components.buttons["lock"].config(image=self.lock_image)
+            self.root.attributes("-transparentcolor", "")
+
+            for widget in widgets_to_update:
+                widget.configure(bg=current_bg, bd=0, highlightthickness=0)
+
+        elif self.lock_mode == 1:  # Lock with hidden bg
+            self.state.is_locked = True
+            self.components.buttons["lock"].config(image=self.unlock_image)
+            self.root.attributes("-transparentcolor", current_bg)
+
+            for widget in widgets_to_update:
+                widget.configure(bg=current_bg, bd=0, highlightthickness=0)
+
+            # Update buttons
+            for button in self.components.buttons.values():
+                button.configure(bg=current_bg, bd=0)
+
+        else:  # Lock with visible bg
+            self.state.is_locked = True
+            self.components.buttons["lock"].config(image=self.bg_lock_image)
+            self.root.attributes("-transparentcolor", "")
+
+            for widget in widgets_to_update:
+                widget.configure(bg=current_bg, bd=0, highlightthickness=0)
+
+    def change_bg_color(self) -> None:
+        """Open color picker and update background color"""
+        color = colorchooser.askcolor(
+            color=self.settings.get("bg_color", appearance_manager.bg_color),
+            title="Choose Background Color",
+        )
+
+        if color[1]:
+            self.settings.set("bg_color", color[1])
+            self.settings.save_settings()
+
+            # Update all UI components
+            widgets_to_update = [
+                self.root,
+                self.components.main_frame,
+                self.components.text_frame,
+                self.components.canvas,
+                self.components.control_area,
+            ]
+
+            for widget in widgets_to_update:
+                widget.configure(bg=color[1], bd=0, highlightthickness=0, relief="flat")
+
+            # Update buttons separately
+            for button in self.components.buttons.values():
+                button.configure(bg=color[1], bd=0, relief="flat", highlightthickness=0)
+
+            if self.lock_mode == 1:
+                self.root.attributes("-transparentcolor", color[1])
+
+    def setup_window_resizing(self) -> None:
+        """Initialize window resize functionality"""
+        self.resize_handle = tk.Label(
+            self.components.main_frame,
+            text="✦",
+            bg="#2A2A2A",
+            fg="white",
+            font=("Arial", 12, "bold"),
+            cursor="sizing",
+        )
+        self.resize_handle.place(relx=1, rely=1, anchor="se")
+
+        self.resize_handle.bind("<Button-1>", self.start_resize)
+        self.resize_handle.bind("<B1-Motion>", self.on_resize)
+        self.resize_handle.bind("<ButtonRelease-1>", self.stop_resize)
+
+        self.is_resizing = False
+        self.last_resize_time = 0
+        self.resize_throttle = 0.016  # ~60fps
+
+    def start_resize(self, event: tk.Event) -> None:
+        """
+        Initialize window resize operation
+        Args:
+            event: Mouse event containing initial coordinates
+        """
+        self.is_resizing = True
+        self.resize_x = event.x_root
+        self.resize_y = event.y_root
+        self.resize_w = self.root.winfo_width()
+        self.resize_h = self.root.winfo_height()
+        print("\rStarting translated UI resize...", end="", flush=True)
+
+    def on_resize(self, event: tk.Event) -> None:
+        """
+        Handle window resizing with throttling
+        Args:
+            event: Mouse event containing current coordinates
+        """
+        if not self.is_resizing:
+            return
+
+        try:
+            current_time = time.time()
+            if current_time - self.last_resize_time < self.resize_throttle:
+                return
+
+            dx = event.x_root - self.resize_x
+            dy = event.y_root - self.resize_y
+
+            new_width = max(300, self.resize_w + dx)
+            new_height = max(200, self.resize_h + dy)
+
+            self.root.geometry(f"{int(new_width)}x{int(new_height)}")
+
+            self.settings.set("width", new_width)
+            self.settings.set("height", new_height)
+
+            self.last_resize_time = current_time
+            print(
+                f"\rResizing translated UI to {int(new_width)}x{int(new_height)}...",
+                end="",
+                flush=True,
+            )
+
+        except Exception as e:
+            logging.error(f"Resize error: {e}")
+            print(f"\rResize error: {e}")
+
+    def stop_resize(self, event: Optional[tk.Event] = None) -> None:
+        """
+        End window resize operation and save final settings
+        Args:
+            event: Optional mouse event
+        """
+        if self.is_resizing:
+            self.settings.save_settings()
+
+            final_w = self.root.winfo_width()
+            final_h = self.root.winfo_height()
+
+            # Update canvas and check overflow
+            self.on_canvas_configure({"width": final_w - 40})
+            self.force_check_overflow()
+
+            print(f"\rTranslated UI resize complete: {final_w}x{final_h}")
+
+        self.is_resizing = False
+
+    def force_check_overflow(self) -> None:
+        """Force check text overflow and update UI accordingly"""
+        self.check_text_overflow()
+
+    def on_canvas_configure(self, event: Union[tk.Event, Dict[str, int]]) -> None:
+        """
+        Handle canvas resize event
+        Args:
+            event: Canvas configure event or dictionary with width
+        """
+        try:
+            available_width = (
+                event.width - 20 if isinstance(event, tk.Event) else event["width"]
+            )
+
+            if hasattr(self.components, "text_container"):
+                # Update text container width
+                self.components.canvas.itemconfig(
+                    self.components.text_container, width=available_width
+                )
+
+                # Update outline widths
+                for outline in self.components.outline_container:
+                    self.components.canvas.itemconfig(outline, width=available_width)
+
+                # Update scroll region
+                self.components.canvas.update_idletasks()
+                bbox = self.components.canvas.bbox("all")
+                if bbox:
+                    self.components.canvas.configure(scrollregion=bbox)
+
+            self.check_text_overflow()
+
+        except Exception as e:
+            logging.error(f"Canvas configure error: {e}")
+
+    def on_mousewheel(self, event: tk.Event) -> None:
+        """
+        Handle mouse wheel scrolling
+        Args:
+            event: Mouse wheel event
+        """
+        self.components.canvas.yview_scroll(-1 * (event.delta // 120), "units")
+
+    def on_click(self, event: tk.Event) -> None:
+        """
+        Handle mouse click event
+        Args:
+            event: Mouse click event
+        """
+        if self.state.is_locked and not self._is_click_on_button(event):
+            if self.lock_mode == 2:  # Lock with visible bg
+                self.show_full_text()
+            return
+        self._start_move(event)
+        if not self.state.is_locked:
+            self.show_full_text()
+
+    def _is_click_on_button(self, event: tk.Event) -> bool:
+        """
+        Check if click was on a button
+        Args:
+            event: Mouse click event
+        Returns:
+            bool: True if click was on a button
+        """
+        for button in self.components.buttons.values():
+            if button.winfo_containing(event.x_root, event.y_root) == button:
+                return True
+        return False
+
+    def _is_click_on_scrollbar(self, event: tk.Event) -> bool:
+        """
+        Check if click was on scrollbar
+        Args:
+            event: Mouse click event
+        Returns:
+            bool: True if click was on scrollbar
+        """
+        return (
+            self.components.scrollbar.winfo_containing(event.x_root, event.y_root)
+            == self.components.scrollbar
+        )
+
+    def _start_move(self, event: tk.Event) -> None:
+        """
+        Initialize window movement
+        Args:
+            event: Mouse click event
+        """
+        if not self.state.is_locked:
+            self.x = event.x
+            self.y = event.y
+
+    def on_drag(self, event: tk.Event) -> None:
+        """
+        Handle window dragging
+        Args:
+            event: Mouse drag event
+        """
+        if not self.state.is_locked:
+            self._do_move(event)
+
+    def stop_move(self, event: Optional[tk.Event] = None) -> None:
+        """
+        Stop window movement
+        Args:
+            event: Optional mouse release event
+        """
+        self.x = None
+        self.y = None
+
+    def _do_move(self, event: tk.Event) -> None:
+        """
+        Perform window movement
+        Args:
+            event: Mouse drag event
+        """
+        if not self.state.is_locked and self.x is not None and self.y is not None:
+            deltax = event.x - self.x
+            deltay = event.y - self.y
+            x = self.root.winfo_x() + deltax
+            y = self.root.winfo_y() + deltay
+            self.root.geometry(f"+{x}+{y}")
+
+    def on_hover_enter(self, event: Optional[tk.Event] = None) -> None:
+        """
+        Handle mouse hover enter event
+        Args:
+            event: Optional mouse enter event
+        """
+        pass  # All hover handling removed as per UI simplification
+
+    @staticmethod
+    def _calculate_content_dimensions(
+        text: str, font: tuple, max_width: int
+    ) -> Tuple[int, int]:
+        """
+        Calculate required dimensions for text content
+        Args:
+            text: Text content
+            font: Font configuration tuple
+            max_width: Maximum available width
+        Returns:
+            Tuple[int, int]: Calculated width and height
+        """
+        temp_label = tk.Label(text=text, font=font)
+        temp_label.update_idletasks()
+
+        raw_width = temp_label.winfo_reqwidth()
+        raw_height = temp_label.winfo_reqheight()
+
+        if raw_width > max_width:
+            # Calculate wrapped height
+            lines = math.ceil(raw_width / max_width)
+            height = raw_height * lines
+            width = max_width
+        else:
+            width = raw_width
+            height = raw_height
+
+        temp_label.destroy()
+        return width, height
+
+    def cleanup(self) -> None:
+        """Cleanup resources before closing"""
+        try:
+            # Cancel any pending typewriter effects
+            if hasattr(self, "type_writer_timer"):
+                self.root.after_cancel(self.type_writer_timer)
+
+            # Clear canvas items
+            if self.components.canvas:
+                self.components.canvas.delete("all")
+
+            # Reset state
+            self.state = UIState()
+
+            logging.info("TranslatedUI cleanup completed")
+
+        except Exception as e:
+            logging.error(f"Error during cleanup: {e}")
+
+    def _setup_character_name_binding(self):
+        """Setup binding for character name clicks"""
+        self.components.canvas.tag_bind("name", "<Button-1>", self._on_name_click)
+        logging.info("Character name click binding setup")
+
+    def _on_name_click(self, event):
+        """
+        จัดการเมื่อมีการคลิกที่ชื่อตัวละคร
+        - สร้าง click effect
+        - ส่งต่อไปยัง character handler
+        
+        Args:
+            event: tkinter event object ที่มีข้อมูลตำแหน่งที่คลิก
+        """
+        try:
+            # ค้นหา item ที่ถูกคลิก
+            clicked_item = self.components.canvas.find_closest(
+                self.components.canvas.canvasx(event.x),
+                self.components.canvas.canvasy(event.y)
+            )[0]
+
+            # เก็บสีเดิมไว้
+            original_color = self.components.canvas.itemcget(clicked_item, "fill")
+            original_text = self.components.canvas.itemcget(clicked_item, "text")
+
+            # สร้าง click effect
+            def flash_effect():
+                # เปลี่ยนเป็นสีแดงสว่าง
+                self.components.canvas.itemconfig(clicked_item, fill="#FF4444")
+                
+                # คืนค่าสีเดิมหลังจาก delay
+                self.root.after(150, lambda: self.components.canvas.itemconfig(
+                    clicked_item, 
+                    fill=original_color
+                ))
+
+            # ทำ flash effect และส่งต่อไปยัง handler
+            flash_effect()
+            self.root.after(50, lambda: self._handle_character_click(original_text))
+
+        except Exception as e:
+            self.logging_manager.log_error(f"Error in name click effect: {e}")
+
+    def _handle_character_click(self, character_name):
+        """Process character name click and open NPC Manager"""
+        try:
+            if not self.main_app:
+                self.logging_manager.log_warning("Main application reference not provided to Translated UI")
+                return
+
+            # เริ่มการทำงานกับ NPC Manager ในรอบเดียว
+            self.root.update_idletasks()  # รอให้ UI อัพเดทเสร็จก่อน
+            
+            if not hasattr(self.main_app, 'npc_manager') or self.main_app.npc_manager is None:
+                from npc_manager import create_npc_manager
+                self.main_app.npc_manager = create_npc_manager(
+                    self.root,
+                    self.main_app.reload_npc_data,
+                    self.logging_manager
+                )
+                self.main_app.npc_manager_button.config(bg="#404040")
+
+            # แสดง window และอัพเดทข้อมูลในรอบเดียว
+            npc_manager = self.main_app.npc_manager
+            if npc_manager.window.state() == 'withdrawn':
+                npc_manager.show_window()
+                
+            if character_name:
+                clean_name = character_name.strip(":!?. ")
+                is_verified = clean_name in self.names
+                npc_manager.find_and_display_character(clean_name, is_verified)
+
+        except Exception as e:
+            error_msg = f"Error handling character click: {e}"
+            self.logging_manager.log_error(error_msg)
+            messagebox.showerror("Error", error_msg)
+
+    def _setup_character_name_binding(self):
+        """
+        ตั้งค่า event binding สำหรับการโต้ตอบกับชื่อตัวละคร
+        - รองรับ hover effect ด้วย mouse enter/leave
+        - รองรับการคลิกที่ชื่อ
+        """
+        # เพิ่ม binding สำหรับ hover effect
+        self.components.canvas.tag_bind("name", "<Enter>", self._on_name_hover_enter)
+        self.components.canvas.tag_bind("name", "<Leave>", self._on_name_hover_leave)
+        self.components.canvas.tag_bind("name", "<Button-1>", self._on_name_click)
+        logging.info("Character name interaction bindings setup")
+
+    def _on_name_hover_enter(self, event):
+        """
+        จัดการเมื่อ mouse hover เข้าบริเวณชื่อตัวละคร
+        Parameters:
+            event: Event object ที่มีข้อมูลพิกัดของเมาส์
+        """
+        try:
+            # 1. เปลี่ยน cursor เป็นรูปมือ
+            self.components.canvas.configure(cursor="hand2")
+            
+            # 2. ค้นหา item ที่ถูก hover
+            current_x = self.components.canvas.canvasx(event.x)
+            current_y = self.components.canvas.canvasy(event.y)
+            items = self.components.canvas.find_overlapping(
+                current_x-5, current_y-5, 
+                current_x+5, current_y+5
+            )
+            
+            # 3. ค้นหา item ที่มี tag 'name'
+            name_item = None
+            for item in items:
+                if 'name' in self.components.canvas.gettags(item):
+                    name_item = item
+                    break
+                    
+            if name_item:
+                # 4. เก็บสีปัจจุบันไว้ใน tag
+                current_color = self.components.canvas.itemcget(name_item, "fill")
+                tag_name = f"original_color:{current_color}"
+                
+                # ลบ tag เก่าออกก่อน (ถ้ามี)
+                for tag in self.components.canvas.gettags(name_item):
+                    if tag.startswith('original_color:'):
+                        self.components.canvas.dtag(name_item, tag)
+                
+                # เพิ่ม tag ใหม่
+                self.components.canvas.addtag_withtag(tag_name, name_item)
+                
+                # 5. เปลี่ยนเป็นสีขาว
+                self.components.canvas.itemconfig(name_item, fill="white")
+            
+        except Exception as e:
+            self.logging_manager.log_error(f"Error in hover enter effect: {e}")
+
+    def _on_name_hover_leave(self, event):
+        """
+        จัดการเมื่อ mouse ออกจากบริเวณชื่อตัวละคร
+        Parameters:
+            event: Event object ที่มีข้อมูลพิกัดของเมาส์
+        """
+        try:
+            # 1. คืนค่า cursor กลับเป็นปกติ
+            self.components.canvas.configure(cursor="")
+            
+            # 2. ค้นหา item ที่ถูก hover ออก
+            current_x = self.components.canvas.canvasx(event.x)
+            current_y = self.components.canvas.canvasy(event.y)
+            items = self.components.canvas.find_overlapping(
+                current_x-5, current_y-5, 
+                current_x+5, current_y+5
+            )
+            
+            # 3. ค้นหา item ที่มี tag 'name'
+            for item in items:
+                if 'name' in self.components.canvas.gettags(item):
+                    # 4. ค้นหาสีเดิมจาก tag
+                    original_color = None
+                    for tag in self.components.canvas.gettags(item):
+                        if tag.startswith('original_color:'):
+                            original_color = tag.split(':')[1]
+                            self.components.canvas.dtag(item, tag)
+                            break
+                    
+                    # 5. ถ้าพบสีเดิม ให้ใช้สีนั้น ถ้าไม่พบให้ใช้สีตามประเภท
+                    if original_color:
+                        self.components.canvas.itemconfig(item, fill=original_color)
+                    else:
+                        # ตรวจสอบว่าเป็นชื่อลึกลับหรือไม่
+                        text = self.components.canvas.itemcget(item, "text")
+                        name_color = "#a855f7" if "?" in text else "#38bdf8"
+                        self.components.canvas.itemconfig(item, fill=name_color)
+                    break
+                    
+        except Exception as e:
+            self.logging_manager.log_error(f"Error in hover leave effect: {e}")
+
+
+if __name__ == "__main__":
+    root = tk.Tk()
+    settings = Settings()
+
+    class DummyLoggingManager:
+        def log_feedback(
+            self, original_text: str, translated_text: str, rating: int
+        ) -> None:
+            print(f"Logged feedback: {rating}")
+
+    dummy_logging_manager = DummyLoggingManager()
+
+    # Test setup with dummy callbacks
+    app = Translated_UI(
+        root=root,
+        toggle_translation=lambda: None,
+        stop_translation=lambda: None,
+        force_translate=lambda: None,
+        toggle_main_ui=lambda: None,
+        toggle_ui=lambda: None,
+        settings=settings,
+        switch_area=lambda x: None,
+        logging_manager=dummy_logging_manager,
+    )
+
+    root.mainloop()

translation_logger.py

@@ -0,0 +1,213 @@
+import os
+import json
+from datetime import datetime
+import difflib
+import logging
+
+class TranslationLogger:
+    def __init__(self, base_path=r"C:\Magicite Babel"):
+        """
+        Initialize translation logger
+        Args:
+            base_path (str): Base directory path where logs will be stored
+        """
+        # กำหนดพาธพื้นฐาน
+        self.base_path = base_path
+        self.log_path = os.path.join(base_path, "logs", "translations")
+        
+        # สร้างโฟลเดอร์ถ้ายังไม่มี
+        self.ensure_log_directory()
+        
+        # เก็บวันที่ปัจจุบัน
+        self.today_date = self._get_today_date()
+        
+        # เก็บข้อความแปลล่าสุดเพื่อเช็คความซ้ำซ้อน
+        self.last_en_text = None
+        self.last_th_text = None
+        
+        logging.info(f"TranslationLogger initialized. Log path: {self.log_path}")
+        
+    def ensure_log_directory(self):
+        """Create log directory if it doesn't exist"""
+        try:
+            if not os.path.exists(self.log_path):
+                os.makedirs(self.log_path)
+                logging.info(f"Created log directory: {self.log_path}")
+        except Exception as e:
+            logging.error(f"Error creating log directory: {e}")
+            raise
+
+    def _get_today_date(self):
+        """Get current date in YYYYMMDD format"""
+        return datetime.now().strftime("%Y%m%d")
+
+    def _get_log_files(self):
+        """
+        Get paths for today's log files
+        Returns:
+            dict: Paths for English and Thai log files
+        """
+        today = self._get_today_date()
+        return {
+            'en': os.path.join(self.log_path, f"EN_cons_{today}.log"),
+            'th': os.path.join(self.log_path, f"TH_cons_{today}.log")
+        }
+
+    def _format_message(self, text):
+        """
+        Format message for logging with speaker name and content
+        Args:
+            text (str): Text to format
+        Returns:
+            tuple: (speaker, content) or (None, text) if no speaker
+        """
+        # ถ้าข้อความว่างเปล่า
+        if not text or not text.strip():
+            return None, ""
+                
+        # แยกส่วนชื่อผู้พูดและข้อความ
+        if ": " in text:
+            speaker, message = text.split(": ", 1)
+            return speaker.strip(), message.strip()
+        return None, text.strip()
+
+    def _clean_text_for_comparison(self, text):
+        """
+        Clean text for similarity comparison
+        Args:
+            text (str): Text to clean
+        Returns:
+            str: Cleaned text
+        """
+        if not text:
+            return ""
+        # ลบช่องว่างและตัวอักษรพิเศษ
+        text = text.strip()
+        # ถ้ามีชื่อคนพูด ให้ตัดออกก่อนเปรียบเทียบ
+        if ": " in text:
+            text = text.split(": ", 1)[1]
+        return text
+
+    def _is_similar(self, text1, text2, threshold=0.8):
+        """
+        Check if two texts are similar using difflib
+        Args:
+            text1 (str): First text
+            text2 (str): Second text
+            threshold (float): Similarity threshold (0-1)
+        Returns:
+            bool: True if texts are similar
+        """
+        if not text1 or not text2:
+            return False
+            
+        # ทำความสะอาดข้อความก่อนเปรียบเทียบ
+        clean_text1 = self._clean_text_for_comparison(text1)
+        clean_text2 = self._clean_text_for_comparison(text2)
+        
+        if not clean_text1 or not clean_text2:
+            return False
+            
+        # คำนวณความเหมือน
+        similarity = difflib.SequenceMatcher(None, clean_text1, clean_text2).ratio()
+        return similarity >= threshold
+
+    def _load_last_text(self, file_path):
+        """
+        Load last non-empty text from file
+        Args:
+            file_path (str): Path to log file
+        Returns:
+            str: Last text or None if file doesn't exist
+        """
+        if not os.path.exists(file_path):
+            return None
+            
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                lines = f.readlines()
+                # ย้อนกลับมาหาข้อความสุดท้ายที่ไม่ใช่บรรทัดว่าง
+                for line in reversed(lines):
+                    if line.strip():
+                        return line.strip()
+        except Exception as e:
+            logging.error(f"Error loading last text from {file_path}: {e}")
+            return None
+            
+        return None
+
+    def log_translation(self, original_text, translated_text):
+        """
+        Log original and translated text to respective files
+        Args:
+            original_text (str): Original English text
+            translated_text (str): Translated Thai text
+        """
+        # เช็ควันที่เพื่อสร้างชื่อไฟล์
+        current_date = self._get_today_date()
+        if current_date != self.today_date:
+            self.today_date = current_date
+
+        # ถ้าข้อความว่างเปล่า ไม่ต้องบันทึก
+        if not original_text.strip() or not translated_text.strip():
+            return
+
+        try:
+            log_files = self._get_log_files()
+            
+            # แยกชื่อผู้พูดและข้อความต้นฉบับ
+            en_speaker, en_content = self._format_message(original_text)
+            _, th_content = self._format_message(translated_text)
+            
+            # บันทึกข้อความต้นฉบับ
+            with open(log_files['en'], 'a', encoding='utf-8') as f:
+                if en_speaker:
+                    f.write(f"{en_speaker}: {en_content}\n\n")
+                else:
+                    f.write(f"{en_content}\n\n")
+                    
+            # บันทึกข้อความแปลพร้อมชื่อผู้พูดจากต้นฉบับ
+            with open(log_files['th'], 'a', encoding='utf-8') as f:
+                if en_speaker:
+                    f.write(f"{en_speaker}: {th_content}\n\n")
+                else:
+                    f.write(f"{th_content}\n\n")
+                
+            logging.debug(f"Translation logged successfully")
+                
+        except Exception as e:
+            logging.error(f"Error logging translation: {e}")
+
+    def get_today_logs(self):
+        """
+        Get both English and Thai logs for today
+        Returns:
+            dict: Dictionary containing English and Thai logs
+        """
+        log_files = self._get_log_files()
+        logs = {'en': [], 'th': []}
+        
+        for lang, file_path in log_files.items():
+            if os.path.exists(file_path):
+                try:
+                    with open(file_path, 'r', encoding='utf-8') as f:
+                        # อ่านและกรองเฉพาะบรรทัดที่ไม่ว่างเปล่า
+                        logs[lang] = [line.strip() for line in f.readlines() if line.strip()]
+                except Exception as e:
+                    logging.error(f"Error reading {lang} log file: {e}")
+                    logs[lang] = []
+                    
+        return logs
+
+    def clear_today_logs(self):
+        """Clear log files for today"""
+        try:
+            log_files = self._get_log_files()
+            for file_path in log_files.values():
+                if os.path.exists(file_path):
+                    with open(file_path, 'w', encoding='utf-8') as f:
+                        f.write("")
+            logging.info("Today's logs cleared")
+        except Exception as e:
+            logging.error(f"Error clearing logs: {e}")
+            raise

translator.py

@@ -0,0 +1,663 @@
+from openai import OpenAI
+import os
+from dotenv import load_dotenv
+import re
+import tkinter as tk
+from tkinter import messagebox
+import json
+import difflib
+import time
+import logging
+from translation_logger import TranslationLogger
+from enum import Enum
+from text_corrector import TextCorrector, DialogueType
+
+load_dotenv()
+
+
+class DialogueCache:
+    def __init__(self):
+        self.name_history = []  # เก็บประวัติชื่อที่ validate แล้ว 5 ชื่อล่าสุด
+        self.last_speaker = None  # เก็บชื่อล่าสุดที่ validate แล้ว
+        self.MAX_HISTORY = 5
+        self.session_speakers = []
+        self.name_translations = {}
+        self.speaker_styles = {}  # เพิ่มตรงนี้เพื่อเก็บรูปแบบการพูดของตัวละคร
+
+    def add_validated_name(self, name):
+        """เพิ่มชื่อที่ผ่านการ validate แล้วเท่านั้น"""
+        if name and name not in self.name_history:
+            # ถ้ามีครบ 5 ตัวแล้ว ให้ลบตัวแรกออก
+            if len(self.name_history) >= self.MAX_HISTORY:
+                self.name_history.pop(0)
+            self.name_history.append(name)
+            self.last_speaker = name
+
+    def add_speaker(self, speaker_name, translated_name=None):
+        """เพิ่มชื่อผู้พูดพร้อมการแปล (ถ้ามี)"""
+        if speaker_name:
+            if speaker_name not in self.session_speakers:
+                self.session_speakers.append(speaker_name)
+            if speaker_name not in self.name_history:
+                self.add_validated_name(speaker_name)
+            if translated_name:
+                self.name_translations[speaker_name] = translated_name
+
+    def get_speaker_translation(self, speaker_name):
+        """ดึงการแปลชื่อที่เคยแปลไว้"""
+        return self.name_translations.get(speaker_name)
+
+    def get_last_speaker(self):
+        """ดึงชื่อล่าสุดที่ validate แล้ว"""
+        return self.last_speaker
+
+    def get_recent_names(self):
+        """ดึงประวัติชื่อที่ validate แล้ว"""
+        return self.name_history
+
+    def get_speaker_style(self, speaker_name):
+        """ดึงรูปแบบการพูดของตัวละคร"""
+        return self.speaker_styles.get(speaker_name, "")
+
+    def clear(self):
+        """ล้าง cache"""
+        self.name_history.clear()
+        self.last_speaker = None
+
+    def clear_session(self):
+        """ล้างข้อมูลเซสชั่น"""
+        self.session_speakers.clear()
+        self.name_translations.clear()
+        self.speaker_styles.clear()  # เพิ่มการล้าง speaker_styles
+        self.last_speaker = None
+
+    def add_validated_name(self, name):
+        """เพิ่มชื่อที่ผ่านการ validate แล้วเท่านั้น"""
+        if name and name != self.last_speaker:
+            self.last_speaker = name
+            if name not in self.name_history:
+                self.name_history.append(name)
+                if len(self.name_history) > self.MAX_HISTORY:
+                    self.name_history.pop(0)
+
+    def add_speaker(self, speaker_name, translated_name=None):
+        """เพิ่มชื่อผู้พูดในเซสชั่น"""
+        if speaker_name:
+            if speaker_name not in self.session_speakers:
+                self.session_speakers.append(speaker_name)
+            self.last_speaker = speaker_name
+            if translated_name:
+                self.name_translations[speaker_name] = translated_name
+
+    def get_speaker_translation(self, speaker_name):
+        """ดึงการแปลชื่อที่เคยแปลไว้"""
+        return self.name_translations.get(speaker_name)
+
+    def get_last_speaker(self):
+        """ดึงชื่อล่าสุดที่ validate แล้ว"""
+        return self.last_speaker
+
+    def get_recent_names(self):
+        """ดึงประวัติชื่อที่ validate แล้ว"""
+        return self.name_history
+
+    def get_speaker_style(self, speaker_name):
+        """ดึงรูปแบบการพูดของตัวละคร"""
+        return self.speaker_styles.get(speaker_name, "")
+
+    def clear(self):
+        """ล้าง cache"""
+        self.name_history.clear()
+        self.last_speaker = None
+
+    def clear_session(self):
+        """ล้างข้อมูลเซสชั่น"""
+        self.session_speakers.clear()
+        self.name_translations.clear()
+        self.speaker_styles.clear()  # เพิ่มการล้าง speaker_styles
+        self.last_speaker = None
+
+
+class Translator:
+    def __init__(self, settings=None):
+        self.api_key = os.getenv("OPENAI_API_KEY")
+        if not self.api_key:
+            raise ValueError("OPENAI_API_KEY not found in .env file")
+        self.client = OpenAI(api_key=self.api_key)
+        self.translation_logger = TranslationLogger()
+
+        # ใช้ settings object ถ้ามี
+        if settings:
+            api_params = settings.get_api_parameters()
+            self.model = api_params.get("model", "gpt-4o")
+            self.max_tokens = api_params.get("max_tokens", 500)
+            self.temperature = api_params.get("temperature", 0.7)
+            self.top_p = api_params.get("top_p", 0.9)
+        else:
+            # ถ้าไม่มี settings ให้โหลดจากไฟล์
+            try:
+                with open("settings.json", "r") as f:
+                    settings_data = json.load(f)
+                    api_params = settings_data.get("api_parameters", {})
+                    self.model = api_params.get("model", "gpt-4o")
+                    self.max_tokens = api_params.get("max_tokens", 500)
+                    self.temperature = api_params.get("temperature", 0.7)
+                    self.top_p = api_params.get("top_p", 0.9)
+            except (FileNotFoundError, json.JSONDecodeError):
+                self.model = "gpt-4o"
+                self.max_tokens = 500
+                self.temperature = 0.7
+                self.top_p = 0.9
+                logging.warning("Could not load settings.json, using default values")
+
+        self.cache = DialogueCache()
+        self.last_translations = {}
+        self.character_names_cache = set()
+        self.text_corrector = TextCorrector()
+        self.load_npc_data()
+        self.load_example_translations()
+
+    def get_current_parameters(self):
+        """Return current translation parameters"""
+        return {
+            "model": self.model,  # สำหรับ GPT ใช้ค่าเดียวกันทั้ง model และ displayed_model
+            "displayed_model": self.model,
+            "max_tokens": self.max_tokens,
+            "temperature": self.temperature,
+            "top_p": self.top_p,
+        }
+
+    def load_npc_data(self):
+        try:
+            with open("NPC.json", "r", encoding="utf-8") as file:
+                npc_data = json.load(file)
+                self.character_data = npc_data["main_characters"]
+                self.context_data = npc_data["lore"]
+                self.character_styles = npc_data["character_roles"]
+
+                # Update character_names_cache
+                self.character_names_cache = set()  # เคลียร์ก่อน
+                self.character_names_cache.add("???")  # เพิ่ม ??? เป็นลำดับแรก
+
+                # Load main characters
+                for char in self.character_data:
+                    self.character_names_cache.add(char["firstName"])
+                    if char["lastName"]:
+                        self.character_names_cache.add(
+                            f"{char['firstName']} {char['lastName']}"
+                        )
+
+                # Load NPCs
+                for npc in npc_data["npcs"]:
+                    self.character_names_cache.add(npc["name"])
+
+                print(
+                    "Translator: Loaded character names:", self.character_names_cache
+                )  # Debug log
+
+                # เพิ่มรูปแบบการพูดเข้า cache
+                for name, style in self.character_styles.items():
+                    self.cache.speaker_styles[name] = style
+
+                # ตรวจสอบว่ามี style สำหรับ ???
+                if "???" not in self.character_styles:
+                    self.character_styles["???"] = "ใช้ภาษาที่เป็นปริศนา ชวนให้สงสัยในตัวตน"
+                    self.cache.speaker_styles["???"] = self.character_styles["???"]
+
+        except FileNotFoundError:
+            raise FileNotFoundError("NPC.json file not found")
+        except json.JSONDecodeError:
+            raise ValueError("Invalid JSON in NPC.json")
+
+    def load_example_translations(self):
+        self.example_translations = {
+            # ตัวอย่างการแปลข้อความสั้น
+            "'Tis": "ช่างเป็น...",
+            "'I do": "ฉันเข้าใจ",
+            "'do": "ฉันเข้าใจ",
+            "'Twas": "มันเคยเป็น...",
+            "Nay": "หามิได้",
+            "Aye": "เป็นเช่นนั้น",
+            "Mayhaps": "บางที...",
+            "Hm...": "อืม...",
+            "Wait!": "เดี๋ยวก่อน!",
+            "My friend...": "สหายข้า...",
+            "Tataru?": "Tataru เหรอ?",
+            "Estinien!": "Estinien!",
+            "sigh": "เฮ่อ..",
+            "Hmph.": "ฮึ่ม.",
+            # ตัวอย่างข้อความประโยคยาว
+            "Y'shtola: The aetheric fluctuations in this area are most peculiar. We should proceed with caution.": "Y'shtola: ความผันผวนของพลังอีเธอร์แถบนี้... น่าพิศวงยิ่งนัก เราควรก้าวต่อไปด้วยความระมัดระวัง",
+            "Alphinaud: The political implications of our actions here could be far-reaching. We must consider every possible outcome.": "Alphinaud: นัยทางการเมืองจากการกระทำของพวกเราในครั้งนี้ อาจส่งผลกระทบไปไกล เราต้องนึกถึงทุกความเป็นไปได้อย่างถี่ถ้วน",
+            "Alisaie: I won't stand idly by while others risk their lives. If we're to face this threat, we do so together.": "Alisaie: ฉันจะไม่ยืนดูดายในขณะที่คนอื่นเสี่ยงชีวิตหรอกนะ ถ้าเราต้องเผชิญหน้ากับภัยคุกคามนี้ เราก็จะสู้ไปด้วยกันนี่แหล่ะ!",
+            "Urianger: Pray, let us contemplate the implications of our recent discoveries. The path ahead may yet be fraught with unforeseen perils.": "Urianger: ข้าขอวิงวอน ให้พวกเราใคร่ครวญถึงนัยสำคัญแห่งการค้นพบล่าสุดของพวกเรา หนทางเบื้องหน้าอาจเต็มไปด้วยภยันตรายอันมิอาจคาดเดา",
+            "Thancred: Sometimes, you have to take risks. Calculated risks, mind you. But risks all the same.": "Thancred: บางครั้งเราก็ต้องเสี่ยงบ้างล่ะนะ เสี่ยงแบบคำนวณแล้วน่ะ แต่ก็ยังเป็นการเสี่ยงอยู่ดี",
+        }
+
+    def update_parameters(
+        self, model=None, max_tokens=None, temperature=None, top_p=None, **kwargs
+    ):
+        """อัพเดทค่าพารามิเตอร์สำหรับการแปล"""
+        try:
+            old_params = {
+                "model": self.model,
+                "max_tokens": self.max_tokens,
+                "temperature": self.temperature,
+                "top_p": self.top_p,
+            }
+
+            changes = []
+
+            if model is not None:
+                valid_models = ["gpt-4o", "gpt-4o-mini"]
+                if model not in valid_models:
+                    raise ValueError(
+                        f"Invalid model for GPT translator. Must be one of: {', '.join(valid_models)}"
+                    )
+                self.model = model  # model ID และ displayed_model เป็นค่าเดียวกันสำหรับ GPT
+                changes.append(f"Model: {old_params['model']} -> {model}")
+
+            if max_tokens is not None:
+                if not (100 <= max_tokens <= 1000):
+                    raise ValueError(
+                        f"Max tokens must be between 100 and 1000, got {max_tokens}"
+                    )
+                self.max_tokens = max_tokens
+                changes.append(
+                    f"Max tokens: {old_params['max_tokens']} -> {max_tokens}"
+                )
+
+            if temperature is not None:
+                if not (0.5 <= temperature <= 0.9):
+                    raise ValueError(
+                        f"Temperature must be between 0.5 and 0.9, got {temperature}"
+                    )
+                self.temperature = temperature
+                changes.append(
+                    f"Temperature: {old_params['temperature']} -> {temperature}"
+                )
+
+            if top_p is not None:
+                if not (0.5 <= top_p <= 0.9):
+                    raise ValueError(f"Top P must be between 0.5 and 0.9, got {top_p}")
+                self.top_p = top_p
+                changes.append(f"Top P: {old_params['top_p']} -> {top_p}")
+
+            if changes:
+                print("\n=== GPT Parameters Updated ===")
+                for change in changes:
+                    print(change)
+                print(f"Current model: {self.model}")
+                print("==========================\n")
+
+            return True, None
+
+        except ValueError as e:
+            print(f"[GPT] Parameter update failed: {str(e)}")
+            return False, str(e)
+
+    def translate(
+        self, text, source_lang="English", target_lang="Thai", is_choice_option=False
+    ):
+        """
+        แปลข้อความพร้อมจัดการบริบทของตัวละคร
+        Args:
+            text: ข้อความที่ต้องการแปล
+            source_lang: ภาษาต้นฉบับ (default: English)
+            target_lang: ภาษาเป้าหมาย (default: Thai)
+            is_choice_option: เป็นข้อความตัวเลือกหรือไม่ (default: False)
+        Returns:
+            str: ข้อความที่แปลแล้ว
+        """
+        try:
+            if not text:
+                logging.warning("Empty text received for translation")
+                return ""
+
+            # ใช้ text_corrector instance ที่สร้างไว้แล้ว
+            speaker, content, dialogue_type = (
+                self.text_corrector.split_speaker_and_content(text)
+            )
+
+            # เพิ่มการตรวจสอบพิเศษสำหรับ 22
+            if text.strip() in ["22", "22?", "222", "222?"]:
+                return "???"
+
+            # กรณีพิเศษสำหรับ ??? หรือ 222
+            if text.strip() in ["222", "222?", "???"]:
+                return "???"
+
+            # ตรวจสอบว่าเป็นข้อความตัวเลือกหรือไม่
+            if not is_choice_option:
+                is_choice, prompt_part, choices = self.is_similar_to_choice_prompt(text)
+                if is_choice:
+                    return self.translate_choice(text)
+
+            # กรณีมีชื่อผู้พูด
+            if dialogue_type == DialogueType.CHARACTER and speaker:
+                # กรณีพิเศษสำหรับ ???
+                if speaker.startswith("?"):
+                    speaker = "???"
+
+                character_name = speaker
+                dialogue = content
+
+                # ตรวจสอบ cache สำหรับการแปล
+                if (
+                    dialogue in self.last_translations
+                    and character_name == self.cache.get_last_speaker()
+                ):
+                    translated_dialogue = self.last_translations[dialogue]
+                    return f"{character_name}: {translated_dialogue}"
+
+                # 1. ดึงข้อมูลพื้นฐานของตัวละคร
+                character_info = self.get_character_info(character_name)
+                context = ""
+                if character_info:
+                    context = (
+                        f"Character: {character_info['firstName']}, "
+                        f"Gender: {character_info['gender']}, "
+                        f"Role: {character_info['role']}, "
+                        f"Relationship: {character_info['relationship']}"
+                    )
+                elif character_name == "???":
+                    context = "Character: Unknown, Role: Mystery character"
+
+                # 2. ดึงรูปแบบการพูด
+                character_style = self.character_styles.get(character_name, "")
+                if not character_style and character_name == "???":
+                    character_style = (
+                        "ใช้ภาษาที่เป็นปริศนา ชวนให้สงสัยในตัวตน แต่ยังคงบุคลิกที่น่าสนใจ"
+                    )
+
+                self.cache.add_speaker(character_name)
+
+            else:
+                # กรณีข้อความทั่วไป
+                dialogue = text
+                character_name = ""
+                context = ""
+                character_style = ""
+
+            # สร้าง prompt และแปล
+            special_terms = self.context_data.copy()
+            example_prompt = "Here are examples of good translations:\\n\\n"
+            for eng, thai in self.example_translations.items():
+                example_prompt += f"English: {eng}\\nThai: {thai}\\n\\n"
+
+            prompt = (
+                "You are a professional translator specializing in video game localization for Final Fantasy XIV. "
+                "Your task is to translate English game text to Thai with these requirements:\\n"
+                "1. Translate the text naturally while preserving the character's tone and style\\n"
+                "2. Keep proper nouns and character names in English\\n"
+                "3. For very short text, treat it as either: phrase, exclamation, or name calling only\\n"
+                "4. If the text contains unclear parts, translate what you can understand and mark unclear parts with [...]\\n"
+                "5. Maintain character speech patterns and emotional expressions\\n"
+                "6. Use ellipsis (...) or em dash (—) for pauses as in the original\\n"
+                "7. Avoid polite particles unless part of character's style\\n"
+                "8. Focus on natural, conversational Thai that matches the game context\\n"
+                f"Context: {context}\\n"
+                f"Character's style: {character_style}\\n"
+                f"Do not translate: {', '.join(self.character_names_cache)}\\n\\n"
+                "Special terms:\\n"
+            )
+
+            for term, explanation in special_terms.items():
+                prompt += f"{term}: {explanation}\\n"
+            prompt += f"\\n{example_prompt}\\nText to translate: {dialogue}"
+
+            try:
+                response = self.client.chat.completions.create(
+                    model=self.model,
+                    messages=[
+                        {"role": "system", "content": prompt},
+                        {"role": "user", "content": dialogue},
+                    ],
+                    max_tokens=self.max_tokens,
+                    temperature=self.temperature,
+                    top_p=self.top_p,
+                )
+                translated_dialogue = response.choices[0].message.content.strip()
+
+                # เพิ่มการบันทึก log ตรงนี้
+                try:
+                    self.translation_logger.log_translation(text, translated_dialogue)
+                except Exception as e:
+                    logging.error(f"Error logging translation: {e}")
+
+                # ทำความสะอาดข้อความแปล
+                translated_dialogue = re.sub(
+                    r"\b(ครับ|ค่ะ|ครับ/ค่ะ)\b", "", translated_dialogue
+                ).strip()
+                for term in special_terms:
+                    translated_dialogue = re.sub(
+                        r"\b" + re.escape(term) + r"\b",
+                        term,
+                        translated_dialogue,
+                        flags=re.IGNORECASE,
+                    )
+
+                # บันทึกลง cache
+                self.last_translations[dialogue] = translated_dialogue
+
+                if character_name:
+                    self.cache.add_validated_name(character_name)  # เพิ่มชื่อเข้า cache
+                    return f"{character_name}: {translated_dialogue}"
+                return translated_dialogue
+
+            except ValueError as e:
+                logging.error(f"Error in is_similar_to_choice_prompt: {str(e)}")
+                return self.translate_choice(text)
+
+        except Exception as e:
+            logging.error(f"Unexpected error in translation: {str(e)}")
+            return f"[Error: {str(e)}]"
+
+    def is_similar_to_choice_prompt(self, text, threshold=0.8):
+        """
+        ตรวจสอบและแยกส่วนประกอบของ choice dialogue
+        Returns:
+            tuple: (is_choice, prompt_part, choices)
+        """
+        try:
+            # 1. ถ้าไม่มีข้อความหรือสั้นเกินไป ถือว่าไม่ใช่ choice
+            if not text or len(text) < 10:
+                return False, None, []
+
+            # 2. ตัวอย่างรูปแบบ header ที่ต้องตรวจจับ
+            choice_headers = [
+                "What will you say?",
+                "What will you do?",
+                "Select an option.",
+                "Choose your response.",
+            ]
+
+            # 3. ตรวจสอบ header ตรงๆ
+            if not any(header.lower() in text.lower() for header in choice_headers):
+                return False, None, []
+
+            # 4. แยก header
+            header = "What will you say?"
+            remaining_text = text.replace(header, "").strip()
+
+            # 5. คำขึ้นต้นที่พบบ่อยในตัวเลือก - สำคัญมากห้ามลบ!
+            common_starts = [
+                "I suppose",
+                "I think",
+                "I will",
+                "I'll",
+                "I can",
+                "We should",
+                "We can",
+                "We will",
+                "We'll",
+                "Yes",
+                "No",
+                "Perhaps",
+                "Maybe",
+                "The ",
+                "But ",
+                "So ",
+                "You ",
+                "Let's",
+                "Please",
+                "Thank",
+                "Very",
+            ]
+
+            # 6. ลองแยกด้วย ! หรือ . ก่อน
+            choices = [c.strip() for c in re.split("[!.]", remaining_text) if c.strip()]
+
+            # 7. ถ้าแยกไม่ได้ ใช้ common_starts
+            if len(choices) <= 1:
+                temp_text = remaining_text
+                choices = []
+
+                for start in common_starts:
+                    if start in temp_text:
+                        parts = temp_text.split(start)
+                        if parts[0]:
+                            choices.append(parts[0].strip())
+                        temp_text = start + parts[1]
+
+                if temp_text:
+                    choices.append(temp_text.strip())
+
+            # 8. ต้องมีอย่างน้อย 1 ตัวเลือก
+            if choices:
+                return True, header, choices
+
+            return False, None, []
+
+        except Exception as e:
+            logging.error(f"Error in is_similar_to_choice_prompt: {str(e)}")
+            return False, None, []
+
+    def translate_choice(self, text):
+        """แปลข้อความตัวเลือกของผู้เล่น
+        Args:
+            text: ข้อความที่จะแปล เช่น "What will you say?\nOption 1\nOption 2"
+        Returns:
+            str: ข้อความที่แปลแล้ว เช่น "คุณจะพูดว่าอย่างไร?\nตัวเลือก 1\nตัวเลือก 2"
+        """
+        try:
+            # 1. ตรวจสอบและแยกส่วนประกอบ
+            is_choice, header, choices = self.is_similar_to_choice_prompt(text)
+
+            if is_choice:
+                # 2. กำหนด header ภาษาไทยแบบคงที่
+                translated_header = "คุณจะพูดว่าอย่างไร?"
+                translated_choices = []
+
+                # 3. แปลเฉพาะส่วน choices โดยตัด header ออก
+                for choice in choices:
+                    choice = choice.strip()
+                    if not choice:
+                        continue
+
+                    # 4. แปลแต่ละตัวเลือก โดยใช้ is_choice_option=True
+                    translated_choice = self.translate(choice, is_choice_option=True)
+                    if translated_choice:
+                        # 5. ตรวจสอบและป้องกันการซ้ำซ้อนกับ header
+                        if translated_choice != translated_header:
+                            translated_choices.append(translated_choice)
+
+                # 6. รวมผลลัพธ์ในรูปแบบที่ถูกต้อง
+                if translated_choices:
+                    # ใช้ \n เพียงครั้งเดียวระหว่าง header และ choices
+                    result = f"{translated_header}\n" + "\n".join(translated_choices)
+                    logging.debug(f"Choice translation result: {result}")
+                    return result
+
+                # 7. กรณีไม่มี choices ส่งคืนเฉพาะ header
+                return translated_header
+
+            # 8. กรณีไม่ใช่ข้อความตัวเลือก แปลปกติ
+            return self.translate(text)
+
+        except Exception as e:
+            logging.error(f"Error in translating choices: {str(e)}")
+            return f"[Error in choice translation: {str(e)}]"
+
+    def get_character_info(self, character_name):
+        if character_name == "???":
+            return {
+                "firstName": "???",
+                "gender": "unknown",
+                "role": "Mystery character",
+                "relationship": "Unknown/Mysterious",
+                "pronouns": {"subject": "ฉัน", "object": "ฉัน", "possessive": "ของฉัน"},
+            }
+        for char in self.character_data:
+            if (
+                character_name == char["firstName"]
+                or character_name == f"{char['firstName']} {char['lastName']}".strip()
+            ):
+                return char
+        return None
+
+    def batch_translate(self, texts, batch_size=10):
+        """แปลข้อความเป็นชุด"""
+        translated_texts = []
+        for i in range(0, len(texts), batch_size):
+            batch = texts[i : i + batch_size]
+            translated_batch = [self.translate(text) for text in batch]
+            translated_texts.extend(translated_batch)
+        return translated_texts
+
+    def analyze_translation_quality(self, original_text, translated_text):
+        """วิเคราะห์คุณภาพการแปล"""
+        prompt = (
+            "As a translation quality assessor, evaluate the following translation from English to Thai. "
+            "Consider factors such as accuracy, naturalness, and preservation of the original tone and style. "
+            f"Original (English): {original_text}\n"
+            f"Translation (Thai): {translated_text}\n"
+            "Provide a brief assessment and a score out of 10."
+        )
+
+        try:
+            # เปลี่ยนเป็นการใช้ client ใหม่
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": prompt},
+                    {"role": "user", "content": "Assess the translation quality."},
+                ],
+                max_tokens=200,
+            )
+            return response.choices[0].message.content.strip()
+        except Exception as e:
+            logging.error(f"Error in translation quality analysis: {str(e)}")
+            return "Unable to assess translation quality due to an error."
+
+    def reload_data(self):
+        """โหลดข้อมูลใหม่และล้าง cache"""
+        print("Translator: Reloading NPC data...")  # เพิ่มบรรทัดนี้
+        self.load_npc_data()
+        self.load_example_translations()
+        self.cache.clear_session()
+        self.last_translations.clear()
+        print("Translator: Data reloaded successfully")  # เพิ่มบรรทัดนี้
+
+
+if __name__ == "__main__":
+    try:
+        translator = Translator()
+
+        # ตัวอย่างการแปลข้อความเดี่ยว
+        test_cases = [
+            "Y'shtola: The aetheric fluctuations in this area are most peculiar.",
+            "Y'shtola: We should proceed with caution.",
+            "???: Who goes there?",
+            "What will you say?\nYes, of course.\nI'm not sure about this.",
+            "The wind howls through the ancient ruins.",
+        ]
+
+        print("=== Translation Test Cases ===")
+        for text in test_cases:
+            translated = translator.translate(text)
+            print(f"\nOriginal: {text}")
+            print(f"Translation: {translated}")
+
+    except ValueError as e:
+        print(f"Error: {e}")

translator_claude.py

@@ -0,0 +1,332 @@
+import anthropic
+import os
+from dotenv import load_dotenv
+import re
+import tkinter as tk
+from tkinter import messagebox
+import json
+import difflib
+import time
+import logging
+
+load_dotenv()
+
+class TranslatorClaude:
+    def __init__(self, settings=None):
+        self.api_key = os.getenv('ANTHROPIC_API_KEY')
+        if not self.api_key:
+            raise ValueError("ANTHROPIC_API_KEY not found in .env file")
+        self.client = anthropic.Anthropic(api_key=self.api_key)
+        
+        # ใช้ settings object ถ้ามี
+        if settings:
+            api_params = settings.get_api_parameters()
+            self.model = api_params.get('model', "claude-3-5-haiku-20241022")
+            self.displayed_model = api_params.get('displayed_model', "claude-3.5-haiku")
+            self.max_tokens = api_params.get('max_tokens', 500)
+            self.temperature = api_params.get('temperature', 0.7)
+        else:
+            # ถ้าไม่มี settings ให้ใช้ค่าเริ่มต้น
+            self.model = "claude-3-5-haiku-20241022"
+            self.displayed_model = "claude-3.5-haiku"
+            self.max_tokens = 500
+            self.temperature = 0.7
+
+        self.character_names_cache = set()
+        self.character_data = []
+        self.context_data = {}
+        self.character_styles = {}
+        self.character_names_cache.add("???")
+        self.load_npc_data()
+        self.load_example_translations()
+        
+        print(f"[Claude API] Initialized with model: {self.displayed_model}")
+
+    def load_npc_data(self):
+        try:
+            with open('NPC.json', 'r', encoding='utf-8') as file:
+                npc_data = json.load(file)
+                self.character_data = npc_data['main_characters']
+                self.context_data = npc_data['lore']
+                self.character_styles = npc_data['character_roles']
+                
+                # Update character_names_cache
+                for char in self.character_data:
+                    self.character_names_cache.add(char['firstName'])
+                    if char['lastName']:
+                        self.character_names_cache.add(f"{char['firstName']} {char['lastName']}")
+                
+                # Add NPCs to character_names_cache
+                for npc in npc_data['npcs']:
+                    self.character_names_cache.add(npc['name'])
+                
+                print("[Claude API] Successfully loaded NPC data")
+        except FileNotFoundError:
+            raise FileNotFoundError("NPC.json file not found")
+        except json.JSONDecodeError:
+            raise ValueError("Invalid JSON in NPC.json")
+
+    def load_example_translations(self):
+        self.example_translations = {
+            "Y'shtola: The aetheric fluctuations in this area are most peculiar. We should proceed with caution.":
+            "Y'shtola: ความผันผวนของพลังอีเธอร์แถบนี้... น่าพิศวงยิ่งนัก เราควรก้าวต่อไปด้วยความระมัดระวัง",
+
+            "Alphinaud: The political implications of our actions here could be far-reaching. We must consider every possible outcome.":
+            "Alphinaud: นัยทางการเมืองจากการกระทำของพวกเราในครั้งนี้ อาจส่งผลกระทบไปไกล เราต้องนึกถึงทุกความเป็นไปได้อย่างถี่ถ้วน",
+
+            "Alisaie: I won't stand idly by while others risk their lives. If we're to face this threat, we do so together.":
+            "Alisaie: ฉันจะไม่ยืนดูดายในขณะที่คนอื่นเสี่ยงชีวิต ถ้าเราต้องเผชิญหน้ากับภัยคุกคามนี้ เราก็จะสู้ไปด้วยกันนี่แหล่ะ!",
+
+            "Urianger: Pray, let us contemplate the implications of our recent discoveries. The path ahead may yet be fraught with unforeseen perils.":
+            "Urianger: ข้าขอวิงวอน ให้พวกเราใคร่ครวญถึงนัยสำคัญแห่งการค้นพบล่าสุดของพวกเรา หนทางเบื้องหน้าอาจเต็มไปด้วยภยันตรายอันมิอาจคาดเดา",
+
+            "Thancred: Sometimes, you have to take risks. Calculated risks, mind you. But risks all the same.":
+            "Thancred: บางครั้งเราก็ต้องเสี่ยงบ้างล่ะนะ เสี่ยงแบบคำนวณแล้วน่ะ แต่ก็ยังเป็นการเสี���ยงอยู่ดี"
+        }
+        print("[Claude API] Example translations loaded")
+
+    def update_parameters(self, model=None, max_tokens=None, temperature=None, **kwargs):
+        """อัพเดทค่าพารามิเตอร์สำหรับการแปล"""
+        try:
+            changes = []
+            
+            if model is not None:
+                old_model = self.model
+                # ตรวจสอบ model ID แทนชื่อที่แสดง
+                if model != "claude-3-5-haiku-20241022":
+                    raise ValueError(f"Invalid model for Claude translator: {model}")
+                self.model = model
+                self.displayed_model = "claude-3.5-haiku"  # ใช้ชื่อแสดงคงที่
+                changes.append(f"Model: {old_model} -> {model}")
+                
+            if max_tokens is not None:
+                old_tokens = self.max_tokens
+                if not (100 <= max_tokens <= 1000):
+                    raise ValueError(f"Max tokens must be between 100 and 1000, got {max_tokens}")
+                self.max_tokens = max_tokens
+                changes.append(f"Max tokens: {old_tokens} -> {max_tokens}")
+                
+            if temperature is not None:
+                old_temp = self.temperature
+                if not (0.5 <= temperature <= 0.9):
+                    raise ValueError(f"Temperature must be between 0.5 and 0.9, got {temperature}")
+                self.temperature = temperature
+                changes.append(f"Temperature: {old_temp} -> {temperature}")
+
+            if changes:
+                print("\n[Claude API] Parameters updated:")
+                for change in changes:
+                    print(change)
+                print(f"Current model: {self.displayed_model}")
+            return True, None
+
+        except ValueError as e:
+            print(f"[Claude API] Parameter update failed: {str(e)}")
+            return False, str(e)
+        
+    def is_valid_text(self, text):
+        """ตรวจสอบความถูกต้องของข้อความ"""
+        return bool(re.search(r'\b\w{3,}\b', text))
+
+    def get_character_info(self, character_name):
+        """ดึงข้อมูลตัวละคร"""
+        for char in self.character_data:
+            if character_name == char["firstName"] or character_name == f"{char['firstName']} {char['lastName']}".strip():
+                return char
+        return None
+
+    def extract_character_name(self, text):
+        """แยกชื่อตัวละครออกจากข้อความ"""
+        parts = text.split(':', 1)
+        if len(parts) > 1:
+            character_name = parts[0].strip()
+            if character_name in self.character_names_cache:
+                return character_name, parts[1].strip()
+        return "", text
+
+    def translate(self, text, source_lang="English", target_lang="Thai", force_translate=False):
+        """แปลข้อความโดยใช้ Claude API"""
+        try:
+            print(f"[Claude API] Translating: {text}")
+            if not self.is_valid_text(text):
+                return ""
+
+            character_name, dialogue = self.extract_character_name(text)
+            character_info = self.get_character_info(character_name)
+            
+            # สร้าง context สำหรับการแปล
+            context = ""
+            if character_info:
+                context = f"Character: {character_info['firstName']}, Gender: {character_info['gender']}, Role: {character_info['role']}, Relationship: {character_info['relationship']}"
+            elif character_name == "???":
+                context = "Character: Unknown, Role: Mystery character"
+
+            # ดึง character style
+            character_style = self.character_styles.get(character_name, "")
+            if character_name == "???":
+                character_style = "ใช้ภาษาที่เป็นปริศนา ชวนให้สงสัยในตัวตน แต่ยังคงบุคลิกที่น่าสนใจ"
+
+            # สร้าง prompt
+            system_prompt = (
+                "You are a professional translator specializing in video game localization for Final Fantasy XIV. "
+                "Translate the given English text to Thai with these requirements:\n"
+                "1. Keep the original tone and character's personality\n"
+                "2. Maintain character names and special terms in English\n"
+                "3. Use natural, conversational Thai that matches the game context\n"
+                "4. Use proper emotion and speech patterns\n"
+                "5. Use ellipsis (...) or em dash (—) for pauses\n"
+                "6. Avoid polite particles (ครับ/ค่ะ)\n"
+                "Provide only the translated text without explanations."
+            )
+
+            user_prompt = (
+                f"Context: {context}\n"
+                f"Character speaking style: {character_style}\n\n"
+                f"Do not translate these names: {', '.join(self.character_names_cache)}\n\n"
+                "Special terms:\n"
+            )
+
+            for term, explanation in self.context_data.items():
+                user_prompt += f"{term}: {explanation}\n"
+
+            user_prompt += f"\nText to translate: {dialogue}"
+
+            try:
+                response = self.client.messages.create(
+                    model=self.model,
+                    max_tokens=self.max_tokens,
+                    temperature=self.temperature,
+                    system=system_prompt,
+                    messages=[{"role": "user", "content": user_prompt}]
+                )
+                
+                translated_dialogue = response.content[0].text.strip()
+                
+                # ตรวจสอบและแก้ไขชื่อตัวละคร
+                if translated_dialogue:
+                    for name in self.character_names_cache:
+                        if name in dialogue and name not in translated_dialogue:
+                            translated_dialogue = translated_dialogue.replace(name, name)
+                
+                translated_dialogue = re.sub(r'\b(ครับ|ค่ะ|ครับ/ค่ะ)\b', '', translated_dialogue).strip()
+                
+                # เพิ่มชื่อตัวละครกลับเข้าไป
+                if character_name:
+                    final_translation = f"{character_name}: {translated_dialogue}"
+                else:
+                    final_translation = translated_dialogue
+
+                print(f"[Claude API] Translation complete")
+                return final_translation
+
+            except Exception as e:
+                print(f"[Claude API] Translation error: {str(e)}")
+                return f"[Translation Error: {str(e)}]"
+
+        except Exception as e:
+            print(f"[Claude API] Unexpected error: {str(e)}")
+            return ""
+
+    def batch_translate(self, texts, batch_size=10):
+        """แปลข้อความเป็นชุด"""
+        translated_texts = []
+        for i in range(0, len(texts), batch_size):
+            batch = texts[i:i+batch_size]
+            translated_batch = [self.translate(text) for text in batch]
+            translated_texts.extend(translated_batch)
+        return translated_texts
+
+    def adaptive_translation(self, text, max_retries=3):
+        """พยายามแปลซ้ำหากเกิดข้อผิดพลาด"""
+        for attempt in range(max_retries):
+            try:
+                translation = self.translate(text)
+                if translation:
+                    return translation
+            except Exception:
+                if attempt == max_retries - 1:
+                    return self.fallback_translation(text)
+        return self.fallback_translation(text)
+
+    def fallback_translation(self, text):
+        """แปลแบบฉุกเฉินเมื่อไม่สามารถแปลปกติได้"""
+        return f"[ไม่สามารถแปลได้: {text}]"
+
+    def update_character_style(self, character_name, new_style):
+        """อัพเดทสไตล์การพูดของตัวละคร"""
+        self.character_styles[character_name] = new_style
+        print(f"[Claude API] Updated style for {character_name}")
+
+    def reload_data(self):
+        """โหลดข้อมูล NPC ใหม่"""
+        print("[Claude API] Reloading NPC data")
+        self.load_npc_data()
+        self.load_example_translations()    
+
+    def get_current_parameters(self):
+        """Return current translation parameters"""
+        return {
+            'model': self.model,
+            'displayed_model': self.displayed_model,
+            'max_tokens': self.max_tokens,
+            'temperature': self.temperature
+        }
+
+    def analyze_translation_quality(self, original_text, translated_text):
+        """วิเคราะห์คุณภาพการแปล (ใช้เฉพาะเมื่อต้องการตรวจสอบ)"""
+        prompt = (
+            "As a translation quality assessor for Final Fantasy XIV, evaluate this translation:\n"
+            f"Original (English): {original_text}\n"
+            f"Translation (Thai): {translated_text}\n"
+            "Provide a brief assessment and score out of 10."
+        )
+        
+        try:
+            response = self.client.messages.create(
+                model=self.model,
+                max_tokens=200,
+                temperature=0.7,
+                messages=[
+                    {"role": "user", "content": prompt}
+                ]
+            )
+            assessment = response.content[0].text.strip()
+            return assessment
+        except Exception as e:
+            print(f"[Claude API] Quality assessment error: {str(e)}")
+            return "Unable to assess translation quality."
+
+# Example usage
+if __name__ == "__main__":
+    try:
+        translator = TranslatorClaude()
+        
+        # Single translation example
+        text_to_translate = "Y'shtola: The aetheric fluctuations in this area are most peculiar. We should proceed with caution."
+        translation = translator.translate(text_to_translate)
+        print(f"\nOriginal: {text_to_translate}")
+        print(f"Translation: {translation}")
+        
+        # Unknown character example
+        unknown_character_text = "???: I apologize for startling you, but I have my reasons for lurking in the shadows."
+        unknown_translation = translator.translate(unknown_character_text)
+        print(f"\nOriginal: {unknown_character_text}")
+        print(f"Translation: {unknown_translation}")
+        
+        # Batch translation example
+        texts_to_translate = [
+            "Urianger: Pray, let us consider the implications of our recent discoveries.",
+            "Wuk Lamat: Wow! This place is amazing! I can't wait to explore every nook and cranny!",
+            "Sphene: As princess of Alexandria, I must remain composed, but I admit this adventure excites me greatly."
+        ]
+        
+        print("\nBatch Translation Examples:")
+        batch_translations = translator.batch_translate(texts_to_translate)
+        for original, translated in zip(texts_to_translate, batch_translations):
+            print(f"\nOriginal: {original}")
+            print(f"Translation: {translated}")
+        
+    except ValueError as e:
+        print(f"Error: {e}")
+    except Exception as e:
+        print(f"Unexpected error: {e}")    

translator_factory.py

@@ -0,0 +1,35 @@
+# translator_factory.py
+import logging
+from translator import Translator
+from translator_claude import TranslatorClaude
+
+class TranslatorFactory:
+    @staticmethod
+    def create_translator(settings):
+        """สร้าง translator ตามประเภทของ model ที่กำหนดใน settings"""
+        try:
+            api_params = settings.get_api_parameters()
+            model = api_params.get('model')
+            
+            # ตรวจสอบประเภท model
+            if model == "claude-3-5-haiku-20241022":
+                logging.info(f"Creating Claude Translator with model: {model}")
+                return TranslatorClaude(settings)
+            else:
+                logging.info(f"Creating GPT Translator with model: {model}")
+                return Translator(settings)
+                
+        except Exception as e:
+            logging.error(f"Error creating translator: {str(e)}")
+            # ถ้าเกิดข้อผิดพลาด ให้ใช้ GPT translator เป็นค่าเริ่มต้น
+            return Translator(settings)
+
+    @staticmethod
+    def validate_model_type(model):
+        """ตรวจสอบประเภทของ model"""
+        model_types = {
+            'gpt-4o': 'gpt',
+            'gpt-4o-mini': 'gpt', 
+            'claude-3-5-haiku-20241022': 'claude'
+        }
+        return model_types.get(model)