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("", self.on_click) self.root.bind("", self.stop_move) self.root.bind("", self.on_drag) self.components.canvas.bind("", self.show_full_text) self.components.canvas.bind("", self.on_canvas_configure) self.components.canvas.bind("", self.on_mousewheel) # Add mousewheel binding to all frames for widget in [ self.components.main_frame, self.components.text_frame, self.root, ]: widget.bind("", self.on_mousewheel) # Resize bindings self.resize_handle.bind("", self.start_resize) self.resize_handle.bind("", self.on_resize) self.resize_handle.bind("", 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("", 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("", self.start_resize) self.resize_handle.bind("", self.on_resize) self.resize_handle.bind("", 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", "", 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", "", self._on_name_hover_enter) self.components.canvas.tag_bind("name", "", self._on_name_hover_leave) self.components.canvas.tag_bind("name", "", 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()