récuperer les valeurs de plusieurs gtk_entry et les stocker dans une matrice

Version imprimable

Bonjour ;
je travaille sur un programme qui permet d effectuer plusieurs opération sur les matrices, et j'utilise gtk pour a gestion de l interface graphique .
dans mon programme je demande tout d'abord a l'utilisateur de donner la taille de la matrice dans une fenêtre et ensuite je créer une autre fenêtre qui représente la matrice .
j ai aussi ajouté un bouton connecté a un signal qui appelle la fonction permettant de récupérer toutes les valeurs de la matrice .
mon problème est que je n arrive pas a récupérer ces valeur de la fenêtre vers la matrice.
c'est la fonction initialisation qui permet de faire la récupération.
mon code est le suivant :

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
#include<stdio.h>
#include<gtk/gtk.h>
#include<stdlib.h>
 
char *temp,*temp2;
int entier,temp3;
int	mat[5][5];
GtkWidget   *entre[20];
 
void    initialisation(GtkWidget *Widget, GtkWidget *data)
{
    int    i,j,k=0;
    g_print("%d\n",mat[0][0]);
    g_print("%d\n",entier);
    for(i=0;i<entier;i++)
    {
        for(j=0;j<entier;j++)
        {
           temp2 = gtk_entry_get_text(GTK_ENTRY(entre[k]));
           temp3=atoi(temp2);
           mat[i][j]=temp2;
           k++;
 
        }
    }g_print("%s",mat[0][0]);
}
void creation(GtkWidget *Widget, gpointer *Data)
{
    int    i,j;
GtkWidget   *fenetre,*boxv,*boxh[20];
GtkWidget   *evaluer;
// recupere la chaine contenu dans l'entree
    temp = gtk_entry_get_text(GTK_ENTRY(Data));
    entier=atoi(temp);
    fenetre=gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(fenetre),"les  entres  de  donnees avec    les matrices");
    g_signal_connect(G_OBJECT(fenetre),"destroy",G_CALLBACK(gtk_main_quit),NULL);
 
    boxv=gtk_vbox_new(TRUE,0);
    gtk_container_add(GTK_CONTAINER(fenetre),boxv);
 
    for(i=0;i<entier;i++)
    {
    boxh[i]=gtk_hbox_new(FALSE,0);
    gtk_box_pack_start(GTK_BOX(boxv),boxh[i], TRUE,FALSE, 0);
 
    for(j=0;j<entier;j++)
    {
        entre[j]=gtk_entry_new();
        gtk_box_pack_start(GTK_BOX(boxh[i]),entre[j], TRUE, FALSE, 0);
    }
}
evaluer=gtk_button_new_with_label("evaluer");
gtk_box_pack_start(GTK_BOX(boxv),evaluer, TRUE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(evaluer), "clicked", GTK_SIGNAL_FUNC (initialisation),(gpointer)entre);
gtk_widget_show_all(fenetre);
    gtk_main();
}
 
 
int main(int    argc,char   **argv)
{
    GtkWidget   *pwindows,*pvbox,*label,*pbouton;
    GtkWidget    *pentry;
    gchar       *texte=NULL;
    gtk_init(&argc,&argv);
    pwindows=gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_default_size(GTK_WINDOW(pwindows),200,200);
    gtk_window_set_title(GTK_WINDOW(pwindows),"les  entres  de  donnees avec    les matrices");
    g_signal_connect(G_OBJECT(pwindows),"destroy",G_CALLBACK(gtk_main_quit),NULL);
    pvbox=gtk_vbox_new(TRUE,0);
    gtk_container_add(GTK_CONTAINER(pwindows),pvbox);
    texte="veillez  donner  la  taille  de  la  matrice";
    label=gtk_label_new(texte);
    gtk_box_pack_start(GTK_BOX(pvbox),label,TRUE,FALSE,0);
    pentry=gtk_entry_new();
    gtk_box_pack_start(GTK_BOX(pvbox),pentry,TRUE,FALSE,0);
    pbouton=gtk_button_new_with_label("valider");
    gtk_box_pack_start(GTK_BOX(pvbox),pbouton,TRUE,FALSE,0);
 
 
    gtk_signal_connect(GTK_OBJECT(pbouton), "clicked", GTK_SIGNAL_FUNC (creation), (gpointer)pentry);
    gtk_signal_connect(GTK_OBJECT(pentry), "activate", GTK_SIGNAL_FUNC (creation), (gpointer)pentry);
 
    //g_signal_connect(G_OBJECT(pbouton), "clicked", G_CALLBACK(gtk_main_quit), NULL);
    gtk_widget_show_all(pwindows);
    gtk_main();
 
return  0;
}

Merci d'avance .

Tu te trompes en stockant et en écrivant les adresses des GtkEntry que tu as stocké dans ton tableau nommé "entre".
Code:

1 2 3 4 5 6 7 8 9 10 11 12 for(i=0;i<entier;i++) { boxh[i]=gtk_hbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(boxv),boxh[i], TRUE,FALSE, 0); for(j=0;j<entier;j++) { entre[j]=gtk_entry_new(); gtk_box_pack_start(GTK_BOX(boxh[i]),entre[j], TRUE, FALSE, 0); } }
Ici le soucis c'est que tu écrases entre[j] pour chaque ligne de valeur. Pour une matrice de 3×3, tu écris aux indices: 0, 1, 2, 0, 1, 2, 0, 1, 2. Normalement tu devrais écrire à 0, 1, 2, 3, 4, 5, 6, 7, 8. Pense à initialiser tes pointeurs à NULL pour éviter de passer des valeurs aléatoires à des fonctions GTK. Ici tu passais des valeurs de ton tableau non-initialisé en disant à GTK que c'était des pointeur vers de GtkEntry...

Prends aussi l'habitude de compiler avec le flags -Wall qui t'ajoutera un maximum de warnings pour détecter les problèmes de ton code.

merci de votre aide, finalement j'ai trouver l'erreur. En fait l'erreur se trouvais au niveau des indices, j ai rectifié et sa marche .

J'ai introduit l'indice k dans la fonction initialisation et la fonction creation.

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
#include<stdio.h>
#include<gtk/gtk.h>
#include<stdlib.h>
 
char *temp,*temp2;
int entier,temp3;
int mat[5][5];
GtkWidget *entre[20];
 
void initialisation(GtkWidget *Widget, GtkWidget *data)
{
int i=0,j=0,k=0;
 
for(i=0;i<entier;i++)
{
for(j=0;j<entier;j++)
{
temp2 = gtk_entry_get_text(GTK_ENTRY(entre[k]));
temp3=atoi(temp2);
mat[i][j]=temp3;
g_print("%d\n",mat[i][j]);
k++;
}
}
 
}
void creation(GtkWidget *Widget, gpointer *Data)
{
int i,j,k=0;
GtkWidget *fenetre,*boxv,*boxh[20];
GtkWidget *evaluer,*fermer;
// recupere la chaine contenu dans l'entree
temp = gtk_entry_get_text(GTK_ENTRY(Data));
entier=atoi(temp);
fenetre=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(fenetre),"les entres de donnees avec les matrices");
g_signal_connect(G_OBJECT(fenetre),"destroy",G_CALLBACK(gtk_main_quit),NULL);
 
boxv=gtk_vbox_new(TRUE,0);
gtk_container_add(GTK_CONTAINER(fenetre),boxv);
 
for(i=0;i<entier;i++)
{
boxh[i]=gtk_hbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(boxv),boxh[i], TRUE,FALSE, 0);
 
for(j=0;j<entier;j++)
{
entre[k]=gtk_entry_new();
gtk_box_pack_start(GTK_BOX(boxh[i]),entre[k], TRUE, FALSE, 0);
k++;
}
}
evaluer=gtk_button_new_with_label("evaluer");
fermer=gtk_button_new_with_label("fermer");
gtk_box_pack_start(GTK_BOX(boxv),evaluer, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(boxv),fermer, TRUE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(evaluer), "clicked", GTK_SIGNAL_FUNC (initialisation),(gpointer)entre);
g_signal_connect(G_OBJECT(fermer), "clicked", gtk_main_quit, NULL);
gtk_widget_show_all(fenetre);
gtk_main();
}
 
 
int main(int argc,char **argv)
{
GtkWidget *pwindows,*pvbox,*label,*pbouton;
GtkWidget *pentry;
gchar *texte=NULL;
gtk_init(&argc,&argv);
pwindows=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(pwindows),200,200);
gtk_window_set_title(GTK_WINDOW(pwindows),"les entres de donnees avec les matrices");
g_signal_connect(G_OBJECT(pwindows),"destroy",G_CALLBACK(gtk_main_quit),NULL);
pvbox=gtk_vbox_new(TRUE,0);
gtk_container_add(GTK_CONTAINER(pwindows),pvbox);
texte="veillez donner la taille de la matrice";
label=gtk_label_new(texte);
gtk_box_pack_start(GTK_BOX(pvbox),label,TRUE,FALSE,0);
pentry=gtk_entry_new();
gtk_box_pack_start(GTK_BOX(pvbox),pentry,TRUE,FALSE,0);
pbouton=gtk_button_new_with_label("valider");
gtk_box_pack_start(GTK_BOX(pvbox),pbouton,TRUE,FALSE,0);
 
 
gtk_signal_connect(GTK_OBJECT(pbouton), "clicked", GTK_SIGNAL_FUNC (creation), (gpointer)pentry);
gtk_signal_connect(GTK_OBJECT(pentry), "activate", GTK_SIGNAL_FUNC (creation), (gpointer)pentry);
//g_signal_connect(G_OBJECT(pbouton), "clicked", G_CALLBACK(gtk_main_quit), NULL);
gtk_widget_show_all(pwindows);
gtk_main();
return 0;
}

02/03/2012, 10h57
troumad
Bonjour

Je me permets plusieurs remarques sur le programme :
1) évite les variables globales
Code:

1 2 int mat[5][5]; GtkWidget *entre[20];
Il est vrai que là, ça peut simplifier le travail. Mais, si tu commences à prévoir d'utiliser plusieurs matrices (un nombre indéterminé), tu pourras vite en comprendre l'intérêt.
Code:

1 2 char *temp,*temp2; int entier,temp3;
En tant que temporaire ces variable n'ont rien à faire comme globlaes, il risquerait y avoir des effats de bord.
2) essaie d'allouer ton tableau dynamiquement :
Code:

1 2 3 4 5 6 7 #define TAILLE 5 signed long **mat; mat=(signed long **)malloc(TAILLE*sizeof(signed long *)); for (i=0;i<TAILLE;i++) mat[i]=(signed long *)malloc(TAILLE*sizeof(signed long));
Tu comprendras vite l'intérêt si tu veux faire un calcul de déterminant. C'est beaucoup plus simple !
3) J'ai mis signed long car int est à proscrire dans une programmation sécurisée (interdit par exemple pour eurocoptère et on doit à int le crash d'une fusée ariane). Autant prendre de bonnes habitudes dès le départ.
4) Finalement, j'ai mis un #define pour la taille, ça te permettra de changer facilement la taille sans problème si un jour tu veux le faire.

OK... Mes deux dernières remarques sont un peu exagérées, mais, il faut y penser.

nb : As-tu résolu le problème ?
02/03/2012, 11h27
liberforce

Citation:

Envoyé par troumad

OK... Mes deux dernières remarques sont un peu exagérées, mais, il faut y penser.

La remarque n°3 est même clairement abusée... Si tu ne travailles pas dans l'embarqué, tu auras rarement à te poser la question de savoir quelle taille fait un int, mais prendre un signed long pour compter des valeurs qui tiennent dans un char...

De plus, la GLib fournit des types permettant d'abstraire ce problème: en plus de gint (comparable à l'int de base), elle fournit gint8, gint16, gint32, gint64 (et leurs variantes non signées).

Au passage, caster le résultat d'un malloc ne sert à rien, un void * se convertit automatiquement en pointeur vers n'importe quelle valeur. Cela ne fait qu'alourdir l'écriture et nuit à la lisibilité du code.

Pour les tableaux dynamiques, la GLib fournit GPtrArray, GArray, GByteArray... Cela évite d'utiliser des define pour les tailles de tableau, et t'évite donc de recompiler dès que tu manques de place...

Ensuite, malloc renvoie NULL si tu n'as plus assez de mémoire, ce qui fait que ton programme peut crasher sans que tu saches pourquoi suite à un manque de mémoire. C'est pour cela que la GLib fournit là encore des remplaçants: g_malloc, g_new, etc., à libérer avec g_free Ces fonctions tuent l'application (erreur fatale) si ton allocation mémoire échoue. g_try_malloc conserve un fonctionnement proche de malloc, en renvoyant NULL dans les cas om tu as une grosse allocation à faire dont tu n'es pas sûr qu'elle réussisse.

Bref: avant de rentrer dans les détails, il faut maîtriser l'essentiel. Et le C possède de nombreux pièges.