Python Forum
Treeview - SQL - Add child node
Thread Rating:
  • 0 Vote(s) - 0 Average
  • 1
  • 2
  • 3
  • 4
  • 5
Treeview - SQL - Add child node
#1
I've got a bunch of entry boxes that add data to an SQL database which is then pulled and added to a tkinter treeview widget. I can select each row in the treeview, edit it and delete it.

Now I want to be able to add the option of adding a child to a selected treeview row.

How might I go about this?

It's hard to summarise what I've tried and thought about trying without writing war and peace!

I know how to add a child to the treeview but I completely fog over when it comes to taking the child data from the database and using it in a method that will display the parent-child relationship in treeview. I would imagine my current methods need a lot of extra code or completely re-writing.

It the second class in my code that needs this ... the Accounts class. The 'child account' method (and associated entry boxes etc) are just part of previous experiments.

Any help with direction would be very much appreciated! Thank you

from tkinter import *
from tkinter.ttk import *
import sqlite3

root = Tk()
root.title("Bookkeeping")
root.geometry("1920x1080")

notebook = Notebook(root)
notebook.pack(fill="both", expand=1, pady=15)

class Contact_tab:
    def __init__ (self, tab_name, contact_column_names, button_info):
        self.tab_name = tab_name
        self.contact_column_names = contact_column_names
        self.button_info = button_info

        self.tab = Frame(notebook)
        self.tab.pack(fill="both", expand=YES)
        notebook.add(self.tab, text=str(tab_name))        
        
    def tab_tree (self):       
        self.treeview_frame = Frame(self.tab)
        self.treeview_frame.pack(fill="both", expand=1)

        self.tree_scroll = Scrollbar(self.treeview_frame)
        self.tree_scroll.pack(side=RIGHT, fill=Y) 

        self.tab_tree = Treeview(self.treeview_frame, yscrollcommand=self.tree_scroll.set, selectmode="extended") 
        self.tab_tree.pack(fill="both", expand=YES)        
        
        self.tab_tree['columns'] = self.contact_column_names
        self.tab_tree.column("#0", width=0, stretch=NO)
        self.tab_tree.column("ID", width=0, stretch=NO)
        self.tab_tree.heading("#0", text="")
        self.tab_tree.heading("ID", text="")
        
        self.contact_column_names = self.contact_column_names[:0] + self.contact_column_names[1:]
        for name in self.contact_column_names:
            self.tab_tree.column(name, minwidth=25, width=50) 
            self.tab_tree.heading(name, text=name)   
                        
    def populate_tab_tree(self):   
        conn = sqlite3.connect('Bookkeeping_Database.sqlite3')
        cur = conn.cursor()
        cur.execute("CREATE TABLE IF NOT EXISTS " + self.tab_name + " (id INTEGER, name TEXT, company TEXT, street TEXT, town TEXT, city TEXT, county TEXT, postcode TEXT, email TEXT, phone INTEGER)")
        cur.execute("SELECT rowid,  * FROM " + self.tab_name)
        record = cur.fetchall()    
        conn.commit()
        conn.close() 
        global count
        self.count = 0
        for row in record:
            self.tab_tree.insert(parent='', index='end', iid=self.count, text='', values=(row[0], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10]))
            self.count+=1    

    def entry_boxes(self):
        self.entry_box_frame = LabelFrame(self.tab, text="Contact Details")
        self.entry_box_frame.pack(fill="x", pady=20)

        self.id_label = Label(self.entry_box_frame, text="ID")
        #self.id_label.grid(row=1, column=5, padx=10)
        self.id_entry = Entry(self.entry_box_frame, width=15)
        #self.id_entry.grid(row=1, column=6, padx=10)

        self.name_label = Label(self.entry_box_frame, text="Name")
        self.name_label.grid(row=1, column=1, padx=10)
        self.name_entry = Entry(self.entry_box_frame, width=15)
        self.name_entry.grid(row=1, column=2, padx=10)

        self.company_label = Label(self.entry_box_frame, text="Company")
        self.company_label.grid(row=1, column=3, padx=10)
        self.company_entry = Entry(self.entry_box_frame, width=15)
        self.company_entry.grid(row=1, column=4, padx=10)

        
        self.street_label = Label(self.entry_box_frame, text="Street")
        self.street_label.grid(row=2, column=1, padx=10)
        self.street_entry = Entry(self.entry_box_frame, width=15)
        self.street_entry.grid(row=2, column=2, padx=10)

        self.town_label = Label(self.entry_box_frame, text="Town")
        self.town_label.grid(row=2, column=3, padx=10)
        self.town_entry = Entry(self.entry_box_frame, width=15)
        self.town_entry.grid(row=2, column=4, padx=10)

        self.city_label = Label(self.entry_box_frame, text="City")
        self.city_label.grid(row=2, column=5, padx=10)
        self.city_entry = Entry(self.entry_box_frame, width=15)
        self.city_entry.grid(row=2, column=6, padx=10)

        self.county_label = Label(self.entry_box_frame, text="County")
        self.county_label.grid(row=2, column=7, padx=10)
        self.county_entry = Entry(self.entry_box_frame, width=15)
        self.county_entry.grid(row=2, column=8, padx=10)

        self.postcode_label = Label(self.entry_box_frame, text="Postcode")
        self.postcode_label.grid(row=2, column=9, padx=10)
        self.postcode_entry = Entry(self.entry_box_frame, width=15)
        self.postcode_entry.grid(row=2, column=10, padx=10)

        self.email_label = Label(self.entry_box_frame, text="Email")
        self.email_label.grid(row=3, column=1, padx=10)
        self.email_entry = Entry(self.entry_box_frame, width=15)
        self.email_entry.grid(row=3, column=2, padx=10)

        self.phone_label = Label(self.entry_box_frame, text="Phone")
        self.phone_label.grid(row=3, column=3, padx=10)
        self.phone_entry = Entry(self.entry_box_frame, width=15)
        self.phone_entry.grid(row=3, column=4, padx=10)

    def select_record(self, event):
                
        self.id_entry.delete(0,END)
        self.name_entry.delete(0,END)
        self.company_entry.delete(0,END)
        self.street_entry.delete(0,END)
        self.town_entry.delete(0,END)
        self.city_entry.delete(0,END)
        self.county_entry.delete(0,END)
        self.postcode_entry.delete(0,END)
        self.email_entry.delete(0,END)
        self.phone_entry.delete(0,END)

        self.selected = self.tab_tree.focus()
        self.values = self.tab_tree.item(self.selected, 'values') 
        
        self.id_entry.insert(0, self.values[0])
        self.name_entry.insert(0, self.values[1])
        self.company_entry.insert(0, self.values[2])
        self.street_entry.insert(0, self.values[3])
        self.town_entry.insert(0, self.values[4])
        self.city_entry.insert(0, self.values[5])
        self.county_entry.insert(0, self.values[6])
        self.postcode_entry.insert(0, self.values[7])
        self.email_entry.insert(0, self.values[8])
        self.phone_entry.insert(0, self.values[9])
        
    def buttons(self):        
        self.button_frame = LabelFrame(self.tab, text="Controls")
        self.button_frame.pack(fill="x", pady=20)

        self.new_contact_button = Button(self.button_frame, text="Add New " + self.button_info, command=self.new_contact)
        self.new_contact_button.pack(side=LEFT, padx=10, pady=10) 

        self.edit_contact_button = Button(self.button_frame, text="Update " + self.button_info, command=self.update_contact)
        self.edit_contact_button.pack(side=LEFT, padx=10, pady=10) 

        self.delete_contact_button = Button(self.button_frame, text="Delete " + self.button_info, command=self.delete_contact)
        self.delete_contact_button.pack(side=LEFT, padx=10, pady=10)

    def new_contact(self):
        conn = sqlite3.connect('Bookkeeping_Database.sqlite3')
        cur = conn.cursor()
        
        inputted_data= [self.id_entry.get(), 
                        self.name_entry.get(), 
                        self.company_entry.get(), 
                        self.street_entry.get(), 
                        self.town_entry.get(), 
                        self.city_entry.get(), 
                        self.county_entry.get(), 
                        self.postcode_entry.get(), 
                        self.email_entry.get(), 
                        self.phone_entry.get()]
        
        if len(self.name_entry.get()) == 0:
            self.window = Toplevel()
            self.window.title("Error")
            
            self.window.frame = Frame(self.window)
            self.window.frame.pack(fill="both", expand=1, pady=10)
            
            self.failed = Label(self.window.frame, text="A new " + self.button_info + " must have a name")
            self.failed.pack(side=LEFT, padx=10, pady=10)
            
            self.close_button = Button(self.window, text="Close", command=self.window.destroy)
            self.close_button.pack(side=BOTTOM, pady=10)
        else:
            cur.execute("INSERT INTO " + self.tab_name + "(id, name, company, street, town, city, county, postcode, email, phone) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", inputted_data)
            
            conn.commit()
            conn.close() 

        self.id_entry.delete(0,END)
        self.name_entry.delete(0,END)
        self.company_entry.delete(0,END)
        self.street_entry.delete(0,END)
        self.town_entry.delete(0,END)
        self.city_entry.delete(0,END)
        self.county_entry.delete(0,END)
        self.postcode_entry.delete(0,END)
        self.email_entry.delete(0,END)
        self.phone_entry.delete(0,END)

        for record in self.tab_tree.get_children():
            self.tab_tree.delete(record)

        conn = sqlite3.connect('Bookkeeping_Database.sqlite3')
        cur = conn.cursor()
        cur.execute("SELECT rowid, * FROM " + self.tab_name)
        record = cur.fetchall()    
        conn.commit()
        conn.close() 

        for row in record:
            self.tab_tree.insert(parent='', index='end', iid=self.count, text='', values=(row[0], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10]))
            self.count+=1 
    
    def update_contact(self):
        self.selected = self.tab_tree.focus()
        self.values = self.tab_tree.item(self.selected, 'values') 

        conn = sqlite3.connect('Bookkeeping_Database.sqlite3')
        cur = conn.cursor()

        if len(self.name_entry.get()) == 0:
            self.window = Toplevel()
            self.window.title("Error")
            
            self.window.frame = Frame(self.window)
            self.window.frame.pack(fill="both", expand=1, pady=10)
            
            self.failed = Label(self.window.frame, text="A new " + self.button_info + " must have a name")
            self.failed.pack(side=LEFT, padx=10, pady=10)
            
            self.close_button = Button(self.window, text="Close", command=self.window.destroy)
            self.close_button.pack(side=BOTTOM, pady=10)
        else:
            cur.execute("UPDATE " + self.tab_name + " SET name = :name, company = :company, street = :street, town = :town, city = :city, county = :county, postcode = :postcode, email = :email, phone = :phone WHERE oid = :oid",
                {
                    'name' : self.name_entry.get(),
                    'company' : self.company_entry.get(),
                    'street' : self.street_entry.get(),
                    'town' : self.town_entry.get(),
                    'city'  : self.city_entry.get(),
                    'county' : self.county_entry.get(),
                    'postcode' : self.postcode_entry.get(),
                    'email' : self.email_entry.get(),
                    'phone' : self.phone_entry.get(),
                    'oid' : self.id_entry.get(),

                })
        
        self.id_entry.delete(0,END)
        self.name_entry.delete(0,END)
        self.company_entry.delete(0,END)
        self.street_entry.delete(0,END)
        self.town_entry.delete(0,END)
        self.city_entry.delete(0,END)
        self.county_entry.delete(0,END)
        self.postcode_entry.delete(0,END)
        self.email_entry.delete(0,END)
        self.phone_entry.delete(0,END)

        for record in self.tab_tree.get_children():
            self.tab_tree.delete(record)

        cur.execute("SELECT rowid, * FROM " + self.tab_name)
        record = cur.fetchall()    
        conn.commit()
        conn.close() 

        for row in record:
            self.tab_tree.insert(parent='', index='end', iid=self.count, text='', values=(row[0], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10]))
            self.count+=1 

    def delete_contact(self):
        self.selected = self.tab_tree.focus()
        self.values = self.tab_tree.item(self.selected, 'values') 

        conn = sqlite3.connect('Bookkeeping_Database.sqlite3')
        cur = conn.cursor()
        cur.execute("SELECT rowid, * FROM " + self.tab_name)
        self.record = cur.fetchall()       
        
        cur.execute("DELETE FROM " + self.tab_name + " WHERE rowid = " + str(self.values[0]))

        self.id_entry.delete(0,END)
        self.name_entry.delete(0,END)
        self.company_entry.delete(0,END)
        self.street_entry.delete(0,END)
        self.town_entry.delete(0,END)
        self.city_entry.delete(0,END)
        self.county_entry.delete(0,END)
        self.postcode_entry.delete(0,END)
        self.email_entry.delete(0,END)
        self.phone_entry.delete(0,END)

        for record in self.tab_tree.get_children():
            self.tab_tree.delete(record)

        cur.execute("SELECT rowid, * FROM " + self.tab_name)
        record = cur.fetchall()    
        conn.commit()
        conn.close() 

        for row in record:
            self.tab_tree.insert(parent='', index='end', iid=self.count, text='', values=(row[0], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10]))
            self.count+=1 

class Accounts:
    def __init__ (self, tab_name, account_column_names, button_info):
        self.tab_name = tab_name
        self.account_column_names = account_column_names
        self.button_info = button_info

        self.tab = Frame(notebook)
        self.tab.pack(fill="both", expand=YES)
        notebook.add(self.tab, text=str(tab_name))
    
    def tab_tree (self):       
        self.treeview_frame = Frame(self.tab)
        self.treeview_frame.pack(fill="both", expand=1)

        self.tree_scroll = Scrollbar(self.treeview_frame)
        self.tree_scroll.pack(side=RIGHT, fill=Y) 

        self.tab_tree = Treeview(self.treeview_frame, yscrollcommand=self.tree_scroll.set, selectmode="extended") 
        self.tab_tree.pack(fill="both", expand=YES)        
        
        #self.tab_tree['columns'] = self.account_column_names
        #self.tab_tree.column("#0", width=0, stretch=NO)
        #self.tab_tree.heading("#0", text="")
        #for name in account_column_names:
        #    self.tab_tree.column(name, minwidth=25, width=50) 
        #    self.tab_tree.heading(name, text=name)  
        
        self.tab_tree['columns'] = ("ID", "Account Number", "Account", "Total")
        self.tab_tree.column("#0", width=0, stretch=NO)
        self.tab_tree.column("ID", width=0, stretch=0) 
        self.tab_tree.column("Account Number", minwidth=25, width=50)
        self.tab_tree.column("Account", minwidth=25, width=50) 
        self.tab_tree.column("Total", minwidth=25, width=50) 

        self.tab_tree.heading("#0", text="")
        self.tab_tree.heading("ID", text="ID")    
        self.tab_tree.heading("Account Number", text="Account Number")
        self.tab_tree.heading("Account", text="Account")    
        self.tab_tree.heading("Total", text="Total")          

    def populate_tab_tree(self):   
        conn = sqlite3.connect('Bookkeeping_Database.sqlite3')
        cur = conn.cursor()
        cur.execute("CREATE TABLE IF NOT EXISTS Accounts (id INTEGER, account_number INTEGER, account_name TEXT, total INTEGER, child_account TEXT)")
        cur.execute("SELECT rowid, * FROM Accounts")
        record = cur.fetchall()   
        conn.commit()
        conn.close() 
        global count
        self.count = 0
        for row in record:
            self.tab_tree.insert(parent='', index='end', iid=self.count, text='', values=(row[0], row[2], row[3], row[4]))
            self.count+=1  

    def entry_boxes(self):
        self.entry_box_frame = LabelFrame(self.tab, text="Accounts")
        self.entry_box_frame.pack(fill="x", pady=20)

        self.account_id_label = Label(self.entry_box_frame, text="ID")
        #self.account_id_label.grid(row=1, column=1, padx=10)
        self.account_id_entry = Entry(self.entry_box_frame, width=15)
        #self.account_id_entry.grid(row=1, column=2, padx=10)

        self.account_name_label = Label(self.entry_box_frame, text="Account Name")
        self.account_name_label.grid(row=1, column=1, padx=10)
        self.account_name_entry = Entry(self.entry_box_frame, width=15)
        self.account_name_entry.grid(row=1, column=2, padx=10) 
        
        self.account_number_label = Label(self.entry_box_frame, text="Account Number")
        self.account_number_label.grid(row=1, column=3, padx=10)
        self.account_number_entry = Entry(self.entry_box_frame, width=15)
        self.account_number_entry.grid(row=1, column=4, padx=10)           

        self.account_total_label = Label(self.entry_box_frame, text="Total")
        #self.account_total_label.grid(row=1, column=3, padx=10)
        self.account_total_entry = Entry(self.entry_box_frame, width=15)
        #self.account_total_entry.grid(row=1, column=4, padx=10)    

        self.child_account_label = Label(self.entry_box_frame, text="Add Sub-account")
        self.child_account_label.grid(row=2, column=1)
        self.child_account_entry = Entry(self.entry_box_frame, width=15)
        self.child_account_entry.grid(row=2, column=2, padx=10)  

        self.child_account_number_label = Label(self.entry_box_frame, text="Sub-account Number")
        self.child_account_number_label.grid(row=2, column=3, padx=10)
        self.child_account_number_entry = Entry(self.entry_box_frame, width=15)
        self.child_account_number_entry.grid(row=2, column=4, padx=10)

    def select_record(self, event):      
        self.account_id_entry.delete(0,END)
        self.account_number_entry.delete(0,END)
        self.account_name_entry.delete(0,END)
        self.account_total_entry.delete(0,END)
        
        self.selected = self.tab_tree.focus()
        self.values = self.tab_tree.item(self.selected, 'values') 
        
        self.account_id_entry.insert(0, self.values[0])
        self.account_number_entry.insert(0,self.values[1])
        self.account_name_entry.insert(0, self.values[2])
        self.account_total_entry.insert(0, self.values[3])

    def buttons(self):        
        self.button_frame = LabelFrame(self.tab, text="Controls")
        self.button_frame.pack(fill="x", pady=20)

        self.new_account_button = Button(self.button_frame, text="Add New Account", command=self.new_account)
        self.new_account_button.pack(side=LEFT, padx=10, pady=10)

        self.update_account_button = Button(self.button_frame, text="Update Account", command=self.update_account)
        self.update_account_button.pack(side=LEFT, padx=10, pady=10)

        self.delete_account_button = Button(self.button_frame, text="Delete Account", command=self.delete_account)
        self.delete_account_button.pack(side=LEFT, padx=10, pady=10)

        self.child_account_button = Button(self.button_frame, text="Add Sub Account", command=self.child_account)
        self.child_account_button.pack(side=LEFT, padx=10, pady=10)

    def new_account(self):
        conn = sqlite3.connect('Bookkeeping_Database.sqlite3')
        cur = conn.cursor()

        inputted_data = [self.account_id_entry.get(), self.account_number_entry.get(), self.account_name_entry.get(), self.account_total_entry.get()]

        if len(self.account_name_entry.get()) == 0:
            self.window = Toplevel()
            self.window.title("Error")
            
            self.window.frame = Frame(self.window)
            self.window.frame.pack(fill="both", expand=1, pady=10)
            
            self.failed = Label(self.window.frame, text="A new " + self.button_info + " must have a name")
            self.failed.pack(side=LEFT, padx=10, pady=10)
            
            self.close_button = Button(self.window, text="Close", command=self.window.destroy)
            self.close_button.pack(side=BOTTOM, pady=10)
        else:
            cur.execute("INSERT INTO Accounts (id, account_number, account_name, total) VALUES (?, ?, ?, ?)", inputted_data)
            
        conn.commit()
        conn.close()

        self.account_id_entry.delete(0,END)
        self.account_number_entry.delete(0,END)
        self.account_name_entry.delete(0,END)
        self.account_total_entry.delete(0,END)

        for record in self.tab_tree.get_children():
            self.tab_tree.delete(record)

        conn = sqlite3.connect('Bookkeeping_Database.sqlite3')
        cur = conn.cursor()
        cur.execute("SELECT rowid, * FROM Accounts")
        record = cur.fetchall()    
        conn.commit()
        conn.close() 

        for row in record:
            self.tab_tree.insert(parent='', index='end', iid=self.count, text='', values=(row[0], row[2], row[3], row[4]))
            self.count+=1 

    def update_account(self):
            self.selected = self.tab_tree.focus()
            self.values = self.tab_tree.item(self.selected, 'values') 

            conn = sqlite3.connect('Bookkeeping_Database.sqlite3')
            cur = conn.cursor()

            cur.execute("UPDATE Accounts SET account_name = :account_name, account_number = :account_number, total = :total WHERE oid = :oid", {'account_name' : self.account_name_entry.get(), 'account_number' : self.account_number_entry.get(), 'total' : self.account_total_entry.get(), 'oid' : self.account_id_entry.get()})
    
            self.account_id_entry.delete(0,END)
            self.account_number_entry.delete(0,END)
            self.account_name_entry.delete(0,END)
            self.account_total_entry.delete(0,END)

            for record in self.tab_tree.get_children():
                self.tab_tree.delete(record)

            cur.execute("SELECT rowid, * FROM Accounts")
            record = cur.fetchall()    
            conn.commit()
            conn.close() 

            for row in record:
                self.tab_tree.insert(parent='', index='end', iid=self.count, text='', values=(row[0], row[2], row[3], row[4]))
                self.count+=1

    def delete_account(self):

            self.selected = self.tab_tree.focus()
            self.values = self.tab_tree.item(self.selected, 'values') 

            conn = sqlite3.connect('Bookkeeping_Database.sqlite3')
            cur = conn.cursor()
            cur.execute("SELECT rowid, * FROM Accounts")
            self.record = cur.fetchall()         
            
            cur.execute("DELETE FROM Accounts WHERE rowid = " + str(self.values[0]))

            self.account_id_entry.delete(0,END)
            self.account_number_entry.delete(0,END)
            self.account_name_entry.delete(0,END)
            self.account_total_entry.delete(0,END)

            for record in self.tab_tree.get_children():
                self.tab_tree.delete(record)

            cur.execute("SELECT rowid, * FROM Accounts")
            record = cur.fetchall()    
            conn.commit()
            conn.close() 

            for row in record:
                self.tab_tree.insert(parent='', index='end', iid=self.count, text='', values=(row[0], row[2], row[3], row[4]))
                self.count+=1

    def child_account(self):
        self.selected = self.tab_tree.focus()
        self.values = self.tab_tree.item(self.selected, 'values') 

        print(self.values[0])

        conn = sqlite3.connect('Bookkeeping_Database.sqlite3')
        cur = conn.cursor()

        inputted_data= [self.account_id_entry.get(), self.child_account_number_entry.get(), self.account_total_entry.get(), self.child_account_entry.get()]

        cur.execute("INSERT INTO Accounts (id, account_number, total, child_account) VALUES (?, ?, ?, ?)", inputted_data)

        conn.commit()
        conn.close()


########## Create Tabs ##########

# Contact Tabs
contact_column_names = ["ID",
                        "Name",
                        "Company",
                        "Street",
                        "Town",
                        "City",
                        "County",
                        "Postcode", 
                        "Email", 
                        "Phone", 
                        ]

customer_tab = Contact_tab("Customers", contact_column_names, "Customer")
customer_tree = customer_tab.tab_tree()
customer_populate = customer_tab.populate_tab_tree()
customer_entry_boxes = customer_tab.entry_boxes()
customer_buttons = customer_tab.buttons()
customer_select = customer_tab.tab_tree.bind('<ButtonRelease-1>', customer_tab.select_record) 

vendor_tab = Contact_tab("Vendors", contact_column_names, "Vendor")
vendor_tree = vendor_tab.tab_tree()
vendor_populate = vendor_tab.populate_tab_tree()
vendor_entry_boxes = vendor_tab.entry_boxes()
vendor_buttons = vendor_tab.buttons() 
vendor_select = vendor_tab.tab_tree.bind('<ButtonRelease-1>', vendor_tab.select_record) 

# Account Tab
account_column_names = ["ID",
                        "Number"
                        "Account", 
                        "Total",
                        ]

accounts_tab = Accounts("Chart of Accounts", account_column_names, "Account")
accounts_tree = accounts_tab.tab_tree()
accounts_populate = accounts_tab.populate_tab_tree()
accounts_entry_boxes = accounts_tab.entry_boxes()
accounts_buttons = accounts_tab.buttons()
accounts_select = accounts_tab.tab_tree.bind('<ButtonRelease-1>', accounts_tab.select_record) 

root.mainloop()
Reply


Possibly Related Threads…
Thread Author Replies Views Last Post
  [Tkinter] [split] Is there a way to embed a treeview as a row inside another treeview? CyKlop 5 595 Oct-20-2021, 12:14 AM
Last Post: CyKlop
  Treeview scroll selected node to top rfresh737 1 896 Apr-14-2021, 03:27 AM
Last Post: deanhystad
  [PyGUI] Expand last sub-node of treeview widget mart79 1 1,027 Apr-25-2020, 07:57 PM
Last Post: mart79
  [PyQt] Create Node via ToolbarButtonClick Basti 2 1,058 Mar-26-2020, 11:41 AM
Last Post: Basti

Forum Jump:

User Panel Messages

Announcements
Announcement #1 8/1/2020
Announcement #2 8/2/2020
Announcement #3 8/6/2020