Discussion :

[Flow_75]

Bonjour,

J'ai réalisé deux fenetres dont une avec deux labels.

Le probleme est que quand je la cache, l'affichage de ces labels ne réapparaissent que lorsque je les modifie.

Sans compter ma fenetre principale, où j'utilise Cairo afin d'afficher un graphique, où je dois attendre que je "réutilise" les fonctions de Cairo pour la faire réapparaitre.

Pareil quand je reviens sur le bureau correspondant (sous ubuntu), je dois attendre aussi le rafraichissement des données.

J'ai essayer d'activer "GDK_EXPOSURE_MASK".
Mais pas mieux.

Merci de votre aide.

[gerald3d]

Utiliserais-tu un GtkDrawingArea comme widget parent?

[Flow_75]

Utiliserais-tu un GtkDrawingArea comme widget parent?

Mon Widget parent, c'est un gtkWindow (du moins, j'utilise gtk_window_new pour faire le widget).

Merci

[gerald3d]

Pourrais-tu nous mettre un peu de code alors histoire qu'on n'y voit un peu plus clair?

[Flow_75]

voila le main :

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
int main(int argc, char **argv)
{
 
	pthread_t id;
	GtkWidget *pWindow1;
 
	GtkWidget *pTable;
	GtkWidget *pFrame;
 
 
	int ret;
	g_thread_init(NULL);
	gdk_threads_init();
	gdk_threads_enter();
 
 
	gtk_init(&argc, &argv);
 
 
 
	for(int i = 0;i<2000;i++)curve[i] =0;
 
	pWindow1 = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 
	pWindow2 = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	//gtk_window_set_default_size(GTK_WINDOW(pWindow2), 50, 150);
 
	pTable = gtk_vbox_new(TRUE, 0);
 
	pFrame  = gtk_frame_new("Informations:");
	//pLabel = gtk_label_new("None");
 
	pLabel1 = gtk_label_new("                                                         ");
	pLabel2 = gtk_label_new("                                                         ");
	pLabel3 = gtk_label_new("                                                         ");
 
	gtk_container_add(GTK_CONTAINER(pWindow2), pFrame); 
 
	gtk_container_add(GTK_CONTAINER(pFrame), pTable);
 
	gtk_box_pack_start(GTK_BOX(pTable), pLabel1, TRUE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(pTable), pLabel2, TRUE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(pTable), pLabel3, TRUE, FALSE, 0);
 
	gtk_label_set_justify(GTK_LABEL(pLabel3), GTK_JUSTIFY_LEFT);
	//gtk_label_set_justify(GTK_LABEL(pLabel2), GTK_JUSTIFY_CENTER);
	gtk_window_set_resizable(GTK_WINDOW(pWindow2), FALSE);
 
 
	gtk_window_set_default_size(GTK_WINDOW(pWindow1),905, 305);
	gtk_window_set_default_size(GTK_WINDOW(pWindow2),350, 100);
	gtk_window_set_position(GTK_WINDOW(pWindow2), GTK_WIN_POS_NONE);
 
	gtk_window_set_position(GTK_WINDOW(pWindow1), GTK_WIN_POS_CENTER_ALWAYS);	
	g_signal_connect(G_OBJECT(pWindow1), "destroy", G_CALLBACK(gtk_main_quit), NULL);
	g_signal_connect(G_OBJECT(pWindow1), "expose-event", G_CALLBACK(Expo_Evnt), pWindow1);
	//gtk_widget_set_events(pWindow1, GDK_EXPOSURE_MASK);
	//§§gtk_widget_set_events(pWindow2, GDK_EXPOSURE_MASK);
	gtk_widget_show_all(pWindow2);
 
 
	gtk_widget_show_all(pWindow1); 
 
 
	pthread_create(&id, NULL, LoopReceive, pWindow1);
	pthread_create(&id, NULL, LoopSend, NULL);
 
	gtk_main();
 
	gdk_threads_leave();
 
 
}

Le code de LoopReceive :

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
 
void *LoopReceive(void  *args)
{
	int z;
	Rs = new CRs232( (char*)"/dev/ttyS0", 115200, 8,1,0,true);
 
 
 
	float *curvetoplot;
	cairo_t *cr;
	int pts = 0;
	int recu = 0;
	int freq = 0;
 
	GtkWidget *pWindow = (GtkWidget*)args;
 
	unsigned char* data[30];
 
 
 
	int j = -1;
 
 
 
 
	int Terror = 0;
	int Ttotal = 0;
 
 
do{	
	recu = 0;
 
 
	memset(cbuffer, 0, 6033);
	Rs->FlushBytes();
	while(recu != 33)
	{
		recu += Rs->recv((char*)cbuffer + recu, 33 - recu);
	}
 
	if(time +10 != ExtractTime(cbuffer) && time != -1)
	{
		fprintf(stderr, "%li >> %li : T1: %i, T2: %i\n", time, ExtractTime(cbuffer), pts, ExtractSize(cbuffer));
		Terror++;
	}
 
	if(time == -1 && TIME_VALID(ExtractTime(cbuffer)) )
		{
			int u = ExtractTime(cbuffer);
			time_debut = u;
			fprintf(stderr, "Début @%i - %s Frequence : %i, Taille : %i \n", u, asctime( localtime((time_t*)&u) ), ExtractFrequence(cbuffer), ExtractSize(cbuffer));
		}
	intcurve = ExtractSize(cbuffer);
	time = ExtractTime(cbuffer);
 
	tm *secondes = localtime(&time);
 
 
	Ttotal ++;
 
 
 
 
 
recu += Rs->recv((char*)cbuffer + recu, pts - recu);
 
 
 
 
 
 
 
gtk_label_set_label(GTK_LABEL(pLabel1), asctime(secondes));
 
char buf[10];
sprintf(buf, "%i heure(s), %i minute(s)", (int) difftime(time, time_debut)/3600, ((int)difftime(time, time_debut)/60)%60)   ;
 
gtk_label_set_label(GTK_LABEL(pLabel2), buf);
 
if(Terror < 2)
	sprintf(buf, "%i erreur de trame sur %i trames", Terror, Ttotal);
if(Terror > 1)
	sprintf(buf, "%i erreurs de trame sur %i trames", Terror, Ttotal);
 
gtk_label_set_label(GTK_LABEL(pLabel3), buf);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
     ymax = MINFLOAT;
     ymin = MAXFLOAT;
 
	for(int i = 0; i < intcurve; i++)
	{
		int t =0;
		unsigned  char *A;
		A =(unsigned char*) &t;
		int u = 0;
		unsigned char *B;
		B = (unsigned char*)&u;
 
 
*(A+3) = cbuffer[30 + 3*i]&0x80?0xff:0x00;
*(A+2) = cbuffer[30 + 3*i];
*(A+1) = cbuffer[29 + 3*i];
*(A)   = cbuffer[28 + 3*i]; 
 
 
		curve[i] = t;
 
		if(t > ymax) ymax = t;
		if(t < ymin) ymin = t;		
	}
	if(ymax > abs((int)ymin))
		ymax =ymax;
	else
		ymax = -ymin;
 
 
 
	g_idle_add(Invalidate, pWindow);
 
}while(1);

le code de Invalidate:

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
gboolean Invalidate(void * p)
{
 
GtkWidget *pWindow= (GtkWidget*)p;
gdk_window_clear (pWindow->window);
GdkRegion *region = gdk_drawable_get_clip_region (pWindow->window);
 
gdk_window_invalidate_region (pWindow->window, region, FALSE);
gdk_window_process_updates (pWindow->window, FALSE);
 
 
gdk_window_clear(pWindow2->window);
region = gdk_drawable_get_clip_region (pWindow2->window);
 
gdk_window_invalidate_region (pWindow2->window, region, FALSE);
gdk_window_process_updates (pWindow2->window, FALSE);
 
 
return FALSE;
}

Le code de Expo_Evnt

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
gboolean Expo_Evnt  (GtkWidget *widget, GdkEventExpose *event, gpointer p)
	{
 
	ymax += ymax/20;	
 
 
	GtkWidget *pWindow = (GtkWidget*)p;
 
 
 
	cairo_t * cr = gdk_cairo_create (pWindow->window);
 
	cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);
	cairo_set_line_width(cr, 1.2);
 
 
 
	cairo_move_to(cr, 0, 1);
	cairo_line_to(cr, 0, 300);
 
 
	cairo_move_to(cr, 0, 150);
	cairo_line_to(cr, 900, 150);
 
	cairo_stroke(cr);
cairo_destroy(cr);
 
	cr = gdk_cairo_create (pWindow->window);
 
	cairo_set_source_rgb(cr, 1.0, 0.0, 0.0);
	cairo_set_line_width(cr, 0.5);	
 
 
	for(int  i = 0 ; i < intcurve-1; i++)
{
	int y = 150. -  (float)curve[i]*150. / ymax;
	int x = 150. - (float)curve[i+1]*150. / ymax;
	cairo_move_to (cr, i* 900/ intcurve - 1,   y);
    cairo_line_to (cr, (i+1)*900/intcurve - 1, x);
 
}
 
 
cairo_stroke(cr);
cairo_destroy(cr);
 
return true;
}

Merci de ton aide.

[gerald3d]

J'ai complètement épuré ton code juste pour voir si la fonction Expo_Evnt(); était bien appelée.
De ce côté ca marche. Je te conseille toutefois de renvoyer FALSE plutôt que TRUE. Il vaut mieux laisser propager ce signal.
La fonction main(); doit renvoyer une valeur aussi. Ajoute return 0; juste avant de quitter.

Enfin ton affichage marche nickel sans les threads. Teuf pourrait t'en dire plus sur le sujet mais il est difficile de faire cohabiter les threads et Gtk surtout si tes threads doivent agir sur l'interface.

J'ai justement ouvert un post qui parle de ce sujet il y a 2 jours.
Creuse de ce côté là.

[Flow_75]

J'ai complètement épuré ton code juste pour voir si la fonction Expo_Evnt(); était bien appelée.
De ce côté ca marche. Je te conseille toutefois de renvoyer FALSE plutôt que TRUE. Il vaut mieux laisser propager ce signal.
La fonction main(); doit renvoyer une valeur aussi. Ajoute return 0; juste avant de quitter.

Enfin ton affichage marche nickel sans les threads. Teuf pourrait t'en dire plus sur le sujet mais il est difficile de faire cohabiter les threads et Gtk surtout si tes threads doivent agir sur l'interface.

J'ai justement ouvert un post qui parle de ce sujet il y a 2 jours.
Creuse de ce côté là.

Alors,
Déja merci de ton aide.
J'ai essayé de mettre FALSE plutot que TRUE. Et là, ma fenetre principale n'affiche meme pas le graphique....

J'ai remarqué que la petite fenetre s'affichait de deux manières différentes (voir les captures d'écran)
Quand ca s'affichait comme sur "Capture-Hyper-2.png", les labels se réaffichait normalement contrairement à l'autre cas.....

Y a pas un widget pour faire des graphiques au passage, car dans le cas de Cairo, on ne peux pas mettre d'autre chose que le graphe...

Merci.
F.

[Flow_75]

Bon, j'ai fais quelques manips.
J'ai juste afficher les axes du graphique.
Et là ca reste affiché meme quand tu déplaces la fenetre hors de l'écran....bizarre