Actualiser une image

Version imprimable

Bonsoir à tous !

Voilà, j'ai un petit soucis actuellement avec un projet que je développe. Le but est simple, afficher une image dont on récupère l'emplacement à intervalle régulier, c'est-à-dire que l'image change parfois, donc son chemin aussi. J'ai un bout de code qui récupère cet emplacement et me le renvoie. A la base j'utilisais Xlib et Imlib2 pour afficher l'image dans une fenêtre, mais j'aimerai utiliser Gtk. Or je débute ...

Afficher l'image n'est pas un problème, en revanche, je n'arrive pas à l'actualiser ... Voilà mon code de base, sans fioriture ni test de sécurité :
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 #include <stdio.h> #include <string.h> #include <unistd.h> #include <gtk/gtk.h> int inter, pos_x, pos_y; char *fname; gint x, y; GtkWidget *fen, *img, *box, *label; /* La fonction qui nous sert à afficher l'image dont le chemin est passé en argument. */ void imageDisplay( char *image ) { /* On charge l'image */ img = gtk_image_new_from_file(image); if(!img) { fprintf(stderr,"imageDisplay() : error loading image\n"); sortie(1); } gtk_box_pack_start(GTK_BOX(box), img, FALSE, FALSE, 5); } void windowDisplay(char *image, int x, int y) { // Crée la fenêtre fen = gtk_window_new (GTK_WINDOW_POPUP); gtk_window_move (GTK_WINDOW(fen), x, y); g_signal_connect(G_OBJECT(fen),"destroy",G_CALLBACK(gtk_main_quit),NULL); gtk_window_set_default_size (GTK_WINDOW(fen), 200, 200); box = gtk_vbox_new (FALSE, 10); gtk_container_add (GTK_CONTAINER (fen), box); imageDisplay(image); gtk_widget_show_all (fen); } int main ( int argc, char **argv ) { inter = atoi( argv[1] ); pos_x = atoi( argv[2] ); pos_y = atoi( argv[3] ); gtk_init(&argc, &argv); fname = getImagePath(); windowDisplay(fname,pos_x,pos_y); gtk_main(); return 0; }
Précision : je ne colle pas ma fonction getImagePath qui n'apporte rien au problème, elle a juste le prototype suivant :

Code:

const char * amarokCover();

Elle me renvoie l'emplacement de l'image dans une chaine.

Là tout fonctionne, le programme ouvre une fenêtre et m'affiche l'image. Seulement je suis incapable de faire en sorte que l'image s'actualise. En utilisant Xlib je passais par une boucle infinie qui tournait avec un sleep(intervalle); et cela fonctionnait nickel. Mais avec GTK, le problème est que pour afficher l'image, j'ai besoin de gtk_main() je crois, et je n'arrive pas à me débrouiller avec ...

Quelqu'un aurait une idée ? merci d'avance :)

13/08/2008, 00h21
teuf13

Je t'invite à consulter http://gtk.developpez.com/faq/?page=gtkmain qui devrait te permettre d'avancer.

Bonjour!

En effet, ton lien m'a permis d'avancer, merci !

Malheureusement, je suis bloqué un peu plus loin ^^ maintenant la boucle fonctionne, et le programme prend en compte le changement d'emplacement de l'image s'il se produit. Mais l'image affichée ne change pas, je n'arrive pas à trouver pourquoi l'affichage de l'image ne prend pas en compte le changement :/ voilà 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
 
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <gtk/gtk.h>
 
int inter, pos_x, pos_y;
char *fname;
 
gint x, y;
GtkWidget *fen, *img, *box, *label;
 
/* La fonction qui nous sert à afficher l'image dont le chemin
   est passé en argument. */
 
void imageDisplay(char *image)
{
        printf(" -> imageDisplay();\n");
        printf(" ---> image = %s\n", image);
 
        img = gtk_image_new_from_file(image);
        if(!img)
        {
                fprintf(stderr,"imageDisplay() : error loading image\n");
                sortie(1);
        }
 
        //gtk_box_pack_start(GTK_BOX(box), cover, FALSE, FALSE, 5);
        printf("inter=%d\n",inter);
        sleep(inter);
}
 
void windowDisplay()
{
        printf(" -> windowDisplay();\n");
 
        fen = gtk_window_new (GTK_WINDOW_POPUP);
        gtk_window_move (GTK_WINDOW(fen), pos_x, pos_y);
        g_signal_connect(G_OBJECT(fen),"destroy",G_CALLBACK(gtk_main_quit),NULL);
        gtk_window_set_default_size (GTK_WINDOW(fen), 150, 150);
 
        box = gtk_vbox_new(FALSE, 10);
        gtk_container_add(GTK_CONTAINER(fen), box);
 
        fname = getImagePath();
        printf(" ---> fname = %s\n", fname);
        imageDisplay(fname);
 
        gtk_box_pack_start(GTK_BOX(box), cover, FALSE, FALSE, 5);
        gtk_widget_show_all(fen);
 
        g_timeout_add( (guint)inter, (gpointer)windowDisplay, NULL);
}
 
 
int main ( int argc, char **argv )
{
        /* on passe en entier l'intervalle et la position */
	inter = atoi( argv[2] );
	pos_x = atoi( argv[3] );
	pos_y = atoi( argv[4] );
 
        gtk_init(&argc, &argv);
 
        windowDisplay();
 
	gtk_main();
 
	return 0;
}

Voilà, si quelqu'un à une idée, elle est plus que bienvenue :D

Merci d'avance !

17/08/2008, 21h24
teuf13

Le sleep dans imageDisplay n'est pas utile. une fonction callback de g_timeout_add doit renvoyer TRUE ouFALSE pour indiquer s'il faut continuer à appeler le callback ou non. Je mettrais le g_timeout_add dans la fonction principale d'ailleurs. Et quand tu dis que l'image ne change pas, es-tu sûr que tu passes dans windowDisplay et qu'un fichier contenant une image différente est chargé ?
En relisant ton code, je pense que gtk doit afficher pas mal d'avertissements dans la console... Pour modifier l'image affichée, il faut utiliser gtk_image_set_from_file, je n'ai pas l'impression que tu fasses cela
18/08/2008, 00h43
Askelon

Et bien écoute, grâce à toi tout fonctionne !!!

J'ai simplement déplacé l'appel à g_timeout_add() dans main(), et l'affichage de l'image prend bien en compte la modification du chemin !

D'ailleurs je ne vois pas trop ce que ça change :lol: que la fonction s'appelle elle-même via g_timeout_add() ou que cela soit main() qui lance, cela revient au même, au final la boucle est quand même là ... enfin bref, ça marche, c'est l'essentiel :mrgreen:

Merci beaucoup pour ton aide rapide et (très !) efficace teuf13 !!

Cordialement, Askelon =)
18/08/2008, 09h59
teuf13

g_timeout_add, ça n'ajoute pas une fonction qui sera appelé X ms plus tard mais ça ajoute une fonction qui sera appelée toutes les X ms jusqu'à ce que tu lui dises d'arrêter. Donc si tu fais l'ajout dans ton callback, le premier coup tu as une fonction qui est appelée toutes les X ms, le 2nd coup tu as 2 fonctions qui sont appelées toutes les X ms, etc etc. Enfin tu peux indiquer au callback de ne se lancer qu'une fois, mais ça se fait en renvoyant TRUE or FALSE (je sais plus quelle valeur il faut renvoyer).