Discussion :

[Kazujoshi]

Bonjour,

Je débute avec GTK et j'aurais voulu, pour mon application, construire un pedigree.

Première idée
Dans un premier temps, j'ai fait ça à l'aide de GtkBox et GtkTextView comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
void init_pedigree(GtkBuilder *p_builder)
{
	GtkWidget *p_scrolled_win = (GtkWidget *) gtk_builder_get_object (p_builder, "scrolledwindow_ped");
	GtkWidget *p_hbox = gtk_hbox_new (TRUE, 5);
	GtkWidget *p_vbox[5];
	GtkWidget *p_textview[62];
	gint i, j, k, exp;
	const GdkColor colors[] = {
		{0, 62976, 52480, 56064},  
		{0, 38144, 46848, 63488}};
 
	gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(p_scrolled_win), p_hbox);
	for(i=1;i<6;i++) {
		p_vbox[i] = gtk_vbox_new (TRUE, 5);
		gtk_box_pack_start(GTK_BOX(p_hbox), GTK_WIDGET(p_vbox[i]), TRUE, TRUE, 0);
		exp = 1;
		for(k=0;k<i;k++) exp = exp*2;
		for(j=0;j<exp;j++) {
			p_textview[j] = gtk_text_view_new();
			gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (p_textview[j]), GTK_WRAP_WORD_CHAR);
			gtk_text_view_set_justification (GTK_TEXT_VIEW (p_textview[j]), GTK_JUSTIFY_CENTER);
			if (j & 1) gtk_widget_modify_base (p_textview[j], GTK_STATE_NORMAL, &colors[1]);
			else       gtk_widget_modify_base (p_textview[j], GTK_STATE_NORMAL, &colors[0]);
			gtk_box_pack_start(GTK_BOX(p_vbox[i]), GTK_WIDGET(p_textview[j]), TRUE, TRUE, 0);
		}
	}
	gtk_widget_show_all(p_hbox);
}

Le résultat est satisfaisant même si le fait de ne pouvoir centrer le texte verticallement dans les GtkTextview m'embête un peu. Peut-être bidouiller quelque chose avec gtk_text_view_get_visible_rect ( ) et gtk_text_view_set_pixels_above_lines ( ) ? Le résultat peut-il être correct pour ce que je veux faire et cela ne va-t-il pas poser des problèmes en cas de redimensionnement de la fenêtre ? (avec toutes les valeurs à recalculer ?)

Deuxième idée
J'avais aussi pensé réaliser un custom widget sur le modèle de GtkLed, y détecter un click de souris, afficher alors une gtkdialog contenant un gtktextview, recueillir le texte saisi et l'afficher dans mon rectangle. Le tout avec des GtkDrawingArea (et GtkEventBox pour détecter le click ?) + des appels à la bibliothèque cairo. Visuellement, le résultat sera meilleur je pense et ressemblera plus à ce qui est fait dans Gramps (http://gramps-project.org/wiki/image...en5-gramps.jpg) par exemple. Faut-il nécessairement créer de toute pièce un custom widget ou peut-on se contenter de plusieurs GtkDrawingArea contenues dans plusieurs GtkBox comme celles utilisées dans la première idée ? Le réaffichage de nombreuses GtkDrawingArea ne va-t-il pas faire clignoter l'affichage dans tous les sens ?

Merci pour votre aide sur ces deux "idées" ou pour en proposer une meilleure

[pvincent]

Bonjour,
Je ne sais pas exactement ce que tu veux faire, mais l'image en lien laisse penser qu'il s'agit simplement d'une arborescence pour laquelle un GtkTree me semble bien adapté. Voir la doc GTK et ce tutorial par exemple
http://scentric.net/tutorial/treeview-tutorial.html
Sinon, il me semble qu'une seule GtkDrawingArea contenant tout le dessin doit suffire.

[Kazujoshi]

Merci pour ta réponse,

En effet, c'est assez simple de contenir tout le dessin dans une GtkDrawingArea mais alors se posent plusieurs questions :

- Pour interagir avec chaque élément du dessin afin d'éditer le texte contenu dans un élément, on recueille à chaque click sur la GtkDrawingArea la position du curseur ?

- Visiblement une GtkTable n'est pas prévue pour contenir un grand nombre de widget (2000 GtkLabel par exemple) puisque dans ce cas, l'affichage est assez lent. Mais est-ce qu'il est conseillé d'utiliser une GtkDrawingArea alors que beaucoup disent sur ce forum que c'est très gourmand en ressources ? Existe-t-il des astuces pour minimiser l'exploitation de ces ressources ?

Merci pour vos éclaircissements.

[gerald3d]

Oui il existe une astuce toute simple.

En règle général les utilsateurs d'un GtkDrawingArea "dessinent" directement dessus. Tout leur code de dessin se retrouve dans le CALLBACK associé au signal "expose-event"du widget. Cette méthode est très gourmande en temps processus. En effet à chaque rafraichissement, même partiel, du widget le CALLBACK est appelé. Tout le dessin est alors recalculé.

Pour éviter cet écueil il faut passer par un GdkPixbuf. On dessine dans celui-ci. Dans la fonction CALLBACK on ne fait qu'insérer le GdkPixbuf dans le GtkDrawingArea. Ainsi, lors d'un rafraîchissement l'image n'est pas recalculée. Elle existe déjà. Les temps processus sont donc largement réduits.

[liberforce]

En même temps tu n'es pas censé tout redessiner à chaque expose-event. L'expose-event t'indique quelle zone de l'image est à redessiner. Tu peux donc redessiner uniquement les éléments présents dans cette zone (la clipping region). Tu peux directement passer cette région à cairo.

Tu peux aussi comme tu le dis utiliser la technique du double-buffering, qui consiste à dessiner dans un buffer plutôt que directement à l'écran, puis dessiner ce bufffer à l'écran en une fois. Tous les widgets GTK utilisent déjà en interne (et par défaut) du double buffering... Pour un GtkDrawingArea, il suffit de gérer soi même les appels à gdk-window-begin-paint-region pour faire du double buffering.

[Kazujoshi]

Après une petite absence j'ai pu essayer ces astuces. Merci à tous les deux pour votre aide.