Comment afficher des images les unes devant les autres avec GTK+ ?

**getgetxx** · 23/04/2009, 20h15

Bonjour,
Alors voila, je doit realiser un programme en C et j'utilise GTK+ dont je commence a maitrisé les commandes de base, j'aimerai afficher une image en fond puis plusieurs images "clicquable" par dessus (je sais deja faire mes images "clicquable", il me manque juste l'image de fond a afficher derriere).
Si quelqu'un peut m'expliquer ce que je doit faire pour sa se serait super!
Merci

**gerald3d** · 23/04/2009, 21h02

Comment réalises-tu tes images cliquables?

**getgetxx** · 23/04/2009, 21h12

Pour faire mes images cliquables, j'utilise "gtk_event_box"

Code :

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

1
2
3
4
5
6
7
8
9
10
 
       eventbox=gtk_event_box_new();
	gtk_container_add(GTK_CONTAINER(eventbox), image);
	gtk_container_add(GTK_CONTAINER(fenetre), eventbox);
 
	// Ajout du signal "click" sur l'image
	gtk_widget_add_events(eventbox,GDK_BUTTON_PRESS_MASK);
 
	//connexion du signal pour voir le click sur image
	g_signal_connect(GTK_OBJECT(eventbox), "button_press_event", gtk_main_quit, NULL);

**gerald3d** · 23/04/2009, 21h19

Tu peux utiliser les GtkRc. Il y a une explication de son utilisation sur la page du lien. Ca te permet d'indiquer le style d'affichage de tes fenêtres et donc d'indiquer que tu veux une image de fond particulière à leur ouverture.

**gerald3d** · 23/04/2009, 21h26

Petite précision tout de même. Les GtkEventBox ne sont pas transparentes au sens où on l'entend. Il est vrai qu'elles n'apparaissent pas mais elles cachent tout de même ce qu'il y a dessous.
Il existe bien une option paramétrable demandant quelle le soit mais dans ce cas le widget enfant disparait aussi!

**getgetxx** · 23/04/2009, 21h33

Ok merci beaucoup je vais allez voir ces explication, par contre aurais-tu une autre façon de créer une image cliquable sans GtkEventBox qui apparement me cachera mon image de fond?

**gerald3d** · 23/04/2009, 21h43

Je ne suis pas sûr que ma réponse va te plaire mais bon, je te la donne quand même

.
Faire du dessin.

Bon ok, c'est un peu laconique comme réponse. Je développe un peu.
Widget utilisé comme support : GtkDrawingArea.
Avec ce widget on dispose de l'évènement "expose-event". Dans le callback associé tu peux afficher séquentiellement toutes tes images en commençant par l'image de fond.
Pour les images cliquables, ca va être un peut compliqué. Le GtkDrawingArea peut recevoir l'évènement du clic de la souris. Donc on peut récupérer sa position lors du clic. Ensuite il "suffit" de voir si les coordonnées correspondent à un point appartenant à une des images. Si oui tu lances les opérations que tu veux sur cette image.

**getgetxx** · 23/04/2009, 22h00

Ok, ça me parait vraiment compliqué, surtout que depuis tout à l'heure je regarde les explication sur les GtkRc et je n'ai encore pas trouvé comment les utilisé (je me rend compte que je connai vraiment à peine la base de GTK et rien de plus). Tu saurai ou je peut trouver des explications sur l'utilisation de toute ces fonction (explication un peut plus detaillé et en français si possible...).

**gerald3d** · 23/04/2009, 22h26

En francais je pense que non, ou très peu malheureusement. Je peux toujours te donner déjà ce lien. Tu y trouveras pas grand chose hormis la fonction à utiliser pour charger un fichier de configuration GtkRc.

Sur ce lien tu trouveras un petit exemple pour une image de fond.

Désolé de ne pouvoir t'en donner plus.

**getgetxx** · 23/04/2009, 22h34

Merci, c'est deja pas mal, jusqu'ici je n'avais rien trouver du tout (et pourtant j'ai chercher tout l'après midi)
Je regarderai tout ça demain, il est temps du repos xD...
(j'ai trois semaine pour arrivé a realisé mon programme... je pense que ça va etre possible)
En tout cas merci encore

**getgetxx** · 24/04/2009, 10h44

J'ai vue certain utilitaire comme "glade 3", sais tu s'il est possible de faire mes images cliquables en utilisant cette application ??

**gerald3d** · 24/04/2009, 18h55

Glade est un constructeur d'interface. Tu obtiens comme résultat un fichier xml utilisable dans une application Gtk+. Ca simplifie la construction mais malheureusement ca n'aide pas du tout un novice de cette librairie à la comprendre.

Pour les images cliquables ca n'apporte absolument rien.

**getgetxx** · 24/04/2009, 19h58

Ok merci glade m'est alors d'aucune utilité ...
Par contre, j'ai vraiment du mal a trouver des explications sur l'utilisation des GtkRc et ce qui est donné sur "gnome.org" est vraiment peut expliqué...

**getgetxx** · 27/04/2009, 15h23

Comment doit-je faire pour afficher mes images les une après les autre dans le GtkDrawingArea ?

**gerald3d** · 27/04/2009, 18h06

Principe:
Un GtkDrawingArea doit être vu comme une feuille de dessin. Je peux soit y dessiner directement avec quelques fonctions fournis par le Gdk soit en y "collant" une image existante.
Partons du principe que je place une image dessus. Si je prends une deuxième image et je la place encore dessus, elle va cacher partiellement (ou totalement) la précédente.

Quels outils pour charger les images en mémoire?
Je n'irai pas par quatre chemins. On utilise les GdkPixbufs. Pour une première approche de cette structure voir la faq.

Comment "coller" mes images?
Le moyen pour dessiner ou coller des images dans un GtkDrawingArea est l'utilisation d'un CallBack associé au signal "expose-event". Dans cette fonction il est possible, par exemple, de lire une liste chaînée (préalablement initialisée) dans laquelle on va trouver toutes les images à afficher dans l'ordre d'apparition. La première image est l'image de fond et les suivantes viennent par dessus. La fonction utilisée pour placer une image est la suivante :

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
gdk_draw_pixbuf ()
 
void                gdk_draw_pixbuf                     (GdkDrawable *drawable,
                                                         GdkGC *gc,
                                                         const GdkPixbuf *pixbuf,
                                                         gint src_x,
                                                         gint src_y,
                                                         gint dest_x,
                                                         gint dest_y,
                                                         gint width,
                                                         gint height,
                                                         GdkRgbDither dither,
                                                         gint x_dither,
                                                         gint y_dither);
Renders a rectangular portion of a pixbuf to a drawable. The destination drawable must have a colormap. All windows have a colormap, however, pixmaps only have colormap by default if they were created with a non-NULL window argument. Otherwise a colormap must be set on them with gdk_drawable_set_colormap().
 
On older X servers, rendering pixbufs with an alpha channel involves round trips to the X server, and may be somewhat slow.
 
The clip mask of gc is ignored, but clip rectangles and clip regions work fine.
 
If GDK is built with the Sun mediaLib library, the gdk_draw_pixbuf function is accelerated using mediaLib, which provides hardware acceleration on Intel, AMD, and Sparc chipsets. If desired, mediaLib support can be turned off by setting the GDK_DISABLE_MEDIALIB environment variable.
 
drawable*:
 
Destination drawable.
gc*:
 
a GdkGC, used for clipping, or NULL
pixbuf*:
 
a GdkPixbuf
src_x*:
 
Source X coordinate within pixbuf.
src_y*:
 
Source Y coordinates within pixbuf.
dest_x*:
 
Destination X coordinate within drawable.
dest_y*:
 
Destination Y coordinate within drawable.
width*:
 
Width of region to render, in pixels, or -1 to use pixbuf width.
height*:
 
Height of region to render, in pixels, or -1 to use pixbuf height.
dither*:
 
Dithering mode for GdkRGB.
x_dither*:
 
X offset for dither.
y_dither*:
 
Y offset for dither.
Since 2.2

La suite au prochain épisode...

**getgetxx** · 27/04/2009, 19h25

d'accord j'avance bien avec ça il me manque juste a trouver comment declaré un GdkDrawable car je ne trouve pas ... donc si tu a un petit morceau de code example ou autre il serait bienvenue .

**getgetxx** · 27/04/2009, 19h32

je crois avoir trouver tout seul comment declaré le gdkdrawable donc je vais beaucoup avancer garce a ça je pense merci beaucoup !!!

**gerald3d** · 27/04/2009, 19h34

Les foules sont en liesse, on applaudie, on en redemande... Finalement on ne pourra pas attendre le prochain épisode

. (je fatigue. Va falloir que j'arrête

)

Ok, je poursuis alors. Pour obtenir un drawable ce n'est pas bien compliqué.

Dans le callback il suffit de faire "drawing->window" pour obtenir le GdkDrawable.

**getgetxx** · 30/04/2009, 20h26

merci pour tout ça, j'ai réussis a afficher des images les unes dessus les autres et j'arrive a trouver les coordonées de la souris sur ma fenetre et meme sur l'ecran.
Par contre j'ai un autre souci, j'aimerai faire une structure avec des GdkPixbuf *... mais lorsque je les utilises dans mon programme, le programme ne fonctionne plus, il se compile mais lorsque je le lance il plante!!

voila une des structure que j'ai fait:

Code :

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

1
2
3
4
5
6
7
 
struct pix
{
       GdkPixbuf *image           ;
       gdouble   x,y              ;
       gint      width,height     ;
};

**getgetxx** · 30/04/2009, 20h58

Après recherche et recherche j'ai trouvé en partie mon erreur (j'avai oublier d'alloué la place avec malloc ... )
j'ai toujour un probleme, j'ai une structure pour laquellle ça ne fonctionne que pour les 6 premiere declaration se trouvant dans ma structure

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
 
typedef struct 
{
       GdkPixbuf *bleue1          ;
       gdouble   bleu1x,bleue1y   ;
       gint      bleu1w,bleue1h   ;
 
       GdkPixbuf *bleue2          ;
       gdouble   bleue2x,bleue2y  ;
       gint      bleue2w,bleue2h  ;
 
       GdkPixbuf *marron          ;
       gdouble   marronx,marrony  ;
       gint      marronw,marronh  ;
 
       GdkPixbuf *rouge           ;
       gdouble   rougex,rougey    ;
       gint      rougew,rougeh    ;
 
       GdkPixbuf *rose            ;
       gdouble   rosex,rosey      ;
       gint      rosew,roseh      ;
 
       GdkPixbuf *jaune           ;
       gdouble   jaunex,jauney    ;
       gint      jaunew,jauneh    ;
 
       GdkPixbuf *vert            ;
       gdouble   vertx,verty      ;
       gint      vertw,verth      ;
 
       GdkPixbuf *violet          ;
       gdouble   violetx,violety  ;
       gint      violetw,violeth  ;
 
       GdkPixbuf *vide            ;
       gdouble   videx,videy      ;
       gint      videw,videh      ;
}couleur;
 
 
couleur *init_couleurs()
{
    couleur   *couleur= g_malloc(sizeof(couleur))         ;        
 
 
    couleur->bleue1  = gdk_pixbuf_new_from_file_at_size("./bleue1.jpg", 39, 36, NULL)   ;
    couleur->bleue1h = 36;
    couleur->bleu1w  = 39;
 
    couleur->bleue2  = gdk_pixbuf_new_from_file_at_size("./bleue2.jpg", 38, 35, NULL)   ;
    couleur->bleue2h = 35;
    couleur->bleu1w  = 38;
 
    couleur->rouge   = gdk_pixbuf_new_from_file_at_size("./rouge.jpg", 39, 36, NULL)    ;
    couleur->rougeh  = 36;
    couleur->rougew  = 39;
 
    couleur->vert    = gdk_pixbuf_new_from_file_at_size("./vert.jpg", 40, 36, NULL)     ;
    couleur->verth   = 36;
    couleur->vertw   = 40;
 
    couleur->violet  = gdk_pixbuf_new_from_file_at_size("./violet.jpg", 39,35 , NULL)   ;
    couleur->violeth = 35;
    couleur->violetw = 39;
 
    couleur->rose    = gdk_pixbuf_new_from_file_at_size("./rose.jpg", 39, 36, NULL)     ;
    couleur->roseh   = 36;
    couleur->rosew   = 39;
 
    couleur->marron  = gdk_pixbuf_new_from_file_at_size("./marron.jpg", 38, 36, NULL)   ;
    couleur->marronh = 36;
    couleur->marronw = 38;
 
    couleur->jaune   = gdk_pixbuf_new_from_file_at_size("./jaune.jpg", 39, 35, NULL)    ;
    couleur->jauneh  = 35;
    couleur->jaunew  = 39;
 
    couleur->vide    = gdk_pixbuf_new_from_file_at_size("./case vide.jpg", 42, 36, NULL);
    couleur->videh   = 36;
    couleur->videw   = 42;
 
    return(couleur);
}

j'ai pu voir que ça plante à partir de "couleur->rouge"
si tu peut m'aider...
merci d'avance

Comment afficher des images les unes devant les autres avec GTK+ ?

GTK+ avec C & C++

Discussions similaires

Partager

Partager