Full Circle Magazine FR

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
Nous allons approfondir l'exploration des widgets fournis par Tkinter. Cette fois, nous allons examiner les menus, listes déroulantes, les boîtes de sélection, barres de séparation, barres de progression et les onglets. Nous en parlerons à tour de rôle.

Vous avez vu des menus dans presque toutes les applications que vous utilisez. Tkinter rend très facile la création des menus. Les listes déroulantes sont similaires aux listes dont nous avons parlé dans le dernier article sur la démo  des widgets, sauf que la liste se déroule vers le bas au lieu d'être visible en permanence. Les contrôles de sélection numérique sont pratiques pour définir une plage fixe de valeurs dans laquelle on peut se déplacer vers le haut ou vers le bas. Par exemple, si nous voulons que l'utilisateur soit en mesure de choisir des entiers compris entre 1 et 100, nous pouvons facilement utiliser une boîte de sélection. Les barres de progression sont une merveilleuse façon de montrer que votre application n'a pas planté quand quelque chose prend beaucoup de temps, comme la lecture des enregistrements d'une base de données. Elle peuvent montrer le pourcentage d'achèvement d'une tâche. Il y a deux types de barres de progression, déterminée et indéterminée. Vous utilisez une barre de progression déterminée quand vous savez exactement combien d'actions vous devez réaliser. Si vous ne connaissez pas le nombre d'actions ou le pourcentage de progression de votre tâche à un instant t, vous pouvez utiliser la version indéterminée. Nous allons travailler avec les deux. Enfin un widget à onglets verticaux (ou widget à onglets horizontaux) est régulièrement utilisé pour les réglages des écrans de configuration. Vous pouvez regrouper logiquement une série de widgets sur chaque onglet.

**We are going to explore even more widgets provided by tkinter. This time we will look at menus, combo boxes, spin boxes, separator bar, progress bars and notebooks. Let's talk about them one at a time.

You've seen menus in almost every application that you have ever used. Tkinter makes it VERY easy for us to make menus. Combo Boxes are similar to  the list box that we explored in the last widget demo article, except the list “pops down” instead of being visible at all times. Spin box controls are great for giving a fixed range of values that can “scroll” up or down. For example, if we want the user to be able to choose from integers
between 1 and 100, we can easily use a spin box. Progress bars are a wonderful way to show that your application hasn't locked up when something  takes a lot of time, like reading records from a database. It can show the percentage of completion of a task. There are two types of progress bars,
Determinate and Indeterminate. You use a determinate progress bar when you know just how many items you are dealing with. If you don't know the  number of items or the percentage of how done your task is at any point, you would use the Indeterminate version. We will work with both. Finally a notebook widget (or tabbed widget) is used many times for things like configuration screens. You can logically group a series of widgets on each tab.**

Nous allons donc commencer. Comme d'habitude, nous allons créer une application de base et construire notre programme avec des widgets supplémentaires, que nous allons lui ajouter. Regardez à droite pour la première partie de notre application. Vous avez presque déjà vu tout cela.

Enregistrez le code en tant que widgetdemo2a.py. Rappelez-vous, nous allons l'utiliser comme base pour construire la démonstration complète. Maintenant, nous allons commencer le processus de création du menu. Voici les étapes que nous allons suivre. Premièrement, nous définissons une variable pour contenir l'occurrence de menu. Comme la plupart des widgets que nous utilisons, le format est : NotreVariable = Widget(parent,options).
 
**So, let's get started. As usual, we will create a base application and build on to it with each extra widget we add. Shown right is the first part of our application. You've seen most of this before.

Save all of this as widgetdemo2a.py. Remember we will use this as the base to build the full demo. Now we will start the process of creating the menu. Here are the steps we need to do. First, we define a variable to hold the menu instance. Like most any widget we use, the format is...
OurVariable = Widget(parent, options).**

Dans le cas présent, nous utilisons le widget Menu avec l'attribut « principale » en tant que fenêtre-mère. Nous faisons cela dans la routine ConstruireWidgets. Ensuite, nous créons un autre élément de menu, cette fois-ci en le nommant menuFichier. Nous ajouterons des commandes et des séparateurs, au besoin. Enfin, nous l'ajoutons à la barre de menu et continuons de la sorte jusqu'à ce que nous ayons fini. Dans notre exemple, nous allons avoir la barre de menu, un menu déroulant Fichier, un menu déroulant Edition et un menu déroulant Aide (en haut à droite). Commençons.

Ensuite (au milieu à droite), nous nous concentrons sur le menu Fichier. Il contiendra cinq éléments. Nouveau, Ouvrir, Sauver, un séparateur et Quitter. Nous allons utiliser la méthode .add_command pour ajouter les commandes. Tout ce que nous devons faire, c'est appeler la méthode avec le texte (label = ) et ensuite fournir une fonction de rappel pour prendre la main quand l'utilisateur clique sur l'élément. Enfin, nous utilisons la fonction menubar.add_cascade pour attacher le menu à la barre.

**In this case, we are using the Menu widget and we will assign it to master as the parent. We do this under the BuildWidgets routine. Next we create another menu item, this time calling it filemenu. We add commands and separators as needed. Finally we add it to the menu bar and do it all over again until we are done. In our example, we'll have the menubar, a File pulldown, an Edit pulldown and a Help pulldown (top right). Let's get started.

Next (middle right) we concentrate on the File Menu. There will be five elements. New, Open, Save, a separator and Exit. We'll use the .add_command method to add the command. All we really need to do is call the method with the text (label = ) and then provide a callback function to handle when the user clicks the item. Finally we use the menubar.add_cascade function to attach the menu to the bar.**

Notez que la commande Quitter utilise "root.quit" pour mettre fin au programme. Pas besoin de fonction de rappel pour cela. Ensuite, nous ferons la même chose pour les menus Edition et Aide.

Notez la partie « tearoff = 0 » dans chacune des définitions de groupe de menu. Si vous changez le 0 en 1, le menu commencera par une sorte de ligne pointillée qui permet de détacher le menu de la barre de menus en créant sa propre fenêtre. Bien que cela puisse être utile dans le futur, ce n'est pas ce que nous voulons ici.

**Notice that the Exit command uses “root.quit” to end the program. No call back needed for that. Next we'll do the same thing 0for the Edit and Help menus.

Notice the part in each of the menu group definitions that says “tearoff=0”. If you were to change the “=0” to “=1”, the menu would start with what looks like a dashed line and if you drag it, it “tears off” and creates its own window. While this might be helpful sometime in the future, we don't want that here.**

Enfin et surtout, nous devons placer le menu. Nous ne faisons pas un placement normal avec la fonction .grid(). Nous allons simplement l'ajouter en utilisant la fonction parent.config (en bas à droite).

Tout cela est placé dans la routine ConstruireWidgets. Maintenant (page suivante, en haut à droite), nous avons besoin d'ajouter un cadre générique et de mettre l'instruction de retour avant de passer à la routine PlacerWidgets.

**Last but not least, we need to place the menu. We don't do a normal placement with the .grid() function. We simply add it by using the parent.config function (bottom right).

All of this has gone in the BuildWidgets routine. Now (next page, top right) we need to add a generic frame and set the return statement before we move on to the PlaceWidgets routine.**

Enfin (page suivante, en bas à droite) nous devons créer toutes les fonctions de rappel que nous avons définies plus tôt. Pour la démo, tout ce que nous allons faire c'est afficher quelque chose dans le terminal utilisé pour lancer le programme.

C'est tout. Enregistrez et exécutez le programme. Cliquez sur chacune des options de menu (en gardant Fichier|Quitter pour la fin).

**Finally (next page, bottom right) we need to create all the callbacks we defined earlier. For the demo, all we'll do is print something in the terminal used to launch the program.

That's it. Save and run the program. Click on each of the menu options (saving File|Exit for last).**

Maintenant (ci-dessous), nous allons traiter la liste déroulante. Enregistrez votre fichier sous widgetdemo2b.py et nous serons prêts à commencer. Les importations, les définitions de classes et la routine <nowiki>__init__</nowiki> sont toutes les mêmes, ainsi que la partie inférieure du programme. Nous allons ajouter deux lignes à la routine DefinirVariables. Commentez ou effacez l'instruction « pass » et mettez le code suivant (j'ai inclus la ligne de définition juste pour la clarté).

Nous définissons d'abord une étiquette, comme nous l'avons déjà fait. Ensuite, nous définissons la liste déroulante. Nous utilisons « ttk.Combobox », définissons le parent et réglons la hauteur à 19, la largeur à 20 et le textvariable à « self.selectionListeDeroulante1 ». Rappelez-vous que nous avons utilisé les « textvariables » dans le dernier article, mais juste au cas où vous l'auriez oublié... il change à tout moment sa valeur dès que la liste déroulante est modifiée. Nous l'avons défini dans DefinirVariables comme un objet StringVar. Ensuite nous chargeons les valeurs que nous voulons que l'utilisateur puisse choisir, et de nouveau, nous les avons définies dans DefinirVariables. Enfin, nous lions l'événement virtuel « ComboboxSelected » à la routine testListeDeroulante que nous allons étoffer dans une minute.

**Now (below) we'll deal with the combo box. Save your file as widgetdemo2b.py and we'll get started. The imports, class definition and the def  <nowiki>__init__</nowiki> routines are all the same, as is the bottom part of the program. We'll add two lines to the DefineVars routine. Either comment out the “pass” statement or erase it and put in the following code. (I included the definition line just for clarity.)

First we define a label, which we've done before. Next we define the combo box. We use “ttk.Combobox”, define the parent and set the height to 19, the width to 20 and the textvariable to “self.cmbo1Val”. Remember that we set textvariables in the last widget demo, but just in case you forgot...this is changed anytime the value in the combo box is changed. We defined it in DefineVars as a StringVar object. Next we load the values that we want the user to choose from, again we defined that in DefineVars. Finally we bind the virtual event <<ComboboxSelected>> to the cmbotest routine that we will flesh out in a minute.**

Ensuite, nous allons placer la liste déroulante et le titre dans notre fenêtre (en haut à droite).

Sauvegardez tout et testez.

**Next let's place the combo box and the label into our form (top right).

Save everything and test it out.**

Maintenant enregistrez sous widgetdemo2c.py et nous allons commencer avec la barre de séparation. C'est super facile. Alors que les mises à jour de Tkinter fournissent un widget barre de séparation, je n'ai jamais été en mesure de le faire fonctionner. Voici une autre façon de faire. Nous utiliserons un cadre avec une hauteur de 2. Les seuls changements à notre programme seront la définition du cadre dans ConstruireWidgets après l'instruction « bind » de la liste déroulante et le placement du cadre dans la routine PlacerWidgets. Donc dans ConstruireWidgets ajoutez les lignes suivantes (montrées au milieu à droite).

Vous avez déjà vu tout cela avant. Enregistrez et testez. Vous aurez probablement à élargir la fenêtre de premier niveau pour voir le séparateur, tout cela va être bien plus évident dans la prochaine démo. Enregistrez en tant que widgetdemo2d.py, nous allons ajouter la zone de sélection numérique.

**Now save as widgetdemo2c.py and we'll start with the separator bar. This is SO super easy. While the updated tkinter provides a separator bar  widget, I've never been able to get it to work. Here's an easy work around. We use a frame with a height of 2. The only changes to our program will be the definition of the frame in BuildWidgets after the combo box bind statement and placing the frame in the Place Widgets routine. So, in  BuildWidgets put in the following lines (shown middle right)...

Once again, you've seen all this before. Save and test it. You'll probably have to expand the topmost window to see the separator, but it will become much more evident in the next demo. Save as widgetdemo2d.py and we'll add the spin control.**

Sous DefinirVariabless, ajoutez la ligne suivante :

  self.valeurSelection = StringVar()

Maintenant, vous savez que c'est pour pouvoir obtenir sa valeur à tout moment. Ensuite, nous allons ajouter du code à la routine ConstruireWidgets, juste avant la ligne « return fenetre » (en bas à droite).

**Under DefineVars, add the following line...

  self.spinval = StringVar()

By now, you know that this is so we can get the value at any time we want. Next, we'll add some code to the BuildWidgets routine...just before the “return frame” line (bottom right).**

Ici, nous définissons une étiquette et la zone de sélection numérique. La définition de la zone de sélection est :

notreWidget =
Spinbox(parent,valeur basse,
valeur haute, largeur,
textvariable, wrap)

La valeur mini doit s'appeler « from_ » car le mot « from » est un mot-clé réservé du langage python et l'utiliser risquerait de casser votre programme. Les valeurs « from_ » et « to » doivent être définies comme valeurs flottantes. Ici, nous voulons que valeur mini soit 1 et la valeur maxi soit 10. Enfin l'option « wrap »  signifie que si la valeur est (dans notre cas) 10 et que l'utilisateur clique sur la flèche du haut, nous voulons qu'il retourne à la valeur mini et ainsi de suite. Il en est de même pour la valeur mini. Si l'utilisateur clique sur la flèche du bas alors que la valeur est 1, il retourne à 10 et et ainsi de suite. Si vous mettez « wrap = False », le mécanisme s'arrête simplement et il n'y a pas de bouclage.

**Here we define a label and the spin control. The spin control definition is as follows: 
ourwidget =
Spinbox(parent,low value,
high value, width,
textvariable, wrap)**

**The low value must be called as “from_” since the word “from” is a keyword and using that would simply confuse everyting. The values “from_” and  "to” must be defined as float values. In this case we want it to have a low value of 1 and a high value of 10. Finally the wrap option says that if the value is (in our case) 10 and the user clicks on the up arrow, we want it to wrap around to the low value and keep going. The same works for the low value. If the user clicks the down arrow of the control and the value is 1, it wraps to 10 and keeps going. If you set “wrap=False”, the control simply stops at whichever direction the user is going.**

Maintenant, nous allons placer les widgets dans PlacerWidgets (ci-dessous).

**Now we'll place the widgets in PlaceWidgets (below).**

Voilà, c'est tout. Enregistrez et jouez. Vous voyez nettement le séparateur maintenant.
Enregistrez en tant que widgetdemo2e.py et nous allons créer les barres de progression.

Encore une fois, nous avons besoin de définir certaines variables, dans la routine DefinirVariables ajoutez le code suivant :
self.valeurSelection2 = StringVar ()
self.boutonEtat = False
self.valeurBarreProg2 = StringVar ()

**Again, that's it. Save and play. You'll really notice the separator now.
   Save as widgetdemo2e.py and we'll do the progress bars.

Again, we need to define some variables, so in the DefineVars routine add the following code... 
self.spinval2 = StringVar()
self.btnStatus = False
self.pbar2val = StringVar()**

Il est assez évident de deviner ce que sont les deux variables StringVar. Nous parlerons de self.boutonEtat dans un instant. Pour le moment, continuons et définissons les widgets pour cette portion dans ConstruireWidgets (à droite).

**It should be pretty obvious what the two StringVar variables are. We'll discuss the “self.btnStatus” in a moment. For now, let's go and define the widgets for this portion in BuildWidgets (right).**

De nouveau ceci est placé avant le « return fenetre ». Ce que nous faisons c'est la mise en place d'un cadre qui contiendra les widgets. Puis, nous avons mis en place deux étiquettes comme guides. Et nous définissons la première barre de progression. Les seules choses qui pourraient être étranges sont la longueur, le mode et le maximum. La longueur est la taille en pixels de notre barre. Le maximum est la valeur la plus élevée possible. Dans ce cas, c'est 100 comme nous utilisons des pourcentages. Dans le cas présent mode vaut « indéterminé ». Rappelez-vous, nous utilisons ce mode lorsque nous ne savons pas précisément où nous en sommes dans la progression d'une tâche, mais que nous voulons que l'utilisateur sache qu'il se passe toujours quelque chose.

**Again this goes before the “return frame” line. What we are doing is setting up a frame for us to put the widgets into. Then we set up two labels as guides. Next we define the first progress bar. Here the only things that might be strange are length, mode and maximum. Length is the size in pixels of our bar. Maximum is the highest value that will be seen. In this case it's 100 since we are looking at percentage. Mode in this case is  indeterminate'. Remember, we use this mode when we don't know how far we've gotten in a task so we just want to let the user know that something is happening.**

Maintenant, nous ajoutons un bouton (vous l'avez déjà fait), une autre étiquette, une autre barre de progression et une autre zone de sélection numérique. Le mode de cette seconde barre de progression est « déterminé ». Nous  utilisons la zone de sélection numérique pour régler le « pourcentage » d'achèvement. Puis, ajoutons les lignes suivantes (page suivante, en haut à gauche) dans la routine PlacerWidgets.

**Next we add a button (you've done this before), another label another progress bar and another spin control. The mode for the second progress bar is “determinate”. We will use the spin control to set the “percentage” of completion. Next add the following lines (next page, top left) into the PlaceWidgets routine.**

Finalement, nous ajoutons deux routines pour contrôler nos barres de progression (en bas à droite).

**Lastly, we add two routines to control our progress bars (bottom right).**

La routine TestBarreProg contrôle la barre de progression indéterminée. Simplement, nous démarrons et arrêtons une horloge interne qui est intégrée dans la barre de progression. La ligne « self.barreProg.start(10) » paramètre le minuteur à 10 millisecondes. Cela rend le mouvement de la barre assez rapide. N'hésitez pas à jouer avec cette valeur à la hausse ou à la baisse. La routine SelectionAction définit simplement l'avancement de la barre de progression en fonction de la valeur sélectionnée. Nous l'affichons dans un terminal.

C'est tout pour le moment. Sauvegardez et jouez.

Maintenant sauvegardez sous le nom widgetdemo2f.py et nous allons nous occuper des onglets. Ajoutez le code suivant dans ConstruireWidgets (ci-dessous) avant la ligne « return fenetre » : 

**The TestPBar routine controls the indeterminate progress bar. Basically, we are starting and stopping an internal timer that is built into the progress bar. The line “self.pbar.start(10)” sets the timer to 10 milliseconds. This makes the bar move fairly quickly. Feel free to play with this value up and down on your own. The Spin2Do routine simply sets the progress bar to whatever value the spin control has. We print it as well to the terminal.

That's all the changes for this. Save and play.

Now save as widgetdemo2f.py and we'll deal with the tabbed notebook widgets. In BuildWidgets put the following code (below) before the “return frame” line...**

Regardons ce que nous avons fait. Premièrement, nous définissons un cadre pour notre widget « onglets ». Puis nous définissons le widget. Nous avons déjà rencontré toutes les options auparavant. Ensuite, nous définissons deux cadres nommés self.p1 et self.p2 qui seront nos pages. Les deux lignes suivantes (self.onglets.add) attachent les cadres au widget et ils ont un onglet qui leur est rattaché. Nous avons également réglé les titres des onglets. Enfin, nous mettons une étiquette sur la page numéro un. Nous allons en mettre une sur la page deux lorsque nous plaçerons les contrôles juste pour le plaisir.

**Let's look at what we did. First, we define a frame for our notebook widget. Now we define  the widget. All the options are ones we've seen before. Next we define two frames named self.p1 and self.p2. These act as our pages. The next two lines (self.notebook.add) attach the frames to the  notebook widget and they get a tab attached to them. We also set the text for the tabs. Finally, we put a label on page number one. We'll put one on page number two when we place the controls just for fun.**

Dans la routine PlacerWidgets, insérez le code suivant (ci-dessous).

**In the PlaceWidgets routine put the following code (below).**

La seule chose qui pourrait paraître étrange, c'est l'étiquette sur la page deux. Nous combinons la définition et la mise en place dans la grille avec la même commande. Nous l'avons déjà fait dans notre première application de démo.

**The only thing that might possibly be strange is the label on page two. We combine the definition and placement in the grid with the same command. We did that when we did our first widget demo app.**

C'est fini. Sauvegardez et amusez-vous.

**That's it. Save and play.**

Comme toujours le code de l'application complète est sur pastebin : http://pastebin.com/7BJr54au

**As always the full code for the full application is up on pastebin at** http://pastebin.com/qSPkSNU1.**

Au plaisir. La prochaine fois nous allons plutôt aborder des trucs sur les bases de données.

**Enjoy. Next time we'll deal with some more database stuff.**


====== Code python : ======


===== Page 7 =====

  import sys
  from Tkinter import *
  import ttk
  # montre comment creer un menu
  class WidgetDemo2:
  
    def __init__(self,master = None):
      self.DefineVars()
      f = self.BuildWidgets(master)
      self.PlaceWidgets(f)

    def DefineVars(self):
      pass

Et voici la fin de notre programme. Vous avez déjà vu ça précédemment, rien de nouveau ici.

  if __name__ == '__main__':
    def Center(window):
        # recupere largeur et hauteur de l'ecran
        sw = window.winfo_screenwidth()
        sh = window.winfo_screenheight()        
        # recupere largeur et hauteur de la fenetre
        rw = window.winfo_reqwidth()
        rh = window.winfo_reqheight()
        xc = (sw-rw)/2
        yc = (sh-rh)/2
        print "{0}x{1}".format(rw,rh)
        window.geometry("%dx%d+%d+%d"%(rw,rh,xc,yc))
        window.deiconify()
    
    root = Tk()
    root.title('Demo de plus de widgets')
    demo = DemoWidget2(root)
    root.after(13,Center,root)
    root.mainloop()


===== Page 8 =====

    def ConstruireWidgets(self,principale):
        fenetre = Frame(principale)
        #==============================================================
        #                        LES MENUS
        #==============================================================
        # Cretion de la barre de menus
        self.barreMenus = Menu(principale)

        # Creation du menu Fichier, et ajout a la barre de menus
        menuFichier = Menu(self.barreMenus, tearoff = 0)
        menuFichier.add_command(label = "Nouveau", command = self.FichierNouveau)
        menuFichier.add_command(label = "Ouvrir", command = self.FichierOuvrir)
        menuFichier.add_command(label = "Sauver", command = self.FichierSauver)
        menuFichier.add_separator()
        menuFichier.add_command(label = "Quitter", command = root.quit)
        self.barreMenus.add_cascade(label = "Fichier", menu = menuFichier)

        # Creation du menu Edition
        menuEdition = Menu(self.barreMenus, tearoff = 0)
        menuEdition.add_command(label = "Couper", command = self.EditionCouper)
        menuEdition.add_command(label = "Copier", command = self.EditionCopier)
        menuEdition.add_command(label = "Coller", command = self.EditionColler)
        self.barreMenus.add_cascade(label = "Edition", menu = menuEdition)
        # Creation du menu Aide
        menuAide = Menu(self.barreMenus, tearoff=0)
        menuAide.add_command(label = "A propos", command = self.AideApropos)
        self.barreMenus.add_cascade(label = "Aide", menu = menuAide)

        # affichage du menu
        principale.config(menu = self.barreMenus) 
        #==============================================================
        #                  FIN DES MENUS
        #==============================================================

===== Page 9 =====

        self.f1 = Frame(fenetre,
                        relief = SUNKEN,
                        borderwidth = 2, 
                        width = 500
                        height = 100
                        )

Ensuite (comme nous l'avons déjà fait) nous nous occupons de placer les autres widgets.

    def PlacerWidgets(self,principale):
        fenetre = principale
        fenetre.grid(column = 0, row = 0)
       
        self.f1.grid(column = 0,
                     row = 0,
                     sticky = 'nsew'
                     )

    def DefinirVariables(self):
        self.selectionListeDeroulante1 = StringVar()
        self.valeursC1 = ['Neant','Option 1','Option 2','Option 3']

Insérez le code suivant dans ConstruireWidgets après la définition self.f1 et avant la ligne "return fenetre".

        self.labelListeDeroulante = Label(self.f1, text = "Liste deroulante : ")
        self.listeDeroulante1 = ttk.Combobox(self.f1, 
                                  height = "19",
                                  width = 20, 
                                  textvariable = self.selectionListeDeroulante1
                                 )
        self.listeDeroulante1['values'] = self.valeursC1 
        # associe l'evenement virtuel a une fonction de rappel
        self.listeDeroulante1.bind("<<ComboboxSelected>>",self.testListeDeroulante)

    def FichierNouveau(self):
        print "Menu - Fichier Nouveau"
    def FichierOuvrir(self):
        print "Menu - Fichier Ouvrir"
    def FichierSauver(self):
        print "Menu -Fichier Sauver"
    def EditionCouper(self):
        print "Menu - Edition Couper"
    def EditionCopier(self):
        print "Menu - Edition Copier"
    def EditionColler(self):
        print "Menu - Edition Coller"
    def AideApropos(self):
        print "Menu - Aide Apropos"

===== Page 10 =====

        self.labelSelection.grid(column = 0, row = 4)
        self.selection1.grid(column = 1, 
                        row = 4,
                        pady = 2
                        )

Et enfin on écrit la fonction de retour qui affiche simplement dans le terminal ce que l'utilisateur a choisi.

    def testListeDeroulante(self,p1):
        print self.selectionListeDeroulante1.get()

        self.separ = Frame(self.f1,
                          width = 140,
                          height = 2,
                          relief = RIDGE,
                          borderwidth = 2
                          )

Puis ajoutez cela dans PlacerWidgets...

        self.separ.grid(column = 0,
                       row = 3,
                       columnspan = 8,
                       sticky = 'we',
                       padx = 3,
                       pady = 3
                       )

        self.labelSelection = Label(self.f1, text = "Selection numerique :")
        self.selection1 = Spinbox(self.f1, 
                             from_ = 1.0, 
                             to = 10.0, 
                             width = 3,
                             textvariable = self.valeurSelection,
                             wrap=True
                             )

===== Page 11 =====

        #=======================================
        # Barre de progression
        #=======================================
        self.fBarreProg = Frame(self.f1,
                        relief = SUNKEN,
                        borderwidth = 2
                        )

        self.lbl0 = Label(self.fBarreProg,
                        text = "Barres de progression"
                        )
        self.lbl1 = Label(self.fBarreProg,
                        text = "Indeterminee",
                        anchor = 'e'
                        )
        self.barreProg = ttk.Progressbar(self.fBarreProg, 
                        orient = HORIZONTAL, 
                        length = 100, 
                        mode = 'indeterminate',
                        maximum = 100
                        )
        self.btnptest = Button(self.fBarreProg,
                        text = "Demarrer",
                        command = self.TestBarreProg
                        )
        self.lbl2 = Label(self.fBarreProg,
                        text = "Determinee"
                        )
        self.barreProg2 = ttk.Progressbar(self.fBarreProg,
                        orient = HORIZONTAL,
                        length = 100,
                        mode = 'determinate',
                        variable = self.valeurBarreProg2
                        )
        self.selection2 = Spinbox(self.fBarreProg, 
                        from_ = 1.0, 
                        to = 100.0, 
                        textvariable = self.valeurSelection2,
                        wrap = True,
                        width = 5,
                        command = self.SelectionAction
                        )

        self.labelSelection.grid(column = 0, row = 4)
        self.selection1.grid(column = 1, 
                        row = 4,
                        pady = 2
                        )

===== Page 12 =====

        #=======================================
        #              ONGLETS
        #=======================================
        self.fenetreOnglets = Frame(self.f1,
                            relief = SUNKEN,
                            borderwidth = 2,
                            width = 500,
                            height = 300
                            )
        self.onglets = ttk.Notebook(self.fenetreOnglets,
                                     width = 490,
                                     height = 290
                                     )
        self.p1 = Frame(self.onglets)
        self.p2 = Frame(self.onglets)
        self.onglets.add(self.p1,text = 'Page 1')
        self.onglets.add(self.p2,text = 'Page 2')
        self.labelPage1 = Label(self.p1,
                          text = "Voici un texte sur la page 1",
                          padx = 3,
                          pady = 3
                          )

        # Barre de progression
        self.fBarreProg.grid(column = 0,
                        row = 5,
                        columnspan = 8,
                        sticky = 'nsew',
                        padx = 3,
                        pady = 3
                        )
        self.lbl0.grid(column = 0, row = 0)
        self.lbl1.grid(column = 0, 
                       row = 1, 
                       pady = 3
                       )
        self.barreProg.grid(column = 1, row = 1)
        self.btnptest.grid(column = 3, row = 1)
        self.lbl2.grid(column = 0, 
                       row = 2, 
                       pady = 3
                       )
        self.barreProg2.grid(column = 1, row = 2)
        self.selection2.grid(column = 3, row = 2)

    def TestBarreProg(self):
        if self.boutonEtat == False:
            self.btnptest.config(text="Arreter")
            self.boutonEtat = True
            self.barreProg.start(10)
        else:
            self.btnptest.config(text="Demarrer")
            self.boutonEtat = False
            self.barreProg.stop()
    
    def SelectionAction(self):
        v = self.valeurSelection2.get()
        print v
        self.valeurBarreProg2.set(v)

===== Page 13 =====

        self.fenetreOnglets.grid(column = 0,
                         row = 6,
                         columnspan = 8,
                         rowspan = 7,
                         sticky = 'nsew'
                         )
        self.onglets.grid(column = 0,
                           row = 0,
                           columnspan = 11,
                           sticky = 'nsew'
                           )
        self.labelPage1.grid(column = 0,row = 0)
        self.labelPage2 = Label(self.p2,
                          text = 'Voici un texte sur la page 2',
                          padx = 3,
                          pady = 3
                          ).grid(
                                 column = 0,
                                 row = 1
                                 )