IdentifiantMot de passe
Loading...
Mot de passe oubli� ?Je m'inscris ! (gratuit)
logo

FAQ GTK+Consultez toutes les FAQ

Nombre d'auteurs : 10, nombre de questions : 101, derni�re mise � jour : 22 f�vrier 2018  Ajouter une question

 

Cette faq a �t� r�alis�e � partir des questions fr�quemment pos�es sur les forums de www.developpez.com et de l'exp�rience personnelle des auteurs.
Je tiens � souligner que cette faq ne garantit en aucun cas que les informations qu'elle propose sont correctes ; les auteurs font le maximum, mais l'erreur est humaine. Cette faq ne pr�tend pas non plus �tre compl�te. Si vous trouvez une erreur, ou que vous souhaitez devenir r�dacteur, lisez ceci.
Sur ce, nous vous souhaitons une bonne lecture, L'�quipe GTK+.

SommaireGTK+GtkWidget (43)
pr�c�dent sommaire suivant
 

Dans certaines circonstances, il peut �tre n�cessaire d'emp�cher un utilisateur d'utiliser un widget (cliquer sur un bouton, par exemple). Pour cela, il suffit de le d�sactiver gr�ce � la fonction :

Code C : S�lectionner tout
void gtk_widget_set_sensitive (GtkWidget *widget, gboolean sensitive);

Mis � jour le 16 novembre 2006 sub_khaine

Chaque classe d�rivant des GtkWidget d�finit une macro permettant de savoir si une variable appartient � cette classe, par exemple pour les GtkLabel :

Code C : S�lectionner tout
#define GTK_IS_LABEL(widget)
Cette macro renvoie TRUE si widget est un GtkLabel.

Mis � jour le 16 novembre 2006 sub_khaine

Toutes les fonctions de cr�ation de widgets retournent un GtkWidget alors que pour configurer ce dernier, il faut g�n�ralement faire un cast � l'aide des macros du type GTK_TYPE_DU_WIDGET, alors dans quel cas utiliser tel ou tel type ? Il n'existe pas de r�ponse type, mais g�n�ralement on utilise le type GtkWidget lors de la cr�ation du widget et de sa configuration, et ensuite, lorsque l'on doit modifier le widget dans des fonctions callback, on utilise le type r�el de ce dernier pour �viter d'avoir � tester son type et de faire des casts.

Mis � jour le 16 novembre 2006 sub_khaine

Pour qu'un widget soit affich�, il faut le pr�ciser explicitement � GTK en faisant appel � la fonction :

Code C : S�lectionner tout
void gtk_widget_show (GtkWidget *widget);

Mis � jour le 16 novembre 2006 sub_khaine

Pour qu'un widget apparaisse � l'�cran, il faut demander son affichage � l'aide de la fonction :

Code C : S�lectionner tout
void gtk_widget_show (GtkWidget *widget);
Mais lorsque que l'on cr�e une fen�tre avec plusieurs widgets, il est plus pratique de demander d'afficher tout son contenu gr�ce � la fonction :

Code C : S�lectionner tout
void gtk_widget_show_all (GtkWidget *widget);

Mis � jour le 16 novembre 2006 sub_khaine

Vous avez cr�� une fen�tre et essay� d'ajouter plusieurs widgets dans celle-ci mais GTK+ vous dit que c'est impossible avec un message ressemblant � :

Code : S�lectionner tout
1
2
3
(gtk_box.exe:492) : Gtk-WARNING **: Attempting to add a widget with type 
GtkButton to a GtkWindow, but as a GtkBin subclass a GtkWindow can only contain 
one widget at a time; it already contains a widget of type GtkButton
Cela vient du fait qu'un GtkWindow h�rite des GtkBin et qu'il ne peut contenir qu'un seul widget. Pour r�soudre ce probl�me, il faut ins�rer vos widgets dans un GtkBox, un GtkButtonBox, un GtkPaned ou un GtkTable selon vos besoins.

Mis � jour le 16 novembre 2006 sub_khaine

Il faut distinguer deux cas :

  • Le widget impl�mente les barres de d�filement de fa�on native, dans ce cas il suffit d'afficher ce widget dans un objet de type GtkScrolledWindow
  • Le widget ne supporte pas les barres de d�filement, il faut alors ajouter le widget � un conteneur de type GtkViewport.

Mis � jour le 16 novembre 2006 sub_khaine

Les widgets qui supportent les barres de d�filement poss�dent une ou deux propri�t�s de type GtkAdjustment (une pour la barre verticale, l'autre pour la barre horizontale). Actuellement seules trois classes en sont capables :

  • GtkTextView
  • GtkTreeView
  • GtkLayout.

Mis � jour le 16 novembre 2006 sub_khaine

Pour modifier la couleur d'un widget, il suffit d'utiliser la fonction gtk_widget_modify_bg :

Code C : S�lectionner tout
1
2
3
4
5
6
7
8
9
10
GdkColor color; 
GtkWidget *p_widget = NULL; 
  
/* Creation du widget */ 
  
color.pixel = 32; 
color.red = 65535; 
color.green = 0; 
color.blue = 0; 
gtk_widget_modify_bg (p_widget, GTK_STATE_NORMAL, &color);
Le second param�tre est de type GtkStateType et permet de sp�cifier l'�tat du widget pour lequel on souhaite modifier la couleur :

  • GTK_STATE_NORMAL : �tat de base
  • GTK_STATE_ACTIVE : lorsque le widget est actif (qu'il a le focus)
  • GTK_STATE_PRELIGHT : lorsque le curseur de la souris est sur le widget
  • GTK_STATE_SELECTED : lorsque le widget est s�lectionn� (la colonne d'une liste, par exemple)
  • GTK_STATE_INSENSITIVE : lorsque le widget est inactif

Mis � jour le 16 novembre 2006 sub_khaine

Le code ci-dessus fonctionne tr�s bien, si vous n'arrivez pas � modifier la couleur d'un widget, c'est qu'il n'est pas possible de le faire directement.
C'est le cas pour les widgets qui ne sont pas des fen�tres (le flag GTK_NO_WINDOW est s�lectionn�, les GtkLabel par exemple), dans ce cas il faut modifier la couleur de son parent.
Si vous ne souhaitez pas modifier l'apparence de tous les enfants de ce dernier, vous pouvez isoler un widget en le pla�ant dans un GtkEventBox dont vous modifiez la couleur.

Si le probl�me persiste, il peut s'agir du th�me utilis� par GTK+ qui ne supporte pas le changement de couleur.

Mis � jour le 16 novembre 2006 sub_khaine

Tout widget h�ritant d'un GtkWidget, on peut utiliser la fonction :

Code C : S�lectionner tout
void gtk_widget_set_size_request (GtkWidget *widget, gint width, gint height);
Si vous ne d�sirez pas changer la largeur ou la hauteur, vous pouvez mettre l'argument � la valeur -1 ce qui gardera la taille pr�f�r�e par d�faut.
Certains widgets impl�mentent leur propre fonction comme GtkWindow avec la fonction :

Code C : S�lectionner tout
void gtk_window_set_default_size (GtkWindow *window, gint width, gint height);
Pensez donc � toujours remonter dans la hi�rarchie des widgets pour voir si la fonction que vous recherchez n'existe pas !

Mis � jour le 16 novembre 2006 P'tit Pack

Il faut convertir la valeur num�rique en cha�ne puis la faire afficher par le widget :

Code C : S�lectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <gtk/gtk.h> 
#include <glib/gprintf.h> 
  
gint val = 10; 
gchar *chaine = NULL; 
GtkWidget *p_label = NULL; 
  
p_label = gtk_label_new (NULL); 
  
chaine = g_strdup_printf ("%d", val); 
gtk_label_set_text (GTK_LABEL (p_label), chaine); 
  
g_free (chaine), chaine = NULL;

Mis � jour le 16 novembre 2006 P'tit Pack

Pour commencer, il faut cr�er un canal alpha pour la fen�tre o� le widget sera affich�, ensuite vous pouvez utiliser les fonctions de cairo pour dessiner avec un canal alpha (la fonction cairo_set_source_rgba permet de s�lectionner la couleur avec un niveau de transparence).

Voici un exemple qui affiche une fen�tre transparente avec un cercle rouge semi-transparent :

Code C : S�lectionner tout
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
#include <gtk/gtk.h> 
#include <gdk/gdkscreen.h> 
#include <cairo.h> 
  
/* 
 * This program shows you how to create semi-transparent windows, 
 * without any of the historical screenshot hacks. It requires 
 * a modern system, with a compositing manager. I use xcompmgr 
 * and the nvidia drivers with RenderAccel, and it works well. 
 * 
 * I'll take you through each step as we go. Minimal GTK+ knowledge is 
 * assumed. 
 */ 
  
/* Only some X servers support alpha channels. Always have a fallback */ 
gboolean supports_alpha = FALSE; 
  
static void screen_changed (GtkWidget *widget, GdkScreen *old_screen, 
                            gpointer userdata) 
{ 
  /* To check if the display supports alpha channels, get the colormap */ 
  GdkScreen *screen = NULL; 
  GdkColormap *colormap = NULL; 
  
  screen = gtk_widget_get_screen (widget); 
  colormap = gdk_screen_get_rgba_colormap (screen); 
  if (colormap == NULL) 
  { 
    g_message ("Your screen does not support alpha channels!\n"); 
    colormap = gdk_screen_get_rgb_colormap(screen); 
    supports_alpha = FALSE; 
  } 
  else 
  { 
    g_message ("Your screen supports alpha channels!\n"); 
    supports_alpha = TRUE; 
  } 
  
  /* Now we have a colormap appropriate for the screen, use it */ 
  gtk_widget_set_colormap (widget, colormap); 
} 
  
/* This is called when we need to draw the windows contents */ 
static gboolean expose (GtkWidget *widget, GdkEventExpose *event, 
                        gpointer userdata) 
{ 
  gint width; 
  gint height; 
  cairo_t *cr = NULL; 
  
  cr = gdk_cairo_create(widget->window); 
  if (supports_alpha) 
  { 
    /* transparent */ 
    cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.0); 
  } 
  else 
  { 
    /* opaque white */ 
    cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); 
  } 
  
  /* draw the background */ 
  cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); 
  cairo_paint (cr); 
  
  /* draw a circle */ 
  gtk_window_get_size (GTK_WINDOW (widget), &width, &height); 
  
  cairo_set_source_rgba (cr, 1, 0.2, 0.2, 0.6); 
  cairo_arc (cr, width / 2, height / 2, 
             (width < height ? width : height) / 2 - 8 , 0, 2 * 3.14); 
  cairo_fill (cr); 
  cairo_stroke (cr); 
  
  cairo_destroy (cr); 
  return FALSE; 
} 
  
int main (int argc, char **argv) 
{ 
  GtkWidget *window = NULL; 
  
  /* boilerplate initialization code */ 
  gtk_init(&argc, &argv); 
  
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL); 
  gtk_window_set_title (GTK_WINDOW(window), "Alpha Demo"); 
  g_signal_connect (G_OBJECT(window), "delete-event", gtk_main_quit, NULL); 
  
  
  /* Tell GTK+ that we want to draw the windows background ourself. 
    * If we don't do this then GTK+ will clear the window to the 
    * opaque theme default color, which isn't what we want. 
    */ 
  gtk_widget_set_app_paintable (window, TRUE); 
  
  /* We need to handle two events ourself: "expose-event" and "screen-changed". 
    * 
    * The X server sends us an expose event when the window becomes 
    * visible on screen. It means we need to draw the contents.  On a 
    * composited desktop expose is normally only sent when the window 
    * is put on the screen. On a non-composited desktop it can be 
    * sent whenever the window is uncovered by another. 
    * 
    * The screen-changed event means the display to which we are 
    * drawing changed. GTK+ supports migration of running 
    * applications between X servers, which might not support the 
    * same features, so we need to check each time. 
    */ 
  g_signal_connect (G_OBJECT (window), "expose-event", G_CALLBACK (expose), 
                    NULL); 
  g_signal_connect (G_OBJECT (window), "screen-changed", 
                    G_CALLBACK (screen_changed), NULL); 
  
  /* initialize for the current display */ 
  screen_changed (window, NULL, NULL); 
  
  /* Run the program */ 
  gtk_widget_show_all (window); 
  gtk_main(); 
  
  return 0; 
}
Et voici le r�sultat obtenu :

Pour obtenir un effet de transparence, il faut que votre syst�me le supporte. La copie d'�cran ci-dessus a �t� prise sous Debian Etch avec le gestionnaire de fen�tre Beryl ( Installer beryl sous XFCE4).

Mis � jour le 16 novembre 2006 sub_khaine

C'est la biblioth�que Pango qui s'occupe d'afficher du texte, il faut donc utiliser cette API. Voici un exemple qui modifie le style d'un texte affich� par un GtkEntry :

Code C : S�lectionner tout
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
#include <gtk/gtk.h> 
  
int main (int argc, char **argv) 
{ 
  gtk_init (&argc, &argv); 
  { 
    GtkWidget *p_window = NULL; 
  
    p_window  = gtk_window_new (GTK_WINDOW_TOPLEVEL); 
    g_signal_connect (G_OBJECT (p_window), "delete-event", G_CALLBACK (gtk_main_quit), NULL); 
    { 
      GtkWidget *p_entry = NULL; 
  
      p_entry = gtk_entry_new (); 
      { 
        PangoFontDescription *desc =  pango_font_description_new (); 
  
        pango_font_description_set_weight (desc, PANGO_WEIGHT_BOLD); 
        gtk_widget_modify_font (p_entry, desc); 
      } 
      gtk_container_add (GTK_CONTAINER (p_window), p_entry); 
    } 
    gtk_widget_show_all (p_window); 
  } 
  gtk_main (); 
  return 0; 
}

Mis � jour le 14 mai 2007 sub_khaine

Il faut utiliser la fonction gtk_widget_grab_focus et lui passer le GtkWidget qui doit recevoir le focus. Il faut cependant v�rifier si le widget cible peut prendre le focus, ce qu'on peut d�terminer facilement avec la fonction gtk_widget_get_can_focus().

Mis � jour le 14 mai 2007 P'tit Pack

Pour d�tecter un clic droit sur un widget, il suffit d'intercepter le signal button-press-event puis de tester la valeur de l'attribut gtk.gdk.Event.button :

Code python : S�lectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import gtk 
  
class UneClasse: 
  
	def __init__(self): 
		self.fenetre=gtk.Window(gtk.WINDOW_TOPLEVEL) 
		self.fenetre.set_title("Titre") 
		self.fenetre.set_default_size(200,200) 
		self.fenetre.set_position(gtk.WIN_POS_CENTER) 
		self.fenetre.connect("destroy",gtk.main_quit,None) 
		self.bouton=gtk.Button("cliquez pour voir") 
		self.bouton.connect("button-press-event",self.unClick) 
		self.fenetre.add(self.bouton) 
		self.fenetre.show_all() 
		gtk.main() 
  
	def unClick(self,w,event): 
		if (event.button==3): 
			self.bouton.set_label("droit") 
		elif (event.button==1): 
			self.bouton.set_label("gauche") 
  
if __name__ == '__main__': 
	UneClasse()

Mis � jour le 14 mai 2007 Michel_57

Proposer une nouvelle r�ponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plut�t sur le forum de la rubrique pour �a


R�ponse � la question

Liens sous la question
pr�c�dent sommaire suivant
 

Les sources pr�sent�es sur cette page sont libres de droits et vous pouvez les utiliser � votre convenance. Par contre, la page de pr�sentation constitue une �uvre intellectuelle prot�g�e par les droits d'auteur. Copyright � 2025 Developpez Developpez LLC. Tous droits r�serv�s Developpez LLC. Aucune reproduction, m�me partielle, ne peut �tre faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'� trois ans de prison et jusqu'� 300 000 � de dommages et int�r�ts.