Untitled

import customtkinter as ctk
from PIL import Image, ImageTk

class ClassificationResultScreen(ctk.CTkToplevel):
    def __init__(self, parent, waste_type: str, dark_mode: bool, language='EN'):
        super().__init__(parent)
        
        # Constants for animation
        self.DISPLAY_TIME = 5  # seconds
        self.PROGRESS_HEIGHT = 6
        self.start_time = time.time()
        self._destroyed = False
        
        # Store parameters
        self.waste_type = waste_type
        self.dark_mode = dark_mode
        self.language = language
        
        # Make it fullscreen and disable all close operations
        self.overrideredirect(True)
        self.geometry(f"{self.winfo_screenwidth()}x{self.winfo_screenheight()}+0+0")
        self.protocol("WM_DELETE_WINDOW", lambda: None)
        self.attributes('-topmost', True)

        # Set colors based on waste type and dark mode
        self.bg_color = self._get_waste_color()
        self.text_color = self._get_text_color()
        self.configure(fg_color=self.bg_color)
        
        # Create progress bar frame at the top
        self.progress_frame = ctk.CTkFrame(
            self,
            height=self.PROGRESS_HEIGHT,
            fg_color='white' if self.text_color == 'black' else 'black',
            corner_radius=0
        )
        self.progress_frame.pack(fill='x', pady=0)
        
        # Create progress bar
        self.progress_bar = ctk.CTkFrame(
            self.progress_frame,
            height=self.PROGRESS_HEIGHT,
            fg_color='black' if self.text_color == 'grey' else 'grey',
            corner_radius=0
        )
        self.progress_bar.place(relx=0, rely=0, relwidth=1)
        
        # Create main container
        self.container = ctk.CTkFrame(
            self,
            fg_color=self.bg_color,
            corner_radius=0
        )
        self.container.pack(fill='both', expand=True)
        
        # Get translated waste type
        self.translated_waste_type = self._get_translated_waste_type()
        
        # Add the result text
        self.result_label = ctk.CTkLabel(
            self.container,
            text=self.translated_waste_type,
            font=('Dongle', 48, 'bold'),
            text_color=self.text_color
        )
        self.result_label.pack(pady=(80, 20))

        # Add icon
        try:
            icon_path = f"icons/{self._get_icon_name()}.png"
            icon_image = ctk.CTkImage(
                light_image=Image.open(icon_path),
                dark_image=Image.open(icon_path),
                size=(120, 120)
            )
            self.icon_label = ctk.CTkLabel(
                self.container,
                text="",
                image=icon_image
            )
            self.icon_label.pack(pady=20)
        except Exception as e:
            print(f"Error loading icon: {e}")

        self.bind("<Destroy>", self._on_destroy)
        self.update_progress()

    def _on_destroy(self, event):
        """Handle the window destruction event"""
        if event.widget is self:
            self._destroyed = True

    def _get_waste_color(self):
        """Get background color based on waste type and dark mode"""
        color_mapping = {
            'Paper': ('#0d7dd4', '#e6f3ff'),  # (dark mode, light mode)
            'Papier': ('#0d7dd4', '#e6f3ff'),
            'Recycling': ('#fec20c', '#fff3d6'),
            'Gelber Sack': ('#fec20c', '#fff3d6'),
            'Organic': ('#8a6849', '#e8d5c4'),
            'Biomüll': ('#8a6849', '#e8d5c4'),
            'Residual': ('#3a3a3c', '#cececf'),
            'Restmüll': ('#3a3a3c', '#cececf')
        }
        colors = color_mapping.get(self.waste_type, ('#3a3a3c', '#cececf'))
        return colors[0] if self.dark_mode else colors[1]

    def _get_text_color(self):
        """Determine text color based on background"""
        light_bg_types = ['Gelber Sack', 'Recycling']
        if self.waste_type in light_bg_types and self.dark_mode:
            return 'black'
        return 'white' if self.dark_mode else 'black'

    def _get_translated_waste_type(self):
        """Get waste type name in correct language"""
        return self.waste_type  # Simplified for testing

    def _get_icon_name(self):
        """Get icon filename based on waste type"""
        icon_mapping = {
            'Paper': 'paper',
            'Papier': 'paper',
            'Recycling': 'recycling',
            'Gelber Sack': 'recycling',
            'Organic': 'organic',
            'Biomüll': 'organic',
            'Residual': 'residual',
            'Restmüll': 'residual'
        }
        return icon_mapping.get(self.waste_type)

    def update_progress(self):
        """Update the progress bar and check if window should close"""
        if self._destroyed:
            return
            
        elapsed = time.time() - self.start_time
        remaining = max(0, 1 - (elapsed / self.DISPLAY_TIME))
        
        if remaining > 0:
            self.progress_bar.place_configure(relwidth=remaining)
            self.after(16, self.update_progress)
        else:
            if not self._destroyed:
                self.destroy()

# Test function to launch the screen
def test_classification_result():
    root = ctk.CTk()
    root.geometry("800x600")
    
    def show_result():
        # Get values from controls
        waste_type = waste_var.get()
        dark_mode = dark_mode_var.get()
        language = lang_var.get()
        
        ClassificationResultScreen(root, waste_type, dark_mode, language)
    
    # Create test controls
    controls_frame = ctk.CTkFrame(root)
    controls_frame.pack(pady=20)
    
    # Waste type selector
    waste_types = ['Paper', 'Recycling', 'Organic', 'Residual', 
                   'Papier', 'Gelber Sack', 'Biomüll', 'Restmüll']
    waste_var = ctk.StringVar(value=waste_types[0])
    waste_menu = ctk.CTkOptionMenu(controls_frame, variable=waste_var, values=waste_types)
    waste_menu.pack(pady=5)
    
    # Dark mode toggle
    dark_mode_var = ctk.BooleanVar(value=False)
    dark_mode_switch = ctk.CTkSwitch(controls_frame, text="Dark Mode", 
                                    variable=dark_mode_var)
    dark_mode_switch.pack(pady=5)
    
    # Language selector
    lang_var = ctk.StringVar(value='EN')
    lang_frame = ctk.CTkFrame(controls_frame)
    lang_frame.pack(pady=5)
    
    ctk.CTkRadioButton(lang_frame, text='EN', variable=lang_var, 
                       value='EN').pack(side='left', padx=5)
    ctk.CTkRadioButton(lang_frame, text='DE', variable=lang_var, 
                       value='DE').pack(side='left', padx=5)
    
    # Test button
    test_btn = ctk.CTkButton(controls_frame, text="Show Result Screen", 
                            command=show_result)
    test_btn.pack(pady=10)
    
    root.mainloop()

if __name__ == "__main__":
    test_classification_result()