Discussion :

[austin57]

Bonjour à tous,

Je suis actuellement en train de suivre le livre de G.Swinnen sur Pytohn en l'adaptant à la sauce ttk (car je trouve le thème Tkinter de base vraiment très vilain).

Sauf que je bute sur l'utilisation du widget "labeledscale" destiné à remplacer le widget "scale".
Il est noté comme extension du widget ttk "scale" mais je n'arrive à faire rien d'autres que choisir de mettre le texte de la valeur courant au-dessus ou en-dessous du curseur.

Voici le code d'origine

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
from tkinter import *
 
def updateLabel(x):
    lab.configure(text='Valeur actuelle = ' + str(x))
 
root = Tk()
xx = Scale(root, length=250, orient=HORIZONTAL, label='Réglage:', troughcolor="dark grey", sliderlength="20",\
           showvalue='0', from_=-25, to=125, tickinterval=25, command=updateLabel)
xx.pack()
lab = Label(root)
lab.pack()
root.mainloop()

Voici le mieux que j'arrive faire

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
from tkinter import *
from tkinter import ttk
 
def updateLabel(x):
    lab.configure(text='Valeur actuelle = ' + str(x))
 
root = Tk()
xx = ttk.LabeledScale(root, from_=-25, to=125, compound="bottom")
xx.pack()
lab = Label(root)
lab.pack()
root.mainloop()

On remarque que quasiment aucune fonction de scale n'est valable, pire même la fonction "command" passe à la trappe et pour le fun, un petit bug graphique lorsque le curseur arrive au milieu, le texte semble masqué par quelque chose. J'ai beau Googler pour trouver des exemples, cette fonction n'est que très peu documentée (je suis gentil là :p )

Voilà, si quelqu'un sait comment utiliser ce widget ttk, je suis pas contre une explication de texte. Merci d'avance à vous.

Cordialement,
Damien

[wiztricks]

Salut,

stricto sensu, ttk.Scale devrait remplacer tk.Scale.
ttk.LabeledScale n'est pas un widget "ttk" a proprement parler, c'est un widget Python qui bouche un des nombreux trous de ttk.Scale (compare a tk.Scale): afficher la valeur courante.
Les "trous" étant l'ensemble des options qu'on peut préciser a tk.Scale et qui sont absentes de ttk.Scale.
Dans la pratique comment on joue avec?
tk.Scale: le code reprend le votre.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
import tkinter as tk
from tkinter.constants import *
import tkinter.ttk as ttk
 
def use_tk_widgets(app):
    scale_cfg = dict(
        length=250, orient=HORIZONTAL,
        label='Réglage:', troughcolor="dark grey",
        sliderlength="20", showvalue='0',
        from_=-25, to=125, tickinterval=25)
 
    return tk.Scale(app, scale_cfg, command=update_label)

ttk.Scale: moins d'options mais toujours "command".

Code :

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

1
2
3
def use_ttk_widgets(app):
    scale_cfg = dict(from_=-25, length=250, orient=HORIZONTAL, to=125, value=0)
    return ttk.Scale(app, command=update_label, **scale_cfg)

ttk.LabeledScale est un tk.Frame dans lequel on été créés un ttk.Scale et un ttk.Label. Le Label affiche la valeur du "scale".
Si vous voulez garder update_label, il faut définir le callback update_label en accédant a l'attribut "scale" de l'objet crée:

Code :

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

1
2
3
4
def use_ttk_labeledscale(app):
    w = ttk.LabeledScale(app, from_=-25, to=125)
    w.scale['command'] = update_label
    return w

Pour jouer avec chaque widgets:

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
def update_label(x):
    label['text'] = 'Valeur actuelle: %s' % x
 
if __name__ == '__main__':
 
    app = tk.Tk()
    app.geometry('300x200')
    tk.Button(text='next', command=app.quit).grid(row=0)
    label = tk.Label()
    label.grid(row=2)
 
    for start in use_tk_widgets, use_ttk_widgets, use_ttk_labeledscale:
        w = start(app)
        w.grid(row=1)
        update_label(0)
        app.mainloop()
        w.destroy()

remplacer les widgets tk par ceux de ttk n'est pas toujours une bonne idée d'autant qu'ils se mélangent assez bien.

- W

[austin57]

Merci pour votre réponse si rapide.

Donc, en définitive, si j'ai bien compris, cela veut aussi dire qu'à l'heure actuelle, impossible d'obtenir le même rendu que tk.scale avec ttk.scale :.(
Le seul "plus" de labeledscale, c'est l'affichage de la valeur courante et a moins de créer son propre widget, avec par exemple, l'affichage d'intervalles significatifs (0,5,10,...) avec plusieurs labels, point de salut.

[austin57]

Suite au problème ci-dessus, je me suis mis en tête de créer mon propre widget.
Je suis arrivé à des résultats intéressants mais je bloque sur le positionnement précis des labels qui indique la postion du curseur le long de la glissière.

Lorsque le curseur arrive en face d'une valeur, par exemple 300, la méthode scale.get() renvoi une valeur proche (par exemple:314) mais pas 300.
Les labels sont légèrement décalés et après plusieurs essais infructueux, j'aurai bien besoin d'une explication.
Il doit y avoir quelque chose de particulier à savoir su le positionnement du label mais impossible de mettre la main dessus. En tout cas, cela se joue à quelques pixels.

Ci-dessous, une version simplifiée pour illustrer le problème.

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
from tkinter import *
from tkinter import ttk
 
def update(x):
    print(scale.get())
 
settings = [0,500,100]
interval = int((settings[1]-settings[0])/settings[2])
 
root = Tk()
# Création du widget Scale
scale = ttk.Scale(root, from_=settings[0], to=settings[1], length=500, command=update)
scale.grid(row=1, column=1, rowspan=1, columnspan=interval+1, sticky=EW)
 
# Définition du label de départ
start = ttk.Label(text='0')
start.grid(row=0, column=1, sticky=W)
 
# Définition des labels intermediaires
for i in range(0,interval-1,1):
    z = ttk.Label(root,text=str(round(settings[0]+settings[2]*(i+1),0)))
    z.place(x=(settings[2]*(i+1)), y=0)
 
# Définition du label de fin
finish = ttk.Label(root, text=str(settings[1]))
finish.grid(row=0, column=interval+1, sticky=E)
 
root.mainloop()

Merci d'avance pour votre aide.
Damien

[wiztricks]

Salut,

C'est plutôt prise de chou avec papier millimètre et/ou un Canvas dans lequel on construit une réglette avec des labels au dessus.
Sans oublier d'entrer dans les détails sur la gestion des bords (si on les voit, ils ont une épaisseur).

- W

[austin57]

Bonjour,

Je vais essayé de potasser cela, j'ai trouvé une piste mais qui ne semble fonctionner que sur des ensembles positifs.
Je verrai.

Merci pour la réponse, on se sent moins seul

[austin57]

Bonjour,

C'est encore moi, enfin, avec quelques cheveux de moins. Après mettre bien cassé la tête pour positionner les labels le long de ma réglette, j'ai lâché l'affaire.
Un vrai jeu de devinette pour trouver la bonne position, puis la gestion du redimensionnement, du système d'exploitation (skin différent qui modifie l'aspect et légèrement les positions), je me suis dis que je ne prenais pas le problème par le bon bout.
Ainsi, plutôt que de deviner la position sur la réglette par des calculs savants, je demande au widget de me donner la position pour les valeurs qui m'intéresse et j'utilise la valeur retournée.
J'ai fais un test, voici ce que cela donne:

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
from tkinter import *
from tkinter import ttk
 
 
root = Tk()
w = ttk.Label(root, text='debut')
w.grid(row=2, column=1)
 
def update(x):
    print(scale.get(), scale.coords())
    w.configure(text='Valeur actuelle = ' + str(round(float(x),0)))
 
settings = [-300,500,125]
interval = int((settings[1]-settings[0])/settings[2])
 
 
# Création du widget Scale
scale = ttk.Scale(root, from_=settings[0], to=settings[1], length=500, command=update)
scale.grid(row=1, column=1, rowspan=1, columnspan=interval+1, sticky=EW)
 
# Définition du label de départ
start = ttk.Label(text='0')
start.grid(row=0, column=1, sticky=W)
 
# Définition des labels intermediaires
for i in range(0, interval-1, 1):
    current = round(settings[0]+settings[2]*(i+1),0)
    scale.set(current)
    scale.update()
    z = ttk.Label(root,text=str(round(settings[0]+settings[2]*(i+1),0)), background='blue')
    z.place(x=scale.coords(current)[0], y=10, anchor=CENTER)
 
# Définition du label de fin
finish = ttk.Label(root, text=str(settings[1]))
finish.grid(row=0, column=interval+1, sticky=E)
 
root.mainloop()

Comme ça, c'est bien ce que je veux et ça fonctionne! Je me suis donc attelé à créer une classe de widget spécifique, voici le code:

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
from tkinter import *
from tkinter import ttk
 
class ExtendScale(Frame):
    def __init__(self, master=NONE):
        Frame.__init__(self)
 
        settings = [0,500,100]
        interval = int((settings[1]-settings[0])/settings[2])
 
        # Création du widget Scale
        self.scale = ttk.Scale(self, from_=settings[0], to=settings[1], length=500, command=self.updateLabel)
        self.scale.grid(row=1, column=1, rowspan=1, columnspan=interval+1, sticky=EW)
 
        ############
        # Ajout d'un label pour test
        self.label = ttk.Label(self)
        self.label.grid(row=3, column=1)
        ############
 
        # Définition du label de départ
        self.start = ttk.Label(self, text='0')
        self.start.grid(row=0, column=1, sticky=W)
 
        # Définition des labels intermediaires
        for i in range(0,interval-1, 1):
            current = round(settings[0]+settings[2]*(i+1),0)
            self.scale.set(current)
            self.scale.update()
            z = ttk.Label(self, text=str(round(settings[0]+settings[2]*(i+1),0)), background='blue')
            z.place(x=self.scale.coords(current)[0], y=10, anchor=CENTER)
 
        # Définition du label de fin
        finish = ttk.Label(self, text=str(settings[1]))
        finish.grid(row=0, column=interval+1, sticky=E)
 
    def updateLabel(self, widget):
        """test"""
        self.label.configure(text='Valeur actuelle = ' + str(round(float(widget), 0)))
 
if __name__== "__main__":
    root = Tk()
    scale = ExtendScale(root)
    scale.grid()
    root.mainloop()

Mais là, craque... ça ne fonctionne plus, la ligne "self.scale.update()", ne fait plus effet et je ne récupère de "self.scale.coords()" que des zéros. Il y a certainement quelque chose qui se passe en interne qui empêche la mise à jour, un élément qui n'est pas crée ou quelque chose dans ce goût là. Et c'est là que j'aurai bien besoin d'une explication de texte.

Merci d'avance pour le coup de main.
Damien G.

[wiztricks]

Salut,

En ce moment, je n'ai pas assez de temps libre pour en passer sur ce sujet.
Je retiens que vous avez une mouture qui vous convient et qu'en voulant transformer ce code qui fonctionne avec:

• des variables globales
• dans le Toplevel associée a l'instance de Tk

En classe spécifique combinant les différents widgets dans une Frame, ça ne le fait plus.
Le soucis est dans le remplacement de Toplevel par Frame.
Ou plutôt dans la conséquence de:

Ainsi, plutôt que de deviner la position sur la réglette par des calculs savants, je demande au widget de me donner la position pour les valeurs qui m'intéresse et j'utilise la valeur retournée.

C'est une bonne idee... mais!
La conséquence est que pour que les widgets dans la Frame aient une position, il faut qu'elle ait une dimension.
Et pour avoir une dimension il faut que le parent lui ait impose un layout.
Ce qui passe par appeler .grid ou .pack des que possible (avant les calculs).
Essayez:

Code :

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

1
2
3
4
class ExtendScale(Frame):
    def __init__(self, master=NONE):
        Frame.__init__(self)
        self.pack()

Et virez le .grid qui traîne après l'instanciation.

Ça fonctionne mais ça aura d'autres conséquences.
Pour l'instant, je n'ai pas de meilleure idée.
Et je suis d'accord, calculez a la main c'est galère (sinon je l'aurais fait ou propose autre chose).
Mais c'est un bon exercice: ne jetez pas tout trop vite.

- W

[austin57]

Bonjour Wiztrick,

Je n'ai pas réussi à utiliser la méthode avec self.pack() juste après le constructeur de la classe parent. J'ai probablement omis quelques choses.
Mais ce n'est pas grave, en suivant votre conseil d'utiliser cela comme exercice, j'en suis revenu sur ma première idée en reprenant les calculs de position des labels depuis le début et en faisant un magnifique tableau excel (une dizaine de cellules à tout casser ).

Et bien, maintenant, j'arrive à quelque chose de bien plus probant. Je vais donc poursuivre dans cette voie, d'autant plus que je commence à bien mieux cerner la mécanique. Lorsque j'aurai avancé davantage, je publierai la nouvelle version.

En tous les cas, j'ai beaucoup d'admiration pour le temps que vous passez pour aider les autres (ainsi que d'autres sur le forum qui se reconnaîtront, je l'espère). Un très grand merci. Quelques lignes ou même un simple encouragement, ça redonne du peps.

A+

[austin57]

Rebonjour à tous,

Je suis toujours sur mon petit widget, j'en ai refais plusieurs versions en y ajoutant des options, bref, je lâche pas le morceau (et j'ai maintenant mes labels qui sont placés au millimètres ).
Il y a toutefois une chose que je ne comprends pas avec la méthode .place()
Si je l'utilise hors d'une classe, en utilsant .place(), python me crée bien une fenêtre adaptée pour recevoir mon widget et celui-ci est bien visible.
Par contre, dans une classe, impossible! Au mieux, j'arrive afficher le widget mais je dois agrandir la fenêtre car celui-ci est mal placé mais en général, je n'ai même rien du tout.
Les méthodes .pack() et .grid() fonctionnent, eux, sans problème. J'avais d'ailleurs utilisé comme astuce de prendre le premier label à afficher avec grid() pour bien agrandir la fenêtre avant de mettre en place les autres labels à la suite avec place(). C'est en voulant bien faire les choses que j'ai constater le problème (comprendre par là, ne pas utiliser grid() et place() dans un même conteneur)

Ci-dessous, un test de code, qui à mon sens devrait fonctionner mais qui ne fonctionne pas

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
from tkinter import *
from tkinter import ttk
 
 
class SuperScale(Frame):
    def __init__(self, master=NONE):
        Frame.__init__(self)
        #self.pack()
        self.scale = ttk.Scale(self,
              orient=HORIZONTAL,
              length=284,
              from_=0,
              to=250,)
 
        self.group = ttk.Frame(self)
        self.start = ttk.Label(self.group, text='test')
        self.start.place(x=270, y=26)
        self.scale.pack()
        self.group.pack()
 
if __name__== "__main__":
    root = Tk()
    x = SuperScale(root)
    x.pack()
    root.mainloop()

Ci-dessous, un bout de code qui fonctionne mais au moins deux choses qui me gêne:
1-Impossible de définir un parent pour le widget self.start, si je le fais, je perds l'affiche du widget
2-L'obligation d'utiliser self.finish avec .grid (ou .pack) pour agrandir la fenêtre principale, sinon les labels ne sont plus visibles.

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
from tkinter import *
from tkinter import ttk
 
 
class SuperScale(Frame):
    def __init__(self, master=NONE):
        Frame.__init__(self)
        #self.pack()
        self.scale = ttk.Scale(self,
              orient=HORIZONTAL,
              length=284,
              from_=0,
              to=250,)
 
        self.group = ttk.Frame(self)
        self.start = ttk.Label(text='0')
        self.start.place(x=270, y=26)
        self.finish = ttk.Label(self.group, text='retest')
        self.finish.grid(row=0, column=0)
        self.scale.grid(row=0, column=0, sticky='NE')
        self.group.grid(row=1, column=0, sticky='W')
 
if __name__== "__main__":
    root = Tk()
    x = SuperScale(root)
    x.pack()
    root.mainloop()

Voilà, si sur le principe général, je crois avoir bien saisie le fonctionnement des différents gestionnaires, il y a clairement des points de détails qui m'échappe et si quelqu'un peut m'expliquer ce qui se passe, ce serait sympa. Car après de très nombreux essais, j'ai du mal à comprendre.

Merci d'avance à vous pour vos réponses.

[wiztricks]

Salut,

J’évite .place!
Après quelques tests, si on ne donne pas de dimension a la Frame dans laquelle on va .place(r) un widget, ça ne le fait pas.

Rapporté dans votre premier exemple:

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
from tkinter import *
from tkinter import ttk
 
 
class SuperScale(ttk.Frame):
    def __init__(self, master=None):
        super().__init__(master)
        #self.pack()
        scale = ttk.Scale(self,
              orient=HORIZONTAL,
              length=284,
              from_=0,
              to=250,)
 
        group = ttk.Frame(self, width=284, height=50)
        start = ttk.Label(text='0')
        start.place(x=270, y=26)
        group.pack()
        scale.pack()
 
 
if __name__== "__main__":
    root = Tk()
    x = SuperScale(root)
    x.pack()
    root.mainloop()

Note! NONE est un str intéressant cote Tk mais celui de master=None c'est le singleton Python qu'il faut donner.
Dans le code que vous avez poste, vous évitez de l'utiliser et ça a l'air de marcher.

- W

[austin57]

Effectivement, c'était tout bête, la définition d'une taille pour Frame résous le problème (bien que je reste perplexe en voyant que dans certains cas, cela fonctionne).
Je n'aime pas du tout le gestionnaire .place(), mais pour un widget scale, je ne vois pas d'autres possibilités pour positionner très précisément les labels tout le long.
En tout cas, merci beaucoup, je devrais pouvoir achever maintenant la première version de mon premier widget (et accessoirement, mon deuxième programme Python) grâce à vous.
A bientôt!