Comportement de fenêtres GTK+ avec dessins

Version imprimable

Voir 40 message(s) de cette discussion en une page

Bonjour,

je développe un programme Fortran90/C/Gtk+, à une certaine étape je dessine des courbes dans une GtkWindow en utilisant Cairo:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 GtkWidget * info; cairo_t *cr; int i; int sizecurve; float curvetoprint[sizecurve]; info = (GtkWidget *) gtk_builder_get_object (BuilderGtk, "RDFs"); /* RDFs est une Windows décrite dans un fichier xml */ cr = gdk_cairo_create(widget -> window); cairo_set_source_rgb(cr, 0, 0, 0); cairo_set_line_width (cr, 1.0); for (i=0; i < sizecurve-2; i++) { /* On place le tout dans une fenêtre 800x600 */ cairo_move_to(cr, i*800/sizecurve, 600-50*curvetoprint[i]); cairo_line_to(cr, (i+1)*800/sizecurve, 600-50*curvetoprint[i+1]); } cairo_stroke(cr); cairo_destroy(cr);
Tout cela fonctionne parfaitement seulement j'ai noté quelque chose de désagréable lors de l'exécution du programme.
La courbe est tracée pas de soucis seulement quand je masque la fenêtre dans la barre des taches et que je la fait réapparaître son contenu a été effacé ...

Une suggestion pour empêcher cela ?

S.

17/04/2009, 17h41
gerald3d
2 solutions de principe :
1. dessiner dans un bloc mémoire alloué. Ce bloc est affiché dans le Callback appelé par le signal "expose-event".
2. Dessiner entièrement la courbe dans le callback appelé par le signal "expose-event". Pas terrible comme solution. Ralentissement de l'éxécution. Mais c'est la solution la plus simple à mettre en oeuvre.
18/04/2009, 19h15
Slookeur

Merci pour l'info je vais essayer de faire uniquement avec l'expose event.

S.
31/12/2010, 00h16
reda91

pouvez M. Slookeur m'envouyé le code du programme permetant de dessiner n'imprte qu'elle courbes dans une GtkWindow en utilisant Cairo plz et merci d'avance :)
31/12/2010, 01h49
Gamall
Citation:
Envoyé par gerald3d

2 solutions de principe :

dessiner dans un bloc mémoire alloué. Ce bloc est affiché dans le Callback appelé par le signal "expose-event".
Dessiner entièrement la courbe dans le callback appelé par le signal "expose-event". Pas terrible comme solution. Ralentissement de l'éxécution. Mais c'est la solution la plus simple à mettre en oeuvre.
Pour le expose-event, j'ai remarqué qu'il n'est pas émis si le fenêtre est partiellement cachée. Du coup la partie qui était cachée est effacée lorsque la fenêtre réapparaît.
31/12/2010, 10h16
gerald3d

Je n'ai jamais rencontré ce genre de problème. Maintenant je n'ai jamais dessiné directement dans un GtkWindow. Mes dessins se sont toujours faits dans un GtkDrawingArea. Est-ce que ca fait une différence? Pas sûr...
31/12/2010, 17h51
reda91

oui oui mon fraire je veux seulement le code du programme qui dessine n'importe qu'elle courbe et merci ;)
03/01/2011, 10h33
liberforce

Citation:

Envoyé par reda91

oui oui mon fraire je veux seulement le code du programme qui dessine n'importe qu'elle courbe et merci ;)

Merci de ne pas venir polluer le fil de discussion de quelqu'un d'autre. Si tu as des questions, ouvre ton propre fil de discussion.
03/01/2011, 10h37
liberforce

Citation:

Envoyé par artificier59

Pour le expose-event, j'ai remarqué qu'il n'est pas émis si le fenêtre est partiellement cachée. Du coup la partie qui était cachée est effacée lorsque la fenêtre réapparaît.

Je ne suis pas d'accord. L'expose-event est émis à chaque fois qu'il y a quelque chose à dessiner. Quand la fenêtre est à l'arrière plan et partiellement cachée, et qu'on la fait passer à l'avant plan, je suis à peu près certain qu'il est émis.

@Gerald, dessiner dans un GtKDrawingArea ou un autre widgets, c'est pareil, cairo dessine de toute façon dans le GdkWindow associé au widget...
03/01/2011, 11h18
gerald3d

Citation:

Envoyé par liberforce

@Gerald, dessiner dans un GtKDrawingArea ou un autre widgets, c'est pareil, cairo dessine de toute façon dans le GdkWindow associé au widget...

Oui tu as raison. +1

Citation:

Envoyé par liberforce

Je ne suis pas d'accord. L'expose-event est émis à chaque fois qu'il y a quelque chose à dessiner. Quand la fenêtre est à l'arrière plan et partiellement cachée, et qu'on la fait passer à l'avant plan, je suis à peu près certain qu'il est émis.

Je viens de faire un petit test simple avec ce code:
Code:

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 #include <gtk/gtk.h> gboolean expose_cb (GtkWidget *widget, GdkEventExpose *event) { g_print ("Expose event emitted !\n"); return FALSE; } int main(int argc, char ** argv) { GtkWidget *window; GtkWidget *draw; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW(window), 320, 200); g_signal_connect (G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL); draw = gtk_drawing_area_new (); g_signal_connect (draw, "expose-event", G_CALLBACK(expose_cb), NULL); gtk_container_add (GTK_CONTAINER(window), draw); gtk_widget_show_all (window); gtk_main (); return 0; }
J'ai mis une fenêtre en partie par dessus ce programme, et quand je clique sur cette fenêtre pour cacher le programme, puis que je re-clique sur le programme pour le remettre au premier plan, le signal n'est pas émis.
Autre chose, quand je glisse la fenêtre (sans la relâcher) sous une autre ou sous le tableau de bord du bas (sous gnome), le signal n'est pas non plus émis.
Du coup ben s'il y a un dessin dans la fenêtre, ben celui-ci est effacé :aie:

Aussi, ce que je comprends pas, c'est pourquoi pour une fenêtre qui contient des widgets (boutons, barre de menu, etc...), qui est partiellement cachée comme je l'ai décris plus haut, les widgets ne s’effacent pas ?

03/01/2011, 11h50
gerald3d

Histoire d'être sûr. Ajoute le signal "GDK_EXPOSURE_MASK" avec la fonction gtk_widget_set_events (GtkWidget *widget, gint events); à ta GtkWindow* et retente l'expérience.

Si on prend les GtkDrawingArea ils héritent bien des GtkWidgets mais ils n'écoutent pas tous les signaux de ces derniers. Il est possible que les GtkWindow n'écoutent pas le signal "GDK_EXPOSURE_MASK".

Oui, j'ai aussi essayé comme ça:

Code:

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
#include <gtk/gtk.h>
 
gboolean expose_cb (GtkWidget *widget, GdkEventExpose *event)
{
	g_print ("Expose event emitted !\n");
 
	return FALSE;
}
 
int
main(int argc, char ** argv)
{
	GtkWidget *window;
	GtkWidget *draw;
 
	gtk_init (&argc, &argv);
 
	window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gtk_window_set_default_size (GTK_WINDOW(window), 320, 200);
	g_signal_connect (G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
	draw = gtk_drawing_area_new ();
	gtk_widget_set_events (draw,
				gtk_widget_get_events (draw)
			|	GDK_EXPOSURE_MASK);
	g_signal_connect (draw, "expose-event", G_CALLBACK(expose_cb), NULL);
	gtk_container_add (GTK_CONTAINER(window), draw);
 
	gtk_widget_show_all (window);
 
	gtk_main ();
 
	return 0; 
}

En fait, le seul moment où le signal est émis chez moi, c'est quand la fenêtre est réduite dans la barre des tâches. J'ai aussi essayé en désactivant compiz.

03/01/2011, 12h22
liberforce

Et si tu corriges le prototype de la callback ? Le prototype que tu utilises pour l'expose-event est incomplet.

Idem pour le signal destroy, le prototype est incomplet.

Voila un petit code qui affiche les évènements emits par un GtkWindow. Le code n'est pas propre mais au moins ca donne une idée de la chose.

Code:

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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
#include <gtk/gtk.h>
 
gboolean event_emitted (GtkWidget *widget, GdkEvent  *event, gpointer user_data)
{
  g_print("event emitted : ");
 
  switch (event->type)
  {
    case GDK_NOTHING:
      g_print("GDK_NOTHING\n");
      break;
    case GDK_DELETE:
      g_print("GDK_DELETE\n");
      break;
    case GDK_DESTROY:
      g_print("GDK_DESTROY\n");
      break;
    case GDK_EXPOSE:
      g_print("GDK_EXPOSE\n");
      break;
    case GDK_MOTION_NOTIFY:
      g_print("GDK_MOTION_NOTIFY\n");
      break;
    case GDK_BUTTON_PRESS:
      g_print("GDK_BUTTON_PRESS\n");
      break;
    case GDK_2BUTTON_PRESS:
      g_print("GDK_2BUTTON_PRESS\n");
      break;
    case GDK_3BUTTON_PRESS:
      g_print("GDK_3BUTTON_PRESS\n");
      break;
    case GDK_BUTTON_RELEASE:
      g_print("GDK_BUTTON_RELEASE\n");
      break;
    case GDK_KEY_PRESS:
      g_print("GDK_KEY_PRESS\n");
      break;
    case GDK_KEY_RELEASE:
      g_print("GDK_KEY_RELEASE\n");
      break;
    case GDK_ENTER_NOTIFY:
      g_print("GDK_ENTER_NOTIFY\n");
      break;
    case GDK_LEAVE_NOTIFY:
      g_print("GDK_LEAVE_NOTIFY\n");
      break;
    case GDK_FOCUS_CHANGE:
      g_print("GDK_FOCUS_CHANGE\n");
      break;
    case GDK_CONFIGURE:
      g_print("GDK_CONFIGURE\n");
      break;
    case GDK_MAP:
      g_print("GDK_MAP\n");
      break;
    case GDK_UNMAP:
      g_print("GDK_UNMAP\n");
      break;
    case GDK_PROPERTY_NOTIFY:
      g_print("GDK_PROPERTY_NOTIFY\n");
      break;
    case GDK_SELECTION_CLEAR:
      g_print("GDK_SELECTION_CLEAR\n");
      break;
    case GDK_SELECTION_REQUEST:
      g_print("GDK_SELECTION_REQUEST\n");
      break;
    case GDK_SELECTION_NOTIFY:
      g_print("GDK_SELECTION_NOTIFY\n");
      break;
    case GDK_PROXIMITY_IN:
      g_print("GDK_PROXIMITY_IN\n");
      break;
    case GDK_PROXIMITY_OUT:
      g_print("GDK_PROXIMITY_OUT\n");
      break;
    case GDK_DRAG_ENTER:
      g_print("GDK_DRAG_ENTER\n");
      break;
    case GDK_DRAG_LEAVE:
      g_print("GDK_DRAG_LEAVE\n");
      break;
    case GDK_DRAG_MOTION:
      g_print("GDK_DRAG_MOTION\n");
      break;
    case GDK_DRAG_STATUS:
      g_print("GDK_DRAG_STATUS\n");
      break;
    case GDK_DROP_START:
      g_print("GDK_DROP_START\n");
      break;
    case GDK_DROP_FINISHED:
      g_print("GDK_DROP_FINISHED\n");
      break;
    case GDK_CLIENT_EVENT:
      g_print("GDK_CLIENT_EVENT\n");
      break;
    case GDK_VISIBILITY_NOTIFY:
      g_print("GDK_VISIBILITY_NOTIFY\n");
      break;
    case GDK_NO_EXPOSE:
      g_print("GDK_NO_EXPOSE\n");
      break;
    case GDK_SCROLL:
      g_print("GDK_SCROLL\n");
      break;
    case GDK_WINDOW_STATE:
      g_print("GDK_WINDOW_STATE\n");
      break;
    case GDK_SETTING:
      g_print("GDK_SETTING\n");
      break;
    case GDK_OWNER_CHANGE:
      g_print("GDK_OWNER_CHANGE\n");
      break;
    case GDK_GRAB_BROKEN:
      g_print("GDK_GRAB_BROKEN\n");
      break;
    case GDK_DAMAGE:
      g_print("GDK_DAMAGE\n");
      break;
  }
 
  return FALSE;
}
 
int
main(int argc, char ** argv)
{
	GtkWidget *window;
 
	gtk_init (&argc, &argv);
 
	window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gtk_window_set_default_size (GTK_WINDOW(window), 320, 200);
	g_signal_connect (G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
	g_signal_connect (G_OBJECT(window), "event", G_CALLBACK(event_emitted), NULL);
 
	gtk_widget_show_all (window);
 
	gtk_main ();
 
	return 0; 
}

Autant que je me souvienne la DrawingArea n'étant reliée à rien, il faut spécifier tous les évenements que l'on veut prendre en compte.
A titre d'exemple, dans GraceGTK, j'utilise la séquence suivante:

Code:

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
 
 
  gg_canvas = gtk_drawing_area_new ();
/* gg_drawing_window est fille de gg_main_window */
  gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (gg_drawing_window),gg_canvas );
  gtk_widget_modify_bg (GTK_WIDGET(gg_canvas), GTK_STATE_NORMAL ,&wheat);
  gtk_widget_show (gg_canvas);
 
  /* a gtk_drawing_area does not handle key-press-event: we must connect to gg_main_window */
  gtk_widget_add_events (GTK_WIDGET (gg_main_window)
			 ,GDK_KEY_PRESS_MASK
			 |GDK_KEY_RELEASE_MASK );
  g_signal_connect (gg_main_window ,"key-press-event"   ,G_CALLBACK (gg_myproc) ,NULL);
  g_signal_connect (gg_main_window ,"key-release-event" ,G_CALLBACK (gg_myproc) ,NULL);
  g_signal_connect (gg_main_window ,"delete-event"      ,G_CALLBACK (gg_bailout_main), GINT_TO_POINTER(1));
 
  g_signal_connect (gg_canvas ,"expose_event" ,G_CALLBACK (gg_expose_resize_CB), NULL);
  gtk_widget_add_events (GTK_WIDGET(gg_canvas)
			 , GDK_ENTER_NOTIFY_MASK
			 | GDK_LEAVE_NOTIFY_MASK
			 | GDK_BUTTON_PRESS_MASK
			 | GDK_POINTER_MOTION_MASK
			 );
  g_signal_connect (gg_canvas, "motion-notify-event" ,G_CALLBACK (gg_myproc) ,NULL);
  g_signal_connect (gg_canvas, "button-press-event"  ,G_CALLBACK (gg_myproc) ,NULL);

qui permet d'utiliser la souris et le clavier dans gg_canvas et rafraîchit l'affichage quand c'est nécessaire.
Par exemple, quand le programme est interrompu par le debogueur ddd, tout est bloqué,gg_expose_resize_CB n'est pas appelée et si on déplace une fenêtre par dessus, on laisse une trace dans la drawing area

03/01/2011, 17h39
liberforce

Une drawing area, c'est fait pour dessiner... Donc effectivement, de nombreux signaux ne sont tout bonnement pas connectés par défaut, ce qui est logique. Seul le configure-event et l'expose-event sont nécessaires.

Citation:

Envoyé par gerald3d

Voila un petit code qui affiche les évènements emits par un GtkWindow. Le code n'est pas propre mais au moins ca donne une idée de la chose.

Code:

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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
#include <gtk/gtk.h>
 
gboolean event_emitted (GtkWidget *widget, GdkEvent  *event, gpointer user_data)
{
  g_print("event emitted : ");
 
  switch (event->type)
  {
    case GDK_NOTHING:
      g_print("GDK_NOTHING\n");
      break;
    case GDK_DELETE:
      g_print("GDK_DELETE\n");
      break;
    case GDK_DESTROY:
      g_print("GDK_DESTROY\n");
      break;
    case GDK_EXPOSE:
      g_print("GDK_EXPOSE\n");
      break;
    case GDK_MOTION_NOTIFY:
      g_print("GDK_MOTION_NOTIFY\n");
      break;
    case GDK_BUTTON_PRESS:
      g_print("GDK_BUTTON_PRESS\n");
      break;
    case GDK_2BUTTON_PRESS:
      g_print("GDK_2BUTTON_PRESS\n");
      break;
    case GDK_3BUTTON_PRESS:
      g_print("GDK_3BUTTON_PRESS\n");
      break;
    case GDK_BUTTON_RELEASE:
      g_print("GDK_BUTTON_RELEASE\n");
      break;
    case GDK_KEY_PRESS:
      g_print("GDK_KEY_PRESS\n");
      break;
    case GDK_KEY_RELEASE:
      g_print("GDK_KEY_RELEASE\n");
      break;
    case GDK_ENTER_NOTIFY:
      g_print("GDK_ENTER_NOTIFY\n");
      break;
    case GDK_LEAVE_NOTIFY:
      g_print("GDK_LEAVE_NOTIFY\n");
      break;
    case GDK_FOCUS_CHANGE:
      g_print("GDK_FOCUS_CHANGE\n");
      break;
    case GDK_CONFIGURE:
      g_print("GDK_CONFIGURE\n");
      break;
    case GDK_MAP:
      g_print("GDK_MAP\n");
      break;
    case GDK_UNMAP:
      g_print("GDK_UNMAP\n");
      break;
    case GDK_PROPERTY_NOTIFY:
      g_print("GDK_PROPERTY_NOTIFY\n");
      break;
    case GDK_SELECTION_CLEAR:
      g_print("GDK_SELECTION_CLEAR\n");
      break;
    case GDK_SELECTION_REQUEST:
      g_print("GDK_SELECTION_REQUEST\n");
      break;
    case GDK_SELECTION_NOTIFY:
      g_print("GDK_SELECTION_NOTIFY\n");
      break;
    case GDK_PROXIMITY_IN:
      g_print("GDK_PROXIMITY_IN\n");
      break;
    case GDK_PROXIMITY_OUT:
      g_print("GDK_PROXIMITY_OUT\n");
      break;
    case GDK_DRAG_ENTER:
      g_print("GDK_DRAG_ENTER\n");
      break;
    case GDK_DRAG_LEAVE:
      g_print("GDK_DRAG_LEAVE\n");
      break;
    case GDK_DRAG_MOTION:
      g_print("GDK_DRAG_MOTION\n");
      break;
    case GDK_DRAG_STATUS:
      g_print("GDK_DRAG_STATUS\n");
      break;
    case GDK_DROP_START:
      g_print("GDK_DROP_START\n");
      break;
    case GDK_DROP_FINISHED:
      g_print("GDK_DROP_FINISHED\n");
      break;
    case GDK_CLIENT_EVENT:
      g_print("GDK_CLIENT_EVENT\n");
      break;
    case GDK_VISIBILITY_NOTIFY:
      g_print("GDK_VISIBILITY_NOTIFY\n");
      break;
    case GDK_NO_EXPOSE:
      g_print("GDK_NO_EXPOSE\n");
      break;
    case GDK_SCROLL:
      g_print("GDK_SCROLL\n");
      break;
    case GDK_WINDOW_STATE:
      g_print("GDK_WINDOW_STATE\n");
      break;
    case GDK_SETTING:
      g_print("GDK_SETTING\n");
      break;
    case GDK_OWNER_CHANGE:
      g_print("GDK_OWNER_CHANGE\n");
      break;
    case GDK_GRAB_BROKEN:
      g_print("GDK_GRAB_BROKEN\n");
      break;
    case GDK_DAMAGE:
      g_print("GDK_DAMAGE\n");
      break;
  }
 
  return FALSE;
}
 
int
main(int argc, char ** argv)
{
	GtkWidget *window;
 
	gtk_init (&argc, &argv);
 
	window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gtk_window_set_default_size (GTK_WINDOW(window), 320, 200);
	g_signal_connect (G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
	g_signal_connect (G_OBJECT(window), "event", G_CALLBACK(event_emitted), NULL);
 
	gtk_widget_show_all (window);
 
	gtk_main ();
 
	return 0; 
}

ça c'est bien, mais c'est surtout le résultat sur ta machine qui m'intéresse ;)

03/01/2011, 17h51
gerald3d

Je confirme les dire de artificier59. Le signal "expose-event" n'est pour ainsi dire jamais émit.
Par contre, et je pense que la solution est là, c'est plutôt le signal "configure-event" qui est sollicité.

Maintenant, lorsqu'on cache partiellement la fenêtre par une autre, seul le signal du focus est émit lors du changement de fenêtre. Ensuite, si on déplace cette autre fenêtre sur la notre, aucun signal n'est émit.8O

J'ai du loupé quelque chose en route... Tout ceci est vrai pour l'écoute d'un GtkWindow.

Je relance mon essai sur un GtkDrawingArea pour voir.
03/01/2011, 17h55
gerald3d

Le test a été rapide. Même comportement sur un GtkDrawingArea. Ce qui reste normal il me semble.

Voir 40 message(s) de cette discussion en une page