Utilisation de g_signal_connect

**kmizgier** · 20/11/2009, 23h13

Bonjour,

Je suis en train de commencer avec Gtk et j'essaye de passer des données à travers g_signal_connect. Une fois exécuté le programme il y a une fenêtre qui apparait et dit APPCRASH quand la fonction G_CALLBACK(accounts) est exécutée. C'est sûrement le code qui est mauvais mais je sais pas comment corriger l'erreur...

Merci par avance.

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
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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>


struct sheet
{
    unsigned long identifier;
    char name[20];
    char surname[20];
    unsigned long credit;
    unsigned short pass;
};

void steps(GtkWidget *pWindow,struct sheet * pers);
void begin(GtkWidget *pWindow,struct sheet * pers);
void accounts(GtkWidget * window, GdkEventKey* pKey, gpointer userdata,struct sheet * pers);

int main(int argc, char **argv)
{
    struct sheet * pers;

    GtkWidget *pWindow;

    gtk_init(&argc,&argv);

    steps(pWindow,pers);
    gtk_main();
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit),NULL);
    return EXIT_SUCCESS;

}

void steps(GtkWidget* pWindow, struct sheet * pers)
{
    begin(pWindow,pers);

}

void begin(GtkWidget *pWindow,struct sheet * pers)
{
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(pWindow,"The free ATM");
    gtk_window_set_default_size(GTK_WINDOW(pWindow),600,600);
    gtk_window_set_position(GTK_WINDOW(pWindow),GTK_WIN_POS_MOUSE);

    g_signal_connect(pWindow, "key-press-event",G_CALLBACK(accounts),(gpointer) pers);

    gtk_widget_show_all(pWindow);

}

void accounts(GtkWidget * window, GdkEventKey* pKey, gpointer userdata,struct sheet * pers)
{
    /**
     *    F1->F12
     * 65470->65481
     */

    unsigned short i=65470;
    unsigned short z=1,place;
    char chain[50];

    FILE * file;
    file = fopen("accounts.txt","r");

    for(i;i<65481;i++)
    {
        fscanf(file,"%[^\n]",chain);
        fgetc(file);

        if(i == pKey->keyval)
        {
             break;
        }

    }

    fclose(file);

    printf("%s\n",chain);

    /**Initialize parameters*/
    pers->identifier=0;
    pers->credit=0;
    pers->pass=0;

    /**Fill sheet*/
    for(z;chain[z]!=';';z++)
    {
        pers->identifier=pers->identifier*10+chain[z]-'0';
    }

    z++;
    place=z;

    for(z;chain[z]!=';';z++)
    {
        pers->name[z-place]=chain[z];
    }

    pers->name[z-place]=0;

    z++;
    place=z;

    for(z;chain[z]!=';';z++)
    {
        pers->surname[z-place]=chain[z];
    }

    pers->surname[z-place]=0;

    z++;
    place=z;

    for(z;chain[z]!=';';z++)
    {
        pers->credit=pers->credit*10+chain[z]-'0';
    }

    z++;
    place=z;

    for(z;chain[z]!=';';z++)
    {
        pers->pass=pers->pass*10+chain[z]-'0';
    }

    printf("%lu\n",pers->identifier);
    printf("%s\n",pers->name);
    printf("%s\n",pers->surname);
    printf("%lu\n",pers->credit);
    printf("%hu\n",pers->pass);

}

**liberforce** · 20/11/2009, 23h56

Bonjour,
tout d'abord, merci d'utiliser les balises permettant d'insérer du code, parce que sinon on perd l'indentation, et le programme devient difficilement lisible. C'est l'icône en forme de dièse (#).

Ensuite, ton erreur vien du fait que tu ne respectes pas le prototype du signal key-press-event. Le dernier paramètre, user_data, te permet de récupérer un pointeur passé en paramètre à g_signal_connect (le paramètre data).

Tu dois donc écrire ta fonction:

Code :

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

1
2
3
4
5
void accounts(GtkWidget * window, GdkEventKey* pKey, gpointer userdata)
{
     struct sheet * pers = userdata;
     /* ... */
}

ou bien

Code :

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

1
2
3
4
void accounts(GtkWidget * window, GdkEventKey* pKey, struct sheet * pers)
{
     /* ... */
}

Je te conseille ensuite de regarder la fonction g_strsplit pour découper tes champs séparés par des points virgules.

Autre gros problème: tu ne maîtrises pas le passage par adresse et par valeur. Ton pointeur pWindow qui se trouve dans le main ne sera jamais initialisé tel qu'est écrit ton code. Revois tes cours de C sur ce point.

Et enfin, pour convertir des chiffres en ascii en nombres entiers, utilise g_strtod.

**titemewie** · 02/12/2009, 16h12

Bonjour,
je dois faire un projet informatique en C pour les cours on a choisie le démineur et je m'occupe de l'interface graphique. J'ai fais mon tableau de bouton et je veux qu'au signal cliqué cela affiche une image. J'ai fais des test avec un pointeur d'entier et ça marche mais je n'arrive pas à faire la même chose avec un pointeur de structure, j'y suis depuis la semaine dernière, j'ai revu mes cours de C mais je n'y arrive toujours pas... Mon prof est tellement surchargé qu'il peut pas m'aider..

Merci d'avance d'aider un surboulet!!!

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 <stdlib.h>
#include <gtk/gtk.h>
 
 
typedef struct
{
 
    int        i;
    int        j;
    int        n;
}SJeu;
 
void afficher_image(GtkWidget* pTable, SJeu *Jeu1);
 
 
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pTable;      // Table bouton
    int i=0, j=0, n=20;
    SJeu      *Jeu1;               // Donnée du jeu
    GtkWidget *pButton[(n*n)];
    GtkWidget *pImage[n*n];  // Table bouton
 
    //int x=1;
    //int *D;  test pointeur entier
    //D=&x;    
 
    gtk_init(&argc, &argv);
 
    /* Creation de la fenetre */
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Demineur");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), n*10, n*10);
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
    /* Creation et insertion de la table n lignes n colonnes */
    pTable=gtk_table_new(n,n,TRUE);
    gtk_container_add(GTK_CONTAINER(pWindow), GTK_WIDGET(pTable));
 
 
 
          /* Creation des boutons */
     for (i=0; i<(n*n); i++) 
	{
		pButton[i] = gtk_button_new();
 
 
	}
 
 
    for (i = 0; i < n; i++) {
  for (j = 0; j < n; j++) {
    /* n*i donne 0 au premier passage, n au deuxième, 2*n au troisième, etc.
     * 0+j = 0 au premier passage, 1 au deuxième, etc. */
 
    SJeu Jeu={i,j,n};
    Jeu1=&Jeu;  //Jeu1 pointe vers Jeu
 
    gtk_table_attach_defaults (GTK_TABLE(pTable), pButton[n*i+j],
                               j, j+1, i, i+1);
    pImage[n*i+j] =gtk_image_new_from_file(".\\Images\\case.jpg");
    gtk_container_add(GTK_CONTAINER(pButton[n*i+j]), pImage[n*i+j]);
    g_signal_connect(G_OBJECT(pButton[n*i+j]), "clicked", G_CALLBACK(afficher_image), Jeu1);
  }
}
 
 
    gtk_widget_show_all(pWindow);
    gtk_main();
 
    return EXIT_SUCCESS;
}
 
 
void afficher_image(GtkWidget* pTable, SJeu *Jeu1) {
     //int x=1;
     //D=&x;                  test pointeur d'entier
     //printf("%d\n",*D);
 
     GtkWidget* pImage[200];
 
 
     pImage[(Jeu1.n)*(Jeu1.i)+(Jeu1.j)] = gtk_image_new_from_stock(GTK_STOCK_ABOUT, GTK_ICON_SIZE_MENU);
     gtk_table_pack_start(GTK_TABLE(pTable), pImage[(Jeu1.n)*(Jeu1.i)+(Jeu1.j)], (Jeu1.j), (Jeu1.j)+1, (Jeu1.i), (Jeu1.i)+1);
}

**gerald3d** · 02/12/2009, 16h49

Tout d'abord dans la fonction afficher_image(); jeu1 est un pointeur. Donc tu ne peux pas accéder aux données de la structure en utilisant le ".". Il faut utiliser "->" à la place.

**teuf13** · 02/12/2009, 16h55

Petite question de C pour tenter de te mettre sur la piste, jusqu'à quel moment les données que tu as stockées dans SJeu Jeu={i,j,n}; sont-elles valides ?

**titemewie** · 02/12/2009, 21h11

bein j'aimerais qu'elles soient valide pour ma boucle.

**teuf13** · 02/12/2009, 22h08

Quand tes callbacks vont tenter d'accéder à ces données, tu seras sorti de ta boucle depuis longtemps non ? (tu seras "dans" gtk_main)

**titemewie** · 03/12/2009, 14h48

Pourtant j'ai essayé d'initialiser dans ma fonction main mais cela ne fonctionne pas, ma façon d'initialiser est peut-être pas bonne...

**gerald3d** · 03/12/2009, 17h20

Envoyé par teuf13

Petite question de C pour tenter de te mettre sur la piste, jusqu'à quel moment les données que tu as stockées dans SJeu Jeu={i,j,n}; sont-elles valides ?

Je rejoins tout à fait teuf13 sur ce point. J'ai modifié ton code pour le rendre opérationnel. La méthode la plus simple, mais pas forcément la meilleure est d'allouer dans le tas SJeu pour chaque bouton. L'inconvénient est l'utilisation mémoire ici mais la souplesse d'accès aux données est sans commune mesure.

**titemewie** · 04/12/2009, 11h08

Merci pour les réponses, je pense que j'y arrive pas car je comprend pas comment fonctionne l'appel de la fonction (j'ai mis pTable au pif et je sais pas pourquoi la fonction callback doit être de cette forme...

) sur internet on trouve la forme des fonction à utiliser mais pas le fonctionnement en lui mM (peut être que c'est tellement simple que personne ne l'explique

)

**gerald3d** · 04/12/2009, 11h42

L'appel aux fonctions CALLBACK est effectivement simple. Maintenant le prototype des fonctions appelées change parce qu'il dépend du signal activant. Il est donc primordial de le respecter.

Pour faire simple tous les CALLBACK finissent par une donnée utilisateur. Cette donnée est un pointeur générique. Il apporte la souplesse de pouvoir transmettre ce que l'on veut dans la mesure où ce que l'on transmet est un pointeur.

C'est là que généralement on bute. Si on doit transmettre un pointeur il est important de maitriser la portée de ce pointeur. Si sa déclaration est locale lors de la construction, le résultat sera des plus improbables. Le plus simple alors est d'allouer ce pointeur dans le tas, c'est à dire en utilisant génériquement la fonction malloc();. Maintenant ce n'est pas une obligation à partir du moment où l'on sait ce que l'on fait

.

Pour ton problème pTable peut être transmis directement au CALLBACK. Il est déclaré en local, certes, mais il est dans la fonction main();. Tant que l'application tourne nous restons dans cette fonction. Donc le pointeur est toujours valide.

Par contre SJeu est déclaré pour chaque bouton dans une boucle for();. Sortie de cette boucle tous les SJeu n'existent plus! On touche ici au problème.

La solution est donc de déclarer tous les SJeu dans le tas. Mais une fois fait comment transmettre 2 pointeurs au CALLBACK (SJeu et pTable)? La solution la plus simple encore une fois est d'ajouter pTable à ta structure SJeu.

Ce qui donne au final le code suivant:

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
87
88
89
#include <stdlib.h>
#include <gtk/gtk.h>
 
 
typedef struct
{
    int        i;
    int        j;
    int        n;
    GtkWidget *pTable;
}SJeu;
 
void afficher_image(GtkWidget* pTable, SJeu *Jeu1);
 
 
int main(int argc, char **argv)
{
	GtkWidget *pWindow;
	GtkWidget *pTable;      // Table bouton
	int i=0, j=0, n=20;
	SJeu      *Jeu1;               // Donnée du jeu
	GtkWidget *pButton[(n*n)];
	GtkWidget *pImage[n*n];  // Table bouton
 
	//int x=1;
	//int *D;  test pointeur entier
	//D=&x;    
 
	gtk_init(&argc, &argv);
 
	/* Creation de la fenetre */
	pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(pWindow), "Demineur");
	gtk_window_set_default_size(GTK_WINDOW(pWindow), n*10, n*10);
	g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
	/* Creation et insertion de la table n lignes n colonnes */
	pTable=gtk_table_new(n,n,TRUE);
	gtk_container_add(GTK_CONTAINER(pWindow), GTK_WIDGET(pTable));
 
	/* Creation des boutons */
	for (i=0; i<(n*n); i++) 
	{
		pButton[i] = gtk_button_new();
	}
 
 
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < n; j++)
		{
			/* n*i donne 0 au premier passage, n au deuxième, 2*n au troisième, etc.
			* 0+j = 0 au premier passage, 1 au deuxième, etc. */
			Jeu1= g_new(SJeu, 1);
			Jeu1->i=i;
			Jeu1->j=j;
			Jeu1->n=n;
			Jeu1->pTable=pTable;
 
			gtk_table_attach_defaults (GTK_TABLE(pTable), pButton[n*i+j], j, j+1, i, i+1);
			pImage[n*i+j] =gtk_image_new_from_file(".\\Images\\case.jpg");
			gtk_container_add(GTK_CONTAINER(pButton[n*i+j]), pImage[n*i+j]);
 
			g_signal_connect(G_OBJECT(pButton[n*i+j]), "clicked", G_CALLBACK(afficher_image), Jeu1);
		}
	}
 
 
	gtk_widget_show_all(pWindow);
	gtk_main();
 
	return EXIT_SUCCESS;
}
 
 
void afficher_image(GtkWidget* pButton, SJeu *Jeu1)
{
	//int x=1;
	//D=&x;                  test pointeur d'entier
	//printf("%d\n",*D);
 
	GtkWidget* pImage[200];
	GtkWidget *pTable=Jeu1->pTable;
 
g_print("%d,%d,%d\n", Jeu1->i, Jeu1->j, Jeu1->n);
 
	pImage[(Jeu1->n)*(Jeu1->i)+(Jeu1->j)] = gtk_image_new_from_stock(GTK_STOCK_ABOUT, GTK_ICON_SIZE_MENU);
	gtk_table_attach_defaults(GTK_TABLE(pTable), pImage[(Jeu1->n)*(Jeu1->i)+(Jeu1->j)], (Jeu1->j), (Jeu1->j)+1, (Jeu1->i), (Jeu1->i)+1);
}

Utilisation de g_signal_connect

GTK+ avec C & C++

Vue hybride

Discussions similaires

Partager

Partager