Récupérer le text d'un label situé dans un eventbox

**rollbich** · 31/08/2013, 18h56

bonjour,

J'ai placé un label dans un eventbox. Quand je clique dessus, je voudrais récupérer le widget label. Comment faire car dans le callback on récupère l'eventbox ??? J'ai pas réussi à trouver de tuto ni en francais ni en anglais sur google.

Code :

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

1
2
3
4
5
6
7
static gboolean on_eventbox_label_press_event_cb (GtkWidget *eventbox, GdkEvent  *event, gpointer data) {
    gchar texte[5];
    //GtkWidget *lab = le label situé dans l'eventbox
    g_sprintf(texte, "%s", gtk_label_get_text(GTK_LABEL(lab)));
    g_print("texte: %s", texte);
    return TRUE;
}

Merci d'avance pour vos réponses.

**cueffic** · 31/08/2013, 22h56

Il y a get_child() mais je ne sais pas si ça fonctionne. A tester

**rollbich** · 31/08/2013, 23h11

ah oui !!!
car eventbox est un gtkContainer.

Merci bien, j'avais pas pensé à chercher de ce coté là.
Je vais tester ça.

**rollbich** · 01/09/2013, 12h41

J'ai pas réussi mais j'ai fait autrement, il suffit de mettre le label en paramètre dans le callback.

Code :

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

g_signal_connect (G_OBJECT(event_box), "button_press_event", G_CALLBACK(on_tw_cfl_label_press_event_cb), label);

Code :

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

1
2
3
4
5
6
7
static gboolean on_tw_cfl_label_press_event_cb (GtkWidget *eventbox, GdkEvent  *event, gpointer data) {
    GtkWidget *lab = data;
    gchar texte[5];
    g_sprintf(texte, "%s", gtk_label_get_text(GTK_LABEL(lab)));
    g_print("texte: %s", texte);
    return TRUE;
}

**liberforce** · 01/09/2013, 19h03

Utilise plutôt g_signal_connect_swapped, qui inverse le premier paramètre avec user_data lors de l'appel de la calllback. En général on fait en sorte que l'objet qui est le "héros" de l'action soit le premier paramètre.

Autre chose, 'utilisation de g_sprintf avec un buffer de taille fixe n'est pas très heureuse non plus, gtk_label_get_text te renvoie un const gchar * que tu peux utiliser directement. Là ton code pète s'il y a plus de 4 caractères dans le label.

**rollbich** · 01/09/2013, 23h55

Merci pour tes remarques.

C'est noté pour le signal swapped.
Pour le label, il est prédéfini par moi et donc ne peut excéder 3 caractères. Du coup, j'ai pensé ne pas avoir besoin de faire plus.

Je réouvre le sujet car au final, j'ai besoin de récupérer mon label situé dans l'eventbox.
J'ai essayé :

Code :

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

1
2
3
4
GtkWidget *child;
child = gtk_container_get_children(eventbox);
gchar texte[5];
g_sprintf(texte, "%s", gtk_label_get_text(GTK_LABEL(child)));

J'ai le message d'erreur suivant :
GLib-GObject-WARNING **: invalid uninstantiable type '(null)' in cast to 'GtkLabel'

On dirait donc que mon eventbox est vide ??? Pourtant non, voir le code suivant

code en entier pour ceux qui veulent le compiler :

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
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
#include <gtk/gtk.h>
#include <stdlib.h>
// convertit un int en string
int int_to_str(int value, char *buf, unsigned int len) {
	unsigned result = 0;
	if (!buf) return -1;
#define ADDCHAR(chr) \
	if (result < len - 1) \
	{ \
		*buf++ = (chr); \
		result++; \
	}
	int j = 0;
	char int_to_str[16];
	if (value < 0) ADDCHAR('-');
	char *ptr = int_to_str + sizeof(int_to_str) - 1;
	do {
		int modulo = value % 10;
		modulo = (modulo<0)?-modulo:modulo;
		*ptr-- =  modulo + '0';
		value /= 10;
		j++;
	} while (value);
 
	for (; j > 0; j--) ADDCHAR(int_to_str[sizeof(int_to_str) - j]);
	*buf = '\0';
	return 0;
}
 
typedef struct {
    double cfl;
    char *callsign;
} s_plane;
 
static gboolean on_cfl_label_press_event_cb (GtkWidget *eventbox, GdkEvent  *event, gpointer data) {
    GtkWidget *label = data;
    gchar texte[5];
    GtkWidget *child;
    child = gtk_container_get_children(eventbox);
    g_sprintf(texte, "%s", gtk_label_get_text(GTK_LABEL(child)));
    g_print("CFL: %s\n", texte);
    return TRUE;
}
 
int main(int argc, char *argv[])
{
    GtkWidget *window, *scr_win, *grid;
    s_plane *plane;
    plane->cfl = 320.0;
    plane->callsign = "BAW4237";
    gtk_init(&argc, &argv);
 
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(window), 150, 150);
    gtk_window_set_title(GTK_WINDOW(window), "Test");
 
    grid = gtk_grid_new();
    int i, j;
    j=0;
    GtkWidget *label[12], *event_box[12];
    char *str_lab = malloc(sizeof(char[5]));
 
    for (i=650; i>410; i=i-20) {
        int_to_str(i, str_lab, 4);
        label[j] = gtk_label_new(str_lab);
        gtk_widget_set_size_request(label[j], 100, 14);
        event_box[j] = gtk_event_box_new();
        gtk_container_add(GTK_CONTAINER(event_box[j]), label[j]);
        gtk_grid_attach(GTK_GRID (grid), event_box[j], 0, j, 1, 1);
        g_signal_connect (G_OBJECT(event_box[j]), "button_press_event", G_CALLBACK(on_cfl_label_press_event_cb), label[j]);
        j++;
    }
 
    free(str_lab);
    scr_win = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scr_win), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
    gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW (scr_win), grid);
    gtk_container_add(GTK_CONTAINER(window), scr_win);
 
    g_signal_connect_swapped(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), G_OBJECT(window));
 
    gtk_widget_show_all(window);
    gtk_main();
    return 0;
}

**liberforce** · 02/09/2013, 03h18

Envoyé par rollbich

Pour le label, il est prédéfini par moi et donc ne peut excéder 3 caractères. Du coup, j'ai pensé ne pas avoir besoin de faire plus.

Une bonne pratique est de prévoir le changement dans ton code. Imagine que toi, ou quelqu'un qui reprend un programme écrit par toi, décide à un moment de changer le texte. Ton programme crashera, car tu seras parti sur un postulat qui est vrai à un instant t mais qui peut changer un jour. En plus, là ça te prends moins de code de faire ça bien. De même, toutes les fonctions de type sprintf sont à proscrire, car elles sont vecteur de failles de sécurité (risque de buffer overflow). Pour éviter cela on utilise les varaintes avec un n, comme snprintf, qui permettent d'indiquer la taille max du buffer, pour éviter de se retrouver avec un buffer qui ne se finit pas par un caractère nul.

Envoyé par rollbich

Je réouvre le sujet car au final, j'ai besoin de récupérer mon label situé dans l'eventbox.
J'ai essayé :

Code :

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

1
2
3
4
GtkWidget *child;
child = gtk_container_get_children(eventbox);
gchar texte[5];
g_sprintf(texte, "%s", gtk_label_get_text(GTK_LABEL(child)));

J'ai le message d'erreur suivant :
GLib-GObject-WARNING **: invalid uninstantiable type '(null)' in cast to 'GtkLabel'

On dirait donc que mon eventbox est vide ??? Pourtant non, voir le code suivant

Non, en fait, tu commets plusieurs erreurs:
tu ne compiles pas avec le flag -Wall qui active tous les warnings classiques, sinon tu aurais vu que tu as des problèmes de conversion de type. En particulier, tu aurais vu que gtk_container_get_children renvoie un GList * (une liste d'éléments), pas un GtkWidget *.
Tu peux faire ça proprement avec:

Code :

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

1
2
3
4
5
6
7
8
9
 
    GtkWidget *child = NULL;
    GList *list = gtk_container_get_children(GTK_CONTAINER(eventbox));
    g_assert (list != NULL);
    child = list->data;
    g_assert (child != NULL);
    g_list_free (list);
 
    g_print("CFL: %s\n", gtk_label_get_text(GTK_LABEL(child)));

Ensuite, ton code compile mais ne s'exécute pas, tu as une erreur dans les premières lignes du main:

Code :

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

1
2
3
4
 
 s_plane *plane;
 plane->cfl = 320.0;
 plane->callsign = "BAW4237"

plane est un pointeur, mais tu ne lui as pas alloué de mémoire. Soit tu fais un malloc, soit tu utilises une structure allouée dans la pile à la place.

Tu utilises aussi g_sprintf, mais tu n'as pas l'include correspondant (voir les première lignes de la page d'aide de cette fonction). Il te faut un #include <glib/gprintf.h> pour l'utiliser. Mais comme je te l'ai dit, mieux vaut t'en passer.

**rollbich** · 02/09/2013, 12h22

Merci bien Liberforce, tu me tires une bonne épine du pied !

tu ne compiles pas avec le flag -Wall qui active tous les warnings classiques

Va falloir que je règle mon code blocks.
Le pire, c'est que je m'étais aperçu que ça renvoyait une Glist et puis hier soir en recodant j'ai oublié.
J'avais d'ailleurs essayé y'a 2 jours d'utiliser

Code :

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

g_list_first(list);

pour récupérer le label et j'avais la même erreur de cast dans le label.
J'ai regardé la doc mais je ne comprends pas la différence entre g_list_first et ton code list->data qui bien évidemment fonctionne parfaitement.

plane est un pointeur, mais tu ne lui as pas alloué de mémoire.

Je crois que j'ai pas bien compris un truc.
Quand tu déclares GtkWidget *child = NULL; pourquoi tu n'as pas fait un malloc ? Pourtant il ne connait pas la taille du widget ?

Quelle est la différence entre GtkWidget *child = NULL; et GtkWidget *child; ??

**pvincent** · 02/09/2013, 14h45

Je mets mon grain de sel.

GList est une structure qui contient un pointeur vers les données (data) et des pointeurs pour se déplacer le long de la liste (voir la doc).

g_list_first() retourne un pointeur vers le premier élément de la liste, c'est à dire vers une structure GList: ça sert à se repositionner au début de la liste, mais ça ne retourne pas les données.

Le = NULL utilisé à la déclaration d'un pointeur permet d'être sûr que si on emploi ce pointeur sans lui avoir donner de valeur, le programme va planter: sinon, il prend une valeur aléatoire qui peut donner des erreurs difficiles à détecter.
Pour ce qui est du malloc(), celui-ci n'est utile que si le pointeur est utilisé sur une nouvelle zone mémoire: dans le cas examiné ici, c'est à la création du widget que la zone a été réservée, il ne faut donc pas en réserver une nouvelle.

J'espère que je suis assez clair.

**rollbich** · 02/09/2013, 16h03

pvincent, sache que tout grain de sel est le bienvenu !

J'ai compris pour la Glist ainsi que pour la déclaration de pointeur avec NULL. Merci !

Désolé, mais c'est pas bien clair pour moi cette histoire de malloc.

Pour ce qui est du malloc(), celui-ci n'est utile que si le pointeur est utilisé sur une nouvelle zone mémoire

tu pourrais me donner un exemple ?

dans le cas examiné ici, c'est à la création du widget que la zone a été réservée

Je comprends ici que pour les widgets, j'ai pas besoin de malloc mais si c'est une structure perso comme s_plane dans mon cas, j'ai besoin d'utiliser malloc ?

edit : Par exemple dans mon code, si au lieu de déclarer char texte[5]; je faisais char *texte = NULL; dois-je faire un malloc ou pas ?

Liberforce's quote
Soit tu fais un malloc, soit tu utilises une structure allouée dans la pile à la place.

Je vais jeter un oeil à "structure allouée dans la pile" car je ne connais pas et le peu que j'ai cherché n'est pas bien clair quand à son utilisation précise. Si tu as un exemple ?

**pvincent** · 02/09/2013, 19h21

Quand tu déclare:

Code :

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

s_plane plan;

le compilateur réserve suffisamment de place dans la pile pour stocker la structure, mais quand tu déclare

Code :

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

s_plane * plan;

seule, la place pour le pointeur est allouée par le compilateur, pas celle pour l'objet pointé. D'ailleurs, il y a souvent plus d'une variable qui pointe sur la même zone mémoire.
Donc quand tu écrit char texte[5], le compilateur réserve une zone de 5*size_t de long, mais elle ne peut pas varier au cours de l''exécution.
Quand tu écrit char *texte, seule la place pour un pointeur est réservée par le compilateur, d'où la nécessité du malloc() qui te permet d'ajuster la taille réservée à tes besoins, et éventuellement de la modifier ensuite avec realloc().

**rollbich** · 02/09/2013, 21h27

Merci pour tes explications, je pense avoir compris et je suis bien content car c'est quand même une base importante.

GtkWidget *child = NULL;
GList *list = gtk_container_get_children(GTK_CONTAINER(eventbox));
g_assert (list != NULL);
child = list->data;

ici, child pointe vers une zone mémoire déjà allouée puisque list->data pointe vers cette zone mémoire. C'est pour cela qu'on a pas besoin de malloc.
C'est ça ?

char *texte;
g_sprintf(texte, "%s", gtk_label_get_text(GTK_LABEL(child)));

ici, texte ne pointe vers rien et c'est g_sprintf qui va remplir pour la 1ere fois la zone mémoire donc il faut la réserver avec malloc
C'est ça ?

Quelle différence y-a-t-il entre

Code :

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

gchar *texte = malloc(sizeof(char[5]));

et

Code :

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

1
2
gchar *texte = NULL;
texte = malloc(sizeof(char[5]));

**liberforce** · 03/09/2013, 01h17

Envoyé par rollbich

ici, child pointe vers une zone mémoire déjà allouée puisque list->data pointe vers cette zone mémoire. C'est pour cela qu'on a pas besoin de malloc.
C'est ça ?

C'est bien ça.

Envoyé par rollbich

ici, texte ne pointe vers rien et c'est g_sprintf qui va remplir pour la 1ere fois la zone mémoire donc il faut la réserver avec malloc
C'est ça ?

En fait, pour écrire dans une zone mémoire via un pointeur, il faut que ton pointeur pointe vers une zone mémoire valide. Avec un pointeur non initialisé, tu peux avoir n'importe quoi (tous les compilateurs ne te garantissent pas d'initialiser les pointeurs à NULL) et en général un crash. Si ton pointeur vaut NULL, tu auras un crash à coup sûr. Donc soit texte doit pointer vers une zone mémoire déjà allouée, ou alors tu dois en allouer une nouvelle. Si tu as des questions sur les pointeurs, pose tes questions dans la section "C" du forum, là on s'éloigne de GTK.

Envoyé par rollbich

Quelle différence y-a-t-il entre

Code :

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

gchar *texte = malloc(sizeof(char[5]));

et

Code :

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

1
2
gchar *texte = NULL;
texte = malloc(sizeof(char[5]));

Fonctionnellement, tu ne verras pas de différence. C'est si tu insères du code entre la déclaration et l'allocation que cela peut être plus judicieux d'initialiser ton pointeur à NULL au départ, juste pour être sûr de provoquer un crash si on tente de l'utiliser. Si ces deux lignes sont séparées par de nombreuses lignes de code, il peu y avoir un risque. Sur 5 lignes de code, ce n'est sans doute pas nécessaire de l'initialiser, mais quand tu apprends à maîtriser les pointeurs, c'est une bonne habitude à prendre.

Au fait, ta variante compile ? Perso j'écris plutôt ça:

Code :

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

gchar * texte = malloc (sizeof(char) * 5);

Et pour en apprendre plus sur les pointeurs:
[ame="http://www.youtube.com/watch?v=5VnDaHBi8dM"]http://www.youtube.com/watch?v=5VnDaHBi8dM[/ame]

**rollbich** · 03/09/2013, 16h28

Merci, la vidéo est parfaitement claire.

Juste une dernière question :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#include <gtk/gtk.h>
 
int main( int argc, char *argv[])
{
  GtkWidget *window;
  gtk_init(&argc, &argv);
  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_widget_show(window);
  gtk_main();
  return 0;
}

Dans ce code, on a pas alloué de mémoire au widget fenêtre donc window ne pointe nulle part. Pourquoi y'a pas d'allocation avec malloc dans ce cas ? Et surtout comment connaître la taille à l'avance du widget ?
Je suppose que gtk gère ça tout seul ??

Oui la prochaine fois, j'ouvrirai un thread sur le forum c.

Un grand merci en tout cas.

**rollbich** · 03/09/2013, 22h04

J'ai trouvé la réponse dans "Introduction to memory Management in GTK+" by Stewart Weiss. Je crois que ça va être mon livre de chevet ce soir...

Code :

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

1
2
GtkWidget *button;
button = gtk_button_new();

The storage for the button is created by GTK+ and a pointer to it is returned by gtk_button_new().

bonne soirée à tous

Récupérer le text d'un label situé dans un eventbox

GTK+ avec C & C++

Discussions similaires

Partager

Partager