Code::Blocks et Gtk+ sous Windows

Comme indiqué dans l’introduction, Gtk+ met à disposition une page explicative en anglais pour installer tout le nécessaire à la compilation, mais aussi à l’installation des bibliothèques. Deux méthodes d’installation sont proposées :

1. MSYS2 permet de faire du développement cross-platform entre Linux et Windows et permet d'utiliser des outils Linux sous Windows. C’est la méthode qui sera utilisée ici ;
2. gvsbuild permet de créer les bibliothèques Gtk+ à l'aide de Visual Studio.

Il existe (existait) d’autres manières de faire comme dans cet article sur DVP de Thierry Chappuis. Malheureusement, tous les liens indiqués sont morts aujourd’hui.

Téléchargeons MSYS2, puis lançons l’installation en laissant tous les champs tels qu'ils sont présentés. L'installation par défaut s’effectue dans c:\msys64.

Une fois l'installation terminée, lançons le shell (MSYS2 MSYS). Une fenêtre avec un prompt s’ouvre. Comme spécifié sur la page officielle, il faut exécuter une mise à jour avec la commande « pacman -Syu ».

Il nous faut réitérer l’opération avec la commande « pacman -Su ».

Maintenant que MSYS2 est à jour, plus précisément sa base de données des différents outils utilisables, passons à l’installation de tout le nécessaire pour compiler.

Lançons la commande « pacman -S --needed base-devel mingw-w64-x86_64-toolchain ».

Elle propose de choisir entre différents outils de compilation. Le choix « All » par défaut semble tout indiqué (~200Mo à télécharger). Nous aurons ainsi à notre disposition un compilateur (gcc), un débogueur (gdb), etc.

À partir d’ici, nous pouvons, en lançant « MSYS MinGW 64-bit », compiler un projet sous Windows « à la main ». Nous obtiendrons un shell dans lequel les commandes gcc et make sont opérationnelles.

Remarque : il existe d’autres compilateurs utilisables sous Windows (voir cette page pour une liste détaillée). Avec MinGW, c’est gcc qui sera utilisé ici.

La page officielle de Gtk+ indique comment installer les bibliothèques Gtk+ avec l’une des commandes suivantes en fonction de la version désirée :

« pacman -S mingw-w64-x86_64-gtk2 ».

« pacman -S mingw-w64-x86_64-gtk3 ».

« pacman -S mingw-w64-x86_64-gtk4 ».

Il n’est pas interdit de toutes les installer. C’est la configuration de Code::Blocks qui nous permettra de choisir entre elles en fonction des besoins.

Pour celles et ceux qui désirent utiliser Glade, il faut lancer la commande « pacman -S mingw-w64-x86_64-glade ». Pour rappel, Glade est un outil RAD permettant de développer rapidement et facilement des interfaces utilisateur pour la boîte à outils GTK et l'environnement de bureau GNOME.

Avant tout, Code::Blocks est un IDE (Integrated Development Environment). C'est-à-dire, pour faire simple, un éditeur de texte amélioré adapté à la programmation. Il n’intègre pas de compilateur par défaut. Il faudra donc lui indiquer, via ses menus de configuration, où trouver les outils dont il a besoin.

Pour l’installation de ce dernier, rien de plus simple. Téléchargeons la dernière version sur la page officielle et lançons l’exécutable.

Les ennuis commencent ici. Une première fenêtre apparaît pour signifier qu'aucun compilateur n'a été trouvé ! Pourtant, MSYS2 s'en est justement occupé. Il va nous falloir lui montrer où cela se trouve. Ignorons cet avertissement pour arriver sur l'interface principale.

2-3-1. Spécification du compilateur▲

Ouvrons la fenêtre de configuration des outils de compilation depuis le menu «Settings→Compiler».

Dans cette fenêtre, il y a différents onglets, dont « Toolchain executables ». Cliquons dessus. Il faut spécifier le répertoire où se trouvent les outils de compilation dans « Compiler's installation directory ». Comme nous n’avons pas changé les répertoires d’installation par défaut, il suffit de spécifier « C:\msys64\mingw64\bin ». Ce répertoire est important pour l'utilisation de Gtk+ aussi. Dans cette même fenêtre, il faut spécifier le même répertoire pour gcc. Il est possible de répéter l'opération pour les autres outils de compilation si nous devons les utiliser.

À partir de maintenant, Code::Blocks peut compiler. Mais si nous essayons de compiler un code source qui utilise Gtk+, il ne sait pas encore l’utiliser. La section suivante va nous permettre de combler ce manque.

2-3-2. Configuration des bibliothèques Gtk+▲

Sous Linux, de nombreuses bibliothèques utilisent un outil pour générer les options de compilation à transmettre au compilateur. Il s’agit de «pkg-config». L’outil attend en paramètres le nom d’un fichier et une option.

Pour ce qui nous concerne ici, le nom du fichier sera lié à Gtk. Ce sera gtk+-2.0, gtk+-3.0 ou gtk4 en fonction de la version désirée. Pour l’option, il en existe deux :

1. --cflags qui permet d’inclure les bibliothèques nécessaires lors de la compilation ;
2. --libs qui permet de lier les bibliothèques lors de la construction de l’exécutable.

Si nous tapons en console la commande « pkg-config gtk+-3.0 --cflags », voici ce que nous obtenons :

 

Sélectionnez

pkg-config gtk+-3.0 –cflags

-pthread -I/usr/include/gtk-3.0 -I/usr/include/at-spi2-atk/2.0 -I/usr/include/at-spi-2.0 -I/usr/include/dbus-1.0 -I/usr/lib/x86_64-linux-gnu/dbus-1.0/include -I/usr/include/gtk-3.0 -I/usr/include/gio-unix-2.0 -I/usr/include/cairo -I/usr/include/pango-1.0 -I/usr/include/harfbuzz -I/usr/include/pango-1.0 -I/usr/include/fribidi -I/usr/include/harfbuzz -I/usr/include/atk-1.0 -I/usr/include/cairo -I/usr/include/pixman-1 -I/usr/include/uuid -I/usr/include/freetype2 -I/usr/include/libpng16 -I/usr/include/gdk-pixbuf-2.0 -I/usr/include/libpng16 -I/usr/include/x86_64-linux-gnu -I/usr/include/libmount -I/usr/include/blkid -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include

Et de même avec la commande « pkg-config gtk+-3.0 --libs » :

 

Sélectionnez

pkg-config gtk+-3.0 –libs

-lgtk-3 -lgdk-3 -lpangocairo-1.0 -lpango-1.0 -lharfbuzz -latk-1.0 -lcairo-gobject -lcairo -lgdk_pixbuf-2.0 -lgio-2.0 -lgobject-2.0 -lglib-2.0

Comme MSYS a installé tout le nécessaire, nous retrouverons cet outil. Nous allons donc insérer ces commandes dans la configuration de Code::Blocks pour qu’il puisse les utiliser lors de la compilation.

2-3-2-1. Gtk+ pour tous les nouveaux projets▲

Si nous voulons qu’à chaque nouveau projet créé, Code::blocks intègre les bibliothèques Gtk+, voilà la méthode à suivre.

On ouvre à nouveau la fenêtre « compiler settings ».

L'onglet « compiler settings » sélectionné, en dessous il y a une rangée d'onglets. Choisissons « Other compiler options ».

Copions l’une des lignes suivantes en fonction de la version désirée dans la partie inférieure :

`pkg-config gtk+-2.0 –-cflags`

`pkg-config gtk+-3.0 –-cflags`

`pkg-config gtk4 –-cflags`

Les apostrophes n'en sont pas. Ce sont des « quotes inversées » obtenues par la combinaison de touches AltGr + 7. Elles sont nécessaires.

Dans l'onglet « Linker settings », copions l’une des lignes suivantes dans la partie droite en fonction de la version désirée.

`pkg-config gtk+-2.0 –-libs`

`pkg-config gtk+-3.0 –-libs`

`pkg-config gtk4 –-libs`

Les apostrophes n'en sont pas. Ce sont des « quotes inversées » obtenues par la combinaison de touches AltGr + 7. Elles sont nécessaires.

2-3-2-2. Gtk+ pour un projet spécifique▲

Ici, nous partons du principe que Code::Blocks n’est pas configuré de manière permanente pour intégrer Gtk+. Pour ma part, je privilégie cette méthode. Elle est plus contraignante puisqu’elle oblige à insérer à chaque fois les options de compilation. Mais elle a le mérite de configurer le processus de compilation exactement selon les besoins de la future application.

Toutes les manipulations de la section précédente vont être à faire à l’identique. La différence réside dans le menu choisi au départ.

Créons un projet vide (Empty project). Nous allons spécifier les mêmes options de compilation en ouvrant cette fois le menu « Project→build options ».

Une fenêtre ressemblant très fortement à la fenêtre de configuration vue précédemment s’ouvre. Il nous suffit de placer les commandes `pkg-config gtk+-3.0 –-cflags` et `pkg-config gtk+-3.0 –-libs` aux mêmes endroits (ici Gtk+ v3).

Remarque : comme nous pouvons le voir sur les captures d’écran sous le nom du projet, « Debug » est sélectionné. Nous devrons répéter l’opération pour la version « Release ». Nous pouvons aussi généraliser la configuration en sélectionnant le nom du projet au départ avant de saisir les options de configuration.

Créons un projet en mode console. Choisissons le langage C. Dans le fichier source main.c, remplaçons le code source par celui-ci :

#include <stdio.h>
#include <stdlib.h>
#include "gtk/gtk.h"
int main(gint argc, gchar **argv)
{
    gtk_init (&argc, &argv);
    GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);

    gtk_widget_show_all (window);

    gtk_main ();

    return 0;
}

Si Code::Blocks est configuré de manière permanente, ce code doit compiler au premier essai. Si par contre, Code::Blocks n’est pas configuré par défaut, il faut alors configurer le projet comme indiqué à la section « Gtk+ pour un projet spécifique ».

Cet exemple est tiré de la documentation officielle.

#include <gtk/gtk.h>

static void
activate (GtkApplication* app,
          gpointer        user_data)
{
  GtkWidget *window;

  window = gtk_application_window_new (app);
  gtk_window_set_title (GTK_WINDOW (window), "Window");
  gtk_window_set_default_size (GTK_WINDOW (window), 200, 200);
  gtk_widget_show (window);
}

int
main (int    argc,
      char **argv)
{
  GtkApplication *app;
  int status;

  app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
  g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
  status = g_application_run (G_APPLICATION (app), argc, argv);
  g_object_unref (app);

  return status;
}