Mise à jour d'un treeview entre toplevel et fenêtre principale

Version imprimable

07/11/2021, 22h32
cegehi

Mise à jour d'un treeview entre toplevel et fenêtre principale

Bonjour,
Je me gratte la tête depuis un moment mais je n'y arrive pas :bebe:donc je viens vous demander de l'aide.

Dans ma fenêtre principale j'ai un treeview(tk) qui est alimenté par une bdd sql3 et une fonction affichage.
Pour créer de nouvelle donnée, j'ai un toplevel qui enregistre les valeur saisi dans la bdd.
J’essaie d'activer la fonction affichage depuis le toplevel afin que la prise en compte de la nouvelle ligne du treeview soit prise en compte immédiatement.

Je me retrouve avec le message suivant : "AttributeError: module 'Main' has no attribute 'affichage'

Actuellement, la nouvelle ligne n'apparait que lorsque j'active affichage par un bouton dans la fenêtre principale.

Si quelqu'un peut me décoincé, je lui en serai reconnaissant :hola:
merci
08/11/2021, 06h58
MPython Alaplancha

Bonjour,

Citation:

Envoyé par cegehi

Je me retrouve avec le message suivant : "AttributeError: module 'Main' has no attribute 'affichage'

Ce qui signifie que la méthode affichage n'est pas une méthode associée à Main...

Citation:

Envoyé par cegehi

Actuellement, la nouvelle ligne n'apparait que lorsque j'active affichage par un bouton dans la fenêtre principale.

Tu peux par exemple lancer un événement 'maison' lors de la validation(voir event_generate()). Événement que tu associes à ta méthode affichage() (via bind())
08/11/2021, 12h22
cegehi

Citation:

Bonjour,

Ce qui signifie que la méthode affichage n'est pas une méthode associée à Main...

Je débute et je ne vois pas ce que cela veut dire, puisque pour moi affichage est une procédure qui fonctionne dans Main.
Mais si on parle de méthode, c'est que je dois passer par un objet ?

Citation:

Tu peux par exemple lancer un événement 'maison' lors de la validation

Effectivement, j'ai associé l'évènement <Enter> à ma fenêtre principale et ça marche.
Quand je quitte la toplevel et que j'entre dans main, l'évènement à lieu.
Ça fonctionne aussi avec l'évènement <Destroy> quand je ferme la fenêtre.

Mais il doit bien y avoir une solution pour que lorsque je valide mes modifications dans la toplevel grâce à un bouton "Valider",
la fonction Affichage de Main soit actionnée? Certainement en passant par une class d'après ta première remarque...

Si quelqu'un peut me donner un petit exemple pédagogique, ce serait plus clair pour moi
Merci
08/11/2021, 14h15
wiztricks

Salut,

Citation:

Envoyé par cegehi

Si quelqu'un peut me donner un petit exemple pédagogique, ce serait plus clair pour moi

Ce que vous essayez de faire s'appelle "fenêtre de dialogue".

Vous avez des classes dans tkinter pour aider à leur mise en place (et des exemples d'utilisation à butiner sur le ouèbe).

Sorti de là, si vous vous fabriquer vos propres interactions entre widgets, vous devez commencer par faire un petit exemple qui essaie de traduire ce que vous voulez faire pour comprendre les mécanismes qui font que ça marche.

Et si vous ne vous en sortez pas, vous aurez un code à poster.

- W

Citation:

Envoyé par cegehi

Si quelqu'un peut me donner un petit exemple pédagogique, ce serait plus clair pour moi
Merci

Bonjour,
Voici un exemple d'interaction possible entre les classes via un evenement pour prévenir à la classe main que le traitement de la classe B est fini.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import tkinter as tk
 
class Main:
    def __init__(self, can):
        self.can = can
        self.can.bind('<<mon_event>>', self.affichage)
        self.create_t = self.can.create_text(100, 100, text='Patatipatata', anchor="w")
        self.b = B(self.can)
 
    def affichage(self, event):
        self.can.itemconfig(self.create_t, text=self.b.ma_string)
 
 
class B(tk.Toplevel):
    def __init__(self, can):
        tk.Toplevel.__init__(self)
        self.can = can
        self.ma_string = "string définie dans B"
        self.after(2000, lambda: self.can.event_generate('<<mon_event>>')
 
 
root = tk.Tk()
can = tk.Canvas(root)
can.grid()
m = Main(can)
root.mainloop()

Salut,

Il est préférable de réserver event_generate à la simulation d'entrées utilisateurs. Ici, on peut très bien s'en passer en appelant directement la méthode:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import tkinter as tk
 
class Main:
    def __init__(self, can):
        self.can = can
        self.create_t = self.can.create_text(100, 100, text='Patatipatata', anchor="w")
        self.b = B(self.affichage)
 
    def affichage(self, text):
        self.can.itemconfig(self.create_t, text=text)
 
 
class B(tk.Toplevel):
    def __init__(self, affichage):
        tk.Toplevel.__init__(self)
        ma_string = "string définie dans B"
        self.after(2000, affichage, ma_string)
 
 
root = tk.Tk()
can = tk.Canvas(root)
can.grid()
m = Main(can)
root.mainloop()

- W

09/11/2021, 14h29
MPython Alaplancha

Effectivement.
Merci ;)
09/11/2021, 18h59
wiztricks

Abstraction faite de cette digression, "AttributeError: module 'Main' has no attribute 'affichage' est en général levée lors de l'accès à Main.affichage, Main étant un module qui a été importé (c'est le message qui le dit...).

Le programme semble donc être découpé en modules... et le problème plutôt provenir d'autre chose que la simple mise à jour un widget depuis le callback appelé lorsqu'on appui sur le Button "Valider".

Comme les débutants sont assez créatifs dans leur code, pas la peine de se prendre le chou à imaginer ce qui a pu être fait: quand on demande de l'aide, on décrit le problème et on fournit de quoi le reproduire... Si possible résumé en quelques lignes, histoire de montré qu'on a bossé dessus plutôt que de tout balancer pour qu'on trie.

- W

Bonjour,
Si si ! je bosse sur mon code.
Je suis parti de rien, ne connais pas python. Les tutos et autres cours sur python sont intéressants mais quand je suis confronté au projet qui me sert d'apprentissage souvent j'ai besoin d'aide et surtout de pédagogie
pour faire le lien entre la théorie et la pratique.
Lorsque je poste une question, c'est que j'y ai passé beaucoup de temps, trop, alors que quelqu'un qui maitrise, peut la plupart du temps me débloquer et m'apporter la pédagogie nécessaire pour comprendre.
:arf:

Mon code est effectivement coupé en modules

Main : Ma fenêtre d'accueil dont voici le code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import tkinter as tk
from tkinter import ttk
 
from AffTreeview import MyTreeview
import Archives
import Autrefenetre
import Nouvelleconsigne
import Bdd
 
 
if __name__ == "__main__":
 
        inter = 0  # Init Bascule du sens de tri
 
 
        def open_encours():
            window_ec = Archives.Window(app)
            window_ec.grab_set()
 
        def open_autres():
            window_a = Autrefenetre.Window2(app)
            window_a.grab_set()
 
        def open_nouvelle():
            window_n = Nouvelleconsigne.NewCons(app)
            window_n.grab_set()
 
        color = '#c1c1c3'
 
        app = tk.Tk()
        hght = app.winfo_screenheight()
        wdth = app.winfo_screenwidth()
        app.geometry(str(wdth - 300) + "x" + str(hght - 100))
        app.title('Fenetre Accueil')
        app.configure(bg=color)
 
        frtitre = tk.Frame(app)
        frtitre.grid(row=0, column=0, columnspan=10, padx=5, pady=10, sticky="ew")
        lbltitre = tk.Label(frtitre, text="Consigne en cours", font=30)
        lbltitre.grid(sticky="ew")
 
        frbout = tk.Frame(app, bg=color)
        frbout.grid(row=1, column=0, rowspan=7, columnspan=1, padx=5, pady=10, sticky="ns")
        b1 = ttk.Button(frbout, text='Archives', command=open_encours)
        b1.grid(row=0, column=0, columnspan=1, padx=5, pady=10, sticky="ew")
        b2 = ttk.Button(frbout, text='Nouvelle Consigne', command=open_nouvelle)
        b2.grid(row=2, column=0, columnspan=1, padx=5, pady=10, sticky="ew")
        b3 = ttk.Button(frbout, text='Autres', command=open_autres)
        b3.grid(row=4, column=0, columnspan=1, padx=5, pady=10, sticky="ew")
 
        mytree = MyTreeview(app, 1, 1, 6, 1)
        Bdd.Affichage(mytree.c_tree, 1)
        app.mainloop()

Nouvelleconsigne :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
import tkinter as tk
from tkinter import ttk
from tkcalendar import *
import locale
import Main
import Bdd
locale.setlocale(locale.LC_TIME, '')
 
class NewCons(tk.Toplevel):
    def __init__(self, parent):
        super().__init__(parent)
 
        bgcolor = '#c1c1c3'
 
        self.geometry("800x600")
        self.title('Nouvelle consigne')
        self.columnconfigure(1, weight=1)
        self.rowconfigure(5, weight=1)
 
        def effacer_champs():
            e_date.delete(0, tk.END)
            e_objet.delete(0, tk.END)
            e_objet2.delete(0, tk.END)
            e_type.delete(0, tk.END)
            e_consigne.delete(0, tk.END)
            e_action.delete(0, tk.END)
            e_soff.delete(0, tk.END)
            e_cloture.delete(0, tk.END)
            var.set(0)
 
        def ajouter():
            ajtdate = e_date.get()
            ajtobjet = e_objet.get()
            ajtobjet2 = e_objet2.get()
            ajttype = e_type.get()
            ajtconsigne = e_consigne.get()
            ajtaction = e_action.get()
            ajtsoff = e_soff.get()
 
            if var.get() == 1:
                ajtcloture = e_cloture.get()
            else:
                ajtcloture = "None"
 
            liste_entry = (ajtdate, ajtobjet, ajtobjet2, ajttype, ajtconsigne, ajtaction, ajtsoff, ajtcloture)
            Bdd.AjoutDsBdd(" TConsignes", liste_entry)
            effacer_champs()
            Main.app.configure(bg="yellow")
 
        def check():
            if var.get() == 1:
                e_cloture.grid(row=3, column=5, padx=5, pady=5)
            else:
                e_cloture.grid_forget()
 
        # -------------------------------------------------------------------------------------Zone Titre
        frtitre = tk.Frame(self, bg=bgcolor)
        frtitre.grid(row=0, column=0, columnspan=6, ipady=30, padx=10, pady=10)
        lbl_titre = tk.Label(frtitre, text="+++++   Nouvelle Consigne   +++++-----------------",
                             bg=bgcolor,
                             fg="black",
                             font=("calibri", 30, "bold"))
        lbl_titre.grid(row=0, column=0, padx=5, pady=0, sticky="ew")
 
        # ------------------------------------------------------------------------Maj des listes combobox
        choixspp = Bdd.chxspp()
        choixservice = Bdd.choixservice()
 
        # -------------------------------------------------------------------------------------Zone Saisie
 
        frentry = tk.Frame(self, bg=bgcolor)
        frentry.grid(row=2, column=0, columnspan=6, ipady=30, padx=10, pady=10)
 
        lbl_date = tk.Label(frentry, text="Date : ", bg=bgcolor, width=30, height=3)
        lbl_date.grid(row=0, column=0, padx=5, pady=5)
        e_date = DateEntry(frentry, locale='fra', showweeknumbers=False, date_pattern='yyyy-mm-dd', width=30, height=3)
        e_date.grid(row=0, column=1, padx=5, pady=5)
 
        lbl_soff = tk.Label(frentry, text="Soff : ", bg="red", width=10, height=3)
        lbl_soff.grid(row=1, column=0, padx=5, pady=5)
        e_soff = ttk.Combobox(frentry, values=choixspp, width=30, height=3)
        e_soff.set('Choix SOff')
        e_soff.grid(row=1, column=1, padx=5, pady=5)
 
        lbl_objet = tk.Label(frentry, text="Service : ", bg=bgcolor, width=30, height=3)
        lbl_objet.grid(row=2, padx=5, pady=5)
        e_objet = ttk.Combobox(frentry, width=30, values=choixservice)
        e_objet.grid(row=2, column=1, padx=5, pady=5)
 
        lbl_objet2 = tk.Label(frentry, text="Objet : ", bg=bgcolor, width=40, height=3)
        lbl_objet2.grid(row=3, column=0, padx=5, pady=5)
        e_objet2 = tk.Entry(frentry, bg=bgcolor, width=40)
        e_objet2.grid(row=3, column=1, padx=5, pady=5)
 
        lbl_type = tk.Label(frentry, text="Type : ", bg=bgcolor, width=40, height=3)
        lbl_type.grid(row=0, column=2, padx=5, pady=5)
        e_type = tk.Entry(frentry, bg=bgcolor, width=40)
        e_type.grid(row=0, column=3, padx=5, pady=5)
 
        lbl_consigne = tk.Label(frentry, text="Consigne : ", bg=bgcolor, width=30, height=6)
        lbl_consigne.grid(row=0, column=4, padx=5, pady=5)
        e_consigne = tk.Entry(frentry, width=30)
        e_consigne.grid(row=0, column=5, padx=5, pady=5)
 
        lbl_action = tk.Label(frentry, text="Action : ", bg=bgcolor, width=30, height=6)
        lbl_action.grid(row=1, column=4, padx=5, pady=5)
        e_action = tk.Entry(frentry, width=30)
        e_action.grid(row=1, column=5, padx=5, pady=5)
 
        e_cloture = DateEntry(frentry, locale='fra', showweeknumbers=False, date_pattern='yyyy-mm-dd')
 
        var = tk.IntVar()
        chk_cloture = tk.Checkbutton(frentry, text="Cloturer ?", bg=bgcolor, variable=var, command=check)
        chk_cloture.grid(row=3, column=4, padx=0, pady=5, sticky="w")
 
        # -------------------------------------------------------------------------------------Zone boutons
        frbouton = tk.Frame(self, bg=bgcolor)
        frbouton.grid(row=3, column=0, columnspan=6, ipady=30, padx=10, pady=10)
 
        b_ajouter = tk.Button(frbouton, text="Ajouter", padx=20, command=ajouter)
        b_ajouter.grid(row=5, column=0, padx=5)
        b_close = tk.Button(frbouton, text="close", padx=20, command=self.destroy)
        b_close.grid(row=5, column=2, padx=5)

un module qui gère le treeview: AFFTreeview

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
import tkinter as tk
from tkinter import ttk
import Bdd
 
 
class MyTreeview:
    def __init__(self, fenetre, rw, clmn, cspn, run):  # -Run permet de savoir si archive ou en court
 
        self.place = fenetre
        self.t_row = rw
        self.t_column = clmn
        self.t_columnspan = cspn
        self.run = run
        self.inter = 0  # Init Bascule du sens de tri
 
        ftree = tk.LabelFrame(self.place, text="consignes", bg='#c1c1c3')
        ftree.grid(row=self.t_row, column=self.t_column,
                   rowspan=4, columnspan=self.t_columnspan,
                   padx=0, pady=0, sticky="ew")
 
        treescroll = ttk.Scrollbar(ftree)
        treescroll.grid(row=self.t_row, column=self.t_columnspan + 1, sticky="ns")
        style = ttk.Style()
        style.theme_use('clam')
        style.configure("mystyle.Treeview.Heading",
                        font=('Calibri', 14))  # Modify the font of the headings
        style.configure("mystyle.Treeview", rowheight=25, font=('Calibri', 10))
        col = ("N°", "Date", "Objet", "Objet2", "Type", "Consigne", "Action", "Soff", "Cloture")
        self.c_tree = ttk.Treeview(ftree,
                                   style="mystyle.Treeview",
                                   yscrollcommand=treescroll.set,
                                   columns=col,
                                   height=10,
                                   show="headings")
 
        self.c_tree.column("#0", width=5, minwidth=1)
        self.c_tree.heading("#0", text="", anchor="w")
        self.c_tree.column("N°", width=30, minwidth=10, stretch=True)
        self.c_tree.heading("N°", text="N°", anchor="w", command=self.sortnum)
        self.c_tree.column("Date", width=100, minwidth=100, stretch=False)
        self.c_tree.heading("Date", text="Date", anchor="w", command=self.sortdate)
        self.c_tree.column("Objet", width=100, minwidth=50, stretch=False)
        self.c_tree.heading("Objet", text="Objet", anchor="w", command=self.sortobjet)
        self.c_tree.column("Objet2", width=100, minwidth=50, stretch=False)
        self.c_tree.heading("Objet2", text="Objet2", anchor="w", command=self.sortobjet2)
        self.c_tree.column("Type", width=100, minwidth=50, stretch=False)
        self.c_tree.heading("Type", text="Type", anchor="w")
        self.c_tree.column("Consigne", width=300, minwidth=50, stretch=False)
        self.c_tree.heading("Consigne", text="Consigne", anchor="w")
        self.c_tree.column("Action", width=200, minwidth=50, stretch=False)
        self.c_tree.heading("Action", text="Action", anchor="w")
        self.c_tree.column("Soff", width=100, minwidth=100, stretch=False)
        self.c_tree.heading("Soff", text="Soff", anchor="w", command=self.sortsoff)
        self.c_tree.column("Cloture", width=100, minwidth=50, stretch=True)
        self.c_tree.heading("Cloture", text="Cloture", anchor="w")
        self.c_tree.grid(row=rw, column=clmn, columnspan=cspn, padx=0, pady=0, sticky="ew")
 
        # Config scrollbar
        treescroll.config(command=self.c_tree.yview)
 
    def trier(self, chpstri):
        tri = Bdd.Trier(chpstri, self.run)
        self.vidertreeview()
        tri.conn.commit()
        for row in tri.select:
            self.c_tree.insert("", tk.END, value=row)
        tri.conn.close()
 
    def vidertreeview(self):
        for i in self.c_tree.get_children():
            self.c_tree.delete(i)
 
    def sortnum(self):
        self.trier("id")
 
    def sortdate(self):
        self.trier("Date")
 
    def sortsoff(self):
        self.trier("Soff")
 
    def sortobjet(self):
        self.trier("Objet")
 
    def sortobjet2(self):
        self.trier("Objet2")
 
    def affiche(self):
        Bdd.Affichage(self.c_tree, 1)

Un module pour la base de donnée: Bdd

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
import sqlite3
import tkinter as tk
 
 
# -------------------------------------------------Creation liste pour liste deroulante
 
 
class Crealiste:
    def __init__(self, table, champs):
        self.table = table
        self.champs = champs
 
        self.conn = sqlite3.connect("ConsigneDB.db")
        cur = self.conn.cursor()
        self.select = cur.execute("SELECT  " + self.champs + " FROM " + self.table + " ORDER BY " + self.champs)
 
        self.choixspp = []
        self.choixservice = []
        self.choixvehicule = []
 
    # -------------------------------------------------Ajout des valeurs saisies dans bdd
 
 
class AjoutDsBdd:
    def __init__(self, table, listechps):
        self.table = table
        self.liste = listechps
 
        self.conn = sqlite3.connect("ConsigneDB.db")
        cur = self.conn.cursor()
 
        insert = cur.execute("INSERT INTO" +
                             " TConsignes" +
                             " (Date, Objet, Objet2, Type, Consigne, Action, Soff,  Cloture)" +
                             " VALUES(?,?,?,?,?,?,?,?)", self.liste)
        self.conn.commit()
        self.conn.close()
 
 
# -------------------------------------------------Affichage des consignes cloturees ou non
 
 
class Affichage:
    def __init__(self, tree, run):  # run = 0 en cours run = 1 cloturé
        self.tree = tree
        self.run = run
        conn = sqlite3.connect("ConsigneDB.db")
        cur = conn.cursor()
        if self.run == 1:
            select = cur.execute("select * from TConsignes where Cloture=? order by id desc", ("None",))
        else:
            select = cur.execute("select * from TConsignes order by id desc")
 
        for i in self.tree.get_children():
            self.tree.delete(i)
        for row in select:
            self.tree.insert("", tk.END, value=row)
        conn.close()
 
 
# -------------------------------------------------Bascule du tri asc/desc
 
 
class Trier:
    n = 0
 
    def __init__(self, tri, run=1):
        self.tri = tri
        self.run = run
        if self.__class__.n == 0:
            sens = "asc"
            self.__class__.n += 1
 
        else:
            sens = "desc"
            self.__class__.n -= 1
 
        self.conn = sqlite3.connect("ConsigneDB.db")
        cur = self.conn.cursor()
        if self.run == 1:
            query = "select * from TConsignes where Cloture is null order by " + self.tri + " {}".format(sens)
        else:
            query = "select * from TConsignes order by " + self.tri + " {}".format(sens)
 
        self.select = cur.execute(query)
 
 
class Recherche:
    def __init__(self, tree, spprech):
        conn = sqlite3.connect("ConsigneDB.db")
        cur = conn.cursor()
        select = cur.execute("SELECT * FROM TConsignes WHERE Soff=?", (spprech,))
        conn.commit()
        for row in select:
            tree.c_tree.insert("", tk.END, value=row)
        conn.close()
 
 
def chxspp():
    creaspp = Crealiste("TUtilisateurs", "Nom")
    for n in creaspp.select:
        creaspp.choixspp.append(n[0])
    creaspp.conn.close()
    return creaspp.choixspp
 
 
def choixservice():
    creaserv = Crealiste("TServices", "Service")
    for n in creaserv.select:
        creaserv.choixservice.append(n[0])
    creaserv.conn.close()
    return creaserv.choixservice
 
 
def creavehi():
    creavehicule = Crealiste("TVehicules", "Vehicule")
    for n in creavehicule.select:
        creavehicule.choixvehicule.append(n[0])
    creavehicule.conn.close()
    return creavehicule.choixvehicule

Et un dernier module Archives :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
import tkinter as tk
from tkinter import ttk
import locale
 
import Bdd
from AffTreeview import MyTreeview
 
locale.setlocale(locale.LC_TIME, '')
 
idselect = 0
 
color = 'grey40'
 
 
class Window(tk.Toplevel):
    def __init__(self, parent):
        super().__init__(parent)
 
        hght = self.winfo_screenheight()
        wdth = self.winfo_screenwidth()
        self.geometry(str(wdth - 100) + "x" + str(hght - 100))
 
        self.title('Consignes en cours')
        self.iconbitmap("Images/flower.ico")
        self.configure(bg=color)
        self.columnconfigure(1, weight=1)
        self.rowconfigure(5, weight=1)
        self.inter = 0  # Init Bascule du sens de tri
 
        def recherche():
 
            MyTreeview.vidertreeview(tree)
            spprech = cbb_rech2.get()
            select = Bdd.Recherche(tree, spprech)
            Bdd.Recherche(tree, select)
 
        def treevisu():
            # gestion des entry
            e_date.config(text=tree.c_tree.item(tree.c_tree.selection())['values'][1])
            e_soff.config(text=tree.c_tree.item(tree.c_tree.selection())['values'][2])
            e_objet.config(text=tree.c_tree.item(tree.c_tree.selection())['values'][3])
            e_objet2.config(text=tree.c_tree.item(tree.c_tree.selection())['values'][4])
            e_type.config(text=tree.c_tree.item(tree.c_tree.selection())['values'][5])
            e_consigne.config(text=tree.c_tree.item(tree.c_tree.selection())['values'][6])
            e_vu.config(text=tree.c_tree.item(tree.c_tree.selection())['values'][7])
            e_prevu.config(text=tree.c_tree.item(tree.c_tree.selection())['values'][8])
            e_cloture.config(text=tree.c_tree.item(tree.c_tree.selection())['values'][9])
 
        def imprim():
            item = tree.c_tree.selection()
            for i in range(9):
                print(tree.c_tree.item(item)['values'][i])
        # ---------------------------------------------------------------------- Construction Titre
        lbl_titre = tk.Label(self, text="-----   ARCHIVES   -----",
                             bg="grey40",
                             fg="black",
                             font=("calibri", 40, "bold"))
        lbl_titre.grid(row=0, column=0, columnspan=6, padx=0, pady=0, sticky="ew")
        # -------------------------------------------------------------------------- gestion frame
        f_rech = tk.Frame(self, padx=5, bg="red")
        f_rech.grid(row=2, column=0, columnspan=4, padx=0, pady=5, sticky="ew")
 
        choixspp = Bdd.chxspp()
 
        l_recherche = tk.Label(f_rech, text="Recherche par :", padx=10)
        l_recherche.grid(row=0, column=1, padx=5, pady=5)
        cbb_rech1 = ttk.Combobox(f_rech, values=choixspp)
        cbb_rech1.grid(row=0, column=2, padx=5, pady=5)
        cbb_rech2 = ttk.Combobox(f_rech, values=choixspp)
        cbb_rech2.grid(row=0, column=3, padx=5, pady=5)
        btrech = tk.Button(f_rech, text="Rechercher ", padx=10, command=recherche)
        btrech.grid(row=0, column=4, padx=5, pady=5)
        btprint = tk.Button(f_rech, text="imprim ", padx=10, command=imprim)
        btprint.grid(row=0, column=5, padx=5, pady=5)
 
        f_bouton = tk.Frame(self, padx=5, bg=color)
        f_bouton.grid(row=3, column=0, columnspan=4, padx=0, pady=0, sticky="ew")
 
        f_entry = tk.Frame(self, padx=10, bg=color)
        f_entry.grid(row=4, column=0, columnspan=4, padx=0, pady=0, sticky="ew")
 
        tree = MyTreeview(self, 2, 1, 4, 0)
 
        Bdd.Affichage(tree.c_tree, 0)
        # ---------------------------------------------------------------------- Construction Label Info
        btaff = tk.Button(f_entry, text="Afficher consigne", padx=10, command=treevisu)
        btaff.grid(row=5, column=0, padx=5, pady=5)
 
        lbl_date = tk.Label(f_entry, text="Date : ", bg=color, width=20)
        lbl_date.grid(row=0, padx=5, pady=5)
        e_date = tk.Label(f_entry, bg=color, width=20)
        e_date.grid(row=0, column=1, padx=5, pady=5)
 
        lbl_soff = tk.Label(f_entry, text="Soff : ", bg=color, width=20)
        lbl_soff.grid(row=1, column=0, padx=5, pady=5)
        e_soff = tk.Label(f_entry, bg=color, width=20)
        e_soff.grid(row=1, column=1, padx=5, pady=5)
 
        lbl_objet = tk.Label(f_entry, text="Objet : ", bg=color, width=20)
        lbl_objet.grid(row=2, padx=5, pady=5)
        e_objet = tk.Label(f_entry, bg=color, width=20)
        e_objet.grid(row=2, column=1, padx=5, pady=5)
 
        lbl_objet2 = tk.Label(f_entry, text="Objet2 : ", bg=color, width=20)
        lbl_objet2.grid(row=3, padx=5, pady=5)
        e_objet2 = tk.Label(f_entry, bg=color, width=20)
        e_objet2.grid(row=3, column=1, padx=5, pady=5)
 
        lbl_type = tk.Label(f_entry, text="Type : ", bg=color, width=20)
        lbl_type.grid(row=4, padx=5, pady=5)
        e_type = tk.Label(f_entry, bg=color, width=20)
        e_type.grid(row=4, column=1, padx=5, pady=5)
 
        lbl_consigne = tk.Label(f_entry, text="Consigne : ", bg=color, width=20)
        lbl_consigne.grid(row=0, column=4, padx=5, pady=5)
        e_consigne = tk.Label(f_entry, bg=color, width=20)
        e_consigne.grid(row=0, column=5, padx=5, pady=5)
 
        lbl_vu = tk.Label(f_entry, text="Vu : ", bg=color, width=20)
        lbl_vu.grid(row=1, column=4, padx=5, pady=5)
        e_vu = tk.Label(f_entry, bg=color, width=20)
        e_vu.grid(row=1, column=5, padx=5, pady=5)
 
        lbl_prevu = tk.Label(f_entry, text="Prevu : ", bg=color, width=20)
        lbl_prevu.grid(row=2, column=4, padx=5, pady=5)
        e_prevu = tk.Label(f_entry, bg=color, width=20)
        e_prevu.grid(row=2, column=5, padx=5, pady=5)
 
        lbl_cloture = tk.Label(f_entry, text="Cloture : ", bg=color, width=20)
        lbl_cloture.grid(row=3, column=4, padx=5, pady=5)
        e_cloture = tk.Label(f_entry, bg=color, width=20)
        e_cloture.grid(row=3, column=5, padx=5, pady=5)

Mon problème est donc dans le module Nouvelleconsigne lorsque je fais ajouter j'aimerais que le treeview dans le module Main s'actualise directement, que je vois instantanement la consigne que j'ai ajoutée.
Actuellement ça ne fonctionne qu'après une action.

J'espère etre plus clair dans ma demande.
Le code est bordelique, je sais, tout conseil est le bienvenu :ave:
Merci

20/11/2021, 20h48
wiztricks

Citation:

Envoyé par cegehi

Actuellement ça ne fonctionne qu'après une action.

J'espère etre plus clair dans ma demande.
Le code est bordelique, je sais, tout conseil est le bienvenu :ave:
Merci

"main" est le seul module qu'on va pouvoir importer 2 fois (et qu'il ne faut pas importer car ce faisant il perd sa propriété de singleton)

Ce qui fait que tout ce qui est dans sous la condition __name__ == "__main__" ne sera exécuté qu'en tant que script principal et non via import où app ne sera pas défini.

Ce problème là n'a rien à voir avec tkinter et se reproduit en quelques lignes de code.

Il a certainement de meilleures solutions pour faire ce que vous voulez faire... comme récupérer dynamiquement la fenêtre principale (via tkinter) ou comment passer la fenêtre principale en argument de la fênetre secondaire (ce que vous faites déjà... sans l'exploiter).

Mais si vous voulez vous lancer à faire des choses compliquées avec tkinter, il faut y aller mollo. Car si tkinter est facile pour débuter et toucher un peu à la programmation évènementielle, il est ensuite limité par la patience du programmeur à coder avec (on peut faire des choses sympa mais c'est du boulot pour le faire correctement).

- W
22/11/2021, 18h36
cegehi
Merci wiztricks pour la réponse mais une fois encore, je ne comprends pas tout.

J'aimerai qu'on m'explique pourquoi ça ne fonctionne pas.

Dans le module Archives, mon tableau (une instance de la class Mytreeview dans le module Afftreeview) s'affiche grâce à :
Code:

1 2 3 tree = MyTreeview(self, 2, 1, 4, 0) Bdd.Affichage(tree.c_tree, 0)
Dans le module Nouvelleconsigne, je pensais donc pouvoir appeler la procédure Bdd.affichage avec en paramètre : Archives.tree.c_tree.
soit

Code:

Bdd.Affichage(Archives.tree.c_tree, 0)

Mais cela ne fonctionne pas et j'ai le message déjà cité précédemment : AttributeError: module 'Archives' has no attribute 'tree'.

Qu'est ce que je ne comprend pas ? :marteau:
Merci
22/11/2021, 18h52
wiztricks
Citation:

Envoyé par cegehi

Qu'est ce que je ne comprend pas ?

Il y a une différence entre script principal et module. Un module ne sera importé qu'une fois, alors que le script principal sera lu au lancement du programme et aura pour nom __main__ et si on l'importe en tant que module, ce sera un module avec le nom Main. Et un module différent vu tout ce qui n'est pas exécuté via if __name __ == '__main__'.

Vous pouvez tester avec un truc simple:
main.py
Code:

1 2 3 4 5 6 import toto b = 1 if __name__ == '__main__': a = 123 toto.f()
toto.py
Code:

1 2 3 4 def f(): print(main.a) import main
Et si vous voulez encore plus de surprises, pas sur que le b de __main__ soit le b de main.b

=> Ca ne marche pas parce que ça ne peut pas marcher.

Mais rien ne vous empêche d'avoir une classe (dans main) hérité (ou pas) de Tk dont l'instance sera appelée app avec pour attribut mytree pour le Treeview.
Vous passez déjà app à la création de NewCons et donc tout ce qu'il faut pour accéder à app.mytree.

C'est de la POO basique... mais vu comme vous maltraitez cela, je comprends que ce soit difficile à piger mais vous devez prendre le temps d'ouvrir un tuto pour apprendre plutôt que de vouloir faire tomber en marche des trucs mal construits.

- W
22/11/2021, 22h22
cegehi
J'ai finalement trouvé une solution à mon problème.
Partant de la remarque

Citation:

Il a certainement de meilleures solutions pour faire ce que vous voulez faire... comme récupérer dynamiquement la fenêtre principale (via tkinter) ou comment passer la fenêtre principale en argument de la fênetre secondaire (ce que vous faites déjà... sans l'exploiter).

J'ai donc changé la class NewCons qui ne me servait pas à grand chose pour plutôt ne faire qu'une " simple" fonction avec pour argument le treeview.
Code:

1 2 def newcons(treev): new = tk.Toplevel()
et dans Main j'appelle avec :
Code:

1 2 def open_nouvelle(): window_n = Nouvelleconsigne.newcons(mytree)
Ma façon de faire est elle correcte ? en partie oui car j'arrive à faire ce que je voulais :roll: mais est ce correct d'un point de vue python?
22/11/2021, 23h01
wiztricks

Citation:

Envoyé par cegehi

Ma façon de faire est elle correcte ? en partie oui car j'arrive à faire ce que je voulais :roll: mais est ce correct d'un point de vue python?

Si le critère est "ça marche alors c'est bon" alors c'est correct.

Pour écrire une solution quelque soit le langage se fera avec le sous-ensemble du langage qu'on maîtrise. Maîtriser ne veut pas dire "savoir-faire" mais connaître ses limites pour ne pas faire n'importe quoi.

Par exemple, quand on code et que çà ne marche pas, il est important de pouvoir relire son code et comprendre ses erreurs. Pouvoir se relire suppose utiliser des constructions dont on est confiant du résultat (quitte à tester sur un petit exemple/brouillon).

A défaut, en cas de problème on ne sait pas où chercher... Et comme faire deux trois trucs, c'est plein de lignes de code qui vont devoir interagir, "programmer", c'est plus faire le plan de construction du programme qui permettra de le construire pas à pas sans problème que de coder avec un Python avancé.

- W