Afficher une image sur clic d'un bouton

**thibane** · 15/02/2007, 17h20

Bonjour à tous.

Je voudrais afficher une image sur clic d'un bouton.
Le code suivant m'affiche bien mon bouton mais par contre ca n'affiche rien.

Est-ce que qqun peut me dire ou est le pb dans ce 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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
#include <stdio.h>
#include <stdlib.h>
#include <gtk/gtk.h>
 
void charge(GtkWidget *pButton,GtkWidget *pVBox);
 
int main(int argc,char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pButton;
    GtkWidget *pImage;
    GtkWidget *pVBox;
 
    gtk_init(&argc,&argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(pWindow), GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 600, 400);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Charger Image");
 
    pVBox = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
 
    pButton = gtk_button_new_with_label("Charger");
    gtk_box_pack_start(GTK_BOX(pVBox), pButton, FALSE, FALSE, 0);
 
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    g_signal_connect(G_OBJECT(pButton), "clicked", G_CALLBACK(charge),pVBox);
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    return EXIT_SUCCESS;
 
}
void charge(GtkWidget *pButton,GtkWidget *pVBox)
{
    GtkWidget *pImage;
 
    pImage = gtk_image_new_from_file("1.png");
 
    gtk_box_pack_end(GTK_BOX(pVBox), pImage, TRUE, FALSE, 0);
 
}

Je développe en C/GTK+

**Franck.H** · 15/02/2007, 17h42

Il faudrais penser à respecter les signature des callback:

Code :

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

void charge(GtkWidget *pButton, gpointeur p_data)

Ensuite tu cast dans ta fonction pou récupérer ton pVbox, j'ai pas regardé tout ton code mais essaye déjà de rectifier ca

PS: Bienvenue sur les forums de developpez.com

**thibane** · 15/02/2007, 18h05

Merci pour la rapidité de la réponse franck, ca fait plusieurs heures que je bombarde plusieurs forums et pour l'instant c'est le seul ou j'ai eu une réponse

J'ai apporté, selon tes conseils, quelques modifications :

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
#include <stdio.h>
#include <stdlib.h>
#include <gtk/gtk.h>
 
void charge(GtkWidget *pButton, gpointeur data);
 
int main(int argc,char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pButton;
    GtkWidget *pImage;
    GtkWidget *pVBox;
 
    gtk_init(&argc,&argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(pWindow), GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 600, 400);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Charger Image");
 
    pVBox = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
 
    pButton = gtk_button_new_with_label("Charger");
    gtk_box_pack_start(GTK_BOX(pVBox), pButton, FALSE, FALSE, 0);
 
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    g_signal_connect(G_OBJECT(pButton), "clicked", G_CALLBACK(charge),(gpointer*) pVBox);
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    return EXIT_SUCCESS;
 
}
void charge(GtkWidget *pButton, gpointeur data)
{
    GtkWidget *pImage;
    GtkWidget *pVBox1;
 
    pVBox1 = (pVBox*) data;
 
    pImage = gtk_image_new_from_file("1.png");
 
    gtk_box_pack_end(GTK_BOX(pVBox1), pImage, TRUE, FALSE, 0);
 
}

J'ai quelques erreurs que je ne comprends pas comme
error: expected declaration specifiers or '...' before 'gpointeur'
concernant la ligne "void...." juste après les include.

Là je patauge royalement

PS : merci pour l'accueil

**Franck.H** · 15/02/2007, 18h07

Ha oups désolé c'est ma faute pour l'erreur, c'est gpointer

**thibane** · 15/02/2007, 18h11

Je venais justement de rectifier, je croyais qu'elle venait de moi.

Plus d'erreur à la compilation, par contre, toujours rien qui s'affiche dans ma satanée Window...

**thibane** · 15/02/2007, 18h14

Je redonne le code en entier avec comme modifications :
_ dans la fonction "charge", je cast avec GtkWidget et non plus pVBox
_pointeur remplacé par pointer un peu partout..

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
#include <stdio.h>
#include <stdlib.h>
#include <gtk/gtk.h>
 
void charge(GtkWidget *pButton, gpointer data);
 
int main(int argc,char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pButton;
    GtkWidget *pImage;
    GtkWidget *pVBox;
 
    gtk_init(&argc,&argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(pWindow), GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 600, 400);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Charger Image");
 
    pVBox = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
 
    pButton = gtk_button_new_with_label("Charger");
    gtk_box_pack_start(GTK_BOX(pVBox), pButton, FALSE, FALSE, 0);
 
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    g_signal_connect(G_OBJECT(pButton), "clicked", G_CALLBACK(charge),(gpointer*) pVBox);
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    return EXIT_SUCCESS;
 
}
void charge(GtkWidget *pButton, gpointer data)
{
    GtkWidget *pImage;
    GtkWidget *pVBox1;
 
    pVBox1 = (GtkWidget*) data;
 
    pImage = gtk_image_new_from_file("1.png");
 
    gtk_box_pack_end(GTK_BOX(pVBox1), pImage, TRUE, FALSE, 0);
 
}

**thibane** · 15/02/2007, 18h20

J'ai réussi à faire afficher une image!

J'ai rajouté
gtk_widget_show_all(pWindow);
dans ma fonction charge.

Par contre, pWindow n'étant pas déclaré, j'ai dû le déclarer en superglobal. Y a-t-il un moyen plus propre de procéder?

**Franck.H** · 15/02/2007, 18h22

Moi je t'aurais plutôt suggéré ceci a la fin de ton callback:

Code :

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

gtk_widget_show (pImage);

Par ailleurs, tu peux faire la récupération du pointeur générique du callback en une seule ligne soit:

Code :

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

GtkWidget *pVBox1 = (GtkWidget *) data;

**thibane** · 15/02/2007, 18h52

Désolé d'abuser de votre patience mais le résultat obtenu n'est pas encore ce que je voulais.

En fait, à chaque fois que j'appuies sur "charger", il me charge l'image en bas, en dessous de la précédente, et etc jusqu'à ce que je ne vois plus rien.

Moi ce que j'aimerais, c'est remplacer l'image par une autre. J'ai cherché une fonction de "nettoyage" de la VBox mais je ne trouve pas.

Je vous remets 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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include <stdio.h>
#include <stdlib.h>
#include <gtk/gtk.h>
 
void charge(GtkWidget *pButton, gpointer data);
 GtkWidget *pWindow;
int main(int argc,char **argv)
{
 
    GtkWidget *pButton;
    GtkWidget *pImage;
    GtkWidget *pVBox;
 
    gtk_init(&argc,&argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(pWindow), GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 600, 400);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Charger Image");
 
    pVBox = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
 
    pButton = gtk_button_new_with_label("Charger");
    gtk_box_pack_start(GTK_BOX(pVBox), pButton, FALSE, FALSE, 0);
 
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    g_signal_connect(G_OBJECT(pButton), "clicked", G_CALLBACK(charge),(gpointer*) pVBox);
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    return EXIT_SUCCESS;
 
}
void charge(GtkWidget *pButton, gpointer data)
{
    GtkWidget *pImage;
    GtkWidget *pVBox;
 
    /*Récupération de la pVBox */
    pVBox = (GtkWidget*) data;
 
    /*Création de l'image*/
    pImage = gtk_image_new_from_file("6.png");
 
    /*Ajout de l'image à la box*/
    gtk_box_pack_end(GTK_BOX(pVBox), pImage, TRUE, FALSE, 0);
    gtk_widget_show(pImage);
}

Encore merci!

**Franck.H** · 15/02/2007, 19h05

Ce que tu peux éventuellement faire, c'est effacer ton widget GtkImage (mais il faudrais en garder un pointeur dans ce cas) avec la fonction gtk_image_clear puis charger une nouvelle image dans ce même widget gtk_image_set_from_file

Je n'ai pas testé mais cela semble être une bien meilleure solution

Ce que tu peux faire étant donné que tu devras passer deux widgets à ton callback, serait de mettre ton GtkVBox et ton GtkImage dans une structure que tu met hors de toutes fonctions puis que tu passes cette structure à ton callback

**thibane** · 16/02/2007, 14h46

Bonjour Franck (et les autres)

Et oui me revoilà! Je lâche pas l'affaire!

J'ai zeffectué la modif avec la structure de base, à savoir une structure contenant une VBox et une image et à ma grande surprise, j'ai réussi du premier coup!

Donc l'appli fonctionne éxactement comme la dernière mais avec une structure passée dans le CALLBACK.

Ensuite j'ai voulu tester un truc, à savoir le fameux gtk_image_clear que tu m'as indiqué.
Réponse de gcc :
In function `charge':
: undefined reference to `gtk_widget_clear'
collect2: ld returned 1 exit status

Je mets le nouveau 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
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
#include <stdio.h>
#include <stdlib.h>
#include <gtk/gtk.h>
 
void charge(GtkWidget *pButton, gpointer data);
 
struct _Structure
{
    GtkWidget *pVBox;
    GtkWidget *pImage;
};
 
typedef struct _Structure Structure;
 
 
GtkWidget *pWindow;
 
int main(int argc,char **argv)
{
    Structure *structure;
    GtkWidget *pButton;
 
    gtk_init(&argc,&argv);
 
    structure = g_malloc(sizeof(Structure));
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(pWindow), GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 600, 400);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Charger Image");
 
    structure->pVBox = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow), structure->pVBox);
 
    pButton = gtk_button_new_with_label("Charger");
    gtk_box_pack_start(GTK_BOX(structure->pVBox), pButton, FALSE, FALSE, 0);
 
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    g_signal_connect(G_OBJECT(pButton), "clicked", G_CALLBACK(charge),(gpointer*) structure);
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    g_free(structure);
 
    return EXIT_SUCCESS;
 
}
void charge(GtkWidget *pButton, gpointer data)
{
    Structure *structure;
 
    /*Récupération de la pVBox */
    structure = (Structure*) data;
 
    /*Création de l'image*/
    gtk_image_clear(structure->pImage);
    structure->pImage = gtk_image_new_from_file("6.png");
 
    /*Ajout de l'image à la box*/
    gtk_box_pack_end(GTK_BOX(structure->pVBox), structure->pImage, TRUE, FALSE, 0);
    gtk_widget_show(structure->pImage);
}

PS : en fait, le fait d'avoir rajouté le gtk_image_clear ici ,

Code :

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

1
2
3
 /*Création de l'image*/
    gtk_image_clear(structure->pImage);
    structure->pImage = gtk_image_new_from_file("6.png");

quand bien même la fonction fonctionnait, je ne sais pas vraiment ce qu'il va se passer :
je pense qu'à chaque clic, il va supprimer l'image et remettre la même...

Sur ce, bonne journée!

**Franck.H** · 16/02/2007, 15h59

Ton code remanié:

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
#include <stdio.h>
#include <stdlib.h>
#include <gtk/gtk.h>
 
void charge(GtkWidget *pButton, gpointer data);
 
struct _Structure
{
    GtkWidget *pVBox;
    GtkWidget *pImage;
};
 
typedef struct _Structure Structure;
 
 
GtkWidget *pWindow;
 
int main(int argc,char **argv)
{
    Structure *structure;
    GtkWidget *pButton;
 
    gtk_init(&argc,&argv);
 
    structure = g_malloc(sizeof(Structure));
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(pWindow), GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 600, 400);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Charger Image");
 
    structure->pVBox = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow), structure->pVBox);
 
    pButton = gtk_button_new_with_label("Charger");
    gtk_box_pack_start(GTK_BOX(structure->pVBox), pButton, FALSE, FALSE, 0);
 
    structure->pImage = gtk_image_new ();
    gtk_box_pack_end(GTK_BOX(structure->pVBox), structure->pImage, TRUE, FALSE, 0);
 
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    g_signal_connect(G_OBJECT(pButton), "clicked", G_CALLBACK(charge),(gpointer*) structure);
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    g_free(structure);
 
    return EXIT_SUCCESS;
 
}
void charge(GtkWidget *pButton, gpointer data)
{
    Structure *structure;
 
    /*Récupération de la pVBox */
    structure = (Structure*) data;
 
    /*Création de l'image*/
    gtk_image_clear(structure->pImage);
    gtk_image_set_from_file(GTK_IMAGE (structure->pImage), "1.png");
}

Comme je te l'avais dit plus haut, il faut faire appel à la fonction gtk_image_set_from_file dans le callback ce qui implique par la logique même de la chose que la création du GtkImage se fasse dans ton main soit par la fonction gtk_image_new.

Pour la fonction gtk_image_clear chez moi elle passe mais j'avais oublié de préciser que cette fonction n'est disponible qu'à partir de la version 2.8 de GTK+ donc si tu tourne avec une version antérieur, il serait bon que tu mettes à jour ton installation de GTK+

je pense qu'à chaque clic, il va supprimer l'image et remettre la même...

Sans aucun doute, tant que tu lui passera toujours la même image

C'est à toi qu'il appartient de faire en sorte de pouvoir choisir le fichier que tu veux afficher et de la passer à ton callback, ici rien de bien compliqué, tu met une chaîne dans la structure et pis c'est bon.

**thibane** · 16/02/2007, 19h19

Merci pour cette réponse claire et précise.
Je teste ça lundi sans faute.

PS : pour la version de GTK, je ne sais pas si je pourrai étant donné que je bosse sur les pc de l'école et forcément les dossiers ne sont pas libre d'acces m'enfin je m'en tirerai qdmm..

**thibane** · 20/02/2007, 15h09

Encore une fois, merci franck. Ca fonctionne, même en enlevant le image_clear qui ne passe pas chez moi.

Mais comme toutes les bonnes choses n'ont pas de fin, voilà la suite...

Donc je récapitule, j'ai un bouton et quand je clic dessus, un nom aléatoire est généré et l'image est bien remplacé dans ma fenetre.

De plus, j'ai rajouté une fonction qui renvoie dans la console la position de la souris par rapport à la fenetre et par rapport à l'écran.

Séparément, tous mes codes fonctionnent, ca se corse quand j'essaye de les mélanger.

Breve explication : c'est sur clic d'un bouton de la souris et quand le curseur est dans la fenetre que la fonction "position_souris" est appelée.
Maintenant, je voudrais faire la même chose pour cette fameuse fonction "charge", à savoir que quand je clic dans la fenêtre, à la fois j'ai la position de la souris et je voudrais qu'il me charge une nouvelle image dans ma box.

(NB : le bouton "pButton" ne sert plus à rien mais je l'ai laissé)

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
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
#include <stdio.h>
#include <stdlib.h>
#include <gtk/gtk.h>
#include <string.h>
#define MAX_LIGNE 8
#define MAX_COLONNE 4
 
int coord[MAX_LIGNE][MAX_COLONNE];
 
void charge(GtkWidget *pButton, gpointer data);
 
struct _Structure
{
    GtkWidget *pVBox;
    GtkWidget *pImage;
};
 
typedef struct _Structure Structure;
 
 
GtkWidget *pWindow;
 
void position_souris( GtkWidget *widget, GdkEventMotion *event )
{
    gint x1, y1;
    gint x2, y2;
 
    /* Position dans la fenêtre */
    if (event->is_hint)
        gdk_window_get_pointer (event->window, &x1, &y1, NULL);
    else
    {
        x1 = event->x;
        y1 = event->y;
    }
    /* Position dans l'écran */
    if (event->is_hint)
        gdk_window_get_pointer (gdk_screen_get_root_window(gdk_screen_get_default()),&x2, &y2, NULL);
    else
    {
        x2 = event->x_root;
        y2 = event->y_root;
    }
/*RECUPERATION DES COORDONNEES ICI*/
	coord[0][0]=x1;
	coord[0][1]=y1;
	coord[0][2]=x2;
	coord[0][3]=y2;
//	printf("%d \t%d\n %d\t %d\n",coord[0][0],coord[0][1],coord[0][2],coord[0][3]);
/* Affichage */
  g_printf("Fenetre x:%d  y:%d\t\t Ecran x:%d  y:%d\n", x1, y1, x2, y2);
 
}
 
int main(int argc,char **argv)
{
    Structure *structure;
    GtkWidget *pButton;
    GtkWidget *pImage;
 
    gtk_init(&argc,&argv);
 
    structure = g_malloc(sizeof(Structure));
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(pWindow), GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 600, 400);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Charger Image");
 
     /* agrandissement automatique de la fenêtre */
    gtk_window_maximize (GTK_WINDOW (pWindow));
 
    structure->pVBox = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow), structure->pVBox);
 
    pButton = gtk_button_new_with_label("Charger");
    gtk_box_pack_start(GTK_BOX(structure->pVBox), pButton, FALSE, FALSE, 0);
 
    structure->pImage = gtk_image_new();
    gtk_box_pack_end(GTK_BOX(structure->pVBox), structure->pImage, TRUE, FALSE, 0);
 
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    gtk_signal_connect (GTK_OBJECT (pWindow), "button_press_event", G_CALLBACK(charge),(gpointer*) structure);
    gtk_signal_connect (GTK_OBJECT (pWindow), "button_press_event", G_CALLBACK(position_souris) , NULL);
 
    /* Désigne les évènements à gérer  */
    gtk_widget_set_events (pWindow, GDK_BUTTON_PRESS_MASK);
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    g_free(structure);
 
    return EXIT_SUCCESS;
 
}
 
 
void charge(GtkWidget *pWindow, gpointer data)
{
    Structure *structure;
    int i;
    char nom_image[10];
 
       srand(time (NULL));
       i = rand() % 8;
 
       sprintf(nom_image,"%d",i);
       strcat(nom_image,".png");
 
    /*Récupération de la pVBox */
    structure = (Structure*) data;
 
    /*Création de l'image*/
    gtk_image_set_from_file(GTK_IMAGE (structure->pImage), nom_image);
}

A la compilation : aucun soucis.
A l'exécution : quand je clic dans la fenetre "pWindow" :

GLib-GObject-WARNING **: invalid cast from `GdkWindow' to `GtkImage'
Gtk-CRITICAL **: gtk_image_set_from_file: assertion `GTK_IS_IMAGE (image)' failed

Je ne comprends pas ce que signifie cette erreur...

**Franck.H** · 20/02/2007, 16h23

Je n'est pas testé mais il me semble qu'on ne peut pas affecter deux callback au même signal d'un même widget ... un peu normal quoi, mais c'est ce que tu fait pour le signal button_press_event !

**thibane** · 21/02/2007, 08h32

Ok alors c'est impossible d'avoir deux actions sur le même évènement? Y'a bien un moyen de biaiser non?

**Franck.H** · 21/02/2007, 10h09

Envoyé par thibane

Ok alors c'est impossible d'avoir deux actions sur le même évènement? Y'a bien un moyen de biaiser non?

Bin, tu enregistre le callback primaire qui lui appel tout simplement le second qui pourra être une simple fonction, même sans arguments si tu n'utilise pas les arguments du callback.

Afficher une image sur clic d'un bouton

GTK+ avec C & C++

Discussions similaires

Partager

Partager