Le bouton du volume
Le bouton du volume ressemble beaucoup aux curseurs que nous venons de voir. En fait, il hérite de ceux-ci. Donc, les méthode et le signal que nous verrons sur le bouton du volume fonctionne aussi avec les curseurs.
Pour créer un tel bouton, il faut faire comme suit :
Code : Python1 | boutonVolume = gtk.VolumeButton()
|
Mais, si on l'affiche, nous n'avons pas le volume du système. Pour le connaître, il faut importer un module supplémentaire (à mettre au début du fichier) :
Code : Python
Comme le volume du système est de 0 à 100, il faut changer l'ajustement du bouton :
Code : Python1
2 | ajustement = gtk.Adjustment(0, 0, 100, 1, 10) #Création d'un ajustement de 0 à 100
boutonVolume.set_adjustment(ajustement)
|
On crée un ajustement et on change l'ajustement du bouton.
Ensuite, il faut changer la valeur du bouton :
Code : Python1
2 | mixer = ossaudiodev.openmixer() #Création d'un mixer
boutonVolume.set_value(mixer.get(ossaudiodev.SOUND_MIXER_VOLUME)[0])
|
À la première ligne, nous créons un mixer pour pouvoir obtenir le volume.
À la seconde, on change la valeur du bouton avec la méthode
set_value() et
mixer.get(ossaudiodev.SOUND_MIXER_VOLUME)[0] nous donne le volume.
Maintenant, on veut que lorsque l'on change le volume sur le bouton, que ça change le volume du système :
Code : Python1 | boutonVolume.connect('value-changed', changerVolumeSysteme)
|
On voit un nouveau signal ('value-changed') qui est émit lorsque l'on bouge le curseur.
Voyons la fonction changerVolumeSysteme:
Code : Python1
2 | def changerVolumeSysteme(widget, volume):
mixer.set(ossaudiodev.SOUND_MIXER_VOLUME, (int(volume), int(volume)))
|
On change le volume du système avec
mixer.set().
Une horloge numérique
Ce n'est pas vraiment un widget, mais je voulais quand même vous montrer comment faire une horloge numérique. Si je vous demanderais de faire une horloge numérique (où le temps se met à jour à toutes les secondes), vous en seriez incapables. C'est pourquoi je vous montre comment faire. Vous apprendrez à utiliser une boucle qui ne bloquera pas le programme. Elle s'exécutera en parallèle à la boucle principale.
Premièrement, on importe les bibliothèques nécessaires :
Code : Python 1
2
3
4
5
6
7
8
9
10
11 | # -*- coding:Utf-8 -*-
import pygtk
pygtk.require("2.0")
import gtk
import gobject
from time import *
|
Le module gobject nous servira pour pouvoir exécuter une boucle en parallèle et le module time, pour connaître la date et l'heure.
Deuxièmement, on crée notre classe principale et la fenêtre :
Code : Python1
2
3
4
5
6
7 | class Horloge(gtk.Window):
def __init__(self):
super(Horloge, self).__init__()
self.set_title("Horloge en temps réel")
self.set_default_size(320, 180)
self.set_position(gtk.WIN_POS_CENTER)
|
Ensuite, on crée quelques variables :
Code : Python 1
2
3
4
5
6
7
8
9
10
11
12
13 | #Puisque la fonction localtime() donne des chiffres, il faut les convertir en mots grâce à ces tuples
self.jours = ('Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi', 'Dimanche')
self.mois = ('', 'Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin', 'Juillet', 'Août', 'Septembre', 'Octobre', 'Novembre', 'Décembre')
if localtime()[4] < 10: #Si les minutes sont inférieurs à 10, on ajoute un 0 pour que l'affichage soit comme ceci 13:01.05 au lieu de 13:1.5
minutes = "0" + str(localtime()[4])
else:
minutes = str(localtime()[4])
if localtime()[5] < 10:
secondes = "0" + str(localtime()[5])
else:
secondes = str(localtime()[5])
|
On crée des tuples qui conresponderont avec les valeurs que
localtime() donne pour pouvoir changer les chiffres des jours de la semaine et des mois en mots.
Enfin, si les minutes et les secondes sont inférieurs à 10, on ajoute un 0, de sorte que 13:05.04 soit affiché à la place de 13:5.4 qui est moins esthétique.
Puis, on crée les chaînes de caractères qui s'afficheront dans un gtk.Label() :
Code : Python1
2
3
4
5
6
7
8 | temps = 'Il est ' + str(localtime()[3]) + ':' + minutes + '.' + secondes + '.'
date = 'Nous sommes ' + self.jours[localtime()[6]] + ', le ' + str(localtime()[2]) + ' ' + self.mois[localtime()[1]] + ' ' + str(localtime()[0]) + '.'
self.etiquette = gtk.Label(temps + '\n' + date)
self.add(self.etiquette)
self.connect("destroy", gtk.main_quit)
self.show_all()
gobject.idle_add(self.metAJourTemps) #C'est grâce à ceci que l'on peut ajouter une boucle parallèle à la boucle principale
|
Après, on ajoute l'étiquette à la fenêtre, on connecte la fenêtre à la méthode
gtk.main_quit() et on affiche tous les widgets.
À la dernière ligne, on utilise la méthode
idle_add du module
gobject avec comme paramètre la méthode (ou fonction, selon les cas) qui sera appeller indéfiniment. Si cette méthode retourne True, la boucle continue, si elle renvoie False, elle s'arrête. Elle s'arrête aussi lors de l'appel de
gtk.main_quit().
Et finalement, la dernière méthode :
Code : Python 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 | def metAJourTemps(self):
if localtime()[4] < 10:
minutes = "0" + str(localtime()[4])
else:
minutes = str(localtime()[4])
if localtime()[5] < 10:
secondes = "0" + str(localtime()[5])
else:
secondes = str(localtime()[5])
temps = 'Il est ' + str(localtime()[3]) + ':' + minutes + '.' + secondes + '.'
date = 'Nous sommes ' + self.jours[localtime()[6]] + ', le ' + str(localtime()[2]) + ' ' + self.mois[localtime()[1]] + ' ' + str(localtime()[0]) + '.'
self.etiquette.set_text(temps + '\n' + date)
sleep(1) #On attend un seconde avant de refaire la boucle de nouveau
return True #Si le retour est True, la boucle continue
|
La première partie de ce code est du déjà-vu. Ensuite, on fait attendre le programme 1 seconde (avec
sleep(1)) pour que la mise à jour du texte ne se fasse qu'à chaque seconde (cela consomme moins de ressource ; chez moi, il consomme 20% à 40% du CPU sans cette appel et 0% avec).
On retourne True et la boucle continue. Elle s'arrête lors de l'appel de
gtk.main_quit() ou lorsqu'elle revoie False.
Une icône dans la barre des tâches
Certains programmes ont une icône qui est affichée dans la barre des tâches (sous Windows et KDE, l'icône se situera en bas à droite et sous GNOME, en haut à droite).
Voici un exemple :
L'icône de mon programme est l'icône
d'Opera de Gtk+
Voyons comment faire ceci :
Code : Python 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 | # -*- coding:Utf-8 -*-
import pygtk
pygtk.require("2.0")
import gtk
def afficheCacheFenetre(widget, fenetre):
[...]
def afficheMenu(widget, bouton, temps):
[...]
fenetre = gtk.Window(gtk.WINDOW_TOPLEVEL)
fenetre.set_title("Les boîtes de dialogue")
fenetre.set_default_size(640, 480)
fenetre.set_position(gtk.WIN_POS_CENTER)
fenetre.connect("destroy", gtk.main_quit)
|
Premièrement, on importe les modules et on crée deux fonctions (qu'on verra plus tard). Puis, on crée une fenêtre.
Après, on crée notre icône qui ira dans la barre des tâches :
Code : Python1
2
3
4
5 | icone = gtk.StatusIcon() #Création d'une icône qui va dans la barre des tâches
icone.set_from_file("gtk.png") #Charger une image pour l'icône à partir d'un fichier
icone.set_tooltip("Gtk+") #Afficher du texte lorsque l'on pointe la souris longtemps sur l'icône
icone.connect("activate", afficheCacheFenetre, fenetre) #Lorsqu'on clique avec le bouton gauche
icone.connect("popup-menu", afficheMenu) #Lorsqu'on clique avec le bouton droit
|
À la première ligne, on crée cette icône.
À la deuxième, on charge dans cette icône une image avec la méthode
set_from_file(filename). Il existe également la méthode
set_from_stock(stock_id) qui la charge à partir d'un Stock Item.
À la troisième, on donne à cette icône un infobulle (donc du texte sera affiché au survol de la souris).
À la quatrième, on connecte l'icône à la fonction afficheCacheFenetre lorsque l'on active l'icône (donc lorsque l'on clique dessus). Dans cette méthode, on affichera ou cachera la fenêtre selon le cas.
À la cinquième ligne, on connecte l'icône à la fonction afficheMenu lorsque l'on fait un clique-droit sur cette icône. Cette fonction affichera un (popup) menu.
Ensuite, on affiche tout et on démarre la boucle principale :
Code : Python1
2
3 | fenetre.show_all()
gtk.main()
|
Voyons maintenant les deux fonctions que nous avons passés au début. Voici la première :
Code : Python1
2
3
4
5
6 | def afficheCacheFenetre(widget, fenetre):
if fenetre.get_property("visible"): #Si la fenêtre est affichée
fenetre.hide() #On la cache
else:
fenetre.show() #On l'affiche
fenetre.deiconify() #Remet la fenêtre au premier plan
|
Au début, on vérifie si la fenêtre est affichée ; si c'est le cas, on la cache, sinon on l'affiche et on la remet au premier plan.
Donc, lorsque l'on clique(-gauche) sur l'icône dans la barre des tâches, grâce à cette fonction, on cache ou affiche la fenêtre selon le cas.
Voici la seconde fonction, qui affiche un popup menu :
Code : Python 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 | def afficheMenu(widget, bouton, temps):
menu = gtk.Menu()
objetMenuOuvrir = gtk.ImageMenuItem(gtk.STOCK_OPEN)
objetMenuEnregistrer = gtk.ImageMenuItem(gtk.STOCK_SAVE)
objetMenuQuitter = gtk.ImageMenuItem(gtk.STOCK_QUIT)
objetMenuQuitter.connect("activate", gtk.main_quit)
menu.append(objetMenuOuvrir)
menu.append(objetMenuEnregistrer)
menu.append(objetMenuQuitter)
menu.show_all() #Il faut afficher le menu, car c'est un menu popup
menu.popup(None, None, None, bouton, temps) #Popup le menu
|
Je viens de me rappeler que je ne vous ai pas montrer comment créer un menu avec du code python. Je n'ai guère le choix maintenant. Souvenez-vous, ce popup menu s'affiche lorsque l'on clique-droit sur l'icône.
À la deuxième ligne, on crée un menu déroulant.
À la quatrième ligne, on crée un élément pour le menu déroulant.
Pareil pour les lignes 5 et 6.
À la ligne 7, on connecte l'élément quitter à la méthode gtk.main_quit() (pour fermer le programme).
Aux lignes 9, 10 et 11, on ajoute ces éléments au menu déroulant.
À la ligne 13, on affiche tous les éléments du menu.
À la ligne 15, on popup le menu (on l'affiche). Les deux premiers paramètres sont inutiles pour un popup menu comme ceci (ce sont ces parents). Le troisième est une fonction qui positionnera le menu. Comme on veut que le menu apparaisse près de l'icône, on ne met rien. Les deux paramètres suivants sont les mêmes que l'on a reçu en appelant la fonction.
Désactiver un widget
Pour désactiver un widget, il suffit d'utiliser la méthode
set_sensitive(sensitive). Si sensitive vaut False, le widget sera désactivé.
À quoi ressemble un widget désactivé ?
Un widget désactivé est un widget qui n'est pas/plus utilisable par l'utilisateur. Par conséquent, il sera donc gris :
Les widgets suite (Partie 1)
)
) et la mettre où l'on veut. Ensuite, sous l'onglet Général, il faut choisir une des trois options suivantes, dessous Modifier l'image :
?
- appelé Boîte combinée dans le concepteur).
.
Trouvez une formation
Suggestions
Flux RSS News
Twitter
Facebook
Google+