translated_logs.py

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()