afficher une bitmap

Version imprimable

23/08/2021, 20h39
LSBTD

afficher une bitmap

Bonjour,
Est-il possible d'afficher une image bitmap sur une fenêtre GTK2.0 ?
Si oui, comment faire ?
Merci d'avance
24/08/2021, 09h14
gerald3d

Bonjour.

Oui bien sûr c’est possible. Mais avant d’aller plus avant Gtk4 vient de sortir. Tu tiens vraiment à utiliser Gtk2 ? Plus obsolète ça va être difficile de trouver 😉
24/08/2021, 10h34
LSBTD

En fait j'ai trouvé un tuto gtk 2 sur le site. J'avais déjà commencé et du coup je n'ai pas envie de tout réapprendre.
De plus je suis sous codeblocks et j'ai galéré à installer gtk 2. et je veux pas recommencer cette galère à moins que quelqu'un m'explique pas à pas comment faire.
24/08/2021, 11h23
gerald3d

2 pièce(s) jointe(s)

Je comprends les difficultés que tu peux rencontrer. Malheureusement pour toi je suis sous linux et ne peux donc pas trop t'éclairer pour Windows.

Il existe cependant un tutoriel officiel pour installer les bibliothèques Gtk+ sous Windows :
https://www.gtk.org/docs/installations/windows/

Pour Code::Blocks je viens de l'essayer. Soit tu crées un projet Gtk+ directement soit tu crées un projet C simple auquel il faudra spécifier les options de compiliation dans la fenêtre "Build options" accessible dans le menu "Project".

Voila une capture 'écran pour les options de compilation (flags) :
Pièce jointe 603790

Et les options de linkage (libs) :
Pièce jointe 603791

Ceci étant dit au point où en est Gtk2 le plus simple est de passer par les GdkPixbuf pour créer une image à partir d'un tableau de unsigned char (il existe toute une redéfinition des types sous Gtk+. Ici tu peux utiliser guchar comme type équivalent). La fonction ad hoc est gdk_pixbuf_new ();.
Je précise que les GdkPixbuf sont indépendants de la version Gtk+ utilisée.

Tu pourras ensuite utiliser ce GdkPixbuf pour créer un GtkWidget insérable dans ta fenêtre avec la fonction GtkWidget *gtk_image_new_from_pixbuf (GdkPixbuf *pixbuf);
24/08/2021, 12h08
LSBTD

j'ai MSYS2, mais ça bug. Il y a toujours un .h qu'il ne trouve pas !
je peux écrire :

Code:

#include <gtk/gtk.h>

et il me dit qu'il trouve pas,
si j'écris

Code:

#include <gtk-2.0/gtk/gtk.h>

là il m'ouvre gtk.h et me dis qu'il ne trouve pas un autre .h qui est dans gtk.h

C'est sans fin !
j'ai essayé avec gtk 2, 3, 4.
24/08/2021, 13h56
gerald3d

Je soupçonne que CodeBlock ne connaît pas le chemin des includes de Gtk+. Il doit y avoir un moyen de lui spécifier les répertoires à regarder dans les menus de configuration. (Désolé je ne suis plus sur mon PC pour t’aiguiller plus précisément)
24/08/2021, 13h58
LSBTD

J'ai oublié de dire : j'utilise MSYS2 comme compilateur. Donc il devrait savoir ou lui-même a mis les fichier !!!
24/08/2021, 14h11
gerald3d

MSYS2 n’est pas le compilateur. Il te fournit un environnement Linux avec Shell ouvert en console. Dans cet environnement tu disposes de l’application pacman pour installer Gtk+ ainsi que d’autres outils tel qu’un compilateur,Glade etc.

Tu utilises Code Blocks. Comment sait-il où se trouvent les bibliothèques que tu veux utiliser si tu ne lui dis pas explicitement ?

Voilà la documentation de CB en français page 22. https://www.codeblocks.org/docs/manu..._fr.pdf#page22

Elle explique comment spécifier les variables d’environnement.
25/08/2021, 16h53
gerald3d

Je viens de faire un petit tuto pour essayer de répondre à ta question de comment utiliser Gtk+ avec Code::Blocks sur ton post dans le sous-forum C :

https://www.developpez.net/forums/d2.../#post11756502
25/08/2021, 17h09
LSBTD

Merci, c'est vraiment sympa !
aurais-tu réponse à ça :
https://www.developpez.net/forums/d2...p/dll-gtk-2-a/

Autre question :
la différence gtk2 et gtk 4 est-elle grande (faut-il tout réapprendre ?)
25/08/2021, 17h14
LSBTD
Puisqu'on y est j'ai un problème avec g_signal_connect.
je n'arrive pas à passer cette structure en paramêtre :
Code:

1 2 3 struct variable{ GtkWidget *window, *table; };
et j'aurais besoin d'aide aussi du côté de ma fonction callback au niveau du prototype.

Ce que je veux faire :
quand on clique, ça efface la fenêtre par un gtk_widget_destroy sur la table, et après je met d'autres bouttons.
25/08/2021, 17h51
gerald3d

Il me faut plus de code source pour pouvoir te répondre.

Pour la compilation en statique c'est une option à fournir au compilateur lors de la compilation. En théorie c'est l'option -static. Je ne l'ai jamais utilisée donc je ne pourrai pas t'être d'une grande aide de ce côté là.
26/08/2021, 08h56
LSBTD
je pose autrement ma question, comment passerais-tu plusieurs paramètres dans une fonction callback. pour l'instant je n'ai qu'une table, et j'aimerais bien passer la fenetre:

Code:

g_signal_connect(G_OBJECT(Boutons[a]), "clicked", G_CALLBACK(Clic1), table);
Code:

1 2 3 4 5 void Clic1(GtkWidget *bouton, gpointer WinTable){ gtk_widget_destroy(WinTable); }
J'avais pensé qu'une structure contenant les deux pouvait faire l'affaire, mais je ne vois pas comment faire pour la mettre dans la g_signal_connect et dans le deuxième paramètre de clic1 tout en gardant le gpointer.

Voila un exemple que tu pourras agrémenter à ta guise :

Code:

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
#include <gtk/gtk.h>
 
typedef struct {
  GtkWidget *window;
  gchar *text;
} t_data;
 
void callback_button_clicked (GtkButton *button, gpointer userdata) {
  /* Casting de la donnée utilisateur transmise dans le bon type */
  t_data *data = (t_data*)userdata;
 
  /* Affichage de la donnée exemple en console */
  g_print ("%s", data->text);
}
 
gint
main(int argc, char* argv[]) {
  /* Déclaration d'une variable de type t_data */
  t_data data;
 
  /* Initialisation des bibliothèques Gtk+ */
  gtk_init (&argc, &argv);
 
  /* Création d'une fenêtre principale.
  * Le pointeur initialisé est issu de data */
  data.window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  /* Fixation de la taille de la fenêtre principale à l'ouverture */
  gtk_widget_set_size_request (data.window, 400, 400);
  /* Connexion du signal "destroy" pour fermer la fenêtre principale et quitter
   * la boucle principale Gtk+ */
  g_signal_connect (G_OBJECT (data.window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
 
  /* Initialisation pour l'exemple d'une donnée supplémentaire qui sera affichée
   * en console lors du clic sur un bouton */
  data.text = "texte à afficher lors du clic\n";
 
  /* Création d'un bouton */
  GtkWidget *button = gtk_button_new_with_label ("bouton à cliquer");
  /* Insertion du bouton dans la fenêtre principale */
  gtk_container_add (GTK_CONTAINER (data.window), button);
  /* Connexion du signal "clicked" au callback qui sera exécuter lors du
   * clic du bouton.
   * Transmission à ce même callback du pointeur de la variable data pour
   * traitement */
  g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback_button_clicked), &data);
 
  /* Affichage de la fenêtre principale */
  gtk_widget_show_all (data.window);
 
  /* Lancement de la boucle principale Gtk+ */
  gtk_main ();
 
  return 0;
}

26/08/2021, 10h23
LSBTD

Super !
Merci beaucoup pour les nombreuses réponses que tu m'as apporté !!!:D
Où pourrais_je trouvé des infos sur le "Casting" ?
car je vois que ça marche mais je déteste faire des choses sans savoir POURQUOI ça marche...
26/08/2021, 10h49
gerald3d
En C un pointeur générique n'est qu'une variable contenant une adresse. Le compilateur ne sait pas quel type de donnée se trouve à cette adresse. Il n'y a que toi qui le sait.

Gtk+ permet de transmettre un pointeur générique, c'est à dire une simple adresse à tes callbacks. Il faut donc indiquer au compilateur quel est le type de donnée qui s'y trouve. C'est le principe du casting.

Pour prendre un exemple plus simple imaginons que tu disposes d'une variable double data;. C'est à dire avec une virgule flottante. Tu désires afficher cette donnée mais seule la partie entière t'intéresse. Tu as deux possibilités pour le faire :
1. utiliser les arguments de printf sur les doubles pour n'afficher que la partie entière : printf ("%0.0f", data);
2. caster (anglicisme) le double en int : printf ("%d", (int)data);
Tu as les tutoriels C : https://c.developpez.com/cours/
Et aussi la Faq : https://c.developpez.com/faq/

Voila l'explication dans un tutoriel : https://c.developpez.com/cours/poly-...sions#LII-B-12

C'est une mine d'or. N'hésite pas à les consulter.
26/08/2021, 12h23
LSBTD

Merci bcp !!!:)