Hello World en gtkmm

• Programming with gtkmm 3
• Fondamentaux

Nous en savons maintenant assez pour examiner un exemple réel. Pour reprendre une vieille tradition du monde de l'informatique, nous allons maintenant présenter le programme « Hello World » accommodé à la gtkmm :

Code source

File: helloworld.h (For use with gtkmm 3, not gtkmm 2)

#ifndef GTKMM_EXAMPLE_HELLOWORLD_H
#define GTKMM_EXAMPLE_HELLOWORLD_H

#include <gtkmm/button.h>
#include <gtkmm/window.h>

class HelloWorld : public Gtk::Window
{

public:
  HelloWorld();
  virtual ~HelloWorld();

protected:
  //Signal handlers:
  void on_button_clicked();

  //Member widgets:
  Gtk::Button m_button;
};

#endif // GTKMM_EXAMPLE_HELLOWORLD_H

File: main.cc (For use with gtkmm 3, not gtkmm 2)

#include "helloworld.h"
#include <gtkmm/main.h>

int main (int argc, char *argv[])
{
  Gtk::Main kit(argc, argv);

  HelloWorld helloworld;
  //Shows the window and returns when it is closed.
  Gtk::Main::run(helloworld);

  return 0;
}

File: helloworld.cc (For use with gtkmm 3, not gtkmm 2)

#include "helloworld.h"
#include <iostream>

HelloWorld::HelloWorld()
: m_button("Hello World")   // creates a new button with label "Hello World".
{
  // Sets the border width of the window.
  set_border_width(10);

  // When the button receives the "clicked" signal, it will call the
  // on_button_clicked() method defined below.
  m_button.signal_clicked().connect(sigc::mem_fun(*this,
              &HelloWorld::on_button_clicked));

  // This packs the button into the Window (a container).
  add(m_button);

  // The final step is to display this newly created widget...
  m_button.show();
}

HelloWorld::~HelloWorld()
{
}

void HelloWorld::on_button_clicked()
{
  std::cout << "Hello World" << std::endl;
}

Essayez de le compiler et de le lancer avant de poursuivre. Vous devriez voir quelque chose comme :

Figure III.1 Hello World

Tout à fait palpitant, n'est-ce-pas ? Examinons le code. D'abord, la classe HelloWorld :

class HelloWorld : public Gtk::Window
{

public:
  HelloWorld();
  virtual ~HelloWorld();

protected:
  //Gestionnaire de signal :
  virtual void on_button_clicked();

  //éléments graphiques membres :
  Gtk::Button m_button;
};

Cette classe implémente la fenêtre « Hello World ». Elle est dérivée de la classe Gtk::Window et possède un simple Gtk::Button comme membre. Nous avons pris le parti d'utiliser le constructeur pour faire toutes les tâches d'initialisation de la fenêtre, y compris la définition des signaux. Voici le code, les commentaires sont omis :

HelloWorld::HelloWorld()
:
  m_button ("Hello World")
{
  set_border_width(10);
  m_button.signal_clicked().connect(sigc::mem_fun(*this,
    &HelloWorld::on_button_clicked));
  add(m_button);.
  m_button.show();
}

Notez que nous avons utilisé une instruction d'initialisation pour étiqueter l'objet m_button avec « Hello World ».

Puis nous appelons la fonction membre set_border_width() de l'objet Window. Elle fixe la dimension de l'espace entre les côtés de la fenêtre et l'élément graphique qu'elle contient.

Ensuite, nous raccordons un gestionnaire de signal pour le signal clicked du m_button. Le gestionnaire affiche sur stdout notre salut amical.

Puis, nous utilisons la fonction membre add() avec l'objet Window pour y placer le m_button (add() est une fonction membre de la classe Gtk::Container que nous décrirons dans le chapitre des éléments graphiques conteneurs). La fonction add() place l'élément graphique dans la fenêtre, mais elle ne l'affiche pas. Les éléments graphiques gtkmm sont toujours invisibles à leur création — pour les afficher, vous devez faire appel à la fonction show(), ce que nous faisons à la ligne suivante.

Maintenant examinons la fonction main() du programme. La voici, sans commentaire :

int main(int argc, char** argv)
{
  Gtk::Main kit(argc, argv);

  HelloWorld helloworld;
  Gtk::Main::run(helloworld);

  return 0;
}

Tout d'abord nous créons un exemplaire d'un objet nommé kit. Il est du type Gtk::Main. Tout programme gtkmm doit en posséder un. Nous passons les paramètres en ligne de commande à son constructeur. Il prélève les arguments dont il a besoin et vous laisse le reste, comme nous l'avons expliqué plus haut.

Ensuite nous définissons un objet de la classe HelloWorld dont le constructeur ne prend pas de paramètres ; il n'est pas encore visible. Quand nous appelons Gtk::Main::run(), avec comme paramètre la fenêtre helloworld, la fonction main() affiche la fenêtre et démarre la boucle des événements gtkmm. Lorsque la boucle des événements gtkmm est inactive, elle est en attente des actions de l'utilisateur pour y répondre de façon appropriée. Quand l'utilisateur ferme la fenêtre, la fonction run() retourne et déclenche l'exécution de la dernière ligne de la fonction main(). Et le programme se termine.