rafraichir ecran avec une echelle de couleur

**mdrhaha** · 11/05/2010, 18h26

Bonjour,

j'ai commencé a codé en gtk il y a quelque temps et il y a qqs trucs que j'ai toujours pas assimilé.
Dans, mon code j'ouvre une fenetre ou j'affiche une rectangle et a l'interieur de ce meme rectange j'affiche plusieurs rectangles.
Et, a coté de ce rectangle j'affiche 3 rectangle avec des couleurs différentes pour definir une echelle de couleur.
De plus, j'ai 2 boutons, Lecture et Pause.

Ainsi, je voudrai changer la couleur de chaque rectangle a l'interieur de mon grand rectangle, pour cela j'aimerai definir un pas de temps et rafraichir l'ecran a chaque pas de temps afin d'afficher differentes couleurs dans mon rectangle.

Bon, voila mon code.

**monnomamoi** · 11/05/2010, 22h34

Salut,

Regarde du côté de la fonction g_timeout_add pour exécuter une fonction à intervalle régulier.

La fonction sera alors exécutée périodiquement tant qu'elle ne renvoie pas FALSE. Tu peux par exemple renvoyer une variable "test" qui sera mise à TRUE si l'utilisateur appuie sur Lecture, et à FALSE s'il appuie sur PAUSE. Ou bien exécuter la fonction quoi qu'il arrive mais en ne dessinant que si "test" est vrai.

Le signal associé aux clics sur les boutons est "clicked".

-

**mdrhaha** · 11/05/2010, 23h05

merci pour ta reponse

enfaite jai deja essayé d'utiliser g_timeout_add
mais le problème je sais pas koi mettre dans la fonction a appeller...
et meme dans data?

**monnomamoi** · 12/05/2010, 19h11

Dans data, tu mets un pointeur vers les données que tu veux passer à la fonction. Par défaut, si tu n'as besoin de rien, c'est NULL.

Ça donnera un truc du genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
TEST_CONTINUE = TRUE;
//..
  // Appel toutes les 1000 ms :
  g_timeout_add(1000, (GSourceFunc)rafraichir, NULL);
// ...
gboolean rafraichir(gpointer data)
{
  //..
  return TEST_CONTINUE;
}

**mdrhaha** · 13/05/2010, 20h51

enfaite j'ai reussi a faire un chronomètre et meme je rafraichi toute les secondes environ...
et mon problème maintenant c que je voudrai faire en sorte que je choisi une couleur entre les 3 couleurs que j'ai defini et que je l'ajoute dans un des rectangles du grand rectangle a chaque pas de temps tps.
Comment je pourais faire ceci?

Voila mon nouveau code :

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
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
 
#include <stdlib.h>
#include <gtk/gtk.h>
#include <string.h>
#include <time.h>
 
static GdkColor couleur[] =
{
  {0, 0xFFFF, 0x0, 0x0},
  {0, 0xFFFF, 0x0, 0x7530},
  {0, 0xFFFF, 0x7530, 0xFDE8},
};
 
struct _MainWindow
{
    GtkWidget *fenetre, *Vbox, *Hbox, *bouton[1], *area;
    time_t temps;
    gboolean appui;
    guint test;
    int tps, jour, heure, min;
 
};
 
typedef struct _MainWindow MainWindow;
 
 
int Rectangle(GtkWidget *area, gpointer data);
int EchelleCouleur(GtkWidget *area, gpointer data);
int chrono_start(GtkWidget *, gpointer data);
int chrono_stop(GtkWidget *, gpointer data);
gboolean chrono(gpointer data);
int choix(gpointer data, int k);
 
int main(int argc, char **argv)
{
    MainWindow *pf;
 
    pf = (MainWindow*)g_malloc(sizeof(MainWindow));
 
    gtk_init (&argc, &argv);
 
    pf->fenetre = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_container_set_border_width(GTK_CONTAINER(pf->fenetre), 5);
    gtk_window_set_title(GTK_WINDOW(pf->fenetre), "Simulateur hydraulique de Colonnes Pulsees");
    gtk_window_set_default_size(GTK_WINDOW(pf->fenetre), 320, 200);
    g_signal_connect(G_OBJECT(pf->fenetre), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
    pf->Vbox = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(pf->fenetre), pf->Vbox);
 
    pf->Hbox = gtk_hbox_new(TRUE, 0);
    gtk_box_pack_start(GTK_BOX(pf->Vbox), pf->Hbox, FALSE, FALSE, 0);
 
    pf->bouton[0] = gtk_button_new_with_label("Lecture/Reprise");
    gtk_box_pack_start(GTK_BOX(pf->Hbox), pf->bouton[0], TRUE, TRUE, 0);
 
    pf->bouton[1] = gtk_button_new_with_label("Pause");
    gtk_box_pack_start(GTK_BOX(pf->Hbox), pf->bouton[1], TRUE, TRUE, 0);
 
    pf->area = gtk_drawing_area_new();
    gtk_drawing_area_size((GtkDrawingArea*)pf->area, 500, 500);
    gtk_box_pack_start(GTK_BOX(pf->Vbox), pf->area, TRUE, TRUE, 5);
 
    g_signal_connect(G_OBJECT(pf->area), "expose-event", G_CALLBACK(Rectangle), (gpointer)pf);
    g_signal_connect(G_OBJECT(pf->area), "expose-event", G_CALLBACK(EchelleCouleur), (gpointer)pf);
    g_signal_connect(G_OBJECT(pf->bouton[0]), "clicked", G_CALLBACK(chrono_start), (gpointer*)pf);
    g_signal_connect(G_OBJECT(pf->bouton[1]), "clicked", G_CALLBACK(chrono_stop), (gpointer*)pf);
 
 
    gtk_widget_show_all(pf->fenetre);
 
    gtk_main();
 
    g_free(pf);
 
    return EXIT_SUCCESS;
}
 
int Rectangle(GtkWidget *area, gpointer data)
{
    MainWindow *pf;
    pf = (MainWindow*)data;
 
    gdk_draw_rectangle(area->window, area->style->black_gc, FALSE, 225, 100, 50, 300);
 
    for(int i=0; i<6; i++)
    {
        gdk_draw_rectangle(area->window, area->style->white_gc, FALSE, 225, 100+50*i, 50, 50);
    }
 
    return 0;
}
 
int EchelleCouleur(GtkWidget *area, gpointer data)
{
    MainWindow *pf;
    pf = (MainWindow*)data;
 
    GdkFont *font = NULL;
    font = gdk_font_load ("-Adobe-Helvetica-Bold-R-Normal--*-100-*-*-*-*-*-*");
 
    GdkColormap *colormap;
    colormap = gdk_drawable_get_colormap(area->window);
 
    for(int i=0; i<3; i++)
    {
 
 
        gdk_colormap_alloc_color(colormap,&couleur[i],TRUE, FALSE);
 
        gdk_gc_set_foreground(area->style->fg_gc[GTK_WIDGET_STATE(area)], &couleur[i]);
 
        gdk_draw_rectangle(area->window, area->style->fg_gc[GTK_WIDGET_STATE(area)], TRUE, 50, 240+55*i, 50, 50);
    }
 
    gdk_draw_string (area->window, font, area->style->black_gc, 105, 270, "0");
    gdk_draw_string (area->window, font, area->style->black_gc, 105, 320, "10");
    gdk_draw_string (area->window, font, area->style->black_gc, 105, 375, "20");
 
    return 0;
}
 
int chrono_start(GtkWidget *bouton, gpointer data)
{
    MainWindow *pf;
    pf = (MainWindow*)data;
 
 
 
    pf->appui = TRUE;
    pf->temps=time(NULL);
    pf->test = g_timeout_add(1, chrono, (gpointer)pf);
 
 
 
    return 0;
}
 
int chrono_stop(GtkWidget *bouton, gpointer data)
{
    MainWindow *pf;
    pf = (MainWindow*)data;
    pf->appui = FALSE;
    gdk_draw_rectangle(pf->area->window, pf->area->style->white_gc, TRUE, 0, 0, 50, 50);
    return 0;
}
 
gboolean chrono(gpointer data)
{
    MainWindow *pf;
    pf = (MainWindow*)data;
 
    GdkColormap *colormap;
    colormap = gdk_drawable_get_colormap(pf->area->window);
 
    GdkFont *font = NULL;
    font = gdk_font_load ("-Adobe-Helvetica-Bold-R-Normal--*-100-*-*-*-*-*-*");
 
 
    for(int i=0; i<6; i++)
    {
 
        gdk_colormap_alloc_color(colormap,&couleur[i],TRUE, FALSE);
 
        gdk_gc_set_foreground(pf->area->style->fg_gc[GTK_WIDGET_STATE(pf->area)], &couleur[i]);
 
 
        gdk_draw_rectangle(pf->area->window, pf->area->style->fg_gc[GTK_WIDGET_STATE(pf->area)], TRUE, 225, 100+50*i, 50, 50);
    }
 
    gchar buf[32];
 
    time_t tA=0;
 
 
    if (pf->appui==FALSE)
    {
    return pf->appui;
    }
 
     tA=time(NULL);
 
     //définir les textes des trois GtkEntry pour  les heures et les minutes les secondes
     pf->tps=tA-pf->temps;
     pf->jour =pf->tps/(24*60*60);
     pf->tps-= pf->jour*24*60*60;
     pf->heure= pf->tps/(60*60);
     pf->tps-=pf->heure*60*60;
     pf->min =pf->tps/60;
     pf->tps-=pf->min*60;
 
     sprintf(buf,"%d h %d min %d sec",pf->heure, pf->min, pf->tps);
     gdk_draw_string (pf->area->window, font, pf->area->style->black_gc, 300, 50, buf);
 
 
 
 
 
 
 
 
gtk_widget_queue_draw(GTK_WIDGET(pf->area));
 
 
 
     gtk_widget_show_all(pf->fenetre);
 
 
    return pf->appui;
}

**monnomamoi** · 15/05/2010, 03h29

Je ne suis pas sûr d'avoir compris ta question, mais si tu cherches à remplir un rectangle avec une certaine couleur, alors je crois qu'il faut carrément le redessiner.

-

**mdrhaha** · 15/05/2010, 13h34

oui c ca je veux remplir un rectangle quelqonk avec une couleur quelqonk et ceux-ci pour chaque pas de temps...
sinon comment je fais pour le redessiner?

**gerald3d** · 16/05/2010, 11h57

C'est dimanche. Je suis d'humeur à faire un petit cadeau.

Un code exemple simpliste fera l'affaire

:

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
struct SGlobalData
{
	gint index;
    GtkWidget *DrawingArea;
    GdkColor color[5];
};
 
typedef struct SGlobalData GlobalData;
 
gboolean Callback_expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer user_data)
{
	GlobalData *data=(GlobalData*)user_data;
	GdkGC *gc;
 
	// On affecte la couleur en fonction de la valeur de l'index.
	gc=gdk_gc_new(widget->window);
	gdk_gc_set_foreground (gc, &data->color[data->index]);
	gdk_draw_rectangle(widget->window, gc, true, widget->allocation.width/2-25, widget->allocation.height/2-25, 50,50);
 
	g_object_unref(gc);
 
	return FALSE;
}
 
gboolean Callback_Timeout(gpointer user_data)
{
	GlobalData *data=(GlobalData*)user_data;
 
	data->index++;
	if (data->index>4) data->index=0;
 
	// Appel de la fonction de dessin du GtkDrawingArea	
	Callback_expose_event(data->DrawingArea, NULL, data);
 
	return TRUE;
}
 
int main (int argc, char **argv)
{
	GtkWidget *window=NULL;
	GlobalData data;
 
	gtk_init(&argc, &argv);
 
	/* On affecte une couleur différente */
	data.color[0].pixel=0x000000;
	data.color[1].pixel=0xFF0000;
	data.color[2].pixel=0x00FF00;
	data.color[3].pixel=0x0000FF;
	data.color[4].pixel=0xFFFFFF;
 
	// Initialisation de l'index de couleur
	data.index=0;
 
	window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(window), "Test rectangle couleur");
	gtk_widget_set_size_request(window, 640, 480);
 
 
	data.DrawingArea = gtk_drawing_area_new();
	gtk_container_add(GTK_CONTAINER(window), data.DrawingArea);
	g_signal_connect(G_OBJECT(data.DrawingArea), "expose-event", GCallback(Callback_expose_event), &data);
 
	// On lance une fonction toutes les secondes pour changer la couleur du rectangle
	g_timeout_add_seconds(1, (GSourceFunc)Callback_Timeout, &data);
 
	// signaux pour la fermeture de l'application
	g_signal_connect(GTK_OBJECT(window), "delete_event", (GtkSignalFunc)gtk_exit, NULL);
	g_signal_connect(GTK_OBJECT(window), "destroy", (GtkSignalFunc)gtk_exit, NULL);
 
	gtk_widget_show_all(window);
 
	gtk_main();
 
	return EXIT_SUCCESS;
}

**mdrhaha** · 18/05/2010, 21h58

merci, ton code ma vraiment aidé...
Maintenant, j'ai un nouveau problème :

je veux ouvrir un fichier text qui a son tour ouvre un autre fichier texte et ainsi je lis mes paramètres contenues dans ces deux fichiers et je les ajoutes dans deux vecteurs differents.
Ces paramètres me permettent de definir la hauteur et le diametre, puis la position (x,y) de mon rectangle.

Ensuite, en utilisant ta fonction je veux faire varier les couleurs de haut en bas du rectangle que j'ai dessiner grace aux parametres obtenus...

Seulement, j'ai un problème SEGMENTATION FAULT!!!

voila mon code, si qq1 pouvait me dire mon erreur ca fait des heures k jsui dessus et...

mon Interface.h :

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
 
#ifndef INTERFACE_H_INCLUDED
#define INTERFACE_H_INCLUDED
 
#include <gtk/gtk.h>
#include <vector.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <time.h>
#include <fstream.h>
 
using namespace std;
 
 
struct GlobalData
{
	gint index;
	gint choix;
	gint x, y, tps, jour, heure, min;
    GtkWidget *fenetre, *area, *Vbox, *Hbox, *bouton[3], *pMenu, *pMenuBar, *pMenuItem;
    time_t temps;
    gboolean appui;
    GdkColor color[19];
};
 
void ChargeDim(char *chemin);
void ChargeCoord(char *chemin);
gboolean Callback_Timeout(gpointer user_data);
int chrono_start(GtkWidget *widget, gpointer user_data);
int chrono_stop(GtkWidget *widget, gpointer user_data);
int chrono_continue(GtkWidget *widget, gpointer user_data);
int Couleur(GtkWidget *widget, GdkEventExpose *event, gpointer user_data);
void Nouveau(GtkWidget *widget, gpointer user_data);
int Rectangle (GtkWidget *widget, gpointer user_data);
 
 
 struct Coord
{
    string chemin;
    gint X;
    gint Y;
};
 
 
  struct Dim
    {
        gint H;
        gint D;
    };
 
 
 
#endif // INTERFACE_H_INCLUDED

mon main.c :

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
 
#include "Interface.h"
 
 
int main (int argc, char **argv)
{
	GlobalData *data=NULL;
 
	data = (GlobalData*)g_malloc(sizeof(GlobalData));
 
	gtk_init(&argc, &argv);
 
	/* On affecte une couleur différente */
	data->color[0].pixel=0x000000;
	data->color[1].pixel=0xF00000;
	data->color[2].pixel=0x0F0000;
	data->color[3].pixel=0x00F000;
	data->color[4].pixel=0x000F00;
	data->color[5].pixel=0x0000F0;
	data->color[6].pixel=0x00000F;
	data->color[7].pixel=0xF0000F;
	data->color[8].pixel=0xF000F0;
	data->color[9].pixel=0xF00F00;
	data->color[10].pixel=0xF0F000;
	data->color[11].pixel=0xFF0000;
	data->color[12].pixel=0x0FF000;
	data->color[13].pixel=0x0F0F00;
	data->color[14].pixel=0x0F00F0;
	data->color[15].pixel=0x0F000F;
	data->color[16].pixel=0x00FF00;
	data->color[17].pixel=0x00F0F0;
	data->color[18].pixel=0x00F00F;
 
 
 
	// Initialisation de l'index de couleur
	data->index=0;
	data->x=225;
	data->y=50;
	data->jour=0;
	data->heure=0;
	data->min=0;
 
	data->fenetre=gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(data->fenetre), "Test rectangle couleur");
	gtk_widget_set_size_request(data->fenetre, 500, 500);
 
    data->Vbox = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(data->fenetre), data->Vbox);
 
    data->pMenuBar = gtk_menu_bar_new();
 
    /* Premier sousmenu
    ETAPE 2 */
    data->pMenu = gtk_menu_new();
    /* ETAPE 3 */
    data->pMenuItem = gtk_menu_item_new_with_label("Nouveau");
    g_signal_connect(G_OBJECT(data->pMenuItem), "activate", G_CALLBACK(Nouveau), (gpointer)data);
    gtk_menu_shell_append(GTK_MENU_SHELL(data->pMenu), data->pMenuItem);
 
    /* ETAPE 4 */
    data->pMenuItem = gtk_menu_item_new_with_label("Fichier");
    /* ETAPE 5 */
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(data->pMenuItem), data->pMenu);
    /* ETAPE 6 */
    gtk_menu_shell_append(GTK_MENU_SHELL(data->pMenuBar), data->pMenuItem);
 
 
    /* Ajout du menu a la fenetre */
    gtk_box_pack_start(GTK_BOX(data->Vbox), data->pMenuBar, FALSE, FALSE, 0);
 
 
    data->Hbox = gtk_hbox_new(TRUE, 0);
    gtk_box_pack_start(GTK_BOX(data->Vbox), data->Hbox, FALSE, FALSE, 0);
 
 
 
    data->bouton[0] = gtk_button_new_with_label("Lecture");
    gtk_box_pack_start(GTK_BOX(data->Hbox), data->bouton[0], TRUE, TRUE, 0);
    data->bouton[1] = gtk_button_new_with_label("Pause");
    gtk_box_pack_start(GTK_BOX(data->Hbox), data->bouton[1], TRUE, TRUE, 0);
    data->bouton[2] = gtk_button_new_with_label("Reprise");
    gtk_box_pack_start(GTK_BOX(data->Hbox), data->bouton[2], TRUE, TRUE, 0);
    data->bouton[3] = gtk_button_new_with_label("Nouveau");
    gtk_box_pack_start(GTK_BOX(data->Hbox), data->bouton[3], TRUE, TRUE, 0);
    data->bouton[4] = gtk_button_new_with_label("Affichage");
    gtk_box_pack_start(GTK_BOX(data->Hbox), data->bouton[4], TRUE, TRUE, 0);
 
 
	data->area = gtk_drawing_area_new();
	gtk_box_pack_start(GTK_BOX(data->Vbox), data->area, TRUE, TRUE, 5);
 
 
 
	g_signal_connect(GTK_OBJECT(data->fenetre), "delete_event", (GtkSignalFunc)gtk_exit, NULL);
	g_signal_connect(GTK_OBJECT(data->fenetre), "destroy", (GtkSignalFunc)gtk_exit, NULL);
	g_signal_connect(G_OBJECT(data->bouton[0]), "clicked", G_CALLBACK(chrono_start), (gpointer*)data);
    g_signal_connect(G_OBJECT(data->bouton[1]), "clicked", G_CALLBACK(chrono_stop), (gpointer*)data);
    g_signal_connect(G_OBJECT(data->bouton[2]), "clicked", G_CALLBACK(chrono_continue), (gpointer*)data);
    g_signal_connect(G_OBJECT(data->area), "expose-event", G_CALLBACK(Couleur), (gpointer)data);
    g_signal_connect(G_OBJECT(data->area), "expose-event", G_CALLBACK(Rectangle), (gpointer)data);
 
 
	gtk_widget_show_all(data->fenetre);
 
	gtk_main();
 
	g_free(data);
 
	return EXIT_SUCCESS;
}

mon Interface.cpp :

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
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
 
#include "Interface.h"
 
vector<Coord> cord;
vector<Dim> dim;
 
Dim bufferDim;
Coord bufferCoord;
 
 
int Callback_expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer user_data)
{
	GlobalData *data=(GlobalData*)user_data;
	GdkGC *gc;
 
	gint z=50;
 
	// On affecte la couleur en fonction de la valeur de l'index.
	gc=gdk_gc_new(widget->window);
	gdk_gc_set_foreground (gc, &data->color[data->index]);
	gdk_draw_rectangle(widget->window, gc, true, data->x, data->y, z, 50);
 
	g_object_unref(gc);
 
 
	return 0;
}
 
gboolean Callback_Timeout(gpointer user_data)
{
	GlobalData *data=(GlobalData*)user_data;
 
	GdkFont *font = NULL;
    font = gdk_font_load ("-Adobe-Helvetica-Bold-R-Normal--*-100-*-*-*-*-*-*");
 
	data->index++;
	data->y = data->y + 50;
	if(data->y>500) data->y=100;
	if (data->index>4) data->index=0;
 
	// Appel de la fonction de dessin du GtkDrawingArea
	Callback_expose_event(data->area, NULL, data);
 
	gchar buf[32];
 
    time_t tA=0;
 
     tA=time(NULL);
 
 
     data->tps=tA-data->temps;
     data->jour =data->tps/(24*60*60);
     data->tps-= data->jour*24*60*60;
     data->heure= data->tps/(60*60);
     data->tps-=data->heure*60*60;
     data->min =data->tps/60;
     data->tps-=data->min*60;
 
     sprintf(buf,"%d h %d min %d sec",data->heure, data->min, data->tps);
     gdk_draw_string (data->area->window, font, data->area->style->black_gc, 800, 50, buf);
 
     gtk_widget_queue_draw(GTK_WIDGET(data->area));
 
     g_free(buf);
 
	return data->appui;
}
 
int chrono_start(GtkWidget *widget, gpointer user_data)
{
    GlobalData *data=(GlobalData*)user_data;
 
    data->appui = TRUE;
    data->temps=time(NULL);
    g_timeout_add(1000, (GSourceFunc)Callback_Timeout, (gpointer)data);
 
    return 0;
}
 
int chrono_stop(GtkWidget *widget, gpointer user_data)
{
    GlobalData *data=(GlobalData*)user_data;
 
    data->appui = FALSE;
 
    return 0;
}
 
int chrono_continue(GtkWidget *widget, gpointer user_data)
{
    GlobalData *data=(GlobalData*)user_data;
 
    data->appui = TRUE;
 
    g_timeout_add(1000, (GSourceFunc)Callback_Timeout, (gpointer)data);
 
    return 0;
}
 
int Couleur(GtkWidget *widget, GdkEventExpose *event, gpointer user_data)
{
    GlobalData *data=(GlobalData*)user_data;
	GdkGC *gc;
 
 
	gc=gdk_gc_new(widget->window);
 
	for(int i=0; i<19; i++)
	{
	gdk_gc_set_foreground (gc, &data->color[i]);
	gdk_draw_rectangle(data->area->window, gc, true, 50, 50+i*26, 30, 25);
	}
 
	g_object_unref(gc);
 
	return 0;
}
 
 
void Nouveau(GtkWidget *widget, gpointer user_data)
{
    GlobalData *data=(GlobalData*)user_data;
    GtkWidget *pFileSelection;
    GtkWidget *pParent;
    GtkFileFilter *filter;
    gchar *sChemin;
 
    pParent = GTK_WIDGET(user_data);
 
    /* Creation de la fenetre de selection */
    pFileSelection = gtk_file_chooser_dialog_new("Ouvrir...",
	GTK_WINDOW(pParent),
	GTK_FILE_CHOOSER_ACTION_OPEN,
	GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
	GTK_STOCK_OPEN, GTK_RESPONSE_OK,
	NULL);
    /* On limite les actions a cette fenetre */
    gtk_window_set_modal(GTK_WINDOW(pFileSelection), TRUE);
 
 
    // on positionne des filtres pour n'afficher que les fichiers *.txt
    gtk_window_set_modal(GTK_WINDOW(pFileSelection), TRUE);
    filter = gtk_file_filter_new();
    gtk_file_filter_add_pattern (filter, "*.txt");
    gtk_file_filter_set_name(filter, "Filtres");
    gtk_file_chooser_set_filter (GTK_FILE_CHOOSER(pFileSelection) , filter);
 
 
 
    /* Affichage fenetre */
    switch(gtk_dialog_run(GTK_DIALOG(pFileSelection)))
    {
        case GTK_RESPONSE_OK:
            /* Recuperation du chemin */
            sChemin = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(pFileSelection));
 
 
    ChargeCoord(sChemin);
 
	    g_free(sChemin);
 
 
            break;
        default:
            break;
    }
    gtk_widget_destroy(pFileSelection);
 
}
 
 
 
void ChargeCoord(char *chemin)
{
    ifstream f(chemin, ios::in);
 
        f >> bufferCoord.chemin;
 
    string str = bufferCoord.chemin;
    // créer le buffer pour copier la chaîne
    size_t size = str.size() + 1;
    char * buffer = new char[ size ];
    // copier la chaîne
    strncpy( buffer, str.c_str(), size );
 
        ChargeDim(buffer);
 
          // libérer la mémoire
    delete [] buffer;
 
        f >> bufferCoord.X >> bufferCoord.Y;
 
        cord.push_back(bufferCoord);
 
 
    f.close();
}
 
 
void ChargeDim(char *chemin)
{
    //On ouvre en lecture
    ifstream fichier(chemin, ios::in);
 
    /*on lit jusqu'à l'espace et on stocke ce qui est lu dans la variable indiquée */
    fichier >> bufferDim.H >> bufferDim.D;
 
 
    dim.push_back(bufferDim);
 
    fichier.close();
}
 
 
 
int Rectangle (GtkWidget *widget, gpointer user_data)
{
    GlobalData *data=(GlobalData*)user_data;
 
        gint X = bufferCoord.X;
        gint Y = bufferCoord.Y;
        gint H = bufferDim.H;
        gint D = bufferDim.D;
 
 
        // Rectangle
        gdk_draw_rectangle(data->area->window, data->area->style->black_gc, FALSE, X, Y, H, D);
 
 
    return 0;
}

**teuf13** · 18/05/2010, 23h08

Dans ChargeCoord, j'ai l'impression que tu t'embêtes poru pas grand chose, tu dois pouvoir faire directement ChargeDim (str.c_str()). Ou mieux, utiliser des std::string comme argument à ChargeDim.

Ton crash vient probablement de Callback_Timeout où tu tentes d'appeler g_free sur de la mémoire allouée dans la pile.

**mdrhaha** · 19/05/2010, 13h35

enfaite quand j'enlève le g_free ca ne me modifie rien, j'ai toujours un bug quand je fais fichier->nouveau et que je selectionne mon fichier texte, puis quand je l'ouvre j'ai toujours le message
memoire was not read...

**teuf13** · 19/05/2010, 18h09

C'est le moment de regarder comment tu peux utiliser un debugger pour qu'il t'indique l'endroit exact de ton programme où l'erreur s'est produite

**mdrhaha** · 20/05/2010, 16h57

et comment tu utilise un debuggeur sachant que je suis sous Code::Blocks?

**teuf13** · 20/05/2010, 17h24

Peut être des pistes sur http://www.developpez.net/forums/d43...er-codeblocks/

**gerald3d** · 21/05/2010, 15h10

Je ne viens pas par ce message résoudre ton problème mais plutôt apporter une précision.

A ce que je vois tu mélanges du C et du C++. Rien de bien méchant jusque là. Par contre ca t'oblige à compiler en C++. Et là il y a au moins une subtilité.
Le casting implicite du C du type

Code :

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

1
2
3
4
double a;
int b;
 
b = (int)a;

peut donner des résultats plus qu'hasardeux compilé en C++. Il est préconisé d'utiliser des directives prévues à cet effet. Il en existe plusieurs en fonction des besoins. Voila un lien (en anglais) qui détaille le tout avec des exemples de code.

Le code précédent serait certainement plus sûr écrit de la sorte:

Code :

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

1
2
3
4
double a;
int b;
 
b = static_cast<int>(a);

Pour finir prenons un exemple de ton code:

Code :

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

data = (GlobalData*)g_malloc(sizeof(GlobalData));

En C++ il est plus naturel d'utiliser la directive new, ce que tu fais d'ailleurs dans la fonction void ChargeCoord(char *chemin);. Ca pourrait donner

Code :

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

data = new GlobalData;

Un simple delete data; suffira pour libérer l'espace mémoire. Avec cette écriture tu supprimes de surcroit le casting version C.

**gerald3d** · 21/05/2010, 21h36

J'ai jeté un oeil à ton code.

Le premier crash vient de la fonction int Rectangle (GtkWidget *widget, gpointer user_data);.

J'avoue ne pas trop comprendre ta démarche. cette fonction est considérée comme un callback attaché au signal "expose-event". Déjà le prototype pour ce signal est gboolean user_function (GtkWidget *widget, GdkEventExpose *event, gpointer user_data);.

A partir de là à quoi te sers la fonction int Callback_expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer user_data);?

**mdrhaha** · 23/05/2010, 12h13

Oui c le prototype de la fonction qui etait mal defini et sinon merci pour les conversions aussi.

Et, est-ce k tu sais comment je peux faire pour compiler un Makefile k j'ai fais sur Code::Blocks?

**gerald3d** · 24/05/2010, 14h36

Compiler un Makefile?

Makefile est un fichier texte interprété par la commande make. Donc point de "compilation".

Sous linux un simple "make" dans une console dans le répertoire contenant le fichier Makefile suffit.

Sous Windows, heuuu ... je n'en sais rien. Je ne programme pas sous cet OS. Mais avec un peu de recherche sur le net je suis sûr que tu trouveras ton bonheur.

rafraichir ecran avec une echelle de couleur

GTK+

Discussions similaires

Partager

Partager