[GTK+ 3.10] Affichage dynamique

Version imprimable

10/06/2014, 15h58
phantomlibre

[GTK+ 3.10] Affichage dynamique

Bonjour,

Je suis entrain de faire un programme permettant l'exécution d'automates cellulaires à deux dimensions, et je fait toute la partie graphique avec GTK+.

J'ai un souci pour l'affichage de l'automate.

Pour l'afficher j'ai fait une image que je créé initialement grâce à un pixbuf, je met ensuite l'image dans la fenêtre. À chaque étapes de l'automate je détruit l'image qui est affiché, et j'en créé une nouvelle à partir d'un pixbuf correspondant au nouvel état de l'automate.
Le problème c'est que ça ne marche pas ! Rien n'est mis à jours, et si je change de fenêtre, puis je reviens sur mon application, la fenêtre est devenue complètement vide, plus rien n'est affiché (les menus, les boutons,...).

Comme il semble que ce ne soit pas la bonne méthode j'ai cherché un autre moyen de parvenir à mes fins. J'ai donc trouvé les gtkDrawingArea. Le problème c'est que je n'y comprend pas grand chose. J'ai trouvé deux exemples (ici et là) pour essayé d'y voir un peu plus claire, mais que je compile gcc me dit que gktwidget ou gtkdrawingarea n'ont pas d'attributs window ou allocation.

Je ne sais vraiment pas comment m'y prendre, donc si quelqu'un veut bien éclairer ma lanterne je lui en serais très reconnaissant. :)

Cordialement,
Phantom

PS : je ne sais pas si ça change quelque chose, mais je suis sous Ubuntu 14.04, et j'utilise la version 3.10 de GTK+.
11/06/2014, 09h05
gerald3d

Bonjour.

Pour pouvoir t'apporter un début de réponse il nous faut le code incriminé. Te répondre sans est pour nous impossible ;).

La fonction qui lance l'automate, elle est appelé quand on clique sur un bouton. J'ai essayé d'utiliser les threads pour voir si ça changé quelque chose, mais non.

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
 
// callback function to play the automaton
void play (GtkWidget* window, gpointer data) {
	GtkWidget* image;
	pthread_t thread;
 
	g_signal_handler_disconnect (window, proc.handP);
	proc.handP=g_signal_connect (G_OBJECT(window), "clicked", G_CALLBACK(pause_auto), NULL);
//	image=gtk_image_new_from_stock (GTK_STOCK_MEDIA_PAUSE, GTK_ICON_SIZE_BUTTON);
	image=gtk_image_new_from_icon_name ("media-playback-pause", GTK_ICON_SIZE_BUTTON);
	gtk_button_set_image (GTK_BUTTON(window), image);
 
	proc.holdOn=1;
	proc.stop=0;
	while (proc.holdOn==1) {
		//timer
		if (proc.holdOn==1) {
			MPI_Bcast (&(proc.stop), 1, MPI_INT, 0, MPI_COMM_WORLD);
			recv_grid ();
/*int i;
for (i=0 ; i<proc.width ; i++) {
	printf ("%d ", proc.grid[i]);
}
printf ("\n");*/
			while (pthread_create (&(thread), NULL, print_grid, NULL)!=0) {
				perror ("pthread_create");
			}
			pthread_join (thread, NULL);
	gtk_widget_show_all (scrolledWindow);
//			print_grid ();
sleep (1);
		}
	}
}

La fonction qui est censé afficher la grille dans la fenêtre.

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
 
// to display the grid
void* print_grid (void* arg) {
	GdkPixbuf* pixbuf;
	GtkWidget* image;
	int i, j, zi, zj;
	GList* list;
 
 
for (i=0 ; i<proc.width ; i++) {
	printf ("%d ", proc.grid[i]);
}
printf ("\ndans print_grid\n");
	list=gtk_container_get_children (GTK_CONTAINER(scrolledWindow));
	if (list!=NULL) {
		gtk_container_remove (GTK_CONTAINER(scrolledWindow), (GtkWidget*)list->data);
	}
 
	pixbuf=gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, proc.width*proc.zoom, proc.height*proc.zoom);
 
	for (i=0 ; i<proc.height ; i++) {
		for (j=0 ; j<proc.width ; j++) {
			if (proc.grid[i*proc.width+j]==0) {
				for (zi=0 ; zi<proc.zoom ; zi++) {
					for (zj=0 ; zj<proc.zoom ; zj++) {
						put_pixel (pixbuf, j*proc.zoom+zj, i*proc.zoom+zi, 255, 255, 255);
					}
				}
			}
			else {
				for (zi=0 ; zi<proc.zoom ; zi++) {
					for (zj=0 ; zj<proc.zoom ; zj++) {
						put_pixel (pixbuf, j*proc.zoom+zj, i*proc.zoom+zi, 0, 0, 0);
					}
				}
			}
		}
	}
 
	image=gtk_image_new_from_pixbuf (pixbuf);
	gtk_container_add (GTK_CONTAINER(scrolledWindow), image);
	gtk_widget_show_all (scrolledWindow);
 
	return NULL;
}

La fonction put_pixel est une fonction trouvé sur un tutoriel sur les pixbuf (je ne sais plus où).

Dans la seconde fonction plutôt que de supprimer l'ancienne image j'ai essayé de la modifier par la fonction gtk_image_set_from_pixbuf, mais le résultat est toujours le même.

Enfin, comme c'est une application répartie grâce à la bibliothèque MPI, le processus chargé de l'affichage récupère la grille dans la fonction recv_grid. Je ne pense pas que le problème vienne de là car quand j'affiche des choses dans le terminal à chaque étapes, tout se passe bien.

J'espère que ça vous aidera à m'aider. :)

11/06/2014, 22h26
Tarnyko
Phantomlibre,

L'idéal serait même de poster le code complet, pour qu'on l'essayer et le corriger facilement, mais ce n'est peut-être pas possible... ?

Sinon, mes idées : GTK+ utilise un système de boucle principale nommé "g_main_loop". Tu la lances en principe une fois dans la fonction "main()" -> "gtk_main ();"
Le redessinage des widgets, et à plus forte raison des autres éléments graphiques, n'est effectué qu'à chaque fois que cette boucle s'exécute.

Si tu boucles via ta propre logique, par exemple avec ton propre timer, GTK+ va lui donner la main et se "pauser" en attendant que ce soit fini ; et donc tu arrives dans l'état "blanc/gelé" que tu as observé.

Une solution serait d'appeler à chaque fois :

Code:

gtk_main_iteration ();

ce qui va faire avancer la boucle, juste après avoir demandé explicitement à GTK+ de redessiner ton widget :

Code:

gtk_widget_queue_draw (widget);

Voici l'ensemble si tu veux ne reprendre ton timer que quand GTK+ a traité tous ses événements (plus fluide, mais rend les délais imprédictibles) :
Code:

1 2 3 gtk_widget_queue_draw (widget); while (gtk_events_pending ()) gtk_main_iteration ();
12/06/2014, 09h10
gerald3d

Utiliser des threads en dehors de la boucle principale Gtk+ pour modifier des widgets est source à problème. Commence par utiliser une simple boucle pour afficher "normalement" les unes à la suite des autres tes images.

Ensuite une petite question : scrolledwindow est-elle une variable globale ?

Petite remarque. Tu devrais renommer GtkWidget *window dans ta fonction callback en GtkWidget *button. Ca évitera des confusions...

Dernière petite question : de quoi est composée la fonction pause_auto(); ?
12/06/2014, 11h05
phantomlibre

\o/ Ça marche !!!

Merci Tarnyko ! :)

Citation:

Envoyé par gerald3d

Utiliser des threads en dehors de la boucle principale Gtk+ pour modifier des widgets est source à problème. Commence par utiliser une simple boucle pour afficher "normalement" les unes à la suite des autres tes images.

Enlevé.

Citation:

Envoyé par gerald3d

Ensuite une petite question : scrolledwindow est-elle une variable globale ?

Oui tout à fait.

Citation:

Envoyé par gerald3d

Petite remarque. Tu devrais renommer GtkWidget *window dans ta fonction callback en GtkWidget *button. Ca évitera des confusions...

C'était prévu dans le nettoyage du code une fois que tout marchera.

Citation:

Envoyé par gerald3d

Dernière petite question : de quoi est composée la fonction pause_auto(); ?

Elle déconnecte le signal qu'il y a sur la bouton play/pause, elle remet un signal qui appel la fonction play, elle change l’icône, et elle met la variable holdOn à 0 pour sortir de la boucle qui est dans play.

Merci à tout les deux. ;)

PS : je laisse le sujet non résolut quelque temps au cas où vous souhaiteriez rajouter quelque chose.