Discussion :

[masterkillat]

Bonjours à tous, j'ai un projet info à faire en c avec interface graphique, j'ai choisis gtk car j'ai pas mal de menus à faire, c'est un jeu de carte (le 6 qui prend),j'ai un problème, je n'arrives pas à faire en sorte que quand je clique sur un bouton, il quitte le menu en cours et en ouvre un autre sur la même fenêtre.

voici une partie du code, je voudrais que quand je clique sur le bouton 2 (ou autre), il ferme la fonction en cours et m'en ouvre une autre
PS: j'ai vraiment cherché partout, je n'ai rien trouvé.

d'avance merci et bonne soirée

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
void menu_1(GtkWidget *pWindow)
{
    GtkWidget *pTable;
    GtkWidget *Boutton[4];
 
 
     /* Creation et insertion de la table 7 lignes 4 colonnes */
    pTable=gtk_table_new(7,4,TRUE);
    gtk_container_add(GTK_CONTAINER(pWindow), GTK_WIDGET(pTable));
 
 
    /* Creation des boutons */
    Boutton[0]= gtk_button_new_with_label("Jouer contre l'ordinateur");
    Boutton[1]= gtk_button_new_with_label("Jouer contre un autre joueur");
    Boutton[2]= gtk_button_new_with_label("Lire les règles");
    Boutton[3]= gtk_button_new_with_label("Quitter");
 
 
    /* Insertion des boutons */
 
    gtk_table_attach_defaults(GTK_TABLE(pTable), Boutton[0],
        1, 3, 1, 2);
 
    gtk_table_attach_defaults(GTK_TABLE(pTable), Boutton[1],
        1, 3, 3, 4);
 
    gtk_table_attach_defaults(GTK_TABLE(pTable), Boutton[2],
        1, 3, 5, 6);
 
    gtk_table_attach(GTK_TABLE(pTable), Boutton[3],
        3, 4, 6, 7,
        GTK_EXPAND, GTK_EXPAND ,
        0, 0);
 
 
    g_signal_connect (Boutton[2], "clicked", regles, NULL);//je voudrais que quand je clique sur le bouton 2, je ferme cette fonction et que j'en appelle une autre
 
 
    g_signal_connect (Boutton[3], "clicked", gtk_main_quit, NULL);
 
 
 
 
 
 
 
}
 
 
 
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
 
 
    gtk_init(&argc, &argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 800, 600);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Le 6 qui prend!");
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
 
 
    menu_1(pWindow);
 
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}

[gerald3d]

Qu'entends-tu par "fermer cette fonction" ? Serait-ce plutôt fermer la fenêtre actuelle ? Si oui dans le callback "regles" tu commences par un gtk_widget_destroy(pWindow);. Il te faudra donc propager le pointeur pWindow à cette fonction callback "regles".

[masterkillat]

Merci de répondre aussi vite en fait je voudrais que quand je clique sur le bouton 2, ça détruise le menu en cours, c'est a dire la table et les quatre boutons et que je la remplace par une autre table initialisée dans une autre fonction, un peut comme ce code qui vient de la version qui n'a pas d'interface graphique:

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
 
void menu_principal() { /* Fonction menu principal */
 
    int choix=0; /* Déclaration et initialisation de la variable choix pour le menu */
    printf("\n\n\t Menu principal:");
    printf("\n\n 1 - Jouer");
    printf("\n 2 - Lire les règles");
    printf("\n 3 - Quitter");
    printf("\n\n Choix: ");
    scanf("%d",&choix);
    switch (choix){
        case 1:menu_compte(); /* Appel de la fonction menu_compte */
            break;
        case 2:regles();/*appel de la fonction règle*/
            break;
        case 3:printf("\n Vous avez choisi de quitter. \n ");
            break;
 
            }
 
        }
 
 
void menu_compte() { /* Fonction menu compte */
 
    int choix=0; /* Déclaration et initialisation de la variable choix pour le menu */
    printf("\n\n\t Menu compte:");
    printf("\n\n 1 - Créer un compte");
    printf("\n 2 - Choisir un compte existant");
    printf("\n 3 - Retour au menu principal");
    printf("\n\n Choix: ");
    scanf("%d",&choix);
    switch (choix){
        case 1:creer_compte(); /*  Appel de la fonction creer_compte */
            break;
        case 2:selectionner_compte(); /* Appel de la fonction choisir_compte et ouvre le menu joueur avec en paramètre le compte sélectionné */
            break;
        case 3:menu_principal(); /* Appel de la fonction menu_principal */
            break;
 
            }
 
        }

[gerald3d]

C'est relativement simple à faire. Tu transmets à ton callback regles le pointeur pTable comme suit : g_signal_connect (Boutton[2], "clicked", regles, pTable);Ensuite, dans le callback regles il te suffit de détruire pTable avec gtk_widget_destroy(pTable);. Le prototype de regles est : void regles (GtkButton *button, GtkWidget *pTable)Une fois détruit tu peux ajouter une nouvelle table dans ta fenêtre principale et ainsi changer sa physionomie .

[masterkillat]

j'ai bien fait comme vous l'avez expliqué mais ça ne compile pas, il me dit:"invalid use of void expression" et "expected GCallback but argument is type void"

voici le code du bouton:

Code :

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

g_signal_connect (Boutton[0], "clicked",regle(pWindow,pTable),pTable);

le début du code de la fonction:

Code :

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

1
2
3
4
void menu_2(GtkWidget *pWindow,GtkWidget *table_menu_precedent)
{   
gtk_widget_destroy(table_menu_precedent);
}

[gerald3d]

Code :

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

g_signal_connect (Boutton[0], "clicked",regle(pWindow,pTable),pTable);

Non ca tu ne peux pas le faire. Ensuite si c'est la fonction menu_2(); que tu veux appeler il faut faire :

Code :

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

g_signal_connect (Boutton[0], "clicked", G_CALLBACK(menu_2), pTable);

Pour finir tu ne récupères pas en premier argument de menu_2(); pWindow mais le widget qui a émis le signal "clicked". C'est à dire ici le le bouton.

[masterkillat]

je n'ai pas très bien compris, l'histoire du signal émis.
sinon maintenant ça compile mais le programme crash quand je clique sur le bouton 0 du menu_1

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
 
void menu_2(GtkWidget *table_menu_precedent,GtkWidget *fenetre)
{
    GtkWidget *Table;
    GtkWidget *Boutton[3];
    //destruction de la table précédente
    gtk_widget_destroy(table_menu_precedent);
    //création de la table 7 lignes 4 colonnes
    Table=gtk_table_new(7,4,TRUE);
    gtk_container_add(GTK_CONTAINER(fenetre), GTK_WIDGET(Table));
    //création des boutons
    Boutton[0]= gtk_button_new_with_label("Choisir un compte");
    Boutton[1]= gtk_button_new_with_label("Créer un compte");
    Boutton[2]= gtk_button_new_with_label("Quitter");
 
    gtk_table_attach_defaults(GTK_TABLE(Table), Boutton[0],
        1, 3, 1, 2);
 
    gtk_table_attach_defaults(GTK_TABLE(Table), Boutton[1],
        1, 3, 3, 4);
 
    gtk_table_attach_defaults(GTK_TABLE(Table), Boutton[2],
        1, 3, 5, 6);
 
    gtk_table_attach(GTK_TABLE(Table), Boutton[3],
        3, 4, 6, 7,
        GTK_EXPAND, GTK_EXPAND ,
        0, 0);
 
    //lien des boutons avec les différentes fonctions
    g_signal_connect (Boutton[2], "clicked", gtk_main_quit, NULL);
 
}
 
void menu_1(GtkWidget *pWindow,GtkWidget *table_menu_precedent)
{
    GtkWidget *Table;
    GtkWidget *Boutton[4];
    GtkWidget *frame;
    gtk_widget_destroy(table_menu_precedent);
    frame = gtk_frame_new ("menu");
 
     /* Creation et insertion de la table 7 lignes 4 colonnes */
    Table=gtk_table_new(7,4,TRUE);
    gtk_container_add(GTK_CONTAINER(pWindow), GTK_WIDGET(Table));
 
 
    /* Creation des boutons */
    Boutton[0]= gtk_button_new_with_label("Jouer contre l'ordinateur");
    Boutton[1]= gtk_button_new_with_label("Jouer contre un autre joueur");
    Boutton[2]= gtk_button_new_with_label("Lire les règles");
    Boutton[3]= gtk_button_new_with_label("Quitter");
 
 
    /* Insertion des boutons */
 
    gtk_table_attach_defaults(GTK_TABLE(Table), Boutton[0],
        1, 3, 1, 2);
 
    gtk_table_attach_defaults(GTK_TABLE(Table), Boutton[1],
        1, 3, 3, 4);
 
    gtk_table_attach_defaults(GTK_TABLE(Table), Boutton[2],
        1, 3, 5, 6);
 
    gtk_table_attach(GTK_TABLE(Table), Boutton[3],
        3, 4, 6, 7,
        GTK_EXPAND, GTK_EXPAND ,
        0, 0);
 
    g_signal_connect (Boutton[0], "clicked", G_CALLBACK(menu_2), Table);
 
    g_signal_connect (Boutton[2], "clicked", regles, NULL);
 
    g_signal_connect (Boutton[3], "clicked", gtk_main_quit, NULL);
 
}

[gerald3d]

Tu as inversé les widgets dans le callback menu_2();. Tu détruis le bouton et non la table !

Pour essayer d'être plus clair soit la fonction suivante : void func (GtkWidget *button, GtkWidget *table);.

Soit ensuite la connexion du signal "clicked" d'un GtkButton : vg_signal_connect (button, G_CALLBACK(func), table);.

Dans la fonction "func" tu récupères en premier argument le GtkButton sur lequel tu as appuyé. En deuxième argument tu récupères le pointeur de l'élément que tu transmis dans la fonction g_signal_connect(); en dernier argument (ici c'est 'table").

[masterkillat]

merci beaucoup, ça marche nickel

[masterkillat]

ah en fait j'ai un petit problème, j'arrive bien a faire disparaitre la table mais je n'arrive pas a faire apparaitre la nouvelle, ça compile bien mais quand je clique sur le bouton, le programme crash, je pense que c'est parce que le pointeur fenetre n'est pas pris en argument dans la fonction g_connect.

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
void menu_2(GtkWidget *bouton,GtkWidget *table_menu_precedent,GtkWidget *fenetre)
{
    GtkWidget *Table;
    GtkWidget *Boutton[3];
    //destruction de la table précédente
    gtk_widget_destroy(table_menu_precedent);
    //création de la table 7 lignes 4 colonnes
    Table=gtk_table_new(7,4,TRUE);
    gtk_container_add(GTK_CONTAINER(fenetre), GTK_WIDGET(Table));
    //création des boutons
    Boutton[0]= gtk_button_new_with_label("Choisir un compte");
    Boutton[1]= gtk_button_new_with_label("Créer un compte");
    Boutton[2]= gtk_button_new_with_label("Quitter");
 
    gtk_table_attach_defaults(GTK_TABLE(Table), Boutton[0],
        1, 3, 1, 2);
 
    gtk_table_attach_defaults(GTK_TABLE(Table), Boutton[1],
        1, 3, 3, 4);
 
    gtk_table_attach_defaults(GTK_TABLE(Table), Boutton[2],
        1, 3, 5, 6);
 
    gtk_table_attach(GTK_TABLE(Table), Boutton[3],
        3, 4, 6, 7,
        GTK_EXPAND, GTK_EXPAND ,
        0, 0);
 
    //lien des boutons avec les différentes fonctions
    g_signal_connect (Boutton[2], "clicked", gtk_main_quit, NULL);
 
}
 
void menu_1(GtkWidget *table_menu_precedent, GtkWidget *pWindow)//pwindow est la fenetre principale du programme
{
    GtkWidget *Table;
    GtkWidget *Bouton[4];
    GtkWidget *frame;
    gtk_widget_destroy(table_menu_precedent);
    frame = gtk_frame_new ("menu");
 
     /* Creation et insertion de la table 7 lignes 4 colonnes */
    Table=gtk_table_new(7,4,TRUE);
    gtk_container_add(GTK_CONTAINER(pWindow), GTK_WIDGET(Table));
 
    /* Creation des boutons */
    Bouton[0]= gtk_button_new_with_label("Jouer contre l'ordinateur");
    Bouton[1]= gtk_button_new_with_label("Jouer contre un autre joueur");
    Bouton[2]= gtk_button_new_with_label("Lire les règles");
    Bouton[3]= gtk_button_new_with_label("Quitter");
 
    /* Insertion des boutons */
    gtk_table_attach_defaults(GTK_TABLE(Table), Bouton[0],
        1, 3, 1, 2);
    gtk_table_attach_defaults(GTK_TABLE(Table), Bouton[1],
        1, 3, 3, 4);
    gtk_table_attach_defaults(GTK_TABLE(Table), Bouton[2],
        1, 3, 5, 6);
    gtk_table_attach(GTK_TABLE(Table), Bouton[3],
        3, 4, 6, 7,
        GTK_EXPAND, GTK_EXPAND ,
        0, 0);
/*connection des boutons avec les autres fonctions*/
    g_signal_connect (Bouton[0], "clicked", G_CALLBACK(menu_2), Table);
 
    g_signal_connect (Bouton[2], "clicked", regles, NULL);
    g_signal_connect (Bouton[3], "clicked", gtk_main_quit, NULL);
 
}

[gerald3d]

J'attendais que tu reviennes avec ce genre de question .

Alors premièrement tu ne peux modifier le prototype du callback associé au signal "clicked". Donc la fonction menu2 ne peut être que du type : void user_function (GtkButton *button, gpointer userdata);.

Deuxièmement tu touches au problème que rencontrent bon nombre d'utilisateurs débutants avec Gtk+ : "Comment passer plusieurs arguments à un callback ?"

La réponse à cette question est simple : transmettre un pointeur sur une variable de type struct qui va contenir tous les pointeurs dont on a besoin dans les différents callback appelés.

Dans ton cas ce pourrait-être de ce style :

Code :

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

1
2
3
4
typedef struct {
GtkWidget *mainwindow; // Fenêtre principale
GtkWidget *table; // Widget table que tu détruis/reconstruis en fonction des choix de l'utilisateur
} GlobalData;

[masterkillat]

j'ai bien fait la structure comme déctrite:

Code :

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

1
2
3
4
typedef struct lien_fct_callback{
GtkWidget *fenetre;
GtkWidget *table;
}GlobalData;

mais j'ai un probleme avec le g_signal, le compilateur me dit que l'argument est incompatible:

Code :

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

g_signal_connect (Bouton[0], "clicked", G_CALLBACK(menu_2),menu);

,menu étant une variable de type lien_fct_callback.
et je voulais aussi savoir à quoi servait le gpointeur userdata , ma fonction ressemble à ça:

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
void menu_1(struct lien_fct_callback menu)
{
    GtkWidget *Bouton[4];
    gtk_widget_destroy(menu.table);
 
     /* Creation et insertion de la table 7 lignes 4 colonnes */
    menu.table=gtk_table_new(7,4,TRUE);
    gtk_container_add(GTK_CONTAINER(menu.fenetre), GTK_WIDGET(menu.table));
 
 
    /* Creation des boutons */
    Bouton[0]= gtk_button_new_with_label("Jouer contre l'ordinateur");
    Bouton[1]= gtk_button_new_with_label("Jouer contre un autre joueur");
    Bouton[2]= gtk_button_new_with_label("Lire les règles");
    Bouton[3]= gtk_button_new_with_label("Quitter");
 
 
    /* Insertion des boutons */
 
    gtk_table_attach_defaults(GTK_TABLE(menu.table), Bouton[0],
        1, 3, 1, 2);
 
    gtk_table_attach_defaults(GTK_TABLE(menu.table), Bouton[1],
        1, 3, 3, 4);
 
    gtk_table_attach_defaults(GTK_TABLE(menu.table), Bouton[2],
        1, 3, 5, 6);
 
    gtk_table_attach(GTK_TABLE(menu.table), Bouton[3],
        3, 4, 6, 7,
        GTK_EXPAND, GTK_EXPAND ,
        0, 0);
    g_signal_connect (Bouton[0], "clicked", G_CALLBACK(menu_2),menu);
 
    g_signal_connect (Bouton[2], "clicked", regles, NULL);
 
    g_signal_connect (Bouton[3], "clicked", gtk_main_quit, NULL);
 
}

[masterkillat]

Je voulais aussi savoir à quoi sert le globadata dans la structure?

[gerald3d]

La réponse a ta dernière question est simple. C'est lié directement à la programmation en langage C. Plutôt d'écrire ceux qui l'ont déjà fait pour nous voila le lien qui va tout t'expliquer

Pour le problème de l'utilisation de la variable menu je suppose que tu l'as déclaré ainsi : GlobalData menu;. Jusque là ca meut ne pas poser trop de problèmes, tant que la fonction dans laquelle tu l'as déclarée n'est pas terminée. Typiquement le main();.

Maintenant la fonction g_signal_connect(); attend un pointeur et non une variable. Il te faut donc passer l'adresse de menu et non menu elle-même. Ce qui induit dans la fonction callback l'utilisation du sigle -> et non . pour l'accès aux données de menu.

Toujours dans la même continuité voila un lien pour expliquer par l'exemple l'utilisation des variables et des pointeurs.

Bonne lecture

[masterkillat]

J'ai bien lu les deux articles, mais il doit y avoir un truc que je ne comprends pas car quand je lance ma fonction, le programme plante, de plus quand j'utilise -> pour le pointeur au lieu du . ça ne compile pas.
encore merci de me répondre sur votre temps libre

voici le code complet de mon programme

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
#include <stdlib.h>
#include <gtk/gtk.h>
typedef struct lien_fct_callback{
GtkWidget *fenetre;
GtkWidget *table;
 
}GlobalData;
 
 
void regles (){
 
GtkWidget *pWindow;
GtkWidget* label = NULL;
 
    /* Création de la fenêtre */
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(pWindow), GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Règles du jeu");
    gtk_widget_show(pWindow);
 
    label = gtk_label_new("les règles du jeu");
 
  gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER);
  gtk_container_add(GTK_CONTAINER(pWindow), label);
  gtk_widget_show_all(pWindow);
 
 
}
 
 
 
void menu_2(struct lien_fct_callback menu)
{
    GtkWidget *Boutton[3];
    //destruction de la table précédente
    gtk_widget_destroy(menu.table);
    //création de la table 7 lignes 4 colonnes
    menu.table=gtk_table_new(6,4,TRUE);
    gtk_container_add(GTK_CONTAINER(menu.fenetre), GTK_WIDGET(menu.table));
    //création des boutons
    Boutton[0]= gtk_button_new_with_label("Choisir un compte");
    Boutton[1]= gtk_button_new_with_label("Créer un compte");
    Boutton[2]= gtk_button_new_with_label("Quitter");
 
    gtk_table_attach_defaults(GTK_TABLE(menu.table), Boutton[0],
        1, 3, 1, 2);
 
    gtk_table_attach_defaults(GTK_TABLE(menu.table), Boutton[1],
        1, 3, 3, 4);
 
    gtk_table_attach(GTK_TABLE(menu.table), Boutton[2],
        3, 4, 5, 6,
        GTK_EXPAND, GTK_EXPAND ,
        0, 0);
 
    //lien des boutons avec les différentes fonctions
    g_signal_connect (Boutton[2], "clicked", gtk_main_quit, NULL);
 
}
 
void menu_1( struct lien_fct_callback menu)
{
    GtkWidget *Bouton[4];
    /*destruction de la table précédente*/
     gtk_widget_destroy(menu.table);
     /* Creation et insertion de la table 7 lignes 4 colonnes */
    menu.table=gtk_table_new(7,4,TRUE);
    gtk_container_add(GTK_CONTAINER(menu.fenetre), GTK_WIDGET(menu.table));
 
 
    /* Creation des boutons */
    Bouton[0]= gtk_button_new_with_label("Jouer contre l'ordinateur");
    Bouton[1]= gtk_button_new_with_label("Jouer contre un autre joueur");
    Bouton[2]= gtk_button_new_with_label("Lire les règles");
    Bouton[3]= gtk_button_new_with_label("Quitter");
    /* Insertion des boutons */
    gtk_table_attach_defaults(GTK_TABLE(menu.table), Bouton[0],
        1, 3, 1, 2);
 
    gtk_table_attach_defaults(GTK_TABLE(menu.table), Bouton[1],
        1, 3, 3, 4);
 
    gtk_table_attach_defaults(GTK_TABLE(menu.table), Bouton[2],
        1, 3, 5, 6);
 
    gtk_table_attach(GTK_TABLE(menu.table), Bouton[3],
        3, 4, 6, 7,
        GTK_EXPAND, GTK_EXPAND ,
        0, 0);
 
        /*connection des boutons aux diverses fonctions*/
    g_signal_connect (Bouton[0], "clicked", G_CALLBACK(menu_2),&menu);
 
    g_signal_connect (Bouton[2], "clicked", regles, NULL);
 
    g_signal_connect (Bouton[3], "clicked", gtk_main_quit, NULL);
 
}
 
 
 
int main(int argc, char **argv)
 
{
    struct lien_fct_callback  menu;
 
 
    gtk_init(&argc, &argv);
 
    menu.fenetre = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(menu.fenetre), GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(menu.fenetre), 800, 600);
    gtk_window_set_title(GTK_WINDOW(menu.fenetre), "Le 6 qui prend!");
    g_signal_connect(G_OBJECT(menu.fenetre), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
 
    menu_1(menu);
 
 
    gtk_widget_show_all(menu.fenetre);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}

[gerald3d]

Il ne faut pas transmettre à menu1 et menu2 une copie de la variable menu mais son adresse. Donc les prototypes de menu1 et menu2 doivent être :

Code :

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

1
2
3
void menu_1( GlobalData *menu);
 
void menu_2( GtkButton *button, GlobalData *menu);

Au passage tu remarqueras que menu2(); ne correspond pas au prototype de menu1(); puisque tu t'en sers de callback appelé par un bouton avec le signal "clicked".

Une fois les prototypes modifiés il te faut modifier le reste de ton code pour prendre en compte le fait d'utiliser un pointeur et non une variable.

[masterkillat]

Je n'ai plus d'erreurs lors de la compilation mais la il n'affiche même plus de fenêtre -.-' j'ai relu plusieurs fois les différents cours sur les pointeurs mais je ne vois pas ou est mon erreur, je pense que c'est un truc tout bête...
re-voici mon code, avec les modifications:

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
#include <stdlib.h>
#include <gtk/gtk.h>
typedef struct lien_fct_callback{
GtkWidget *fenetre;
GtkWidget *table;
 
}GlobalData;
 
 
void regles (){
 
GtkWidget *pWindow;
GtkWidget* label = NULL;
 
    /* Création de la fenêtre */
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(pWindow), GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Règles du jeu");
    gtk_widget_show(pWindow);
 
    label = gtk_label_new("les règles du jeu");
 
  gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER);
  gtk_container_add(GTK_CONTAINER(pWindow), label);
  gtk_widget_show_all(pWindow);
 
 
}
 
 
 
void menu_2(GtkWidget *bouton,GlobalData *menu)
{
    GtkWidget *Boutton[3];
    //destruction de la table précédente
    gtk_widget_destroy(menu->table);
    //création de la table 7 lignes 4 colonnes
    menu->table=gtk_table_new(6,4,TRUE);
    gtk_container_add(GTK_CONTAINER(menu->fenetre), GTK_WIDGET(menu->table));
    //création des boutons
    Boutton[0]= gtk_button_new_with_label("Choisir un compte");
    Boutton[1]= gtk_button_new_with_label("Créer un compte");
    Boutton[2]= gtk_button_new_with_label("Quitter");
 
    gtk_table_attach_defaults(GTK_TABLE(menu->table), Boutton[0],
        1, 3, 1, 2);
 
    gtk_table_attach_defaults(GTK_TABLE(menu->table), Boutton[1],
        1, 3, 3, 4);
 
    gtk_table_attach(GTK_TABLE(menu->table), Boutton[2],
        3, 4, 5, 6,
        GTK_EXPAND, GTK_EXPAND ,
        0, 0);
 
    //lien des boutons avec les différentes fonctions
    g_signal_connect (Boutton[2], "clicked", gtk_main_quit, NULL);
 
}
 
void menu_1(GlobalData *menu)
{
    GtkWidget *Bouton[4];
    /*destruction de la table précédente*/
     gtk_widget_destroy(menu->table);
     /* Creation et insertion de la table 7 lignes 4 colonnes */
    menu->table=gtk_table_new(7,4,TRUE);
    gtk_container_add(GTK_CONTAINER(menu->fenetre), GTK_WIDGET(menu->table));
 
 
    /* Creation des boutons */
    Bouton[0]= gtk_button_new_with_label("Jouer contre l'ordinateur");
    Bouton[1]= gtk_button_new_with_label("Jouer contre un autre joueur");
    Bouton[2]= gtk_button_new_with_label("Lire les règles");
    Bouton[3]= gtk_button_new_with_label("Quitter");
    /* Insertion des boutons */
    gtk_table_attach_defaults(GTK_TABLE(menu->table), Bouton[0],
        1, 3, 1, 2);
 
    gtk_table_attach_defaults(GTK_TABLE(menu->table), Bouton[1],
        1, 3, 3, 4);
 
    gtk_table_attach_defaults(GTK_TABLE(menu->table), Bouton[2],
        1, 3, 5, 6);
 
    gtk_table_attach(GTK_TABLE(menu->table), Bouton[3],
        3, 4, 6, 7,
        GTK_EXPAND, GTK_EXPAND ,
        0, 0);
 
        /*connection des boutons aux diverses fonctions*/
    g_signal_connect (Bouton[0], "clicked", G_CALLBACK(menu_2),(GlobalData*) menu);
 
    g_signal_connect (Bouton[2], "clicked", regles, NULL);
 
    g_signal_connect (Bouton[3], "clicked", gtk_main_quit, NULL);
 
}
 
 
 
int main(int argc, char **argv)
 
{
    GlobalData  *menu;
 
 
    gtk_init(&argc, &argv);
 
    menu->fenetre = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(menu->fenetre), GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(menu->fenetre), 800, 600);
    gtk_window_set_title(GTK_WINDOW(menu->fenetre), "Le 6 qui prend!");
    g_signal_connect(G_OBJECT(menu->fenetre), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
 
    menu_1(&menu);
 
 
    gtk_widget_show_all(menu->fenetre);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}

[gerald3d]

Bon tu as quelques lacunes avec les pointeurs, mais tu y es presque .

Dans la fonction main(); il faut déclarer menu en temps que variable, pour qu'elle est une existence viable. Si tu déclares un pointeur directement il te faut alors l'allouer dans le tas (avec malloc).

Ensuite dans menu_1(); tu commences pas détruire menu->table alors que ce pointeur n'est pas encore initialisé. D'où une erreur de segmentation.

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
#include <stdlib.h>
#include <gtk/gtk.h>
typedef struct lien_fct_callback{
GtkWidget *fenetre;
GtkWidget *table;
 
}GlobalData;
 
 
void regles (){
 
GtkWidget *pWindow;
GtkWidget* label = NULL;
 
    /* Création de la fenêtre */
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(pWindow), GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Règles du jeu");
    gtk_widget_show(pWindow);
 
    label = gtk_label_new("les règles du jeu");
 
  gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER);
  gtk_container_add(GTK_CONTAINER(pWindow), label);
  gtk_widget_show_all(pWindow);
 
 
}
 
 
 
void menu_2(GtkWidget *bouton,GlobalData *menu)
{
    GtkWidget *Boutton[3];
    //destruction de la table précédente
    gtk_widget_destroy(menu->table);
    //création de la table 7 lignes 4 colonnes
    menu->table=gtk_table_new(6,4,TRUE);
    gtk_container_add(GTK_CONTAINER(menu->fenetre), GTK_WIDGET(menu->table));
    //création des boutons
    Boutton[0]= gtk_button_new_with_label("Choisir un compte");
    Boutton[1]= gtk_button_new_with_label("Créer un compte");
    Boutton[2]= gtk_button_new_with_label("Quitter");
 
    gtk_table_attach_defaults(GTK_TABLE(menu->table), Boutton[0],
        1, 3, 1, 2);
 
    gtk_table_attach_defaults(GTK_TABLE(menu->table), Boutton[1],
        1, 3, 3, 4);
 
    gtk_table_attach(GTK_TABLE(menu->table), Boutton[2],
        3, 4, 5, 6,
        GTK_EXPAND, GTK_EXPAND ,
        0, 0);
 
    //lien des boutons avec les différentes fonctions
    g_signal_connect (Boutton[2], "clicked", gtk_main_quit, NULL);
 
}
 
void menu_1(GlobalData *menu)
{
    GtkWidget *Bouton[4];
    /*destruction de la table précédente*/
 //    gtk_widget_destroy(menu->table);
     /* Creation et insertion de la table 7 lignes 4 colonnes */
    menu->table=gtk_table_new(7,4,TRUE);
    gtk_container_add(GTK_CONTAINER(menu->fenetre), GTK_WIDGET(menu->table));
 
 
    /* Creation des boutons */
    Bouton[0]= gtk_button_new_with_label("Jouer contre l'ordinateur");
    Bouton[1]= gtk_button_new_with_label("Jouer contre un autre joueur");
    Bouton[2]= gtk_button_new_with_label("Lire les règles");
    Bouton[3]= gtk_button_new_with_label("Quitter");
    /* Insertion des boutons */
    gtk_table_attach_defaults(GTK_TABLE(menu->table), Bouton[0],
        1, 3, 1, 2);
 
    gtk_table_attach_defaults(GTK_TABLE(menu->table), Bouton[1],
        1, 3, 3, 4);
 
    gtk_table_attach_defaults(GTK_TABLE(menu->table), Bouton[2],
        1, 3, 5, 6);
 
    gtk_table_attach(GTK_TABLE(menu->table), Bouton[3],
        3, 4, 6, 7,
        GTK_EXPAND, GTK_EXPAND ,
        0, 0);
 
        /*connection des boutons aux diverses fonctions*/
    g_signal_connect (Bouton[0], "clicked", G_CALLBACK(menu_2),(GlobalData*) menu);
 
    g_signal_connect (Bouton[2], "clicked", regles, NULL);
 
    g_signal_connect (Bouton[3], "clicked", gtk_main_quit, NULL);
 
}
 
 
 
int main(int argc, char **argv)
 
{
    GlobalData  menu;
 
 
    gtk_init(&argc, &argv);
 
    menu.fenetre = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(menu.fenetre), GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(menu.fenetre), 800, 600);
    gtk_window_set_title(GTK_WINDOW(menu.fenetre), "Le 6 qui prend!");
    g_signal_connect(G_OBJECT(menu.fenetre), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
 
    menu_1(&menu);
 
 
    gtk_widget_show_all(menu->fenetre);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}

[masterkillat]

Je pensais que l'on pouvais le déclarer directement en pointeur, autant pour moi ^^, sinon j'ai changé les arguments de la fonction menu_1 pour que je puisse l'appeler avec un bouton retour au cas ou:

Code :

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

void menu_1(GtkWidget *bouton,GlobalData *menu)

du coup j'ai créé une table dans le main et un gtkwidget qui ne servent a rien sauf pouvoir lancer la fonction:

Code :

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

1
2
3
4
 
GtkWidget *bouton_inutil;
menu.table=gtk_table_new(1,1,TRUE);
    menu_1(bouton_inutil,&menu);

maintenant le code s'exécute sans problèmes (aucunes erreurs) cependant quand je clique sur le bouton 0 qui appelle la fonction menu_2, la table se détruit bien mais la fonction ne crée pas la nouvelle table, j'ai essayé en créant une table tampon, ça ne marche pas.

[gerald3d]

Il te faut dans menu2(); demander l'affichage de la table :

Code :

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

gtk_widget_show_all (menu->table);