IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Tkinter Python Discussion :

affichage temporaire d'une Listbox dans un Text


Sujet :

Tkinter Python

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre confirmé
    Profil pro
    Inscrit en
    Novembre 2010
    Messages
    147
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2010
    Messages : 147
    Par défaut affichage temporaire d'une Listbox dans un Text
    Bonjour,
    Il s'agit d'afficher une Listbox qui propose une complémentation au mot saisi en cours sur un widget Text.
    L'affichage de la Listbox doit être temporaire et j'aimerais que le bind '<Down>' soit effectif uniquement pendant l'affichage de la Listbox.
    J'ai essayé avec objet.after(...) et des variables pour tester si il y a une action en cours ou non, mais visiblement, je n'ai pas tout compris. Que dois-je alors modifier dans le code ci-dessous?
    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
    import tkinter
     
    class Gestion_feuille():
     
        def __init__(self):
            self.root = tkinter.Tk()
            self.compl_flag=tkinter.BooleanVar(0)
            self.root.title("Essai de complémentation")
            self.texte1 = tkinter.Text(self.root, wrap=tkinter.WORD)
            self.texte1.pack()
            self.liste_complement=tkinter.Listbox(self.root)
     
            self.liste_complement.bind('<Return>',self.remplacement_complement_direct)
     
            self.texte1.bind('<KeyRelease>', self.proposition_liste)
            self.texte1.bind('<Control-Down>', self.selection_liste_proposition)
            self.texte1.bind('<Control-space>', self.remplacement_complement_direct)
            self.texte1.focus_set()
            self.root.mainloop()
     
     
        def affichage_liste(self,event=None):
            ligne_fin=float(self.texte1.index(tkinter.END))
            ligne_insertion=float(self.texte1.index(tkinter.INSERT))
            self.position=self.texte1.index(tkinter.INSERT)
            if ligne_fin-ligne_insertion<1:
                self.texte1.insert(tkinter.END,'\n')
    #        if not self.compl_flag.get():
    #            self.compl_flag.set(1)
    #        else:
    #            self.texte1.after(3000, self.affichage_liste)
    #            return
            self.position_liste=self.position + '+1l'
    #        self.texte1.bind('<Down>', self.selection_liste_proposition)
            self.texte1.window_create(self.position_liste,align=tkinter.TOP,window=self.liste_complement)
            self.texte1.mark_set("insert", self.position)        
    #        self.texte1.after(3000,self.effacement_liste)
     
        def effacement_liste(self,event=None):
    #        self.liste_complement.forget()
            self.texte1.focus_set()
    #        self.compl_flag.set(0)
     
        def selection_balise_mot(self,event=None):
            """Délimite les balises le mot en cours par des balises"""
            position=self.texte1.index(tkinter.INSERT)
            delimitateur=r'[\s\n0-9<>,?;.:/!*&~#\"\'\-_\^@°=+{}()\[\]\|]'
            position_fin=self.texte1.search(delimitateur,index=position,stopindex=tkinter.END,regexp=1,count=1)
            position_debut=self.texte1.search(delimitateur,index=position,stopindex="1.0",backwards=1,regexp=1,count=1)
            if position_debut=="":
                position_debut="1.0"
            return position_debut,position_fin
     
        def recuperation_mot_saisi(self,event=None):
            """Fonction qui permet de récupérer le dernier <<mot>> qui est entrain d'être saisi"""
            [position_debut,position_fin]=self.selection_balise_mot()
            if position_debut=="1.0":
                mot_saisi=self.texte1.get(position_debut,position_fin)
            else:
                mot_saisi=self.texte1.get(position_debut+'+1c',position_fin)
            return mot_saisi
     
        def mots_pour_complements(self):
            """Liste des mots de complémentation"""
            liste_mots=['peut-être','essaie','si et seulement si','il faut et il suffit',r'\frac{}{}']
            return liste_mots
     
     
        def recherche_complement(self,saisie,liste_mots):
            """Saisie: le mot en cours saisie , liste de mots: la liste exhaustive et liste_complement_recherche: la selection des mots"""    
            liste_complement_recherche=[]
            for index in range(len(liste_mots)):
                if saisie in liste_mots[index]:
                    liste_complement_recherche.append(liste_mots[index])
            return liste_complement_recherche
     
        def proposition_liste(self,event=None):
                mot_saisi=self.recuperation_mot_saisi()
                liste_mots=self.mots_pour_complements()
                self.liste_complement_proposition=self.recherche_complement(mot_saisi,liste_mots)
                self.liste_complement.delete(0,tkinter.END)
                for index in range(len(self.liste_complement_proposition)):
                    self.liste_complement.insert(tkinter.END,self.liste_complement_proposition[index])
                self.liste_complement.selection_set(0,0)
                self.affichage_liste()            
     
        def selection_liste_proposition(self,event=None):
            """Si l'utilisateur tape <'Ctrl+Down'> on positionne le focus sur la liste des mots"""
            self.position_texte=self.texte1.index(tkinter.INSERT)
            self.liste_complement.focus_set()
     
        def remplacement_complement_direct(self,event=None):
            mot_select=self.liste_complement.get(self.liste_complement.curselection())
            indice=self.liste_complement.index(self.liste_complement.curselection())
            self.texte1.focus_set()
            if indice!=0:
                self.texte1.mark_set(tkinter.INSERT,self.position_texte)
            mot_saisi=self.recuperation_mot_saisi()
            [position_debut,position_fin]=self.selection_balise_mot()
            if position_debut!="1.0":
                position_debut=position_debut+'+1c'
            self.texte1.delete(position_debut, position_fin)
            self.texte1.insert(tkinter.INSERT,mot_select)
     
    if __name__ == '__main__':
        Gestion_feuille()
    Par ailleurs, petit pb subsidiaire... la Listbox se positionne sur la ligne du dessous mais ne suit pas l'évolution du texte tapé alors que j'ai fait
    <<self.position+'+1l'>>

    Puis autre problème... lorsque l'on tape 2 lignes sur le widget Text et qu'on revient sur la première ligne, la Listbox décale et coupe la deuxième ligne...

    Merci pour vos réponses.

    Gabriel

  2. #2
    Membre Expert Avatar de PauseKawa
    Homme Profil pro
    Technicien Help Desk, maintenance, réseau, système et +
    Inscrit en
    Juin 2006
    Messages
    2 725
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Technicien Help Desk, maintenance, réseau, système et +
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2006
    Messages : 2 725
    Par défaut
    Bonjour,

    Puis-je vous suggérer de ne pas utiliser .window_create() mais un Toplevel (exemple dans les sources du site)?
    Cela éviterais pas mal de souci.

    @+

    PS:
    Un 'truc', en exemple, que je n'ai jamais fini sur l'exemple des sources.
    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
    #!/usr/bin/env python
    # -*- coding: UTF-8 -*-
    #
    #
    """whiteboard.py
    Utilitaire de capture d'écran multiplateforme sous Python 2.x.
    Prérequis généraux : Tkinter et PIL
    Prérequis Linux : ImageMagick
    Prérequis Mac : screencapture
    Version de test suite à ce sujet :
    http://www.developpez.net/forums/d1058928/autres-langages/python-zope/gui/wxpython/aide-application/
    """
     
    import sys
    import os
    # TODO : port to Python 3k
    try:
        import Tkinter as Tk
        import tkFileDialog as tkFD
    except ImportError:
        import tkinter as Tk
        import tkinter.tkFileDialog as tkFD
    import Image, ImageTk
     
     
    # Classe de capture d'image
    class ScreenCap(object):
        def __init__(self):
            # Test de l'os.
            if sys.platform == 'linux2':
                self.grab = self._GarbLinux
            elif sys.platform == 'win32':
                import Image, ImageGrab
                self.grab = self._GrabWin
            elif sys.platform == 'darwin':
                self.grab = self._GrabMac
            else:
                pass # TODO
            self._currentf = None
     
        def _FicNormalyze(self, name):
            """Internal Function"""
            # Génération du chemin du fichier image. Par défaut dans le
            # Répertoire de l'utilisateur pour éviter tout problème
            # de droits.
            if name:
                if os.path.basename(name) == name:
                    _fichier = os.path.join(os.path.expanduser('~'), name)
                else:
                    _fichier = name
            else:
                # Nom par défaut
                _fichier = os.path.join(os.path.expanduser('~'), 'scrcap.jpg')
            self._currentf = _fichier
            return _fichier
     
        # Fonction de capture Linux
        def _GarbLinux(self, name=None):
            _fichier = self._FicNormalyze(name)
            _commande = "import -silent -window root " + _fichier
            os.system(_commande)
            return _fichier
     
        # Fonction de capture Windows.
        # ImageGrab de PIL ne fonctionne que sous Windows
        def _GrabWin(self, name=None):
            import ImageGrab
            _fichier = self._FicNormalyze(name)
            ImageGrab.grab().save(_fichier, "JPEG")
            return _fichier
     
        # Fonction de capture Mac.
        def _GrabMac(self, name=None): # A faire
            _fichier = self._FicNormalyze(name)
            _commande = "screencapture -m -x -t jpg " + _fichier
            os.system(_commande)
            return _fichier
     
        def delete(self):
            # Pour détruire le fichier temporaire 
            if os.path.isfile(self._currentf):
                os.remove(self._currentf)
     
    # Classe pour créer le menu principal.
    class MainMenu(object):
        def __init__(self, master, bg=None, fg=None, activefg=None):
            # Master qui vas nous donner la fenetre Tk à utiliser.
            self.master = master
            # Dicos des lignes du menu. {'titre': fonction dans master}.
            self.dicitem = {}
            self.dicctrl = {}
            if bg:
                self.bg = bg
            else:
                self.bg = 'gray'
            if fg:
                self.fg = fg
            else:
                self.fg = 'black'
            if activefg:
                self.activefg = activefg
            else:
                self.activefg = 'blue'
     
        def rootquit(self, event):
            # Tout simplement pour fermer le programme à partir du menu.
            self.master.quit()
     
        # Fonction de placement du menu. Réutilisable puisque
        # l'on donne 'widget'.
        # Remplacable par une classe pour etre plus général.
        def positionne(self, widget, x, y):
            # Mise à jour 
            widget.update()
            # Informations de géométrie sur le widget.
            reqw = widget.winfo_reqwidth()
            reqh = widget.winfo_reqheight()
            winw = widget.winfo_screenwidth()
            winh = widget.winfo_screenheight()
            posx = x - (reqw/2)
            if x + reqw/2 > winw:
                posx =  posx - ((x + reqw/2) - winw)
            elif x - reqw/2 < 0:
                posx =  0
            posy = y - reqh/2
            if y + reqh/2 > winh:
                posy =  posy - ((y + reqh/2) - winh)
            elif y - reqh/2 < 0:
                posy =  0
            # Positionement du widget
            widget.geometry("%dx%d+%d+%d" % (reqw, reqh, posx, posy))
     
        # fonction d'affichage du menu
        def affichemenu(self, event=None):
            # On détruit les Toplevel existants.
            for widget in (widget for widget in self.master.winfo_children()
                if isinstance(widget, Tk.Toplevel)):
                    return
            # On récupère la position de la souris
            position = self.master.winfo_pointerxy()
            x, y = position[0], position[1]
            # Création du Toplevel qui sert de menu
            self.topmenu = Tk.Toplevel(self.master, bg=self.bg)
            # On le réduit
            self.topmenu.withdraw()
            ctnfrm = Tk.Frame(self.topmenu, bd=1, relief=Tk.RIDGE, bg=self.bg)
            Tk.Label(ctnfrm, text='MENU', fg=self.fg,
                     bg=self.bg).pack(padx=3, pady=2)
            Tk.Frame(ctnfrm, height=2, bd=1, relief=Tk.SUNKEN,
                     bg=self.bg).pack(fill=Tk.X, padx=5, pady=5)
            # listes vides pour créer les Labels 
            lab = {}
            tri = []
            # Création des Labels suivant les dicos
            for cle in self.dicitem.keys():
                tri.append(cle)
            tri.sort()
            for elems in tri:
                cmd = self.dicitem[elems]
                lab[elems] = Tk.Label(ctnfrm, text=elems, fg=self.fg, bg=self.bg)
                lab[elems].pack(padx=3, pady=2)
                # Liaison des Labels avec la fonction de 'master'
                # qui lui correspond dans le dico.
                lab[elems].bind("<1>", cmd)
                # Association au gestionnaire de focus
                self.focusctrl(lab[elems])
            tri = []
            for cle in self.dicctrl.keys():
                tri.append(cle)
            tri.sort()
            for elems in tri:
                cmd = self.dicctrl[elems]
                lab[elems] = Tk.Label(ctnfrm, text=elems, fg=self.fg, bg=self.bg)
                lab[elems].pack(padx=3, pady=2)
                lab[elems].bind("<1>", cmd)
                self.focusctrl(lab[elems])
            # Label quitter
            labelquit = Tk.Label(ctnfrm, text='Quitter', fg=self.fg, bg=self.bg)
            labelquit.pack(padx=3, pady=2)
            self.focusctrl(labelquit)
            ctnfrm.pack(padx=3, pady=2)
            # Liaison bouton gauche sur le Label quitter avec la fonction
            # interne rootquit
            labelquit.bind("<1>", self.rootquit)
            # On positionne le menu
            self.positionne(self.topmenu, x, y)
            # On enleve les bordures
            self.topmenu.overrideredirect(True)
            # Liaison du bouton gauche > fonction qui cache le Label
            self.topmenu.bind("<1>", self.cacher)
            # On affiche le menu
            self.topmenu.deiconify()
     
        def cacher(self, event=None):
            # Destruction du menu
            self.topmenu.destroy()
     
        def focusctrl(self, widget):
            # Lorsque l'on entre ou quitter le Label on change la couleur du texte avec
            # isactive/noactive
            widget.bind("<Leave>", lambda e: self.notactive(widget))
            widget.bind("<Enter>", lambda e: self.isactive(widget))
     
        def isactive(self, widget):
            # Changement de la couleur du texte
            widget['fg']=self.activefg
            # Mise à jour forcée.
            widget.update()
     
        def notactive(self, widget):
            widget['fg']=self.fg
            widget.update()
     
        def additem(self, name, cb):
            # Ajout dans le menu
            self.dicitem[name] = cb
     
        def delitem(self, name):
            # Supprime du menu
            del self.dicitem[name]
     
        def addctrl(self, name, cb):
            # Comme additem mais pour les fonctions de controle
            # Permet de place les fonctions de controle sous les autres
            # Puisque la création des Label de controle se fait après
            # dans affichemenu
            self.dicctrl[name] = cb
     
        def delctrl(self, name):
            # Comme delitem mais pour les fonctions de controle
            del self.dicctrl[name]
     
    # instance Tk principale
    class interface(Tk.Tk):
        def __init__(self, parent):
            Tk.Tk.__init__(self, parent)
            self.title('Whiteboard')
            self.pts = []
            self.totrace = None
            # variables globales pour le dessin
            self.color = Tk.StringVar()
            self.color.set('red')
            self.width = Tk.IntVar()
            self.width.set(3)
            # Création de la capture
            self.sccap = ScreenCap()
            img = self.sccap.grab(name='scrcap.jpg')
            fcapture = Image.open(img)
            self.photo = ImageTk.PhotoImage(fcapture)
            # Mise en place de la capture dans la Canvas c
            # Le Canvas c vas nous servir pour les dessins
            self.c = Tk.Canvas(self, width=self.winfo_screenwidth(),
                height=self.winfo_screenheight())
            self.c.create_image(0, 0, image=self.photo, anchor=Tk.NW)
            # Mise à jour de la fenetre
            self.update()
            # destruction du fichier temporaire
            self.sccap.delete()
            self.c.pack(fill=Tk.BOTH)
            # Création du menu et rajout des Labels
            mainmenu = MainMenu(self, bg='white', fg='black', activefg='blue')
            mainmenu.additem('Ligne', lambda e: self.trace('ligne'))
            mainmenu.additem('Rectangle', lambda e: self.trace('rectangle'))
            mainmenu.additem('Ovale', lambda e: self.trace('ovale'))
            mainmenu.additem('Texte', lambda e: self.trace('texte'))
            mainmenu.addctrl('Effacer', lambda e: self.trace('delete'))
            mainmenu.addctrl('Sauvegarder', lambda e: self.after(2, self.sauve))
            mainmenu.addctrl('Configurer', self.config)
            mainmenu.addctrl("Réduire", self.reduire)
            # Liaison de évènements clavier/souris
            # pour la fenetre principale
            self.bind('<Escape>', self.intercepte)
            self.bind('<3>', mainmenu.affichemenu)
            self.bind('<1>', self.addlist)
            # gestion de la géométrie :
            # La fenetre principale est en plein écran
            self.wm_attributes('-fullscreen', 1)
            # On réduit la fenetre à l'initialisation du programme
            self.iconify()
     
        # Fonction pour réduire la fenetre principale
        def reduire(self, event=None):
            self.iconify()
     
        # Actions suivant self.totrace
        def addlist(self, event):
            self.pts.append((event.x, event.y))
            if self.totrace == 'delete':
                item = self.c.find_closest(event.x, event.y)
                if item != (1,):
                    self.c.delete(item)
                self.clear()
            elif self.totrace == 'ligne' and len(self.pts) == 2:
                self.c.create_line(self.pts[0][0], self.pts[0][1],
                                   self.pts[1][0], self.pts[1][1],
                                   fill=self.color.get(),
                                   width=self.width.get())
                self.clear()
            elif self.totrace == 'rectangle' and len(self.pts) == 2:
                self.c.create_rectangle(self.pts[0][0], self.pts[0][1],
                                        self.pts[1][0], self.pts[1][1],
                                        outline=self.color.get(),
                                        width=self.width.get())
                self.clear()
            elif self.totrace == 'ovale' and len(self.pts) == 2:
                self.c.create_oval(self.pts[0][0], self.pts[0][1],
                                   self.pts[1][0], self.pts[1][1],
                                   outline=self.color.get(),
                                   width=self.width.get())
                self.clear()
            elif self.totrace == 'texte':
                for widget in (widget for widget in self.winfo_children()
                    if isinstance(widget, Tk.Toplevel)):
                        widget.destroy()
                self.menutext = Tk.Toplevel()
                self.menutext.title("Ajout d'un texte")
                self.textentry = Tk.Entry(self.menutext, width=80)
                self.textentry.grid(row=0, column=0, columnspan=2, padx=5,
                                    pady=5)
                self.textentry.focus_set()
                self.btvalid = Tk.Button(self.menutext, fg='green', text='Valider',
                                         command=self.createtxt)
                self.btvalid.grid(row=1, column=0, padx=5, pady=5)
                self.btquit = Tk.Button(self.menutext, fg='red',
                                        text='Annuler',
                                        command=lambda:
                                        self.delwidget(self.menutext))
                self.btquit.grid(row=1, column=1, padx=5, pady=5)
                self.menutext.update()
                self.menutext.geometry("%dx%d+%d+%d" %
                                       (self.menutext.winfo_reqwidth(),
                                       self.menutext.winfo_reqheight(),
                                       event.x, event.y))
                self.menutext.bind('<Escape>', lambda e:
                                   self.delwidget(self.menutext))
     
        # Destruction d'un 'dessin'
        def delwidget(self, widget):
            widget.destroy()
            self.clear()
     
        # pour la création de texte
        def createtxt(self):
            self.c.create_text(self.pts[0][0], self.pts[0][1],
                               fill=self.color.get(), text=self.textentry.get())
            self.delwidget(self.menutext)
     
        # Vide la liste des points
        def clear(self):
            self.totrace = None
            del(self.pts[:])
     
        # Pour quitter proprement le programme
        def intercepte(self, event=None):
            self.quit()
     
        # initialisation de la liste des point et mise en place
        # de self.totrace
        def trace(self, obj):
            del(self.pts[:])
            self.totrace = obj
     
        # Sauvegarde de l'image
        def sauve(self, event=None):
            img = self.sccap.grab(name='scrcap.jpg')
            filetosave = tkFD.asksaveasfilename(
                initialdir=os.path.expanduser('~'), title="Enregistrement",
                filetypes=[('JPEG / JFIF','*.jpg')], defaultextension='jpg',
                initialfile='capture.jpg')
            if filetosave:
                if os.path.isfile(filetosave):
                    os.remove(filetosave)
                os.rename(img, filetosave)
            else:
                self.sccap.delete()
     
        # Menu de configuration
        def config(self, event=None):
            for widget in (widget for widget in self.winfo_children()
                if isinstance(widget, Tk.Toplevel)):
                    widget.destroy()
            self.menuconfig = Tk.Toplevel()
            self.menuconfig.title("Configuration")
            Tk.Label(self.menuconfig, text='Epaisseur de ligne').grid(row=0,
                                                                      column=0,
                                                                      padx=5,
                                                                      pady=5)
            for i in range(0, 11):
                Tk.Radiobutton(self.menuconfig, text=str(i), variable=self.width,
                               value=i).grid(row=1+i, column=0, padx=5, pady=5)
            Tk.Label(self.menuconfig, text='Couleur').grid(row=0, column=2,
                     padx=5, pady=5)
            col = 0
            for c, n in [('Noir', 'black'), ('Blanc', 'white'), ('Rouge', 'red'),
                ('Vert', 'green'), ('Bleu', 'blue'), ('Jaune', 'yellow'),
                ('Violet', 'purple'), ('Orange', 'orange'), ('Gris', 'gray'),
                ('Rose', 'pink'), ('Marron', 'brown'),]:
                Tk.Radiobutton(self.menuconfig, text=c, variable=self.color,
                               value=n).grid(row=col+1, column=2, padx=5, pady=5,
                                             sticky=Tk.W)
                col += 1
            Tk.Button(self.menuconfig, fg='green', text='Quitter',
                      command=lambda: self.delwidget(self.menuconfig)
                      ).grid(row=14, column=1, pady=10)
            self.menuconfig.bind('<Escape>', lambda e: 
                                 self.delwidget(self.menuconfig))
     
    if __name__ == "__main__":
        app = interface(None)
        app.mainloop()

  3. #3
    Membre Expert Avatar de PauseKawa
    Homme Profil pro
    Technicien Help Desk, maintenance, réseau, système et +
    Inscrit en
    Juin 2006
    Messages
    2 725
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Technicien Help Desk, maintenance, réseau, système et +
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2006
    Messages : 2 725
    Par défaut
    Petite explication quand même: Votre Windows compte pour 1 caractère pour le Widget Text.

    Vous en comprendrez l'avantage de ma proposition

    @+

  4. #4
    Membre confirmé
    Profil pro
    Inscrit en
    Novembre 2010
    Messages
    147
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2010
    Messages : 147
    Par défaut
    Bonsoir,

    Je vais tester l'exemple avec python 3.2.

    Merci

    Gabriel

  5. #5
    Membre confirmé
    Profil pro
    Inscrit en
    Novembre 2010
    Messages
    147
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2010
    Messages : 147
    Par défaut
    Rebonsoir,
    Bon, j'ai des soucis avec import Image, ImageTk, ImageGrab...
    Je suis allé sur la FAQ, mais elle est plus relative à la version 2.7 que 3.2.
    Faut-il faire tourner le programme avec 2.7?

    Gabriel

  6. #6
    Membre Expert Avatar de PauseKawa
    Homme Profil pro
    Technicien Help Desk, maintenance, réseau, système et +
    Inscrit en
    Juin 2006
    Messages
    2 725
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Technicien Help Desk, maintenance, réseau, système et +
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2006
    Messages : 2 725
    Par défaut
    Prérequis généraux : Tkinter et PIL

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 9
    Dernier message: 15/09/2011, 08h50
  2. Export du contenu d'une listbox dans un fichier texte
    Par GCAccess dans le forum VBA Word
    Réponses: 10
    Dernier message: 07/11/2008, 00h46
  3. PB d'affichage d'une listbox dans Access
    Par Tybox dans le forum IHM
    Réponses: 3
    Dernier message: 19/12/2007, 14h54
  4. affichage d'une cellule dans un text box
    Par magictom42 dans le forum Macros et VBA Excel
    Réponses: 4
    Dernier message: 06/11/2006, 11h10
  5. Réponses: 1
    Dernier message: 11/05/2006, 16h37

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo