Problème au niveau de GTK

Bonjour / Bonsoir a tous ;)

Il y a une semaine je me suis lancer dans un projet,
crée un système de t'chat avec une interface graphique .
J'avais réussis l’échange Serveur > client , mais quand j'ai fait après
Serveur > Client et Serveur < Client Il y a plein d'erreur pas cool qui sont arriver 8O
au niveaux du client

Et c'est la ou je vient abuser de votre gentillesse :cry:

Voici les étapes du programme :
1) J’appelle la fonction qui va crée les sockets, si tous se passe bien, la fonction se finit et ont revient dans le main .

2) Création de l'interface graphique via GTK
3) Quand clique sur le bouton envoyer, ont appelle la fonction "saisie" qui envoie le text
4) ont crée un thread sur la fonction recevoir a la fin, juste avant " gtk_main(); " qui va lire les donner reçu si il en a reçu et les affiches .

Voici 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
#include <stdio.h>
#include <stdlib.h>
#include "sockets_ouv.h"
#include <gtk/gtk.h>
#include <pthread.h>
#define PORT 23
 
#if defined (WIN32)
    #include <winsock2.h>
    typedef int socklen_t;
#elif defined (linux)
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <unistd.h>
    #define INVALID_SOCKET -1
    #define SOCKET_ERROR -1
    #define closesocket(s) close(s)
    typedef int SOCKET;
    typedef struct sockaddr_in SOCKADDR_IN;
    typedef struct sockaddr SOCKADDR;
#endif
 
/* Declaration des variables globales */
GtkWidget *pText_view[2];
GtkWidget *pEntry[1];
SOCKET sock;
GtkTextBuffer* text_buffer=0;
GtkTextBuffer* text_buffer2=0;
GtkTextIter start;
GtkTextIter end;
GtkTextIter start2;
GtkTextIter end2;
 
/* ********************************** Fonction qui permet l'ouverture des sockets ************************* */
void sockets_ouverture_client()
{
    #if defined (WIN32)
        WSADATA WSAData;
        int erreur = WSAStartup(MAKEWORD(2,2), &WSAData);
    #else
        int erreur = 0;
    #endif
 
   // SOCKET sock;
    SOCKADDR_IN sin;
 //   char buffer[32] = "";
 
    /* Si les sockets Windows fonctionnent */
    if(!erreur)
    {
        /* Création de la socket */
        sock = socket(AF_INET, SOCK_STREAM, 0);
 
        /* Configuration de la connexion */
        sin.sin_addr.s_addr = inet_addr("127.0.0.1");
        sin.sin_family = AF_INET;
        sin.sin_port = htons(PORT);
 
        /* Si l'on a réussi à se connecter */
        if(connect(sock, (SOCKADDR*)&sin, sizeof(sin)) != SOCKET_ERROR)
        {
            printf("Connection à %s sur le port %d\n", inet_ntoa(sin.sin_addr), htons(sin.sin_port));
 
        }
        /* sinon, on affiche "Impossible de se connecter" */
        else
        {
            printf("Impossible de se connecter\n");
            closesocket(sock);
            #if defined (WIN32)
            WSACleanup();
            #endif
        }
 
    }
}
 
/* Fonction qui permet l'envoie de donner via la socket et aussi au niveaux de la fenetre */
void saisie(GtkButton *pButton[0])
{
    gchar* buf=0;
    const gchar* buf2=NULL;
 
    //On recupere les buffer
    text_buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(pText_view[0]));
    text_buffer2=gtk_text_view_get_buffer(GTK_TEXT_VIEW(pText_view[1]));
 
    //On recupere l'origine du buffer
     gtk_text_buffer_get_start_iter(text_buffer,&start);
     gtk_text_buffer_get_start_iter(text_buffer2,&start2);
 
    //On recupere la fin du buffer
    gtk_text_buffer_get_end_iter(text_buffer,&end);
    gtk_text_buffer_get_end_iter(text_buffer2,&end2);
 
    //On copie le contenu du buffer dans une variable
    buf=gtk_text_buffer_get_text(text_buffer,&start, &end,TRUE);
 
    // ont recupere le contenue de notre gtk_entry dans une variable
    buf2=gtk_entry_get_text(GTK_ENTRY(pEntry[0]));
 
    // ont insert le contenue de notre gtk_entry dans la text_buffer2
    gtk_text_buffer_insert(text_buffer2, &end2, buf2, -1);
    send(sock, buf2, 32, 0);
 
    gtk_text_buffer_insert(text_buffer2, &end2, " >>>: ", -1);
    send(sock, ">>>: ", 32, 0);
 
    // ont prend le Text_Buffer 2 et ont lui mets notre buf
    gtk_text_buffer_insert(text_buffer2, &end2, buf , -1);
    send(sock, buf, 32, 0);
 
    /* Ont fait un saut a la ligne */
    gtk_text_buffer_insert(text_buffer2, &end2, "\n", 1);
    send(sock, "\n", 32, 0);
 
    /* Ont suprime le contenue de notre text_buffer soit notre text_view 1 */
    gtk_text_buffer_delete(text_buffer, &start, &end);
 
 
    //On libere la memoire
    g_free(buf);
    return ;
}
 
/* ************************************* FONCTION qui permet de recevoir les donners  ************************ */
void* recevoir(void* data)
{
 
    char buffer[32] = "";
    while (1)
    {
        if(recv(sock, buffer, 32, 0))
         {
            text_buffer2=gtk_text_view_get_buffer(GTK_TEXT_VIEW(pText_view[1]));
            gtk_text_buffer_get_start_iter(text_buffer2,&start2);
            gtk_text_buffer_get_end_iter(text_buffer2,&end2);
            gtk_text_buffer_insert(text_buffer2, &end2, buffer , -1);
         }
    }
    return 0;
}
 
 
/* ******************************************************* Fonction principal ******************************************************************** */
int main(int argc, char **argv)
{
    /* Ont ouvre les sockets si c'est bon ont affiche la fenetre sinon,
     ont mets un message d'erreur et ont quitte tous */
    sockets_ouverture_client();
 
 
    /* ************************************* PARTIE GTK *************************** */
    GtkWidget *pWindow;
    GtkWidget *pTable;
    GtkWidget *pButton[1];
    GtkWidget *pLabel[2];
    GtkWidget *pFrame[2];
    GtkWidget *scrollbar[2];
 
    gtk_init(&argc, &argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 620, 400);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Systeme de T'Chat Client");
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    gtk_container_border_width (GTK_CONTAINER (pWindow), 10);
 
    /* Creation et insertion de la table 100 lignes 100 colonnes */
    pTable=gtk_table_new(100,100,TRUE);
    gtk_container_add(GTK_CONTAINER(pWindow), GTK_WIDGET(pTable));
 
    /* Creation des carrer */
    pFrame[0]= gtk_frame_new("Message reçue");
    pFrame[1]= gtk_frame_new("En ligne");
 
    /* Creation des boutons */
    pButton[0]= gtk_button_new_with_label("Envoyer");
 
    /* Creation d'un champs pour le name */
    pEntry[0]= gtk_entry_new_with_max_length(12);
 
 
    /* Creation des labels */
    pLabel[0]= gtk_label_new ("Bienvenue sur le systeme de T'chat");
    pLabel[1]= gtk_label_new("Crée par Mizio et ....");
 
    /* Creation de la Text view */
    pText_view[0]=gtk_text_view_new();
    pText_view[1]=gtk_text_view_new();
 
 
    /* Creation des scrollBar */
    scrollbar[0]=gtk_scrolled_window_new(NULL, NULL);
    scrollbar[1]=gtk_scrolled_window_new(NULL, NULL);
 
    /* Mise en boite des scollbar dans les pText_view ou l'inverse */
    gtk_container_add(GTK_CONTAINER(scrollbar[0]), pText_view[1]);
    gtk_container_add(GTK_CONTAINER(scrollbar[1]), pText_view[0]);
 
    /* Ont interdit d'editer la Text view 2 */
    gtk_text_view_set_editable (GTK_TEXT_VIEW(pText_view[1]),FALSE);
    /* Ont ne montre pas le curseur pour la text_view 2 */
    gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(pText_view[1]),FALSE);
 
 
    /* Insertino des carrer */
    gtk_table_attach_defaults(GTK_TABLE(pTable), pFrame[0], 0, 75, 20, 70);
    gtk_table_attach_defaults(GTK_TABLE(pTable), pFrame[1], 80, 95, 20, 70);
 
    /* Insertion des boutons colonne >> ligne */
    gtk_table_attach_defaults(GTK_TABLE(pTable), pButton[0],80, 95, 75, 85);
 
 
    /* Insertion des Labels */
    gtk_table_attach_defaults(GTK_TABLE(pTable), pLabel[0],20, 60, 0, 10);
    gtk_table_attach_defaults(GTK_TABLE(pTable), pLabel[1], 70, 95, 95, 100);
 
    /* Insertion de la Text view est devenue inutile car elle sont dans les conatainers avec les scrollbars */
 //   gtk_table_attach_defaults(GTK_TABLE(pTable), pText_view[0], 0, 75, 75, 95);
 //   gtk_table_attach_defaults(GTK_TABLE(pTable), pText_view[1], 2, 74, 25, 65);
 
 
    gtk_table_attach_defaults(GTK_TABLE(pTable), pEntry[0], 0, 20, 0, 10);
 
    /*Insertion des scrollBar  avec text_view */
    gtk_table_attach_defaults(GTK_TABLE(pTable), scrollbar[0], 2, 74, 25, 65);
    gtk_table_attach_defaults(GTK_TABLE(pTable), scrollbar[1], 0, 75, 75, 95);
 
 
    /* Conexion des bouttons, >> la conexion des bouttons se doti de se faire a la fin sinon, risque de bug */
     g_signal_connect(G_OBJECT(pButton[0]),"clicked",G_CALLBACK(saisie),FALSE);
 
    gtk_widget_show_all(pWindow);
 
    // On crée un thread
    pthread_t thread;
 
    // Permet d'exécuter le fonction maFonction en parallèle
    pthread_create(&thread, NULL, recevoir, NULL);
 
    gtk_main();
 
     /* On ferme la socket */
    closesocket(sock);
 
    #if defined (WIN32)
        WSACleanup();
    #endif
    return 0;
}

Voici le code d'erreur via GDB

http://img.funky-emu.net/uploads/224...2-16-47-34.png

Voila voila, en espérant avoir bien expliquer et je m’excuse pour toutes les fautes d'orthographes ect ...

Bonsoir,

Une règle : tous les appels à des fonctions de la bibliothèque GTK doivent se faire du même thread qui contient gtk_main.

recevoir essaye de lancer d'un autre thread des appels à gtk_* -> plantage.
Il faut séparer ton modèle (le moteur de tchat) de ta vue (tes fenêtres GTK). Ton modèle va avertir ta vue d'un changement et ta vue va refléter ce changement.

Comme tu utilises la bibliothèque GTK+, autant que tu jettes un coup d'oeil à l'interface GThread (qui serait adaptée à ton cas), voire même à des interfaces comme GSocket*. Du coup (de mémoire ... pas certain du fait), tu n'auras plus besoin de t'embêter avec des #if je suis sur windows/#if je suis sur linux, car GLib/GTK s'en préoccupent pour toi.

Je te remercie pour tous.
Je vais appliquer les changements :)

J'avais fait quelque chose de similaire et j'avais utilisé les threads standards et une fonction callback qui se chargeait d'aller lire les données dans le buffer (avec un mutex bien entendu). J'avais trouvé les threads gtk incompréhensible.

Par contre je n'arrive pas du tout à me souvenir du nom de la fonction callback de gtk que j'ai utilisé... Elle était appelée à chaque fois qu'il avait fini sa boucle d'event / refresh / repaint / etc... Si jamais je la retrouve je la mettrai là.