dérréférencement d'un pointeu << void * >>

Version imprimable

09/02/2007, 05h41
echantillon

dérréférencement d'un pointeu << void * >>
Bonjour,

J'ai un problème lors du traitement du deuxième paramètre passé a une fonction callback.

Une structure chaînable me sert à créer une chaîne d'eventbox contenant des labels.
J'insère au moment de leur initialisation les eventbox dans une vbox, et j' obtient une liste de labels cliquables.
Tout ça fonctionne au poil, mais lors-ce que je veux récupérer le label au clic de l'evenbox je reçoit un message que je n'arrive pas a résoudre :
pep.c: In function `ecouter':
pep.c:291: attention : déréférencement d'un pointeur « void * »
pep.c:291: erreur: requête du membre « label » dans quelque chose n'étant ni une structure ni une union

Ma structure :
Code:

1 2 3 4 5 6 7 typedef struct maillon { GtkWidget * label; GtkWidget * event; struct maillon * precedent; } maillon ;
Mon callback dans une fonction qui génère des nouveau maillon :
(un pointeur sur 'maillon' s'appelant 'nouveau' est initialisé et rempli)
Code:

1 2 g_signal_connect(G_OBJECT(nouveau->event), "button_press_event", G_CALLBACK(ecouter), nouveau);
et la fonction :
Code:

1 2 3 4 void ecouter (GtkEventBox *event, gpointer maillonclike) { if (gtk_label_get_label (GTK_LABEL (maillonclike->label)) == "test") printf ("ça fcontionne .. "); }
La fonction qui génère des nouveau maillon ne fait que les initialiser, les raccorder a la chaîne, et attacher le signale du clic sur l'eventbox a la fonction écouter.

L'appel a la fonction écouter fonctionne bien, je l'ai testé avec un simple printf("bonjour"), mais je n'arrive pas a aller plus loin.

Voilà, je ne sais pas si j'ai réussi à être clair en cette heure tardive (ou tôdive) mais à la demande je peux peut-être poster mon programme (300 lignes) .
En vous remerciant d'éventuelles réponses :°)
09/02/2007, 11h56
Franck.H
Rien de plus normal, tu utilises directement le pointeur dit "générique" de ton callback alors qu'il faut le récupérer par le biais d'un pointeur de son ton type d'origine pour pouvoir l'utiliser correctement car un pointeur de type void * ne peut être déréférencé !

Ce que tu doit faire:
Code:

1 2 3 4 5 6 void ecouter (GtkEventBox *event, gpointer maillonclike) { maillon * p = maillonclike; if (gtk_label_get_label (GTK_LABEL (p->label)) == "test") printf ("ça fcontionne .. "); }
Révise néanmoins un peu ton C car ce genre d'erreur ne devraient presque jamais arriver, sauf chez des débutants éventuellement ;)

Pour ton enregistrement du callback, cast le dernier argument, c'est mieux ainsi:
Code:

1 2 3 4 5 g_signal_connect ( G_OBJECT(nouveau->event), "button_press_event", G_CALLBACK(ecouter), (maillon *) nouveau );
Voilà, ceci devrait résoudre ton problème !
09/02/2007, 14h08
echantillon

bonjour, et merci pour la réponse.

Effectivement je débute encore, et j'ai perdu a l'esprit qu'un pointeur était typé.

En revanche je n'ai pas compris a quoi sert de caster le dernier argument.
Tu pourrais m'éclairer sur ce point ? Ou me donner a lire tout ce que tu veux sur le sujet ! ;°)

EDIT : arf, je me prend une erreur de segmentation..
09/02/2007, 14h22
Franck.H

Citation:

Envoyé par echantillon

En revanche je n'ai pas compris a quoi sert de caster le dernier argument.
Tu pourrais m'éclairer sur ce point ?

Heu désolé, je me suis trompé dans le cast, c'est ainsi:

Code:

(gpointer) nouveau

La fonction attendant un pointeur de type gpointer (un void * en réalité). Enfin bon, normalement on peut s'en passer du cast donc ce n'est pas obligatoire. Je me souviens un jour où je n'avais pas le choix, il fallait que je cast à la transmission de l'argument car sinon y'avais un bug énorme ...

Pour ton erreur de segmentation, il faudrait donner le code minimum et compilable pour mieux t'aider à moins que tu saches où se situe l'erreur !

Bon et bien, je me permet de poster le source complet.
Ca vous permettra de me disputer assez sur les blasphèmes commis, que je ne recommence plus jamais. (si vous avez l'envie, au passage :°) )

J'ai volontairement délaisser pleins de choses, comme la gestion de la mémoire, les couleurs par ci par là au pifomètre (tiens, firefox connaît !) .. enfin c'est brouillon quoi!

Il s'agit a la base d'une IG pour ceci. :°)
Le fil est assez sympathique et fait preuve d'un bon esprit libre.
Sinon ah oui, le 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
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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
/* Ligne de compilation :                            gcc -o pep pep.c `pkg-config --cflags --libs gtk+-2.0`
 
 
Détails des fonctions et de leurs appels :
 
 
Fonction principale.    (main)
    Afficher la liste des radios.    (afficher_liste)
        Créer une liste chainée de label + dans eventbox + Psuivant.    (genese)
            Remplir le label avec le nom de la radio.    (scsv)
        Ecouter la sélection en quittant la fenêtre de liste.    (ecouter)
            Retrouver l'adresse de la radio en fonction de son nom.    (scsv)
 
 
 
 
main  ->  afficher_liste  ->  ecouter
                  genese              scsv
                    scsv
 
 
 
*/
 
 
#include <stdio.h>
#include <gtk/gtk.h>
#include <stdlib.h>
 
 
GtkWidget *label;    // Le label, dans lequel on fera défiler du texte :)
 
 
 
typedef struct csv 
{ 
char *radio; 
char *http; 
} csv ;
 
typedef struct maillon
{ 
GtkWidget * label; 
GtkWidget * event;
struct maillon * precedent; 
} maillon ;
 
 
 
struct csv * scsv (int i, struct csv * donnee);
void afficher_liste (GtkToggleButton *bouton, gpointer data);
void genese (maillon * Pcourant, int a, GtkWidget * vbox);
void ecouter (GtkEventBox *event, gpointer maillonclike);
 
int main(int argc, char *argv[]) {
 
    GtkWidget *pep;    // La fenêtre principale.
       GtkWidget *Vbox;    // La vbox principale. Elle contient l'interface, et déroule la liste de lecture.
          GtkWidget *hbox;    // La box qui contient l'interface et la vbox des boutons.
             GtkWidget *vbox;    // La box qui contient les deux boutons.
                GtkWidget *lecture_pause;    // Bouton pour mettre en lecture/pause.
                GtkWidget *fermer;    // Bouton pour fermer l'interface.
          GtkWidget *bouton;    // L'interface.
 
 
    GdkColor color;    // Une structure qui permet de modifier les couleures des widgets.
 
    gtk_init(&argc,&argv);
 
    // Fenêtre.
        pep = gtk_window_new(GTK_WINDOW_TOPLEVEL);    // Création de la fenêtre.
        gtk_window_set_title (GTK_WINDOW(pep), "pep");    // Son titre. 
        gtk_window_set_default_size(GTK_WINDOW(pep), 300,20);    // Sa taille.
        gtk_window_set_position(GTK_WINDOW(pep), GTK_WIN_POS_CENTER);    // Son positionnement au centre de l'écran.
        gtk_window_set_decorated (GTK_WINDOW (pep), FALSE);    // Je lui enlève la décoration.
 
    // Vbox.
        Vbox = gtk_vbox_new(FALSE,0);
        gtk_container_add(GTK_CONTAINER(pep), Vbox);
 
    // hBox.
        hbox = gtk_hbox_new(FALSE, 0);    
        gtk_box_pack_start(GTK_BOX(Vbox), GTK_WIDGET(hbox), TRUE, TRUE, 0);
 
    // vBox.
        vbox = gtk_vbox_new(FALSE, 0);
        gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox), TRUE, TRUE, 0);
 
    // Bouton principal.
        bouton = gtk_toggle_button_new ();
        gtk_widget_set_size_request (bouton, 280, 26);
        gtk_box_pack_start (GTK_BOX (hbox), bouton, TRUE, TRUE, 0);
        // Couleures :    normale = noir
            color.pixel = 32;    color.red = 0;    color.green = 0;    color.blue = 0;
            gtk_widget_modify_bg (GTK_WIDGET(bouton), GTK_STATE_NORMAL, &color);
            color.red = 3000;    color.green = 6000;    color.blue = 8000;
            gtk_widget_modify_bg (GTK_WIDGET(bouton), GTK_STATE_PRELIGHT, &color);
            color.red = 2000;    color.green = 5000;    color.blue = 5000;
            gtk_widget_modify_bg (GTK_WIDGET(bouton), GTK_STATE_ACTIVE, &color);
        // Label.
            label = gtk_label_new (NULL);
            gtk_container_add (GTK_CONTAINER (bouton), label);
            gtk_widget_set_size_request (label, 250, 20);
                // Couleure :    bleu
                    gtk_label_set_markup(GTK_LABEL(label), "<span foreground=\"#7eacdc\"> Tiens, ça fonctionne !? :))) </span>");
 
    // Bouton fermer.
        fermer = gtk_button_new();   
        gtk_widget_set_size_request (fermer, 20, 13);
        gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(fermer), FALSE, TRUE, 0);
        // Couleures :    normal = noir    survol = rouge    clic = rouge foncé
            color.pixel = 32;    color.red = 15000;    color.green = 0;    color.blue = 0;
            gtk_widget_modify_bg (GTK_WIDGET(fermer), GTK_STATE_NORMAL, &color);
            color.red = 55000;    color.green = 0;    color.blue = 5000;
            gtk_widget_modify_bg (GTK_WIDGET(fermer), GTK_STATE_PRELIGHT, &color);
            color.red = 35000;    color.green = 0;    color.blue = 5000;
            gtk_widget_modify_bg (GTK_WIDGET(fermer), GTK_STATE_ACTIVE, &color);
 
    // Bouton lecture/pause.
        lecture_pause = gtk_button_new();   
        gtk_widget_set_size_request (lecture_pause, 20, 13);
        gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(lecture_pause), FALSE, TRUE, 0);
        // Couleures :    normal = noir    survol = cian    clic = bleu
            color.red = 0;    color.green = 5000;    color.blue = 20000;
            gtk_widget_modify_bg (GTK_WIDGET(lecture_pause), GTK_STATE_NORMAL, &color);
            color.red = 10000;    color.green = 30000;    color.blue = 60000;
            gtk_widget_modify_bg (GTK_WIDGET(lecture_pause), GTK_STATE_PRELIGHT, &color);
            color.red = 10000;    color.green = 20000;    color.blue = 40000;
            gtk_widget_modify_bg (GTK_WIDGET(lecture_pause), GTK_STATE_ACTIVE, &color);
 
    // Connection des signaux.    */
        g_signal_connect(G_OBJECT(fermer), "clicked", G_CALLBACK(gtk_main_quit), NULL);
        g_signal_connect(G_OBJECT(bouton), "clicked", G_CALLBACK(afficher_liste), Vbox);    // On fourni Vbox afin d'y insérer la liste.
 
    gtk_widget_show_all(pep);
    gtk_main();
    return 0;
}
 
 
 
 
// Fonction de traitement du csv.
struct csv * scsv (int i, struct csv * donnee) 
{
    FILE *f = fopen ("radios.csv","r");
    if (f == NULL) 
    {
        printf ("\nL'ouverture du fichier radios.csv m'a renvoyé une erreure\n Je dois me mettre fin. ;(");
        exit(EXIT_FAILURE);
    }
    // Aller jusqu'a la ligne 'i' et la mettre dans un buffer.
        char *buffer = malloc(300);
        if (buffer == NULL)
        {
            printf("\nMalloc m'a renvoyé une erreure.\n Je dois me mettre fin. ;(\n");
            free(buffer);
            exit(EXIT_FAILURE);
        }
        int a = 0;
        for (a = 0; a < i; a++) fgets(buffer, 300 +1, f);
    // Séparation des données dans la structure.
        donnee->radio = malloc (100);
        donnee->http = malloc (200);
        if ((donnee->radio == NULL) || (donnee->http == NULL))
        {
            printf("\nMalloc m'a renvoyé une erreure.\n Je dois me mettre fin. ;(\n");
            free(donnee->radio);
            free(donnee->http);
            exit(EXIT_FAILURE);
        }
        int b = 0;
        a = 0;
    /* http://forum.kubuntu-fr.org/viewtopic.php?pid=726987#p726987  
    merci gene69 et guyver2 d'avoir pallié cette nuit a mon esprit embrouillé  ;) */
        while ( (donnee->radio[a] = buffer[a ++]) && (buffer [a] != ';') );    donnee->radio[a] = '\0';    a++;
        while ( (donnee->http[b++] = buffer[a ++]) && (buffer [a] != ';') );    donnee->http[b] = '\0';
 
    free(buffer);
    fclose(f);    
    return donnee;
}
 
 
 
 
 
void afficher_liste (GtkToggleButton *boutton, gpointer Vbox)
{
    GtkWidget *event1;
       GtkWidget *scroll;
          GtkWidget *event;
             GtkWidget *vbox;
                                                                    /* affichage de la liste */
    // Scrollbar de la fenêtre.
        scroll = gtk_scrolled_window_new (NULL, NULL);
        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
        gtk_scrolled_window_set_placement (GTK_SCROLLED_WINDOW (scroll), GTK_CORNER_TOP_RIGHT);
        gtk_widget_set_size_request (scroll, 300, 500);
        gtk_box_pack_start(GTK_BOX(Vbox), GTK_WIDGET(scroll), TRUE, TRUE, 0);
 
    // Eventbox dans la Scrollbar.
        event = gtk_viewport_new (NULL, NULL);
        gtk_container_add (GTK_CONTAINER (scroll), event);
 
    // Vbox dans l'eventbox.
        vbox = gtk_vbox_new(FALSE,0);
        gtk_container_add (GTK_CONTAINER (event), vbox);
 
                                                           /* remplissage et création des signaux */
 
    // Remplissage de la la liste avec une chaine de pointeurs du structure eventbox+label. Les GtkTreeView c'est trop compliqué :)
        // Donc on evaluation d'abort le nombre de ligne du fichier radio.sh.
        int nb_lignes = 0;
        FILE *f = fopen ("radios.csv","r");
        if (f == NULL) 
        {
        printf ("\nL'ouverture du fichier radios.csv m'a renvoyé une erreure\n Je dois me mettre fin. ;(");
        exit(EXIT_FAILURE);
        }
        char c;
        while ( (c = fgetc (f)) != EOF)    if (c == '\n') nb_lignes ++;
        fclose (f);
        // Puis on rempli la vbox. (voir la fontion genese)
        maillon * tete = malloc(sizeof (maillon));    // Maillon de tête.
        maillon * Pcourant = malloc(sizeof (maillon));    // Pcourant sera notre pointeur courant dans la chaine.
        if ((tete == NULL) || (Pcourant == NULL))
        {
            printf("\nMalloc m'a renvoyé une erreure.\n Je dois me mettre fin. ;(\n");
            free(Pcourant);
            exit(EXIT_FAILURE);
        }
        tete->precedent = NULL;
        Pcourant = tete;
        int a = 0;
        // On appelle autant de fois la fonction 'genese' qu'il y a de ligne. 
        for (a =1; a<(nb_lignes+1); a++)    genese (Pcourant,a,vbox);
 
 
    gtk_widget_show_all (Vbox);    
}
 
 
 
 
 
 
void genese (maillon *Pcourant, int a, GtkWidget *vbox)
{ 
        // cette fonction créer des nouveau maillons, les initialise, connecte les signaux, et les ajoute dans la chaine.
 
// 1: CREATION
    csv * donnee = malloc (sizeof (csv));    // On utilise cette structure pour pouvoir faire appel a scsv.
    maillon * nouveau = malloc (sizeof (maillon));    // Le noueau maillon de la chaine.
    if ((donnee == NULL) || (nouveau == NULL))    // Gestion des erreures de malloc.
        {
            printf("\nMalloc m'a renvoyé une erreure.\n Je dois me mettre fin. ;(\n");
            free(donnee);
            free(nouveau);
            exit(EXIT_FAILURE);
        }
 
// 2 : INITIALISATION
    nouveau->event = gtk_event_box_new ();    // Initialisation de l'eventbox du nouveau maillon.
    gtk_box_pack_start (GTK_BOX (vbox), nouveau->event, TRUE, TRUE, 0);    // On la met dans la vbox de la liste.
 
    nouveau->label = gtk_label_new ( scsv(a,donnee)->radio );    // Initialisation du label du nouveau maillon, rempli avec scsv.
    gtk_misc_set_alignment (GTK_MISC (nouveau->label), 0, 0.5);
    gtk_widget_set_size_request (nouveau->label, -1, 20);    
    gtk_container_add (GTK_CONTAINER (nouveau->event), nouveau->label);    // Et on le met dans l'eventbox du nouveau maillon.
    // Reste a liberer l'espace que la fonction scsv c'est permise d'allouer :
    free (donnee->http);    free (donnee->radio);    free (donnee);
 
// 4 : CREATION DES SIGNAUX
    g_signal_connect(G_OBJECT(nouveau->event), "button_press_event", G_CALLBACK(ecouter), (gpointer) nouveau);
 
 
// 3 : AJOUT DANS LA CHAINE
    nouveau->precedent = Pcourant;    // On fait pointer le nouveau maillon sur le pointeur courant, qui pointe sur le maillon précédent.
    Pcourant = nouveau;    // On fait avancer le pointeur courant sur le nouveau maillon. Terminé !
 
}
 
 
void ecouter (GtkEventBox *event, gpointer maillonclike)
{
 
   maillon *p = maillonclike;
   if (gtk_label_get_label (GTK_LABEL (p->label)) == "France Inter") printf ("ça fcontionne .. ");
 
 
}

ouf !
Voilouche, si vous avez le temps de m'aider, me grogner.. ou de la doc à me faire dévorer sur les points que j'ai à revoir selon vous, ce serais avec plaisir.

maintenant : DODO!
(J'ouvrirais les éventuels cadeaux cette nuit ;°) )

Finalement après avoir aseptiser mon programme j'ai réussi a isoler l'erreur.
Je vous poste ce que vous m'aviez demandé :

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
#include <stdio.h>
#include <gtk/gtk.h>
 
typedef struct maillon
{ 
GtkWidget * label; 
GtkWidget * event;
struct maillon * precedent; 
} maillon ;
 
void callrt (GtkEventBox *event, gpointer test);
 
int main(int argc, char *argv[]) {
 
    gtk_init(&argc,&argv);
 
    GtkWidget * fenetre;
    GtkWidget * Vbox;
 
    // fenetre
    fenetre = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title (GTK_WINDOW(fenetre), "test");
    gtk_window_set_default_size(GTK_WINDOW(fenetre), 300,300);
 
    // box
    Vbox = gtk_vbox_new(FALSE,0);
    gtk_container_add(GTK_CONTAINER(fenetre), Vbox);
 
 
    maillon * test = malloc (sizeof (maillon));
 
    test->event = gtk_event_box_new();
    gtk_box_pack_start (GTK_BOX (Vbox), test->event, TRUE, TRUE, 0);
 
    test->label = gtk_label_new ( "bonjour" );
    gtk_misc_set_alignment (GTK_MISC (test->label), 0, 0.5);
    gtk_widget_set_size_request (test->label, -1, 20);    
    gtk_container_add (GTK_CONTAINER (test->event), test->label);
 
    g_signal_connect(G_OBJECT(test->event), "button_press_event", G_CALLBACK(callrt), (gpointer) test);
 
    gtk_widget_show_all(fenetre);
    gtk_main();
    return 0;
 
}
 
void callrt (GtkEventBox *event, gpointer test)
{
   maillon *t = test;
    // ce qui ne marche pas.
   if (gtk_label_get_label (GTK_LABEL (t->label)) == "bonjour") printf ("Ca marche! ");
}

Et quand on clic sur le label une erreur de segmentation se produit.
Voilà, si quelqu'un pouvais m'aider, merci d'avance.

Bonjour,

Parce que ta fonction callback n'a pas le bon prototype : button-press-event
Code:

1 2 3 gboolean user_function (GtkWidget *widget, GdkEventButton *event, gpointer user_data)
;)

10/02/2007, 14h23
Médinoc

Et comme GTK+ exige un cast sur toutes les fonctions callback, l'erreur passe inaperçue pour le compilo...
12/02/2007, 04h36
echantillon

bon merci :°)

J'ai corrigé ça et un tas d'autres problèmes grâce a la doc présente sur le site.
résolu!