Classe Entry Numérique filtrée et bornée.

**luc pic** · 14/07/2017, 14h16

Salut à tous,
Grace à la courtoisie et la patience de plusieurs d'entre-vous ( certains se reconnaîtront) qui m'ont aidé par leurs exemples et conseils, j'ai poursuivi l'idée de construire une Entry numérique filtrée, bornée et mise en forme convenable.
J'aurais souhaité afficher un message à la place de la saisie quand les bornes sont dépassées: ('trop grand' ou 'trop petit').
Je rencontre un problème avec l'utilisation de sleep() ligne 111, il semble que cette fonction empêche la ligne 109 qui ne s'affiche plus sauf à inhiber sleep(3).
Il faut pourtant bien qu’après l'affichage du message d'erreur, j'efface ce message après un court laps de temps (ligne 113).
Les 'print()' témoins des lignes 112 et 114 ne s'affichent pourtant qu’après les 3 secondes demandées mais le message d'erreur ne s'affiche pas pendant cette pose.

root.after() idem ( essai lignes 116 à 121)

Je n'ai pas réussi. Si quelqu’un a un idée!

L.P.

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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
# -*- coding: utf-8 -*-
# Name:    MyEntryNum_00.py
# Created:     14/07/2017
#-------------------------------------------------------------------------------
 
from tkinter import *
from time import*
 
class MyEntryNum(Entry):
    """ Cette classe Entry surchargée doit permettre de controler les saisies numeriques
        entieres ou decimales bornees ou non avec une valeur par defaut ou non.
            Les arguments  a renseigner sont:
        typ= 0, defaut= '', maxi= None, mini= None, root= None
        (typ= 0 pour entier ou typ= 1 pour decimal)
            Exemple de creation d'une MyEntryNum:
       e1 = MyEntryNum(root= fen, defaut= 10, maxi= 100, mini= 10)
    """
    def __init__(self, typ= 1 , defaut= '', maxi= None, mini= None, root= None):
        self.maxi= maxi # ; print('maxi:=', self.maxi) ##
        self.mini= mini # ; print('mini:=', self.mini) ##
        self.defaut= defaut # ; print('defaut:=', self.defaut) ##
        self.root= root
        self.typ= typ # ; print('type',typ) ## Entier ou Decimal
        self.strVar = StringVar()
        self.strVar.set(self.defaut)
        self.strVar.trace("w", self.validation)
 
        Entry.__init__(self, textvariable= self.strVar, justify= 'right',
              bg='grey', validate= 'key', vcmd= self.verifsaisieKey)
        self.bind('<FocusOut>', self.verifMini)
        self.bind('<Key>', self.saisieKey)
 
    def verifMini(self, event):
        self.strVar.set(self.get().rstrip('.')) #°°°°°°°°°
        self.strVar.set(self.get().rstrip('-')) #°°°°°°°°°
        if self.get()=='' and self.mini != None and self.defaut != None:
            self.strVar.set(self.defaut)
 
        if self.mini != None and self.get() != '':
           if eval(self.get())< self.mini:
              self.strVar.set(self.defaut)
              self.config(bg='red')
              self.root.event_generate('<Shift-Tab>')
 
    def saisieKey(self, event):
        self.config(bg= 'grey')
        self.touche= event
        self.configure(validate= 'key', vcmd= self.verifsaisieKey)
 
    def verifsaisieKey(self):
        try: self.touche
        except: return True
 
 # cas decimal + ou -
        if self.typ==1 and self.touche.char in '0123456789.-' \
        or self.touche.keysym == 'BackSpace':
           return True
 
 # cas decimal +
        if self.typ==1 and self.touche.char in '0123456789.' \
        and self.mini> 0 or self.touche.keysym == 'BackSpace':
            return True
 # cas entier + ou -
        elif self.typ==0 and self.touche.char in '0123456789-' \
        and (self.mini==None or self.mini<= 0) or self.touche.keysym == 'BackSpace':
             return True
 # cas entier +
        elif self.typ==0 and self.touche.char in '0123456789' \
        and self.mini>= 0 or self.touche.keysym == 'BackSpace':
             return True
        else:
            self.bell()
            return False
 
    def validation(self,*args ):
 # cas du zero en debut si non dec : efface -> pas 0123 mais 123
        if len(self.get())>1 and self.get()[0]=='0' and self.get()[1] !='.':
            self.strVar.set(self.get().lstrip('0'))
 # cas du point en debut : ajoute 0. -> pas .123 mais 0.123
        if len(self.get())>0 and self.get()[0]=='.':
            self.event_generate('<BackSpace>')
            self.insert(0,'0.')
 # cas du zero en debut nb. ent. neg. : efface -> pas -.123 mais -0.123
        if len(self.get())==3 and self.get()[0]=='-' \
        and self.get()[1]=='0' and self.get()[2] !='.':
            self.event_generate('<BackSpace>')
            self.event_generate('<BackSpace>')
 # cas du zero en debut nb. dec. neg. : ajoute 0. -> pas .123 mais 0.123
        if len(self.get())==2 and self.get()[0]=='-' \
        and self.get()[1]=='.':
            self.event_generate('<BackSpace>')
            self.insert(1,'0.')
 # cas du - pas en debut : efface si le signe n'est en pos[0]
        if self.get().endswith('-') and len(self.get())>1:
            self.event_generate('<BackSpace>')
 # cas du . unique : efface si il y a + de 1 .
        if len(self.get())>1 and self.get().count('.')>1:
           self.event_generate('<BackSpace>')
 # cas du - unique : efface si il y a + de 1 -
        if len(self.get())>1 and self.get().count('-')>1:
           self.event_generate('<BackSpace>')
 # cas du maxi
        if len(self.get())>0 and self.maxi != None:
            if self.get()[0] not in '.-':
                if float(self.strVar.get())> self.maxi:
                    print('ligne 106')
                    self.delete(0,END)
                    print('ligne 108')
                    self.config(bg='red') ; self.insert(INSERT,'Trop Grand')
                    print('ligne 110')
                    sleep(3) #;
                    print('ligne 112')
                    self.delete(0,END)
                    print('ligne 114')
 
##                    self.root.after(2000, self.effMessage(self))
##                    self.bind('<FocusOut>', self.effMessage)
##
##    def effMessage(self, event):
##        print('efface')
##        self.delete(0,END)
 
#------- if main pour les essais -------------------
 
if __name__ == "__main__":
    fen = Tk()
    fen.geometry ("350x280+850+50")
    fen.title("      MyEntryNum  Exemple")
    def tabul(e):
        fen.event_generate("<Tab>")
        add(e)
 
    def add(e):
        """"""
        r1 = eval(e1.get()) if e1.get()!= '' else 0
        r2 = eval(e2.get()) if e2.get()!= '' else 0
        r3 = eval(e3.get()) if e3.get()!= '' else 0
        r4 = eval(e4.get()) if e4.get()!= '' else 0
        r5 = eval(e5.get()) if e5.get()!= '' else 0
 
        t= str(r1 + r2 + r3 + r4 + r5) ; l1.config(text=t)
 
    e1 = MyEntryNum(root= fen, typ= 1)
    e1.place(x= 50, y= 10,width= 60)
    e2 = MyEntryNum(root= fen, typ= 1, mini= -5, maxi= 5, defaut= 1)
    e2.place(x= 50, y= 40, width= 60)
    e3 = MyEntryNum(root= fen, typ= 0)
    e3.place(x= 50, y= 70, width =60)
    e4 = MyEntryNum(root =fen, typ= 0, mini= -10, maxi= 20)
    e4.place(x= 50, y= 100,width= 60)
    e5 = MyEntryNum(root= fen, typ= 0, mini= 10, maxi= 20)
    e5.place(x= 50, y= 130, width= 60)
 
    e1.focus_set()
    e1.select_range(0,END)
    fen.bind('<Return>', tabul)
    fen.bind('<Tab>', add)
    fen.bind('<1>', add)
    fen.bind('<FocusOut>', add)
 
    l1 = Label(fen, bg='light grey', width=20)
    l1.place(x=80,y=200,width=100)
 
    l_1 = Label(fen, text='e1 typ '+str(e1.typ))
    l_1.place(x=5,y=10,width=40)
    l_11 = Label(fen, text='min: '+str(e1.mini)+'  max: '+str(e1.maxi)+'  defaut: '+str(e1.defaut))
    l_11.place(x=110,y=10,width=200)
    l_2 = Label(fen, text='e2 typ '+str(e2.typ))
    l_2.place(x=5,y=40,width=40)
    l_12 = Label(fen, text='min: '+str(e2.mini)+'  max: '+str(e2.maxi)+'  defaut: '+str(e2.defaut))
    l_12.place(x=110,y=40,width=200)
    l_3 = Label(fen, text='e3 typ '+str(e3.typ))
    l_3.place(x=5,y=70,width=40)
    l_13 = Label(fen, text='min: '+str(e3.mini)+'  max: '+str(e3.maxi)+'  defaut: '+str(e3.defaut))
    l_13.place(x=110,y=70,width=200)
 
    l_4 = Label(fen, text='e4 typ '+str(e4.typ))
    l_4.place(x=5,y=100,width=40)
    l_14 = Label(fen, text='min: '+str(e4.mini)+'  max: '+str(e4.maxi)+'  defaut: '+str(e4.defaut))
    l_14.place(x=110,y=100,width=200)
 
    l_5 = Label(fen, text='e5 typ '+str(e5.typ))
    l_5.place(x=5,y=130,width=40)
    l_15 = Label(fen, text='min: '+str(e5.mini)+'  max: '+str(e5.maxi)+'  defaut: '+str(e5.defaut))
    l_15.place(x=110,y=130,width=200)
 
    fen.mainloop()

**bistouille** · 14/07/2017, 20h12

Salut.

J'ai regardé un peu ton code, et je ne comprends rien à ce que tu veux faire

Tout ce que je peux constater c'est que tu n'utilises pas les types de validations comme il faut, et au lieu d'utiliser des StringVar, il serait judicieux d'utiliser des IntVar et FloatVar, pour cela il te suffit d'utiliser de l'héritage, une classe pour les floats, une classe pour les integers, et une classe définissant les méthodes communes au 2, qui en hériteront, de cette façon ça va simplifier ton code en utilisant une méthode de validation pour chaque type de valeurs.

Cela te permettra également d'ôter ces infâmes eval de ton code.

Et j'ai oublié, on ne met généralement pas les messages d'avertissements ou erreurs dans une entrée, on l'affiche soit à côté/au-dessus du champ de saisie, ou on les affiche ensembles dans une zone distincte de la fenêtre.

[EDIT]
Je viens de percuter à l'instant, plutôt que d'utiliser des champs de saisies, je pense que tu devrais changer pour des spinbox, tu n'aurais ainsi pas besoin de faire ces vérifications, car les valeurs autorisées se situent dans des intervalles, les spinbox sont justement destinées à ça.

**luc pic** · 15/07/2017, 14h23

Salut à tous et à bistouille pour sa réponse.
Je ne connaissais pas IntVar et FloatVar. Je vais voir comment les utiliser. Merci pour l'info.

A propos de ce que j'ai voulu faire:
Construire un widget de saisie numérique polyvalent (int et float au choix, borné si besoin, valeur par défaut si besoin avec correction en live de la saisie.
ex: pas de .123 mais 0.123
pas de -.123 mais -0.123
pas de 0123 mais 123
pas de - ou de . seuls etc.

Ce widget est destiné à être utilisé comme un widget supplémentaire autonome. A ce stade il est fonctionnel si on supprime les lignes concernant l'essai d'affichage du hors bornes. (code joint)

Ce que j'aurais voulu rajouter ce sont, en cas de hors bornes, des indications d'erreur indissociables du widget.
J'ai réfléchi un moment sur un popup mais je n'ai pas su faire.
L'affichage éphémère dans le widget lui-même m'a paru être une solution intéressante et amusante.

A propos des spinbox, j'ai déjà utilisé scale et spinbox. Effectivement ça fait l'affaire mais il s'agit ici d'un exercice que je me suis donné de création d'un widget à partir d'un autre (c'est pour comprendre apprendre et surtout pour le plaisir de faire).

L.P.

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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
# -*- coding: utf-8 -*-
# Name:    MyEntryNum_1.0.py
# Created:     14/07/2017
#-------------------------------------------------------------------------------
 
from tkinter import *
from time import*
import pdb
 
class MyEntryNum(Entry):
    """ Cette classe Entry surchargée doit permettre de controler les saisies numeriques
        entieres ou decimales bornees ou non avec une valeur par defaut ou non.
            Les arguments  a renseigner sont:
        typ= 0, defaut= '', maxi= None, mini= None, root= None
        (typ= 0 pour entier ou typ= 1 pour decimal)
            Exemple de creation d'une MyEntryNum:
       e1 = MyEntryNum(root= fen, defaut= 10, maxi= 100, mini= 10)
    """
    def __init__(self, typ= 1 , defaut= '', maxi= None, mini= None, root= None):
        self.maxi= maxi # ; print('maxi:=', self.maxi) ##
        self.mini= mini # ; print('mini:=', self.mini) ##
        self.defaut= defaut # ; print('defaut:=', self.defaut) ##
        self.root= root
        self.typ= typ # ; print('type',typ) ## Entier ou Decimal
        self.strVar = StringVar()
        self.strVar.set(self.defaut)
        self.strVar.trace("w", self.validation)
 
        Entry.__init__(self, textvariable= self.strVar, justify= 'right',
              bg='grey', validate= 'key', vcmd= self.verifsaisieKey)
        self.bind('<FocusOut>', self.verifMini)
        self.bind('<Key>', self.saisieKey)
 
    def verifMini(self, event):
        self.strVar.set(self.get().rstrip('.')) #°°°°°°°°°
        self.strVar.set(self.get().rstrip('-')) #°°°°°°°°°
        if self.get()=='' and self.mini != None and self.defaut != None:
            self.strVar.set(self.defaut)
 
        if self.mini != None and self.get() != '':
           if eval(self.get())< self.mini:
              self.strVar.set(self.defaut)
              self.config(bg='red')
              self.root.event_generate('<Shift-Tab>')
 
    def saisieKey(self, event):
        self.config(bg= 'grey')
        self.touche= event
        self.configure(validate= 'key', vcmd= self.verifsaisieKey)
 
    def verifsaisieKey(self):
        try: self.touche
        except: return True
 
 # cas decimal + ou -
        if self.typ==1 and self.touche.char in '0123456789.-' \
        or self.touche.keysym == 'BackSpace':
           return True
 
 # cas decimal +
        if self.typ==1 and self.touche.char in '0123456789.' \
        and self.mini> 0 or self.touche.keysym == 'BackSpace':
            return True
 # cas entier + ou -
        elif self.typ==0 and self.touche.char in '0123456789-' \
        and (self.mini==None or self.mini<= 0) or self.touche.keysym == 'BackSpace':
             return True
 # cas entier +
        elif self.typ==0 and self.touche.char in '0123456789' \
        and self.mini>= 0 or self.touche.keysym == 'BackSpace':
             return True
        else:
            self.bell()
            return False
 
    def validation(self,*args ):
 # cas du zero en debut si non dec : efface -> pas 0123 mais 123
        if len(self.get())>1 and self.get()[0]=='0' and self.get()[1] !='.':
            self.strVar.set(self.get().lstrip('0'))
 # cas du point en debut : ajoute 0. -> pas .123 mais 0.123
        if len(self.get())>0 and self.get()[0]=='.':
            self.event_generate('<BackSpace>')
            self.insert(0,'0.')
 # cas du zero en debut nb. ent. neg. : efface -> pas -.123 mais -0.123
        if len(self.get())==3 and self.get()[0]=='-' \
        and self.get()[1]=='0' and self.get()[2] !='.':
            self.event_generate('<BackSpace>')
            self.event_generate('<BackSpace>')
 # cas du zero en debut nb. dec. neg. : ajoute 0. -> pas .123 mais 0.123
        if len(self.get())==2 and self.get()[0]=='-' \
        and self.get()[1]=='.':
            self.event_generate('<BackSpace>')
            self.insert(1,'0.')
 # cas du - pas en debut : efface si le signe n'est en pos[0]
        if self.get().endswith('-') and len(self.get())>1:
            self.event_generate('<BackSpace>')
 # cas du . unique : efface si il y a + de 1 .
        if len(self.get())>1 and self.get().count('.')>1:
           self.event_generate('<BackSpace>')
 # cas du - unique : efface si il y a + de 1 -
        if len(self.get())>1 and self.get().count('-')>1:
           self.event_generate('<BackSpace>')
 # cas du maxi
        if len(self.get())>0 and self.maxi != None:
            if self.get()[0] not in '.-':
                if float(self.strVar.get())> self.maxi:
                    self.delete(0,END)
                    self.config(bg='red') ;
 
 
#------- if main pour les essais -------------------
 
if __name__ == "__main__":
    fen = Tk()
    fen.geometry ("350x280+850+50")
    fen.title("      MyEntryNum  Exemple")
    def tabul(e):
        fen.event_generate("<Tab>")
        add(e)
 
    def add(e):
        """"""
        r1 = eval(e1.get()) if e1.get()!= '' else 0
        r2 = eval(e2.get()) if e2.get()!= '' else 0
        r3 = eval(e3.get()) if e3.get()!= '' else 0
        r4 = eval(e4.get()) if e4.get()!= '' else 0
        r5 = eval(e5.get()) if e5.get()!= '' else 0
 
        t= str(r1 + r2 + r3 + r4 + r5) ; l1.config(text=t)
 
    e1 = MyEntryNum(root= fen, typ= 1)
    e1.place(x= 50, y= 10,width= 60)
    e2 = MyEntryNum(root= fen, typ= 1, mini= -5, maxi= 5, defaut= 1)
    e2.place(x= 50, y= 40, width= 60)
    e3 = MyEntryNum(root= fen, typ= 0)
    e3.place(x= 50, y= 70, width =60)
    e4 = MyEntryNum(root =fen, typ= 0, mini= -10, maxi= 20)
    e4.place(x= 50, y= 100,width= 60)
    e5 = MyEntryNum(root= fen, typ= 0, mini= 10, maxi= 20)
    e5.place(x= 50, y= 130, width= 60)
 
    e1.focus_set()
    e1.select_range(0,END)
    fen.bind('<Return>', tabul)
    fen.bind('<Tab>', add)
    fen.bind('<1>', add)
    fen.bind('<FocusOut>', add)
 
    l1 = Label(fen, bg='light grey', width=20)
    l1.place(x=80,y=200,width=100)
 
    l_1 = Label(fen, text='e1 typ '+str(e1.typ))
    l_1.place(x=5,y=10,width=40)
    l_11 = Label(fen, text='min: '+str(e1.mini)+'  max: '+str(e1.maxi)+'  defaut: '+str(e1.defaut))
    l_11.place(x=110,y=10,width=200)
    l_2 = Label(fen, text='e2 typ '+str(e2.typ))
    l_2.place(x=5,y=40,width=40)
    l_12 = Label(fen, text='min: '+str(e2.mini)+'  max: '+str(e2.maxi)+'  defaut: '+str(e2.defaut))
    l_12.place(x=110,y=40,width=200)
    l_3 = Label(fen, text='e3 typ '+str(e3.typ))
    l_3.place(x=5,y=70,width=40)
    l_13 = Label(fen, text='min: '+str(e3.mini)+'  max: '+str(e3.maxi)+'  defaut: '+str(e3.defaut))
    l_13.place(x=110,y=70,width=200)
 
    l_4 = Label(fen, text='e4 typ '+str(e4.typ))
    l_4.place(x=5,y=100,width=40)
    l_14 = Label(fen, text='min: '+str(e4.mini)+'  max: '+str(e4.maxi)+'  defaut: '+str(e4.defaut))
    l_14.place(x=110,y=100,width=200)
 
    l_5 = Label(fen, text='e5 typ '+str(e5.typ))
    l_5.place(x=5,y=130,width=40)
    l_15 = Label(fen, text='min: '+str(e5.mini)+'  max: '+str(e5.maxi)+'  defaut: '+str(e5.defaut))
    l_15.place(x=110,y=130,width=200)
 
    fen.mainloop()

**bistouille** · 16/07/2017, 12h04

Envoyé par luc pic

A propos de ce que j'ai voulu faire:
Construire un widget de saisie numérique polyvalent (int et float au choix, borné si besoin, valeur par défaut si besoin avec correction en live de la saisie.
ex: pas de .123 mais 0.123
pas de -.123 mais -0.123
pas de 0123 mais 123
pas de - ou de . seuls etc.

Je ne comprends pas trop pourquoi ces limitations à part le dernier qui est sensé, mais empêcher un 0123 n'apporte rien puisque cela ne faussera d'aucune manière un résultat à calculer.

Maintenant comment veux-tu faire avec un intervalle de saisie entre -5 et 5 que le champ de saisie ne vaille pas à un moment uniquement le - ?
C'est impossible !
À moins de forcer l'utilisateur à entrer d'abord un nombre et ensuite d'ajouter le signe -, ce qui est complètement saugrenu.

Envoyé par luc pic

Ce que j'aurais voulu rajouter ce sont, en cas de hors bornes, des indications d'erreur indissociables du widget.
J'ai réfléchi un moment sur un popup mais je n'ai pas su faire.
L'affichage éphémère dans le widget lui-même m'a paru être une solution intéressante et amusante.

Alors les pop-up, c'est le truc à éviter, rien de plus énervant que ça, un message d'avertissement dans la même fenêtre est bien plus approprié pour ce genre de chose.

Envoyé par luc pic

A propos des spinbox, j'ai déjà utilisé scale et spinbox. Effectivement ça fait l'affaire mais il s'agit ici d'un exercice que je me suis donné de création d'un widget à partir d'un autre (c'est pour comprendre apprendre et surtout pour le plaisir de faire).

Ok, si c'est uniquement dans la perspective de t'améliorer et t'exercer, ça peut être un bon exercice.

Alors voilà à peu près comment je ferais (dans les grandes lignes) pour une saisie d'un entier, on peut encore affiner la vérification.
Et j'ai finalement gardé StringVar car IntVar pose plus de problèmes par rapport à StringVar.

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
import tkinter as tk
import re
 
class Saisie(tk.Entry) :
    def __init__(self, parent, **dargs) :
        self.etat = False
        super().__init__(parent,
                         dargs,
                         bg='lightBlue',
                         justify='right',
                         validate='all',
                         )
        self._validerCmd = self.register(self.verifier)
        self['validatecommand'] = (self._validerCmd, '%P', '%V')
 
    def verifier(self, *args) :
        return True
 
    def valider(self) :
        self['bg'] = 'lightGreen'
        self.etat = True
        return True
 
    def invalider(self) :
        self['bg'] = 'red'
        self.etat = False
        return False
 
class SaisieEntier(Saisie) :
    def __init__(self, parent, min_:int=None, max_:int=None, defaut:int=None) :
        self.min = min_
        self.max = max_
        self.var = tk.StringVar()
        if defaut :
            self.var.set(defaut)
        super().__init__(parent, textvariable=self.var)
 
    def _verifierMaxMin(self, valeur) :
        try :
            valeur = int(valeur)
        except :
            return False
        if self.min != None and valeur < self.min\
            or self.max != None and valeur > self.max :
            return False
        return True
 
    def verifier(self, pvaleur, action) :
        if action == 'focusout' :
            valeur = self.var.get()
            exp = '^-?[0-9]+$'
            if not re.match(exp, valeur) or not self._verifierMaxMin(valeur) :
                return self.invalider()
            else :
                return self.valider()
 
        exp = '^-?[0-9]*$'
        if re.match(exp, pvaleur) :
            return True
        return False
 
 
class SaisieEntierAvecRappel(SaisieEntier) :
    def __init__(self, parent,
                 rappel,
                 min_:int=None,
                 max_:int=None,
                 defaut:int=None
                 ) :
        self._rappel = rappel
        super().__init__(parent, min_, max_, defaut)
 
    def valider(self) :
        self._rappel(self.var, True)
        return super().valider()
 
    def invalider(self) :
        self._rappel(self.var, False)
        return super().invalider()
 
 
root = tk.Tk()
root.geometry ("350x280+850+50")
root.title('Blabla blibli')
 
resultats = dict()
def changerResultat(var, valide) :
    v = var.get() if valide else 0
    resultats[var._name] = v
    varResultat.set(sum((int(n) for n in resultats.values())))
 
cadre = tk.Frame(root)
cadre.grid()
 
tk.Label(cadre, text='Valeur entre 10 et 20 inclus').grid()
se1 = SaisieEntierAvecRappel(cadre, changerResultat, 10, 20, 12)
se1.grid()
 
tk.Label(cadre, text='Valeur entre - 5 et 5 inclus').grid()
se2 = SaisieEntierAvecRappel(cadre, changerResultat, -5, 5)
se2.grid()
 
tk.Label(cadre, text='Résultat :').grid()
varResultat = tk.IntVar(0)
tk.Label(cadre, textvariable=varResultat, fg='white').grid()
 
root.mainloop()

**flapili** · 23/07/2017, 22h13

Bonjour, j'ai lu en travers le sujet mais d'après ce que j'ai compris vous voulez réinventer la roue alors qu'il existe Spinbox, un widget de tkinter

mea culpa si ce n'est pas ce que tu voulais...

**luc pic** · 27/07/2017, 11h26

Salut à tous,

Il s'agit ici d'un exercice pour apprendre à surcharger une classe existante.
Le code est loin d'être un modèle néanmoins il est fonctionnel.

ATTENTION, Ce n'est pas une leçon, c'est juste un exemple obtenu en tâtonnant..
Toutes les corrections, simplifications et améliorations seront les bienvenues.

Le fichier peut être copié dans le répertoire
C:\Python33\Lib\site-packages\MyMods
par exemple et être réutilisé dans un autre projet par:
from MyMods.MyEntryNum import *
si un fichier __init__.py (vide) se trouve dans ce répertoire.

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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
# -*- coding: utf-8 -*-
# Name:    MyEntryNum.py
# Created:     27/07/2017
#-------------------------------------------------------------------------------
from tkinter import *
 
class MyEntryNum(Entry):
    """ Cette classe Entry surchargée permet de contrôler les saisies numériques
        entières ou décimales bornées ou non avec une valeur par defaut ou non.
            Les arguments a renseigner sont:
        typ= 0, defaut= '', maxi= None, mini= None, root= None
        (typ= 0 pour entier ou typ= 1 pour décimal)
            Exemple de création d'une MyEntryNum:
       e1 = MyEntryNum(root= fen, defaut= 10, maxi= 100, mini= 10)
       Un Double-click gauche sur le widget affiche type, bornes et defaut
       Les saisies hors bornes affichent les infos des attendus autorisés
    """
 
    def __init__(self, typ= 1 , defaut= '', maxi= None, mini= None, root= None):
        self.maxi= maxi # ; print('maxi:=', self.maxi) ##
        self.mini= mini # ; print('mini:=', self.mini) ##
        self.defaut= defaut # ; print('defaut:=', self.defaut) ##
        self.root= root
        self.typ= typ # ; print('type',typ) ## Entier ou Decimal
        self.strVar = StringVar()
        self.strVar.set(self.defaut)
        self.strVar.trace("w", self.validation)
 
        Entry.__init__(self, textvariable= self.strVar, justify= 'right',
              bg='grey', validate= 'key', vcmd= self.verifsaisieKey)
        self.bind('<Return>', self.verifMini)
        self.bind('<FocusOut>', self.verifMini)
        self.bind('<Key>', self.saisieKey)
        self.bind('<Double-1>', self.showinfo_)
        self.bind('<Button-1>', self.saisieKey)
 
    def showinfo_(self, event):
        def fermer(event):
            t.destroy()
 
        ty=' Entier' if self.typ==0 else ' Decimal'
        t = Toplevel(self.root)
 
    # positionnement relatif de la PopUp info
        root_geo= self.root.geometry()
        # print('self.root.geometry():=',root_geo) #,fen.geometry())
        xl=root_geo.find('+') # ; print('xl:=',xl)
        xr=root_geo.rfind('+') # ; print('xr:=',xr)
        x=root_geo[xl+1:xr] # ; print('x:=',x)
        y=root_geo[xr+1:] # ; print('y:=',y)
        lx=root_geo.find('x') # ; print('lx:=',lx)
        l=root_geo[:lx] # ; print('l:=',l)
        h=root_geo[lx+1:xl] # ; print('h:=',h)
 
        tg="180x150+" + str(int(x)+50) + "+" + str(int(y)+200) # ; print('tg:=',tg)
        t.geometry(tg)
 
        t.title("Attendus")
        Label(t, text="type: " + ty + "\n" + "Maxi:  " + str(self.maxi) +" \n" + \
        "Mini:  " + str(self.mini) + "\n" + "defaut:  "+ str(self.defaut) + "\n" )\
        .pack(padx=5, pady=5)
        bt=Button(t, text="  Ok  ", bg='green', command=t.destroy)
        bt.pack(padx=5, pady=5)
        bt.focus_set()
        t.grab_set()
        t.bind('<Return>', fermer)
 
    def verifMini(self, event):
        if len(self.get())==1 and self.get()=='-':
            self.event_generate('<BackSpace>')
            self.event_generate('<BackSpace>')
 
        self.strVar.set(self.get().rstrip('.')) #°°°°°°°°°
        self.strVar.set(self.get().rstrip('-')) #°°°°°°°°°
        if self.get()=='' and self.mini != None and self.defaut != None:
            self.strVar.set(self.defaut)
 
        if self.mini != None and self.get() != '':
           if eval(self.get())< self.mini:
              self.strVar.set(self.defaut)
              self.root.event_generate('<Shift-Tab>')
              self.config(bg='red')
              self.showinfo_(self)
 
    def saisieKey(self, event):
        self.config(bg= 'grey')
        self.touche= event
        self.configure(validate= 'key', vcmd= self.verifsaisieKey)
 
    def verifsaisieKey(self):
        try: self.touche
        except: return True
 
 # cas decimal + ou -
        if self.typ==1 and self.touche.char in '0123456789.-' \
        or self.touche.keysym == 'BackSpace':
           return True
 
 # cas decimal +
        if self.typ==1 and self.touche.char in '0123456789.' \
        and self.mini> 0 or self.touche.keysym == 'BackSpace':
            return True
 # cas entier + ou -
        elif self.typ==0 and self.touche.char in '0123456789-' \
        and (self.mini==None or self.mini<= 0) or self.touche.keysym == 'BackSpace':
             return True
 # cas entier +
        elif self.typ==0 and self.touche.char in '0123456789' \
        and self.mini>= 0 or self.touche.keysym == 'BackSpace':
             return True
        else:
            self.bell()
            return False
 
    def validation(self,*args ):
 # cas du zero en debut si non dec : efface -> pas 0123 mais 123
        if len(self.get())>1 and self.get()[0]=='0' and self.get()[1] !='.':
            self.strVar.set(self.get().lstrip('0'))
 
 # cas du point en debut : ajoute 0. -> pas .123 mais 0.123
        if self.get().startswith('.'):
            self.event_generate('<BackSpace>')
            self.insert(0,'0.')
 
 # cas du zero en debut nb. ent. neg. : efface -> pas -0123 mais -123
        if len(self.get())==3 and self.get().startswith('-0') \
        and self.get()[2] !='.':
            self.event_generate('<BackSpace>')
            self.event_generate('<BackSpace>')
 
 # cas du zero en debut nb. dec. neg. : ajoute 0. -> pas -.123 mais -0.123
 
        if len(self.get())==2 and self.get().startswith('-.'):
            self.event_generate('<BackSpace>')
            self.insert(1,'0.')
 
 # cas du - pas en debut : efface si le signe n'est en pos[0] ## erreur!!!!!!!!!!!!!!
        if self.get().find('-')!=-1 and self.get().find('-')!=0:
            self.event_generate('<BackSpace>')
 
 # cas du . unique : efface si il y a + de 1 .
        if len(self.get())>1 and self.get().count('.')>1:
           self.event_generate('<BackSpace>')
 
 # cas du - unique : efface si il y a + de 1 -
        if len(self.get())>1 and self.get().count('-')>1:
           self.event_generate('<BackSpace>')
 
 # cas du maxi
        if len(self.get())>0 and self.maxi != None:
            if self.get()[0] not in '.-':
                if float(self.strVar.get())> self.maxi:
                    self.delete(0,END)
                    self.config(bg='red')
                    self.showinfo_(self)
 
 
#------- if main pour les essais -------------------
 
if __name__ == "__main__":
    fen = Tk()
    fen.geometry("350x280+850+150")
    fen.title("      MyEntryNum  Exemple")
 
    # print('fen.geometry():=',fen.geometry())
##    print('fen.winfo_width():=',fen.winfo_width())
##    print('fen.winfo_height():=',fen.winfo_height())
 
    def tabul(e):
        fen.event_generate("<Tab>")
        add(e)
 
    def add(e):
        r1 = 0  if e1.get()== '' else eval(e1.get())
        r2 = 0  if e2.get()== '' else eval(e2.get())
        r3 = 0  if e3.get()== '' else eval(e3.get())
        r4 = 0  if e4.get()== '' else eval(e4.get())
        r5 = 0  if e5.get()== '' else eval(e5.get())
 
        t= str(r1 + r2 + r3 + r4 + r5) ; l1.config(text=t)
 
    e1 = MyEntryNum(root= fen, typ= 1)
    e1.place(x= 50, y= 10,width= 60)
    e2 = MyEntryNum(root= fen, typ= 1, mini= -5, maxi= 5, defaut= 1)
    e2.place(x= 50, y= 40, width= 60)
    e3 = MyEntryNum(root= fen, typ= 0)
    e3.place(x= 50, y= 70, width =60)
    e4 = MyEntryNum(root =fen, typ= 0, mini= -10, maxi= 20)
    e4.place(x= 50, y= 100,width= 60)
    e5 = MyEntryNum(root= fen, typ= 0, mini= 10, maxi= 20)
    e5.place(x= 50, y= 130, width= 60)
 
    e1.focus_set()
    e1.select_range(0,END)
    fen.bind('<Return>', tabul)
    fen.bind('<Tab>', add)
##    fen.bind('<1>', add)
    fen.bind('<FocusOut>', add)
 
    l1 = Label(fen, bg='light grey', width=20)
    l1.place(x=80,y=200,width=100)
 
    l_1 = Label(fen, text='e1 typ '+str(e1.typ))
    l_1.place(x=5,y=10,width=40)
    l_11 = Label(fen, text='min: '+str(e1.mini)+'  max: '+str(e1.maxi)+'  defaut: '+str(e1.defaut))
    l_11.place(x=110,y=10,width=200)
    l_2 = Label(fen, text='e2 typ '+str(e2.typ))
    l_2.place(x=5,y=40,width=40)
    l_12 = Label(fen, text='min: '+str(e2.mini)+'  max: '+str(e2.maxi)+'  defaut: '+str(e2.defaut))
    l_12.place(x=110,y=40,width=200)
    l_3 = Label(fen, text='e3 typ '+str(e3.typ))
    l_3.place(x=5,y=70,width=40)
    l_13 = Label(fen, text='min: '+str(e3.mini)+'  max: '+str(e3.maxi)+'  defaut: '+str(e3.defaut))
    l_13.place(x=110,y=70,width=200)
 
    l_4 = Label(fen, text='e4 typ '+str(e4.typ))
    l_4.place(x=5,y=100,width=40)
    l_14 = Label(fen, text='min: '+str(e4.mini)+'  max: '+str(e4.maxi)+'  defaut: '+str(e4.defaut))
    l_14.place(x=110,y=100,width=200)
 
    l_5 = Label(fen, text='e5 typ '+str(e5.typ))
    l_5.place(x=5,y=130,width=40)
    l_15 = Label(fen, text='min: '+str(e5.mini)+'  max: '+str(e5.maxi)+'  defaut: '+str(e5.defaut))
    l_15.place(x=110,y=130,width=200)
 
    fen.mainloop()

Classe Entry Numérique filtrée et bornée.

Tkinter Python

Discussions similaires

Partager

Partager