Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-08-06· OpenAIAi2 WildChat-4.8M (AI2)

move the color config in the tableapp class because it is not needed outside the GUI.…

  1. User

    move the color config in the tableapp class because it is not needed outside the GUI. Python 3.12 code: import tkinter as tk from tkinter import simpledialog, messagebox from tksheet import Sheet import json from pathlib import Path import ctypes

    BACKGROUND_COLOR = '#FFFFFF' SIDEBAR_COLOR = '#F7F8FC' BUTTON_COLOR = '#F7F8FC' BUTTON_COLOR_SELECTED = '#EAEDEF' BUTTON_TEXT_COLOR = '#000000'

    def set_dpi_awareness(): """Enable DPI awareness for high DPI settings.""" try: ctypes.windll.shcore.SetProcessDpiAwareness(1) except Exception as e: print(f"Error setting DPI awareness: {e}")

    class TableApp: def init(self, root): """Initialize the Table Editor application.""" self.root = root self.root.title("Table Editor with Sidebar") self.root.geometry("1280x720")

        self.setup_ui()
        self.initialize_data()
        self.load_tables()
    
    def setup_ui(self):
        """Set up the user interface components."""
        self.create_sidebar()
        self.create_main_frame()
        self.create_header_frame()
        self.create_table_frame()
    
    def create_sidebar(self):
        """Create the sidebar and its components."""
        self.sidebar = tk.Frame(self.root, width=200, bg=SIDEBAR_COLOR, bd=0, relief='flat')
        self.sidebar.pack(expand=False, fill='y', side='left', anchor='nw')
    
        self.separator = tk.Frame(self.root, width=100, bg=BACKGROUND_COLOR, bd=0, relief='flat')
        self.separator.pack(expand=False, fill='y', side='left', anchor='nw')
    
        self.new_table_label = self.create_clickable_label(
            self.sidebar, "Create New Table", self.create_new_table)
        self.new_table_label.pack(padx=0, pady=10, fill='x')
    
        self.table_labels_frame = tk.Frame(self.sidebar, bg=SIDEBAR_COLOR)
        self.table_labels_frame.pack(expand=True, fill='both', padx=0, pady=10)
    
        self.add_custom_hover(self.new_table_label)
    
    def create_main_frame(self):
        """Create the main frame of the application."""
        self.main_frame = tk.Frame(self.root)
        self.main_frame.pack(expand=True, fill='both', side='right')
    
    def create_header_frame(self):
        """Create the header frame with filter and rename options."""
        self.header_frame = tk.Frame(self.main_frame, height=50, bg=BACKGROUND_COLOR)
        self.header_frame.pack(fill='x')
    
        self.filter_label = tk.Label(self.header_frame, text="Filter:", bg=BACKGROUND_COLOR, anchor="w")
        self.filter_label.pack(side='left', padx=5, pady=10)
    
        self.filter_entry = tk.Entry(self.header_frame)
        self.filter_entry.pack(side='left', padx=5, pady=10)
        self.filter_entry.bind("<KeyRelease>", lambda event: self.apply_filter())
    
        self.rename_headers_label = self.create_clickable_label(
            self.header_frame, "Rename Headers", self.rename_headers)
        self.rename_headers_label.pack(side='left', padx=5, pady=10, fill='x')
    
    def create_table_frame(self):
        """Create the frame to hold the table."""
        self.table_frame = tk.Frame(self.main_frame, bg=BACKGROUND_COLOR)
        self.table_frame.pack(expand=True, fill='both')
    
    def initialize_data(self):
        """Initialize data structures and variables."""
        self.save_file_dir = Path("tables")
        self.tables = {}
        self.table_labels = {}
        self.original_data = {}
        self.headers = {}
        self.current_table_name = None
        self.rename_entry = None
        self.selected_table_label = None
    
        self.save_file_dir.mkdir(exist_ok=True)
    
    def create_clickable_label(self, parent, text, command, allow_rename=True):
        """Create a clickable Label widget."""
        label = tk.Label(
            parent, text=text, bg=BUTTON_COLOR, fg=BUTTON_TEXT_COLOR,
            borderwidth=0, relief='flat', cursor='arrow', anchor='w',
            padx=10, pady=5
        )
        label.bind("<Button-1>", lambda e: command())
        if allow_rename:
            label.bind("<Double-1>", lambda e: self.begin_rename(text))
        return label
    
    def create_new_table(self):
        """Create a new table and add it to the available tables list."""
        table_name = f"Table {len(self.tables) + 1}"
        self.add_table(table_name)
        self.load_selected_table(table_name)
    
    def add_table(self, table_name, data=None):
        """Add a table to the UI and internal storage."""
        default_data = [["" for _ in range(5)] for _ in range(10)]
        self.tables[table_name] = Sheet(
            self.table_frame,
            data=data or default_data
        )
        self.tables[table_name].enable_bindings()
        self.tables[table_name].extra_bindings([
            ("end_edit_cell", lambda event, tn=table_name: self.save_data(tn)),
        ])
        self.tables[table_name].pack_forget()
        self.original_data[table_name] = self.tables[table_name].get_sheet_data()
        self.headers[table_name] = self.tables[table_name].headers()
    
        table_label = self.create_clickable_label(
            self.table_labels_frame, table_name,
            lambda name=table_name: self.load_selected_table(name)
        )
        table_label.pack(fill='x', pady=2)
        self.table_labels[table_name] = table_label
    
        self.add_custom_hover(table_label)
    
    def load_tables(self):
        """Load existing tables from the directory."""
        for file_path in self.save_file_dir.glob("*.json"):
            table_name = file_path.stem
            with file_path.open('r') as file:
                data = json.load(file)
                headers = data.pop(0)
                self.add_table(table_name, data)
                self.headers[table_name] = headers
    
    def load_selected_table(self, table_name):
        """Display the selected table and hide others."""
        for name, sheet in self.tables.items():
            if name == table_name:
                sheet.pack(expand=True, fill='both')
                self.current_table_name = table_name
                sheet.headers(self.headers[name])
                self.apply_filter()
    
                selected_label = self.table_labels[name]
                selected_label.config(bg=BUTTON_COLOR_SELECTED)
                self.selected_table_label = selected_label
            else:
                sheet.pack_forget()
                self.table_labels[name].config(bg=BUTTON_COLOR)
    
    def save_data(self, table_name):
        """Save current data of a table to a file."""
        data = [self.headers[table_name]] + self.tables[table_name].get_sheet_data()
        file_path = self.save_file_dir / f"{table_name}.json"
        with file_path.open('w') as file:
            json.dump(data, file)
        print(f"Data for {table_name} saved successfully.")
    
    def apply_filter(self):
        """Apply filtering based on the entered term."""
        if not self.current_table_name:
            return
    
        term = self.filter_entry.get().lower()
        original_data = self.original_data[self.current_table_name]
    
        filtered_data = [
            row for row in original_data 
            if any(term in str(cell).lower() for cell in row)
        ]
    
        self.tables[self.current_table_name].set_sheet_data(filtered_data)
    
    def rename_headers(self):
        """Prompt user to rename headers of the currently selected table."""
        if not self.current_table_name:
            messagebox.showwarning("No Table Selected", "Please select a table to rename headers.")
            return
    
        current_headers = self.headers[self.current_table_name]
        new_headers = simpledialog.askstring(
            "Rename Headers",
            "Enter new headers (comma-separated):",
            initialvalue=", ".join(current_headers)
        )
    
        if new_headers:
            header_list = [header.strip() for header in new_headers.split(',')]
            self.headers[self.current_table_name] = header_list
            self.tables[self.current_table_name].headers(header_list)
            self.save_data(self.current_table_name)
    
    def begin_rename(self, table_name):
        """Begin renaming of the table with a double click."""
        label = self.table_labels[table_name]
        
        if self.rename_entry:
            self.rename_entry.destroy()
        
        label.update_idletasks()
        label_x, label_y = label.winfo_x(), label.winfo_y()
        label_width, label_height = label.winfo_width(), label.winfo_height()
        
        self.rename_entry = tk.Entry(
            self.table_labels_frame,
            bg=label.cget("bg"),
            fg=BUTTON_TEXT_COLOR,
            font=label.cget("font"),
            relief='flat',
            borderwidth=0,
            highlightthickness=0,
            justify='left'
        )
        self.rename_entry.insert(0, table_name)
        
        self.rename_entry.place(x=label_x, y=label_y, width=label_width, height=label_height)
        self.rename_entry.focus()
        self.rename_entry.select_range(0, tk.END)
        
        self.rename_entry.bind('<Return>', lambda event: self.end_rename(table_name))
        self.rename_entry.bind('<FocusOut>', lambda event: self.cancel_rename())
    
    def end_rename(self, old_name):
        """Finish the renaming process for the specified table."""
        new_name = self.rename_entry.get().strip()
    
        if not new_name:
            messagebox.showerror("Invalid Name", "Table name cannot be empty.")
            self.rename_entry.focus_set()
            return
    
        if new_name in self.tables and new_name != old_name:
            messagebox.showerror("Duplicate Name", f"A table named '{new_name}' already exists.")
            self.rename_entry.focus_set()
            return
    
        if new_name != old_name:
            self.tables[new_name] = self.tables.pop(old_name)
            self.original_data[new_name] = self.original_data.pop(old_name)
            self.headers[new_name] = self.headers.pop(old_name)
    
            self.table_labels[new_name] = self.table_labels.pop(old_name)
            self.table_labels[new_name].config(text=new_name)
    
            if self.selected_table_label == self.table_labels[new_name]:
                self.selected_table_label = self.table_labels[new_name]
                self.table_labels[new_name].config(bg=BUTTON_COLOR_SELECTED)
    
            current_file = self.save_file_dir / f"{old_name}.json"
            new_file = self.save_file_dir / f"{new_name}.json"
    
            if current_file.exists():
                current_file.rename(new_file)
    
        self.cancel_rename()
    
    def cancel_rename(self):
        """Cancel the renaming entry."""
        if self.rename_entry:
            self.rename_entry.destroy()
            self.rename_entry = None
    
    def add_custom_hover(self, label):
        """Add custom hover effects to a label."""
        def on_enter(e):
            if label != self.selected_table_label:
                label.config(bg=BUTTON_COLOR_SELECTED)
    
        def on_leave(e):
            if label != self.selected_table_label:
                label.config(bg=BUTTON_COLOR)
    
        label.bind("<Enter>", on_enter)
        label.bind("<Leave>", on_leave)
    

    if name == "main": set_dpi_awareness() root = tk.Tk() app = TableApp(root) root.mainloop()

  2. Assistant

    To encapsulate the color configuration within the TableApp class, we can move the color constants as attributes of the class. This keeps them hidden from global scope and better organized, as they're relevant only within the context of the GUI. Here's how you can modify your code:

    import tkinter as tk
    from tkinter import simpledialog, messagebox
    from tksheet import Sheet
    import json
    from pathlib import Path
    import ctypes
    
    def set_dpi_awareness():
        """Enable DPI awareness for high DPI settings."""
        try:
            ctypes.windll.shcore.SetProcessDpiAwareness(1)
        except Exception as e:
            print(f"Error setting DPI awareness: {e}")
    
    class TableApp:
        def __init__(self, root):
            """Initialize the Table Editor application."""
            self.root = root
            self.root.title("Table Editor with Sidebar")
            self.root.geometry("1280x720")
    
            # Color configurations
            self.BACKGROUND_COLOR = '#FFFFFF'
            self.SIDEBAR_COLOR = '#F7F8FC'
            self.BUTTON_COLOR = '#F7F8FC'
            self.BUTTON_COLOR_SELECTED = '#EAEDEF'
            self.BUTTON_TEXT_COLOR = '#000000'
    
            self.setup_ui()
            self.initialize_data()
            self.load_tables()
    
        def setup_ui(self):
            """Set up the user interface components."""
            self.create_sidebar()
            self.create_main_frame()
            self.create_header_frame()
            self.create_table_frame()
    
        def create_sidebar(self):
            """Create the sidebar and its components."""
            self.sidebar = tk.Frame(self.root, width=200, bg=self.SIDEBAR_COLOR, bd=0, relief='flat')
            self.sidebar.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.separator = tk.Frame(self.root, width=100, bg=self.BACKGROUND_COLOR, bd=0, relief='flat')
            self.separator.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.new_table_label = self.create_clickable_label(
                self.sidebar, "Create New Table", self.create_new_table)
            self.new_table_label.pack(padx=0, pady=10, fill='x')
    
            self.table_labels_frame = tk.Frame(self.sidebar, bg=self.SIDEBAR_COLOR)
            self.table_labels_frame.pack(expand=True, fill='both', padx=0, pady=10)
    
            self.add_custom_hover(self.new_table_label)
    
        def create_main_frame(self):
            """Create the main frame of the application."""
            self.main_frame = tk.Frame(self.root)
            self.main_frame.pack(expand=True, fill='both', side='right')
    
        def create_header_frame(self):
            """Create the header frame with filter and rename options."""
            self.header_frame = tk.Frame(self.main_frame, height=50, bg=self.BACKGROUND_COLOR)
            self.header_frame.pack(fill='x')
    
            self.filter_label = tk.Label(self.header_frame, text="Filter:", bg=self.BACKGROUND_COLOR, anchor="w")
            self.filter_label.pack(side='left', padx=5, pady=10)
    
            self.filter_entry = tk.Entry(self.header_frame)
            self.filter_entry.pack(side='left', padx=5, pady=10)
            self.filter_entry.bind("<KeyRelease>", lambda event: self.apply_filter())
    
            self.rename_headers_label = self.create_clickable_label(
                self.header_frame, "Rename Headers", self.rename_headers)
            self.rename_headers_label.pack(side='left', padx=5, pady=10, fill='x')
    
        def create_table_frame(self):
            """Create the frame to hold the table."""
            self.table_frame = tk.Frame(self.main_frame, bg=self.BACKGROUND_COLOR)
            self.table_frame.pack(expand=True, fill='both')
    
        def initialize_data(self):
            """Initialize data structures and variables."""
            self.save_file_dir = Path("tables")
            self.tables = {}
            self.table_labels = {}
            self.original_data = {}
            self.headers = {}
            self.current_table_name = None
            self.rename_entry = None
            self.selected_table_label = None
    
            self.save_file_dir.mkdir(exist_ok=True)
    
        def create_clickable_label(self, parent, text, command, allow_rename=True):
            """Create a clickable Label widget."""
            label = tk.Label(
                parent, text=text, bg=self.BUTTON_COLOR, fg=self.BUTTON_TEXT_COLOR,
                borderwidth=0, relief='flat', cursor='arrow', anchor='w',
                padx=10, pady=5
            )
            label.bind("<Button-1>", lambda e: command())
            if allow_rename:
                label.bind("<Double-1>", lambda e: self.begin_rename(text))
            return label
    
        def create_new_table(self):
            """Create a new table and add it to the available tables list."""
            table_name = f"Table {len(self.tables) + 1}"
            self.add_table(table_name)
            self.load_selected_table(table_name)
    
        def add_table(self, table_name, data=None):
            """Add a table to the UI and internal storage."""
            default_data = [["" for _ in range(5)] for _ in range(10)]
            self.tables[table_name] = Sheet(
                self.table_frame,
                data=data or default_data
            )
            self.tables[table_name].enable_bindings()
            self.tables[table_name].extra_bindings([
                ("end_edit_cell", lambda event, tn=table_name: self.save_data(tn)),
            ])
            self.tables[table_name].pack_forget()
            self.original_data[table_name] = self.tables[table_name].get_sheet_data()
            self.headers[table_name] = self.tables[table_name].headers()
    
            table_label = self.create_clickable_label(
                self.table_labels_frame, table_name,
                lambda name=table_name: self.load_selected_table(name)
            )
            table_label.pack(fill='x', pady=2)
            self.table_labels[table_name] = table_label
    
            self.add_custom_hover(table_label)
    
        def load_tables(self):
            """Load existing tables from the directory."""
            for file_path in self.save_file_dir.glob("*.json"):
                table_name = file_path.stem
                with file_path.open('r') as file:
                    data = json.load(file)
                    headers = data.pop(0)
                    self.add_table(table_name, data)
                    self.headers[table_name] = headers
    
        def load_selected_table(self, table_name):
            """Display the selected table and hide others."""
            for name, sheet in self.tables.items():
                if name == table_name:
                    sheet.pack(expand=True, fill='both')
                    self.current_table_name = table_name
                    sheet.headers(self.headers[name])
                    self.apply_filter()
    
                    selected_label = self.table_labels[name]
                    selected_label.config(bg=self.BUTTON_COLOR_SELECTED)
                    self.selected_table_label = selected_label
                else:
                    sheet.pack_forget()
                    self.table_labels[name].config(bg=self.BUTTON_COLOR)
    
        def save_data(self, table_name):
            """Save current data of a table to a file."""
            data = [self.headers[table_name]] + self.tables[table_name].get_sheet_data()
            file_path = self.save_file_dir / f"{table_name}.json"
            with file_path.open('w') as file:
                json.dump(data, file)
            print(f"Data for {table_name} saved successfully.")
    
        def apply_filter(self):
            """Apply filtering based on the entered term."""
            if not self.current_table_name:
                return
    
            term = self.filter_entry.get().lower()
            original_data = self.original_data[self.current_table_name]
    
            filtered_data = [
                row for row in original_data
                if any(term in str(cell).lower() for cell in row)
            ]
    
            self.tables[self.current_table_name].set_sheet_data(filtered_data)
    
        def rename_headers(self):
            """Prompt user to rename headers of the currently selected table."""
            if not self.current_table_name:
                messagebox.showwarning("No Table Selected", "Please select a table to rename headers.")
                return
    
            current_headers = self.headers[self.current_table_name]
            new_headers = simpledialog.askstring(
                "Rename Headers",
                "Enter new headers (comma-separated):",
                initialvalue=", ".join(current_headers)
            )
    
            if new_headers:
                header_list = [header.strip() for header in new_headers.split(',')]
                self.headers[self.current_table_name] = header_list
                self.tables[self.current_table_name].headers(header_list)
                self.save_data(self.current_table_name)
    
        def begin_rename(self, table_name):
            """Begin renaming of the table with a double click."""
            label = self.table_labels[table_name]
            
            if self.rename_entry:
                self.rename_entry.destroy()
            
            label.update_idletasks()
            label_x, label_y = label.winfo_x(), label.winfo_y()
            label_width, label_height = label.winfo_width(), label.winfo_height()
            
            self.rename_entry = tk.Entry(
                self.table_labels_frame,
                bg=label.cget("bg"),
                fg=self.BUTTON_TEXT_COLOR,
                font=label.cget("font"),
                relief='flat',
                borderwidth=0,
                highlightthickness=0,
                justify='left'
            )
            self.rename_entry.insert(0, table_name)
            
            self.rename_entry.place(x=label_x, y=label_y, width=label_width, height=label_height)
            self.rename_entry.focus()
            self.rename_entry.select_range(0, tk.END)
            
            self.rename_entry.bind('<Return>', lambda event: self.end_rename(table_name))
            self.rename_entry.bind('<FocusOut>', lambda event: self.cancel_rename())
    
        def end_rename(self, old_name):
            """Finish the renaming process for the specified table."""
            new_name = self.rename_entry.get().strip()
    
            if not new_name:
                messagebox.showerror("Invalid Name", "Table name cannot be empty.")
                self.rename_entry.focus_set()
                return
    
            if new_name in self.tables and new_name != old_name:
                messagebox.showerror("Duplicate Name", f"A table named '{new_name}' already exists.")
                self.rename_entry.focus_set()
                return
    
            if new_name != old_name:
                self.tables[new_name] = self.tables.pop(old_name)
                self.original_data[new_name] = self.original_data.pop(old_name)
                self.headers[new_name] = self.headers.pop(old_name)
    
                self.table_labels[new_name] = self.table_labels.pop(old_name)
                self.table_labels[new_name].config(text=new_name)
    
                if self.selected_table_label == self.table_labels[new_name]:
                    self.selected_table_label = self.table_labels[new_name]
                    self.table_labels[new_name].config(bg=self.BUTTON_COLOR_SELECTED)
    
                current_file = self.save_file_dir / f"{old_name}.json"
                new_file = self.save_file_dir / f"{new_name}.json"
    
                if current_file.exists():
                    current_file.rename(new_file)
    
            self.cancel_rename()
    
        def cancel_rename(self):
            """Cancel the renaming entry."""
            if self.rename_entry:
                self.rename_entry.destroy()
                self.rename_entry = None
    
        def add_custom_hover(self, label):
            """Add custom hover effects to a label."""
            def on_enter(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR_SELECTED)
    
            def on_leave(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR)
    
            label.bind("<Enter>", on_enter)
            label.bind("<Leave>", on_leave)
    
    if __name__ == "__main__":
        set_dpi_awareness()
        root = tk.Tk()
        app = TableApp(root)
        root.mainloop()
    

    Now all color settings are encapsulated within the TableApp class, making it more modular. The references to those color constants throughout the methods have been updated to use self.{COLOR_NAME}.

  3. User

    add an option to inport csv or json files in a new table

  4. Assistant

    To add the capability to import CSV or JSON files as new tables within your application, you can leverage the tkinter.filedialog module to prompt the user to select files, and then parse those files accordingly. Below is an approach to integrate this functionality into your existing TableApp class:

    import tkinter as tk
    from tkinter import simpledialog, messagebox, filedialog
    from tksheet import Sheet
    import json
    import csv
    from pathlib import Path
    import ctypes
    
    def set_dpi_awareness():
        """Enable DPI awareness for high DPI settings."""
        try:
            ctypes.windll.shcore.SetProcessDpiAwareness(1)
        except Exception as e:
            print(f"Error setting DPI awareness: {e}")
    
    class TableApp:
        def __init__(self, root):
            """Initialize the Table Editor application."""
            self.root = root
            self.root.title("Table Editor with Sidebar")
            self.root.geometry("1280x720")
    
            # Color configurations
            self.BACKGROUND_COLOR = '#FFFFFF'
            self.SIDEBAR_COLOR = '#F7F8FC'
            self.BUTTON_COLOR = '#F7F8FC'
            self.BUTTON_COLOR_SELECTED = '#EAEDEF'
            self.BUTTON_TEXT_COLOR = '#000000'
    
            self.setup_ui()
            self.initialize_data()
            self.load_tables()
    
        def setup_ui(self):
            """Set up the user interface components."""
            self.create_sidebar()
            self.create_main_frame()
            self.create_header_frame()
            self.create_table_frame()
    
        def create_sidebar(self):
            """Create the sidebar and its components."""
            self.sidebar = tk.Frame(self.root, width=200, bg=self.SIDEBAR_COLOR, bd=0, relief='flat')
            self.sidebar.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.separator = tk.Frame(self.root, width=100, bg=self.BACKGROUND_COLOR, bd=0, relief='flat')
            self.separator.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.new_table_label = self.create_clickable_label(
                self.sidebar, "Create New Table", self.create_new_table)
            self.new_table_label.pack(padx=0, pady=10, fill='x')
    
            self.import_table_label = self.create_clickable_label(
                self.sidebar, "Import Table", self.import_file)
            self.import_table_label.pack(padx=0, pady=10, fill='x')
    
            self.table_labels_frame = tk.Frame(self.sidebar, bg=self.SIDEBAR_COLOR)
            self.table_labels_frame.pack(expand=True, fill='both', padx=0, pady=10)
    
            self.add_custom_hover(self.new_table_label)
            self.add_custom_hover(self.import_table_label)
    
        def create_main_frame(self):
            """Create the main frame of the application."""
            self.main_frame = tk.Frame(self.root)
            self.main_frame.pack(expand=True, fill='both', side='right')
    
        def create_header_frame(self):
            """Create the header frame with filter and rename options."""
            self.header_frame = tk.Frame(self.main_frame, height=50, bg=self.BACKGROUND_COLOR)
            self.header_frame.pack(fill='x')
    
            self.filter_label = tk.Label(self.header_frame, text="Filter:", bg=self.BACKGROUND_COLOR, anchor="w")
            self.filter_label.pack(side='left', padx=5, pady=10)
    
            self.filter_entry = tk.Entry(self.header_frame)
            self.filter_entry.pack(side='left', padx=5, pady=10)
            self.filter_entry.bind("<KeyRelease>", lambda event: self.apply_filter())
    
            self.rename_headers_label = self.create_clickable_label(
                self.header_frame, "Rename Headers", self.rename_headers)
            self.rename_headers_label.pack(side='left', padx=5, pady=10, fill='x')
    
        def create_table_frame(self):
            """Create the frame to hold the table."""
            self.table_frame = tk.Frame(self.main_frame, bg=self.BACKGROUND_COLOR)
            self.table_frame.pack(expand=True, fill='both')
    
        def initialize_data(self):
            """Initialize data structures and variables."""
            self.save_file_dir = Path("tables")
            self.tables = {}
            self.table_labels = {}
            self.original_data = {}
            self.headers = {}
            self.current_table_name = None
            self.rename_entry = None
            self.selected_table_label = None
    
            self.save_file_dir.mkdir(exist_ok=True)
    
        def create_clickable_label(self, parent, text, command, allow_rename=True):
            """Create a clickable Label widget."""
            label = tk.Label(
                parent, text=text, bg=self.BUTTON_COLOR, fg=self.BUTTON_TEXT_COLOR,
                borderwidth=0, relief='flat', cursor='arrow', anchor='w',
                padx=10, pady=5
            )
            label.bind("<Button-1>", lambda e: command())
            if allow_rename:
                label.bind("<Double-1>", lambda e: self.begin_rename(text))
            return label
    
        def create_new_table(self):
            """Create a new table and add it to the available tables list."""
            table_name = f"Table {len(self.tables) + 1}"
            self.add_table(table_name)
            self.load_selected_table(table_name)
    
        def import_file(self):
            """Import a CSV or JSON file to create a new table."""
            file_path = filedialog.askopenfilename(
                title="Open File",
                filetypes=[("CSV files", "*.csv"), ("JSON files", "*.json")]
            )
            if not file_path:
                return
    
            if file_path.endswith('.csv'):
                with open(file_path, newline='', encoding='utf-8') as csvfile:
                    reader = csv.reader(csvfile)
                    data = list(reader)
                headers, table_data = data[0], data[1:]
    
            elif file_path.endswith('.json'):
                with open(file_path, 'r', encoding='utf-8') as jsonfile:
                    data = json.load(jsonfile)
                headers, table_data = data[0], data[1:]
    
            else:
                messagebox.showerror("Unsupported File", "The selected file format is not supported.")
                return
    
            table_name = Path(file_path).stem
            self.add_table(table_name, table_data)
            self.headers[table_name] = headers
            self.load_selected_table(table_name)
    
        def add_table(self, table_name, data=None):
            """Add a table to the UI and internal storage."""
            default_data = [["" for _ in range(5)] for _ in range(10)]
            self.tables[table_name] = Sheet(
                self.table_frame,
                data=data or default_data
            )
            self.tables[table_name].enable_bindings()
            self.tables[table_name].extra_bindings([
                ("end_edit_cell", lambda event, tn=table_name: self.save_data(tn)),
            ])
            self.tables[table_name].pack_forget()
            self.original_data[table_name] = self.tables[table_name].get_sheet_data()
    
            if table_name not in self.headers:
                self.headers[table_name] = self.tables[table_name].headers()
    
            table_label = self.create_clickable_label(
                self.table_labels_frame, table_name,
                lambda name=table_name: self.load_selected_table(name)
            )
            table_label.pack(fill='x', pady=2)
            self.table_labels[table_name] = table_label
    
            self.add_custom_hover(table_label)
    
        def load_tables(self):
            """Load existing tables from the directory."""
            for file_path in self.save_file_dir.glob("*.json"):
                table_name = file_path.stem
                with file_path.open('r') as file:
                    data = json.load(file)
                    headers = data.pop(0)
                    self.add_table(table_name, data)
                    self.headers[table_name] = headers
    
        def load_selected_table(self, table_name):
            """Display the selected table and hide others."""
            for name, sheet in self.tables.items():
                if name == table_name:
                    sheet.pack(expand=True, fill='both')
                    self.current_table_name = table_name
                    sheet.headers(self.headers[name])
                    self.apply_filter()
    
                    selected_label = self.table_labels[name]
                    selected_label.config(bg=self.BUTTON_COLOR_SELECTED)
                    self.selected_table_label = selected_label
                else:
                    sheet.pack_forget()
                    self.table_labels[name].config(bg=self.BUTTON_COLOR)
    
        def save_data(self, table_name):
            """Save current data of a table to a file."""
            data = [self.headers[table_name]] + self.tables[table_name].get_sheet_data()
            file_path = self.save_file_dir / f"{table_name}.json"
            with file_path.open('w') as file:
                json.dump(data, file)
            print(f"Data for {table_name} saved successfully.")
    
        def apply_filter(self):
            """Apply filtering based on the entered term."""
            if not self.current_table_name:
                return
    
            term = self.filter_entry.get().lower()
            original_data = self.original_data[self.current_table_name]
    
            filtered_data = [
                row for row in original_data
                if any(term in str(cell).lower() for cell in row)
            ]
    
            self.tables[self.current_table_name].set_sheet_data(filtered_data)
    
        def rename_headers(self):
            """Prompt user to rename headers of the currently selected table."""
            if not self.current_table_name:
                messagebox.showwarning("No Table Selected", "Please select a table to rename headers.")
                return
    
            current_headers = self.headers[self.current_table_name]
            new_headers = simpledialog.askstring(
                "Rename Headers",
                "Enter new headers (comma-separated):",
                initialvalue=", ".join(current_headers)
            )
    
            if new_headers:
                header_list = [header.strip() for header in new_headers.split(',')]
                self.headers[self.current_table_name] = header_list
                self.tables[self.current_table_name].headers(header_list)
                self.save_data(self.current_table_name)
    
        def begin_rename(self, table_name):
            """Begin renaming of the table with a double click."""
            label = self.table_labels[table_name]
            
            if self.rename_entry:
                self.rename_entry.destroy()
            
            label.update_idletasks()
            label_x, label_y = label.winfo_x(), label.winfo_y()
            label_width, label_height = label.winfo_width(), label.winfo_height()
            
            self.rename_entry = tk.Entry(
                self.table_labels_frame,
                bg=label.cget("bg"),
                fg=self.BUTTON_TEXT_COLOR,
                font=label.cget("font"),
                relief='flat',
                borderwidth=0,
                highlightthickness=0,
                justify='left'
            )
            self.rename_entry.insert(0, table_name)
            
            self.rename_entry.place(x=label_x, y=label_y, width=label_width, height=label_height)
            self.rename_entry.focus()
            self.rename_entry.select_range(0, tk.END)
            
            self.rename_entry.bind('<Return>', lambda event: self.end_rename(table_name))
            self.rename_entry.bind('<FocusOut>', lambda event: self.cancel_rename())
    
        def end_rename(self, old_name):
            """Finish the renaming process for the specified table."""
            new_name = self.rename_entry.get().strip()
    
            if not new_name:
                messagebox.showerror("Invalid Name", "Table name cannot be empty.")
                self.rename_entry.focus_set()
                return
    
            if new_name in self.tables and new_name != old_name:
                messagebox.showerror("Duplicate Name", f"A table named '{new_name}' already exists.")
                self.rename_entry.focus_set()
                return
    
            if new_name != old_name:
                self.tables[new_name] = self.tables.pop(old_name)
                self.original_data[new_name] = self.original_data.pop(old_name)
                self.headers[new_name] = self.headers.pop(old_name)
    
                self.table_labels[new_name] = self.table_labels.pop(old_name)
                self.table_labels[new_name].config(text=new_name)
    
                if self.selected_table_label == self.table_labels[new_name]:
                    self.selected_table_label = self.table_labels[new_name]
                    self.table_labels[new_name].config(bg=self.BUTTON_COLOR_SELECTED)
    
                current_file = self.save_file_dir / f"{old_name}.json"
                new_file = self.save_file_dir / f"{new_name}.json"
    
                if current_file.exists():
                    current_file.rename(new_file)
    
            self.cancel_rename()
    
        def cancel_rename(self):
            """Cancel the renaming entry."""
            if self.rename_entry:
                self.rename_entry.destroy()
                self.rename_entry = None
    
        def add_custom_hover(self, label):
            """Add custom hover effects to a label."""
            def on_enter(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR_SELECTED)
    
            def on_leave(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR)
    
            label.bind("<Enter>", on_enter)
            label.bind("<Leave>", on_leave)
    
    if __name__ == "__main__":
        set_dpi_awareness()
        root = tk.Tk()
        app = TableApp(root)
        root.mainloop()
    

    Key Additions

    1. File Dialog: Added tkinter.filedialog to prompt users to select either a CSV or JSON file.
    2. File Parsing:
      • CSV: Utilized Python's csv module to read CSV files.
      • JSON: Used the json module to load JSON files.
    3. User Interface: Introduced a new label in the sidebar for importing tables.

    With these modifications, users can import tables directly from CSV or JSON files, supplementing the functionality of your application.

  5. User

    Add an option to delete tables at the bottom of the sidebar

  6. Assistant

    To add an option for deleting tables, we can create a button at the bottom of the sidebar. This button will trigger a function to delete the currently selected table. Here's how you can implement this feature into your existing TableApp class:

    import tkinter as tk
    from tkinter import simpledialog, messagebox, filedialog
    from tksheet import Sheet
    import json
    import csv
    from pathlib import Path
    import ctypes
    
    def set_dpi_awareness():
        """Enable DPI awareness for high DPI settings."""
        try:
            ctypes.windll.shcore.SetProcessDpiAwareness(1)
        except Exception as e:
            print(f"Error setting DPI awareness: {e}")
    
    class TableApp:
        def __init__(self, root):
            """Initialize the Table Editor application."""
            self.root = root
            self.root.title("Table Editor with Sidebar")
            self.root.geometry("1280x720")
    
            # Color configurations
            self.BACKGROUND_COLOR = '#FFFFFF'
            self.SIDEBAR_COLOR = '#F7F8FC'
            self.BUTTON_COLOR = '#F7F8FC'
            self.BUTTON_COLOR_SELECTED = '#EAEDEF'
            self.BUTTON_TEXT_COLOR = '#000000'
    
            self.setup_ui()
            self.initialize_data()
            self.load_tables()
    
        def setup_ui(self):
            """Set up the user interface components."""
            self.create_sidebar()
            self.create_main_frame()
            self.create_header_frame()
            self.create_table_frame()
    
        def create_sidebar(self):
            """Create the sidebar and its components."""
            self.sidebar = tk.Frame(self.root, width=200, bg=self.SIDEBAR_COLOR, bd=0, relief='flat')
            self.sidebar.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.separator = tk.Frame(self.root, width=100, bg=self.BACKGROUND_COLOR, bd=0, relief='flat')
            self.separator.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.new_table_label = self.create_clickable_label(
                self.sidebar, "Create New Table", self.create_new_table)
            self.new_table_label.pack(padx=0, pady=10, fill='x')
    
            self.import_table_label = self.create_clickable_label(
                self.sidebar, "Import Table", self.import_file)
            self.import_table_label.pack(padx=0, pady=10, fill='x')
    
            self.table_labels_frame = tk.Frame(self.sidebar, bg=self.SIDEBAR_COLOR)
            self.table_labels_frame.pack(expand=True, fill='both', padx=0, pady=10)
    
            self.delete_table_button = tk.Button(
                self.sidebar,
                text="Delete Selected Table",
                command=self.delete_table,
                bg=self.BUTTON_COLOR,
                fg=self.BUTTON_TEXT_COLOR
            )
            self.delete_table_button.pack(side='bottom', padx=10, pady=10, fill='x')
    
            self.add_custom_hover(self.new_table_label)
            self.add_custom_hover(self.import_table_label)
    
        def create_main_frame(self):
            """Create the main frame of the application."""
            self.main_frame = tk.Frame(self.root)
            self.main_frame.pack(expand=True, fill='both', side='right')
    
        def create_header_frame(self):
            """Create the header frame with filter and rename options."""
            self.header_frame = tk.Frame(self.main_frame, height=50, bg=self.BACKGROUND_COLOR)
            self.header_frame.pack(fill='x')
    
            self.filter_label = tk.Label(self.header_frame, text="Filter:", bg=self.BACKGROUND_COLOR, anchor="w")
            self.filter_label.pack(side='left', padx=5, pady=10)
    
            self.filter_entry = tk.Entry(self.header_frame)
            self.filter_entry.pack(side='left', padx=5, pady=10)
            self.filter_entry.bind("<KeyRelease>", lambda event: self.apply_filter())
    
            self.rename_headers_label = self.create_clickable_label(
                self.header_frame, "Rename Headers", self.rename_headers)
            self.rename_headers_label.pack(side='left', padx=5, pady=10, fill='x')
    
        def create_table_frame(self):
            """Create the frame to hold the table."""
            self.table_frame = tk.Frame(self.main_frame, bg=self.BACKGROUND_COLOR)
            self.table_frame.pack(expand=True, fill='both')
    
        def initialize_data(self):
            """Initialize data structures and variables."""
            self.save_file_dir = Path("tables")
            self.tables = {}
            self.table_labels = {}
            self.original_data = {}
            self.headers = {}
            self.current_table_name = None
            self.rename_entry = None
            self.selected_table_label = None
    
            self.save_file_dir.mkdir(exist_ok=True)
    
        def create_clickable_label(self, parent, text, command, allow_rename=True):
            """Create a clickable Label widget."""
            label = tk.Label(
                parent, text=text, bg=self.BUTTON_COLOR, fg=self.BUTTON_TEXT_COLOR,
                borderwidth=0, relief='flat', cursor='arrow', anchor='w',
                padx=10, pady=5
            )
            label.bind("<Button-1>", lambda e: command())
            if allow_rename:
                label.bind("<Double-1>", lambda e: self.begin_rename(text))
            return label
    
        def create_new_table(self):
            """Create a new table and add it to the available tables list."""
            table_name = f"Table {len(self.tables) + 1}"
            self.add_table(table_name)
            self.load_selected_table(table_name)
    
        def import_file(self):
            """Import a CSV or JSON file to create a new table."""
            file_path = filedialog.askopenfilename(
                title="Open File",
                filetypes=[("CSV files", "*.csv"), ("JSON files", "*.json")]
            )
            if not file_path:
                return
    
            if file_path.endswith('.csv'):
                with open(file_path, newline='', encoding='utf-8') as csvfile:
                    reader = csv.reader(csvfile)
                    data = list(reader)
                headers, table_data = data[0], data[1:]
    
            elif file_path.endswith('.json'):
                with open(file_path, 'r', encoding='utf-8') as jsonfile:
                    data = json.load(jsonfile)
                headers, table_data = data[0], data[1:]
    
            else:
                messagebox.showerror("Unsupported File", "The selected file format is not supported.")
                return
    
            table_name = Path(file_path).stem
            self.add_table(table_name, table_data)
            self.headers[table_name] = headers
            self.load_selected_table(table_name)
    
        def add_table(self, table_name, data=None):
            """Add a table to the UI and internal storage."""
            default_data = [["" for _ in range(5)] for _ in range(10)]
            self.tables[table_name] = Sheet(
                self.table_frame,
                data=data or default_data
            )
            self.tables[table_name].enable_bindings()
            self.tables[table_name].extra_bindings([
                ("end_edit_cell", lambda event, tn=table_name: self.save_data(tn)),
            ])
            self.tables[table_name].pack_forget()
            self.original_data[table_name] = self.tables[table_name].get_sheet_data()
    
            if table_name not in self.headers:
                self.headers[table_name] = self.tables[table_name].headers()
    
            table_label = self.create_clickable_label(
                self.table_labels_frame, table_name,
                lambda name=table_name: self.load_selected_table(name)
            )
            table_label.pack(fill='x', pady=2)
            self.table_labels[table_name] = table_label
    
            self.add_custom_hover(table_label)
    
        def delete_table(self):
            """Delete the currently selected table."""
            if not self.current_table_name:
                messagebox.showwarning("No Table Selected", "Please select a table to delete.")
                return
    
            response = messagebox.askyesno(
                "Delete Table",
                f"Are you sure you want to delete the table '{self.current_table_name}'?"
            )
            if response:
                # Remove from the UI
                self.tables[self.current_table_name].destroy()
                self.table_labels[self.current_table_name].destroy()
    
                # Remove from internal storage
                del self.tables[self.current_table_name]
                del self.original_data[self.current_table_name]
                del self.headers[self.current_table_name]
                del self.table_labels[self.current_table_name]
    
                # Remove from disk
                file_path = self.save_file_dir / f"{self.current_table_name}.json"
                if file_path.exists():
                    file_path.unlink()
    
                # Reset current table selection
                self.current_table_name = None
                self.selected_table_label = None
    
        def load_tables(self):
            """Load existing tables from the directory."""
            for file_path in self.save_file_dir.glob("*.json"):
                table_name = file_path.stem
                with file_path.open('r') as file:
                    data = json.load(file)
                    headers = data.pop(0)
                    self.add_table(table_name, data)
                    self.headers[table_name] = headers
    
        def load_selected_table(self, table_name):
            """Display the selected table and hide others."""
            for name, sheet in self.tables.items():
                if name == table_name:
                    sheet.pack(expand=True, fill='both')
                    self.current_table_name = table_name
                    sheet.headers(self.headers[name])
                    self.apply_filter()
    
                    selected_label = self.table_labels[name]
                    selected_label.config(bg=self.BUTTON_COLOR_SELECTED)
                    self.selected_table_label = selected_label
                else:
                    sheet.pack_forget()
                    self.table_labels[name].config(bg=self.BUTTON_COLOR)
    
        def save_data(self, table_name):
            """Save current data of a table to a file."""
            data = [self.headers[table_name]] + self.tables[table_name].get_sheet_data()
            file_path = self.save_file_dir / f"{table_name}.json"
            with file_path.open('w') as file:
                json.dump(data, file)
            print(f"Data for {table_name} saved successfully.")
    
        def apply_filter(self):
            """Apply filtering based on the entered term."""
            if not self.current_table_name:
                return
    
            term = self.filter_entry.get().lower()
            original_data = self.original_data[self.current_table_name]
    
            filtered_data = [
                row for row in original_data
                if any(term in str(cell).lower() for cell in row)
            ]
    
            self.tables[self.current_table_name].set_sheet_data(filtered_data)
    
        def rename_headers(self):
            """Prompt user to rename headers of the currently selected table."""
            if not self.current_table_name:
                messagebox.showwarning("No Table Selected", "Please select a table to rename headers.")
                return
    
            current_headers = self.headers[self.current_table_name]
            new_headers = simpledialog.askstring(
                "Rename Headers",
                "Enter new headers (comma-separated):",
                initialvalue=", ".join(current_headers)
            )
    
            if new_headers:
                header_list = [header.strip() for header in new_headers.split(',')]
                self.headers[self.current_table_name] = header_list
                self.tables[self.current_table_name].headers(header_list)
                self.save_data(self.current_table_name)
    
        def begin_rename(self, table_name):
            """Begin renaming of the table with a double click."""
            label = self.table_labels[table_name]
            
            if self.rename_entry:
                self.rename_entry.destroy()
            
            label.update_idletasks()
            label_x, label_y = label.winfo_x(), label.winfo_y()
            label_width, label_height = label.winfo_width(), label.winfo_height()
            
            self.rename_entry = tk.Entry(
                self.table_labels_frame,
                bg=label.cget("bg"),
                fg=self.BUTTON_TEXT_COLOR,
                font=label.cget("font"),
                relief='flat',
                borderwidth=0,
                highlightthickness=0,
                justify='left'
            )
            self.rename_entry.insert(0, table_name)
            
            self.rename_entry.place(x=label_x, y=label_y, width=label_width, height=label_height)
            self.rename_entry.focus()
            self.rename_entry.select_range(0, tk.END)
            
            self.rename_entry.bind('<Return>', lambda event: self.end_rename(table_name))
            self.rename_entry.bind('<FocusOut>', lambda event: self.cancel_rename())
    
        def end_rename(self, old_name):
            """Finish the renaming process for the specified table."""
            new_name = self.rename_entry.get().strip()
    
            if not new_name:
                messagebox.showerror("Invalid Name", "Table name cannot be empty.")
                self.rename_entry.focus_set()
                return
    
            if new_name in self.tables and new_name != old_name:
                messagebox.showerror("Duplicate Name", f"A table named '{new_name}' already exists.")
                self.rename_entry.focus_set()
                return
    
            if new_name != old_name:
                self.tables[new_name] = self.tables.pop(old_name)
                self.original_data[new_name] = self.original_data.pop(old_name)
                self.headers[new_name] = self.headers.pop(old_name)
    
                self.table_labels[new_name] = self.table_labels.pop(old_name)
                self.table_labels[new_name].config(text=new_name)
    
                if self.selected_table_label == self.table_labels[new_name]:
                    self.selected_table_label = self.table_labels[new_name]
                    self.table_labels[new_name].config(bg=self.BUTTON_COLOR_SELECTED)
    
                current_file = self.save_file_dir / f"{old_name}.json"
                new_file = self.save_file_dir / f"{new_name}.json"
    
                if current_file.exists():
                    current_file.rename(new_file)
    
            self.cancel_rename()
    
        def cancel_rename(self):
            """Cancel the renaming entry."""
            if self.rename_entry:
                self.rename_entry.destroy()
                self.rename_entry = None
    
        def add_custom_hover(self, label):
            """Add custom hover effects to a label."""
            def on_enter(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR_SELECTED)
    
            def on_leave(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR)
    
            label.bind("<Enter>", on_enter)
            label.bind("<Leave>", on_leave)
    
    if __name__ == "__main__":
        set_dpi_awareness()
        root = tk.Tk()
        app = TableApp(root)
        root.mainloop()
    

    Key Additions

    1. Delete Button: Added self.delete_table_button to the bottom of the sidebar, allowing users to delete the currently selected table.

    2. Delete Functionality: delete_table function removes the selected table from the UI, internal storage, and deletes its file from the disk after confirming the deletion with the user.

    This implementation keeps the user experience intuitive and straightforward, ensuring the deletion process is both accessible and safe through a confirmation dialog.

  7. User

    use the same design as for the creat table button

  8. Assistant

    To align the design of the delete button with the one used for the "Create New Table" button, we can create the delete button using a label that looks the same as the "Create New Table" label and is clickable. Here are the necessary modifications to achieve that:

    1. Modify the create_sidebar method to use a label for the delete table option, applying the same style as the "Create New Table" option.
    2. Add the delete option to the sidebar using a clickable label with hover effects.

    Here's how you can update the code:

    import tkinter as tk
    from tkinter import simpledialog, messagebox, filedialog
    from tksheet import Sheet
    import json
    import csv
    from pathlib import Path
    import ctypes
    
    def set_dpi_awareness():
        """Enable DPI awareness for high DPI settings."""
        try:
            ctypes.windll.shcore.SetProcessDpiAwareness(1)
        except Exception as e:
            print(f"Error setting DPI awareness: {e}")
    
    class TableApp:
        def __init__(self, root):
            """Initialize the Table Editor application."""
            self.root = root
            self.root.title("Table Editor with Sidebar")
            self.root.geometry("1280x720")
    
            # Color configurations
            self.BACKGROUND_COLOR = '#FFFFFF'
            self.SIDEBAR_COLOR = '#F7F8FC'
            self.BUTTON_COLOR = '#F7F8FC'
            self.BUTTON_COLOR_SELECTED = '#EAEDEF'
            self.BUTTON_TEXT_COLOR = '#000000'
    
            self.setup_ui()
            self.initialize_data()
            self.load_tables()
    
        def setup_ui(self):
            """Set up the user interface components."""
            self.create_sidebar()
            self.create_main_frame()
            self.create_header_frame()
            self.create_table_frame()
    
        def create_sidebar(self):
            """Create the sidebar and its components."""
            self.sidebar = tk.Frame(self.root, width=200, bg=self.SIDEBAR_COLOR, bd=0, relief='flat')
            self.sidebar.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.separator = tk.Frame(self.root, width=100, bg=self.BACKGROUND_COLOR, bd=0, relief='flat')
            self.separator.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.new_table_label = self.create_clickable_label(
                self.sidebar, "Create New Table", self.create_new_table)
            self.new_table_label.pack(padx=0, pady=10, fill='x')
    
            self.import_table_label = self.create_clickable_label(
                self.sidebar, "Import Table", self.import_file)
            self.import_table_label.pack(padx=0, pady=10, fill='x')
    
            self.table_labels_frame = tk.Frame(self.sidebar, bg=self.SIDEBAR_COLOR)
            self.table_labels_frame.pack(expand=True, fill='both', padx=0, pady=10)
    
            # Add delete table option
            self.delete_table_label = self.create_clickable_label(
                self.sidebar, "Delete Selected Table", self.delete_table)
            self.delete_table_label.pack(side='bottom', padx=0, pady=10, fill='x')
    
            self.add_custom_hover(self.new_table_label)
            self.add_custom_hover(self.import_table_label)
            self.add_custom_hover(self.delete_table_label)
    
        def create_main_frame(self):
            """Create the main frame of the application."""
            self.main_frame = tk.Frame(self.root)
            self.main_frame.pack(expand=True, fill='both', side='right')
    
        def create_header_frame(self):
            """Create the header frame with filter and rename options."""
            self.header_frame = tk.Frame(self.main_frame, height=50, bg=self.BACKGROUND_COLOR)
            self.header_frame.pack(fill='x')
    
            self.filter_label = tk.Label(self.header_frame, text="Filter:", bg=self.BACKGROUND_COLOR, anchor="w")
            self.filter_label.pack(side='left', padx=5, pady=10)
    
            self.filter_entry = tk.Entry(self.header_frame)
            self.filter_entry.pack(side='left', padx=5, pady=10)
            self.filter_entry.bind("<KeyRelease>", lambda event: self.apply_filter())
    
            self.rename_headers_label = self.create_clickable_label(
                self.header_frame, "Rename Headers", self.rename_headers)
            self.rename_headers_label.pack(side='left', padx=5, pady=10, fill='x')
    
        def create_table_frame(self):
            """Create the frame to hold the table."""
            self.table_frame = tk.Frame(self.main_frame, bg=self.BACKGROUND_COLOR)
            self.table_frame.pack(expand=True, fill='both')
    
        def initialize_data(self):
            """Initialize data structures and variables."""
            self.save_file_dir = Path("tables")
            self.tables = {}
            self.table_labels = {}
            self.original_data = {}
            self.headers = {}
            self.current_table_name = None
            self.rename_entry = None
            self.selected_table_label = None
    
            self.save_file_dir.mkdir(exist_ok=True)
    
        def create_clickable_label(self, parent, text, command, allow_rename=True):
            """Create a clickable Label widget."""
            label = tk.Label(
                parent, text=text, bg=self.BUTTON_COLOR, fg=self.BUTTON_TEXT_COLOR,
                borderwidth=0, relief='flat', cursor='arrow', anchor='w',
                padx=10, pady=5
            )
            label.bind("<Button-1>", lambda e: command())
            if allow_rename:
                label.bind("<Double-1>", lambda e: self.begin_rename(text))
            return label
    
        def create_new_table(self):
            """Create a new table and add it to the available tables list."""
            table_name = f"Table {len(self.tables) + 1}"
            self.add_table(table_name)
            self.load_selected_table(table_name)
    
        def import_file(self):
            """Import a CSV or JSON file to create a new table."""
            file_path = filedialog.askopenfilename(
                title="Open File",
                filetypes=[("CSV files", "*.csv"), ("JSON files", "*.json")]
            )
            if not file_path:
                return
    
            if file_path.endswith('.csv'):
                with open(file_path, newline='', encoding='utf-8') as csvfile:
                    reader = csv.reader(csvfile)
                    data = list(reader)
                headers, table_data = data[0], data[1:]
    
            elif file_path.endswith('.json'):
                with open(file_path, 'r', encoding='utf-8') as jsonfile:
                    data = json.load(jsonfile)
                headers, table_data = data[0], data[1:]
    
            else:
                messagebox.showerror("Unsupported File", "The selected file format is not supported.")
                return
    
            table_name = Path(file_path).stem
            self.add_table(table_name, table_data)
            self.headers[table_name] = headers
            self.load_selected_table(table_name)
    
        def add_table(self, table_name, data=None):
            """Add a table to the UI and internal storage."""
            default_data = [["" for _ in range(5)] for _ in range(10)]
            self.tables[table_name] = Sheet(
                self.table_frame,
                data=data or default_data
            )
            self.tables[table_name].enable_bindings()
            self.tables[table_name].extra_bindings([
                ("end_edit_cell", lambda event, tn=table_name: self.save_data(tn)),
            ])
            self.tables[table_name].pack_forget()
            self.original_data[table_name] = self.tables[table_name].get_sheet_data()
    
            if table_name not in self.headers:
                self.headers[table_name] = self.tables[table_name].headers()
    
            table_label = self.create_clickable_label(
                self.table_labels_frame, table_name,
                lambda name=table_name: self.load_selected_table(name)
            )
            table_label.pack(fill='x', pady=2)
            self.table_labels[table_name] = table_label
    
            self.add_custom_hover(table_label)
    
        def delete_table(self):
            """Delete the currently selected table."""
            if not self.current_table_name:
                messagebox.showwarning("No Table Selected", "Please select a table to delete.")
                return
    
            response = messagebox.askyesno(
                "Delete Table",
                f"Are you sure you want to delete the table '{self.current_table_name}'?"
            )
            if response:
                # Remove from the UI
                self.tables[self.current_table_name].destroy()
                self.table_labels[self.current_table_name].destroy()
    
                # Remove from internal storage
                del self.tables[self.current_table_name]
                del self.original_data[self.current_table_name]
                del self.headers[self.current_table_name]
                del self.table_labels[self.current_table_name]
    
                # Remove from disk
                file_path = self.save_file_dir / f"{self.current_table_name}.json"
                if file_path.exists():
                    file_path.unlink()
    
                # Reset current table selection
                self.current_table_name = None
                self.selected_table_label = None
    
        def load_tables(self):
            """Load existing tables from the directory."""
            for file_path in self.save_file_dir.glob("*.json"):
                table_name = file_path.stem
                with file_path.open('r') as file:
                    data = json.load(file)
                    headers = data.pop(0)
                    self.add_table(table_name, data)
                    self.headers[table_name] = headers
    
        def load_selected_table(self, table_name):
            """Display the selected table and hide others."""
            for name, sheet in self.tables.items():
                if name == table_name:
                    sheet.pack(expand=True, fill='both')
                    self.current_table_name = table_name
                    sheet.headers(self.headers[name])
                    self.apply_filter()
    
                    selected_label = self.table_labels[name]
                    selected_label.config(bg=self.BUTTON_COLOR_SELECTED)
                    self.selected_table_label = selected_label
                else:
                    sheet.pack_forget()
                    self.table_labels[name].config(bg=self.BUTTON_COLOR)
    
        def save_data(self, table_name):
            """Save current data of a table to a file."""
            data = [self.headers[table_name]] + self.tables[table_name].get_sheet_data()
            file_path = self.save_file_dir / f"{table_name}.json"
            with file_path.open('w') as file:
                json.dump(data, file)
            print(f"Data for {table_name} saved successfully.")
    
        def apply_filter(self):
            """Apply filtering based on the entered term."""
            if not self.current_table_name:
                return
    
            term = self.filter_entry.get().lower()
            original_data = self.original_data[self.current_table_name]
    
            filtered_data = [
                row for row in original_data
                if any(term in str(cell).lower() for cell in row)
            ]
    
            self.tables[self.current_table_name].set_sheet_data(filtered_data)
    
        def rename_headers(self):
            """Prompt user to rename headers of the currently selected table."""
            if not self.current_table_name:
                messagebox.showwarning("No Table Selected", "Please select a table to rename headers.")
                return
    
            current_headers = self.headers[self.current_table_name]
            new_headers = simpledialog.askstring(
                "Rename Headers",
                "Enter new headers (comma-separated):",
                initialvalue=", ".join(current_headers)
            )
    
            if new_headers:
                header_list = [header.strip() for header in new_headers.split(',')]
                self.headers[self.current_table_name] = header_list
                self.tables[self.current_table_name].headers(header_list)
                self.save_data(self.current_table_name)
    
        def begin_rename(self, table_name):
            """Begin renaming of the table with a double click."""
            label = self.table_labels[table_name]
            
            if self.rename_entry:
                self.rename_entry.destroy()
            
            label.update_idletasks()
            label_x, label_y = label.winfo_x(), label.winfo_y()
            label_width, label_height = label.winfo_width(), label.winfo_height()
            
            self.rename_entry = tk.Entry(
                self.table_labels_frame,
                bg=label.cget("bg"),
                fg=self.BUTTON_TEXT_COLOR,
                font=label.cget("font"),
                relief='flat',
                borderwidth=0,
                highlightthickness=0,
                justify='left'
            )
            self.rename_entry.insert(0, table_name)
            
            self.rename_entry.place(x=label_x, y=label_y, width=label_width, height=label_height)
            self.rename_entry.focus()
            self.rename_entry.select_range(0, tk.END)
            
            self.rename_entry.bind('<Return>', lambda event: self.end_rename(table_name))
            self.rename_entry.bind('<FocusOut>', lambda event: self.cancel_rename())
    
        def end_rename(self, old_name):
            """Finish the renaming process for the specified table."""
            new_name = self.rename_entry.get().strip()
    
            if not new_name:
                messagebox.showerror("Invalid Name", "Table name cannot be empty.")
                self.rename_entry.focus_set()
                return
    
            if new_name in self.tables and new_name != old_name:
                messagebox.showerror("Duplicate Name", f"A table named '{new_name}' already exists.")
                self.rename_entry.focus_set()
                return
    
            if new_name != old_name:
                self.tables[new_name] = self.tables.pop(old_name)
                self.original_data[new_name] = self.original_data.pop(old_name)
                self.headers[new_name] = self.headers.pop(old_name)
    
                self.table_labels[new_name] = self.table_labels.pop(old_name)
                self.table_labels[new_name].config(text=new_name)
    
                if self.selected_table_label == self.table_labels[new_name]:
                    self.selected_table_label = self.table_labels[new_name]
                    self.table_labels[new_name].config(bg=self.BUTTON_COLOR_SELECTED)
    
                current_file = self.save_file_dir / f"{old_name}.json"
                new_file = self.save_file_dir / f"{new_name}.json"
    
                if current_file.exists():
                    current_file.rename(new_file)
    
            self.cancel_rename()
    
        def cancel_rename(self):
            """Cancel the renaming entry."""
            if self.rename_entry:
                self.rename_entry.destroy()
                self.rename_entry = None
    
        def add_custom_hover(self, label):
            """Add custom hover effects to a label."""
            def on_enter(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR_SELECTED)
    
            def on_leave(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR)
    
            label.bind("<Enter>", on_enter)
            label.bind("<Leave>", on_leave)
    
    if __name__ == "__main__":
        set_dpi_awareness()
        root = tk.Tk()
        app = TableApp(root)
        root.mainloop()
    

    Key Changes

    • The delete option is now a clickable label styled similarly to the "Create New Table" and "Import Table" options.
    • The add_custom_hover function is used to add hover effects for visual consistency.

    This update ensures a uniform design for all interactive elements within the sidebar, maintaining a cohesive look and feel throughout the user interface.

  9. User

    Use literata as font for all text in the app and use fontsize 12

  10. Assistant

    To apply the "Literata" font with a font size of 12 to all text elements in the Tkinter application, you can configure the font settings in your code. You'll want to ensure that the "Literata" font is installed on your system; otherwise, you'll need to use a fallback font.

    Here's how you can update your code to apply the desired font settings:

    1. Set a default font for the application using tkinter's option_add method.
    2. Update labels, buttons, and entries to use the Literata font with the specified size.

    Here's the modified code:

    import tkinter as tk
    from tkinter import simpledialog, messagebox, filedialog
    from tksheet import Sheet
    import json
    import csv
    from pathlib import Path
    import ctypes
    
    def set_dpi_awareness():
        """Enable DPI awareness for high DPI settings."""
        try:
            ctypes.windll.shcore.SetProcessDpiAwareness(1)
        except Exception as e:
            print(f"Error setting DPI awareness: {e}")
    
    class TableApp:
        def __init__(self, root):
            """Initialize the Table Editor application."""
            self.root = root
            self.root.title("Table Editor with Sidebar")
            self.root.geometry("1280x720")
    
            # Set default font
            font_name = "Literata"
            font_size = 12
            self.root.option_add("*Font", f"{font_name} {font_size}")
    
            # Color configurations
            self.BACKGROUND_COLOR = '#FFFFFF'
            self.SIDEBAR_COLOR = '#F7F8FC'
            self.BUTTON_COLOR = '#F7F8FC'
            self.BUTTON_COLOR_SELECTED = '#EAEDEF'
            self.BUTTON_TEXT_COLOR = '#000000'
    
            self.setup_ui()
            self.initialize_data()
            self.load_tables()
    
        def setup_ui(self):
            """Set up the user interface components."""
            self.create_sidebar()
            self.create_main_frame()
            self.create_header_frame()
            self.create_table_frame()
    
        def create_sidebar(self):
            """Create the sidebar and its components."""
            self.sidebar = tk.Frame(self.root, width=200, bg=self.SIDEBAR_COLOR, bd=0, relief='flat')
            self.sidebar.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.separator = tk.Frame(self.root, width=100, bg=self.BACKGROUND_COLOR, bd=0, relief='flat')
            self.separator.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.new_table_label = self.create_clickable_label(
                self.sidebar, "Create New Table", self.create_new_table)
            self.new_table_label.pack(padx=0, pady=10, fill='x')
    
            self.import_table_label = self.create_clickable_label(
                self.sidebar, "Import Table", self.import_file)
            self.import_table_label.pack(padx=0, pady=10, fill='x')
    
            self.table_labels_frame = tk.Frame(self.sidebar, bg=self.SIDEBAR_COLOR)
            self.table_labels_frame.pack(expand=True, fill='both', padx=0, pady=10)
    
            # Add delete table option
            self.delete_table_label = self.create_clickable_label(
                self.sidebar, "Delete Selected Table", self.delete_table)
            self.delete_table_label.pack(side='bottom', padx=0, pady=10, fill='x')
    
            self.add_custom_hover(self.new_table_label)
            self.add_custom_hover(self.import_table_label)
            self.add_custom_hover(self.delete_table_label)
    
        def create_main_frame(self):
            """Create the main frame of the application."""
            self.main_frame = tk.Frame(self.root)
            self.main_frame.pack(expand=True, fill='both', side='right')
    
        def create_header_frame(self):
            """Create the header frame with filter and rename options."""
            self.header_frame = tk.Frame(self.main_frame, height=50, bg=self.BACKGROUND_COLOR)
            self.header_frame.pack(fill='x')
    
            self.filter_label = tk.Label(self.header_frame, text="Filter:", bg=self.BACKGROUND_COLOR, anchor="w")
            self.filter_label.pack(side='left', padx=5, pady=10)
    
            self.filter_entry = tk.Entry(self.header_frame)
            self.filter_entry.pack(side='left', padx=5, pady=10)
            self.filter_entry.bind("<KeyRelease>", lambda event: self.apply_filter())
    
            self.rename_headers_label = self.create_clickable_label(
                self.header_frame, "Rename Headers", self.rename_headers)
            self.rename_headers_label.pack(side='left', padx=5, pady=10, fill='x')
    
        def create_table_frame(self):
            """Create the frame to hold the table."""
            self.table_frame = tk.Frame(self.main_frame, bg=self.BACKGROUND_COLOR)
            self.table_frame.pack(expand=True, fill='both')
    
        def initialize_data(self):
            """Initialize data structures and variables."""
            self.save_file_dir = Path("tables")
            self.tables = {}
            self.table_labels = {}
            self.original_data = {}
            self.headers = {}
            self.current_table_name = None
            self.rename_entry = None
            self.selected_table_label = None
    
            self.save_file_dir.mkdir(exist_ok=True)
    
        def create_clickable_label(self, parent, text, command, allow_rename=True):
            """Create a clickable Label widget."""
            label = tk.Label(
                parent, text=text, bg=self.BUTTON_COLOR, fg=self.BUTTON_TEXT_COLOR,
                borderwidth=0, relief='flat', cursor='arrow', anchor='w',
                padx=10, pady=5
            )
            label.bind("<Button-1>", lambda e: command())
            if allow_rename:
                label.bind("<Double-1>", lambda e: self.begin_rename(text))
            return label
    
        def create_new_table(self):
            """Create a new table and add it to the available tables list."""
            table_name = f"Table {len(self.tables) + 1}"
            self.add_table(table_name)
            self.load_selected_table(table_name)
    
        def import_file(self):
            """Import a CSV or JSON file to create a new table."""
            file_path = filedialog.askopenfilename(
                title="Open File",
                filetypes=[("CSV files", "*.csv"), ("JSON files", "*.json")]
            )
            if not file_path:
                return
    
            if file_path.endswith('.csv'):
                with open(file_path, newline='', encoding='utf-8') as csvfile:
                    reader = csv.reader(csvfile)
                    data = list(reader)
                headers, table_data = data[0], data[1:]
    
            elif file_path.endswith('.json'):
                with open(file_path, 'r', encoding='utf-8') as jsonfile:
                    data = json.load(jsonfile)
                headers, table_data = data[0], data[1:]
    
            else:
                messagebox.showerror("Unsupported File", "The selected file format is not supported.")
                return
    
            table_name = Path(file_path).stem
            self.add_table(table_name, table_data)
            self.headers[table_name] = headers
            self.load_selected_table(table_name)
    
        def add_table(self, table_name, data=None):
            """Add a table to the UI and internal storage."""
            default_data = [["" for _ in range(5)] for _ in range(10)]
            self.tables[table_name] = Sheet(
                self.table_frame,
                data=data or default_data
            )
            self.tables[table_name].enable_bindings()
            self.tables[table_name].extra_bindings([
                ("end_edit_cell", lambda event, tn=table_name: self.save_data(tn)),
            ])
            self.tables[table_name].pack_forget()
            self.original_data[table_name] = self.tables[table_name].get_sheet_data()
    
            if table_name not in self.headers:
                self.headers[table_name] = self.tables[table_name].headers()
    
            table_label = self.create_clickable_label(
                self.table_labels_frame, table_name,
                lambda name=table_name: self.load_selected_table(name)
            )
            table_label.pack(fill='x', pady=2)
            self.table_labels[table_name] = table_label
    
            self.add_custom_hover(table_label)
    
        def delete_table(self):
            """Delete the currently selected table."""
            if not self.current_table_name:
                messagebox.showwarning("No Table Selected", "Please select a table to delete.")
                return
    
            response = messagebox.askyesno(
                "Delete Table",
                f"Are you sure you want to delete the table '{self.current_table_name}'?"
            )
            if response:
                # Remove from the UI
                self.tables[self.current_table_name].destroy()
                self.table_labels[self.current_table_name].destroy()
    
                # Remove from internal storage
                del self.tables[self.current_table_name]
                del self.original_data[self.current_table_name]
                del self.headers[self.current_table_name]
                del self.table_labels[self.current_table_name]
    
                # Remove from disk
                file_path = self.save_file_dir / f"{self.current_table_name}.json"
                if file_path.exists():
                    file_path.unlink()
    
                # Reset current table selection
                self.current_table_name = None
                self.selected_table_label = None
    
        def load_tables(self):
            """Load existing tables from the directory."""
            for file_path in self.save_file_dir.glob("*.json"):
                table_name = file_path.stem
                with file_path.open('r') as file:
                    data = json.load(file)
                    headers = data.pop(0)
                    self.add_table(table_name, data)
                    self.headers[table_name] = headers
    
        def load_selected_table(self, table_name):
            """Display the selected table and hide others."""
            for name, sheet in self.tables.items():
                if name == table_name:
                    sheet.pack(expand=True, fill='both')
                    self.current_table_name = table_name
                    sheet.headers(self.headers[name])
                    self.apply_filter()
    
                    selected_label = self.table_labels[name]
                    selected_label.config(bg=self.BUTTON_COLOR_SELECTED)
                    self.selected_table_label = selected_label
                else:
                    sheet.pack_forget()
                    self.table_labels[name].config(bg=self.BUTTON_COLOR)
    
        def save_data(self, table_name):
            """Save current data of a table to a file."""
            data = [self.headers[table_name]] + self.tables[table_name].get_sheet_data()
            file_path = self.save_file_dir / f"{table_name}.json"
            with file_path.open('w') as file:
                json.dump(data, file)
            print(f"Data for {table_name} saved successfully.")
    
        def apply_filter(self):
            """Apply filtering based on the entered term."""
            if not self.current_table_name:
                return
    
            term = self.filter_entry.get().lower()
            original_data = self.original_data[self.current_table_name]
    
            filtered_data = [
                row for row in original_data
                if any(term in str(cell).lower() for cell in row)
            ]
    
            self.tables[self.current_table_name].set_sheet_data(filtered_data)
    
        def rename_headers(self):
            """Prompt user to rename headers of the currently selected table."""
            if not self.current_table_name:
                messagebox.showwarning("No Table Selected", "Please select a table to rename headers.")
                return
    
            current_headers = self.headers[self.current_table_name]
            new_headers = simpledialog.askstring(
                "Rename Headers",
                "Enter new headers (comma-separated):",
                initialvalue=", ".join(current_headers)
            )
    
            if new_headers:
                header_list = [header.strip() for header in new_headers.split(',')]
                self.headers[self.current_table_name] = header_list
                self.tables[self.current_table_name].headers(header_list)
                self.save_data(self.current_table_name)
    
        def begin_rename(self, table_name):
            """Begin renaming of the table with a double click."""
            label = self.table_labels[table_name]
            
            if self.rename_entry:
                self.rename_entry.destroy()
            
            label.update_idletasks()
            label_x, label_y = label.winfo_x(), label.winfo_y()
            label_width, label_height = label.winfo_width(), label.winfo_height()
            
            self.rename_entry = tk.Entry(
                self.table_labels_frame,
                bg=label.cget("bg"),
                fg=self.BUTTON_TEXT_COLOR,
                relief='flat',
                borderwidth=0,
                highlightthickness=0,
                justify='left'
            )
            self.rename_entry.insert(0, table_name)
            
            self.rename_entry.place(x=label_x, y=label_y, width=label_width, height=label_height)
            self.rename_entry.focus()
            self.rename_entry.select_range(0, tk.END)
            
            self.rename_entry.bind('<Return>', lambda event: self.end_rename(table_name))
            self.rename_entry.bind('<FocusOut>', lambda event: self.cancel_rename())
    
        def end_rename(self, old_name):
            """Finish the renaming process for the specified table."""
            new_name = self.rename_entry.get().strip()
    
            if not new_name:
                messagebox.showerror("Invalid Name", "Table name cannot be empty.")
                self.rename_entry.focus_set()
                return
    
            if new_name in self.tables and new_name != old_name:
                messagebox.showerror("Duplicate Name", f"A table named '{new_name}' already exists.")
                self.rename_entry.focus_set()
                return
    
            if new_name != old_name:
                self.tables[new_name] = self.tables.pop(old_name)
                self.original_data[new_name] = self.original_data.pop(old_name)
                self.headers[new_name] = self.headers.pop(old_name)
    
                self.table_labels[new_name] = self.table_labels.pop(old_name)
                self.table_labels[new_name].config(text=new_name)
    
                if self.selected_table_label == self.table_labels[new_name]:
                    self.selected_table_label = self.table_labels[new_name]
                    self.table_labels[new_name].config(bg=self.BUTTON_COLOR_SELECTED)
    
                current_file = self.save_file_dir / f"{old_name}.json"
                new_file = self.save_file_dir / f"{new_name}.json"
    
                if current_file.exists():
                    current_file.rename(new_file)
    
            self.cancel_rename()
    
        def cancel_rename(self):
            """Cancel the renaming entry."""
            if self.rename_entry:
                self.rename_entry.destroy()
                self.rename_entry = None
    
        def add_custom_hover(self, label):
            """Add custom hover effects to a label."""
            def on_enter(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR_SELECTED)
    
            def on_leave(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR)
    
            label.bind("<Enter>", on_enter)
            label.bind("<Leave>", on_leave)
    
    if __name__ == "__main__":
        set_dpi_awareness()
        root = tk.Tk()
        app = TableApp(root)
        root.mainloop()
    

    Key Changes:

    • Used self.root.option_add("*Font", "Literata 12") to set the default font for all widgets in the application.
    • Removed the explicit font setting in widgets, relying on the default font configuration.

    Ensure that "Literata" is installed on your machine. If not, replace "Literata" with an available font or download and install it to see the desired effect.

  11. User

    Also uses literata for tksheet

  12. Assistant

    To ensure that the Literata font is used for tksheet as well, you'll need to configure the font settings for the Sheet widget explicitly. We need to pass the desired font settings to the tksheet.Sheet when it is being created.

    Here's how you can update your code to apply the Literata font with size 12 to tksheet:

    import tkinter as tk
    from tkinter import simpledialog, messagebox, filedialog
    from tksheet import Sheet
    import json
    import csv
    from pathlib import Path
    import ctypes
    
    def set_dpi_awareness():
        """Enable DPI awareness for high DPI settings."""
        try:
            ctypes.windll.shcore.SetProcessDpiAwareness(1)
        except Exception as e:
            print(f"Error setting DPI awareness: {e}")
    
    class TableApp:
        def __init__(self, root):
            """Initialize the Table Editor application."""
            self.root = root
            self.root.title("Table Editor with Sidebar")
            self.root.geometry("1280x720")
    
            # Set default font
            font_name = "Literata"
            font_size = 12
            self.root.option_add("*Font", f"{font_name} {font_size}")
    
            # Color configurations
            self.BACKGROUND_COLOR = '#FFFFFF'
            self.SIDEBAR_COLOR = '#F7F8FC'
            self.BUTTON_COLOR = '#F7F8FC'
            self.BUTTON_COLOR_SELECTED = '#EAEDEF'
            self.BUTTON_TEXT_COLOR = '#000000'
    
            self.setup_ui()
            self.initialize_data()
            self.load_tables()
    
        def setup_ui(self):
            """Set up the user interface components."""
            self.create_sidebar()
            self.create_main_frame()
            self.create_header_frame()
            self.create_table_frame()
    
        def create_sidebar(self):
            """Create the sidebar and its components."""
            self.sidebar = tk.Frame(self.root, width=200, bg=self.SIDEBAR_COLOR, bd=0, relief='flat')
            self.sidebar.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.separator = tk.Frame(self.root, width=100, bg=self.BACKGROUND_COLOR, bd=0, relief='flat')
            self.separator.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.new_table_label = self.create_clickable_label(
                self.sidebar, "Create New Table", self.create_new_table)
            self.new_table_label.pack(padx=0, pady=10, fill='x')
    
            self.import_table_label = self.create_clickable_label(
                self.sidebar, "Import Table", self.import_file)
            self.import_table_label.pack(padx=0, pady=10, fill='x')
    
            self.table_labels_frame = tk.Frame(self.sidebar, bg=self.SIDEBAR_COLOR)
            self.table_labels_frame.pack(expand=True, fill='both', padx=0, pady=10)
    
            # Add delete table option
            self.delete_table_label = self.create_clickable_label(
                self.sidebar, "Delete Selected Table", self.delete_table)
            self.delete_table_label.pack(side='bottom', padx=0, pady=10, fill='x')
    
            self.add_custom_hover(self.new_table_label)
            self.add_custom_hover(self.import_table_label)
            self.add_custom_hover(self.delete_table_label)
    
        def create_main_frame(self):
            """Create the main frame of the application."""
            self.main_frame = tk.Frame(self.root)
            self.main_frame.pack(expand=True, fill='both', side='right')
    
        def create_header_frame(self):
            """Create the header frame with filter and rename options."""
            self.header_frame = tk.Frame(self.main_frame, height=50, bg=self.BACKGROUND_COLOR)
            self.header_frame.pack(fill='x')
    
            self.filter_label = tk.Label(self.header_frame, text="Filter:", bg=self.BACKGROUND_COLOR, anchor="w")
            self.filter_label.pack(side='left', padx=5, pady=10)
    
            self.filter_entry = tk.Entry(self.header_frame)
            self.filter_entry.pack(side='left', padx=5, pady=10)
            self.filter_entry.bind("<KeyRelease>", lambda event: self.apply_filter())
    
            self.rename_headers_label = self.create_clickable_label(
                self.header_frame, "Rename Headers", self.rename_headers)
            self.rename_headers_label.pack(side='left', padx=5, pady=10, fill='x')
    
        def create_table_frame(self):
            """Create the frame to hold the table."""
            self.table_frame = tk.Frame(self.main_frame, bg=self.BACKGROUND_COLOR)
            self.table_frame.pack(expand=True, fill='both')
    
        def initialize_data(self):
            """Initialize data structures and variables."""
            self.save_file_dir = Path("tables")
            self.tables = {}
            self.table_labels = {}
            self.original_data = {}
            self.headers = {}
            self.current_table_name = None
            self.rename_entry = None
            self.selected_table_label = None
    
            self.save_file_dir.mkdir(exist_ok=True)
    
        def create_clickable_label(self, parent, text, command, allow_rename=True):
            """Create a clickable Label widget."""
            label = tk.Label(
                parent, text=text, bg=self.BUTTON_COLOR, fg=self.BUTTON_TEXT_COLOR,
                borderwidth=0, relief='flat', cursor='arrow', anchor='w',
                padx=10, pady=5
            )
            label.bind("<Button-1>", lambda e: command())
            if allow_rename:
                label.bind("<Double-1>", lambda e: self.begin_rename(text))
            return label
    
        def create_new_table(self):
            """Create a new table and add it to the available tables list."""
            table_name = f"Table {len(self.tables) + 1}"
            self.add_table(table_name)
            self.load_selected_table(table_name)
    
        def import_file(self):
            """Import a CSV or JSON file to create a new table."""
            file_path = filedialog.askopenfilename(
                title="Open File",
                filetypes=[("CSV files", "*.csv"), ("JSON files", "*.json")]
            )
            if not file_path:
                return
    
            if file_path.endswith('.csv'):
                with open(file_path, newline='', encoding='utf-8') as csvfile:
                    reader = csv.reader(csvfile)
                    data = list(reader)
                headers, table_data = data[0], data[1:]
    
            elif file_path.endswith('.json'):
                with open(file_path, 'r', encoding='utf-8') as jsonfile:
                    data = json.load(jsonfile)
                headers, table_data = data[0], data[1:]
    
            else:
                messagebox.showerror("Unsupported File", "The selected file format is not supported.")
                return
    
            table_name = Path(file_path).stem
            self.add_table(table_name, table_data)
            self.headers[table_name] = headers
            self.load_selected_table(table_name)
    
        def add_table(self, table_name, data=None):
            """Add a table to the UI and internal storage."""
            default_data = [["" for _ in range(5)] for _ in range(10)]
            self.tables[table_name] = Sheet(
                self.table_frame,
                data=data or default_data,
                show_table=True, 
                headers=None,
                font=("Literata", 12)
            )
            self.tables[table_name].enable_bindings()
            self.tables[table_name].extra_bindings([
                ("end_edit_cell", lambda event, tn=table_name: self.save_data(tn)),
            ])
            self.tables[table_name].pack_forget()
            self.original_data[table_name] = self.tables[table_name].get_sheet_data()
    
            if table_name not in self.headers:
                self.headers[table_name] = self.tables[table_name].headers()
    
            table_label = self.create_clickable_label(
                self.table_labels_frame, table_name,
                lambda name=table_name: self.load_selected_table(name)
            )
            table_label.pack(fill='x', pady=2)
            self.table_labels[table_name] = table_label
    
            self.add_custom_hover(table_label)
    
        def delete_table(self):
            """Delete the currently selected table."""
            if not self.current_table_name:
                messagebox.showwarning("No Table Selected", "Please select a table to delete.")
                return
    
            response = messagebox.askyesno(
                "Delete Table",
                f"Are you sure you want to delete the table '{self.current_table_name}'?"
            )
            if response:
                # Remove from the UI
                self.tables[self.current_table_name].destroy()
                self.table_labels[self.current_table_name].destroy()
    
                # Remove from internal storage
                del self.tables[self.current_table_name]
                del self.original_data[self.current_table_name]
                del self.headers[self.current_table_name]
                del self.table_labels[self.current_table_name]
    
                # Remove from disk
                file_path = self.save_file_dir / f"{self.current_table_name}.json"
                if file_path.exists():
                    file_path.unlink()
    
                # Reset current table selection
                self.current_table_name = None
                self.selected_table_label = None
    
        def load_tables(self):
            """Load existing tables from the directory."""
            for file_path in self.save_file_dir.glob("*.json"):
                table_name = file_path.stem
                with file_path.open('r') as file:
                    data = json.load(file)
                    headers = data.pop(0)
                    self.add_table(table_name, data)
                    self.headers[table_name] = headers
    
        def load_selected_table(self, table_name):
            """Display the selected table and hide others."""
            for name, sheet in self.tables.items():
                if name == table_name:
                    sheet.pack(expand=True, fill='both')
                    self.current_table_name = table_name
                    sheet.headers(self.headers[name])
                    self.apply_filter()
    
                    selected_label = self.table_labels[name]
                    selected_label.config(bg=self.BUTTON_COLOR_SELECTED)
                    self.selected_table_label = selected_label
                else:
                    sheet.pack_forget()
                    self.table_labels[name].config(bg=self.BUTTON_COLOR)
    
        def save_data(self, table_name):
            """Save current data of a table to a file."""
            data = [self.headers[table_name]] + self.tables[table_name].get_sheet_data()
            file_path = self.save_file_dir / f"{table_name}.json"
            with file_path.open('w') as file:
                json.dump(data, file)
            print(f"Data for {table_name} saved successfully.")
    
        def apply_filter(self):
            """Apply filtering based on the entered term."""
            if not self.current_table_name:
                return
    
            term = self.filter_entry.get().lower()
            original_data = self.original_data[self.current_table_name]
    
            filtered_data = [
                row for row in original_data
                if any(term in str(cell).lower() for cell in row)
            ]
    
            self.tables[self.current_table_name].set_sheet_data(filtered_data)
    
        def rename_headers(self):
            """Prompt user to rename headers of the currently selected table."""
            if not self.current_table_name:
                messagebox.showwarning("No Table Selected", "Please select a table to rename headers.")
                return
    
            current_headers = self.headers[self.current_table_name]
            new_headers = simpledialog.askstring(
                "Rename Headers",
                "Enter new headers (comma-separated):",
                initialvalue=", ".join(current_headers)
            )
    
            if new_headers:
                header_list = [header.strip() for header in new_headers.split(',')]
                self.headers[self.current_table_name] = header_list
                self.tables[self.current_table_name].headers(header_list)
                self.save_data(self.current_table_name)
    
        def begin_rename(self, table_name):
            """Begin renaming of the table with a double click."""
            label = self.table_labels[table_name]
            
            if self.rename_entry:
                self.rename_entry.destroy()
            
            label.update_idletasks()
            label_x, label_y = label.winfo_x(), label.winfo_y()
            label_width, label_height = label.winfo_width(), label.winfo_height()
            
            self.rename_entry = tk.Entry(
                self.table_labels_frame,
                bg=label.cget("bg"),
                fg=self.BUTTON_TEXT_COLOR,
                relief='flat',
                borderwidth=0,
                highlightthickness=0,
                justify='left'
            )
            self.rename_entry.insert(0, table_name)
            
            self.rename_entry.place(x=label_x, y=label_y, width=label_width, height=label_height)
            self.rename_entry.focus()
            self.rename_entry.select_range(0, tk.END)
            
            self.rename_entry.bind('<Return>', lambda event: self.end_rename(table_name))
            self.rename_entry.bind('<FocusOut>', lambda event: self.cancel_rename())
    
        def end_rename(self, old_name):
            """Finish the renaming process for the specified table."""
            new_name = self.rename_entry.get().strip()
    
            if not new_name:
                messagebox.showerror("Invalid Name", "Table name cannot be empty.")
                self.rename_entry.focus_set()
                return
    
            if new_name in self.tables and new_name != old_name:
                messagebox.showerror("Duplicate Name", f"A table named '{new_name}' already exists.")
                self.rename_entry.focus_set()
                return
    
            if new_name != old_name:
                self.tables[new_name] = self.tables.pop(old_name)
                self.original_data[new_name] = self.original_data.pop(old_name)
                self.headers[new_name] = self.headers.pop(old_name)
    
                self.table_labels[new_name] = self.table_labels.pop(old_name)
                self.table_labels[new_name].config(text=new_name)
    
                if self.selected_table_label == self.table_labels[new_name]:
                    self.selected_table_label = self.table_labels[new_name]
                    self.table_labels[new_name].config(bg=self.BUTTON_COLOR_SELECTED)
    
                current_file = self.save_file_dir / f"{old_name}.json"
                new_file = self.save_file_dir / f"{new_name}.json"
    
                if current_file.exists():
                    current_file.rename(new_file)
    
            self.cancel_rename()
    
        def cancel_rename(self):
            """Cancel the renaming entry."""
            if self.rename_entry:
                self.rename_entry.destroy()
                self.rename_entry = None
    
        def add_custom_hover(self, label):
            """Add custom hover effects to a label."""
            def on_enter(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR_SELECTED)
    
            def on_leave(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR)
    
            label.bind("<Enter>", on_enter)
            label.bind("<Leave>", on_leave)
    
    if __name__ == "__main__":
        set_dpi_awareness()
        root = tk.Tk()
        app = TableApp(root)
        root.mainloop()
    

    Changes Made:

    • Font Setting for tksheet: When initializing the Sheet, I've included the font specification directly in the constructor: font=("Literata", 12).
    • Optionally manages the headers: If you are using headers, make sure they are passed to the Sheet during initialization or set afterwards.

    Ensure that the "Literata" font is available on the system where you're running this application; otherwise, choose a fallback.

  13. User

    Traceback (most recent call last): File "D:\Bilder\Python\Database\Database 23 - Kopie.py", line 372, in app = TableApp(root) File "D:\Bilder\Python\Database\Database 23 - Kopie.py", line 37, in init self.load_tables() ~~~~~~~~~~~~~~~~^^ File "D:\Bilder\Python\Database\Database 23 - Kopie.py", line 226, in load_tables self.add_table(table_name, data) ~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^ File "D:\Bilder\Python\Database\Database 23 - Kopie.py", line 163, in add_table self.tables[table_name] = Sheet( ~~~~~^ self.table_frame, ^^^^^^^^^^^^^^^^^ ...<3 lines>... font=("Literata", 12) ^^^^^^^^^^^^^^^^^^^^^ ) ^ File "C:\Users\Zarathustra\AppData\Local\Programs\Python\Python313\Lib\site-packages\tksheet\sheet.py", line 351, in init self.MT = MainTable( ~~~~~~~~~^ parent=self, ^^^^^^^^^^^^ ...<20 lines>... all_rows_displayed=all_rows_displayed, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ) ^ File "C:\Users\Zarathustra\AppData\Local\Programs\Python\Python313\Lib\site-packages\tksheet\main_table.py", line 274, in init self.PAR.ops.table_font[2], ~~~~~~~~~~~~~~~~~~~~~~~^^^ IndexError: tuple index out of range


    (program exited with code: 1)

  14. Assistant

    The error message indicates a problem with the way the font is passed to the tksheet.Sheet widget. Specifically, it looks like the tuple index out of range error occurs because the font tuple does not have all the expected elements.

    The tksheet library typically expects a font specification in the form of a tuple that includes the font family, size, and optionally, style (like 'normal', 'bold', etc.). If the expected style element is missing or misconfigured, an IndexError might occur.

    Here's how you can ensure that the font is properly configured for tksheet:

    import tkinter as tk
    from tkinter import simpledialog, messagebox, filedialog
    from tksheet import Sheet
    import json
    import csv
    from pathlib import Path
    import ctypes
    
    def set_dpi_awareness():
        """Enable DPI awareness for high DPI settings."""
        try:
            ctypes.windll.shcore.SetProcessDpiAwareness(1)
        except Exception as e:
            print(f"Error setting DPI awareness: {e}")
    
    class TableApp:
        def __init__(self, root):
            """Initialize the Table Editor application."""
            self.root = root
            self.root.title("Table Editor with Sidebar")
            self.root.geometry("1280x720")
    
            # Set default font
            font_name = "Literata"
            font_size = 12
            self.default_font = (font_name, font_size)
            self.root.option_add("*Font", f"{font_name} {font_size}")
    
            # Color configurations
            self.BACKGROUND_COLOR = '#FFFFFF'
            self.SIDEBAR_COLOR = '#F7F8FC'
            self.BUTTON_COLOR = '#F7F8FC'
            self.BUTTON_COLOR_SELECTED = '#EAEDEF'
            self.BUTTON_TEXT_COLOR = '#000000'
    
            self.setup_ui()
            self.initialize_data()
            self.load_tables()
    
        def setup_ui(self):
            """Set up the user interface components."""
            self.create_sidebar()
            self.create_main_frame()
            self.create_header_frame()
            self.create_table_frame()
    
        def create_sidebar(self):
            """Create the sidebar and its components."""
            self.sidebar = tk.Frame(self.root, width=200, bg=self.SIDEBAR_COLOR, bd=0, relief='flat')
            self.sidebar.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.separator = tk.Frame(self.root, width=100, bg=self.BACKGROUND_COLOR, bd=0, relief='flat')
            self.separator.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.new_table_label = self.create_clickable_label(
                self.sidebar, "Create New Table", self.create_new_table)
            self.new_table_label.pack(padx=0, pady=10, fill='x')
    
            self.import_table_label = self.create_clickable_label(
                self.sidebar, "Import Table", self.import_file)
            self.import_table_label.pack(padx=0, pady=10, fill='x')
    
            self.table_labels_frame = tk.Frame(self.sidebar, bg=self.SIDEBAR_COLOR)
            self.table_labels_frame.pack(expand=True, fill='both', padx=0, pady=10)
    
            # Add delete table option
            self.delete_table_label = self.create_clickable_label(
                self.sidebar, "Delete Selected Table", self.delete_table)
            self.delete_table_label.pack(side='bottom', padx=0, pady=10, fill='x')
    
            self.add_custom_hover(self.new_table_label)
            self.add_custom_hover(self.import_table_label)
            self.add_custom_hover(self.delete_table_label)
    
        def create_main_frame(self):
            """Create the main frame of the application."""
            self.main_frame = tk.Frame(self.root)
            self.main_frame.pack(expand=True, fill='both', side='right')
    
        def create_header_frame(self):
            """Create the header frame with filter and rename options."""
            self.header_frame = tk.Frame(self.main_frame, height=50, bg=self.BACKGROUND_COLOR)
            self.header_frame.pack(fill='x')
    
            self.filter_label = tk.Label(self.header_frame, text="Filter:", bg=self.BACKGROUND_COLOR, anchor="w")
            self.filter_label.pack(side='left', padx=5, pady=10)
    
            self.filter_entry = tk.Entry(self.header_frame)
            self.filter_entry.pack(side='left', padx=5, pady=10)
            self.filter_entry.bind("<KeyRelease>", lambda event: self.apply_filter())
    
            self.rename_headers_label = self.create_clickable_label(
                self.header_frame, "Rename Headers", self.rename_headers)
            self.rename_headers_label.pack(side='left', padx=5, pady=10, fill='x')
    
        def create_table_frame(self):
            """Create the frame to hold the table."""
            self.table_frame = tk.Frame(self.main_frame, bg=self.BACKGROUND_COLOR)
            self.table_frame.pack(expand=True, fill='both')
    
        def initialize_data(self):
            """Initialize data structures and variables."""
            self.save_file_dir = Path("tables")
            self.tables = {}
            self.table_labels = {}
            self.original_data = {}
            self.headers = {}
            self.current_table_name = None
            self.rename_entry = None
            self.selected_table_label = None
    
            self.save_file_dir.mkdir(exist_ok=True)
    
        def create_clickable_label(self, parent, text, command, allow_rename=True):
            """Create a clickable Label widget."""
            label = tk.Label(
                parent, text=text, bg=self.BUTTON_COLOR, fg=self.BUTTON_TEXT_COLOR,
                borderwidth=0, relief='flat', cursor='arrow', anchor='w',
                padx=10, pady=5
            )
            label.bind("<Button-1>", lambda e: command())
            if allow_rename:
                label.bind("<Double-1>", lambda e: self.begin_rename(text))
            return label
    
        def create_new_table(self):
            """Create a new table and add it to the available tables list."""
            table_name = f"Table {len(self.tables) + 1}"
            self.add_table(table_name)
            self.load_selected_table(table_name)
    
        def import_file(self):
            """Import a CSV or JSON file to create a new table."""
            file_path = filedialog.askopenfilename(
                title="Open File",
                filetypes=[("CSV files", "*.csv"), ("JSON files", "*.json")]
            )
            if not file_path:
                return
    
            if file_path.endswith('.csv'):
                with open(file_path, newline='', encoding='utf-8') as csvfile:
                    reader = csv.reader(csvfile)
                    data = list(reader)
                headers, table_data = data[0], data[1:]
    
            elif file_path.endswith('.json'):
                with open(file_path, 'r', encoding='utf-8') as jsonfile:
                    data = json.load(jsonfile)
                headers, table_data = data[0], data[1:]
    
            else:
                messagebox.showerror("Unsupported File", "The selected file format is not supported.")
                return
    
            table_name = Path(file_path).stem
            self.add_table(table_name, table_data)
            self.headers[table_name] = headers
            self.load_selected_table(table_name)
    
        def add_table(self, table_name, data=None):
            """Add a table to the UI and internal storage."""
            default_data = [["" for _ in range(5)] for _ in range(10)]
            self.tables[table_name] = Sheet(
                self.table_frame,
                data=data or default_data,
                show_table=True,
                headers=None,
                font=self.default_font  # Use default font
            )
            self.tables[table_name].enable_bindings()
            self.tables[table_name].extra_bindings([
                ("end_edit_cell", lambda event, tn=table_name: self.save_data(tn)),
            ])
            self.tables[table_name].pack_forget()
            self.original_data[table_name] = self.tables[table_name].get_sheet_data()
    
            if table_name not in self.headers:
                self.headers[table_name] = self.tables[table_name].headers()
    
            table_label = self.create_clickable_label(
                self.table_labels_frame, table_name,
                lambda name=table_name: self.load_selected_table(name)
            )
            table_label.pack(fill='x', pady=2)
            self.table_labels[table_name] = table_label
    
            self.add_custom_hover(table_label)
    
        def delete_table(self):
            """Delete the currently selected table."""
            if not self.current_table_name:
                messagebox.showwarning("No Table Selected", "Please select a table to delete.")
                return
    
            response = messagebox.askyesno(
                "Delete Table",
                f"Are you sure you want to delete the table '{self.current_table_name}'?"
            )
            if response:
                # Remove from the UI
                self.tables[self.current_table_name].destroy()
                self.table_labels[self.current_table_name].destroy()
    
                # Remove from internal storage
                del self.tables[self.current_table_name]
                del self.original_data[self.current_table_name]
                del self.headers[self.current_table_name]
                del self.table_labels[self.current_table_name]
    
                # Remove from disk
                file_path = self.save_file_dir / f"{self.current_table_name}.json"
                if file_path.exists():
                    file_path.unlink()
    
                # Reset current table selection
                self.current_table_name = None
                self.selected_table_label = None
    
        def load_tables(self):
            """Load existing tables from the directory."""
            for file_path in self.save_file_dir.glob("*.json"):
                table_name = file_path.stem
                with file_path.open('r') as file:
                    data = json.load(file)
                    headers = data.pop(0)
                    self.add_table(table_name, data)
                    self.headers[table_name] = headers
    
        def load_selected_table(self, table_name):
            """Display the selected table and hide others."""
            for name, sheet in self.tables.items():
                if name == table_name:
                    sheet.pack(expand=True, fill='both')
                    self.current_table_name = table_name
                    sheet.headers(self.headers[name])
                    self.apply_filter()
    
                    selected_label = self.table_labels[name]
                    selected_label.config(bg=self.BUTTON_COLOR_SELECTED)
                    self.selected_table_label = selected_label
                else:
                    sheet.pack_forget()
                    self.table_labels[name].config(bg=self.BUTTON_COLOR)
    
        def save_data(self, table_name):
            """Save current data of a table to a file."""
            data = [self.headers[table_name]] + self.tables[table_name].get_sheet_data()
            file_path = self.save_file_dir / f"{table_name}.json"
            with file_path.open('w') as file:
                json.dump(data, file)
            print(f"Data for {table_name} saved successfully.")
    
        def apply_filter(self):
            """Apply filtering based on the entered term."""
            if not self.current_table_name:
                return
    
            term = self.filter_entry.get().lower()
            original_data = self.original_data[self.current_table_name]
    
            filtered_data = [
                row for row in original_data
                if any(term in str(cell).lower() for cell in row)
            ]
    
            self.tables[self.current_table_name].set_sheet_data(filtered_data)
    
        def rename_headers(self):
            """Prompt user to rename headers of the currently selected table."""
            if not self.current_table_name:
                messagebox.showwarning("No Table Selected", "Please select a table to rename headers.")
                return
    
            current_headers = self.headers[self.current_table_name]
            new_headers = simpledialog.askstring(
                "Rename Headers",
                "Enter new headers (comma-separated):",
                initialvalue=", ".join(current_headers)
            )
    
            if new_headers:
                header_list = [header.strip() for header in new_headers.split(',')]
                self.headers[self.current_table_name] = header_list
                self.tables[self.current_table_name].headers(header_list)
                self.save_data(self.current_table_name)
    
        def begin_rename(self, table_name):
            """Begin renaming of the table with a double click."""
            label = self.table_labels[table_name]
            
            if self.rename_entry:
                self.rename_entry.destroy()
            
            label.update_idletasks()
            label_x, label_y = label.winfo_x(), label.winfo_y()
            label_width, label_height = label.winfo_width(), label.winfo_height()
            
            self.rename_entry = tk.Entry(
                self.table_labels_frame,
                bg=label.cget("bg"),
                fg=self.BUTTON_TEXT_COLOR,
                relief='flat',
                borderwidth=0,
                highlightthickness=0,
                justify='left'
            )
            self.rename_entry.insert(0, table_name)
            
            self.rename_entry.place(x=label_x, y=label_y, width=label_width, height=label_height)
            self.rename_entry.focus()
            self.rename_entry.select_range(0, tk.END)
            
            self.rename_entry.bind('<Return>', lambda event: self.end_rename(table_name))
            self.rename_entry.bind('<FocusOut>', lambda event: self.cancel_rename())
    
        def end_rename(self, old_name):
            """Finish the renaming process for the specified table."""
            new_name = self.rename_entry.get().strip()
    
            if not new_name:
                messagebox.showerror("Invalid Name", "Table name cannot be empty.")
                self.rename_entry.focus_set()
                return
    
            if new_name in self.tables and new_name != old_name:
                messagebox.showerror("Duplicate Name", f"A table named '{new_name}' already exists.")
                self.rename_entry.focus_set()
                return
    
            if new_name != old_name:
                self.tables[new_name] = self.tables.pop(old_name)
                self.original_data[new_name] = self.original_data.pop(old_name)
                self.headers[new_name] = self.headers.pop(old_name)
    
                self.table_labels[new_name] = self.table_labels.pop(old_name)
                self.table_labels[new_name].config(text=new_name)
    
                if self.selected_table_label == self.table_labels[new_name]:
                    self.selected_table_label = self.table_labels[new_name]
                    self.table_labels[new_name].config(bg=self.BUTTON_COLOR_SELECTED)
    
                current_file = self.save_file_dir / f"{old_name}.json"
                new_file = self.save_file_dir / f"{new_name}.json"
    
                if current_file.exists():
                    current_file.rename(new_file)
    
            self.cancel_rename()
    
        def cancel_rename(self):
            """Cancel the renaming entry."""
            if self.rename_entry:
                self.rename_entry.destroy()
                self.rename_entry = None
    
        def add_custom_hover(self, label):
            """Add custom hover effects to a label."""
            def on_enter(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR_SELECTED)
    
            def on_leave(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR)
    
            label.bind("<Enter>", on_enter)
            label.bind("<Leave>", on_leave)
    
    if __name__ == "__main__":
        set_dpi_awareness()
        root = tk.Tk()
        app = TableApp(root)
        root.mainloop()
    

    Key Changes:

    • Font Setting for tksheet: The Sheet is initialized with the font parameter set to self.default_font, which ensures that the correct tuple format (font_name, font_size) is provided.

    Ensure "Literata" is installed on your system for these settings to work. If you continue to encounter issues, you may want to specify a fallback font such as "Arial" or "Helvetica" that is more universally available.

  15. User

    Traceback (most recent call last): File "D:\Bilder\Python\Database\Database 23 - Kopie.py", line 373, in app = TableApp(root) File "D:\Bilder\Python\Database\Database 23 - Kopie.py", line 38, in init self.load_tables() ~~~~~~~~~~~~~~~~^^ File "D:\Bilder\Python\Database\Database 23 - Kopie.py", line 227, in load_tables self.add_table(table_name, data) ~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^ File "D:\Bilder\Python\Database\Database 23 - Kopie.py", line 164, in add_table self.tables[table_name] = Sheet( ~~~~~^ self.table_frame, ^^^^^^^^^^^^^^^^^ ...<3 lines>... font=self.default_font # Use default font ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ) ^ File "C:\Users\Zarathustra\AppData\Local\Programs\Python\Python313\Lib\site-packages\tksheet\sheet.py", line 351, in init self.MT = MainTable( ~~~~~~~~~^ parent=self, ^^^^^^^^^^^^ ...<20 lines>... all_rows_displayed=all_rows_displayed, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ) ^ File "C:\Users\Zarathustra\AppData\Local\Programs\Python\Python313\Lib\site-packages\tksheet\main_table.py", line 274, in init self.PAR.ops.table_font[2], ~~~~~~~~~~~~~~~~~~~~~~~^^^ IndexError: tuple index out of range

  16. Assistant

    The IndexError: tuple index out of range suggests that the tksheet widget is expecting a tuple of at least three items in the font specification, potentially the font family, size, and a font style (like "normal", "bold", etc.). It seems that the tksheet library is trying to access the third element of the tuple, which would be the style part, but it isn't provided.

    The tksheet library typically uses fonts in the form of (family, size, weight/style), so let's try explicitly setting this correctly.

    Here's how you can modify the font parameter to include a style (e.g., "normal"):

    import tkinter as tk
    from tkinter import simpledialog, messagebox, filedialog
    from tksheet import Sheet
    import json
    import csv
    from pathlib import Path
    import ctypes
    
    def set_dpi_awareness():
        """Enable DPI awareness for high DPI settings."""
        try:
            ctypes.windll.shcore.SetProcessDpiAwareness(1)
        except Exception as e:
            print(f"Error setting DPI awareness: {e}")
    
    class TableApp:
        def __init__(self, root):
            """Initialize the Table Editor application."""
            self.root = root
            self.root.title("Table Editor with Sidebar")
            self.root.geometry("1280x720")
    
            # Set default font
            font_name = "Literata"
            font_size = 12
            font_style = "normal"
            self.default_font = (font_name, font_size, font_style)
            self.root.option_add("*Font", f"{font_name} {font_size}")
    
            # Color configurations
            self.BACKGROUND_COLOR = '#FFFFFF'
            self.SIDEBAR_COLOR = '#F7F8FC'
            self.BUTTON_COLOR = '#F7F8FC'
            self.BUTTON_COLOR_SELECTED = '#EAEDEF'
            self.BUTTON_TEXT_COLOR = '#000000'
    
            self.setup_ui()
            self.initialize_data()
            self.load_tables()
    
        def setup_ui(self):
            """Set up the user interface components."""
            self.create_sidebar()
            self.create_main_frame()
            self.create_header_frame()
            self.create_table_frame()
    
        def create_sidebar(self):
            """Create the sidebar and its components."""
            self.sidebar = tk.Frame(self.root, width=200, bg=self.SIDEBAR_COLOR, bd=0, relief='flat')
            self.sidebar.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.separator = tk.Frame(self.root, width=100, bg=self.BACKGROUND_COLOR, bd=0, relief='flat')
            self.separator.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.new_table_label = self.create_clickable_label(
                self.sidebar, "Create New Table", self.create_new_table)
            self.new_table_label.pack(padx=0, pady=10, fill='x')
    
            self.import_table_label = self.create_clickable_label(
                self.sidebar, "Import Table", self.import_file)
            self.import_table_label.pack(padx=0, pady=10, fill='x')
    
            self.table_labels_frame = tk.Frame(self.sidebar, bg=self.SIDEBAR_COLOR)
            self.table_labels_frame.pack(expand=True, fill='both', padx=0, pady=10)
    
            # Add delete table option
            self.delete_table_label = self.create_clickable_label(
                self.sidebar, "Delete Selected Table", self.delete_table)
            self.delete_table_label.pack(side='bottom', padx=0, pady=10, fill='x')
    
            self.add_custom_hover(self.new_table_label)
            self.add_custom_hover(self.import_table_label)
            self.add_custom_hover(self.delete_table_label)
    
        def create_main_frame(self):
            """Create the main frame of the application."""
            self.main_frame = tk.Frame(self.root)
            self.main_frame.pack(expand=True, fill='both', side='right')
    
        def create_header_frame(self):
            """Create the header frame with filter and rename options."""
            self.header_frame = tk.Frame(self.main_frame, height=50, bg=self.BACKGROUND_COLOR)
            self.header_frame.pack(fill='x')
    
            self.filter_label = tk.Label(self.header_frame, text="Filter:", bg=self.BACKGROUND_COLOR, anchor="w")
            self.filter_label.pack(side='left', padx=5, pady=10)
    
            self.filter_entry = tk.Entry(self.header_frame)
            self.filter_entry.pack(side='left', padx=5, pady=10)
            self.filter_entry.bind("<KeyRelease>", lambda event: self.apply_filter())
    
            self.rename_headers_label = self.create_clickable_label(
                self.header_frame, "Rename Headers", self.rename_headers)
            self.rename_headers_label.pack(side='left', padx=5, pady=10, fill='x')
    
        def create_table_frame(self):
            """Create the frame to hold the table."""
            self.table_frame = tk.Frame(self.main_frame, bg=self.BACKGROUND_COLOR)
            self.table_frame.pack(expand=True, fill='both')
    
        def initialize_data(self):
            """Initialize data structures and variables."""
            self.save_file_dir = Path("tables")
            self.tables = {}
            self.table_labels = {}
            self.original_data = {}
            self.headers = {}
            self.current_table_name = None
            self.rename_entry = None
            self.selected_table_label = None
    
            self.save_file_dir.mkdir(exist_ok=True)
    
        def create_clickable_label(self, parent, text, command, allow_rename=True):
            """Create a clickable Label widget."""
            label = tk.Label(
                parent, text=text, bg=self.BUTTON_COLOR, fg=self.BUTTON_TEXT_COLOR,
                borderwidth=0, relief='flat', cursor='arrow', anchor='w',
                padx=10, pady=5
            )
            label.bind("<Button-1>", lambda e: command())
            if allow_rename:
                label.bind("<Double-1>", lambda e: self.begin_rename(text))
            return label
    
        def create_new_table(self):
            """Create a new table and add it to the available tables list."""
            table_name = f"Table {len(self.tables) + 1}"
            self.add_table(table_name)
            self.load_selected_table(table_name)
    
        def import_file(self):
            """Import a CSV or JSON file to create a new table."""
            file_path = filedialog.askopenfilename(
                title="Open File",
                filetypes=[("CSV files", "*.csv"), ("JSON files", "*.json")]
            )
            if not file_path:
                return
    
            if file_path.endswith('.csv'):
                with open(file_path, newline='', encoding='utf-8') as csvfile:
                    reader = csv.reader(csvfile)
                    data = list(reader)
                headers, table_data = data[0], data[1:]
    
            elif file_path.endswith('.json'):
                with open(file_path, 'r', encoding='utf-8') as jsonfile:
                    data = json.load(jsonfile)
                headers, table_data = data[0], data[1:]
    
            else:
                messagebox.showerror("Unsupported File", "The selected file format is not supported.")
                return
    
            table_name = Path(file_path).stem
            self.add_table(table_name, table_data)
            self.headers[table_name] = headers
            self.load_selected_table(table_name)
    
        def add_table(self, table_name, data=None):
            """Add a table to the UI and internal storage."""
            default_data = [["" for _ in range(5)] for _ in range(10)]
            self.tables[table_name] = Sheet(
                self.table_frame,
                data=data or default_data,
                show_table=True,
                headers=None,
                font=self.default_font  # Use default font
            )
            self.tables[table_name].enable_bindings()
            self.tables[table_name].extra_bindings([
                ("end_edit_cell", lambda event, tn=table_name: self.save_data(tn)),
            ])
            self.tables[table_name].pack_forget()
            self.original_data[table_name] = self.tables[table_name].get_sheet_data()
    
            if table_name not in self.headers:
                self.headers[table_name] = self.tables[table_name].headers()
    
            table_label = self.create_clickable_label(
                self.table_labels_frame, table_name,
                lambda name=table_name: self.load_selected_table(name)
            )
            table_label.pack(fill='x', pady=2)
            self.table_labels[table_name] = table_label
    
            self.add_custom_hover(table_label)
    
        def delete_table(self):
            """Delete the currently selected table."""
            if not self.current_table_name:
                messagebox.showwarning("No Table Selected", "Please select a table to delete.")
                return
    
            response = messagebox.askyesno(
                "Delete Table",
                f"Are you sure you want to delete the table '{self.current_table_name}'?"
            )
            if response:
                # Remove from the UI
                self.tables[self.current_table_name].destroy()
                self.table_labels[self.current_table_name].destroy()
    
                # Remove from internal storage
                del self.tables[self.current_table_name]
                del self.original_data[self.current_table_name]
                del self.headers[self.current_table_name]
                del self.table_labels[self.current_table_name]
    
                # Remove from disk
                file_path = self.save_file_dir / f"{self.current_table_name}.json"
                if file_path.exists():
                    file_path.unlink()
    
                # Reset current table selection
                self.current_table_name = None
                self.selected_table_label = None
    
        def load_tables(self):
            """Load existing tables from the directory."""
            for file_path in self.save_file_dir.glob("*.json"):
                table_name = file_path.stem
                with file_path.open('r') as file:
                    data = json.load(file)
                    headers = data.pop(0)
                    self.add_table(table_name, data)
                    self.headers[table_name] = headers
    
        def load_selected_table(self, table_name):
            """Display the selected table and hide others."""
            for name, sheet in self.tables.items():
                if name == table_name:
                    sheet.pack(expand=True, fill='both')
                    self.current_table_name = table_name
                    sheet.headers(self.headers[name])
                    self.apply_filter()
    
                    selected_label = self.table_labels[name]
                    selected_label.config(bg=self.BUTTON_COLOR_SELECTED)
                    self.selected_table_label = selected_label
                else:
                    sheet.pack_forget()
                    self.table_labels[name].config(bg=self.BUTTON_COLOR)
    
        def save_data(self, table_name):
            """Save current data of a table to a file."""
            data = [self.headers[table_name]] + self.tables[table_name].get_sheet_data()
            file_path = self.save_file_dir / f"{table_name}.json"
            with file_path.open('w') as file:
                json.dump(data, file)
            print(f"Data for {table_name} saved successfully.")
    
        def apply_filter(self):
            """Apply filtering based on the entered term."""
            if not self.current_table_name:
                return
    
            term = self.filter_entry.get().lower()
            original_data = self.original_data[self.current_table_name]
    
            filtered_data = [
                row for row in original_data
                if any(term in str(cell).lower() for cell in row)
            ]
    
            self.tables[self.current_table_name].set_sheet_data(filtered_data)
    
        def rename_headers(self):
            """Prompt user to rename headers of the currently selected table."""
            if not self.current_table_name:
                messagebox.showwarning("No Table Selected", "Please select a table to rename headers.")
                return
    
            current_headers = self.headers[self.current_table_name]
            new_headers = simpledialog.askstring(
                "Rename Headers",
                "Enter new headers (comma-separated):",
                initialvalue=", ".join(current_headers)
            )
    
            if new_headers:
                header_list = [header.strip() for header in new_headers.split(',')]
                self.headers[self.current_table_name] = header_list
                self.tables[self.current_table_name].headers(header_list)
                self.save_data(self.current_table_name)
    
        def begin_rename(self, table_name):
            """Begin renaming of the table with a double click."""
            label = self.table_labels[table_name]
            
            if self.rename_entry:
                self.rename_entry.destroy()
            
            label.update_idletasks()
            label_x, label_y = label.winfo_x(), label.winfo_y()
            label_width, label_height = label.winfo_width(), label.winfo_height()
            
            self.rename_entry = tk.Entry(
                self.table_labels_frame,
                bg=label.cget("bg"),
                fg=self.BUTTON_TEXT_COLOR,
                relief='flat',
                borderwidth=0,
                highlightthickness=0,
                justify='left'
            )
            self.rename_entry.insert(0, table_name)
            
            self.rename_entry.place(x=label_x, y=label_y, width=label_width, height=label_height)
            self.rename_entry.focus()
            self.rename_entry.select_range(0, tk.END)
            
            self.rename_entry.bind('<Return>', lambda event: self.end_rename(table_name))
            self.rename_entry.bind('<FocusOut>', lambda event: self.cancel_rename())
    
        def end_rename(self, old_name):
            """Finish the renaming process for the specified table."""
            new_name = self.rename_entry.get().strip()
    
            if not new_name:
                messagebox.showerror("Invalid Name", "Table name cannot be empty.")
                self.rename_entry.focus_set()
                return
    
            if new_name in self.tables and new_name != old_name:
                messagebox.showerror("Duplicate Name", f"A table named '{new_name}' already exists.")
                self.rename_entry.focus_set()
                return
    
            if new_name != old_name:
                self.tables[new_name] = self.tables.pop(old_name)
                self.original_data[new_name] = self.original_data.pop(old_name)
                self.headers[new_name] = self.headers.pop(old_name)
    
                self.table_labels[new_name] = self.table_labels.pop(old_name)
                self.table_labels[new_name].config(text=new_name)
    
                if self.selected_table_label == self.table_labels[new_name]:
                    self.selected_table_label = self.table_labels[new_name]
                    self.table_labels[new_name].config(bg=self.BUTTON_COLOR_SELECTED)
    
                current_file = self.save_file_dir / f"{old_name}.json"
                new_file = self.save_file_dir / f"{new_name}.json"
    
                if current_file.exists():
                    current_file.rename(new_file)
    
            self.cancel_rename()
    
        def cancel_rename(self):
            """Cancel the renaming entry."""
            if self.rename_entry:
                self.rename_entry.destroy()
                self.rename_entry = None
    
        def add_custom_hover(self, label):
            """Add custom hover effects to a label."""
            def on_enter(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR_SELECTED)
    
            def on_leave(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR)
    
            label.bind("<Enter>", on_enter)
            label.bind("<Leave>", on_leave)
    
    if __name__ == "__main__":
        set_dpi_awareness()
        root = tk.Tk()
        app = TableApp(root)
        root.mainloop()
    

    Key Change:

    • Font Style Inclusion: The font tuple now includes a third element ("normal" style) to avoid the IndexError.

    Ensure the "Literata" font is available on your system; else replace it with a system-recognized font. If the error persists, using a more generic font (like "Arial") for troubleshooting might help isolate font-specific issues.

  17. User

    Set the font color for all to TEXT_COLOR = '#000000'

  18. Assistant

    To set the font color for all text elements in the application to #000000, you can use a variable, TEXT_COLOR, to ensure consistency across all widgets. You just need to make sure that this color is applied to every widget that displays text.

    Here's how you can update the code to set this font color consistently:

    import tkinter as tk
    from tkinter import simpledialog, messagebox, filedialog
    from tksheet import Sheet
    import json
    import csv
    from pathlib import Path
    import ctypes
    
    def set_dpi_awareness():
        """Enable DPI awareness for high DPI settings."""
        try:
            ctypes.windll.shcore.SetProcessDpiAwareness(1)
        except Exception as e:
            print(f"Error setting DPI awareness: {e}")
    
    class TableApp:
        def __init__(self, root):
            """Initialize the Table Editor application."""
            self.root = root
            self.root.title("Table Editor with Sidebar")
            self.root.geometry("1280x720")
    
            # Font and color configurations
            font_name = "Literata"
            font_size = 12
            font_style = "normal"
            self.default_font = (font_name, font_size, font_style)
            self.TEXT_COLOR = '#000000'
            self.root.option_add("*Font", f"{font_name} {font_size}")
    
            # Color scheme for backgrounds and buttons
            self.BACKGROUND_COLOR = '#FFFFFF'
            self.SIDEBAR_COLOR = '#F7F8FC'
            self.BUTTON_COLOR = '#F7F8FC'
            self.BUTTON_COLOR_SELECTED = '#EAEDEF'
    
            self.setup_ui()
            self.initialize_data()
            self.load_tables()
    
        def setup_ui(self):
            """Set up the user interface components."""
            self.create_sidebar()
            self.create_main_frame()
            self.create_header_frame()
            self.create_table_frame()
    
        def create_sidebar(self):
            """Create the sidebar and its components."""
            self.sidebar = tk.Frame(self.root, width=200, bg=self.SIDEBAR_COLOR, bd=0, relief='flat')
            self.sidebar.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.separator = tk.Frame(self.root, width=100, bg=self.BACKGROUND_COLOR, bd=0, relief='flat')
            self.separator.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.new_table_label = self.create_clickable_label(
                self.sidebar, "Create New Table", self.create_new_table)
            self.new_table_label.pack(padx=0, pady=10, fill='x')
    
            self.import_table_label = self.create_clickable_label(
                self.sidebar, "Import Table", self.import_file)
            self.import_table_label.pack(padx=0, pady=10, fill='x')
    
            self.table_labels_frame = tk.Frame(self.sidebar, bg=self.SIDEBAR_COLOR)
            self.table_labels_frame.pack(expand=True, fill='both', padx=0, pady=10)
    
            # Add delete table option
            self.delete_table_label = self.create_clickable_label(
                self.sidebar, "Delete Selected Table", self.delete_table)
            self.delete_table_label.pack(side='bottom', padx=0, pady=10, fill='x')
    
            self.add_custom_hover(self.new_table_label)
            self.add_custom_hover(self.import_table_label)
            self.add_custom_hover(self.delete_table_label)
    
        def create_main_frame(self):
            """Create the main frame of the application."""
            self.main_frame = tk.Frame(self.root)
            self.main_frame.pack(expand=True, fill='both', side='right')
    
        def create_header_frame(self):
            """Create the header frame with filter and rename options."""
            self.header_frame = tk.Frame(self.main_frame, height=50, bg=self.BACKGROUND_COLOR)
            self.header_frame.pack(fill='x')
    
            self.filter_label = tk.Label(self.header_frame, text="Filter:", bg=self.BACKGROUND_COLOR, fg=self.TEXT_COLOR, anchor="w")
            self.filter_label.pack(side='left', padx=5, pady=10)
    
            self.filter_entry = tk.Entry(self.header_frame, fg=self.TEXT_COLOR)
            self.filter_entry.pack(side='left', padx=5, pady=10)
            self.filter_entry.bind("<KeyRelease>", lambda event: self.apply_filter())
    
            self.rename_headers_label = self.create_clickable_label(
                self.header_frame, "Rename Headers", self.rename_headers)
            self.rename_headers_label.pack(side='left', padx=5, pady=10, fill='x')
    
        def create_table_frame(self):
            """Create the frame to hold the table."""
            self.table_frame = tk.Frame(self.main_frame, bg=self.BACKGROUND_COLOR)
            self.table_frame.pack(expand=True, fill='both')
    
        def initialize_data(self):
            """Initialize data structures and variables."""
            self.save_file_dir = Path("tables")
            self.tables = {}
            self.table_labels = {}
            self.original_data = {}
            self.headers = {}
            self.current_table_name = None
            self.rename_entry = None
            self.selected_table_label = None
    
            self.save_file_dir.mkdir(exist_ok=True)
    
        def create_clickable_label(self, parent, text, command, allow_rename=True):
            """Create a clickable Label widget."""
            label = tk.Label(
                parent, text=text, bg=self.BUTTON_COLOR, fg=self.TEXT_COLOR,
                borderwidth=0, relief='flat', cursor='arrow', anchor='w',
                padx=10, pady=5
            )
            label.bind("<Button-1>", lambda e: command())
            if allow_rename:
                label.bind("<Double-1>", lambda e: self.begin_rename(text))
            return label
    
        def create_new_table(self):
            """Create a new table and add it to the available tables list."""
            table_name = f"Table {len(self.tables) + 1}"
            self.add_table(table_name)
            self.load_selected_table(table_name)
    
        def import_file(self):
            """Import a CSV or JSON file to create a new table."""
            file_path = filedialog.askopenfilename(
                title="Open File",
                filetypes=[("CSV files", "*.csv"), ("JSON files", "*.json")]
            )
            if not file_path:
                return
    
            if file_path.endswith('.csv'):
                with open(file_path, newline='', encoding='utf-8') as csvfile:
                    reader = csv.reader(csvfile)
                    data = list(reader)
                headers, table_data = data[0], data[1:]
    
            elif file_path.endswith('.json'):
                with open(file_path, 'r', encoding='utf-8') as jsonfile:
                    data = json.load(jsonfile)
                headers, table_data = data[0], data[1:]
    
            else:
                messagebox.showerror("Unsupported File", "The selected file format is not supported.")
                return
    
            table_name = Path(file_path).stem
            self.add_table(table_name, table_data)
            self.headers[table_name] = headers
            self.load_selected_table(table_name)
    
        def add_table(self, table_name, data=None):
            """Add a table to the UI and internal storage."""
            default_data = [["" for _ in range(5)] for _ in range(10)]
            self.tables[table_name] = Sheet(
                self.table_frame,
                data=data or default_data,
                show_table=True,
                headers=None,
                font=self.default_font  # Use default font
            )
            self.tables[table_name].enable_bindings()
            self.tables[table_name].extra_bindings([
                ("end_edit_cell", lambda event, tn=table_name: self.save_data(tn)),
            ])
            self.tables[table_name].pack_forget()
            self.original_data[table_name] = self.tables[table_name].get_sheet_data()
    
            if table_name not in self.headers:
                self.headers[table_name] = self.tables[table_name].headers()
    
            table_label = self.create_clickable_label(
                self.table_labels_frame, table_name,
                lambda name=table_name: self.load_selected_table(name)
            )
            table_label.pack(fill='x', pady=2)
            self.table_labels[table_name] = table_label
    
            self.add_custom_hover(table_label)
    
        def delete_table(self):
            """Delete the currently selected table."""
            if not self.current_table_name:
                messagebox.showwarning("No Table Selected", "Please select a table to delete.")
                return
    
            response = messagebox.askyesno(
                "Delete Table",
                f"Are you sure you want to delete the table '{self.current_table_name}'?"
            )
            if response:
                # Remove from the UI
                self.tables[self.current_table_name].destroy()
                self.table_labels[self.current_table_name].destroy()
    
                # Remove from internal storage
                del self.tables[self.current_table_name]
                del self.original_data[self.current_table_name]
                del self.headers[self.current_table_name]
                del self.table_labels[self.current_table_name]
    
                # Remove from disk
                file_path = self.save_file_dir / f"{self.current_table_name}.json"
                if file_path.exists():
                    file_path.unlink()
    
                # Reset current table selection
                self.current_table_name = None
                self.selected_table_label = None
    
        def load_tables(self):
            """Load existing tables from the directory."""
            for file_path in self.save_file_dir.glob("*.json"):
                table_name = file_path.stem
                with file_path.open('r') as file:
                    data = json.load(file)
                    headers = data.pop(0)
                    self.add_table(table_name, data)
                    self.headers[table_name] = headers
    
        def load_selected_table(self, table_name):
            """Display the selected table and hide others."""
            for name, sheet in self.tables.items():
                if name == table_name:
                    sheet.pack(expand=True, fill='both')
                    self.current_table_name = table_name
                    sheet.headers(self.headers[name])
                    self.apply_filter()
    
                    selected_label = self.table_labels[name]
                    selected_label.config(bg=self.BUTTON_COLOR_SELECTED)
                    self.selected_table_label = selected_label
                else:
                    sheet.pack_forget()
                    self.table_labels[name].config(bg=self.BUTTON_COLOR)
    
        def save_data(self, table_name):
            """Save current data of a table to a file."""
            data = [self.headers[table_name]] + self.tables[table_name].get_sheet_data()
            file_path = self.save_file_dir / f"{table_name}.json"
            with file_path.open('w') as file:
                json.dump(data, file)
            print(f"Data for {table_name} saved successfully.")
    
        def apply_filter(self):
            """Apply filtering based on the entered term."""
            if not self.current_table_name:
                return
    
            term = self.filter_entry.get().lower()
            original_data = self.original_data[self.current_table_name]
    
            filtered_data = [
                row for row in original_data
                if any(term in str(cell).lower() for cell in row)
            ]
    
            self.tables[self.current_table_name].set_sheet_data(filtered_data)
    
        def rename_headers(self):
            """Prompt user to rename headers of the currently selected table."""
            if not self.current_table_name:
                messagebox.showwarning("No Table Selected", "Please select a table to rename headers.")
                return
    
            current_headers = self.headers[self.current_table_name]
            new_headers = simpledialog.askstring(
                "Rename Headers",
                "Enter new headers (comma-separated):",
                initialvalue=", ".join(current_headers)
            )
    
            if new_headers:
                header_list = [header.strip() for header in new_headers.split(',')]
                self.headers[self.current_table_name] = header_list
                self.tables[self.current_table_name].headers(header_list)
                self.save_data(self.current_table_name)
    
        def begin_rename(self, table_name):
            """Begin renaming of the table with a double click."""
            label = self.table_labels[table_name]
            
            if self.rename_entry:
                self.rename_entry.destroy()
            
            label.update_idletasks()
            label_x, label_y = label.winfo_x(), label.winfo_y()
            label_width, label_height = label.winfo_width(), label.winfo_height()
            
            self.rename_entry = tk.Entry(
                self.table_labels_frame,
                bg=label.cget("bg"),
                fg=self.TEXT_COLOR,
                relief='flat',
                borderwidth=0,
                highlightthickness=0,
                justify='left'
            )
            self.rename_entry.insert(0, table_name)
            
            self.rename_entry.place(x=label_x, y=label_y, width=label_width, height=label_height)
            self.rename_entry.focus()
            self.rename_entry.select_range(0, tk.END)
            
            self.rename_entry.bind('<Return>', lambda event: self.end_rename(table_name))
            self.rename_entry.bind('<FocusOut>', lambda event: self.cancel_rename())
    
        def end_rename(self, old_name):
            """Finish the renaming process for the specified table."""
            new_name = self.rename_entry.get().strip()
    
            if not new_name:
                messagebox.showerror("Invalid Name", "Table name cannot be empty.")
                self.rename_entry.focus_set()
                return
    
            if new_name in self.tables and new_name != old_name:
                messagebox.showerror("Duplicate Name", f"A table named '{new_name}' already exists.")
                self.rename_entry.focus_set()
                return
    
            if new_name != old_name:
                self.tables[new_name] = self.tables.pop(old_name)
                self.original_data[new_name] = self.original_data.pop(old_name)
                self.headers[new_name] = self.headers.pop(old_name)
    
                self.table_labels[new_name] = self.table_labels.pop(old_name)
                self.table_labels[new_name].config(text=new_name)
    
                if self.selected_table_label == self.table_labels[new_name]:
                    self.selected_table_label = self.table_labels[new_name]
                    self.table_labels[new_name].config(bg=self.BUTTON_COLOR_SELECTED)
    
                current_file = self.save_file_dir / f"{old_name}.json"
                new_file = self.save_file_dir / f"{new_name}.json"
    
                if current_file.exists():
                    current_file.rename(new_file)
    
            self.cancel_rename()
    
        def cancel_rename(self):
            """Cancel the renaming entry."""
            if self.rename_entry:
                self.rename_entry.destroy()
                self.rename_entry = None
    
        def add_custom_hover(self, label):
            """Add custom hover effects to a label."""
            def on_enter(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR_SELECTED)
    
            def on_leave(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR)
    
            label.bind("<Enter>", on_enter)
            label.bind("<Leave>", on_leave)
    
    if __name__ == "__main__":
        set_dpi_awareness()
        root = tk.Tk()
        app = TableApp(root)
        root.mainloop()
    

    Key Changes:

    • Added a TEXT_COLOR constant set to '#000000'.
    • Updated all tk.Label, tk.Entry, and the Sheet initialization to use this text color: fg=self.TEXT_COLOR.
    • Ensured this color setting is consistently used across all text elements.

    This should ensure that the text in your application consistently uses the specified text color.

  19. User

    set the font color also for tksheet

  20. Assistant

    To set the text color for tksheet, you can utilize the display_columns and header_font parameters for headers and cells when initializing the Sheet widget. However, to apply a consistent text color throughout the tksheet cells, you'll need to directly manipulate its options.

    Here's how you can configure the Sheet widget to use a consistent text color across your application, including for tksheet contents:

    import tkinter as tk
    from tkinter import simpledialog, messagebox, filedialog
    from tksheet import Sheet
    import json
    import csv
    from pathlib import Path
    import ctypes
    
    def set_dpi_awareness():
        """Enable DPI awareness for high DPI settings."""
        try:
            ctypes.windll.shcore.SetProcessDpiAwareness(1)
        except Exception as e:
            print(f"Error setting DPI awareness: {e}")
    
    class TableApp:
        def __init__(self, root):
            """Initialize the Table Editor application."""
            self.root = root
            self.root.title("Table Editor with Sidebar")
            self.root.geometry("1280x720")
    
            # Font and color configurations
            font_name = "Literata"
            font_size = 12
            font_style = "normal"
            self.default_font = (font_name, font_size, font_style)
            self.TEXT_COLOR = '#000000'
            self.root.option_add("*Font", f"{font_name} {font_size}")
    
            # Color scheme for backgrounds and buttons
            self.BACKGROUND_COLOR = '#FFFFFF'
            self.SIDEBAR_COLOR = '#F7F8FC'
            self.BUTTON_COLOR = '#F7F8FC'
            self.BUTTON_COLOR_SELECTED = '#EAEDEF'
    
            self.setup_ui()
            self.initialize_data()
            self.load_tables()
    
        def setup_ui(self):
            """Set up the user interface components."""
            self.create_sidebar()
            self.create_main_frame()
            self.create_header_frame()
            self.create_table_frame()
    
        def create_sidebar(self):
            """Create the sidebar and its components."""
            self.sidebar = tk.Frame(self.root, width=200, bg=self.SIDEBAR_COLOR, bd=0, relief='flat')
            self.sidebar.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.separator = tk.Frame(self.root, width=100, bg=self.BACKGROUND_COLOR, bd=0, relief='flat')
            self.separator.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.new_table_label = self.create_clickable_label(
                self.sidebar, "Create New Table", self.create_new_table)
            self.new_table_label.pack(padx=0, pady=10, fill='x')
    
            self.import_table_label = self.create_clickable_label(
                self.sidebar, "Import Table", self.import_file)
            self.import_table_label.pack(padx=0, pady=10, fill='x')
    
            self.table_labels_frame = tk.Frame(self.sidebar, bg=self.SIDEBAR_COLOR)
            self.table_labels_frame.pack(expand=True, fill='both', padx=0, pady=10)
    
            # Add delete table option
            self.delete_table_label = self.create_clickable_label(
                self.sidebar, "Delete Selected Table", self.delete_table)
            self.delete_table_label.pack(side='bottom', padx=0, pady=10, fill='x')
    
            self.add_custom_hover(self.new_table_label)
            self.add_custom_hover(self.import_table_label)
            self.add_custom_hover(self.delete_table_label)
    
        def create_main_frame(self):
            """Create the main frame of the application."""
            self.main_frame = tk.Frame(self.root)
            self.main_frame.pack(expand=True, fill='both', side='right')
    
        def create_header_frame(self):
            """Create the header frame with filter and rename options."""
            self.header_frame = tk.Frame(self.main_frame, height=50, bg=self.BACKGROUND_COLOR)
            self.header_frame.pack(fill='x')
    
            self.filter_label = tk.Label(self.header_frame, text="Filter:", bg=self.BACKGROUND_COLOR, fg=self.TEXT_COLOR, anchor="w")
            self.filter_label.pack(side='left', padx=5, pady=10)
    
            self.filter_entry = tk.Entry(self.header_frame, fg=self.TEXT_COLOR)
            self.filter_entry.pack(side='left', padx=5, pady=10)
            self.filter_entry.bind("<KeyRelease>", lambda event: self.apply_filter())
    
            self.rename_headers_label = self.create_clickable_label(
                self.header_frame, "Rename Headers", self.rename_headers)
            self.rename_headers_label.pack(side='left', padx=5, pady=10, fill='x')
    
        def create_table_frame(self):
            """Create the frame to hold the table."""
            self.table_frame = tk.Frame(self.main_frame, bg=self.BACKGROUND_COLOR)
            self.table_frame.pack(expand=True, fill='both')
    
        def initialize_data(self):
            """Initialize data structures and variables."""
            self.save_file_dir = Path("tables")
            self.tables = {}
            self.table_labels = {}
            self.original_data = {}
            self.headers = {}
            self.current_table_name = None
            self.rename_entry = None
            self.selected_table_label = None
    
            self.save_file_dir.mkdir(exist_ok=True)
    
        def create_clickable_label(self, parent, text, command, allow_rename=True):
            """Create a clickable Label widget."""
            label = tk.Label(
                parent, text=text, bg=self.BUTTON_COLOR, fg=self.TEXT_COLOR,
                borderwidth=0, relief='flat', cursor='arrow', anchor='w',
                padx=10, pady=5
            )
            label.bind("<Button-1>", lambda e: command())
            if allow_rename:
                label.bind("<Double-1>", lambda e: self.begin_rename(text))
            return label
    
        def create_new_table(self):
            """Create a new table and add it to the available tables list."""
            table_name = f"Table {len(self.tables) + 1}"
            self.add_table(table_name)
            self.load_selected_table(table_name)
    
        def import_file(self):
            """Import a CSV or JSON file to create a new table."""
            file_path = filedialog.askopenfilename(
                title="Open File",
                filetypes=[("CSV files", "*.csv"), ("JSON files", "*.json")]
            )
            if not file_path:
                return
    
            if file_path.endswith('.csv'):
                with open(file_path, newline='', encoding='utf-8') as csvfile:
                    reader = csv.reader(csvfile)
                    data = list(reader)
                headers, table_data = data[0], data[1:]
    
            elif file_path.endswith('.json'):
                with open(file_path, 'r', encoding='utf-8') as jsonfile:
                    data = json.load(jsonfile)
                headers, table_data = data[0], data[1:]
    
            else:
                messagebox.showerror("Unsupported File", "The selected file format is not supported.")
                return
    
            table_name = Path(file_path).stem
            self.add_table(table_name, table_data)
            self.headers[table_name] = headers
            self.load_selected_table(table_name)
    
        def add_table(self, table_name, data=None):
            """Add a table to the UI and internal storage."""
            default_data = [["" for _ in range(5)] for _ in range(10)]
            self.tables[table_name] = Sheet(
                self.table_frame,
                data=data or default_data,
                show_table=True,
                headers=None,
                font=self.default_font,  # Use default font
                header_font=self.default_font,  # Set the header font
            )
            
            self.tables[table_name].set_options(table_fg=self.TEXT_COLOR, header_fg=self.TEXT_COLOR)
    
            self.tables[table_name].enable_bindings()
            self.tables[table_name].extra_bindings([
                ("end_edit_cell", lambda event, tn=table_name: self.save_data(tn)),
            ])
            self.tables[table_name].pack_forget()
            self.original_data[table_name] = self.tables[table_name].get_sheet_data()
    
            if table_name not in self.headers:
                self.headers[table_name] = self.tables[table_name].headers()
    
            table_label = self.create_clickable_label(
                self.table_labels_frame, table_name,
                lambda name=table_name: self.load_selected_table(name)
            )
            table_label.pack(fill='x', pady=2)
            self.table_labels[table_name] = table_label
    
            self.add_custom_hover(table_label)
    
        def delete_table(self):
            """Delete the currently selected table."""
            if not self.current_table_name:
                messagebox.showwarning("No Table Selected", "Please select a table to delete.")
                return
    
            response = messagebox.askyesno(
                "Delete Table",
                f"Are you sure you want to delete the table '{self.current_table_name}'?"
            )
            if response:
                # Remove from the UI
                self.tables[self.current_table_name].destroy()
                self.table_labels[self.current_table_name].destroy()
    
                # Remove from internal storage
                del self.tables[self.current_table_name]
                del self.original_data[self.current_table_name]
                del self.headers[self.current_table_name]
                del self.table_labels[self.current_table_name]
    
                # Remove from disk
                file_path = self.save_file_dir / f"{self.current_table_name}.json"
                if file_path.exists():
                    file_path.unlink()
    
                # Reset current table selection
                self.current_table_name = None
                self.selected_table_label = None
    
        def load_tables(self):
            """Load existing tables from the directory."""
            for file_path in self.save_file_dir.glob("*.json"):
                table_name = file_path.stem
                with file_path.open('r') as file:
                    data = json.load(file)
                    headers = data.pop(0)
                    self.add_table(table_name, data)
                    self.headers[table_name] = headers
    
        def load_selected_table(self, table_name):
            """Display the selected table and hide others."""
            for name, sheet in self.tables.items():
                if name == table_name:
                    sheet.pack(expand=True, fill='both')
                    self.current_table_name = table_name
                    sheet.headers(self.headers[name])
                    self.apply_filter()
    
                    selected_label = self.table_labels[name]
                    selected_label.config(bg=self.BUTTON_COLOR_SELECTED)
                    self.selected_table_label = selected_label
                else:
                    sheet.pack_forget()
                    self.table_labels[name].config(bg=self.BUTTON_COLOR)
    
        def save_data(self, table_name):
            """Save current data of a table to a file."""
            data = [self.headers[table_name]] + self.tables[table_name].get_sheet_data()
            file_path = self.save_file_dir / f"{table_name}.json"
            with file_path.open('w') as file:
                json.dump(data, file)
            print(f"Data for {table_name} saved successfully.")
    
        def apply_filter(self):
            """Apply filtering based on the entered term."""
            if not self.current_table_name:
                return
    
            term = self.filter_entry.get().lower()
            original_data = self.original_data[self.current_table_name]
    
            filtered_data = [
                row for row in original_data
                if any(term in str(cell).lower() for cell in row)
            ]
    
            self.tables[self.current_table_name].set_sheet_data(filtered_data)
    
        def rename_headers(self):
            """Prompt user to rename headers of the currently selected table."""
            if not self.current_table_name:
                messagebox.showwarning("No Table Selected", "Please select a table to rename headers.")
                return
    
            current_headers = self.headers[self.current_table_name]
            new_headers = simpledialog.askstring(
                "Rename Headers",
                "Enter new headers (comma-separated):",
                initialvalue=", ".join(current_headers)
            )
    
            if new_headers:
                header_list = [header.strip() for header in new_headers.split(',')]
                self.headers[self.current_table_name] = header_list
                self.tables[self.current_table_name].headers(header_list)
                self.save_data(self.current_table_name)
    
        def begin_rename(self, table_name):
            """Begin renaming of the table with a double click."""
            label = self.table_labels[table_name]
            
            if self.rename_entry:
                self.rename_entry.destroy()
            
            label.update_idletasks()
            label_x, label_y = label.winfo_x(), label.winfo_y()
            label_width, label_height = label.winfo_width(), label.winfo_height()
            
            self.rename_entry = tk.Entry(
                self.table_labels_frame,
                bg=label.cget("bg"),
                fg=self.TEXT_COLOR,
                relief='flat',
                borderwidth=0,
                highlightthickness=0,
                justify='left'
            )
            self.rename_entry.insert(0, table_name)
            
            self.rename_entry.place(x=label_x, y=label_y, width=label_width, height=label_height)
            self.rename_entry.focus()
            self.rename_entry.select_range(0, tk.END)
            
            self.rename_entry.bind('<Return>', lambda event: self.end_rename(table_name))
            self.rename_entry.bind('<FocusOut>', lambda event: self.cancel_rename())
    
        def end_rename(self, old_name):
            """Finish the renaming process for the specified table."""
            new_name = self.rename_entry.get().strip()
    
            if not new_name:
                messagebox.showerror("Invalid Name", "Table name cannot be empty.")
                self.rename_entry.focus_set()
                return
    
            if new_name in self.tables and new_name != old_name:
                messagebox.showerror("Duplicate Name", f"A table named '{new_name}' already exists.")
                self.rename_entry.focus_set()
                return
    
            if new_name != old_name:
                self.tables[new_name] = self.tables.pop(old_name)
                self.original_data[new_name] = self.original_data.pop(old_name)
                self.headers[new_name] = self.headers.pop(old_name)
    
                self.table_labels[new_name] = self.table_labels.pop(old_name)
                self.table_labels[new_name].config(text=new_name)
    
                if self.selected_table_label == self.table_labels[new_name]:
                    self.selected_table_label = self.table_labels[new_name]
                    self.table_labels[new_name].config(bg=self.BUTTON_COLOR_SELECTED)
    
                current_file = self.save_file_dir / f"{old_name}.json"
                new_file = self.save_file_dir / f"{new_name}.json"
    
                if current_file.exists():
                    current_file.rename(new_file)
    
            self.cancel_rename()
    
        def cancel_rename(self):
            """Cancel the renaming entry."""
            if self.rename_entry:
                self.rename_entry.destroy()
                self.rename_entry = None
    
        def add_custom_hover(self, label):
            """Add custom hover effects to a label."""
            def on_enter(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR_SELECTED)
    
            def on_leave(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR)
    
            label.bind("<Enter>", on_enter)
            label.bind("<Leave>", on_leave)
    
    if __name__ == "__main__":
        set_dpi_awareness()
        root = tk.Tk()
        app = TableApp(root)
        root.mainloop()
    

    Key Changes:

    • Font and Color for tksheet: The Sheet widget has been updated with set_options(table_fg=self.TEXT_COLOR, header_fg=self.TEXT_COLOR) to set both the header and cell font colors to #000000.
    • The font and header_font in the Sheet initialization ensure both header and cell fonts are consistent with your chosen style.

    This should successfully apply the text color throughout your application's tksheet widget. If you need further customization for specific areas (like specific cells or headers), you might directly manipulate those areas using tksheet's provided methods.

  21. User

    The slect all rows and tables button in tksheet has the same color as the sidebar please change the color of this button to white

  22. Assistant

    To change the color of the "Select All" button in tksheet (which usually appears at the intersection of the row and column headers), you can modify its color by changing the options for the Sheet widget. This is often controlled by the corner color options in tksheet.

    Here's how you can adjust the "Select All" button color to white in your application:

    import tkinter as tk
    from tkinter import simpledialog, messagebox, filedialog
    from tksheet import Sheet
    import json
    import csv
    from pathlib import Path
    import ctypes
    
    def set_dpi_awareness():
        """Enable DPI awareness for high DPI settings."""
        try:
            ctypes.windll.shcore.SetProcessDpiAwareness(1)
        except Exception as e:
            print(f"Error setting DPI awareness: {e}")
    
    class TableApp:
        def __init__(self, root):
            """Initialize the Table Editor application."""
            self.root = root
            self.root.title("Table Editor with Sidebar")
            self.root.geometry("1280x720")
    
            # Font and color configurations
            font_name = "Literata"
            font_size = 12
            font_style = "normal"
            self.default_font = (font_name, font_size, font_style)
            self.TEXT_COLOR = '#000000'
            self.root.option_add("*Font", f"{font_name} {font_size}")
    
            # Color scheme for backgrounds and buttons
            self.BACKGROUND_COLOR = '#FFFFFF'
            self.SIDEBAR_COLOR = '#F7F8FC'
            self.BUTTON_COLOR = '#F7F8FC'
            self.BUTTON_COLOR_SELECTED = '#EAEDEF'
            self.SELECT_ALL_COLOR = '#FFFFFF'  # Set select all button color to white
    
            self.setup_ui()
            self.initialize_data()
            self.load_tables()
    
        def setup_ui(self):
            """Set up the user interface components."""
            self.create_sidebar()
            self.create_main_frame()
            self.create_header_frame()
            self.create_table_frame()
    
        def create_sidebar(self):
            """Create the sidebar and its components."""
            self.sidebar = tk.Frame(self.root, width=200, bg=self.SIDEBAR_COLOR, bd=0, relief='flat')
            self.sidebar.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.separator = tk.Frame(self.root, width=100, bg=self.BACKGROUND_COLOR, bd=0, relief='flat')
            self.separator.pack(expand=False, fill='y', side='left', anchor='nw')
    
            self.new_table_label = self.create_clickable_label(
                self.sidebar, "Create New Table", self.create_new_table)
            self.new_table_label.pack(padx=0, pady=10, fill='x')
    
            self.import_table_label = self.create_clickable_label(
                self.sidebar, "Import Table", self.import_file)
            self.import_table_label.pack(padx=0, pady=10, fill='x')
    
            self.table_labels_frame = tk.Frame(self.sidebar, bg=self.SIDEBAR_COLOR)
            self.table_labels_frame.pack(expand=True, fill='both', padx=0, pady=10)
    
            # Add delete table option
            self.delete_table_label = self.create_clickable_label(
                self.sidebar, "Delete Selected Table", self.delete_table)
            self.delete_table_label.pack(side='bottom', padx=0, pady=10, fill='x')
    
            self.add_custom_hover(self.new_table_label)
            self.add_custom_hover(self.import_table_label)
            self.add_custom_hover(self.delete_table_label)
    
        def create_main_frame(self):
            """Create the main frame of the application."""
            self.main_frame = tk.Frame(self.root)
            self.main_frame.pack(expand=True, fill='both', side='right')
    
        def create_header_frame(self):
            """Create the header frame with filter and rename options."""
            self.header_frame = tk.Frame(self.main_frame, height=50, bg=self.BACKGROUND_COLOR)
            self.header_frame.pack(fill='x')
    
            self.filter_label = tk.Label(self.header_frame, text="Filter:", bg=self.BACKGROUND_COLOR, fg=self.TEXT_COLOR, anchor="w")
            self.filter_label.pack(side='left', padx=5, pady=10)
    
            self.filter_entry = tk.Entry(self.header_frame, fg=self.TEXT_COLOR)
            self.filter_entry.pack(side='left', padx=5, pady=10)
            self.filter_entry.bind("<KeyRelease>", lambda event: self.apply_filter())
    
            self.rename_headers_label = self.create_clickable_label(
                self.header_frame, "Rename Headers", self.rename_headers)
            self.rename_headers_label.pack(side='left', padx=5, pady=10, fill='x')
    
        def create_table_frame(self):
            """Create the frame to hold the table."""
            self.table_frame = tk.Frame(self.main_frame, bg=self.BACKGROUND_COLOR)
            self.table_frame.pack(expand=True, fill='both')
    
        def initialize_data(self):
            """Initialize data structures and variables."""
            self.save_file_dir = Path("tables")
            self.tables = {}
            self.table_labels = {}
            self.original_data = {}
            self.headers = {}
            self.current_table_name = None
            self.rename_entry = None
            self.selected_table_label = None
    
            self.save_file_dir.mkdir(exist_ok=True)
    
        def create_clickable_label(self, parent, text, command, allow_rename=True):
            """Create a clickable Label widget."""
            label = tk.Label(
                parent, text=text, bg=self.BUTTON_COLOR, fg=self.TEXT_COLOR,
                borderwidth=0, relief='flat', cursor='arrow', anchor='w',
                padx=10, pady=5
            )
            label.bind("<Button-1>", lambda e: command())
            if allow_rename:
                label.bind("<Double-1>", lambda e: self.begin_rename(text))
            return label
    
        def create_new_table(self):
            """Create a new table and add it to the available tables list."""
            table_name = f"Table {len(self.tables) + 1}"
            self.add_table(table_name)
            self.load_selected_table(table_name)
    
        def import_file(self):
            """Import a CSV or JSON file to create a new table."""
            file_path = filedialog.askopenfilename(
                title="Open File",
                filetypes=[("CSV files", "*.csv"), ("JSON files", "*.json")]
            )
            if not file_path:
                return
    
            if file_path.endswith('.csv'):
                with open(file_path, newline='', encoding='utf-8') as csvfile:
                    reader = csv.reader(csvfile)
                    data = list(reader)
                headers, table_data = data[0], data[1:]
    
            elif file_path.endswith('.json'):
                with open(file_path, 'r', encoding='utf-8') as jsonfile:
                    data = json.load(jsonfile)
                headers, table_data = data[0], data[1:]
    
            else:
                messagebox.showerror("Unsupported File", "The selected file format is not supported.")
                return
    
            table_name = Path(file_path).stem
            self.add_table(table_name, table_data)
            self.headers[table_name] = headers
            self.load_selected_table(table_name)
    
        def add_table(self, table_name, data=None):
            """Add a table to the UI and internal storage."""
            default_data = [["" for _ in range(5)] for _ in range(10)]
            self.tables[table_name] = Sheet(
                self.table_frame,
                data=data or default_data,
                show_table=True,
                headers=None,
                font=self.default_font,  # Use default font
                header_font=self.default_font,  # Set the header font
            )
            
            # Change color of 'Select All' button and other options
            self.tables[table_name].set_options(
                table_fg=self.TEXT_COLOR,
                header_fg=self.TEXT_COLOR,
                index_bg=self.SELECT_ALL_COLOR,
                corner_bg=self.SELECT_ALL_COLOR,
            )
    
            self.tables[table_name].enable_bindings()
            self.tables[table_name].extra_bindings([
                ("end_edit_cell", lambda event, tn=table_name: self.save_data(tn)),
            ])
            self.tables[table_name].pack_forget()
            self.original_data[table_name] = self.tables[table_name].get_sheet_data()
    
            if table_name not in self.headers:
                self.headers[table_name] = self.tables[table_name].headers()
    
            table_label = self.create_clickable_label(
                self.table_labels_frame, table_name,
                lambda name=table_name: self.load_selected_table(name)
            )
            table_label.pack(fill='x', pady=2)
            self.table_labels[table_name] = table_label
    
            self.add_custom_hover(table_label)
    
        def delete_table(self):
            """Delete the currently selected table."""
            if not self.current_table_name:
                messagebox.showwarning("No Table Selected", "Please select a table to delete.")
                return
    
            response = messagebox.askyesno(
                "Delete Table",
                f"Are you sure you want to delete the table '{self.current_table_name}'?"
            )
            if response:
                # Remove from the UI
                self.tables[self.current_table_name].destroy()
                self.table_labels[self.current_table_name].destroy()
    
                # Remove from internal storage
                del self.tables[self.current_table_name]
                del self.original_data[self.current_table_name]
                del self.headers[self.current_table_name]
                del self.table_labels[self.current_table_name]
    
                # Remove from disk
                file_path = self.save_file_dir / f"{self.current_table_name}.json"
                if file_path.exists():
                    file_path.unlink()
    
                # Reset current table selection
                self.current_table_name = None
                self.selected_table_label = None
    
        def load_tables(self):
            """Load existing tables from the directory."""
            for file_path in self.save_file_dir.glob("*.json"):
                table_name = file_path.stem
                with file_path.open('r') as file:
                    data = json.load(file)
                    headers = data.pop(0)
                    self.add_table(table_name, data)
                    self.headers[table_name] = headers
    
        def load_selected_table(self, table_name):
            """Display the selected table and hide others."""
            for name, sheet in self.tables.items():
                if name == table_name:
                    sheet.pack(expand=True, fill='both')
                    self.current_table_name = table_name
                    sheet.headers(self.headers[name])
                    self.apply_filter()
    
                    selected_label = self.table_labels[name]
                    selected_label.config(bg=self.BUTTON_COLOR_SELECTED)
                    self.selected_table_label = selected_label
                else:
                    sheet.pack_forget()
                    self.table_labels[name].config(bg=self.BUTTON_COLOR)
    
        def save_data(self, table_name):
            """Save current data of a table to a file."""
            data = [self.headers[table_name]] + self.tables[table_name].get_sheet_data()
            file_path = self.save_file_dir / f"{table_name}.json"
            with file_path.open('w') as file:
                json.dump(data, file)
            print(f"Data for {table_name} saved successfully.")
    
        def apply_filter(self):
            """Apply filtering based on the entered term."""
            if not self.current_table_name:
                return
    
            term = self.filter_entry.get().lower()
            original_data = self.original_data[self.current_table_name]
    
            filtered_data = [
                row for row in original_data
                if any(term in str(cell).lower() for cell in row)
            ]
    
            self.tables[self.current_table_name].set_sheet_data(filtered_data)
    
        def rename_headers(self):
            """Prompt user to rename headers of the currently selected table."""
            if not self.current_table_name:
                messagebox.showwarning("No Table Selected", "Please select a table to rename headers.")
                return
    
            current_headers = self.headers[self.current_table_name]
            new_headers = simpledialog.askstring(
                "Rename Headers",
                "Enter new headers (comma-separated):",
                initialvalue=", ".join(current_headers)
            )
    
            if new_headers:
                header_list = [header.strip() for header in new_headers.split(',')]
                self.headers[self.current_table_name] = header_list
                self.tables[self.current_table_name].headers(header_list)
                self.save_data(self.current_table_name)
    
        def begin_rename(self, table_name):
            """Begin renaming of the table with a double click."""
            label = self.table_labels[table_name]
            
            if self.rename_entry:
                self.rename_entry.destroy()
            
            label.update_idletasks()
            label_x, label_y = label.winfo_x(), label.winfo_y()
            label_width, label_height = label.winfo_width(), label.winfo_height()
            
            self.rename_entry = tk.Entry(
                self.table_labels_frame,
                bg=label.cget("bg"),
                fg=self.TEXT_COLOR,
                relief='flat',
                borderwidth=0,
                highlightthickness=0,
                justify='left'
            )
            self.rename_entry.insert(0, table_name)
            
            self.rename_entry.place(x=label_x, y=label_y, width=label_width, height=label_height)
            self.rename_entry.focus()
            self.rename_entry.select_range(0, tk.END)
            
            self.rename_entry.bind('<Return>', lambda event: self.end_rename(table_name))
            self.rename_entry.bind('<FocusOut>', lambda event: self.cancel_rename())
    
        def end_rename(self, old_name):
            """Finish the renaming process for the specified table."""
            new_name = self.rename_entry.get().strip()
    
            if not new_name:
                messagebox.showerror("Invalid Name", "Table name cannot be empty.")
                self.rename_entry.focus_set()
                return
    
            if new_name in self.tables and new_name != old_name:
                messagebox.showerror("Duplicate Name", f"A table named '{new_name}' already exists.")
                self.rename_entry.focus_set()
                return
    
            if new_name != old_name:
                self.tables[new_name] = self.tables.pop(old_name)
                self.original_data[new_name] = self.original_data.pop(old_name)
                self.headers[new_name] = self.headers.pop(old_name)
    
                self.table_labels[new_name] = self.table_labels.pop(old_name)
                self.table_labels[new_name].config(text=new_name)
    
                if self.selected_table_label == self.table_labels[new_name]:
                    self.selected_table_label = self.table_labels[new_name]
                    self.table_labels[new_name].config(bg=self.BUTTON_COLOR_SELECTED)
    
                current_file = self.save_file_dir / f"{old_name}.json"
                new_file = self.save_file_dir / f"{new_name}.json"
    
                if current_file.exists():
                    current_file.rename(new_file)
    
            self.cancel_rename()
    
        def cancel_rename(self):
            """Cancel the renaming entry."""
            if self.rename_entry:
                self.rename_entry.destroy()
                self.rename_entry = None
    
        def add_custom_hover(self, label):
            """Add custom hover effects to a label."""
            def on_enter(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR_SELECTED)
    
            def on_leave(e):
                if label != self.selected_table_label:
                    label.config(bg=self.BUTTON_COLOR)
    
            label.bind("<Enter>", on_enter)
            label.bind("<Leave>", on_leave)
    
    if __name__ == "__main__":
        set_dpi_awareness()
        root = tk.Tk()
        app = TableApp(root)
        root.mainloop()
    

    Key Changes:

    • Added self.SELECT_ALL_COLOR = '#FFFFFF' to set the "Select All" button's color to white.
    • Updated self.tables[table_name].set_options(...) to include corner_bg=self.SELECT_ALL_COLOR to change the corner button's background color.

    This will ensure that the "Select All" button in the top-left corner of tksheet now uses a white background.