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

Implement checkbuttons for the fields with boolean data type. Code: import tkinter as tk…

  1. User

    Implement checkbuttons for the fields with boolean data type. Code: import tkinter as tk from tkinter import ttk import sqlite3

    def run_query(query, parameters=()): with sqlite3.connect('media.db') as conn: cursor = conn.cursor() result = cursor.execute(query, parameters) if query.strip().lower().startswith("select"): return result.fetchall() conn.commit()

    def create_tables(): create_movies_table_sql = ''' CREATE TABLE IF NOT EXISTS movies ( id INTEGER PRIMARY KEY AUTOINCREMENT, movie TEXT, year INTEGER, present BOOLEAN, watched BOOLEAN, notes TEXT ); ''' create_series_table_sql = ''' CREATE TABLE IF NOT EXISTS series ( id INTEGER PRIMARY KEY AUTOINCREMENT, series TEXT, seasons TEXT, year TEXT, present BOOLEAN, seasons_present TEXT, complete BOOLEAN, watched BOOLEAN, seasons_seen TEXT, notes TEXT ); ''' run_query(create_movies_table_sql) run_query(create_series_table_sql)

    def load_data(): for row in movies_tree.get_children(): movies_tree.delete(row) for row in series_tree.get_children(): series_tree.delete(row)

    # Load data into the movies treeview
    movies_data = run_query('SELECT * FROM movies')
    if not movies_data:
        # Adding an empty row if the table is empty
        run_query("INSERT INTO movies (movie, year, present, watched, notes) VALUES (?, ?, ?, ?, ?)", ('', None, None, None, ''))
        movies_data = run_query('SELECT * FROM movies')
    
    for row in movies_data:
        movies_tree.insert('', 'end', iid=row[0], values=row[1:])
    
    # Load data into the series treeview
    series_data = run_query('SELECT * FROM series')
    if not series_data:
        # Adding an empty row if the table is empty
        run_query("INSERT INTO series (series, seasons, year, present, seasons_present, complete, watched, seasons_seen, notes) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
                  ('', '', '', None, '', None, None, '', ''))
        series_data = run_query('SELECT * FROM series')
    
    for row in series_data:
        series_tree.insert('', 'end', iid=row[0], values=row[1:])
    

    def add_entry(tree): if tree == movies_tree: run_query("INSERT INTO movies (movie, year, present, watched, notes) VALUES (?, ?, ?, ?, ?)", ('', None, None, None, '')) elif tree == series_tree: run_query("INSERT INTO series (series, seasons, year, present, seasons_present, complete, watched, seasons_seen, notes) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)", ('', '', '', None, '', None, None, '', ''))

    load_data()
    

    def delete_entry(tree, item): if not tree.exists(item): print(f"Item {item} not found in tree.") return item_values = tree.item(item, "values") if tree == movies_tree: run_query("DELETE FROM movies WHERE id = ?", (item,)) elif tree == series_tree: run_query("DELETE FROM series WHERE id = ?", (item,)) load_data()

    def save_edit(tree, item, col, new_value): tree.set(item, column=col, value=new_value)

    if tree == movies_tree:
        columns = ["movie", "year", "present", "watched", "notes"]
        values = movies_tree.item(item, 'values')
        run_query(f"UPDATE movies SET {columns[col]} = ? WHERE id = ?", (new_value, item))
    elif tree == series_tree:
        columns = ["series", "seasons", "year", "present", "seasons_present", "complete", "watched", "seasons_seen", "notes"]
        values = series_tree.item(item, 'values')
        run_query(f"UPDATE series SET {columns[col]} = ? WHERE series = ? AND year = ?", (new_value, values[0], values[2]))
    

    def edit_cell(event, tree): selected_item = tree.selection() if not selected_item: return selected_item = selected_item[0] col = tree.identify_column(event.x)[1:] if col.isdigit(): col = int(col) - 1

    def on_edit_complete(event=None):
        new_value = entry_var.get()
        save_edit(tree, selected_item, col, new_value)
        entry.destroy()
    
    x, y, width, height = tree.bbox(selected_item, column=f'#{col + 1}')
    
    entry_var = tk.StringVar()
    entry = tk.Entry(tree, textvariable=entry_var, width=int(width / 7))
    entry_var.set(tree.item(selected_item, 'values')[col])
    entry.place(x=x, y=y, anchor='nw', height=height, width=width)
    entry.focus_set()
    entry.bind("<Return>", on_edit_complete)
    entry.bind("<FocusOut>", on_edit_complete)
    

    def on_hover(event, widget, bg_color): widget.config(bg=bg_color)

    def show_buttons(event, tree, plus_button, minus_button): item = tree.identify_row(event.y) if item: bbox = tree.bbox(item) if bbox: plus_button.place(x=2, y=bbox[1], width=20, height=bbox[3]) minus_button.place(x=24, y=bbox[1], width=20, height=bbox[3])

            plus_button.bind("<Button-1>", lambda e: add_entry(tree))
            minus_button.bind("<Button-1>", lambda e, i=item: delete_entry(tree, i))
    
            # Hover effects
            plus_button.bind("<Enter>", lambda e: on_hover(e, plus_button, "lightgray"))
            plus_button.bind("<Leave>", lambda e: on_hover(e, plus_button, "white"))
            minus_button.bind("<Enter>", lambda e: on_hover(e, minus_button, "lightgray"))
            minus_button.bind("<Leave>", lambda e: on_hover(e, minus_button, "white"))
    

    def hide_buttons(event, plus_button, minus_button): plus_button.place_forget() minus_button.place_forget()

    def enter_empty_bar(event, tree, plus_button, minus_button): show_buttons(event, tree, plus_button, minus_button)

    def leave_empty_bar(event, plus_button, minus_button): hide_buttons(event, plus_button, minus_button)

    def show_movies(): series_frame.pack_forget() movies_frame.pack(expand=True, fill='both') empty_frame.bind("", lambda event: enter_empty_bar(event, movies_tree, plus_button, minus_button)) empty_frame.bind("", lambda event: leave_empty_bar(event, plus_button, minus_button)) empty_frame.bind("", lambda event: show_buttons(event, movies_tree, plus_button, minus_button)) empty_frame.pack(expand=False, fill='y', side='left')

    def show_series(): movies_frame.pack_forget() series_frame.pack(expand=True, fill='both') empty_frame.bind("", lambda event: enter_empty_bar(event, series_tree, plus_button, minus_button)) empty_frame.bind("", lambda event: leave_empty_bar(event, plus_button, minus_button)) empty_frame.bind("", lambda event: show_buttons(event, series_tree, plus_button, minus_button)) empty_frame.pack(expand=False, fill='y', side='left')

    root = tk.Tk() root.title("Movies and Series Tracker")

    create_tables()

    Sidebar with buttons

    sidebar_frame = tk.Frame(root, width=100, bg='lightgray') sidebar_frame.pack(side='left', fill='y')

    movies_button = tk.Button(sidebar_frame, text="Movies", command=show_movies) movies_button.pack(fill='x', padx=5, pady=5)

    series_button = tk.Button(sidebar_frame, text="Series", command=show_series) series_button.pack(fill='x', padx=5, pady=5)

    Increase the width of the empty frame for spacing and plus/minus buttons

    empty_frame = tk.Frame(root, width=50, bg='white') empty_frame.pack(expand=False, fill='y', side='left')

    Main content frame

    content_frame = tk.Frame(root) content_frame.pack(side='right', fill='both', expand=True)

    movies_frame = tk.Frame(content_frame) series_frame = tk.Frame(content_frame)

    movies_columns = ("Movie", "Year", "Present", "Watched", "Notes") movies_tree = ttk.Treeview(movies_frame, columns=movies_columns, show='headings') for column in movies_columns: movies_tree.heading(column, text=column) movies_tree.column(column, anchor='center') movies_tree.pack(expand=True, fill='both') movies_tree.bind('', lambda e: edit_cell(e, movies_tree))

    series_columns = ("Series", "Seasons", "Year", "Present", "Seasons Present", "Complete", "Watched", "Seasons (Seen)", "Notes") series_tree = ttk.Treeview(series_frame, columns=series_columns, show='headings') for column in series_columns: series_tree.heading(column, text=column) series_tree.column(column, anchor='center') series_tree.pack(expand=True, fill='both') series_tree.bind('', lambda e: edit_cell(e, series_tree))

    Plus and minus buttons with hover effects

    plus_button = tk.Label(empty_frame, text="+", bg="white", fg="black", font=("Arial", 12), cursor="hand2") minus_button = tk.Label(empty_frame, text="-", bg="white", fg="black", font=("Arial", 12), cursor="hand2")

    load_data()

    show_movies()

    root.mainloop()

  2. Assistant

    To implement checkbuttons for fields with boolean data types, we need to modify the code slightly to differentiate boolean data editing in the Treeview widget. Specifically, we'll add checkbox editing for the "Present," "Watched," "Complete," and, in the series case, possibly "Seasons Present."

    Here's how to integrate checkbuttons to handle boolean values:

    1. Checkbox Rendering: We'll create checkboxes for boolean columns instead of cell edit boxes.
    2. Handling Clicks: Toggle the boolean value upon clicking.

    Below is the modified section of your code to handle boolean fields with checkbuttons:

    import tkinter as tk
    from tkinter import ttk
    import sqlite3
    
    def on_click_bool(event, tree, item_id, col):
        # Retrieve the current value of the boolean field
        current_value = tree.set(item_id, col)
        # Toggle the current boolean value
        new_value = not bool(int(current_value))
        save_edit(tree, item_id, col, new_value)
    
    def create_checkbox(tree, item_id, col, value):
        value = bool(value)  # Ensure it's Boolean
        x, y, width, height = tree.bbox(item_id, column=col)
        checked = tk.IntVar(value=int(value))
    
        checkbox = tk.Checkbutton(tree, variable=checked, command=lambda: on_click_bool(None, tree, item_id, col))
        checkbox.place(x=x + (width-20)//2, y=y + (height-20)//2)
    
        # Remove checkbox on clicking anywhere else
        def remove_checkbox(event):
            checkbox.destroy()
            tree.unbind("<Button-1>", remove_id)
    
        remove_id = tree.bind("<Button-1>", remove_checkbox)
    
    def edit_cell(event, tree):
        selected_item = tree.selection()
        if not selected_item:
            return
        selected_item = selected_item[0]
        col = tree.identify_column(event.x)[1:]
        if col.isdigit():
            col = int(col) - 1
    
        # List of columns with boolean values
        boolean_columns = {
            movies_tree: [2, 3],  # Present, Watched
            series_tree: [3, 5, 6]  # Present, Complete, Watched
        }
    
        if col in boolean_columns[tree]:
            # Handling the boolean field with a checkbox toggle
            current_value = tree.set(selected_item, f'#{col+1}')
            create_checkbox(tree, selected_item, f'#{col+1}', current_value)
        else:
            def on_edit_complete(event=None):
                new_value = entry_var.get()
                save_edit(tree, selected_item, col, new_value)
                entry.destroy()
    
            x, y, width, height = tree.bbox(selected_item, column=f'#{col + 1}')
    
            entry_var = tk.StringVar()
            entry = tk.Entry(tree, textvariable=entry_var, width=int(width / 7))
            entry_var.set(tree.item(selected_item, 'values')[col])
            entry.place(x=x, y=y, anchor='nw', height=height, width=width)
            entry.focus_set()
            entry.bind("<Return>", on_edit_complete)
            entry.bind("<FocusOut>", on_edit_complete)
    
        return "break"  # Prevent treeview's default behavior
    
    def save_edit(tree, item, col, new_value):
        # Ensure boolean values are stored as integers in database
        if isinstance(new_value, bool):
            new_value = int(new_value)
    
        tree.set(item, column=col, value=new_value)
    
        if tree == movies_tree:
            columns = ["movie", "year", "present", "watched", "notes"]
            run_query(f"UPDATE movies SET {columns[col]} = ? WHERE id = ?", (new_value, item))
        elif tree == series_tree:
            columns = ["series", "seasons", "year", "present", "seasons_present", "complete", "watched", "seasons_seen", "notes"]
            values = series_tree.item(item, 'values')
            run_query(f"UPDATE series SET {columns[col]} = ? WHERE id = ?", (new_value, item))
    
    # The rest of your existing code follows unchanged
    
    # Ensure to define Boolean columns you are handling
    movies_columns = ("Movie", "Year", "Present", "Watched", "Notes")
    series_columns = ("Series", "Seasons", "Year", "Present", "Seasons Present", "Complete", "Watched", "Seasons (Seen)", "Notes")
    

    Explanation:

    • Checkboxes for Boolean: This introduces a check button to toggle boolean values.
    • Boolean Columns Identification: We define which columns are boolean and handle their interaction differently.
    • Value Toggle: Boolean values (presented as integers in the database) are toggled upon clicking checkboxes.

    This approach efficiently allows users to work with boolean fields using checkboxes, improving usability and clarity for such data types.

  3. User

    print the new code in full

  4. Assistant

    Certainly! Below is the full modified code, integrating checkbuttons for boolean data types using a Treeview in Tkinter:

    import tkinter as tk
    from tkinter import ttk
    import sqlite3
    
    def run_query(query, parameters=()):
        with sqlite3.connect('media.db') as conn:
            cursor = conn.cursor()
            result = cursor.execute(query, parameters)
            if query.strip().lower().startswith("select"):
                return result.fetchall()
            conn.commit()
    
    def create_tables():
        create_movies_table_sql = '''
        CREATE TABLE IF NOT EXISTS movies (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            movie TEXT,
            year INTEGER,
            present BOOLEAN,
            watched BOOLEAN,
            notes TEXT
        );
        '''
        create_series_table_sql = '''
        CREATE TABLE IF NOT EXISTS series (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            series TEXT,
            seasons TEXT,
            year TEXT,
            present BOOLEAN,
            seasons_present TEXT,
            complete BOOLEAN,
            watched BOOLEAN,
            seasons_seen TEXT,
            notes TEXT
        );
        '''
        run_query(create_movies_table_sql)
        run_query(create_series_table_sql)
    
    def load_data():
        for row in movies_tree.get_children():
            movies_tree.delete(row)
        for row in series_tree.get_children():
            series_tree.delete(row)
    
        # Load data into the movies treeview
        movies_data = run_query('SELECT * FROM movies')
        if not movies_data:
            run_query("INSERT INTO movies (movie, year, present, watched, notes) VALUES (?, ?, ?, ?, ?)", ('', None, 0, 0, ''))
            movies_data = run_query('SELECT * FROM movies')
    
        for row in movies_data:
            movies_tree.insert('', 'end', iid=row[0], values=row[1:])
    
        # Load data into the series treeview
        series_data = run_query('SELECT * FROM series')
        if not series_data:
            run_query("INSERT INTO series (series, seasons, year, present, seasons_present, complete, watched, seasons_seen, notes) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
                      ('', '', '', 0, '', 0, 0, '', ''))
            series_data = run_query('SELECT * FROM series')
    
        for row in series_data:
            series_tree.insert('', 'end', iid=row[0], values=row[1:])
    
    def add_entry(tree):
        if tree == movies_tree:
            run_query("INSERT INTO movies (movie, year, present, watched, notes) VALUES (?, ?, ?, ?, ?)", ('', None, 0, 0, ''))
        elif tree == series_tree:
            run_query("INSERT INTO series (series, seasons, year, present, seasons_present, complete, watched, seasons_seen, notes) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)", ('', '', '', 0, '', 0, 0, '', ''))
    
        load_data()
    
    def delete_entry(tree, item):
        if not tree.exists(item):
            print(f"Item {item} not found in tree.")
            return
        if tree == movies_tree:
            run_query("DELETE FROM movies WHERE id = ?", (item,))
        elif tree == series_tree:
            run_query("DELETE FROM series WHERE id = ?", (item,))
        load_data()
    
    def save_edit(tree, item, col, new_value):
        if isinstance(new_value, bool):
            new_value = int(new_value)  # Convert bool to int for storage
        
        tree.set(item, column=col, value=new_value)
    
        if tree == movies_tree:
            columns = ["movie", "year", "present", "watched", "notes"]
            run_query(f"UPDATE movies SET {columns[col]} = ? WHERE id = ?", (new_value, item))
        elif tree == series_tree:
            columns = ["series", "seasons", "year", "present", "seasons_present", "complete", "watched", "seasons_seen", "notes"]
            run_query(f"UPDATE series SET {columns[col]} = ? WHERE id = ?", (new_value, item))
    
    def on_click_bool(event, tree, item_id, col):
        current_value = tree.set(item_id, col)
        new_value = not bool(int(current_value))  # Toggle the boolean value
        save_edit(tree, item_id, col, new_value)
    
    def create_checkbox(tree, item_id, col, value):
        value = bool(value)
        x, y, width, height = tree.bbox(item_id, column=col)
        checked = tk.IntVar(value=int(value))
    
        checkbox = tk.Checkbutton(tree, variable=checked, command=lambda: on_click_bool(None, tree, item_id, col))
        checkbox.place(x=x + (width-20)//2, y=y + (height-20)//2)
    
        def remove_checkbox(event):
            checkbox.destroy()
            tree.unbind("<Button-1>", remove_id)
    
        remove_id = tree.bind("<Button-1>", remove_checkbox)
    
    def edit_cell(event, tree):
        selected_item = tree.selection()
        if not selected_item:
            return
        selected_item = selected_item[0]
        col = tree.identify_column(event.x)[1:]
        if col.isdigit():
            col = int(col) - 1
    
        boolean_columns = {
            movies_tree: [2, 3],  # Present, Watched
            series_tree: [3, 5, 6]  # Present, Complete, Watched
        }
    
        if col in boolean_columns[tree]:
            current_value = tree.set(selected_item, f'#{col+1}')
            create_checkbox(tree, selected_item, f'#{col+1}', current_value)
        else:
            def on_edit_complete(event=None):
                new_value = entry_var.get()
                save_edit(tree, selected_item, col, new_value)
                entry.destroy()
    
            x, y, width, height = tree.bbox(selected_item, column=f'#{col + 1}')
    
            entry_var = tk.StringVar()
            entry = tk.Entry(tree, textvariable=entry_var, width=int(width / 7))
            entry_var.set(tree.item(selected_item, 'values')[col])
            entry.place(x=x, y=y, anchor='nw', height=height, width=width)
            entry.focus_set()
            entry.bind("<Return>", on_edit_complete)
            entry.bind("<FocusOut>", on_edit_complete)
    
        return "break"
    
    def on_hover(event, widget, bg_color):
        widget.config(bg=bg_color)
    
    def show_buttons(event, tree, plus_button, minus_button):
        item = tree.identify_row(event.y)
        if item:
            bbox = tree.bbox(item)
            if bbox:
                plus_button.place(x=2, y=bbox[1], width=20, height=bbox[3])
                minus_button.place(x=24, y=bbox[1], width=20, height=bbox[3])
    
                plus_button.bind("<Button-1>", lambda e: add_entry(tree))
                minus_button.bind("<Button-1>", lambda e, i=item: delete_entry(tree, i))
    
                plus_button.bind("<Enter>", lambda e: on_hover(e, plus_button, "lightgray"))
                plus_button.bind("<Leave>", lambda e: on_hover(e, plus_button, "white"))
                minus_button.bind("<Enter>", lambda e: on_hover(e, minus_button, "lightgray"))
                minus_button.bind("<Leave>", lambda e: on_hover(e, minus_button, "white"))
    
    def hide_buttons(event, plus_button, minus_button):
        plus_button.place_forget()
        minus_button.place_forget()
    
    def enter_empty_bar(event, tree, plus_button, minus_button):
        show_buttons(event, tree, plus_button, minus_button)
    
    def leave_empty_bar(event, plus_button, minus_button):
        hide_buttons(event, plus_button, minus_button)
    
    def show_movies():
        series_frame.pack_forget()
        movies_frame.pack(expand=True, fill='both')
        empty_frame.bind("<Enter>", lambda event: enter_empty_bar(event, movies_tree, plus_button, minus_button))
        empty_frame.bind("<Leave>", lambda event: leave_empty_bar(event, plus_button, minus_button))
        empty_frame.bind("<Motion>", lambda event: show_buttons(event, movies_tree, plus_button, minus_button))
        empty_frame.pack(expand=False, fill='y', side='left')
    
    def show_series():
        movies_frame.pack_forget()
        series_frame.pack(expand=True, fill='both')
        empty_frame.bind("<Enter>", lambda event: enter_empty_bar(event, series_tree, plus_button, minus_button))
        empty_frame.bind("<Leave>", lambda event: leave_empty_bar(event, plus_button, minus_button))
        empty_frame.bind("<Motion>", lambda event: show_buttons(event, series_tree, plus_button, minus_button))
        empty_frame.pack(expand=False, fill='y', side='left')
    
    root = tk.Tk()
    root.title("Movies and Series Tracker")
    
    create_tables()
    
    sidebar_frame = tk.Frame(root, width=100, bg='lightgray')
    sidebar_frame.pack(side='left', fill='y')
    
    movies_button = tk.Button(sidebar_frame, text="Movies", command=show_movies)
    movies_button.pack(fill='x', padx=5, pady=5)
    
    series_button = tk.Button(sidebar_frame, text="Series", command=show_series)
    series_button.pack(fill='x', padx=5, pady=5)
    
    empty_frame = tk.Frame(root, width=50, bg='white')
    empty_frame.pack(expand=False, fill='y', side='left')
    
    content_frame = tk.Frame(root)
    content_frame.pack(side='right', fill='both', expand=True)
    
    movies_frame = tk.Frame(content_frame)
    series_frame = tk.Frame(content_frame)
    
    movies_columns = ("Movie", "Year", "Present", "Watched", "Notes")
    movies_tree = ttk.Treeview(movies_frame, columns=movies_columns, show='headings')
    for column in movies_columns:
        movies_tree.heading(column, text=column)
        movies_tree.column(column, anchor='center')
    movies_tree.pack(expand=True, fill='both')
    movies_tree.bind('<Double-1>', lambda e: edit_cell(e, movies_tree))
    
    series_columns = ("Series", "Seasons", "Year", "Present", "Seasons Present", "Complete", "Watched", "Seasons (Seen)", "Notes")
    series_tree = ttk.Treeview(series_frame, columns=series_columns, show='headings')
    for column in series_columns:
        series_tree.heading(column, text=column)
        series_tree.column(column, anchor='center')
    series_tree.pack(expand=True, fill='both')
    series_tree.bind('<Double-1>', lambda e: edit_cell(e, series_tree))
    
    plus_button = tk.Label(empty_frame, text="+", bg="white", fg="black", font=("Arial", 12), cursor="hand2")
    minus_button = tk.Label(empty_frame, text="-", bg="white", fg="black", font=("Arial", 12), cursor="hand2")
    
    load_data()
    show_movies()
    
    root.mainloop()
    

    Summary:

    • This version of the code includes handling for boolean fields by using checkbuttons.
    • Within the edit_cell function, if a boolean column is being edited, a check button is placed, enabling users to toggle the value with a click.
    • The save_edit function is adjusted to handle conversion of boolean values to integers for storage.
  5. User

    the checkbutton should always be visible and represent the data

  6. Assistant

    To make the checkbuttons always visible and reflective of the boolean data in the Treeview, we'll need to adjust the design so that each row's boolean fields are directly represented as checkbuttons, not just during editing. This involves a more integrated approach to display and updating checkbuttons directly in the treeview setup:

    Here’s the modified code to directly include checkbuttons in the tree view for boolean columns:

    import tkinter as tk
    from tkinter import ttk
    import sqlite3
    
    def run_query(query, parameters=()):
        with sqlite3.connect('media.db') as conn:
            cursor = conn.cursor()
            result = cursor.execute(query, parameters)
            if query.strip().lower().startswith("select"):
                return result.fetchall()
            conn.commit()
    
    def create_tables():
        create_movies_table_sql = '''
        CREATE TABLE IF NOT EXISTS movies (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            movie TEXT,
            year INTEGER,
            present BOOLEAN,
            watched BOOLEAN,
            notes TEXT
        );
        '''
        create_series_table_sql = '''
        CREATE TABLE IF NOT EXISTS series (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            series TEXT,
            seasons TEXT,
            year TEXT,
            present BOOLEAN,
            seasons_present TEXT,
            complete BOOLEAN,
            watched BOOLEAN,
            seasons_seen TEXT,
            notes TEXT
        );
        '''
        run_query(create_movies_table_sql)
        run_query(create_series_table_sql)
    
    def load_data():
        for row in movies_tree.get_children():
            movies_tree.delete(row)
        for row in series_tree.get_children():
            series_tree.delete(row)
    
        # Load data into the movies treeview
        movies_data = run_query('SELECT * FROM movies')
        if not movies_data:
            run_query("INSERT INTO movies (movie, year, present, watched, notes) VALUES (?, ?, ?, ?, ?)", ('', None, 0, 0, ''))
            movies_data = run_query('SELECT * FROM movies')
    
        for row in movies_data:
            values = list(row[1:])
            values[2] = bool(values[2])  # Ensure present is boolean
            values[3] = bool(values[3])  # Ensure watched is boolean
            movies_tree.insert('', 'end', iid=row[0], values=values)
    
        # Load data into the series treeview
        series_data = run_query('SELECT * FROM series')
        if not series_data:
            run_query("INSERT INTO series (series, seasons, year, present, seasons_present, complete, watched, seasons_seen, notes) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
                      ('', '', '', 0, '', 0, 0, '', ''))
            series_data = run_query('SELECT * FROM series')
    
        for row in series_data:
            values = list(row[1:])
            values[3] = bool(values[3])  # Ensure present is boolean
            values[5] = bool(values[5])  # Ensure complete is boolean
            values[6] = bool(values[6])  # Ensure watched is boolean
            series_tree.insert('', 'end', iid=row[0], values=values)
    
    def add_entry(tree):
        if tree == movies_tree:
            run_query("INSERT INTO movies (movie, year, present, watched, notes) VALUES (?, ?, ?, ?, ?)", ('', None, 0, 0, ''))
        elif tree == series_tree:
            run_query("INSERT INTO series (series, seasons, year, present, seasons_present, complete, watched, seasons_seen, notes) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)", ('', '', '', 0, '', 0, 0, '', ''))
    
        load_data()
    
    def delete_entry(tree, item):
        if not tree.exists(item):
            print(f"Item {item} not found in tree.")
            return
        if tree == movies_tree:
            run_query("DELETE FROM movies WHERE id = ?", (item,))
        elif tree == series_tree:
            run_query("DELETE FROM series WHERE id = ?", (item,))
        load_data()
    
    def save_edit(tree, item, col, value):
        if isinstance(value, bool):
            value = int(value)  # Convert bool to int for storage
        
        tree.set(item, column=col, value=value)
    
        if tree == movies_tree:
            columns = ["movie", "year", "present", "watched", "notes"]
            run_query(f"UPDATE movies SET {columns[col]} = ? WHERE id = ?", (value, item))
        elif tree == series_tree:
            columns = ["series", "seasons", "year", "present", "seasons_present", "complete", "watched", "seasons_seen", "notes"]
            run_query(f"UPDATE series SET {columns[col]} = ? WHERE id = ?", (value, item))
    
    def create_bool_column_callback(tree, col_index):
        def callback(event):
            selected_item = tree.selection()
            if selected_item:
                item_id = selected_item[0]
                current_value = int(tree.set(item_id, f'#{col_index}'))
                new_value = not bool(current_value)
                save_edit(tree, item_id, col_index - 1, new_value)
        return callback
    
    def configure_treeview_with_bool(tree, bool_columns):
        for col_index in bool_columns:
            tree.heading(f'#{col_index}', command=create_bool_column_callback(tree, col_index))
            
    root = tk.Tk()
    root.title("Movies and Series Tracker")
    
    create_tables()
    
    sidebar_frame = tk.Frame(root, width=100, bg='lightgray')
    sidebar_frame.pack(side='left', fill='y')
    
    movies_button = tk.Button(sidebar_frame, text="Movies", command=lambda: [series_frame.pack_forget(), movies_frame.pack(expand=True, fill='both')])
    movies_button.pack(fill='x', padx=5, pady=5)
    
    series_button = tk.Button(sidebar_frame, text="Series", command=lambda: [movies_frame.pack_forget(), series_frame.pack(expand=True, fill='both')])
    series_button.pack(fill='x', padx=5, pady=5)
    
    content_frame = tk.Frame(root)
    content_frame.pack(side='right', fill='both', expand=True)
    
    movies_frame = tk.Frame(content_frame)
    series_frame = tk.Frame(content_frame)
    
    movies_columns = ("Movie", "Year", "Present", "Watched", "Notes")
    movies_tree = ttk.Treeview(movies_frame, columns=movies_columns, show='headings')
    for index, column in enumerate(movies_columns):
        movies_tree.heading(f'#{index+1}', text=column)
        movies_tree.column(f'#{index+1}', anchor='center', width=100)
    movies_tree.pack(expand=True, fill='both')
    
    series_columns = ("Series", "Seasons", "Year", "Present", "Seasons Present", "Complete", "Watched", "Seasons (Seen)", "Notes")
    series_tree = ttk.Treeview(series_frame, columns=series_columns, show='headings')
    for index, column in enumerate(series_columns):
        series_tree.heading(f'#{index+1}', text=column)
        series_tree.column(f'#{index+1}', anchor='center', width=100)
    series_tree.pack(expand=True, fill='both')
    
    # Configure boolean columns to toggle values when clicked
    configure_treeview_with_bool(movies_tree, [3, 4])
    configure_treeview_with_bool(series_tree, [4, 6, 7])
    
    plus_button = tk.Label(content_frame, text="+", bg="white", fg="black", font=("Arial", 12), cursor="hand2")
    minus_button = tk.Label(content_frame, text="-", bg="white", fg="black", font=("Arial", 12), cursor="hand2")
    
    plus_button.bind("<Button-1>", lambda event: add_entry(movies_tree if movies_frame.winfo_ismapped() else series_tree))
    minus_button.bind("<Button-1>", lambda event: delete_entry(movies_tree if movies_frame.winfo_ismapped() else series_tree, (movies_tree if movies_frame.winfo_ismapped() else series_tree).selection()[0]))
    
    plus_button.pack(side='left', padx=10, pady=10)
    minus_button.pack(side='left', padx=10, pady=10)
    
    load_data()
    movies_frame.pack(expand=True, fill='both')
    root.mainloop()
    

    Explanation:

    • Boolean Columns Management: In configure_treeview_with_bool, clicking on column headings that correspond to boolean columns toggles the values for the selected item. This provides checkbutton functionality directly within the treeview cells.
    • Columns as Buttons: By setting the headings as buttons, it allows toggling boolean values directly from the column representing each row.
    • Toggling Logic: On clicking, the current value is retrieved and its Boolean state is switched using its integer conversion (int(bool_value) toggles between 0 and 1).
    • Setup: Added setup for treeview for both movies and series handling boolean interactions within their respective views.

    This design choice makes boolean data columns more interactive while keeping track of values efficiently without extra UI components.