Gérer plusieurs fenetres Toplevel sous Tkinter
ylc
J'ai ouvert une série de fenêtres Toplevel avec le même nom, chacune
comportant un bouton de commande pour agir sur la fenêtre.
Le problème est que tous ces boutons pointent vers une seule procédure
qui n'agit que sur la dernière fenêtre ouverte et non pas sur la
fenêtre du bouton cliqué.
D'où ma question : quand on clique sur un bouton d'une fenêtre,
comment récupérer le nom de cette fenêtre pour agir dessus ?
voici un petit prog d'exemple : tous les boutons agissent sur la
dernière fenêtre !......
merci. YLC
# test multifenêtres
from Tkinter import *
def rouge() :
top.config(bg='red')
def vert() :
top.config(bg='green')
def fenetres() :
global top
i=0
while i < 5 :
i=i+1
top=Toplevel()
top.title("toplevel"+str(i))
top.geometry("150x20+20+"+str(i*50))
broug = Button(top, text = 'rouge', command = rouge)
bvert = Button(top, text = 'vert', command = vert)
broug.pack(side=LEFT)
bvert.pack()
# main
fen = Tk(className="Fenetre racine")
fenetres()
fen.mainloop()
# #############################################
Eric Brunel
Il y a plein de solutions à ce problème, mais celle qui semble préférable
dans ton cas est de passer par une sous-classe de Toplevel.
Par exemple:
-------------------------------------------------------
from Tkinter import *
class MaFenetre(Toplevel):
def __init__(self, i):
Toplevel.__init__(self)
self.title("toplevel"+str(i))
self.geometry("150x20+20+"+str(i*50))
broug = Button(self, text = 'rouge', command = self.rouge)
bvert = Button(self, text = 'vert', command = self.vert)
broug.pack(side=LEFT)
bvert.pack()
def rouge(self):
self.config(bg='red')
def vert(self):
self.config(bg='green')
def fenetres():
for i in range(5):
ma_fenetre = MaFenetre(i)
fen = Tk(className="Fenetre racine")
fenetres()
fen.mainloop()
-------------------------------------------------------
Je ne sais pas si tu maîtrises l'orienté-objet, donc je ne vais pas me
lancer dans plein d'explications peut-être inutiles. Si jamais tu ne
comprends pas ce que fait le code ci-dessus, redemande: il y aura bien une
bonne âme pour t'éclairer (peut-être bien moi, d'ailleurs...).
HTH
--
python -c "print ''.join([chr(154 - ord(c)) for c in
'U(17zX(%,5.zmz5(17l8(%,5.Z*(93-965$l7+-'])"
ylc
Merci pour ta réponse, elle fontionne effectivement bien et est
sûrement la plus élégante. Malheureusement, je ne maitrise pas bien
l'orienté objet et dès que cela se complique je m'y perd.
N'y aurait-il pas la possibilité d'identifier le nom de la fenêtre
dans les procédures "rouge" et "vert" pour lui appliquer la commande ?
Eric Brunel
Mais elle est parfaitement identifiée: elle s'appelle self ;-)
Blague à part, il n'y a rien de fondalementalement compliqué dans le bout
de programme que j'ai écrit. L'orienté objet n'a rien de très complexe non
plus, mais je sais qu'on a besoin d'un petit déclic dans la tête pour
commencer à voir les choses clairement. Il faut aussi sans doute accepter
que certaines choses "magiques" se passent sans qu'on ait besoin de rien
dire; c'est d'ailleurs sans doute ce qui est le plus difficile pour
beaucoup de gens...
Cela dit, ne sachant pas vraiment ce que tu connais/maîtrises ou pas, ça
va être difficile de donner des explications pertinentes. Je pourrais me
lancer dans un cours théorique sur l'orienté-objet, mais ça serait long et
peut-être sans intérêt pour toi si tu as déjà des notions de base. Donc ça
m'aiderait de savoir quels langages tu connais déjà, et quels sont les
concepts OO que tu comprends, et ceux avec lesquels tu as du mal (en vrac:
classe, instance, attribut, méthode, spécialisation...).
ylc
et je comprend certains trucs, mais cela m'embrouille.....et je
préfère m'en passer........tant que c'est possible.
Tu ne réponds pas à ma question : peut-on récupérer l'identifiant
d'une fenêtre losqu'on clique un bouton dans celle-ci pour lui
appliquer la commande ?
merci.
Eric Brunel
> Ne cherche pas à m'expliquer l'Oo, j'ai déjà passé des heures dessus
> et je comprend certains trucs, mais cela m'embrouille.....et je
> préfère m'en passer........tant que c'est possible.
Tu te prives de beaucoup de choses très puissantes et très utiles...
> Tu ne réponds pas à ma question : peut-on récupérer l'identifiant
> d'une fenêtre losqu'on clique un bouton dans celle-ci pour lui
> appliquer la commande ?
> merci.
Mais quel identifiant? Il n'y a pas d'"identifiant" de la fenêtre, juste
une instance de MaFenetre, qui est aussi une instance de la classe
Toplevel puisque MaFenetre est une sous-classe de Toplevel, instance sur
laquelle on applique la méthode config... Donc ce que je disais est tout à
fait correct: à l'intérieur des méthodes rouge et vert, l'"identifiant" de
la fenêtre, c'est self...
Je ne vois pas vraiment ce qui te gêne en fait. D'où mes questions...
Faire:
class MaFenetre(...):
def rouge(self):
...
ma_fenetre = MaFenetre(...)
ma_fenetre.rouge()
est pratiquement équivalent à:
class MaFenetre(...):
...
def MaFenetre_rouge(self):
...
ma_fenetre = MaFenetre(...)
MaFenetre_rouge(ma_fenetre)
A l'intérieur de la méthode rouge, comme à l'intérieur de la fonction
MaFenetre_rouge, le paramètre self vaut ma_fenetre... C'est un basique
passage de paramètre à une fonction dans les deux cas. C'est juste la
syntaxe qui diffère: une méthode est appelée en faisant
ma_fenetre.rouge(), alors que la fonction l'est en faisant
MaFenetre_rouge(ma_fenetre). Mais ça fait presque exactement la même chose
derrière...
Si tu voulais quelque chose qui à l'intérieur de la méthode rouge te
renvoie le nom 'ma_fenetre', il y a effectivement des possibilités de le
faire. Mais d'une part, ça va être abominablement compliqué, et d'autre
part ça ne t'apportera rien, puisque tu as déjà l'objet que tu veux
manipuler sous le nom self...
Mais peut-être n'ai-je pas compris la question...?
HTH quand même...
ylc
dans chaque fenetre de mon prog il y a un canvas et dans ce canvas il
y a une image. Les boutons servent à modifier l'image (rotation,
taille,..) et à chaque fois il faut regénérer l'affichage dans la
fenêtre.
Il y a un integer (.nnnnnnnnnn) identifiant chaque fenêtre ou
(nnnnnnnn.nnnnnnnn) pour l'identifier avec son parent. C'est cet
identifiant que je pensais récupérer au clic sur un bouton pour
l'affecter à ma variable nomfenetre.
C'est pas possible ça ?
Eric Brunel
OK, ça ressemble à l'identifiant au niveau tk, c'est ça? Je ne suis pas
sûr de comprendre pourquoi tu en as besoin, vu que normalement, avec
Tkinter, toutes les manipulations se font via des objets Python. Mais en
supposant que tu as une bonne raison, on peut récupérer l'identifiant tk
de la fenêtre simplement en faisant str(self) dans les méthodes.
HTH
ylc
chose. Je ne maitrise pas Python aussi bien que vous et j'ai renoncé
à faire de l'objet. Je suis certain qu'on peut écrire des progs sans
faire de l'Oo puisque j'ai réussi jusqu'à présent à le faire.
Même si cela peut paraitre archaïque ou démodé, voilà ce que je
voudrais faire dans mon exemple :
from Tkinter import *
def rouge() :
IdFen = //get id de la fenêtre activée// <<<<<<< ce que je
cherche à faire
IdFen.config(bg='red') <<<<<<< pour
pouvoir faire ça
def vert() :
IDfen = //get id de la fenêtre activée// <<<<<<< ce que je
cherche à faire
IdFen.config(bg='green') <<<<<<< pour
pouvoir faire ça
def fenetres() :
global top
i=0
while i < 5 :
i=i+1
top=Toplevel()
top.title("toplevel"+str(i))
top.geometry("150x20+20+"+str(i*50))
broug = Button(top, text = 'rouge', command = rouge)
bvert = Button(top, text = 'vert', command = vert)
broug.pack(side=LEFT)
bvert.pack()
# main
fen = Tk(className="Fenetre racine")
fenetres()
fen.mainloop()
.......et sans utiliser de "self"..... :)
Il doir y avoir une commande du genre Cget, mais celle-ci ne
s'applique pas aux options des toplevels.
YLC
Pierre Maurette
> Je suis désolé d'insister, mais je crois qu'on ne parle pas de la même
> chose. Je ne maitrise pas Python aussi bien que vous et j'ai renoncé
> à faire de l'objet. Je suis certain qu'on peut écrire des progs sans
> faire de l'Oo puisque j'ai réussi jusqu'à présent à le faire.
Ce que je trouve bien entre autres chose dans Python c'est
effectivement le fait de pouvoir faire ou ne pas faire de l'objet, de
pouvoir utiliser de l'objet dans un script non objet, etc. En bref, de
ne pas être tenu par une "philisophie" trop rigide. Mais sur ce coup-là
je vous trouve un peu têtu. Si vous avez renoncé à "faire de l'objet"
même un tout petit peu, il vous faut également renoncer à Tkinter, qui
est objet. Dès que vous écrivez:
MaFenetrePrincipale = Tk()
vous faites de l'objet.
Si c'est un jeu, vous pouvez faire ça, juste une petite modif de votre
code, mais qui ne me semble pas réellement plus simple à piger qu'une
petite classounette:
#! /usr/bin/env python
# -*- coding: utf-8 -*-
from Tkinter import *
def rouge(n):
vasistas[n].config(bg='red')
def vert(n) :
vasistas[n].config(bg='green')
def fenetres() :
i=0
tops = []
while i < 5 :
top=Toplevel()
top.title("toplevel"+str(i))
top.geometry("150x20+20+"+str(i*50))
broug = Button(top
, text = 'rouge'
, command = eval("lambda : rouge(" + str(i) +
")"))
bvert = Button(top
, text = 'vert'
, command = eval("lambda : vert(" + str(i) + ")"))
broug.pack(side=LEFT)
bvert.pack()
i=i+1
tops.append(top)
return tops
fen = Tk(className="Fenetre racine")
vasistas = fenetres()
fen.mainloop()
> Il doir y avoir une commande du genre Cget, mais celle-ci ne
> s'applique pas aux options des toplevels.
Je pense que vous vous perdez avec ces histoires d'identificateurs.
Déjà, dans le code ci-dessus, on garde trace (un nom dans un namespace)
des fenêtres créees, sous la forme vasistas[n]. Dans le code de Eric,
on créait les fenêtres comme de petits organismes qu'on laisserait
vivre leur vie. Mais on aurait aussi bien pu en garder l'accès, en les
nommant. Voici un exemple, dans lequel la fenêtre principale peut agir
sur les petites fenêtres, et même les petites fenêtres on accès à leurs
copines (attention, c'est bugué et ça ne résiste pas à la fermeture
d'une petite fenêtre):
#! /usr/bin/env python
# -*- coding: utf-8 -*-
from Tkinter import *
class MaFenetre(Toplevel):
def __init__(self, i):
Toplevel.__init__(self)
self.ident = i
self.title("toplevel"+str(i))
self.geometry("150x20+20+"+str(i*50))
broug = Button(self, text = 'rouge', command = self.rouge)
bvert = Button(self, text = 'vert', command = self.vert)
broug.pack(side=LEFT)
bvert.pack()
def _noircitAutres(self):
#noircit les autres fenêtres
[vasistas[i].noir() for i in range(self.ident) + range(self.ident
+ 1, 5)]
def rouge(self):
self._noircitAutres()
self.config(bg='red')
def vert(self):
self._noircitAutres()
self.config(bg='green')
def noir(self):
self.config(bg='black')
def fenetres():
return [MaFenetre(i) for i in range(5)]
def rouge():
vasistas[int(spin.get())].rouge()
def vert():
vasistas[int(spin.get())].vert()
fen = Tk(className="Fenetre racine")
vasistas = fenetres()
vasistas[2].noir()
spin = Spinbox(fen, from_ = 0, to = 4)
broug = Button(fen, text = 'rouge', command = rouge)
bvert = Button(fen, text = 'vert', command = vert)
spin.pack()
broug.pack(side=LEFT)
bvert.pack(side=RIGHT)
fen.mainloop()
Enfin, tant qu'à faire, une classe également pour la fenêtre
principale. Ça résiste un peu mieux à la fermeture des petites
fenêtres, mais ça demande à être débugué. Je vous conseille vivement de
partir dans cette voie:
#! /usr/bin/env python
# -*- coding: utf-8 -*-
from Tkinter import *
class MainFenetre(Tk):
def __init__(self, nom):
Tk.__init__(self, className=nom)
broug = Button(self, text = 'rouge', command = self.rouge)
bvert = Button(self, text = 'vert', command = self.vert)
self.spin = Spinbox(self, from_ = 0, to = 4)
self.spin.pack()
broug.pack(side=LEFT)
bvert.pack()
self.vasistas = [MaFenetre(i) for i in range(5)]
def rouge(self):
self.vasistas[int(self.spin.get())].rouge()
def vert(self):
self.vasistas[int(self.spin.get())].vert()
class MaFenetre(Toplevel):
vasistas = []
def __init__(self, i):
Toplevel.__init__(self)
self.ident = i
self.title("toplevel"+str(i))
self.geometry("150x20+20+"+str(i*50))
broug = Button(self, text = 'rouge', command = self.rouge)
bvert = Button(self, text = 'vert', command = self.vert)
broug.pack(side=LEFT)
bvert.pack()
MaFenetre.vasistas.append(self)
self.protocol("WM_DELETE_WINDOW", self.onClose)
def onClose(self):
MaFenetre.vasistas.remove(self)
fen.vasistas = MaFenetre.vasistas
fen.spin.config(to=len(MaFenetre.vasistas) - 1)
self.destroy()
def _noircitAutres(self):
#noircit les autres fenêtres
[MaFenetre.vasistas[i].noir() for i in range(self.ident) +
range(self.ident + 1, len(MaFenetre.vasistas))]
def rouge(self):
self._noircitAutres()
self.config(bg='red')
def vert(self):
self._noircitAutres()
self.config(bg='green')
def noir(self):
self.config(bg='black')
fen = MainFenetre("Fenetre racine")
fen.mainloop()
--
Pierre Maurette
ylc
Merci beaucoup à Eric et à Pierre pour vos explications. Je ne sais
quoi trop vous dire pour ne pas vous vexer, mais vous voulez
absolument que j'utilise des classes pour résoudre mon problème. Pour
vous cela semble très évident, mais pour moi cela ne l'est pas. Dès
que le code se complique, cela devient à mes yeux inconpréhensible.
C'est comme si vous vouliez résoudre un problème d'arithmétique en
apportant une solution algébrique.....vous aurez beau dire que c'est
facile et que vous avez la bonne réponse, ce n'est pas la solution
demandée.
Disons que je fais un blocage sur le mot self ; ce n'est pas grave, ça
doit se soigner, et on peut vivre avec :-)
Je vais chercher une autre solution pour ne pas avoir à gérer mes
images dans plusieurs Toplevels (comme ça je contourne la difficulté)
et réduire peut-être mes ambitions sur les manipulations que je
voulais rendre possible.
Je vous remercie quand même très sincèrement.
YLC
ylc
nomfenetre.focus_displayof()
J'ai relu toute la doc Tkinter de Shipman (New Mexico Tech)
et j'ai enfin trouvé la réponse à ma question.
Voilà ce que ça donne dans mon exemple de départ :
# test multifenêtres
from Tkinter import *
def rouge() :
tip=top.focus_displayof() # ce que je cherchais
tip.config(bg='red')
def vert() :
tip=top.focus_displayof()
tip.config(bg='green')
def fenetres() :
global top
i=0
while i < 5 :
i=i+1
top=Toplevel()
top.title("toplevel"+str(i))
top.geometry("150x50+20+"+str(i*50))
canaff = Canvas(top,width=50,height=50)
broug = Button(top, text = 'rouge', command = rouge)
bvert = Button(top, text = 'vert', command = vert)
broug.pack(side=LEFT)
bvert.pack(side=RIGHT)
# main
fen = Tk(className="Fenetre racine")
fenetres()
fen.mainloop()
Je suis bien content car je croyais ne jamais trouver !
....et c'est moins compliqué que de créer des classes, puis
d'instancier chaque widget. isn't it ?
PS : je suis breton (ceci explique peut-être cela) :-))
YLC
Francois
> Disons que je fais un blocage sur le mot self ; ce n'est pas grave, ça
> doit se soigner, et on peut vivre avec :-)
Oui mais c'est quand même dommage. Souhaitez vous une explication sur le
mot "self" ? Je ne suis pas un expert, loin de là, mais si vous le
souhaitez, je veux bien tenter une explication simple là dessus. :-)
--
François
Pierre Maurette
Je plussoie. Je suis assez buse en Python, mais parfois pas trop nul en
pédagogie des langages informatiques. Si le monsieur montre un embryon
de curiosité...
--
Pierre Maurette
moky
Je ne trouve pas qu'il faille commencer par expliquer le mot "self". À
titre personnel, j'avais tapé ce petit "hello word" bien avant de
commprendre "self", "object" et "__init__" ... et même avant de vraiment
comprendre ce qu'était un objet :
++++++++++++++++++++++
#! /usr/bin/python
# -*- coding: utf8 -*-
class vecteur(object):
def __init__(self,a,b):
self.x = a
self.y = b
def norme(self):
return (self.x)**2+(self.y)**2
v = vecteur(3,4)
print "Composante X : "+str(v.x)
print "Norme : "+str(v.norme() )
+++++++++++++++++++++++++++++
Je crois que tout le monde a écrit ce code au moins une fois dans sa vie
(c'est un passage obligé, un peu comme écrire un jeu de snake quand on
est ado)
Au début, on fait des petits trucs en prenant "self" pour de la syntaxe
un peu magique, et avec le temps, on comprend mieux à force d'utiliser.
Bonne journée
Laurent
ylc
mais en fait j'ai compris comment ça marche et je sais faire une
classe et dériver des instanciations tant que c'est du code simple.
Quand cela se complique par moultes fonctions plus ou moins
imbriquées, je ne m'y retrouve pas et je trouve que la lisibilité du
prog en cas de maintenance est difficile. L'an dernier, un pythoniste
de cette liste m'avait très bien expliqué les bases de l'Oo et grâce à
lui j'avais progressé, mais je ne suis pas allé très loin.
Merci à tous pour votre aide, c'est sympa de ne pas se sentir seul
avec ses docs.....
YLC
Eric Brunel
Mmmmouais.... AMHA, pas forcément très pertinent: si jamais on veut
utiliser les fonctions rouge et vert dans un autre cadre que celui des
boutons, on va avoir des surprises...
Bon, si tu ne veux pas utiliser les classes, partons dans le fonctionnel
alors. Voilà une autre solution, que je trouve moins lisible, mais qui
fonctionne aussi:
-------------------------------------
from Tkinter import *
def rouge(fenetre) :
fenetre.config(bg='red')
def vert(fenetre) :
fenetre.config(bg='green')
def fenetres() :
global top
i=0
while i < 5 :
i=i+1
top=Toplevel()
top.title("toplevel"+str(i))
top.geometry("150x50+20+"+str(i*50))
canaff = Canvas(top,width=50,height=50)
broug = Button(top, text = 'rouge', command = lambda top=top:
rouge(top))
bvert = Button(top, text = 'vert', command = lambda top=top:
vert(top))
broug.pack(side=LEFT)
bvert.pack(side=RIGHT)
# main
fen = Tk(className="Fenetre racine")
fenetres()
fen.mainloop()
-------------------------------------
/me s'attend maintenant à une allergie à lambda aussi....
> Je suis bien content car je croyais ne jamais trouver !
> ....et c'est moins compliqué que de créer des classes, puis
> d'instancier chaque widget. isn't it ?
Ben.... non en fait :-)
> PS : je suis breton (ceci explique peut-être cela) :-))
Y'a pas de mal: moi aussi (enfin bientôt....)
ylc
Et bien non, je ne suis pas allergique aux lambda (j'en utilise
déjà)...
Par contre, effectivement,il semble difficile de faire ce que je
voulais faire
sans passer par un code objet, car à chaque étape je repousse le
problème
d'identification de l'objet à traiter au niveau suivant. En effet,
après avoir identifié
la fenêtre ayant le focus, il faut que j'identifie le canvas, puis
ensuite l'image
affichée....etc.. Du coup je me contente d'afficher mes images sans
aucune
fontion associé en dehors de la fermeture de la fenêtre.
Mon code est visible à cette adresse :
http://www.pythonfrance.com/codes/COMPACTEUR-IMAGES-JPEG-LOT_45007.aspx
J'essaayerai de reprendre mon prog en décrivant des classes et en
dérivant mes objets, mais seulement si l'hiver est long et froid, car
j'ai plein
d'autres chose à faire.
En tout cas vous m'avez convaincu. ;-)
Cordialement
YLC
Jean Louison
Ma question est toute simple:
Dans un fichier texte, j'ai des chaines de caractères avec des coordonnées.
ex: "$$polygon( "SIGNAL_1", , [-0.7, -0.7, 0.7, -0.7, 0.7, 0.7, -0.7, 0.7] );"
Je cherche a obtenir deux listes x et y
(dans l'exemple la syntaxe est [x1, y1, x2, y2, ....])
Comme je suis débutant, j'y arrive, mais avec pleins de lignes...
maListe = lineExemple.split('[')[1].split(']')[0].split(',')
Et après, comment je partage maListe en deux liste x et y ???
Je suis sure que vous avez plus simple à me proposer.
Merci,
Jean.
Méta-MCI (MVP)
J'ai oublié, pour obtenir les éléments de rang pair (je suppose 0 comme
étant pair) :
print lat[::2]
Et, pour les éléments de rang impair :
print lat[1::2]
@+ (bis)
--
Michel Claveau
Méta-MCI (MVP)
Un exemple valant mieux qu'un long message :
st='''$$polygon( "SIGNAL_1", , [-0.7, -0.7, 0.7, -0.7, 0.7, 0.7, -0.7,
0.7] );"
'''
pat=re.compile(r'\[[+-. 0123456789]*\]', re.MULTILINE)
lat=eval(pat.findall(st)[0])
@+
--
Michel Claveau
Jean Louison
> Re !
>
> J'ai oublié, pour obtenir les éléments de rang pair (je suppose 0 comme
> étant pair) :
> print lat[::2]
>
> Et, pour les éléments de rang impair :
> print lat[1::2]
>
>
> @+ (bis)
Merci Michel,
C'est ce que je cherchais.
A+,
Jean
Jean Louison
J'ai mis longtemps à trouver qu'il fallait ajouter
import re pour que ça marche.
J'adopte cette solution,
Merci,
Jean
