Discussion :

[liberforce]

En fait sa ne marche pas sa n'a pas changer grand chose d'utiliser une structure car on doi quant même déclarer "fichier gui" dans chaque fonction.
Pour l'instant j'ai fait la déclaration à l'extérieur de toute les fonction pour que sa sois pris en conte partout mais normalement ses pas propre de faire se genre de chose.
Et même comme sa sa ne marche pas quant j'ouvre l'image rien n'apparait.

Question: tu utilises quoi comme éditeur ? Parce que c'est très pénible à lire avec cette indentation. Regarde si tu n'as pas une option d'indentation automatique. La plupart des bons éditeurs le font... Évite aussi de sauter 15000 lignes.

Rien qu'en respectant les règles d'indentation, c'est déjà plus facile à lire:

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
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
#include <stdlib.h>
#include <gtk/gtk.h>
#include <string.h>
 
 
typedef struct
{
	const gchar* chemin;
} fichier;
fichier gui;
 
void modifierpixel(GtkWidget *pButton, gpointer data);
void ouvrirefichier(GtkWidget *pButton, gpointer data);
void utiliserfiltre(GtkWidget *pButton, gpointer data);
void recuperer_chemin (GtkWidget *bouton, GtkWidget *file_selection);
gboolean gdkpixbuf_get_colors_by_coordinates(GdkPixbuf *pixbuf, gint x, gint y, guchar *red, guchar *green, guchar *blue);
static void put_pixel (GdkPixbuf *pixbuf, int x, int y, guchar red, guchar green, guchar blue, guchar alpha);
gboolean gdkpixbuf_set_colors_by_coordinates(GdkPixbuf *pixbuf, gint x, gint y, guchar  red, guchar  green, guchar  blue);
 
int main(int argc, char **argv)
{
	GtkWidget *pWindow;
	GtkWidget *pVBox;
	GtkWidget *pHBox;
	GtkWidget *pLabel;
	GtkWidget *pImage;
	GtkWidget *boutonouvrire;
	GtkWidget *bouton;
	GtkWidget *bouton2;
 
	gtk_init(&argc,&argv);
 
	pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(pWindow), "Les GtkBox");
	gtk_window_set_default_size(GTK_WINDOW(pWindow), 200, 400);
	g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
	pLabel=gtk_label_new("");
 
	pImage = gtk_image_new_from_file(gui.chemin);
 
	boutonouvrire = gtk_button_new_with_label("ouvrire");
	bouton = gtk_button_new_with_label("Modifier pixel");
	bouton2 = gtk_button_new_with_label("filtre");
 
	/* Creation de la GtkBox verticale */
	pVBox = gtk_vbox_new(FALSE, 0);
 
	/* Creation de la GtkHox verticale */
	pHBox = gtk_hbox_new(FALSE, 0);
 
	/* Ajout de la GtkVBox dans la fenetre */
	gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
 
	gtk_box_pack_start(GTK_BOX(pVBox),pHBox, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(pHBox),boutonouvrire, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(pHBox),bouton, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(pHBox),bouton2, FALSE, FALSE, 0);
 
	gtk_box_pack_start(GTK_BOX(pVBox),pImage, TRUE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX(pVBox),pLabel, TRUE, TRUE, 0);
 
	g_signal_connect(G_OBJECT(boutonouvrire), "clicked", G_CALLBACK(ouvrirefichier), NULL);
 
	/* Connexion du signal "clicked" du GtkButton */
	g_signal_connect(G_OBJECT(bouton), "clicked", G_CALLBACK(modifierpixel), (GtkWidget*)  pImage);
 
	/* Connexion du signal "clicked" du GtkButton */
	g_signal_connect(G_OBJECT(bouton2), "clicked", G_CALLBACK(utiliserfiltre), (GtkWidget*)  pImage);
 
	gtk_widget_show_all(pWindow);
 
	gtk_main();
 
	return EXIT_SUCCESS;
}
 
 
/* Fonction callback executee lors du signal "clicked" */
void modifierpixel(GtkWidget *pButton, gpointer data)
{
	GdkPixbuf *pixbuf;
	pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(data));
 
	guchar red, green, blue,alpha;
	red=0;
	green=0;
	blue=0;
 
	char tableaured[2000],tableaugreen[2000],tableaublue[2000];
	gint x=0,y=0;
 
	int sautligne=0;
 
	for (y = 0; y < gdk_pixbuf_get_height(pixbuf); y++) {
		for (x = 0; x < gdk_pixbuf_get_width(pixbuf); x++) {
			/* do something */
 
			gdkpixbuf_get_colors_by_coordinates(pixbuf, x, y,&tableaured[x],&tableaugreen[x],&tableaublue[x]);
 
			sautligne++;
			if(sautligne>10)
			{
				put_pixel(pixbuf,x,y,tableaured[x],tableaugreen[x],tableaublue[x],alpha);
			}
			else
			{
				put_pixel(pixbuf,x,y,tableaured[x],green,blue,alpha);
			}
 
			if(sautligne==20)
			{
				sautligne=0;
 
			}
		}
	}
 
	gtk_image_set_from_pixbuf(GTK_IMAGE(data), pixbuf);
}
 
 
void ouvrirefichier(GtkWidget *pButton, gpointer data)
{
	GtkWidget *selection;
 
	selection = gtk_file_selection_new( g_locale_to_utf8( "Sélectionnez un fichier", -1, NULL, NULL, NULL) );
	gtk_widget_show(selection);
 
	//On interdit l'utilisation des autres fenetres.
	gtk_window_set_modal(GTK_WINDOW(selection), TRUE);
 
	g_signal_connect(G_OBJECT(GTK_FILE_SELECTION(selection)->ok_button), "clicked", G_CALLBACK(recuperer_chemin), selection );
	g_signal_connect_swapped(G_OBJECT(GTK_FILE_SELECTION(selection)->cancel_button), "clicked", G_CALLBACK(gtk_widget_destroy), selection);
}
 
void recuperer_chemin (GtkWidget *bouton, GtkWidget *file_selection)
{
	gui.chemin = gtk_file_selection_get_filename(GTK_FILE_SELECTION (file_selection) );
	gtk_widget_destroy(file_selection);
}
 
void utiliserfiltre(GtkWidget *pButton, gpointer data)
{
	GdkPixbuf *pixbuf;
	pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(data));
 
	guchar red, green, blue,alpha;
	red=0;
	green=0;
	blue=0;
 
	char tableaured[2000],tableaugreen[2000],tableaublue[2000];
	gint x=0,y=0;
 
	int sautligne=0;
 
	for (y = 0; y < gdk_pixbuf_get_height(pixbuf); y++) {
		for (x = 0; x < gdk_pixbuf_get_width(pixbuf); x++) {
			/* do something */
			gdkpixbuf_get_colors_by_coordinates(pixbuf, x, y,&tableaured[x],&tableaugreen[x],&tableaublue[x]);
			put_pixel(pixbuf,x,y,tableaured[x],green,blue,alpha);
		}
	}
 
	gtk_image_set_from_pixbuf(GTK_IMAGE(data), pixbuf);
}
 
gboolean gdkpixbuf_get_colors_by_coordinates(GdkPixbuf *pixbuf, gint x, gint y, guchar *red, guchar *green, guchar *blue)
{
	guchar *pixel=NULL;
	gint channel=0;
	gint rowstride=0;
 
	if (!pixbuf) return FALSE;
	if (x<0 || y<0) return FALSE;
	if (x>gdk_pixbuf_get_width(pixbuf)) return FALSE;
	if (y>gdk_pixbuf_get_height(pixbuf)) return FALSE;
 
	pixel=gdk_pixbuf_get_pixels(pixbuf);
	channel=gdk_pixbuf_get_n_channels(pixbuf);
	rowstride=gdk_pixbuf_get_rowstride(pixbuf);
 
	*red   = pixel[(x*channel)+(y*rowstride)];
	*green = pixel[(x*channel)+(y*rowstride)+1];
	*blue  = pixel[(x*channel)+(y*rowstride)+2];
 
	return TRUE;
}
 
gboolean gdkpixbuf_set_colors_by_coordinates(GdkPixbuf *pixbuf, gint x, gint y, guchar red, guchar green, guchar blue)
{
	guchar *pixel=NULL;
	gint channel=0;
	gint rowstride=0;
 
	if (!pixbuf) return FALSE;
	if (x<0 || y<0) return FALSE;
	if (x>gdk_pixbuf_get_width(pixbuf)) return FALSE;
	if (y>gdk_pixbuf_get_height(pixbuf)) return FALSE;
 
	pixel=gdk_pixbuf_get_pixels(pixbuf);
	channel=gdk_pixbuf_get_n_channels(pixbuf);
	rowstride=gdk_pixbuf_get_rowstride(pixbuf);
 
	pixel[(x*channel)+(y*rowstride)] = red;
	pixel[(x*channel)+(y*rowstride)+1] = green;
	pixel[(x*channel)+(y*rowstride)+2] = blue;
 
	return TRUE;
}
 
static void put_pixel (GdkPixbuf *pixbuf, int x, int y, guchar red, guchar green, guchar blue, guchar alpha)
{
	int width, height, rowstride, n_channels;
	guchar *pixels, *p;
	n_channels = gdk_pixbuf_get_n_channels (pixbuf);
	g_assert (gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB);
	g_assert (gdk_pixbuf_get_bits_per_sample (pixbuf) == 8);
 
 
	width = gdk_pixbuf_get_width (pixbuf);
	height = gdk_pixbuf_get_height (pixbuf);
	g_assert (x >= 0 && x < width);
	g_assert (y >= 0 && y < height);
	rowstride = gdk_pixbuf_get_rowstride (pixbuf);
	pixels = gdk_pixbuf_get_pixels (pixbuf);
	p = pixels + y * rowstride + x * n_channels;
 
	p[0] = red;
	p[1] = green;
	p[2] = blue;
	if(n_channels == 4)
	{
		p[3] = alpha;
	}
}

Pense aussi à compiler avec l'option -Wall pour activer tous les warnings, parce que là ton code en déclenche un paquet...

Ensuite, tu utilises gtk_file_selection_new. GtFileSelector est déprécié et ne doit plus être utilisé, il faut utiliser à la place gtk_file_chooser_dialog_new.

[liberforce]

Ton erreur vient du fait que quand tu as créé ta GtkImage, tu l'as fait au tout début du programme:

Code :

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

pImage = gtk_image_new_from_file(gui.chemin);

Sauf qu'à ce moment là, chemin contient n'importe quoi, il n'a pas été initialisé ! Vu qu'au démarrage tu n'est pas censé afficher d'image (l'utilisateur n'en a pas encore sélectionné), autant créer ta GtkImage vide avec gtk_image_new.

Ensuite, une fois que tu as cliqué sur le bouton "ouvrir", tu récupères le chemin, tu le stockes mais tu n'en fais rien. Or, c'est à ce moment là que tu devrais créer le pixbuf (avec gdk_pixbuf_new_from_file) correspondant et l'affecter à ta GtkImage (avec gtk_image_set_pixbuf).

[Gamall]

À mon avis ça ne fera rien de plus que gtk_image_get_pixbuf...

Ah, oui, quand on prends pas le temps de lire la doc...

[gerald3d]

Je dirais simplement que si on a besoin de charger une image à afficher telle une icône, donc sans modification à postériori, alors gtk_image_new_from_file(); est LA fonction à utiliser.
Par contre si le chargement de l'image est à but de modification de celle-ci, alors passer par les GdkPixbuf me semble plus adapté.

Ce n'est bien sûr que mon humble avis. Rien n'est écrit dans le marbre. A part peut être une dizaine de règles écrites par la foudre il y a longtemps, mais ca c'est une autre histoire...

[liberforce]

Je dirais simplement que si on a besoin de charger une image à afficher telle une icône, donc sans modification à postériori, alors gtk_image_new_from_file(); est LA fonction à utiliser.
Par contre si le chargement de l'image est à but de modification de celle-ci, alors passer par les GdkPixbuf me semble plus adapté.

Ce n'est bien sûr que mon humble avis. Rien n'est écrit dans le marbre. A part peut être une dizaine de règles écrites par la foudre il y a longtemps, mais ca c'est une autre histoire...

Ce n'est pas une question de la modifier ou pas a posteriori, c'est une question de valeur par défaut.

Si tu veux afficher une image par défaut au démarrage de l'application, tu crées le GtkImage en lui donnant le chemin vers image en question avec gtk_image_new_from_file.

Si tu ne veux pas d'image par défaut, que tu préfères un GtkImage vide au démarrage de l'application, alors tu utilises gtk_image_new.

[grex1]

Ton erreur vient du fait que quand tu as créé ta GtkImage, tu l'as fait au tout début du programme:

Code :

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

pImage = gtk_image_new_from_file(gui.chemin);

Sauf qu'à ce moment là, chemin contient n'importe quoi, il n'a pas été initialisé ! Vu qu'au démarrage tu n'est pas censé afficher d'image (l'utilisateur n'en a pas encore sélectionné), autant créer ta GtkImage vide avec gtk_image_new.

Ensuite, une fois que tu as cliqué sur le bouton "ouvrir", tu récupères le chemin, tu le stockes mais tu n'en fais rien. Or, c'est à ce moment là que tu devrais créer le pixbuf (avec gdk_pixbuf_new_from_file) correspondant et l'affecter à ta GtkImage (avec gtk_image_set_pixbuf).

ok j'ai en partit compris mais il reste le probleme de l'image qui n'est pas dans la fonction récupéré chemin donc je ne peut pas la modifier avec gtk_image_set_from_pixbuf à moins de la déclarer en global se qui n'est pas très propre.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
void recuperer_chemin (GtkWidget *bouton, GtkWidget *file_selection)
{
    GtkWidget *pixbuf;
    GError *gerror;
    gchar* chemin;
 
	chemin = gtk_file_selection_get_filename(GTK_FILE_SELECTION (file_selection) );
 
pixbuf=gdk_pixbuf_new_from_file(chemin,&gerror);
	gtk_widget_destroy(file_selection);
}

[liberforce]

ok j'ai en partit compris mais il reste le probleme de l'image qui n'est pas dans la fonction récupéré chemin donc je ne peut pas la modifier avec gtk_image_set_from_pixbuf à moins de la déclarer en global se qui n'est pas très propre.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
void recuperer_chemin (GtkWidget *bouton, GtkWidget *file_selection)
{
    GtkWidget *pixbuf;
    GError *gerror;
    gchar* chemin;
 
	chemin = gtk_file_selection_get_filename(GTK_FILE_SELECTION (file_selection) );
 
pixbuf=gdk_pixbuf_new_from_file(chemin,&gerror);
	gtk_widget_destroy(file_selection);
}

C'est simple: il n'y a pas de solution élégante, les deux seuls objets que tu aies sous la main étant le file selector et le boutton ok du file selector. Ce qui explique sans doute pour cela que ce widget est à présent déprécié et ne devrait plus être utilisé. C'est pas comme si je ne te l'avais pas déjà dit plus haut... Utilise GtkFileChooserDialog qui est déjà plus intuitif.

[grex1]

Pour le GtkFileChooserDialog j'ai trouver un tuto en francais qui est tres bien.
Je les pas encore lu en entier mais il y à le même genre de problème à la différence que tout est répartit dans une seul fonction ouvrire fichier(dans le tuto: OnButton) donc c'est plus pratique.
Pour récupéré l'image en plus de la fenêtre parent dans la fonction je pensse qu'il faudrai utilisé une liste chainée mais je sais pas tros comment faire.
Quant tout les élément sont dans une gtkbox ses simple j'ai qu'a utiliser :

Code :

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

gtk_container_get_children

Mais la le problème ses que la fenêtre parent n'est pas dans un conteneur alors que l'image si.

[liberforce]

Nan, tu passes l'image en paramètre user_data de ta callback "ouvrirefichier". Dans cette callback, tu crées le GtkFileChooser comme dans l'exemple de la doc officielle et tu appelles gtk_dialog_run. En sortant de gtk_dialog_run, tu récupères le chemin de l'image. Tu peux ensuite construire un GdkPixbuf avec ce chemin, et l'affecter au GtkImage que tu as en paramètre d'entrée.

[grex1]

Le problème c'est que pour créer se gtk_file_chooser_dialog_new il me faut une fenêtre parent.
Pour avoir cette fenêtre parent je doit l'envoyer à la fonction ouvrir fichier dans user data alors que se data est déjà occupé par l'image.

[liberforce]

parent : Transient parent of the dialog, or NULL.

Et en passant ta souris sur le "allow-none" à côté, tu as:

allow-none : NULL is ok, both for passing and returning.

En gros, le parent est facultatif, tu peux mettre NULL...