FAQ GTK+Consultez toutes les FAQ

void gtk_widget_set_sensitive (GtkWidget *widget, gboolean sensitive);

#define GTK_IS_LABEL(widget)

void gtk_widget_show (GtkWidget *widget);

void gtk_widget_show (GtkWidget *widget);

void gtk_widget_show_all (GtkWidget *widget);

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

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);

void gtk_widget_set_size_request (GtkWidget *widget, gint width, gint height);

void gtk_window_set_default_size (GtkWindow *window, gint width, gint height);

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;

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; 
}

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; 
}

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()