Discussion :

[suzan_]

Bonjour, je bloque sur un truc un peu enervant... J'ai un tableau qui contient une adresse d'une image sur chaque ligne, quand je fais un printf pour voir son contenu tout est ok... mais quand je le passe à la fonction gtk_image_new_from_file, il affiche une croix rouge. gerror ne me renvoie rien comme si l'image s'était bien chargé. Et quand j'écris l'adresse directement dans ma fonction gtk_image_new_from_file, la évidemment il trouve l'image

Voici le 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
 
GtkWidget *pImage;
char tab_image[50][1000];
 
fichier=fopen("image_list_complete.txt","r");
 
 
    if (fichier != NULL)
    {	
		while (fgets(tab_image[var], 1000, fichier) != NULL) 
        {
		printf("%s\n",tab_image[var]);
		var=var+1;
	} 
        fclose(fichier);
    }
for(l=0;l<5;l++)
{
        //ici tout s'affiche correctement
	printf("%s\n",tab_image[l]);
}
 
 pImage = gtk_image_new_from_file(tab_image[0]);
 
if (pImage == NULL)
{
   /* Affichage du message d'erreur standard : */
   printf ("%s\n", p_err->message);
   g_error_free (p_err);
}
    gtk_box_pack_start(GTK_BOX(VBoxFrame_density), pImage, FALSE, FALSE, 5);

J'ajoute que le fichier "image_list_complete.txt" contient des lignes d'adresses images comme celle ci : C:\\Users\\Suzan\\Documents\\Visual Studio 2008\\Projects\\CT Project\\Debug\\patients\\lady_gaga_10044\\1.JPG

J'ai mis les doubles barres pour les espaces. J'ai essayé sans, ca ne marche pas non plus...
Help

Merci d'avance

[0xpoint]

Tu ne peux pas faire ça. Le prototype de la function gtk_image_new_from_file () a comme argument le type const char *filename. Tu doit passer le nom d'image qui se trouve dans le disque. La function qui charge le image c'est:

Code :

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

1
2
 
GdkPixbuf * gdk_pixbuf_new_from_file (const char *filename, GError **error)

et se trouve ici.

[suzan_]

Merci pour ta réponse rapide et désolé pour ma réponse tardive

Est- ce vraiment obligatoire de charger une image avec gdk_pixbuf_new_from_file?

Sinon, j'ai vu qu'il fallait passer un pointeur sur cette adresse alors j'ai fais :

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
GtkWidget *pImage;
char tab_image[50][1000];
 
fichier=fopen("image_list_complete.txt","r");
 
 
    if (fichier != NULL)
    {	
		while (fgets(tab_image[var], 1000, fichier) != NULL) 
        {
		printf("%s\n",tab_image[var]);
		var=var+1;
	} 
        fclose(fichier);
    }
for(l=0;l<5;l++)
{
        //ici tout s'affiche correctement
	printf("%s\n",tab_image[l]);
}
 
char* filename = NULL;	
 
filename = (char*)malloc(sizeof(char));
filename =  tab_image[0];
 
 pImage = gtk_image_new_from_file(filename);
 
 
    gtk_box_pack_start(GTK_BOX(VBoxFrame_density), pImage, FALSE, FALSE, 5);

et la encore croix rouge

Je ne me suis pas désespérée et j'ai essayé avec gdk_pixbuf_new_from_file comme tu avais dit :

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
GtkWidget *pImage;
 GdkPixbuf *pBuf = NULL;
char tab_image[50][1000];
 
fichier=fopen("image_list_complete.txt","r");
 
 
    if (fichier != NULL)
    {	
		while (fgets(tab_image[var], 1000, fichier) != NULL) 
        {
		printf("%s\n",tab_image[var]);
		var=var+1;
	} 
        fclose(fichier);
    }
for(l=0;l<5;l++)
{
        //ici tout s'affiche correctement
	printf("%s\n",tab_image[l]);
}
 
char* filename = NULL;	
 
filename = (char*)malloc(sizeof(char));
filename =  tab_image[0];
 
 pImage = gtk_image_new_from_file(filename);
 
pBuf = gdk_pixbuf_new_from_file(filename,&p_err);
    gtk_box_pack_start(GTK_BOX(VBoxFrame_density), pImage, FALSE, FALSE, 5);
 
	if (pBuf == NULL)
{
   /* Affichage du message d'erreur standard : */
   printf ("%s\n", p_err->message);
   g_error_free (p_err);
}
 
	pImage = gtk_image_new_from_pixbuf (pBuf);

Et toujours rien : . Le message d'erreur est le suivant :

Code :

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

1
2
Failed to open file :C:\\Users\\Suzan\\Documents\\Visual Studio 2008\\Projects\\CT Project\\Debug\\patients\\lady_gaga_10044\\1.JPG
: invalid argument

J'ai essayé avec et sans les doubles "\", rien ne change. Et quand je mets l'adresse directement la évidement ça marche...

Help please

[0xpoint]

Je ne sais pas si tu as bien compris ou est mon français qui est mauvaise.
Le prototype reçoit une variable du type const char *filename ("./img/img.png"). La function gdk_pixbuf_new_from_file () est responsable pour charger l'image et se trouve dans la function gtk_image_new_from_file. Si tu regarde la function gdk_pixbuf_new_from_file ici, tu peux voir que cette function fait le chargement de l'image avec l'appel g_fopen (). Allor, tu est obligeé de passer le chemin de l'image et pas le adresse. Je me trouve curieux, que-ce que tu veux faire?

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
GdkPixbuf * gdk_pixbuf_new_from_file (const char *filename, GError **error)
{
 	        GdkPixbuf *pixbuf;
 	        int size;
 	        FILE *f;
 	        guchar buffer [128];
 	        GdkPixbufModule *image_module;
 	        gchar *display_name;
 	
 	        g_return_val_if_fail (filename != NULL, NULL);
 	        g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 	       
 	        display_name = g_filename_display_name (filename);     
 	
 	        f = g_fopen (filename, "rb");
 	        if (!f) {
 	                g_set_error (error,
 	                             G_FILE_ERROR,
 	                             g_file_error_from_errno (errno),
 	                             _("Failed to open file '%s': %s"),
 	                             display_name,
 	                             g_strerror (errno));
 	                g_free (display_name);
...

[suzan_]

Oui, escuse il y a eu confusion, j'ai voulu dire le chemin dans ma dernière phrase.

Quoiqu'il en soit, quand je fais :

Code :

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

1
2
3
4
5
char* filename = NULL;	
 
filename = (char*)malloc(sizeof(char));
filename =  tab_image[0];
 pBuf = gdk_pixbuf_new_from_file(filename,&p_err);

je passe bien à pBuf le contenu de filename, donc le chemin de mon image, non???

Alors pourquoi ça ne marche pas?

[Gamall]

Oui, escuse il y a eu confusion, j'ai voulu dire le chemin dans ma dernière phrase.

Quoiqu'il en soit, quand je fais :

Code :

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

1
2
3
4
5
char* filename = NULL;	
 
filename = (char*)malloc(sizeof(char));
filename =  tab_image[0];
 pBuf = gdk_pixbuf_new_from_file(filename,&p_err);

je passe bien à pBuf le contenu de filename, donc le chemin de mon image, non???

Alors pourquoi ça ne marche pas?

Ton code contient une fuite de mémoire car tu commence par allouer filename avec malloc(3), puis tu écrase sa valeur avec tab[0], le contenu alloué ne peut donc plus être libéré.
Sinon, pour ton premier code, il y a quelque chose que je ne comprends pas, tu crée ton GtkImage, avec gtk_image_new_from_file, puis ensuite, tu déréférence p_err (un GError ?), aors qu'il n'a pas été initialisé lors du chargement du fichier. En effet, gtk_image_new_from_file ne prend pas de GError en paramètre, alors j'ai du mal à comprendre à quoi il sert et d'où il sort...


Voici un exemple de code documenté de ce que tu semble vouloir faire, bonne lecture

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
#include <gtk/gtk.h>
 
int
main (int  argc,
      char *argv[])
{
	GtkWidget *window;
	GtkWidget *box;
	GtkWidget *image;
	GdkPixbuf *pixbuf;
        /* Contiendra tout le contenu du fichier */
	gchar *file_content;
        /* Contiendra chaque ligne du fichier */
	gchar **files;
	gchar **tmp;
	GError *error;
 
 
	gtk_init (&argc, &argv);
 
	window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	g_signal_connect (G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
	box = gtk_vbox_new (TRUE, 0);
	gtk_container_add (GTK_CONTAINER(window), box);
 
	/* On charge le contenu du fichier dans file_content.
	 * D'après la doc, on doit libérer file_content, par 
	 * la suite avec g_free
	 */
	g_file_get_contents ("image_list_complete.txt",
			&file_content,
			NULL,
			&error);
	if (NULL == file_content)
	{
		/* Si le fichier n'a pas pu être récuperé */
		g_printerr ("%s", error->message);
		g_free (error);
		return -1;
	}
 
	/* On coupe la chaine file_content à chaque fois qu'on
	 * rencontre un '\n'. Chaque chaine sera stockée dans 
	 * files (tableau de chaine).
	 * files doit être liberé avec g_strfreev
	 */
	files = g_strsplit (file_content, "\n", -1);
	g_free (file_content);
 
	/* On parcourt nôtre tableau qui contient maintenant les noms de fichiers.
	 * l'avant dernière case est NULL, et l'avant dernière ne contient rien 
	 * d'interessant. (une chaine vide)
	 */
	for (tmp = files; NULL != *(tmp+1); tmp++)
	{
		/* On charge les fichier un par un dans un pixbuf */
		error = NULL;
		pixbuf = gdk_pixbuf_new_from_file (*tmp, &error);
		if (NULL == pixbuf)
		{
			/* Si le fichier n'a pas pu être chargé */
			g_printerr ("%s", error->message);
                        g_error_free (error);
		}
		else
		{
			/* On crée le GtkImage à partir du pixbuf */
			image = gtk_image_new_from_pixbuf (pixbuf);
			gtk_container_add (GTK_CONTAINER(box), image);
		}
	}
 
	/* On libère le tableau maintenant inutile */
	g_strfreev (files);
 
	gtk_widget_show_all (window);
 
	gtk_main ();
 
 
	return 0;
}

Résultat:

[liberforce]

Code :

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

1
2
3
 
filename = (char*)malloc(sizeof(char));
filename =  tab_image[0];

Tu as un gros soucis de compréhension des pointeur là. En faisant cela, tu ne copies pas de données, ne fais que pointer vers une zone mémoire fraichement allouée, puis vers une autre. Au passage tu as perdu tout moyen de retrouver la zone allouée avec le malloc, c'est donc une fuite mémoire. Jette un coup d'oeil à cette vidéo pour comprendre un peu mieux comment fonctionnent les pointeurs: [ame="http://www.youtube.com/watch?v=6pmWojisM_E"]comment fonctionnent les pointeurs[/ame]

Pour ton problème d'origine, j'ai trouvé la cause: la manière dont tu effectues la récupération des chemins de fichiers. Déjà tu n'as pas besoin de doubler les backslash '\' dans un fichier de données lu par ton programme. Tu n'as besoin de le faire que quand tu spécifies des noms en dur dans un fichier C, car le caractère backslash est un caractère d'échappement, et qu'en analysant le chemin "C:\nouveau dossier", le compilateur comprendrait le "\n" comme un retour chariot. Pour éviter cela, quand on veut indiquer que c'est bien le caractère backslash que l'on souhaite utiliser, on le double: "C:\\nouveau dossier".

Autrement, pour ton problème initial, il vient du fait que tes chaînes de caractère contiennent encore le retour chariot en fin de ligne, et que le système cherche un fichier contenant ce retour chariot à la fin de son nom...

Bon, ton exemple initial est clairement très imparfait, mais si tu souhaites le conserver, alors il te suffit après avoir lu chaque ligne de ton fichier, de les modifier pour enlever les éventuels espaces et retours chariots en fin de ligne avec g_strchomp.

Code :

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

1
2
3
4
5
6
7
 
while (fgets(tab_image[var], 1000, fichier) != NULL)
{
    g_strchomp (tab_image[var]);
    printf("%s\n",tab_image[var]);
    var=var+1;
}