Discussion :

[liberforce]

Pour les images de 1000 pixel ses juste que j'avais pas allouer assé de mémoire aux tableaux de couleur.

Non, le problème est que tu utilises une taille fixe. Tu peux connaitre les dimensions de l'image, donc tu peux connaitre la taille que devrait faire ton tableau, il te suffit de l'allouer dynamiquement.

Pour le fait d'utiliser des tableaux pour l'instant je sais que sa n'a pas d'intérer, en fait si j'en est fait ses pour pouvoir créer par la suite un autre filtre ou je me saire des valeur des ensyin pixel pour savoir comment les attribuer au nouveau.

Tu sais déjà accéder à un pixel en particulier, les recopier n'a pas spécialement d'intérêt...

Pour saut ligne je suis déjà au courent et je sais comment y remédier ses juste que avent de travailler sur des lignes je voulais déjà m'exercer sur qu'elle que pixel.

Ok, mais évite de rajouter des bouts de code qui sont sans intérêt pour ec que tu veux faire. Une bonne habitude quand on a du code "mort" qu'on veut garder pour le rééutiliser au cas où, c'est de le désactiver en l'encadrant dans un #if 0/#endif.

Pour t'on code je vient de télécharger l'interphase il marche bien mais se qui me plais pas ses qu'il à été fait avec gtk builder donc j'y comprend pas grand chose.

Le but était justement d'éliminer la partie interface graphique pour que le code soit essentiellement axé sur le traitement d'image. D'ailleurs, créer ses interfaces à la main, c'est bien pour apprendre, s'entrainer, ou quand on a besoin dans l'interface de pouvoir rajouter dynamiquement des widgets, mais sinon Glade + GtkBuilder devrait être utilisé tout le reste du temps.

Et puis si je doit je démarrer sur windows(pour l'instent j'utilise ubuntu) pour créer un exécutable avec innosetup sa risque de pas être pratique.

Pas forcément, l'installateur n'a qu'à livrer le fichier gtkbuilder avec l'exécutable. Après il te faut une version de GTK qui gère GtkBuilder...

L'aventage de mon code ses que je le comprend plus facilement donc je peut le modifier et même si ils reste des petites erreur en les corrigent sa m'en apprend beaucoup plus qu'en utilisent un code tout près.
Par contre rien empaiche d'adapter des chose de t'on code vers le mien si tu m'explique de quoi il s'agis .

Je ne te force pas, mais c'est juste que les erreurs tu ne les verras pas forcément tout seul, il faut avoir l'oeil entrainé.

Pour ma fonction modifier pixel elle est juste sensés écrire des bande rouge transparente sur une image et pour la fonction utiliser filtre elle est juste sensé coloriser l'image en rouge de la même fasson mais en totalité.
C'est comme dans gimp quant on clique sur couleur et qu'en bas du menu déroulent on clique sur coloriser.
Mais si je fait sa ses pour m'entréné a comprendre comment fonctionne les pixels.
La le problème de mon code ses que avec les images jpg sa marche mais avec les bmp sa m'affiche par dessus un blanc transparent.

Tu es peut être mal aligné selon que tu as ou non un canal alpha ? Mais j'ai vu le même soucis ailleurs sur le net, alors essaie de voir si tu peux avoir du BMP avec un canal alpha et l'afficher tel quel pour commencer.

A par sa pour un tutorial t'en a pas un anglais mieux explique que la doc que je traduiré avec google traduction?
Il y à surement plun de truck que vous pouvais me dire mais sa m'embaitte de vous déranger tros souvent.
Surtout que j'émerai par la suite apprendre a bouger et coller des surfaces suivent un axe x y en gérent les évènement du clavier et de la souris comme avec la sdl.

Hé bien tu n'es malheureusement pas sorti de l'auberge. Je n'ai pas trouvé de tutoriel sur GdkPixbuf, même en anglais. La doc officielle en fait office. Tu peux néanmoins lancer l'exécutable gtk-demo, fourni avec GTK, qui contient un exemple compilé et le code associé pour des GdkPixbuf. Bon courage.

[liberforce]

Pour info, voila la version en contruisant l'interface manuellement (sans GtkBuilder):

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
#include <gtk/gtk.h>
#include <gdk-pixbuf/gdk-pixbuf.h>
#include <gdk/gdkevents.h>
 
typedef struct
{
	GtkWidget *main_window;
	GtkWidget *original;
	GtkWidget *colorized;
	GtkWidget *box;
} ImageViewerGui;
 
void
on_destroy (GtkObject *object, gpointer user_data)
{
	gtk_main_quit ();
}
 
void 
gdk_pixbuf_replace_color (GdkPixbuf *pixbuf, 
		guchar old_red, guchar old_green, guchar old_blue,
		guchar new_red, guchar new_green, guchar new_blue)
{
	int width, height, rowstride, n_channels;
	guchar *pixels, *p;
	guint x, y;
 
	g_assert (pixbuf != NULL);
	g_assert (gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB);
	g_assert (gdk_pixbuf_get_bits_per_sample (pixbuf) == 8);
 
	n_channels = gdk_pixbuf_get_n_channels (pixbuf);
	width = gdk_pixbuf_get_width (pixbuf);
	height = gdk_pixbuf_get_height (pixbuf);
	rowstride = gdk_pixbuf_get_rowstride (pixbuf);
	pixels = gdk_pixbuf_get_pixels (pixbuf);
 
	for (y = 0; y < height; y++)
	{
		for (x = 0; x < width; x++)
		{
			p = pixels + y * rowstride + x * n_channels;
			if (p[0] == old_red && p[1] == old_green && p[2] == old_blue)
			{
				p[0] = new_red;
				p[1] = new_green;
				p[2] = new_blue;
			}
		}
	}
}
 
int 
main (int argc, char* argv[])
{
	ImageViewerGui gui;
	GdkPixbuf *pixbuf;
 
	gtk_init (&argc, &argv);
 
	gui.main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gui.box = gtk_hbox_new (TRUE, 0);
	gui.original = gtk_image_new_from_file ("test.png");
	gui.colorized = gtk_image_new_from_file ("test.png");
 
	gtk_container_add (GTK_CONTAINER (gui.main_window), gui.box);
	gtk_box_pack_start (GTK_BOX (gui.box), gui.original, TRUE, FALSE, 10);
	gtk_box_pack_start (GTK_BOX (gui.box), gui.colorized, TRUE, FALSE, 10);
 
	pixbuf = gtk_image_get_pixbuf (GTK_IMAGE (gui.colorized));
	gdk_pixbuf_replace_color (pixbuf, 
			0, 0, 0,    /* noir */
			255, 0, 0); /* rouge */
	gtk_widget_show_all (GTK_WIDGET (gui.main_window));
 
	/* connexion du signal déclenché à la destruction de la fenêtre */
	g_signal_connect (G_OBJECT (gui.main_window), "destroy",
			G_CALLBACK (on_destroy), NULL);
 
	gtk_main();
	return 0;
}

[grex1]

Pour glade il n'y a aucun tutorial et pour l'instent je pré faire tout faire manuelment car sa fait pas longtemps que j'utilise GTK donc je risque d'oublier.
Pour t'on code finalment en le regardent sa m'a appris pas mal de chose j'aurré jamais penssé utiliser une structure pour déclarrer les widget.
En regardent le code de la fonction sa m'a aussi appris des choses bien que je ne compraiune pas tous et que se n'est pas exactement se que je voullais faire je sais comment la modifier.
Je suppose que même si sa oblige à réécrire plusieur fois le même code avec les chanels et le rowstride pour chaque filtre plus tot que de les mettre dans une autre fonction ses par se que le programme s'exécutera plus rapidement?
A par sa aisse que tu pourrai me montrer comment on fait pour récupéré une image à partir d'un gtk file selection?

[Gamall]

Tu pourra trouver un tutoriel sur Cairo Graphics ici: (lien) Il est complet et très bien expliqué

Et comme je te l'ai déjà dit, tu auras forcément besoin de la doc, il faut absolument l'effort de la lire. Un tutoriel ne te présentera qu'une infime partie des possibilités du framework.

Après, c'est sûr, on a toujours besoin d'un "getting started"

[Gamall]

PS: Il y a un correcteur d'orthographe intégré à Firefox, que tu soit dyslexique, ok, mais que tu ne l'utilise pas, c'est de la négligence. :s

Je suis d'accord, ça corrige pas tout, mais au moins, ça filtre les fautes comme "ansyin", "interphase", et autre

[grex1]

Pour le correcteur ses du provisoire car depuis la mise à niveau d'ubuntu je n'arrive plus à utiliser firefox.
Mintenen j'utilise le correcteur de Chromium mais il n'arrive pas à corriger des mots comme "ansyin".
Pour se tutiorial je le connais déjà mais comme c'est très mal traduit avec google traduction j'y comprend rien.
Mais tempis avec se qu'on m'a appris sur les gdkpixbuf je devrais pouvoir faire pas mal de chose.
Une dernier chose aisse qu'on peut juste me montrer comment récupéré une image à partir d'un gtk file sélection.

[gerald3d]

Un GtkFileSelection ne retourne qu'un nom d'un fichier avec son chemin. Avec ce filename tu peux ensuite utiliser les fonctions associées aux GdkPixbuf.
Une fois fait tu peux convertir un GdkPixbuf en GtkImage par exemple avec la fonction gtk_image_new_from_pixbuf();

[grex1]

Pour recupéré le pixbuf avec gdk_pixbuf_new_from_file maintenant j'ai compris.
Mais j'émerai savoir comment ne pas passer par une fonction recupérré chemin ses a dire que j'émerai pouvoir envoyé le gtk fileselection dans la fonction main.
En gros j'émerai récupéré le chemin a l'intérrier de la fonction main.
Mais je crois pas que se code soi correct car il faudré changé les arguments de la fonction main :

Code :

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

g_signal_connect(G_OBJECT(GTK_FILE_SELECTION(selection)->ok_button), "clicked", G_CALLBACK(main), selection );

[gerald3d]

La fonction main(); ne devrait rien récupérer du tout. On ne devrait y trouver que l'initialisation des librairies GTK+ et d'autres si besoin. On charge l'interface principale via glade ou une fonction codée qui se charge de la construction et on lance la boucle principale gtk_main();.

Tout le reste doit se passer dans les différents CALLBACK qui doivent avoir la possibilité d'interagir avec les différents widgets de l'interface principale. Pour ce faire on déclare une structure qui regroupe par exemple tous les pointeurs des widgets ou alors on passe le pointeur GtkBuilder de l'interface si on utilise glade.

Ainsi il est possible dans un CALLBACK de récupérer un chemin d'une image et de l'afficher dans le widget adéquat, vu que le CALLBACK récupère ce pointeur via le gpointer user_data.

(j'espère ne pas être trop touffu dans les explications...)

[liberforce]

Un GtkFileSelection ne retourne qu'un nom d'un fichier avec son chemin. Avec ce filename tu peux ensuite utiliser les fonctions associées aux GdkPixbuf.
Une fois fait tu peux convertir un GdkPixbuf en GtkImage par exemple avec la fonction gtk_image_new_from_pixbuf();

Pas besoin de passer par un GdkPixbuf, il suffit d'appeler directement gtk_image_new_from_file avec le chemin du fichier.

[gerald3d]

Oui. Mais c'était juste un exemple. Je ne voulais pas tirer des droites "trop courtes" .

[grex1]

En fait dans le tutoriel de se site il nous montre des exemples avec des listes chainée pour récupéré les widget.
Mais ses plus simple de déclarré la plus par des widget dans une struture pour éviter d'avoir à tout envoyé a chaque appelle de fonction calback.
Grâce à l'exemple de libertforce je sais comment utiliser des structures avec des widget mais ses dommage qu'il n'en parle pas dans le tutoriel alors que ses très pratique.

[teuf13]

Pas besoin de passer par un GdkPixbuf, il suffit d'appeler directement gtk_image_new_from_file avec le chemin du fichier.

Hmm, pour retomber sur le pb de départ où il n'est pas certain du tout qu'on puisse récupérer un pixbuf quand on a utilisé gtk_image_new_from_file ? On tourne en rond

[grex1]

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.

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
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
#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;
  }
}

[gerald3d]

En fait dans le tutoriel de se site il nous montre des exemples avec des listes chainée pour récupéré les widget.
Mais ses plus simple de déclarré la plus par des widget dans une struture pour éviter d'avoir à tout envoyé a chaque appelle de fonction calback.
Grâce à l'exemple de libertforce je sais comment utiliser des structures avec des widget mais ses dommage qu'il n'en parle pas dans le tutoriel alors que ses très pratique.

Ils n'en parlent pas tout simplement parce que c'est un style de programmation et non une obligation d'utilisation avec la bibliothèque. Rien ne t'empêche de tout déclarer en global. Et tu verras que ca fonctionne quand même. Maintenant oublie ce que je viens d'écrire. Les déclarations en global c'est "BEURK"

[grex1]

C'est pas non plus une obligation d'utiliser une liste chainé pourtant y en parle.
Mais la je me rend conte que sens explication les structures sa m'avance pas plus j'ai déjà tenté d'en utiliser mes je suis quant même obliger de faire cette déclaration en global "fichier gui;".
Et même après avoir réussi à transmettre le chemin l'ajouter dans "pImage = gtk_image_new_from_file(chemin); " ne change rien tout reste vide.
(je préfaire convertir l'image en pixbuf après chaque appelle de fonction callback plus tot que de récupérer directement un pixbuf)

[Gamall]

Hmm, pour retomber sur le pb de départ où il n'est pas certain du tout qu'on puisse récupérer un pixbuf quand on a utilisé gtk_image_new_from_file ? On tourne en rond

Peut être avec un truc de ce genre (pas essayé, pas le temps...)

Code :

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

1
2
 
g_object_get (G_OBJECT(img), "pixbuf", &pixbuf, NULL);

non ?

[liberforce]

Peut être avec un truc de ce genre (pas essayé, pas le temps...)

Code :

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

1
2
 
g_object_get (G_OBJECT(img), "pixbuf", &pixbuf, NULL);

non ?

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

[liberforce]

Ils n'en parlent pas tout simplement parce que c'est un style de programmation et non une obligation d'utilisation avec la bibliothèque. Rien ne t'empêche de tout déclarer en global. Et tu verras que ca fonctionne quand même. Maintenant oublie ce que je viens d'écrire. Les déclarations en global c'est "BEURK"

Ce n'est pas interdit. Cela peut être pratique. Le code produit est plus rapide. Mais on sacrifie la réentrance, ce qui est souvent problématique. Apprendre à s'en passer, c'est déjà un pas dans la bonne direction, le suivant étant de savoir quand il est plus intéressant d'utiliser une variable globale .

[liberforce]

Hmm, pour retomber sur le pb de départ où il n'est pas certain du tout qu'on puisse récupérer un pixbuf quand on a utilisé gtk_image_new_from_file ? On tourne en rond

On est pas plus certain avec gdk_pixbuf_new_from_file, c'est juste que gdk_pixbuf_new_from_file donne plus d'infos quand il n'a pas réussi à charger l'image, via son GError **error. Mais les débutant ne l'utilisent pas ici, parce que les pointeurs doubles ça fait peur, donc je ne vois pas bien la différence...