Discussion :

[d_wais]

voila, je veux afficher à intervalle regulier des images dans une cellule d'un ptable d'une fenetre avec gtk thread sous c sans que le programme principale soit géné. quelqu'un peut il suggérer une réponse?
merci.

[gerald3d]

La bonne solution (la plus simple) est d'utiliser la fonction g_timeout_add(); ou une de ses dérivées. Tu peux grâce à elle exécuter une fonction à intervalle régulier sans gêner la boucle principale de Gtk+ tout en interférant directement avec l'interface graphique.

[d_wais]

excusez moi, mais je n'ai pas réussi a faire marcher ce programme. j'ai fait de la lecture du forum, je n'ai pas capté encore. voici un exemple trouvé dans le forum et que j'ai adapté, mais qui ne fonctionne pas:

#include<glib.h>
#include<gtk/gtk.h>
#include<gdk-pixbuf/gdk-pixbuf.h>
#include<gthread.h>


GtkWidget *image0,*image;

static gpointer thread_func(gpointer data)
{
gint i;
gchar tmp0[50],tmp1[50];
for( i = 0; i < 6; i++ )
{
g_usleep( 10000 );
//sprintf(tmp0,"img0%d.png",(i-1));
//g_object_ref((gpointer)tmp0);
sprintf(tmp1,"img0%d.png",i);
}
return( NULL );
}

static gboolean cb_timeout(gpointer data)
{
GtkButton *but;
gtk_button_set_image(GTK_BUTTON(but),image);
return(TRUE);
}

int main( int argc,char **argv )
{
GtkWidget *window;
GtkWidget *button;
GThread *thread;
GError *error = NULL;

// Secure glib
if( ! g_thread_supported() )
g_thread_init( NULL );

//Do stuff as usual
gtk_init( &argc, &argv );

window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_default_size(GTK_WINDOW(window), 500, 400);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS);
g_signal_connect( G_OBJECT( window ), "destroy",G_CALLBACK( gtk_main_quit ), NULL );

button = gtk_button_new();
gtk_container_add( GTK_CONTAINER( window ),button);
//g_timeout_add (500,cb_timeout,(gpointer)button);
//gdk_threads_add_timeout( 100, cb_timeout, (gpointer)button );

// Create new thread
thread = g_thread_create( thread_func, (gpointer)button,FALSE, &error );
if( ! thread )
{
g_print( "Error: %s\n", error->message );
return( -1 );
}

gtk_widget_show_all( window );
gtk_main();

return( 0 );
}

j'aimerai faire aparaitre ces images la 1ière, la 2ième,.... chacune une seconde et rebelote. voila mon idée svp.
merci de votre reponse.

[gerald3d]

Bon, utiliser les gThreads pour inter-agir avec une fenêtre c'est une très mauvaise idée.

Il faut utiliser les g_timeout_add();. Donc en partant de ce postulat commençons par appeler la fonction callback :

Code :

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

g_timeout_add_seconds (1, (GSourceFunc)cb_timeout, button);

À partir de là on peut construire un code simple pour te montrer. Ce code ne me plait pas totalement puisque dans la fonction callback appelée j'initialise à chaque itération les images à insérer. Mais le but ici est de voir comment tout ce petit monde fonctionne :

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
#include<gtk/gtk.h>
 
static gboolean cb_timeout(GtkWidget *button)
{
  static gboolean bascule = FALSE;
  GtkWidget *image0,*image;
  image0 = gtk_image_new_from_icon_name ("go-previous", GTK_ICON_SIZE_BUTTON);
  image = gtk_image_new_from_icon_name ("go-next", GTK_ICON_SIZE_BUTTON);
 
  if (!bascule)
    gtk_button_set_image(GTK_BUTTON(button), image0);
  else
    gtk_button_set_image(GTK_BUTTON(button), image);
 
  bascule = !bascule;
 
  return TRUE;
}
 
int main( int argc,char **argv )
{
  GtkWidget *window;
  GtkWidget *button;
 
  //Do stuff as usual
  gtk_init( &argc, &argv );
 
  window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
  gtk_window_set_default_size(GTK_WINDOW(window), 500, 400);
  gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS);
  g_signal_connect( G_OBJECT( window ), "destroy",G_CALLBACK( gtk_main_quit ), NULL );
 
  button = gtk_button_new();
  gtk_container_add( GTK_CONTAINER( window ),button);
 
  // Insertion d'un callback dans la boucle Gtk+ avec une exécution toutes les secondes environ
  g_timeout_add_seconds (1, (GSourceFunc)cb_timeout, button);
 
  gtk_widget_show_all( window );
  gtk_main();
 
  return( 0 );
}

[d_wais]

merci beaucoup, ça fonctionne mais seulement avec 2 images. est ce qu'on peut réutiliser plusieurs fois "g_timeout_add()"?

j'ai remodifié votre prog pour afficher 5 images. il n'y a pas de pbs, mais juste la dernière image s'affiche. le voici:

#include<gtk/gtk.h>

GtkWidget *envoi_img(guint i)
{
GtkWidget *image0;
gchar tmp[50];
sprintf(tmp,"img0%d.png",i);
image0 = gtk_image_new_from_file(tmp);
return image0;
}
static gboolean cb_timeout(GtkWidget *button)
{
gint i;
GtkWidget *image;

for(i=0;i<6;i++)
{
g_usleep(10000);
image = envoi_img(i);
gtk_button_set_image(GTK_BUTTON(button), image);
}
return TRUE;
}

int main( int argc,char **argv )
{
GtkWidget *window;
GtkWidget *button;

//Do stuff as usual
gtk_init( &argc, &argv );

window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_default_size(GTK_WINDOW(window), 500, 400);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS);
g_signal_connect( G_OBJECT( window ), "destroy",G_CALLBACK( gtk_main_quit ), NULL );

button = gtk_button_new();
gtk_container_add( GTK_CONTAINER( window ),button);

// Insertion d'un callback dans la boucle Gtk+ avec une exécution toutes les secondes environ
//g_timeout_add_seconds(1, (GSourceFunc)cb_timeout, button); ne fonctionne pas pour moi
g_timeout_add(100, (GSourceFunc)cb_timeout, button); fonctionne pour moi

gtk_widget_show_all( window );
gtk_main();

return( 0 );
}

[MichelPlatini]

on ne peut plus simple (si ? )

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
#include <gtk/gtk.h>
#include <glib.h>
#include <glib-object.h>
#include <string.h>
#include <stdlib.h>
 
typedef struct _Block Block;
 
struct _Block {
	gint index;
	GtkImage* image;
};
 
static gboolean show_image (Block* block) {
	block->index++;
	if (block->index == 5)
		block->index = 0;
	g_object_set (block->image, "file",  g_strdup_printf ("/path/to/%d.png", block->index), NULL);
	return TRUE;
}
 
int main (int argc, char ** argv) {
	gtk_init (&argc, &argv);
	GtkWindow* win = (GtkWindow*) gtk_window_new (GTK_WINDOW_TOPLEVEL);
	Block block = {0};
	memset (&block, 0, sizeof (Block));
	block.image = (GtkImage*) gtk_image_new_from_file (g_strdup_printf ("/path/to/%d.png", block.index));
	g_timeout_add (800, show_image, &block);
	gtk_container_add ((GtkContainer*) win, (GtkWidget*) block.image);
	gtk_widget_show_all ((GtkWidget*) win);
	gtk_main();
	return 0;
}

Bien sûr tu peux modifier le délai du timeout et le nombre d'images à afficher (ici 5)