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
PyGTK : Les fenêtres : Donner un titre à la fenêtre
Et bien voilà, notre première fenêtre est née.
Maintenant nous pouvons lui donner un nom à cette petite veinarde.
Pour ce faire, il existe la méthode :
set_title(nom_de_ma_fenetre)
Mais voyons en pratique ce que cela donne :
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 :
08 avril 2008
PyGTK : Les fenêtres : Création d'une fenêtre basique
La classe utilisée pour créer des fenêtres est
gtk.Window(type_fenetre)
L'attribut type_fenetre peut prendre deux valeurs :
gtk.WINDOW_TOPLEVEL
Crée une fenêtre complète composée de la partie active, de la barre de titre, des bordures
gtk.WINDOW_POPUP
A l'inverse, ce paramètre signifie que seule la partie active sera apparente
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()
Résultat :
Quelques explications :
fenetre = gtk.Window(gtk.WINDOW_TOPLEVEL)
Cette ligne permet d'instancier la classe gtk.Window()
fenetre.set_default_size(400, 200)
Ici, la méthode set_default_size(width, height) permet de donner une largeur et une hauteur (en pixels) à la fenêtre
fenetre.show_all()
La méthode show_all() permet d'afficher le widget (ici la fenêtre) et tous les widgets enfants
Pour ce faire, il faut que le parent soit un conteneur.
01 avril 2008
Python : Les fonctions : Nombre de paramètres variable
Voici comment écrire une fonction dont le nombre de paramètres peut être variable.
Deux formes possibles d'écritures :
1/ *ident1 : l'appel à la fonction fournit un nombre variable de paramètres (param. par position)
2/ **ident2 : l'appel à la fonction fournit un nombre variable de paramètres (param. par nom)
Mais voyons plutôt des exemples, ce qui aidera à la compréhension
Méthode 1/
Code :
#!/usr/bin/env python
def total(*nb):
return sum(nb)
print total(15, 55, 102, 300)
Résultat :
./somme1.py
472
Méthode 2/
Code :
#!/usr/bin/env python
def operation(**cle):
total = cle['valeur']
if 'add' in cle:
total += cle['add']
if 'mult' in cle:
total *= cle['mult']
return total
print operation(valeur = 10, add = 50, mult = 5)
Résultat :
./somme2.py
300
Sachez qu'il est également possible de combiner les deux formes.
Dans ce cas, la forme * sera placée avant **
Code :
#!/usr/bin/env python
def operation(*nb, **cle):
total = cle['valeur']
if 'add' in cle:
total += cle['add']
if 'mult' in cle:
total *= cle['mult']
return sum(nb), total
print operation(10, 20, 30, valeur = 10, add = 50, mult = 5)
Résultat :
./somme2.py
(60, 300)
Python : Les fonctions : Objet liste avec remise à 0
Toujours dans l'optique des fonctions de liste, il est possible, à chaque passage d'une valeur, de remettre la liste à 0.
Code :
#!/usr/bin/env python
def val(a, chaine=None):
if chaine is None:
chaine = []
chaine.append(a)
return chaine
print val(10)
print val(20)
print val(50)
print val(100)
Résultat :
./valeur2.py
[10]
[20]
[50]
[100]
Cette fois, on peut voir que la "liste" est affectée d'une valeur unique.
Python : Les fonctions : Objet liste "cumulative"
Je vous propose maintenant, une fonction de liste.
Les paramètres de cette fonction seront les suivants :
a : paramètre effectif dont on affectera manuellement les valeurs
chaine : paramètre facultatif de la forme chaine = [ ]
append() : méthode qui servira à affecter la valeur de a à la fin de chaine
Code :
#!/usr/bin/env python
def val(a, chaine=[]):
chaine.append(a)
return chaine
print val(10)
print val(20)
print val(50)
print val(100)
Résultat :
./valeur.py
[10]
[10, 20]
[10, 20, 50]
[10, 20, 50, 100]
On s'aperçoit ici qu'à chaque fois que l'on passe une valeur à l'aide de la fonction val(), elle se trouve ajoutée à la fin de chaine.
31 mars 2008
Python : Les fonctions : Appels de fonctions dans un module
Nous avons vu comment créer des fonctions. Il est possible de les créer dans un fichier qui regrouperait plusieurs fonctions auxquelles on pourrait faire appel à partir d'un fichier module.
J'ai, à cet effet, créé un fichier maths.py (module) et un fichier opeSimples.py (fonctions).
Voyons comment faire interagir ces deux fichiers.
Code
Fichier : opeSimples.py
#!/usr/bin/env python
def addi(x, y):
res = x+y
return res
def situ(res):
if res == 0:
msg = "La valeur est nulle"
elif res > 0 and res < 10:
msg = "Vous etes dans les unites"
elif res >= 10 and res < 20:
msg = "Vous etes dans les dizaines"
else:
msg = "Valeur indefinie"
return msg
Fichier : maths.py
#!/usr/bin/env python
from opeSimples import *
print situ(addi(5, 100))
print situ(addi(5, 10))
On peut voir dans le fichier maths.py que je fais un import du contenu du fichier opeSimples.py.
L'étoile '*' indique que l'on importe le contenu complet de opeSimples.py
Dans mon exemple, les deux fonctions ne peuvent fonctionner l'une sans l'autre.
Mais, imaginons qu'elles soient indépendantes, et que dans mon module, je n'ai besoin que de la fonction addi().
Dans ce cas, j'aurais pu faire un import de la manière suivante :
from opeSimples import addi
De cette façon, la fonction addi() uniquement aurait été importée.
