GTK avec pList

Version imprimable

GTK avec pList

Bonjour

Merci a tous ceux qui prendrons le temps de me lire ...

J'ai un signal :
g_signal_connect(G_OBJECT(pButton[0]), "clicked", G_CALLBACK(ouverture_fichier), (GtkWidget*) pVBox);

qui appelle la fonction ouverture_fichier et qui prend en paramètre pVBox déclarer dans le .c en question

Dans ma fonction ouverture_fichier, j'utilise une pList, cependant je voulais savoir si en passant un autre argument a ma fonction par exemple G_OBJECT(pWindow), la pList fonctionnerai,

Comment faire si cela marche pour que sa fonctionne (:mouarf:)
actuellement dans la fonction, comme je passe une boite, je récupère les informations qui me son utile (GTK entry ) et utilise la commande
pList = g_list_next(pList);
pour passer au Widget suivant (Label, ou Bouton )

Maintenant je voudrais le faire avec toute la fenetre cependant, j'ai une segmentation fault. ( Je ne trouve pas sa provenance. :cry: )

Comment je dois faire pour faire fonctionner pList ?

Merci d'avance

Je joins le code de la pWindows en question (ici pWindowConnection )

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
void fenetreconnexion(GtkWidget *Fenetre, gpointer data)
{
    GtkWidget* pWindowConnexion;
    if (connexion == 0)
    {
        gtk_widget_destroy((GtkWidget*)data);
    }
    /* Déclaration des widgets */
 
    GtkWidget* pLabel[4];
    GtkWidget* pButton[3];
    GtkWidget *pVBox;
    GtkWidget *pEntry[4];
    gchar* sUtf8;
    pWindowConnexion = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindowConnexion),"Connexion Joueur 1");
    gtk_window_set_default_size(GTK_WINDOW(pWindowConnexion),320,380);
 
    /*Definition des widgets*/
     pLabel[0]=gtk_label_new(NULL);
     pLabel[1]=gtk_label_new(NULL);
     pLabel[2]=gtk_label_new(NULL);
     pLabel[3]=gtk_label_new(NULL);
     pEntry[0] = gtk_entry_new();
     pEntry[1] = gtk_entry_new();
     pEntry[2] = gtk_entry_new();
     pEntry[3] = gtk_entry_new();
     pVBox = gtk_vbox_new(TRUE, 0);
     pButton[0] = gtk_button_new_with_label("Connexion");
     pButton[1] = gtk_button_new_with_label("Precedent");
     pButton[2] = gtk_button_new_with_label("Quitter");
     gtk_container_add(GTK_CONTAINER(pWindowConnexion), GTK_WIDGET(pVBox));
 
     /* Mode mot de passe */
     gtk_entry_set_visibility(GTK_ENTRY(pEntry[1]), FALSE);
     /* Modification du caractere affiche */
     gtk_entry_set_invisible_char(GTK_ENTRY(pEntry[1]), '*');
     if(IA == 0)
     {
    gtk_entry_set_visibility(GTK_ENTRY(pEntry[3]), FALSE);
     /* Modification du caractere affiche */
     gtk_entry_set_invisible_char(GTK_ENTRY(pEntry[3]), '*');
     }
     /* Creation du label*/
     /* Label 1*/
        sUtf8 = g_locale_to_utf8("<span font_desc=\"Sans 16\" foreground=\"#0000FF\"><u>Pseudo Joueur 1</u></span>\n",-1, NULL, NULL, NULL);
        gtk_label_set_markup(GTK_LABEL(pLabel[0]), sUtf8);
        g_free(sUtf8);
     /* Label 2*/
        sUtf8 = g_locale_to_utf8("<span font_desc=\"Sans 16\" foreground=\"#0000FF\"><u>Joueur 1 : Mot de Passe</u></span>\n",-1, NULL, NULL, NULL);
        gtk_label_set_markup(GTK_LABEL(pLabel[1]), sUtf8);
        g_free(sUtf8);
        if(IA == 0)
        {
        /* Label 3*/
        sUtf8 = g_locale_to_utf8("<span font_desc=\"Sans 16\" foreground=\"#0000FF\"><u>Pseudo Joueur 2</u></span>\n",-1, NULL, NULL, NULL);
        gtk_label_set_markup(GTK_LABEL(pLabel[2]), sUtf8);
        g_free(sUtf8);
        /* Label 4*/
        sUtf8 = g_locale_to_utf8("<span font_desc=\"Sans 16\" foreground=\"#0000FF\"><u>Joueur 2 : Mot de Passe</u></span>\n",-1, NULL, NULL, NULL);
        gtk_label_set_markup(GTK_LABEL(pLabel[3]), sUtf8);
        g_free(sUtf8);
        }
 
        /* Mise en forme de la fenetre 2 Fenetre inscription*/
        gtk_box_pack_start(GTK_BOX(pVBox), pLabel[0], TRUE, TRUE, 0);
        gtk_box_pack_start(GTK_BOX(pVBox), pEntry[0], TRUE, TRUE, 0);
        gtk_box_pack_start(GTK_BOX(pVBox), pLabel[1], TRUE, TRUE, 0);
        gtk_box_pack_start(GTK_BOX(pVBox), pEntry[1], TRUE, TRUE, 0);
        if(IA == 0)
        {
        gtk_box_pack_start(GTK_BOX(pVBox), pLabel[2], TRUE, TRUE, 0);
        gtk_box_pack_start(GTK_BOX(pVBox), pEntry[2], TRUE, TRUE, 0);
        gtk_box_pack_start(GTK_BOX(pVBox), pLabel[3], TRUE, TRUE, 0);
        gtk_box_pack_start(GTK_BOX(pVBox), pEntry[3], TRUE, TRUE, 0);
        }
        gtk_box_pack_start(GTK_BOX(pVBox), pButton[0], TRUE, TRUE, 0);
        gtk_box_pack_start(GTK_BOX(pVBox), pButton[1], TRUE, TRUE, 0);
        gtk_box_pack_start(GTK_BOX(pVBox), pButton[2], TRUE, TRUE, 0);
 
        /* Connexion du signal "activate" du GtkEntry */
        g_signal_connect(G_OBJECT(pEntry[0]), "activate", G_CALLBACK(on_activate_entry), (GtkWidget*) pLabel[0]);
        g_signal_connect(G_OBJECT(pEntry[1]), "activate", G_CALLBACK(on_activate_entry), (GtkWidget*) pLabel[1]);
        if(IA == 0)
        {
        g_signal_connect(G_OBJECT(pEntry[2]), "activate", G_CALLBACK(on_activate_entry), (GtkWidget*) pLabel[2]);
        g_signal_connect(G_OBJECT(pEntry[3]), "activate", G_CALLBACK(on_activate_entry), (GtkWidget*) pLabel[3]);
        }
     /* Connexion du signal Bouton*/
     /* On appelle directement la fonction de sortie de boucle */
     g_signal_connect(G_OBJECT(pButton[0]), "clicked", G_CALLBACK(ouverture_fichier), (GtkWidget*) pVBox);
     g_signal_connect(G_OBJECT(pButton[1]),"clicked",G_CALLBACK(choixInscription_Chargement),G_OBJECT(pWindowConnexion));
     g_signal_connect(G_OBJECT(pButton[2]),"clicked",G_CALLBACK(on_quitter_btn),G_OBJECT(pWindowConnexion));
     g_signal_connect(G_OBJECT(pWindowConnexion),"destroy", G_CALLBACK(gtk_main_quit), NULL);
 
//
    gtk_widget_show_all(pWindowConnexion);
    gtk_main();
 
}

20/03/2013, 18h30
liberforce

La partie intéressante, c'est la callback ouverture_fichier, et c'est justement ce que tu ne donnes pas...

Bon

Je sais je suis un boulet

Je vais la rajouté

Désolé

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
void ouverture_fichier(GtkWidget *pWindow, gpointer data)
{
     //if (connexion == 0)
     GtkWidget *pTempEntry[4];
     GList *pList;
     const gchar *sText;
     int resultat;
 
    /* Recuperation de la liste des elements que contient la GtkVBox */
     pList = gtk_container_get_children(GTK_CONTAINER((GtkWidget*)data));
 
    /* Cet element est le GtkLabel */
    pList = g_list_next(pList);
 
    /*le GtkEntry */
     pTempEntry[0] = GTK_WIDGET(pList->data);
     pList = g_list_next(pList);
 
     /* Cet element est le GtkLabel */
     pList = g_list_next(pList);
 
    /*le GtkEntry */
     pTempEntry[1] = GTK_WIDGET(pList->data);
     pList = g_list_next(pList);
    if(IA == 0)
    {
           /* Cet element est le GtkLabel */
     pList = g_list_next(pList);
 
    /*le GtkEntry */
     pTempEntry[2] = GTK_WIDGET(pList->data);
     pList = g_list_next(pList);
 
     /* Cet element est le GtkLabel */
     pList = g_list_next(pList);
 
    /*le GtkEntry */
     pTempEntry[3] = GTK_WIDGET(pList->data);
     pList = g_list_next(pList);
    }
 
    /* Passage a l element suivant : le GtkButton */
     pList = g_list_next(pList);
     pList = g_list_next(pList);
     pList = g_list_next(pList);
 
 
    /* Recuperation du texte contenu dans le GtkEntry */
     sText = gtk_entry_get_text(GTK_ENTRY(pTempEntry[0]));
     strcpy(joueur1.pseudo,sText);
     sText = gtk_entry_get_text(GTK_ENTRY(pTempEntry[1]));
     strcpy(joueur1.motdepasse,sText);
     if(IA == 0)
     {
         sText = gtk_entry_get_text(GTK_ENTRY(pTempEntry[2]));
         strcpy(joueur2.pseudo,sText);
         sText = gtk_entry_get_text(GTK_ENTRY(pTempEntry[3]));
         strcpy(joueur2.motdepasse,sText);
         if(strcmp(joueur1.pseudo,joueur2.pseudo)==0)
         {
             printf("Erreur Même Pseudo\n");
         }
         else
         {
         resultat = ouvertureJoueur(&joueur1);
         if (resultat == 1 )
         {
             resultat = ouvertureJoueur(&joueur2);
             if(resultat == 1)
             {
                menusauvegarde();
             }
         }
        }
     }
     else
     {
         resultat = ouvertureJoueur((&joueur1));
            if(resultat == 1)
            {
                menusauvegarde();
            }
     }
 
    //gtk_widget_destroy((GtkWidget*)data);
    /* Liberation de la memoire utilisee par la liste */
    if(resultat == 1)
    {
      g_list_free(pList);
    }
    /*{
        gtk_widget_destroy((GtkWidget*)data);
    }*/
 }

23/03/2013, 00h31
liberforce
Beaucoup plus simple:
- créer une structure où tu stockes les widgets qui t'intéressent, et passer un pointeur vers la structure comme paramètre data lors de l'appel la connexion du signal.
- ou: utiliser Glade pour créer ton interface graphique, et récupérer tes widgets via GtkBuilder.
Si tu veux vraiment déboguer ton code, dans ce cas utilise un débogueur comme Nemiver sous Linux (ou gdb en ligne de commande, mais c'est un peu plus "abrupt"). Tu verras exactement à quel endroit ton code crashe.
25/03/2013, 07h53
kevingiroux

Bonjour

J'ai regarder Glade, cela semble intéressant.

Le problème c'est sur l'utilisation de la pList mon problème.

Puis-je passer la pWindow, container qui contient tout les éléments ?

Merci d'avance
29/03/2013, 13h03
liberforce

Parcourir les widgets avec un GList (que tu nommes pList) n'est pas ce qu'il y a de plus pratique, sachant que c'est du code qui va casser chaque fois que tu vas ajouter ou retirer des widgets à cet endroit là. Ça casse dès que tu change l'arborescence de tes widgets.