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 :

Combobox uniquement avec Tkinter


Sujet :

Tkinter Python

Mode arborescent

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre averti
    Homme Profil pro
    Technicien réseaux et télécoms
    Inscrit en
    Mai 2012
    Messages
    70
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Technicien réseaux et télécoms
    Secteur : Service public

    Informations forums :
    Inscription : Mai 2012
    Messages : 70
    Par défaut Combobox uniquement avec Tkinter
    Bonjour,

    Ci-dessous une class Combobox, géré uniquement avec Tkinter.
    Je sais que ttk et tix le font aussi, mais l'idée était de développer cette class par défi.

    Par contre, je serais intéressé par les critiques.
    Savoir quel point sont mauvais ou/et comment les améliorer.

    Cordialement

    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
    478
    479
    480
    481
    482
    483
    484
    485
    486
    487
    488
    489
    490
    491
    492
    493
    494
    495
    496
    497
    498
    499
    500
    501
    502
    503
    504
    505
    506
    507
    508
    509
    510
    511
    512
    513
    514
    515
    516
    517
    518
    519
    520
    521
    522
    523
    524
    525
    526
    527
    528
    529
    530
    531
     
    #!/usr/bin/env python
    # -*- coding:UTF-8 -*-
     
    #-------------------------------------------------------------------------------
    # Name:        module1
    # Purpose:
    #
    # Author:      MzBouba
    #
    # Created:     13/04/2012
    # Copyright:   (c) MACHADO.F 2012
    # Licence:     <your licence>
    #-------------------------------------------------------------------------------
    """
    Options standard
     
        activestyle         :Spécifie l'apparence de la ligne active de la liste.
        background  / bg    :Couleur de fond.
        disabledbackground  :Couleur de fond quand le widget est à l'état DISABLED.
        disabledforeground  :Couleur de premier plan affichée quand l'état
                             du widget est DISABLED.
        exportselection     :Par défaut, l'utilisateur sélectionner le texte avec
                             la souris et le texte choisi sera exporté au
                             presse-papiers.
                             Pour mettre hors service ce comportement,
                             utilisez exportselection=0.
        command             :Lance une commande lors du changement de la valeur du
                             champ de saisie.
        borderwidth / bd    :Largeur de la frontière autour de la combobox.
        cursor              :Curseur utilisé quand la souris est sur le widget.
        foreground  / fg    :Couleur du texte.
        highlightbackground :Couleur highlight quand le widget n'a pas de focus.
        highlightcolor      :Couleur highlight quand le widget a un focus.
        highlightthickness  :Intensité de la couleur de focus.
        height              :Nombre de lignes affichés dans la liste.
        insertbackground    :Couleur du curseur d'insertion.
        insertborderwidth   :
        insertofftime       :Clignotement du curseur, temps où il est éteint.
        insertontime        :Clignotement du curseur, temps où il est allumé.
        insertwidth         :Largeur du curseur. 2 pixels par défaut.
        items               :Liste de éléments.
        justify             :Emplacement du texte.
        listvariable        :StringVar connecté à la liste complète.
        matchrequired       :La valeur de saisie doit être dans la liste.
                             Si elle n'y figure pas, le premier élément de la liste
                             est sélectionné
        nodouble            :Enlève les doubles de la liste.
                             0:Ne fait rien (par défaut)
                             1:Supprime les doubles
        readonlybackground  :Couleur de fond l'état du widget est "readonly".
        relief              :Effets tridimensionnels autour de l'entrée de texte.
        selectbackground    :Couleur de fond à l'affichage du texte sélectionné.
        selectborderwidth   :Largeur de la frontière utilisé autour du texte
                             sélectionné. Par défaut un pixel.
        selectforeground    :Couleur de premier plan du texte sélectionné.
        sort                :Tri la liste suivant la valeur renseignée.
                             None       :Pas de tri (par défaut)
                             sort       :Tri croissant par ordre alphanumérique
                             reversed   :Tri décroissant par ordre alphanumérique
                             reverse    :inversion de la liste
        state               :Etat du widget (NORMAL, DISABLED).
        takefocus           :Normalement, le focus contrôle le widget;
                             fournissez la valeur 0 à cette option pour obtenir
                             l'interruption du contrôle de focus.
        textvariable        :StringVar associé à la zone de saisie.
        width               :Largeur de l'étiquette en caractères (pas pixels!).
                             La largeur est basée sur la moyenne des caractères,
                             donc quelques chaînes dans des polices de caractères.
                             proportionnelles ne peuvent pas aller à cette longueur.
        xscrollcommand      :A lier avec une scrollbar pour faire défiler le texte
                             de la boite de saisie si ce texte est trop long.
     
    Methode
     
        append_             :Ajout d'un élément à la fin d'une liste.*
        change_list         :Remplace la liste par une nouvelle.*
        clear_list          :Vide la liste
        extend_             :Concatène la liste d'origine avec la liste <otherlist>.*
        get                 :Récupère la valeur du champ de saisie.
        index_to_item       :Renvoi l'élément de la liste se trouvant à la ligne(index)
        insert_             :Ajout d'un élément dans la liste à la ligne index.*
        item_to_index       :Renvoi l'<index> (ligne), de la liste, correspondant
                             à <item>
        remove_             :Supprime un élément de la liste
        set                 :Modifie le champ de saisie avec la valeur renseignée.
        size                :Renvoi le nombre d'élément de la liste
     
        * Les méthodes de suppression de double et de tri sont aussi appelé.
          Vérifier les options nodouble et sort.
    """
    from tkinter import *
    from time import *
    #import tkinter.messagebox as tkMessageBox
     
    class Combobox(Frame):
        """Champ de saisie associé à une liste déroulante"""
        def __init__(self, master=None, command = '', height=10, items=[],
                        matchrequired=0, nodouble = 0, sort=None, width=20, **Arg
                        ):
            """Construit un Widget Combobox avec master comme parent
     
                Option Standard
     
                        activestyle, background  / bg,
                        disabledbackground, disabledforeground,
                        exportselection, borderwidth / bd, command,
                        cursor, foreground  / fg, highlightbackground,
                        highlightcolor, highlightthickness, height,
                        insertbackground, insertborderwidth,
                        insertofftime, insertontime, insertwidth,
                        items, justify, listvariable, matchrequired,
                        nodouble, readonlybackground, relief,
                        selectbackground, selectborderwidth,
                        selectforeground, sort, state, takefocus,
                        textvariable, width, xscrollcommand
     
                Methode
     
                        append_, change_list, clear_list, extend_,
                        get, index_to_item, insert_, item_to_index,
                        remove_, set, size
            """
            self.Arg=Arg  # Dictionnaire des options de configuration de la Combobox
            self.command=command
            self.height = height
            self.index = -1
            self.items = items
            self.master = master
            self.matchrequired = matchrequired
            self.nodouble = nodouble
            self.sort = sort
            self.sVar = StringVar()
            self.width = width
            self.widget_option = {}
            self.widget_option['button'] = ('bg', 'background', 'cursor', 'fg',
                        'foreground', 'highlightbackground', 'highlightcolor',
                        'highlightthickness', 'relief',
                        )
            self.widget_option['entry'] = ('bg', 'background', 'cursor',
                        'disabledbackground', 'disabledforeground',
                        'exportselection','fg', 'foreground', 'highlightbackground',
                        'highlightcolor', 'highlightthickness', 'insertbackground',
                        'insertborderwidth', 'insertofftime', 'insertontime',
                        'insertwidth', 'justify', 'readonlybackground', 'relief',
                        'selectbackground', 'selectborderwidth', 'selectforeground',
                        'state', 'takefocus', 'textvariable', 'width',
                        'xscrollcommand',
                        )
            self.widget_option['frame'] = ('bd', 'borderwidth', 'cursor',
                        'height', 'highlightbackground',
                        'highlightcolor', 'highlightthickness', 'padx', 'pady',
                        'relief', 'takefocus', 'width',
                        )
            self.widget_option['listbox'] = ('activestyle', 'bg', 'background',
                        'cursor', 'exportselection', 'fg', 'foreground', 'height',
                        'highlightbackground', 'highlightcolor',
                        'highlightthickness', 'listvariable', 'relief',
                        'selectbackground', 'selectborderwidth', 'selectforeground',
                        'width',
                        )
            self.widget_option['scrollbar'] = ('bg', 'background', 'cursor',
                        'highlightbackground', 'highlightcolor',
                        'highlightthickness', 'relief',
                        )
            self.widget_option['toplevel'] = ('bg', 'background', 'cursor',
                        'highlightbackground', 'highlightcolor',
                        'highlightthickness', 'relief',
                        )
     
            # <Frame>---------------------------------------------------------------
            Frame.__init__(self, master, self.__widget_arg__('frame', self.Arg))
     
            if type(self.items) != list:
                if type(self.items) == tuple:
                    self.items = list(self.items)
                else:
                    self.items=['Liste incorrecte']
     
            self.bind('<FocusOut>', self.__match_required__)
            self.__nodouble_in_list__()
            self.__sort_list__()
            self.__initialize__()
     
        def test(self, event):
            print(event.widget)
     
     
        # Initialise la partie graphique
        def __initialize__(self):
            """Fonction interne"""
     
            # Actualise <Entry> en fonction de <self.index>
            def __actu_entry__():
                """Fonction interne"""
                if len(self.items)!= 0:
                    indexmax=len(self.items) - 1
                    if self.index >= indexmax:
                        self.index = indexmax
                    if self.index <= 0:
                        self.index= 0
                    self.set(self.index_to_item(self.index))
                    self.__command__()
                else: self.index = -1
     
            # Autocomplétion lors de la saisie de texte
            def __auto_completion__(event):
                """Fonction interne"""
                if event.keysym not in ['BackSpace', 'Delete', 'Down', 'Up']:
                    index = -1
                    for item in self.items:
                        index += 1
                        if self.sVar.get() in item[:(len(self.sVar.get()))]:
                            self.sVar.set(item)
                            self.entry.select_range(INSERT,END)
                            self.index = index
                            self.__command__()
                            break
                        else:
                            self.__command__()
     
     
            # Action de la touche bas du clavier.
            # fait défiler les items de la liste vers le bas
            def __keypress_down__(event=None):
                """Fonction interne"""
                self.index = self.index + 1
                __actu_entry__()
     
            # Action de la touche haut du clavier.
            # fait défiler les items de la liste vers le haut
            def __keypress_up__(event=None):
                """Fonction interne"""
                self.index = self.index - 1
                __actu_entry__()
     
            # Déplacement de la molette de souris quand le focus est sur <Entry>
            # Action de la molette de la souris. Défilement des items de la liste.
            def __mouse_wheel__(event):
                """Fonction interne"""
                self.index = self.index + int(-event.delta/120)
                __actu_entry__()
            # <Entry>---------------------------------------------------------------
            self.entry=Entry(self, self.__widget_arg__('entry', self.Arg),
                             borderwidth=0, font='Arial, 8', textvariable=self.sVar,
                             width = self.width)
            self.entry.grid(row=0, column=0)
            self.entry.bind('<Down>',__keypress_down__)          # touche bas
            self.entry.bind('<KeyRelease>',__auto_completion__)
            self.entry.bind('<MouseWheel>',__mouse_wheel__)      # Molette de souris
            self.entry.bind('<Up>',__keypress_up__)              # touche haut
            # <Button>--------------------------------------------------------------
            self.sVarbutton=StringVar()
            self.sVarbutton.set('▼')
            self.button=Button(self, self.__widget_arg__('button', self.Arg),
                                background='white', disabledforeground='black',
                                borderwidth=0, command=self.__open_list__,
                                font='Arial, 7', height=1, takefocus=0,
                                textvariable=self.sVarbutton)
            self.button.grid(row=0, column=1)
     
        # lance la commande associé à la combobox en récupérant le contenu de <Entry>
        def __command__(self):
            """Fonction interne"""
            try: self.command(self.sVar.get())
            except: pass
     
        # Créer la <Toplevel> contenant la <Listbox>
        def __create_toplevel__(self):
            """Fonction interne"""
            # Rend l'utilisation du <bouton-1> au <Button>
            def active_button(event_add=None):
                self.button.config(state=NORMAL)
                self.sVarbutton.set('▼')
     
            # Ferme la liste
            def close_list(event=None):
                """Fonction interne"""
                self.toplevel.destroy()
                self.after(1, active_button)
     
            # Déplacement de la souris dans <Listbox>
            def move_mouse(event):
                """Fonction interne"""
                self.listbox.selection_clear(0,END)
                self.listbox.activate(self.listbox.nearest(event.y))
                self.listbox.selection_set(self.listbox.nearest(event.y))
     
            # Sélection d'une item dans <Listbox>
            def select_item(event=None):
                """Fonction interne"""
                if int(self.listbox.size()):            # <Listbox> non vide
                    index=self.listbox.curselection()   # renvoie un tuple d'index
                    ind0 =int(index[0])                 # on ne garde que le premier
                    self.index=ind0
                    item=self.listbox.get(ind0)
                    # <Entry>: Actualisation suivant l'item choisi dans la <Listbox>
                    self.sVar.set(item)
                    # <Entry>: Prend le focus
                    self.entry.focus_set()
                    # <Entry>: Déplace le curseur au début
                    self.entry.icursor(0)
                    # <Entry>: Sélectionne le mot
                    self.entry.select_range(0,END)
                    # <Toplevel>: Destruction
                close_list()
                self.__command__()
     
            # <Toplevel>------------------------------------------------------------
            self.toplevel=Toplevel(self,
                                    self.__widget_arg__('toplevel', self.Arg),
                                    #height=self.height,
                                    )
            #<Toplevel>: Supprime le contour de fenetre
            self.toplevel.overrideredirect(1)
            #<Toplevel>: Geometrie
            x=self.entry.winfo_rootx()             # Coordonnees reelles de
            y=self.entry.winfo_rooty()             # <Entry>
            xTop, yTop=x-2, y + 18
            self.toplevel.geometry("+{}+{}".format(xTop, yTop))
            # <Toplevel> tjs en 1er plan
            self.toplevel.transient()
            # <Toplevel>: Perte du focus, la <Toplevel> se ferme
            self.toplevel.bind('<FocusOut>', close_list)
            self.button.config(state=DISABLED)
     
            # <Listbox>-------------------------------------------------------------
            self.listbox=Listbox(self.toplevel,
                                    self.__widget_arg__('listbox', self.Arg),
                                    width = self.width+2, height=self.height,
                                    )
            self.listbox.pack(side=LEFT)
            # <ListBox>: Remplissage
            for it in self.items:
                self.listbox.insert(END, it)
            # <Listbox>: prend le focus
            self.listbox.focus()
            # <Listbox>: Action
            self.listbox.bind('<Button-1>', select_item)
            self.listbox.bind('<Motion>', move_mouse)
            # <listbox>: Sélection de l'item = <Entry>
            index = self.item_to_index(self.sVar.get())
            if self.index_to_item(self.index) == self.sVar.get():
                if self.index != index:
                    index=self.index
            else:
                index=0
            # <listbox>: Positionne le cuseur sur la valeur de <Entry>
            self.listbox.activate(index)
            self.listbox.selection_set(index)
            self.listbox.see(index)
     
            # <Scrollbar>-----------------------------------------------------------
            if len(self.items) > self.height:
                # <Scrollbar>: Association avec <Listbox>
                self.scrollbar=Scrollbar(self.toplevel,
                                    self.__widget_arg__('scrollbar', self.Arg),
                                     borderwidth=0,
                                     command=self.listbox.yview, width=15,
                                    )
                # <scrollbar>: Implantation
                self.scrollbar.pack(expand =YES, fill =Y)
                # <Listbox>: Association avec <scrollbar>
                self.listbox.config(yscrollcommand=self.scrollbar.set)
                self.listbox.config(width=self.width)
     
        # Vérifie que la valeur saisie est dans la liste
        def __match_required__(self, event=None):
            """Fonction interne"""
            if self.matchrequired:
                listboxId = 0
                try:
                    # Si la <Listbox> prend le focus on ne vérifie pas
                    if self.nametowidget(self.focus_get()) == self.nametowidget(self.listbox):
                        listboxId = 1
                except:
                    pass
                if not listboxId:
                    if not self.sVar.get() in self.items:
                        if self.index == -1:
                            self.sVar.set(self.items[0])
                            self.index=0
                        else:
                            self.sVar.set(self.items[self.index])
     
        # Suppression des doubles dans la liste
        def __nodouble_in_list__(self):
            """Fonction interne"""
            if self.nodouble:
                index0=0
                while index0 < len(self.items)-1:
                    index1 = len(self.items)-1
                    while index1 != index0:
                        if self.items[index0] == self.items[index1]:
                            del(self.items[index1])
                        index1 -= 1
                    index0 += 1
     
        # Ouvre la liste
        def __open_list__(self, event=None):
            """Fonction interne"""
            self.__create_toplevel__()
            self.sVarbutton.set('▲')
     
        # Tri la liste suivant l'option
        def __sort_list__(self):
            """Fonction interne"""
            if self.sort == 'sort': self.items.sort()
            elif self.sort == 'reversed': self.items.sort(reverse=True)
            elif self.sort == 'reverse': self.items.reverse()
     
        # Retourne la liste des options d'un widget
        def __widget_arg__(self, name, arg = {}):
            """Fonction interne"""
            dic_arg={}
            for option in arg:
                if option in self.widget_option[name]:
                    dic_arg[option]=arg[option]
            return dic_arg
     
        #
        def append_(self, string=''):
            """Ajout d'un élément à la fin d'une liste.
               Les méthodes de suppression de double et de tri sont
               aussi appelé.
               Vérifier les options nodouble et sort."""
            self.items.append(string)
            self.__nodouble_in_list__()
            self.__sort_list__()
     
        #
        def change_list(self, newlist=()):
            """Remplace la liste par une nouvelle"""
            self.items=newlist
            self.__nodouble_in_list__()
            self.__sort_list__()
     
        #
        def clear_list(self):
            """Vide la liste"""
            self.items = []
     
        #
        def extend_(self, otherlist=[]):
            """Concatène la liste d'origine avec la liste <otherlist>.
               Les méthodes de suppression de double et de tri sont
               aussi appelé.
               Vérifier les options nodouble et sort."""
            self.items.extend(otherlist)
            self.__nodouble_in_list__()
            self.__sort_list__()
     
        #
        def get(self):
            """Récupère la valeur du champ de saisie"""
            return self.sVar.get()
     
        #
        def index_to_item(self, index=0):
            """Renvoi l'élément de la liste se trouvant à la ligne(index)"""
            try: return self.items[index]
            except: pass
     
        #
        def insert_(self, index = END, string = ''):
            """Ajout d'un élément dans la liste à la ligne index.
               Les méthodes de suppression de double et de tri sont
               aussi appelé.
               Vérifier les options nodouble et sort."""
            if index == END: index = len(self.items)
            self.items.insert(index, string)
            self.__nodouble_in_list__
            self.__sort_list__
     
        #
        def item_to_index(self, string=''):
            """Renvoi la ligne (index) dans la liste du premier élément
               correspondant trouvé"""
            try: self.items.index[string]
            except: index = -1
            return index
     
        #
        def remove_(self, string=''):
            """Supprime un élément de la liste"""
            try: self.items.remove(string)
            except: pass
     
        #
        def set(self, string = ''):
            """Modifie le champ de saisie avec la valeur renseignée"""
            self.sVar.set(string)
            # <Entry>: Déplace le curseur au début
            self.entry.icursor(0)
            self.entry.selection_range(0, END)
     
        #
        def size(self):
            """Renvoi le nombre d'élément de la liste"""
            return len(self.items)
     
     
    mylist=('Pommes', 'Poires', 'Abricot', 'Ananas', 'Raisin','Orange',
            'Clémentine', 'Cerise', 'Mandarine', 'Peche', 'Poires', 'Abricot', )
    nlist='autre'
    listempty=['saucisse', 'merguez']
     
    def main():
        def label_value():
            label.config(text=combobox.index_to_item(0) )
            combobox.extend_(['rien', 'autre'])
     
     
        window=Tk()
        frame=Frame(window)
        frame.grid()
        combobox=Combobox(frame, activestyle='dotbox', borderwidth=2, insertborderwidth=10, troughcolor='#357',
                        items= mylist, relief=GROOVE, font='Arial, 8',height=5,
                         width=25, matchrequired=1, sort='reverse')
        combobox1=Combobox(frame, activestyle='dotbox',  borderwidth=2, items=listempty,
                             matchrequired=1, width=25)
        button=Button(frame, text='test', command=label_value)
        label=Label(frame)
        button.grid(row=0,column=0)
        label.grid(row=0,column=1)
        combobox.grid(row=1,column=0)
        combobox1.grid(row=2,column=0)
        window.mainloop()
     
    if __name__ == '__main__':
        main()
    Fichiers attachés Fichiers attachés

Discussions similaires

  1. ComboBox avec Tkinter
    Par Spitfire 95 dans le forum Tkinter
    Réponses: 3
    Dernier message: 14/02/2010, 12h45
  2. Réponses: 6
    Dernier message: 09/03/2006, 13h35
  3. [Tkinter] Plusieurs fenêtre avec Tkinter
    Par cyrpaut dans le forum Tkinter
    Réponses: 2
    Dernier message: 04/01/2006, 22h24
  4. [Tkinter] Un petit souçis d'event avec Tkinter
    Par fire.stone dans le forum Tkinter
    Réponses: 4
    Dernier message: 29/10/2005, 20h56

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