23 avril 2008
PyGTK : Windows : Give a title in the window
Our first window was born.
Now, we can give it a name.
In order to do that, a method exists :
set_title(name_of_my_window)
But let us see in practice what it gives :
Code :
#!/usr/bin/env python
# -*- Encoding: Latin-1 -*-
import pygtk
pygtk.require('2.0')
import gtk
def fenetre():
fenetre = gtk.Window(gtk.WINDOW_TOPLEVEL)
fenetre.set_default_size(400, 200)
fenetre.set_title("Ma premiere fenetre")
fenetre.show_all()
gtk.main()
if __name__ == '__main__':
fenetre()
Résultat :
PyGTK : Windows : Creation of a basic window
The class used to create windows is :
gtk.Window(windows_type)
Attirbute windows_type can take two values :
gtk.WINDOW_TOPLEVEL
Create a complete window composed of the active party, the bar of title, of the borders
gtk.WINDOW_POPUP
In the opposite, this parameter means that alone active part will be visible
Code :
#!/usr/bin/env python
# -*- Encoding: Latin-1 -*-
import pygtk
pygtk.require('2.0')
import gtk
def fenetre():
fenetre = gtk.Window(gtk.WINDOW_TOPLEVEL)
fenetre.set_default_size(400, 200)
fenetre.show_all()
gtk.main()
if __name__ == '__main__':
fenetre()
Result :
Quelques explications :
fenetre = gtk.Window(gtk.WINDOW_TOPLEVEL)
This line allows to call the class gtk.Window()
fenetre.set_default_size(400, 200)
Here, method set_default_size (width, height) allows to give a width and a height (in pixels) in the window
fenetre.show_all()
Method show_all() allows to show the widget (here, the window) and all widgets children
In order to do that, it is necessary that the parent is a container
20 avril 2008
PyGTK : Les boutons : Bouton poussoir
Voyons maintenant le cas d'un autre bouton : le bouton poussoir
La classe utilisée est la classe
gtk.ToggleButton(label=None, use_underline=True)
Cette classe accepte 2 paramètres qui ont déjà été traités dans les posts précédents.
Par défaut, label=None et use_underline=True
Ce type de bouton peut prendre 3 états :
a/ relâché set_active(False)
b/ enfoncé set_active(True)
c/ pour ce 3ème état, je vais illustrer en utilisant mon logiciel de traitement de texte préféré, dans lequel je crée 2 lignes de texte; 1 avec alignement gauche et une avec alignement centré.
Dans le cas de l'alignement gauche, si je sélectionne le texte, on voit que le bouton passe en mode enfoncé
Dans le cas de l'alignement centré, même chose, mais avec le bouton "alignement centré"
Maintenant, si je sélectionne les deux lignes, les deux boutons repassent en mode relâché
C'est donc ce qu'illustre ce troisième état, pour lequel on utilise la méthode set_inconsistent(True), qui permet de donner au bouton, l'aspect inactif.
Mais voyons plutôt un exemple
Code :
#!/usr/bin/env python
# -*- Encoding: Latin-1 -*-
import pygtk
pygtk.require('2.0')
import gtk
def fenetre():
fenetre = gtk.Window(gtk.WINDOW_TOPLEVEL)
fenetre.set_default_size(400, 200)
fenetre.set_title(u"Ma premiere fenêtre")
verti2 = gtk.VBox(homogeneous=False)
tb = gtk.ToggleButton(label = "b1")
tb.set_active(True)
tb2 = gtk.ToggleButton(label = "b2")
tb2.set_active(False)
tb3 = gtk.ToggleButton(label = "b3")
tb3.set_inconsistent(True)
verti2.pack_start(tb, False)
verti2.pack_start(tb2, False)
verti2.pack_start(tb3, False)
fenetre.add(verti2)
fenetre.show_all()
gtk.main()
if __name__ == '__main__':
fenetre()
Résultat :
1/ b1 enfoncé, b2 relâché et b3 inactif (dont l'état ne peut changer en cliquant sur le bouton)
2/ b1 relâché, b2 enfoncé et b3 inactif
3/ b1 et b2 enfoncé et b3 toujours inactif
14 avril 2008
PyGTK : Manuel de référence
Afin d'avoir un aperçu de toutes les classes et méthodes de PyGTK, voici un lien renvoyant au
13 avril 2008
PyGTK : Les boites
Afin de pouvoir placer plusieurs widgets dans un conteneur, il faut utiliser les méthodes :
gtk.HBox(homogeneous, spacing)
Crée une boite où les widgets seront placés horizontalement
gtk.VBox(homogeneous, spacing)
Crée une boite où les widgets seront placés verticalement
Les paramètres :
homogeneous Si cette valeur est à True, tous les widgets occuperont un espace équivalent
spacing Permet de définir l'espacement entre chacun des widgets
Par défaut, ces paramètres sont à homogeneous=False et spacing=0
Comment ajouter des widgets dans la boite ?
Nous avons besoin ici, des deux méthodes suivantes :
box.pack_start(child, expand, fill, padding)
ajoute les widgets de gauche à droite (HBox) ou de haut en bas (VBox)
box.pack_end(child, expand, fill, padding)
ajoute les widgets de droite à gauche ou de bas en haut
Les paramètres :
child Widget ajouté à la boite
expand Ce paramètre ne peut être actif que lorsque Homogeneous=False.
Un widget dont expand=False occupera seulement l'espace nécessaire
A l'inverse, des widgets dont expand=True occuperont des espaces équivalents
fill Indique si le widget occupera tout l'espace qui lui est réservé
padding Pour ajouter de l'espace autour du widget
Les paramètres par défaut sont expand=True, fill=True, padding=0
Code général :
#!/usr/bin/env python
# -*- Encoding: Latin-1 -*-
import pygtk
pygtk.require('2.0')
import gtk
def fenetre():
fenetre = gtk.Window(gtk.WINDOW_TOPLEVEL)
fenetre.set_default_size(400, 200)
fenetre.set_title("Ma premiere fenetre")
..........
"""Code à ajouter"""
..........
fenetre.show_all()
gtk.main()
if __name__ == '__main__':
fenetre()
Boite avec homogeneous=True :
..........
verti2 = gtk.HBox(homogeneous=True)
bouton1 = gtk.Button("Btn 1")
bouton2 = gtk.Button("Btn 2")
verti2.pack_start(bouton1)
verti2.pack_start(bouton2)
..........
Résultat :
gtk.HBox gtk.VBox
On observe bien ici que les widgets occupent un espace équivalent
Boite avec homogeneous=False et expand=True :
..........
verti2 = gtk.HBox(homogeneous=False)
bouton1 = gtk.Button("Btn 1")
bouton2 = gtk.Button("Btn 2")
verti2.pack_start(bouton1, True)
verti2.pack_start(bouton2, True)
..........
Résultat :
gtk.HBox gtk.VBox
On observe ici le même résultat qu'avec homogeneous=True
Boite avec homogeneous=False et expand alternant True et False :
..........
verti2 = gtk.VBox(homogeneous=False)
bouton1 = gtk.Button("Btn 1")
bouton2 = gtk.Button("Btn 2")
bouton3 = gtk.Button("Btn 3")
bouton4 = gtk.Button("Btn 4")
verti2.pack_start(bouton1, False)
verti2.pack_start(bouton2, True)
verti2.pack_start(bouton3, False)
verti2.pack_start(bouton4, True)
fenetre.add(verti2)
..........
Résultat :
gtk.HBox gtk.VBox
En mettant le paramètre fill=True sur le bouton 2, voici ce que cela donne
On peut observer que le bouton deux n'occupe pas tout l'espace qui lui a été réservé
En mettant maintenant, un padding=15 sur le bouton 4, voici ce que l'on obtient
Enfin, utilisons pack_end(...)
Code :
verti2 = gtk.VBox(homogeneous=False)
bouton1 = gtk.Button("Btn 1")
bouton2 = gtk.Button("Btn 2")
bouton3 = gtk.Button("Btn 3")
bouton4 = gtk.Button("Btn 4")
verti2.pack_end(bouton1, False)
verti2.pack_end(bouton2, True, False)
verti2.pack_end(bouton3, False)
verti2.pack_end(bouton4, True, True, 15)
fenetre.add(verti2)
Résultat :
On peut observer que les boutons sont bien placés de droite à gauche et de bas en haut
12 avril 2008
PyGTK : Buttons : My first button
Dear not French-speaking foreign friends
Do not hesitate to point out to me errors of translation
help me to correct my errors to bring some change in my English
if you wish that I translate other articles, having made it me know by leaving a comment
We are going to deal, of a widget essential new in the creation of graphic interfaces here : Buttons
A simple click on these buttons is going to allow to perform actions
The class which they call for builtin them is the class
gtk.Button(label=None, stock=None, use_underline=True)
As you determine it, there are three accepted, but not obligatory parameters
It is wholly possible to put one no parameter parentheses
Let us itemize these parameters
label There I think that it's not necessary to stretch over question as much as two of my last threads deal with labels.
stock The item corresponding to the picture allows to stock which they want to show - liste des items ici
use_underline
Allow the definition of parameters of abbreviated one composing of the key '
ALT + ' letter of the text that they put in front of one '_ ' of
(Underscore)
By default, label=None, stock=None et use_underline=True
Let us pass to the practical party now
General code - simple button :
#!/usr/bin/env python
# -*- Encoding: Latin-1 -*-
import pygtk
pygtk.require('2.0')
import gtk
def fenetre():
fenetre = gtk.Window(gtk.WINDOW_TOPLEVEL)
fenetre.set_default_size(400, 200)
fenetre.set_title("Ma premiere fenetre")
bouton1 = gtk.Button()
..........
""" code to add """
..........
fenetre.add(bouton1)
fenetre.show_all()
gtk.main()
if __name__ == '__main__':
fenetre()
Result :
Button with label :
..........
label = gtk.Label()
bouton1.set_label("Cliquer ici")
bouton1.add(label)
..........
Result :
Button with label / html :
..........
label = gtk.Label()
label.set_markup("<span font_desc=\"Courier New 10\" foreground=\"red\"><b>Cliquer ici</b></span>")
bouton1.add(label)
..........
Result :
button with combination of keys :
In the list of parameters, let us say that use_underline is speeded up by default (True)
Because of this or that they can directly pass to the creation of necessary code to speed up the abbreviated
..........
label = gtk.Label()
bouton1.set_use_underline(1)
bouton1.set_label("_Cliquer ici")
bouton1.add(label)
..........
In example, I decided to put an abbreviated on ' c ' of departure, therefore I put '_ ' just before
If I had opted for another letter, it would have been necessary that I put it directly in front of this letter
To speed up the underline of the letter in the screen, it is necessary to make call to function
set_use_underline(param)
param correspond au paramètre à passer à la fonction :
1 : soulignement activé
0 : soulignement désactivé
By applying this method, the chosen letter is underlined, what points out that to make ALT+C would be equivalent to click on the button with the aid of the mouse
Résultat :
Button with picture :
A precondition consists in going to choose items in the list of gtk stock items link of which I put in the detail of the parameters of the
class gtk.Button ().
It will be necessary to recover the name of item - in my example below, it is of gtk.STOCK_SAVE.
Code :
..........
bouton1 = gtk.Button(stock=gtk.STOCK_SAVE)
fenetre.add(bouton1)
...........
Result :
11 avril 2008
PyGTK : Les boutons : Mon premier bouton
Nous allons traiter ici, d'un nouveau widget essentiel dans la création d'interfaces graphiques : Les boutons
Un simple clic sur ces boutons va permettre d'effectuer des actions.
La classe à laquelle on fait appel pour l'implémenter est la classe
gtk.Button(label=None, stock=None, use_underline=True)
Comme vous le constatez, il y a trois paramètres acceptés - mais pas obligatoires.
Il est tout à fait possible de ne mettre aucun paramètre dans les parenthèses.
Détaillons ces paramètres
label Bon, là je pense qu'il n'est pas nécessaire de s'étendre sur la question dans la mesure où deux de mes derniers fils traitent des labels.
stock Permet de stocker l'item correspondant à l'image que l'on veut afficher - liste des items ici
use_underline Permet le paramétrage d'un raccourci composé de la touche ALT + lettre du texte que l'on a fait précéder d'un '_' (underscore)
Par défaut, label=None, stock=None et use_underline=True
Passons maintenant à la partie pratique
Code général - bouton simple :
#!/usr/bin/env python
# -*- Encoding: Latin-1 -*-
import pygtk
pygtk.require('2.0')
import gtk
def fenetre():
fenetre = gtk.Window(gtk.WINDOW_TOPLEVEL)
fenetre.set_default_size(400, 200)
fenetre.set_title("Ma premiere fenetre")
bouton1 = gtk.Button()
..........
""" code à ajouter """
..........
fenetre.add(bouton1)
fenetre.show_all()
gtk.main()
if __name__ == '__main__':
fenetre()
Résultat :
Bouton avec label :
..........
label = gtk.Label()
bouton1.set_label("Cliquer ici")
bouton1.add(label)
..........
Résultat :
Bouton avec label / html :
..........
label = gtk.Label()
label.set_markup("<span font_desc=\"Courier New 10\" foreground=\"red\"><b>Cliquer ici</b></span>")
bouton1.add(label)
..........
Résultat :
Bouton avec combinaison de touches :
Dans la liste des paramètres, rappelons que use_underline est activé par défaut (True). De ce fait, on peut directement passer à la création du code nécessaire pour activer le raccourci.
..........
label = gtk.Label()
bouton1.set_use_underline(1)
bouton1.set_label("_Cliquer ici")
bouton1.add(label)
..........
Dans l'exemple, j'ai décidé de mettre un raccourci sur le 'c' de départ, donc j'ai placé le '_' juste avant. Si j'avais opté pour une autre lettre, il aurait fallu que je le place directement devant la lettre en question.
Pour activer le soulignement de la lettre à l'écran, il faut faire appelle à la fonction
set_use_underline(param)
param correspond au paramètre à passer à la fonction :
1 : soulignement activé
0 : soulignement désactivé
En appliquant cette méthode, la lettre choisie est soulignée, ce qui indique que faire un ALT+C équivaudrait à cliquer sur le bouton à l'aide de la souris.
Résultat :
Bouton avec image :
Un préalable consiste à aller choisir les items dans la liste des gtk stock items dont j'ai mis le lien dans le détail des paramètres de la classe gtk.Button().
Il faudra récupérer le nom de l'item - dans mon exemple ci-dessous, il s'agit de gtk.STOCK_SAVE.
Code :
..........
bouton1 = gtk.Button(stock=gtk.STOCK_SAVE)
fenetre.add(bouton1)
...........
Résultat :
PyGTK : Les fenêtres : Label
Il est possible de créer des labels avec mise en forme du texte.
L'idée ici, est d'utiliser les balises HTML, ou plutôt certaines balises.
Ici, encore, nous faisons appel à Pango.
Nous insérons les balises dans le texte, et Pango gère le formatage du texte.
Quelques balises express de mise en forme directe du texte :
<b> Texte en gras
<i> Texte en italique
<u> Texte souligné
<sub> Texte en indice
<sup> Texte en exposant
<small> Diminue la taille du texte
<big> Augmente la taille du texte
La balise utilisée pour mettre le texte en forme le texte est la balise
<span>...</span>
Cette balise dispose d'attributs permettant un champ d'action assez conséquent
Les attributs :
font-family police à utiliser (défaut : sans-serif)
size taille du texte en points (défaut : 10)
style normal, oblique ou italic
font-desc permet de combiner les paramètres précédents en un seul
weight épaisseur des lettres : ultralight, light, normal, bold, ultrabold, heavy, ou une valeur numérique
foreground couleur du texte (valeur héxadécimale de la forme : #xxxxxx)
background couleur du fond (valeur héxadécimale de la forme : #xxxxxx)
underline Souligner le texte
lang pour indiquer la langue
rise pour déplacer le texte verticalement
Vous allez me dire ok, mais comment met-on tout cela en oeuvre
La méthode utilisée :
set_markup("<balises>....texte...</balises>")
Rien ne vaut un exemple
Code :
#!/usr/bin/env python
# -*- Encoding: Latin-1 -*-
import pygtk
pygtk.require('2.0')
import gtk
def fenetre():
fenetre = gtk.Window(gtk.WINDOW_TOPLEVEL)
fenetre.set_default_size(400, 200)
fenetre.set_title("Ma premiere fenetre")
label = gtk.Label(u"Voici le premier label de ma fenêtre \nje dirais même mieux, de ma première fenêtre \nde la première fenêtre de poseidon627")
label.set_markup("<span font_desc=\"Courier New 14\" foreground=\"red\"><b>Courier New 14 Gras</b></span>")
fenetre.add(label)
fenetre.show_all()
gtk.main()
if __name__ == '__main__':
fenetre()
Résultat :
Dans mon exemple, j'utilise la police "Courier New", de taille "14", de couleur "rouge", et je mets le tout en gras à l'aide de la balise <b>
10 avril 2008
PyGTK : Les caractères spéciaux
Pango est la librairie utilisée par GTK.
Celle-ci utilise l'encodage UTF8 qui autorise un codage sur 16 bits.
La possibilité offerte est donc de plus de 65000 caractères (2^16).
L'avantage, c'est que cela permet de coder un très grand nombre de caractères, et plus particulièrement, en ce qui nous concerne, les caractères accentués par exemple.
Afin de pouvoir utiliser cet encodage spécial, il faut y faire "appel" via une ligne que l'on rajoute en début de script :
# -*- Encoding: Latin-1 -*-
Lorsque l'on entre le texte comme dans le label, il suffit de placer un petit 'u' (unicode) devant le premier quote, comme ceci
.......
label.set_label(u"mon texte accentué")
.......
N'hésitez pas à revoir les fils précédents car j'ai utilisé cette méthode pour afficher les labels par exemple.
09 avril 2008
PyGTK : Les fenêtres : Label
Lors de l'instanciation de la classe, on passe le label en paramètre
LabeL = gtk.Label(string mon_label)
string mon_label = label qui sera affiché dans la fenêtre
Si en cours de programme, on a besoin de modifier le texte, utiliser la méthode
set_label(string mon_nouveau_label)
string mon_nouveau_label = nouveau label affiché
Pour ajouter le label à la fenêtre, la méthode utilisée est
fenetre.add(LabeL)
Code :
#!/usr/bin/env python
# -*- Encoding: Latin-1 -*-
import pygtk
pygtk.require('2.0')
import gtk
def fenetre():
fenetre = gtk.Window(gtk.WINDOW_TOPLEVEL)
fenetre.set_default_size(400, 200)
fenetre.set_title("Ma premiere fenetre")
label = gtk.Label(u"Voici le premier label de ma fenêtre \nje dirais même mieux, de ma première fenêtre \nde la première fenêtre de poseidon627")
#label.set_label(u"Voici le nouveau label")
fenetre.add(label)
fenetre.show_all()
gtk.main()
if __name__ == '__main__':
fenetre()
Résultat avec le premier label :
Résultat avec le nouveau label :
Il est également possible d'aligner le texte dans la fenêtre grâce à la méthode
set_justify(param_justify)
param_justify peut prendre plusieurs valeurs :
gtk.JUSTIFY_LEFT
gtk.JUSTIFY_CENTER
gtk.JUSTIFY_RIGHT
gtk.JUSTIFY_FILL
Désolé pour cet exemple, mais je n'ai pas réussi à le réaliser
