Discussion :

[mdrhaha]

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]

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]

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]

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]

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]

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.

-