Dessiner du texte ?

Version imprimable

Dessiner du texte ?

Bonjour,

J'aimerais savoir comment dessiner du texte avec GTK.
Je n'ai pas trouvé grand chose là dessus.
Bien sur il y a la fonction gdk_draw_text () mais je n'ai pas vu d'exemples d'utilisation.
Certain disent qu'il faut utiliser la librairie Pango pour dessiner du texte mais là encore trés peu d'information.

Voici une application ultra simple:
Une fenêtre et une drawing area avec un fond blanc:
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 #define WIDTH 500 #define HEIGHT 300 static GdkPixmap *pixmap = NULL; void refresh_cb(GtkWidget *draw_area, gpointer data) { if (pixmap == NULL) { pixmap = gdk_pixmap_new(draw_area->window, 500, HEIGHT, -1); gdk_draw_rectangle(pixmap, draw_area->style->white_gc, TRUE, 0, 0, WIDTH, HEIGHT); } gdk_draw_pixmap(draw_area->window, draw_area->style->black_gc, pixmap, 0,0,0,0, WIDTH, HEIGHT); } int main(int argc, char **argv) { GtkWidget *pWin; GtkWidget *pDrawArea; GtkWidget *pVBox; gtk_init(&argc, &argv); pWin = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size(GTK_WINDOW(pWin), WIDTH, HEIGHT); g_signal_connect(G_OBJECT(pWin), "destroy", G_CALLBACK(gtk_main_quit), NULL); pVBox = gtk_vbox_new(FALSE, 4); gtk_container_add(GTK_CONTAINER(pWin), pVBox); pDrawArea = gtk_drawing_area_new (); gtk_widget_set_size_request (pDrawArea, WIDTH, HEIGHT); g_signal_connect(G_OBJECT(pDrawArea),"event",G_CALLBACK(refresh_cb), NULL); gtk_box_pack_start(GTK_BOX(pVBox), pDrawArea, TRUE, TRUE, 0); gtk_window_set_title(GTK_WINDOW(pWin), "GTK-Win"); gtk_widget_show_all(pWin); gtk_main(); return EXIT_SUCCESS; }
Est ce que quelqu'un pourrait me montrer comment utiliser gdk_draw_text () afin d'afficher un texte (hello world par ex) au milieu de la fenêtre ?

D'avance merci

04/08/2006, 18h08
gege2061

Citation:

Envoyé par tintin72

Est ce que quelqu'un pourrait me montrer comment utiliser gdk_draw_text () afin d'afficher un texte (hello world par ex) au milieu de la fenêtre ?

gdk_draw_text est obsolète, il faut utiliser gdk_draw_layout (ok ça t'aide pas des masse :( mais je vais essayer de regarder ça pendant le week-end ;))
04/08/2006, 18h20
tintin72

Citation:

mais je vais essayer de regarder ça pendant le week-end

Super sympa, merci :D

Aprés avoir fouillé un peu partout sur le net je suis arrivé à enfin affiché quelque chose comme ceci:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
void refresh_cb(GtkWidget *draw_area, gpointer data)
{
   if (pixmap == NULL)
   {
    pixmap = gdk_pixmap_new(draw_area->window, WIDTH, HEIGHT, -1);
    gdk_draw_rectangle(pixmap, draw_area->style->white_gc, TRUE, 0, 0, WIDTH, HEIGHT);
   }
   gdk_draw_pixmap(draw_area->window, draw_area->style->black_gc, pixmap, 0,0,0,0, WIDTH, HEIGHT); 
 
   GdkGC *gc = gdk_gc_new(pixmap); //créé un contexte graphique
   PangoLayout *layout = gtk_widget_create_pango_layout (draw_area, "Hello World!!");
   gdk_draw_layout(pixmap, gc, 20, 20, layout);
}

Je suis également arrivé à afficher des valeurs d'entier avec sprintf comme ceci:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
#define HFONT 15
 
void refresh_cb(GtkWidget *draw_area, gpointer data)
{
   char txtLnBuf[512];
   int i;
 
   if (pixmap == NULL)
   {
    pixmap = gdk_pixmap_new(draw_area->window, WIDTH, HEIGHT, -1);
    gdk_draw_rectangle(pixmap, draw_area->style->white_gc, TRUE, 0, 0, WIDTH, HEIGHT);
   }
   gdk_draw_pixmap(draw_area->window, draw_area->style->black_gc, pixmap, 0,0,0,0, WIDTH, HEIGHT); 
   GdkGC *gc = gdk_gc_new(pixmap); //créé un contexte graphique
   PangoLayout *layout = gtk_widget_create_pango_layout (draw_area, txtLnBuf);
   for(i = 0; i < 10; i++)
   {
    sprintf(txtLnBuf, "Hello line : %d", i);
    pango_layout_set_text(layout, txtLnBuf, strlen(txtLnBuf)+1);
    gdk_draw_layout(pixmap, gc, 20, i * HFONT, layout);
   }
}

par contre j'ai un pb incompréhensible lorsque je passe une valeur à la fonction refresh_cb via le pointeur sur void.
voici un exemple simple:

dans le main

Code:

1
2
3
4
 
   int leTest = 39;
   code......
   g_signal_connect(G_OBJECT(pDrawArea),"event",G_CALLBACK(refresh_cb), &leTest);

puis dans refresh_cb

Code:

1
2
3
4
5
6
7
8
9
 
  int *pInt = (int*)data; //recupère le pointeur en le castant
  code.....
 
  GdkGC *gc = gdk_gc_new(pixmap); //créé un contexte graphique
   PangoLayout *layout = gtk_widget_create_pango_layout (draw_area, txtLnBuf);
   sprintf(txtLnBuf, "Hello line : %d", *pInt);
   pango_layout_set_text(layout, txtLnBuf, strlen(txtLnBuf)+1);
   gdk_draw_layout(pixmap, gc, 20, 20, layout);

et là, à la place du chiffre attendu j'ai une espèce de gribouilli (comme des nombre superposés), et je n'arrive vraiment pas à comprendre (le passage de pointeur est pourtant correctement effectué).
peut être est ce que je fais une mauvaise utilisation des fonctions de dessin ?

Voilà ce que j'ai fait pour afficher du texte (version minimale) :

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
#include <pango/pango.h>
#include <gtk/gtk.h>
 
void cb_expose_event (GtkWidget *, gpointer);
 
int main (int argc, char **argv)
{
  GtkWidget *p_main_window = NULL;
 
  gtk_init (&argc, &argv);
  p_main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  {
    GtkWidget *p_drawing_area = NULL;
 
    p_drawing_area = gtk_drawing_area_new ();
    g_signal_connect (G_OBJECT (p_drawing_area), "expose_event",
                      G_CALLBACK (cb_expose_event), NULL);
    gtk_container_add (GTK_CONTAINER (p_main_window), p_drawing_area);
  }
  gtk_widget_show_all (p_main_window);
  gtk_main ();
  return 0;
}
 
void cb_expose_event (GtkWidget *p_widget, gpointer user_data)
{
  PangoContext *p_context = NULL;
  PangoLayout *p_layout = NULL;
 
  p_context = gtk_widget_get_pango_context (p_widget);
  p_layout = pango_layout_new (p_context);
  pango_layout_set_text (p_layout, "Hello World !", -1);
  gdk_draw_layout (p_widget->window,
                   p_widget->style->fg_gc[GTK_WIDGET_STATE (p_widget)],
                   0,
                   0,
                   p_layout);
  g_object_unref (p_layout);
 
  (void)user_data;
}

Citation:

Envoyé par tintin72

Code:

1
2
3
4
 
   int leTest = 39;
   code......
   g_signal_connect(G_OBJECT(pDrawArea),"event",G_CALLBACK(refresh_cb), &leTest);

Passer un pointeur sur une varaible locale n'est pas forcement une bonne idée, si tu fais :

Code:

1
2
3
4
5
6
7
8
9
10
11
int main (void)
{
[...]
  {
    int leTest = 39;
 
    g_signal_connect(G_OBJECT(pDrawArea),"event",G_CALLBACK(refresh_cb), &leTest);
  }
  gtk_main ();
  return 0;
}

je ne pense pas que cela fonctionne (la variable étant détruite lors de l'appel à gtk_main).

07/08/2006, 12h45
tintin72
Merci pour ton code :D

Effectivement il est beaucoup plus conforme à l'exemple du gtk reference manual.

nb: toutefois il ne faut pas oublier de mettre dans le main
Code:

1 2 g_signal_connect(G_OBJECT(p_main_window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
sans quoi la fenêtre se ferme mais l'application continue de tourner ;)

Citation:

Passer un pointeur sur une varaible locale n'est pas forcement une bonne idée

J'ai essayé la même chose en déclarant leTest en variable globale mais ça ne marche pas mieux.

Citation:

je ne pense pas que cela fonctionne (la varaible étant détruite lors de l'appel à gtk_main).

si l'appel à gtk_main détruit les variables passées en paramètre, je ne comprend pas l'utilité du dernier argument de g_signal_connect().
En effet, le mécanisme censé passer des données utilisateur devrait permettre de passer tout ce qu'on veut (c'est le cas avec d'autres toolkit).
Peut être GTK a-t-il une autre philosophie du passage de données utilisateur ?
07/08/2006, 12h55
gege2061

Citation:

Envoyé par tintin72

si l'appel à gtk_main détruit les variables passées en paramètre, je ne comprend pas l'utilité du dernier argument de g_signal_connect().
En effet, le mécanisme censé passer des données utilisateur devrait permettre de passer tout ce qu'on veut (c'est le cas avec d'autres toolkit).
Peut être GTK a-t-il une autre philosophie du passage de données utilisateur ?

non je me suis mal exprimé, désolé :oops: La variable est détruite automatiquemebt avant l'appel à gtk_main.
07/08/2006, 13h26
tintin72

Citation:

non je me suis mal exprimé, désolé La variable est détruite automatiquemebt avant l'appel à gtk_main.

remarques ça ne change pas grand chose à mon pb ;)
Il faut que je me renseigne comment passer des données utilisateur sous GTK et qu'est ce qu'il est réellement possible de passer comme données. Si tu dis que les variables sont automatiquement détruite avant l'appel à gtk_main, ça limite drôlement les possibilités.... Bizzare tout cà!

Citation:

Envoyé par tintin72

remarques ça ne change pas grand chose à mon pb ;)
Il faut que je me renseigne comment passer des données utilisateur sous GTK et qu'est ce qu'il est réellement possible de passer comme données. Si tu dis que les variables sont automatiquement détruite avant l'appel à gtk_main, ça limite drôlement les possibilités.... Bizzare tout cà!

Tu n'as pas bien compris le code :fou:

La portée des variables automatiques se limite au bloc (délimité dans des accolades) dans lequel elles sont déclarées, donc dans le code précédent :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 int main (void) { [...] { int leTest = 39; g_signal_connect(G_OBJECT(pDrawArea),"event",G_CALLBACK(refresh_cb), &leTest); } /* Ici leTest n'existe plus puisque l'on ai sortie du bloc */ gtk_main (); return 0; }
C'est un peu tordu mais faut y penser puisque pour le compilateur il y a pas de problème !

Bon j'ai repris le code en affichant l'adresse de la varaible passée en paramètre à la fonction callback :
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 #include <pango/pango.h> #include <gtk/gtk.h> void cb_expose_event (GtkWidget *, gpointer); int main (int argc, char **argv) { GtkWidget *p_main_window = NULL; gint i = 102; gtk_init (&argc, &argv); p_main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); { GtkWidget *p_drawing_area = NULL; p_drawing_area = gtk_drawing_area_new (); printf ("%p\n", (void *)&i); g_signal_connect (G_OBJECT (p_drawing_area), "expose_event", G_CALLBACK (cb_expose_event), (gpointer)&i); gtk_container_add (GTK_CONTAINER (p_main_window), p_drawing_area); } gtk_widget_show_all (p_main_window); gtk_main (); return 0; } void cb_expose_event (GtkWidget *p_widget, gpointer user_data) { PangoContext *p_context = NULL; PangoLayout *p_layout = NULL; gchar text[BUFSIZ]; gint *p_i = user_data; p_context = gtk_widget_get_pango_context (p_widget); p_layout = pango_layout_new (p_context); printf ("%p\n", (void *)p_i); sprintf (text, "Hello World : |%d|", *p_i); pango_layout_set_text (p_layout, text, -1); gdk_draw_layout (p_widget->window, p_widget->style->fg_gc[GTK_WIDGET_STATE (p_widget)], 0, 0, p_layout); g_object_unref (p_layout); (void)user_data; }
Et à l'exécution :
Code:

1 2 3 gege2061@debian:~/Projects/gtk_text$ gcc-ansi `pkg-config --cflags --libs gtk+-2.0` *.c && ./a.out 0xbf841158 0xbf840f30
8O

Citation:

La portée des variables automatiques se limite au bloc (délimité dans des accolades) dans lequel elles sont déclarées

J'ai déclaré la variable dans le main, donc à moins qu'on quitte l'application la variable est toujours valide.
Si on reprend tout depuis le début, dans un prog console hyper basic comme ça tout fonctionne normalement:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 void passArg(void *data) { int *pInt = (int*)data; char buff[25]; sprintf(buff, "passArg! %d\n", *pInt); printf("%s\n", buff); } int main() { int nTest = 96; passArg(&nTest); return 0; }
passArg retourne bien la valeur attendue.
C'est pour ça que je comprend pas bien d'ou vient le pb avec GTK.

Citation:

Bon j'ai repris le code en affichant l'adresse de la varaible passée en paramètre à la fonction callback :

Je ne sais pas si on a le même résultat, mais en compilant ton code moi j'ai:
Hello World : |2|
ça ne me surprend pas car j'ai eu le même résultat lors de mes derniers essaies. 2 doit peut être correspondre à la taille du pointeur ou kek chose dans le genre.
Mystère! :?

08/08/2006, 10h40
tintin72
J'ai la solution enfin! (un grand merci à Teuf ;) )
En fait c'est le prototype de cb_expose_event qui n'est pas bon.
Il faut faire:
Code:

1 2 static void cb_expose_event (GtkWidget *p_widget, GdkEventExpose *event, gpointer user_data);
et là ça marche!!!

Mais bon, si on me l'avait pas dit j'aurais jamais trouvé ;) .
En effet, dans tous les topics et les manuels de référence que j'ai parcouru, le prototype d'une fonction callback est invariablement le même:
Code:

1 2 void fonction(GtkWidget *p, gpointer data);
Je croyais même (d'aprés ce que j'ai lu ici et là) qu'une fonction callback ne pouvait accepter que 2 arguments maximum.
Apparement c'est faux.
Maintenant reste à trouver un bon tuto/article qui expliquerait clairement le fonctionnement des fonctions callback dans GTK ainsi que les divers prototypes possibles.
Il faut aussi que je me renseigne sur GdkEventExpose.
De quel type s'agit-il et pourquoi est-il nécessaire pour le passage de données utilisateur.
08/08/2006, 11h39
gege2061
Citation:
Envoyé par tintin72

En fait c'est le prototype de cb_expose_event qui n'est pas bon.
Il faut faire:

Code:

1 2 static void cb_expose_event (GtkWidget *p_widget, GdkEventExpose *event, gpointer user_data);

et là ça marche!!!

Mais bon, si on me l'avait pas dit j'aurais jamais trouvé ;) .
En effet, dans tous les topics et les manuels de référence que j'ai parcouru, le prototype d'une fonction callback est invariablement le même:

Code:

1 2 void fonction(GtkWidget *p, gpointer data);

Je croyais même (d'aprés ce que j'ai lu ici et là) qu'une fonction callback ne pouvait accepter que 2 arguments maximum.
Apparement c'est faux.
Non ils sont de la forme :
Code:

1 2 3 return_type callback (gpointer data1, [param_types param_names,] gpointer data2);
Mais le plus souvent c'est la version à deux paramètres qui est utilisée.

Citation:

Envoyé par tintin72

Maintenant reste à trouver un bon tuto/article qui expliquerait clairement le fonctionnement des fonctions callback dans GTK ainsi que les divers prototypes possibles.

La documentation de référence : The "expose-event" signal (j'ai dû louper mon copier/coller :oops:)

Citation:

Envoyé par tintin72

Il faut aussi que je me renseigne sur GdkEventExpose.
De quel type s'agit-il et pourquoi est-il nécessaire pour le passage de données utilisateur.

C'est le plus difficile : savoir à quoi correspond les paramètres optionnels des fonctions callback (ils ne sont généralement pas documentés :()
Bon ici ça va tu reçoi une structure de type GdkEventExpose qui t'informe sur la zone qui a demandé un rafraississement.
01/05/2007, 12h02
tomtom750

Bonjour,

Je souhaitais juste savoir comment ecrire le texte "Hello Word" en blanc...merci bcp