Récupérer la largeur d'un bouton situé en dehors de la fenêtre

**Arsene12** · 17/12/2018, 13h34

Bonjour,

j'ai une fenêtre principale appelée master qui contient une autre fenêtre appelée conteneur dans laquelle sont alignés des boutons. La largeur de la fenêtre principale est inférieure à la largeur de la fenêtre qui contient les boutons. Je voudrais en cliquant sur le bouton OK dans mon code ci-dessous pouvoir récupérer la largeur de tous mes boutons. Or j'obtiens un width = 1 pour ceux qui sont situés en dehors de la frame. Pour le bouton à cheval, j'obtiens la largeur de la partie visible du bouton. Pourriez-vous m'aider à obtenir la taille entière de tous les boutons svp? Merci d'avance.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
from tkinter import *
 
 
master = Tk()
L = 300#master.winfo_screenwidth()
H = 160#master.winfo_screenheight()
 
tailleConteneur=500
 
bout=[]
bout1=[]
master.maxsize(L,H)
#master.geometry("320x600")
 
texte = [("HxxxxxrrxxxxH"),("JxxxxxxxxxxxxxR"),("MxxxxxxxxxxxxxO"),("SxxxxxxxxxxxxxxxxT"),("MxxxxxxxxxxxxxxxxxxxxxxxxxxN"),("ExxxxxxxxxxxxxxxxxxxxN")]
 
def callback() :
 
    conteneur = Frame(master, bg='yellow')
    conteneur.pack()
 
    pack = False
    i = 0
 
    for mot in texte :
        if not pack : # pour créer la première rangée de bouton
            frame = Frame(conteneur, bg="red", width=tailleConteneur, height=60)
            frame.pack()
            frame.pack_propagate(False)
            i += 1
            pack = True
 
        try :
            # On pack en définissant le parent
            pass
            bout.pack(in_=frame, side='left')
        except :
            pass
        # On ne définit pas le parent
        bout = Button(text=mot, bg="orange")
        w1= (bout,mot)
        bout1.append(w1)  
        larg = bout.winfo_reqwidth()
        bout.pack(in_=frame, side='left')
 
callback()
 
def mesure():
    myLong="0"
    count=0
    for el in bout1 :  # On détermine la largeur de l'ensemble des boutons d'une même rangée
        count+=1
        myLong=int(myLong)+int(el[0].winfo_width())
        print(" Bouton N° " + str(count) + " : " + str(el[0].winfo_width()))# +" : "+str(el[0]["text"]))
 
 
g = Button(master, text="OK", command=mesure)
g.pack()
 
mainloop()

**wiztricks** · 17/12/2018, 15h58

Salut,

Envoyé par Arsene12

Pour le bouton à cheval, j'obtiens la largeur de la partie visible du bouton.

.winfo_width retourne un nombre de pixels correspondant à la largeur de ce qui est affiché.
S'il n'y a plus assez de place dans la Frame pour tout afficher, il retourne la dimension du bout qui a pu être affiché, et s'il n'y a plus de place çà retournera 1 (et çà n'affiche rien en dehors).
C'est comme çà que "pack" fonctionne.

Envoyé par Arsene12

Pourriez-vous m'aider à obtenir la taille entière de tous les boutons svp?

Si vous voulez calculer la dimension du widget que lui aurait donnée "pack", il vous fait étudier l'algorithme de pack et en écrire votre mouture.

Et vous répéter une fois encore que vous seriez moins embêté en utilisant un Canvas et en créant vos propres Button plutôt que de triturer "pack" et "grid" dans tous les sens en espérant qu'ils voudront bien satisfaire vos desiderata.

- W

**Arsene12** · 17/12/2018, 18h02

Merci pour ces précisions. Mais je répète, le Canvas n'est pas adapté à cette partie-là de mon code. Dans l'application que je suis en train de faire, dès qu'un bouton dépasse le bord droit, je créé une nouvelle frame en dessous et je l'y insère. Voici un bout de code !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
            for el in bout :  # On détermine la largeur de l'ensemble des boutons d'une même rangée
                if el[0].pack_info()['in']==mesFrames[i]: # si le bouton appartient à la frame en question
                   myLong=myLong+el[0].winfo_width() # on rajoute la longueur du bouton

Ensuite je retire tous les boutons qui dépassent

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

while myLong>longConteneur :

Normalement le signe > devrait suffire pour retirer tous les boutons, si on commence bien sûr par ceux situés en bout de rangée. Celui qui chevauche sera retiré aussi car on aura myLong=longConteneur

Mais y'a quelque qui marche pas. Pour récupérer le dernier bouton de la frame, je fais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
                for el in bout :                  #Récupération du dernier bouton de la frame
                    if el[0].pack_info()['in']==mesFrames[i]:
                        myBtn=el[0]

Pour le retirer et le recréer, je fais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
myBtn.pack_forget()
myBtn.pack(in_=myFrame2)  # myFrame2=mesFrames[i+1]

Pour respecter l'ordre, je dois recomposer la frame comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
                for el in bout :
                  if el[0].pack_info()['in']==myFrame2:
                     el[0].pack_forget()
                     el[0].pack(in_=myFrame2, side=LEFT)

Ensuite je boucle pour retirer tous les boutons.

Quand je les aurai placé dans une autre frame, à ce moment-là je pourrais connaître leur width et mon problème sera résolu.

**wiztricks** · 17/12/2018, 18h29

Envoyé par Arsene12

Mais je répète, le Canvas n'est pas adapté à cette partie-là de mon code.

Je suis d'accord, c'est à vous d'adapter le Canvas à ce que vous voulez faire.
La seule chose que je dis, c'est que vous n'aurez plus "grid" et "pack" qui foutront le bazar au milieu.

Envoyé par Arsene12

Dans l'application que je suis en train de faire, dès qu'un bouton dépasse le bord droit, je créé une nouvelle frame en dessous et je l'y insère.

Et vous voici encore parti sur un autre sujet... pour lequel on vous a déjà donné une solution il y a quelques semaines.
Bonne continuation.

- W

**Arsene12** · 19/12/2018, 06h47

Envoyé par wiztricks

Et vous voici encore parti sur un autre sujet... pour lequel on vous a déjà donné une solution il y a quelques semaines.
- W

Pour récupérer la largeur d'un bouton situé en dehors de la fenêtre, c'est le titre de mon sujet, il faut déplacer ce bouton. La solution d'il y a quelques semaines ne comportait pas la condition.

Je crois que je suis sur la bonne voie. Dans l'exemple ci-dessous, j'ai 3 rangées de boutons. La deuxième contient des boutons qui sont hors champs.
Lorsqu'on clique sur "OK", tous les boutons qui sont situé après le bord droit du conteneur sont déplacé dans la rangée du dessous. Je dois m'arranger pour que ça fonctionne aussi avec la première rangée. Pour la dernière, c'est différent car il faut que je créé en plus une nouvelle frame.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
from tkinter import *
from tkinter import ttk
 
master = Tk()
bout=[]
mesFrames=[]
tailleConteneur=500
L = tailleConteneur#master.winfo_screenwidth()
H = master.winfo_screenheight()
 
master.maxsize(tailleConteneur,H)
 
 
def callback() :
    conteneur = Frame(master, bg='green', width=tailleConteneur)
    conteneur.pack() 
    n = 0
    texte = [("")]
    texte0 = [("HxxxG")]
    texte1 = [("Euuut")]
    texte2 = [("HxxxxxrrxxxxH"),("JxxxxxxxxxxxxxR"),("MxxxxxxxxxxxxxO"),("SxxxxxxxxxxxxxxxxT"),("MxxxxxxxxxxxxxxxxxxxxxxxxxxN"),("ExxxxxxxxxxxxxxxxxxxxN")]
 
 
    for mot in texte0 :        
                frame = Frame(conteneur, bg='grey', width=tailleConteneur, height=130)
                frame.pack()
                mesFrames.append(frame)
                w = Button(text=mot, font='arial 16', fg="black", bg="yellow")#, command=lambda j=n: OnButton2Click(j))                    
                w.pack(in_=frame, side='left')
                w1=(w, n, mot)
                bout.append(w1)               
 
    for mot in texte1 :        
                frame = Frame(conteneur, bg='grey', width=tailleConteneur, height=130)
                frame.pack()
                mesFrames.append(frame)
                w = Button(text=mot, font='arial 16', fg="black", bg="yellow")#, command=lambda j=n: OnButton2Click(j))                    
                w.pack(in_=frame, side='left')
                w1=(w, n, mot)
                bout.append(w1)
 
    for mot in texte2 :        
                w = Button(text=mot, font='arial 16', fg="black", bg="yellow")#, command=lambda j=n: OnButton2Click(j))                    
                w.pack(in_=frame, side='left')
                w1=(w, n, mot)
                bout.append(w1)
 
    for mot in texte1 :        
                frame = Frame(conteneur, bg='grey', width=tailleConteneur, height=130)
                frame.pack()
                mesFrames.append(frame)
                w = Button(text=mot, font='arial 16', fg="black", bg="yellow")#, command=lambda j=n: OnButton2Click(j))                    
                w.pack(in_=frame, side='left')
                w1=(w, n, mot)
                bout.append(w1)               
 
 
def formatage():
    numberFrame = len(mesFrames)
    i=0    
    count=0
    while i<numberFrame:
         print(i)
         myFrame = mesFrames[i]
         myFrame2="STOP"
         frameSuivante=0
         for frame in mesFrames :
             count+=1
             if frame == myFrame :
                frameSuivante=1
                myFrame2="STOP"
             elif frameSuivante==1 and len(mesFrames)>count:
                frameSuivante=2 
                myFrame2="STOP"
             elif frameSuivante==1 :
                myFrame2=frame
                frameSuivante=2  
 
         if myFrame2=="STOP" :
               pass
         else :
             myLong=0
 
             for el in bout :                            # on récupère la longueur de la frame
                 if el[0].pack_info()['in']==myFrame:
                    print(el[0]) 
                    myLong=myLong+el[0].winfo_width()
 
             #if myLong<tailleConteneur or myLong>=tailleConteneur :
             print(myLong)
             print(tailleConteneur)                 
             while myLong>=tailleConteneur :
                 print(myLong)
 
                 for el in bout :
                     if el[0].pack_info()['in']==myFrame:  # on récupère le dernier bouton de la frame
                             print("myLong = "+str(myLong))
                             myBtn=el[0]
                 myBtn.pack_forget()                    # on déplace le dernier bouton sur la frame suivante
                 myBtn.pack(in_=myFrame2, side=LEFT)
                 myLong=myLong-myBtn.winfo_width()
 
         i=i+1                   
 
 
g = Button(master, text="OK", command=formatage)
g.pack()
 
callback() 
mainloop()

**Arsene12** · 19/12/2018, 08h36

J'ai fait une autre tentative, c'est pas encore ça.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
from tkinter import *
from tkinter import ttk
 
master = Tk()
bout=[]
mesFrames=[]
tailleConteneur=500
L = tailleConteneur#master.winfo_screenwidth()
H = master.winfo_screenheight()
 
master.maxsize(tailleConteneur,H)
 
 
def callback() :
    conteneur = Frame(master, bg='green', width=tailleConteneur)
    conteneur.pack() 
    texte = [("Tout"),("condamné"),("à"),("mort"),("aura"),("la"),("tête"),("tranchée"),(".")]
 
    for n in range(10):
 
        frame = Frame(conteneur, bg='grey', width=tailleConteneur, height=130)
        frame.pack()
        mesFrames.append(frame)
        for mot in texte :   
                    w = Button(text=mot, font='arial 20', fg="black", bg="yellow")#, command=lambda j=n: OnButton2Click(j))                    
                    w.pack(in_=frame, side='left')
                    w1=(w, n, mot)
                    bout.append(w1)
 
def formatage():
    numberFrame = len(mesFrames)
    i=0    
    count=1
    while i<numberFrame-1:
        myLong=0
        print("Rangée N° = "+str(count))
        master.update()
 
        for frame in mesFrames :
              print(frame)
              pass
 
        myFrame = mesFrames[i]
        myFrame2 = mesFrames[i+1]
 
        for el in bout :                            # on récupère la longueur de la frame
                     if el[0].pack_info()['in']==myFrame:
                        #print(el[0]) 
                        myLong=myLong+el[0].winfo_width()
 
        #if myLong<tailleConteneur or myLong>=tailleConteneur :
        print("myLong = "+str(myLong)+" Rangée N° = "+str(count))               
        while myLong>=tailleConteneur :
                     print("myLong = "+str(myLong)+" Rangée N° = "+str(count))
                     for el in bout :
                         if el[0].pack_info()['in']==myFrame:  # on récupère le dernier bouton de la frame                                 
                                 myBtn=el[0]
                     myBtn.pack_forget()                    # on déplace le dernier bouton sur la frame suivante
                     myBtn.pack(in_=myFrame2, side=LEFT)
                     myLong=myLong-myBtn.winfo_width()
                     print("myLong = "+str(myLong)+" Rangée N° = "+str(count))
 
        count+=1
        i+=1         
 
g = Button(master, text="TEST", command=formatage)
g.pack()
 
callback() 
mainloop()

**Arsene12** · 19/12/2018, 08h50

Là j'y suis presque mais les boutons ne sont pas alignés sur la gauche.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
from tkinter import *
from tkinter import ttk
 
master = Tk()
bout=[]
mesFrames=[]
tailleConteneur=500
L = tailleConteneur#master.winfo_screenwidth()
H = master.winfo_screenheight()
 
master.maxsize(tailleConteneur,H)
 
 
def callback() :
    conteneur = Frame(master, bg='green', width=tailleConteneur)
    conteneur.pack() 
    texte = [("Tout"),("condamné"),("à"),("mort"),("aura"),("la"),("tête"),("tranchée"),(".")]
 
    for n in range(10):
 
        frame = Frame(conteneur, bg='grey', width=tailleConteneur, height=130)
        frame.pack()
        mesFrames.append(frame)
        for mot in texte :   
                    w = Button(text=mot, font='arial 20', fg="black", bg="yellow")#, command=lambda j=n: OnButton2Click(j))                    
                    w.pack(in_=frame, side='left')
                    w1=(w, n, mot)
                    bout.append(w1)
 
def formatage():
    numberFrame = len(mesFrames)
    i=0    
    count=1
    while i<numberFrame-1:
        myLong=0
        print("Rangée N° = "+str(count))
        master.update()
 
        for frame in mesFrames :
              print(frame)
              pass
 
        if i<numberFrame-2 :
            myFrame = mesFrames[i]
            myFrame2 = mesFrames[i+1]
 
            for el in bout :                            # on récupère la longueur de la frame
                         if el[0].pack_info()['in']==myFrame:
                            #print(el[0]) 
                            myLong=myLong+el[0].winfo_width()
 
            #if myLong<tailleConteneur or myLong>=tailleConteneur :
            print("myLong = "+str(myLong)+" Rangée N° = "+str(count))               
            while myLong>=tailleConteneur :
                         print("myLong = "+str(myLong)+" Rangée N° = "+str(count))
                         for el in bout :
                             if el[0].pack_info()['in']==myFrame:  # on récupère le dernier bouton de la frame                                 
                                     myBtn=el[0]
                         myBtn.pack_forget()                    # on déplace le dernier bouton sur la frame suivante
                         myBtn.pack(in_=myFrame2, side=LEFT)
                         for el in bout :
                             if el[0].pack_info()['in']==myFrame2:  # on récupère le dernier bouton de la frame                                 
                                 el[0].pack_forget()                    # on déplace le dernier bouton sur la frame suivante
                                 el[0].pack(in_=myFrame2, side=LEFT)
 
                         myLong=myLong-myBtn.winfo_width()
                         print("myLong = "+str(myLong)+" Rangée N° = "+str(count))
 
        count+=1
        i+=1                   
 
 
g = Button(master, text="OK", command=formatage)
g.pack()
 
callback() 
mainloop()

**Arsene12** · 20/12/2018, 06h34

Voici la solution. Il fallait utiliser grid au lieu de pack pour insérer les frames. Réinsérer l'intégralité des boutons à l'intérieur de la fenêtre principale permet connaitre leur largeur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
from tkinter import *
from tkinter import ttk
 
master = Tk()
bout=[]
mesFrames=[]
tailleConteneur=500
L = tailleConteneur#master.winfo_screenwidth()
H = master.winfo_screenheight()
 
master.maxsize(tailleConteneur,H) 
 
 
def formatage():
    numberFrame = len(mesFrames)
    i=0    
    count=1
    while i<=numberFrame-1:
        myLong=0
        master.update()
 
        for frame in mesFrames :
              #print(frame)
              pass           
 
        myFrame = mesFrames[i]
        for el in bout :                            # on récupère la longueur de la frame
                         if el[0].pack_info()['in']==myFrame:
                            #print(el[0]) 
                            myLong=myLong+el[0].winfo_width()
        if i<numberFrame-1 :
            myFrame2 = mesFrames[i+1]
 
        elif i==numberFrame-1 and myLong>=tailleConteneur :
                frame = Frame(conteneur, bg='grey', width=tailleConteneur, height=130)
                frame.grid(sticky=W, row=numberFrame, column=0)
                mesFrames.append(frame)                
                myFrame = mesFrames[i]
                myFrame2 = mesFrames[i+1]
                numberFrame=numberFrame+1
 
        #if myLong<tailleConteneur or myLong>=tailleConteneur :
        #print("myLong = "+str(myLong)+" Rangée N° = "+str(count))               
        while myLong>=tailleConteneur :
                         #print("myLong = "+str(myLong)+" Rangée N° = "+str(count))
                         for el in bout :
                             if el[0].pack_info()['in']==myFrame:  # on récupère le dernier bouton de la frame                                 
                                     myBtn=el[0]
                         myBtn.pack_forget()                    # on déplace le dernier bouton sur la frame suivante
                         myBtn.pack(in_=myFrame2, side='left')
                         for el in bout :
                             if el[0].pack_info()['in']==myFrame2:  # on récupère le dernier bouton de la frame                                 
                                 el[0].pack_forget()                    # on déplace le dernier bouton sur la frame suivante
                                 el[0].pack(in_=myFrame2, side='left')
 
                         myLong=myLong-myBtn.winfo_width()
                         #print("myLong = "+str(myLong)+" Rangée N° = "+str(count))
 
 
        count+=1
        i+=1
 
    for el in bout :
        print("Bouton : "+str(el[0])+" Largeur = "+str(el[0].winfo_width()))
 
 
g = Button(master, text="OK", command=formatage)
g.pack(side=TOP)
 
conteneur = Frame(master, bg='green', width=tailleConteneur)
conteneur.pack() 
 
def callback() :
 
    texte = [("Tout"),("condamné"),("à"),("mort"),("aura"),("la"),("tête"),("tranchée"),(".")]
 
    for n in range(5):
 
        frame = Frame(conteneur, bg='grey', width=tailleConteneur, height=130)
        frame.grid(sticky=W, row=n, column=0)
        mesFrames.append(frame)
        for mot in texte :   
                    w = Button(text=mot, font='arial 20', fg="black", bg="yellow")#, command=lambda j=n: OnButton2Click(j))                    
                    w.pack(in_=frame, side='left')
                    w1=(w, n, mot)
                    bout.append(w1)
 
callback() 
mainloop()

**wiztricks** · 23/12/2018, 17h01

Salut,

Laborieux votre code!

Si on fait un peu d'informatique (i.e. on essaie de mettre l'information en formes), vous avez N phrases (on dira des suites de mots séparés par des "espace"s se terminant par un ".") qui se terminent par une fin de ligne (ce qui en fait des paragraphes).
Donc on fait 2 choses:

transformer N paragraphes en un seul (en supprimant les retour à la ligne).
et côté affichage plutôt que d'afficher 1 paragraphe par ligne (qui déborde) on revient à la ligne.

Et ces choses là, le widget Text sait déjà le faire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
import tkinter as tk
 
def text_search(text, s):
    return tuple(
        [ str(z) for z in text.tk.call(
            (text._w, 'search', '-forwards', '-all', s, '1.0', 'end')
            )
          ])
 
 
def set_wrap_none(text):
    indexes = text_search(text, '.')
    for z in indexes[::-1]:
        text.replace(z + '+1c', z + '+2c', '\n')
    text['wrap'] = 'none'        
 
def set_wrap_word(text):
    indexes = text_search(text, '\n')
    for z in indexes[::-1]:
        text.replace(z, z + '+1c', ' ')
    text['wrap'] = 'word'
 
 
if __name__ == '__main__':
 
    data = "Tout condamné à mort aura la tête tranchée.\n" * 5
 
    text = tk.Text(width=30, wrap='word')
    text.pack()
    text.tag_configure('word', background='yellow', foreground='black')
    for line in data.splitlines():
        words = line.split(' ')
        for w in words[:-1]:
            text.insert('end', w, 'word', ' ')
        text.insert('end', words[-1], 'word', '\n')
 
    def toggle():
        wrap = text['wrap']
        if wrap == 'none':
            set_wrap_word(text)
        elif wrap == 'word':
            set_wrap_none(text)
        else:
            raise ValueError('Unexpected wrap mode: %s' % wrap)
 
    tk.Button(text='toggle', command=toggle).pack()
    tk.mainloop()

Après on peut dire, non, non, je veux avoir mon tas de Button. Et dans ce cas, utiliser un Canvas:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
import tkinter as tk
 
class Button(tk.Button):
    iid = None
    def __init__(self, canvas, text):
        super().__init__(canvas, text=text, font='arial 20', fg="black", bg="yellow")
        self._canvas = canvas
        self.text = text
 
    def moveto(self, x, y):
        canvas = self._canvas
        if self.iid is None:
            self.iid = canvas.create_window(x, y, window=self, anchor='nw')
        else:
            canvas.coords(self.iid, x, y)
 
 
def set_wrap_none(canvas, buttons):
    x = y = 0
    for btn in buttons:
        btn.moveto(x, y)
        x0, y0, x1, y1 = canvas.bbox(btn.iid)
        x = x1
        if word == '.':
            x = 0
            y = y1
    canvas._wrap = 'none'
 
 
def set_wrap_word(canvas, buttons):
    x = y = 0
    for btn in buttons:
        btn.moveto(x, y)
        x0, y0, x1, y1 = canvas.bbox(btn.iid)
        if x1 >= int(canvas['width']):
            x = 0
            y = y1
            btn.moveto(x, y)
        x += x1 - x0
    canvas._wrap = 'word'
 
if __name__ == '__main__':
    data = "Tout condamné à mort aura la tête tranchée .".split(' ') * 5
 
    canvas = tk.Canvas(width=500, height=500)
    canvas.pack()
 
    buttons = [ Button(canvas, text=text,
                    font='arial 20', fg="black", bg="yellow"
                    ) for text in data ]
 
    set_wrap_none(canvas, buttons)   
 
    def toggle():
        if canvas._wrap == 'none':
            set_wrap_word(canvas, buttons)
        elif canvas._wrap == 'word':
            set_wrap_none(canvas, buttons)   
 
    tk.Button(text='toggle', command=toggle).pack()
    tk.mainloop()

- W

Récupérer la largeur d'un bouton situé en dehors de la fenêtre

Tkinter Python

Discussions similaires

Partager

Partager