Discussion :

[spirzouf]

Bonjour,

en parallèle d'un petit logiciel d'apprentissage du calcul pour le 1er cycle de primaire, je me suis mis à développer une nouvelle classe pour tkinter qui est un ensembles d'item de canvas représentant une date que l'on peut modifier.

je suis dessus depuis 3 jours (c'est long et fastidieux, le code a été en partie réécris plusieurs fois, et peut surement encore être simplifié avec des regex, mais pas encore bossé ce chapitre)

j'ai quasiment fini : le principal fonctionne, mais je voudrais ajouter une petite animation de scrolling des élément de la date quand on clique dessus (l'affichage est un peut à la manière d'un cadenas à code où l'on tourne une roue par caractère)

j'en suis à la première étape de l'animation c'est à dire le scrolling (le redimensionnement de police et l'apparition du nouvel item seront fait quand ce problème aura été réglé) : la position finale est bonne, mais je n'ai pas les affichage intermédiaire. J'ai essayé à la place de time.sleep un fenetre.after, mais sans succès non plus...

par pitié, je suis dessus depuis ce matin et là je craque...

tout se passe dans la procédure 'animation'
j'espère avoir suffisamment documenté le code pour qu'il soit compréhensible

[PauseKawa]

Bonjour,

Le mots magique : self.canvasParent.update_idletasks() ou update()

Regarde ici

@+

[PauseKawa]

Sinon puisque tu as une limite (iterations) pourquoi ne pas utiliser while, comme ici par exemple.

[spirzouf]

Bonjour,

Le mots magique : self.canvasParent.update_idletasks() ou update()

Regarde ici

@+

merci, update est effectivement un mot magique.

par contre, je ne comprends pas pourquoi il n'y en avais pas besoin dans l'ex. de l'info bulle pour le graph de calogerogigante ici. c'est parce que c'était dans un bind event et que l'update était implicite ?

Sinon puisque tu as une limite (iterations) pourquoi ne pas utiliser while, comme ici par exemple.

pour le 'while / for' (ps : pas trouvé de boucle while dans le lien que tu as donné), il y a vraiment un intérêt à l'utiliser préférentiellement à for ? j'ai trouvé le 'for' plus pratique étant donné que je veux un temps prédéfini pour l'animation avec donc un nombre fixe d'itérations contenant un sleep constant... ?


EDIT ; pas trouvé grand chose à part ça sur update_idletask(), et ça reste très obscur pour moi

[spirzouf]

ça a porté ses fruits :

ma nouvelle classe est presque terminée :
- quelques modifs mineures de paramètres à faire
- un problème d'import de module datetime quand la classe est utilisée elle-même comme module (alors que ça marchait avec une version antérieure, je ne comprend pas le problème)

voici le code de cette classe create_date :

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
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
#!/usr/bin/python3
# -*- coding: utf-8 -*-
 
# testé avec python 2.6.2 et python 3.0.1+
# nécessite d'avoir installé les librairies tkinter
 
############################################################
### Module permettant de saisir une date dans un canvas  ###
### de tkinter avec animation des chiffres et des mois   ###
############################################################
 
# Auteur : Spirzouf ( spirzouf at laposte point net )
# Version de développement du 4 fév 2010
 
class create_date():
    # --------------------------------------------------------------
    # !!! La casse des paramètres n'intervient pas !!!
    # --------------------------------------------------------------
    # - x,y : paramètre obligatoire indiquant les coordonnées du milieu du bord gauche
    # - format : 'JJ/MM/AAAA' par défaut, obtenu par compilation des éléments suivants, dans un ordre quelconque, séparés par des slashs :
    # --- jour : 'JJ'
    # --- mois : 'MM' ou 'Moi'/'Mon' ou 'Mois'/'Month' (affichera repectivement 01, Jan., ou Janvier si langue française, January si langue anglaise)
    #     NB : écrire 'mois' ou 'month' n'a pas d'influence sur l'affichage en français ou en anglais. C'est le paramètre lang qui compte pour cela.
    # --- année : AAAA ... xxxA (x étant les 1ers chiffres non modifiables)
    #           ou AA
    #     => exemple avec 24/04/1977 et lang='fr':
    #     'JJ/MM/AAAA' -> (24,04,1977)
    #     'JJ/Mois/19AA' -> (24,'Avril',1977) avec '19' qui ne sera pas modifiable
    #     'JJ/Mois/AA' -> (24,'Avril',77)
    #     'Moi/JJ/AAAA' -> ('Avr.',24,1977)
    # - langue : 'fr' par défaut, traduction anglaise disponible pour lang in [en, us, english]
    # - taille : '32' par défaut, taille de la police d'écriture
    # - font : police (à faire)
    # - item : 0 par défaut, utilisé comme tag (sous la forme 'date0') pour gérer séparément plusieurs dates qui seraient affichées sur le même canvas
    # --------------------------------------------------------------
    # regardez quelques exemples en lançant le module en stand alone
    # --------------------------------------------------------------
 
    # A FAIRE : ajouter un paramètre de positionnement de type anchor pour les valeurs calculables = sw, w et nw (actuellement w par défaut)
 
#==================================================================================
#                       DÉBUT DU __INIT__
#==================================================================================
 
    def __init__(self, canvasParent, x, y, format='JJ/MM/AAAA', lang='fr', date=None, taille=32, font='', item=0):
        print('------ nouveau canvasDate ------' , 'n°',item)
 
        ####################################################################################
        ## Initialisation des variables pour une utilisation dans la classe create_date() ##
        ####################################################################################
 
        ## Variables de positionnement dans le canvas ##
        #-----------------------------------------------
 
        # -> identification du canvas parent pour la création des nouveaux items de la classe
        self.canvasParent = canvasParent
        # -> donne un tag commun aux items pour pouvoir gérer cet affichage de date des autres
        self.item = 'date'+str(item)
 
        # -> coordonnées du 1er item
        self.x, self.y = x, y
 
        # -> création des variables de positionnement des items qui seront calculées en fonction de la taille de la police
        self.taille = int(taille)
        self.tailleMini = int(taille*.5) # taille de police des items sélectionnables sup et inf
        espacementChiffre = int(self.taille*1.6) # espacement en pixels après un item chiffre
        espacementMoi = int(self.taille*3.2) # espacement en pixels après un item 'Moi'
        espacementMois = int(self.taille*7.1) # espacement en pixels après un item 'Mois'
 
        # -> création des variables de couleurs
        self.colorActiveFill = 'green'
        self.colorFill = 'black'
        self.colorFill2 = 'grey'
        self.colorFocus = 'red'
 
        # -> création des variables de zone détection des évènements souris
        self.zonePointeur = max(2,int(self.taille/10)) # zone de détection des items par la souris
        self.zonePointeurLarge = max(5,int(self.taille/3)) # idem mais pour les clics
 
        # -> servira à remettre les items mis en valeur par la flèche de souris en position standard
        self.focusPrecedent = ''
 
        self.objetDatetime = datetime.date.today()
 
        ## Analyse du format de la date ##     --> variable = self.formatDate ; ex : ('jj','mois',[2,2])
        #---------------------------------
 
        # -> Création du dictionnaire dicoDate avec en entrée les correspondances aux tags donnés dans creerItem()
        #  et en sortie les valeurs possibles à afficher pour modifier chaque item de la date
        self.dictionnaire(lang)
 
        # -> Standardisation du format de la date
        # (dans une liste en minuscules, codages mm / moi / mois pour le mois ; ex JJ/Month/AA -> [''jj','mois','aa'])
        self.formatDate = format.lower()
        self.formatDate = self.formatDate.replace('n','i')
        self.formatDate = self.formatDate.replace('th','s')
        self.formatDate = self.formatDate.split('/')
 
        #-> Création du dictionnaire dicoOrdre pour connaitre l'ordre des items contenus dans le formatDate
        self.dicoOrdre = {}
        for i in range(0,3):
            if self.formatDate[i][0] == 'j' : self.dicoOrdre['j'] = i
            elif self.formatDate[i][0] == 'm' : self.dicoOrdre['m'] = i
            elif self.formatDate[i][0] in 'a123456789' : self.dicoOrdre['a'] = i
 
            # A FAIRE : exception en cas d'erreur
            else : print('Erreur de format de date')
 
        # -> Détection du format de l'année et codage en une liste de 2 éléments (AAAA -> [0,4], 19AA -> [2,2], AA -> [0,2], ...)
        formatAnnee = []
        compteur = 0
        for i in '0123456789' : compteur += self.formatDate[self.dicoOrdre['a']].count(i) # compte le nombre de chiffres dans le format de date
        formatAnnee.append(compteur)
        formatAnnee.append(self.formatDate[self.dicoOrdre['a']].count('a')) # compte le nombre de 'a' dans le format de date
        self.formatDate[self.dicoOrdre['a']] = formatAnnee
 
        ## Analyse de la date à afficher ##     -->  variable = self.date ; ex : ('30','Septembre',['18','25'])
        #----------------------------------
 
        # -> création variable canvasDate : date sous forme d'une liste (séparation des éléments constitutifs au niveau des slash)
        # (si aucune date n'est renseignée (date = None), on prend la date du jour adaptée à formatDate)
 
        if date == None :
 
            date = datetime.date.isoformat( datetime.date.today() )
            year, year_temp, month, day = ['',''], date[0:4], date[5:7], date[8:10]
            if self.formatDate[1] == 'moi': month = self.dicoDate['moi'][1][int(month)-1] # traduction du mois chiffré en mois abrégé
            if self.formatDate[1] == 'mois': month = self.dicoDate['mois'][1][int(month)-1] # traduction du mois chiffré en mois complet
            year[0] = year_temp[:self.formatDate[2][0]]
            year[1] = year_temp[self.formatDate[2][0]:]
            self.date = (day, month, year)
 
        else :
 
            date = date.lower()
            self.date = date.split('/')
 
            # -> standardisation avec 1ère lettre en Majuscule puis récupération de la position du mois écrit en lettre dans le dictionnaire
            moisEnLettres = self.date[self.dicoOrdre['m']].lower()
            premLettre = moisEnLettres[0]
            moisEnLettresTemp = ''
            for i in range(1,len(moisEnLettres)) : moisEnLettresTemp += moisEnLettres[i]
            moisEnLettres = self.date[self.dicoOrdre['m']] = premLettre.upper() + moisEnLettresTemp
 
            # -> ajout d'un point aux mois abrégés en 3 lettres (sauf à Mai et May qui ne sont pas abrégés)
            if self.formatDate[self.dicoOrdre['m']] == 'moi':
                if moisEnLettres[len(moisEnLettres)-1] != '.': # Vérification que le point n'existe pas déjà
                    if moisEnLettres != 'Mai' and moisEnLettres != 'May':
                        self.date[self.dicoOrdre['m']] = moisEnLettres + '.'
 
            # -> standardisation de l'année en 4 chiffres, puis découpage en 2 parties
            dateTemp = []
            for i in range(0,3):
                if i == self.dicoOrdre['j'] : dateTemp.append( self.date[i] )
                if i == self.dicoOrdre['m'] : dateTemp.append( self.date[i] )
                if i == self.dicoOrdre['a'] :
                    if len(self.date[i]) < 4 : # format 2000 si tous les chiffres de l'année ne sont pas précisés
                        self.date[i] = self.date[i].zfill(3)
                        self.date[i] = '2' + self.date[i]
                    dateTemp.append(
                        [
                        self.date [i] [ : 4-self.formatDate[i][1]] , # 1ère partie de la date (correspond à la partie chiffrée dans formatDate)
                        self.date [i] [self.formatDate[i][1]-4 : ] # 2nde partie de la date (correspond à la partie AA..dans formatDate)
                        ] )
            self.date = dateTemp
 
 
        ##################################################################
        ## Affichage du contenu de la date en fonction du format choisi ##
        ##################################################################
 
        position = 0 # position s'incrémente en fonction de l'item en cours pour positionner l'affichage de l'item suivant
 
        for i in range(0,3):
 
            # créer J1 et J2
            if i == self.dicoOrdre['j'] :
                self.dicoDate['J1'][0] = self.date[i][0]
                self.creerItem('J1',position,self.date[i][0])
                position += espacementChiffre
                self.dicoDate['J2'][0] = self.date[i][1]
                self.creerItem('J2',position,self.date[i][1])
                position += espacementChiffre
 
            # créer Moi / Mois / M1 + M2
            if i == self.dicoOrdre['m'] :
                if self.formatDate[i] == 'mm':
                    self.dicoDate['M1'][0] = self.date[i][0]
                    self.creerItem('M1',position,self.date[i][0])
                    position += espacementChiffre
                    self.dicoDate['M2'][0] = self.date[i][1]
                    self.creerItem('M2',position,self.date[i][1])
                    position += espacementChiffre
                else:
                    self.creerItem(self.formatDate[i],position,self.date[self.dicoOrdre['m']])
                    if self.formatDate[i] == 'moi' :
                        self.dicoDate['moi'][0] = self.date[i]
                        position += espacementMoi
                    else :
                        self.dicoDate['mois'][0] = self.date[i]
                        position += espacementMois
 
            # créer les chiffres fixes de l'année et les A
            if i == self.dicoOrdre['a'] :
                nombreDeChiffres = self.formatDate[i][0] # nombre de chiffres à afficher à l'écran
                nombreDeA = self.formatDate[i][1]
                # affichage des chiffres fixes si besoin
                for j in range(0,4-nombreDeA):
                    self.dicoDate['A'+str(1+j)][0] = self.date[i][0][j]
                    if nombreDeChiffres > 0 and j < nombreDeChiffres :
                        self.creerItem('/' , position , self.date[i][0][j])
                        position += espacementChiffre
                # affichages des A
                for j in range(0,nombreDeA):
                    self.dicoDate['A'+str(5-nombreDeA+j)][0] = self.date[i][1][j]
                    self.creerItem('A'+str(5-nombreDeA+j) , position , self.date[i][1][j] )
                    position += espacementChiffre
 
            # créer les '/' intercalaires seulement entre 2 séries de chiffres
            if i<2 and ( (self.dicoOrdre['m'] not in [i,i+1]) or self.formatDate[self.dicoOrdre['m']] == 'mm' ):
                    self.creerItem('/' , position , '/')
                    position += espacementChiffre
 
        ###################################################
        ## Lancement de la partie dynamique du programme ##
        ###################################################
 
        # si la souris passe sur un item modifiable, on lance la visualisation de l'item :
        self.canvasParent.tag_bind('+', '<Enter>', self.focusON)
        self.canvasParent.tag_bind('=', '<Enter>', self.focusON)
        self.canvasParent.tag_bind('-', '<Enter>', self.focusON)
        self.canvasParent.tag_bind(self.item, '<Button-1>', self.modifier)
 
#==================================================================================
#                       FIN DU __INIT__
#==================================================================================
 
    #######################################################################
    ## Procédures / fonctions de la partie d'initialisation du programme ##
    #######################################################################
 
    def dictionnaire(self,lang):
        self.dicoDate = {
            'J1' : [0 , ('0','1','2','3')],
            'J2' : [0 , ('0','1','2','3','4','5','6','7','8','9')],
            'mois' : ['' , ('Janvier','Février','Mars','Avril','Mai','Juin','Juillet','Août','Septembre','Octobre','Novembre','Décembre')],
            'moi' : ['' , ('Jan.','Fév.','Mar.','Avr.','Mai','Jun.','Jul.','Aoû.','Sep.','Oct.','Nov.','Déc.')],
            'M1' : ['' , ('0','1')],
            'M2' : ['' , ('0','1','2','3','4','5','6','7','8','9')],
            'A1' : [0 , ('0','1','2','3','4','5','6','7','8','9')],
            'A2' : [0 , ('0','1','2','3','4','5','6','7','8','9')],
            'A3' : [0 , ('0','1','2','3','4','5','6','7','8','9')],
            'A4' : [0 , ('0','1','2','3','4','5','6','7','8','9')],
            '/' : '/',
            'Janvier' : 1, 'Février' : 2, 'Mars' : 3, 'Avril' : 4, 'Mai' : 5, 'Juin' : 6,
            'Juillet' : 7, 'Août' : 8, 'Septembre' : 9, 'Octobre' : 10, 'Novembre' : 11, 'Décembre' : 12,
            'January' : 1, 'February' : 2, 'March' : 3, 'April' : 4, 'May' : 5, 'June' : 6,
            'July' : 7, 'August' : 8, 'September' : 9, 'October' : 10, 'November' : 11, 'December' : 12,
            'Jan.' : 1, 'Fév.' : 2, 'Feb.' : 2, 'Mar.' : 3, 'Avr.' : 4, 'Apr.' : 4, 'Jun.' : 6,
            'Jul.' : 7, 'Aoû.' : 8, 'Aug.' : 8, 'Sep.' : 9, 'Oct.' : 10, 'Nov.' : 11, 'Déc.' : 12, 'Dec.' : 12
            }
        # -> Variable booléenne 'english' et modification du dictionnaire pour l'anglais / américain si english = True
        english = ('en','english','us')
        if lang.lower() in english : english = True
        else : english = False
        if english :
            self.dicoDate['mois'][1] = ('January','February','March','April','May','June','July','August','September','October','November','December')
            self.dicoDate['moi'][1] = ('Jan.','Feb.','Mar.','Apr.','May','Jun.','Jul.','Aug.','Sep.','Oct.','Nov.','Dec.')
 
    def creerItem(self,tag,position,valeur):
        # Les tags des items seront définis comme suit :
          # pour les items non modifiables, tag[0] et tag[1]='/'
          # tag[0] : du type 'date0', 'date1', etc... Tag générique à tous les items d'une même date
          # tag[1] : '=' pour la valeur actuelle, '+' ou '-' pour les valeurs Sup/Inf
          # tag[2] : ex : 'moi' ==> nom de l'item dans le format de date : 'J1','M1','Mois', 'A1', etc...
          # tag[3] : ex : 'date0+' ==> tag[0] + tag[1]
          # tag[4] : ex : 'date0moi+' ==> tag[0] + tag[2] + tag[1]
          # tag[5] : ex: 'date0moi' ==> tag[0] + tag[2]
          # tag[6] et tag[7] : coordonnées x,y de l'item
          # tag[8] : taille de la police (self.taille)
 
        # variables pour simplifier la lecture des create_text
        x = self.x + position
        y = self.y
        t = self.taille
        numeroDate = self.item
 
        if tag != '/':
            # affichage de la valeur actuelle
            self.canvasParent.create_text ( x , y , text = valeur,
                font= ( "Helvetica" , str(self.taille) ), fill=self.colorFill, activefill=self.colorActiveFill, anchor='w',
                tags= ( numeroDate , '=' , tag , tag + '=' , numeroDate + tag + '=' , numeroDate + tag , self.x , y , self.taille ) )
            # trouver les valeurs sup et inf dans le dictionnaire
            valeurInf, valeurSup = self.valeursInfEtSup(tag,valeur)
            # affichage des 2 valeurs sup et inf
            self.canvasParent.create_text ( x , y - self.taille , text = valeurSup,
                font= ( "Helvetica" , str(self.tailleMini) ), fill=self.colorFill2, activefill=self.colorActiveFill, anchor='w',
                tags= ( numeroDate , '+' , tag , tag + '+' , numeroDate + tag + '+' , numeroDate + tag , self.x , y , self.taille ) )
            self.canvasParent.create_text ( x , y + self.taille , text = valeurInf,
                font= ( "Helvetica" , str(self.tailleMini) ), fill=self.colorFill2, activefill=self.colorActiveFill, anchor='w',
                tags= ( numeroDate , '-' , tag , tag + '-' , numeroDate + tag + '-' , numeroDate + tag , self.x , y , self.taille ) )
        else:
            self.canvasParent.create_text(x , y, text = valeur,
                font= ("Helvetica", str(self.taille)), fill=self.colorFill, anchor='w', tags=(numeroDate,'/') )
 
    def valeursInfEtSup(self,tag,valeur):
        index = self.dicoDate[tag][1].index(valeur)
        longueur = len(self.dicoDate[tag][1])
        # retourne valeurInf et valeurSup :
        return self.dicoDate[tag][1][(index-1)%longueur], self.dicoDate[tag][1][(index+1)%longueur]
 
 
    ################################################################
    ## Procédures / fonctions de la partie dynamique du programme ##
    ################################################################
 
 
    ##########   FOCUS   ##########
 
    def focusON(self, event=None):
        item = self.canvasParent.find_overlapping(event.x-self.zonePointeur,event.y-self.zonePointeur,event.x+self.zonePointeur,event.y+self.zonePointeur)
        tag = self.canvasParent.gettags(item)
        if tag != (): # tag == () quand 2 items se trouvent dans la zone de focus ? génère une erreur quand survient
            # Utilisation d'une variable du précédent focus, car la procedure inverse focusOFF ne fonctionnait pas bien avec un bind <Leave> :
            # si un autre focusON arrivait avant un focusOFF, le précédent restait affiché en ON.
            # Permet par ailleurs d'économiser sur le nombre de binds.
            if self.focusPrecedent not in (tag[2],'') : self.focusOFF() # pour éviter la redondance affichage / effacement d'un même élément
            self.focusPrecedent = tag[2]
            # application du focusON
            self.canvasParent.itemconfigure(self.canvasParent.gettags(item)[5], fill=self.colorFocus)
 
    def focusOFF(self):
        self.canvasParent.itemconfigure(self.focusPrecedent, fill='grey') # verticale grise
        self.canvasParent.itemconfigure(self.focusPrecedent+"=", fill='black') # item du milieu noir
 
 
    ##########   MODIFICATION DES VARIABLES ET AFFICHAGE DU RESULTAT FINAL   ##########
 
    def modifier(self, event=None):
 
        # A FAIRE : créer des exceptions / procédures de validation pour les dates invalides
        item = self.canvasParent.find_closest(event.x , event.y, halo=self.zonePointeurLarge) # découverte de l'item cliqué
        tag = self.canvasParent.gettags(item) # importation des tags de l'item
        sens = tag[1] # incrément / décrément
        valeurInf, valeurSup = self.valeursInfEtSup(tag[2],self.dicoDate[tag[2]][0])
 
        # FIXME : et si on récupérait simplement la valeur de l'objet tag[3]=tag[0]+tag[2]+'+'/'-' pour déterminer la valeur
        if     sens in ['+','=']  :
            valeur_next = valeurSup # incrémente si clic sur les items du haut et du milieu
            valeurInf_next, valeurSup_next = self.valeursInfEtSup(tag[2],valeur_next)
            # animation
            self.animation( tag[0]+'_temp', valeurSup_next, tag[5], tag[6], tag[7], sens, tag[8] )
        elif   sens == '-'        :
            valeur_next = valeurInf # décrémente si clic sur l'item du bas
            valeurInf_next, valeurSup_next = self.valeursInfEtSup(tag[2],valeur_next)
            # animation
            self.animation( tag[0]+'_temp', valeurInf_next, tag[5], tag[6], tag[7], sens, tag[8] )
 
        # affichage en fin d'animation
        self.canvasParent.itemconfigure(tag[0]+tag[2]+'=', text=valeur_next)
        self.canvasParent.itemconfigure(tag[0]+tag[2]+'+', text=valeurSup_next)
        self.canvasParent.itemconfigure(tag[0]+tag[2]+'-', text=valeurInf_next)
 
        # actualisation après l'animation
        self.canvasParent.update()
 
        # mise à jour du dictionnaire et de la variable de class 'date' pour utilisation dans la fenetre parente
        # FIXME : créér la date au format de formaDate (seulement JJ/MM/AAAA pour le moment)
        self.dicoDate[tag[2]][0] = valeur_next
 
        # conversion au format du module datetime : datetime.date(year, month, day)
        self.date = ''
        for i in ['J1','J2','/','M1','M2','moi','mois','/','A1','A2','A3','A4']:
            self.date = self.date + str(self.dicoDate[i][0])
        # année
        year = int( self.dicoDate['A1'][0]+self.dicoDate['A2'][0]+self.dicoDate['A3'][0]+self.dicoDate['A4'][0] )
        # mois
        if self.formatDate[self.dicoOrdre['m']] == 'mm': month = int( self.dicoDate['M1'][0] + self.dicoDate['M2'][0] )
        elif self.formatDate[self.dicoOrdre['m']] == 'moi': month = self.dicoDate[ self.dicoDate['moi'][0] ]
        elif self.formatDate[self.dicoOrdre['m']] == 'mois': month = self.dicoDate[ self.dicoDate['mois'][0] ]
        # jour
        day = int( self.dicoDate['J1'][0] + self.dicoDate['J2'][0] )
        # enregistrement de la date en tant qu'objet datetime
        self.objetDatetime = self.objetDatetime.replace(year, month, day)
 
        print(self.date,self.objetDatetime)
 
 
    ##########   ANIMATION DU CHANGEMENT DE DATE   ##########
 
    def animation(self,item_temp,valeur_temp,item,x,y,sens,dy):
 
        # initialisation des variables
        x,y = self.canvasParent.coords( item +"=")
        y = int(y)
        duree = .25                               # durée de l'animation en secondes
        freq = 30                                 # fréquence de l'animation en Hz
        iterations = int(freq * duree)            # nombre maximum de mouvements à faire
        if     sens in ['+','=']  :  sens = 1     # incrémente si clic sur les items du haut et du milieu
        elif   sens == '-'        :  sens = -1    # décrémente si clic sur l'item du bas
        dy = sens*int(dy)                         # variation totale de y en fin d'animation
        pas = dy / float(iterations)              # calcul du pas
        duree_pas = 1 / float(freq)               # durée d'une boucle d'animation
        position = y                              # definition de la variable qui va contenir la position en cours de mouvement
        diff_taille = self.taille-self.tailleMini # différence de taille entre les polices
 
        # création d'un item temporaire de transition
        self.canvasParent.create_text ( x , y - 2*dy , text = valeur_temp ,
            font = ( "Helvetica" , 1 ), fill = self.colorFocus , activefill = self.colorActiveFill , anchor = 'w',
            tags = item_temp )
 
        # boucle de l'animation
        for i in range(1,iterations+1):
            avancement = i/float(iterations)
            new = y + pas*i
            new_int = int(new)
            if sens*new_int > sens*position :     # affichage du déplacement que si ≥ 1 pixel / utilisation de la fonction max pour éviter la valeur 0 pour la taille dans font()
                # mouvement
                self.canvasParent.move( item, 0, new_int - position)
                self.canvasParent.move( item_temp, 0, new_int - position)
                # changement de la taille du texte
                self.canvasParent.itemconfigure(item+'=', font= ( "Helvetica" , str(int(self.taille - diff_taille * avancement) ) ) )
                if sens == 1 :
                    self.canvasParent.itemconfigure(item+'+', font= ( "Helvetica" , str(int(self.tailleMini + diff_taille * avancement) ) ) )
                    self.canvasParent.itemconfigure(item+'-', font= ( "Helvetica" , str(max(1,int(self.tailleMini - self.tailleMini * avancement) ) ) ) )
                    self.canvasParent.itemconfigure(item_temp, font= ( "Helvetica" , str(max(1,int(diff_taille * avancement) ) ) ) )
                else :
                    self.canvasParent.itemconfigure(item+'-', font= ( "Helvetica" , str(int(self.tailleMini + diff_taille * avancement) ) ) )
                    self.canvasParent.itemconfigure(item+'+', font= ( "Helvetica" , str(max(1,int(self.tailleMini - self.tailleMini * avancement) ) ) ) )
                    self.canvasParent.itemconfigure(item_temp, font= ( "Helvetica" , str(max(1,int(diff_taille * avancement) ) ) ) )
                # mise à jour de l'affichage (2nde fois que pauseKawa me sauve... merci à lui !)
                self.canvasParent.update()
                position = new_int
            time.sleep(duree_pas)
 
        # effacement du texte de l'item qui a quasiment disparu
        if sens == 1 : self.canvasParent.itemconfigure(item+'-', text='')
        else :         self.canvasParent.itemconfigure(item+'+', text='')
        self.canvasParent.update()
 
        # réinitialisation des tailles et positions avant  de quitter la procédure (réactualisation du contenu et update viendront après)
        self.canvasParent.itemconfigure(item+'-', font= ( "Helvetica" , self.tailleMini ) )
        self.canvasParent.itemconfigure(item+'=', font= ( "Helvetica" , self.taille ) )
        self.canvasParent.itemconfigure(item+'+', font= ( "Helvetica" , self.tailleMini ) )
        self.canvasParent.move( item, 0, -dy)
 
        # destruction de l'item temporaire de transition
        self.canvasParent.delete(item_temp)
 
#==================================================================================
#                       FIN DE CLASS
#==================================================================================            
 
 
#############################
## Exemples en stand alone ##
#############################
 
if __name__ == '__main__': # 
    try: import tkinter
    except: import Tkinter as tkinter
    import datetime, time
 
    print('\n########## DÉBUT DEBUG ##########\n')
 
    maFenetre = tkinter.Tk()
    maFenetre.title('Test de saisie de date')
    monCanvas = tkinter.Canvas(maFenetre, width=800, height=600, background='white')
    monCanvas.pack()
 
    monCanvasDate_1 = create_date(monCanvas,20,100,taille=40,format='JJ/Moi/AAAA', item=0)
    monCanvasDate_2 = create_date(monCanvas,20,200,taille=25,date='30/sep/1825',format='JJ/Mon/18AA',item=1)
    monCanvasDate_3 = create_date(monCanvas,20,300,taille=25,date='1825/September/30',format='AA/Month/JJ',lang='EnGLisH',item=2)
    monCanvasDate_4 = create_date(monCanvas,20,400,taille=25,date='Sep./30/1825',format='Moi/JJ/AA',item=3)
    monCanvasDate_5 = create_date(monCanvas,20,500,taille=25,date='1825/09/30',format='AAAA/MM/JJ',item=4)
 
    maFenetre.mainloop()

mon code qui appelle la date en tant que module (fonctionnait auparavant, je ne sais pas quelle modification désastreuse j'ai pu 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
#!/usr/bin/python3
# -*- coding: utf-8 -*-
 
# testé avec python 2.6.2 et python 3.0.1+
# nécessite d'avoir installé les librairies tkinter
 
try: import tkinter
except: import Tkinter as tkinter
import datetime, time
from tkCanvasDate import create_date
 
def quitter(event=None):
    maFenetre.destroy()
 
 
print('\n########## DÉBUT DEBUG ##########\n')
 
# fenetre et message descriptif
maFenetre = tkinter.Tk()
maFenetre.title('Test de saisie de date')
tkinter.Label(maFenetre, text="Test de saisie de date dans un canvas", font=("Helvetica","40"), fg='lightblue').pack()
 
# création d'un canvas avec une date dedans
monCanvas = tkinter.Canvas(maFenetre, width=800, height=200, background=None)
monCanvas.pack()
monCanvasDate_1 = create_date(monCanvas,20,100,taille=40,format='JJ/Mois/AAAA')
 
# bouton 'Quitter'
quit = tkinter.Button(maFenetre, text="Quitter", font=("Helvetica","40"), fg='lightblue', command = quitter)
quit.pack()
 
# mainloop
maFenetre.mainloop()
 
# affichage de la date en console
print ('test :',monCanvasDate_1.date)

[spirzouf]

finalement, j'ai résolu mon problème d'import : il faut le faire dans les def concernés au sein de la classe si j'ai bien compris, et effectivement, comme cela, ça marche quand le programme est appelé en tant que module.

reste le update_idletask() pour lequel je n'ai pas compris l'utilisation, mais pas grave pour le moment, je mets un

voici le code actuel en pièce jointe si vous voulez tester