Boutons
gtkmm met à votre disposition quatre types basiques de boutons :
Bouton poussoir 	 Gtk::Button. Standard buttons, usually marked with a label or picture. Pushing one triggers an action. See the Button section.
Bouton bascule 	 Gtk::ToggleButton. Unlike a normal Button, which springs back up, a ToggleButton stays down until you press it again. It might be useful as an on/off switch. See the ToggleButton section.
Case à cocher 	 Gtk::CheckButton. These act like ToggleButtons, but show their state in small squares, with their label at the side. They should be used in most situations which require an on/off setting. See the CheckButton section.
Bouton radio 	 Gtk::RadioButton. Named after the station selectors on old car radios, these buttons are used in groups for options which are mutually exclusive. Pressing one causes all the others in its group to turn off. They are similar to CheckBoxes (a small widget with a label at the side), but usually look different. See the RadioButton section.
Notez qu'en raison du système des thèmes d'apparence de GTK+, l'aspect de ces éléments graphiques peut varier. Dans le cas des cases à cocher et des boutons radio, les variations peuvent être conséquentes.

Bouton

Constructeurs
Il y a deux façons de créer un bouton. Vous pouvez indiquer la chaîne étiquette dans le constructeur de Gtk::Button ou bien la définir plus tard avec set_label().
Pour définir une touche d'accès direct de navigation au clavier, placez un caractère souligné avant l'un des caractères de l'étiquette et définissez à true le paramètre optionnel mnemonic (mnémonique). Par exemple :

Gtk::Button* pButton = new Gtk::Button("_Quelquechose", true);

Stock items have been recommended for use in buttons. From gtkmm-3.10 they are deprecated. They should not be used in newly-written code. However, the documentation of namespace Gtk::Stock shows recommended labels and named icons to show in buttons.
Gtk::Button est aussi un conteneur ; vous pouvez donc y mettre n'importe quel autre élément graphique à l'intérieur, comme une Gtk::Image.
Reference

Exemple
Cet exemple crée un bouton avec image et étiquette.

Exemple de bouton
Source Code
File: buttons.h (For use with gtkmm 3, not gtkmm 2)

#ifndef GTKMM_EXAMPLE_BUTTONS_H
#define GTKMM_EXAMPLE_BUTTONS_H

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

class Buttons : public Gtk::Window
{
public:
  Buttons();
  virtual ~Buttons();

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

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

#endif //GTKMM_EXAMPLE_BUTTONS_H

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

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

Buttons::Buttons()
{
  m_button.add_pixlabel("info.xpm", "cool button");

  set_title("Pixmap'd buttons!");
  set_border_width(10);

  m_button.signal_clicked().connect( sigc::mem_fun(*this,
              &Buttons::on_button_clicked) );

  add(m_button);

  show_all_children();
}

Buttons::~Buttons()
{
}

void Buttons::on_button_clicked()
{
  std::cout << "The Button was clicked." << std::endl;
}

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

#include "buttons.h"
#include <gtkmm/application.h>

int main(int argc, char *argv[])
{
  Glib::RefPtr<Gtk::Application> app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

  Buttons buttons;

  //Shows the window and returns when it is closed.
  return app->run(buttons);
}

Signaux
L'élément graphique Gtk::Button émet les signaux suivants, mais la plupart du temps vous ne gérerez que le signal clicked (cliqué) :
pressed 	 Émis quand le bouton est enfoncé.
released 	 Émis quand le bouton est relâché.
clicked 	 Émis quand le bouton est enfoncé et relâché.
enter 	 Émis quand le pointeur de souris entre dans la fenêtre du bouton.
leave 	 Émis lorsque le pointeur de souris sort de la fenêtre du bouton.

Bouton bascule
Un objet de la classe ToggleButton est semblable à un objet de la classe Button, mais les boutons bascules restent activés, ou enfoncés, jusqu'à ce qu'ils soient à nouveau cliqués.
Pour obtenir l'état du ToggleButton, utilisez la fonction membre get_active(). Elle renvoie true si le bouton est « enfoncé ». Vous pouvez aussi définir l'état du bouton bascule avec set_active(). Notez que, si vous faites cet appel et que l'état du bouton est effectivement modifié, le signal « clicked » sera émis : ce comportement est celui habituellement recherché.
Utilisez la fonction membre toggled() pour inverser l'état du bouton, au lieu de l'obliger à être enfoncé ou pas : l'état du bouton est modifié et le signal toggled (basculé) est émis.
Gtk::ToggleButton est de grande utilité en tant que classe de base pour les classes Gtk::CheckButton et Gtk::RadioButton.
Reference

Case à cocher
La classe Gtk::CheckButton hérite de la classe Gtk::ToggleButton. La seule réelle différence entre les deux classes se situe au niveau de l'aspect graphique du Gtk::CheckButton. Vous obtenez, définissez et inversez son état à l'aide des mêmes fonctions membres que Gtk::ToggleButton.
Reference

Exemple

Case à cocher
Source Code
File: examplewindow.h (For use with gtkmm 3, not gtkmm 2)

#ifndef GTKMM_EXAMPLE_BUTTONS_H
#define GTKMM_EXAMPLE_BUTTONS_H

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

class ExampleWindow : public Gtk::Window
{
public:
  ExampleWindow();
  virtual ~ExampleWindow();

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

  //Child widgets:
  Gtk::CheckButton m_button;
};

#endif //GTKMM_EXAMPLE_BUTTONS_H

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

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

ExampleWindow::ExampleWindow()
: m_button("something")
{
  set_title("checkbutton example");
  set_border_width(10);

  m_button.signal_clicked().connect(sigc::mem_fun(*this,
              &ExampleWindow::on_button_clicked) );

  add(m_button);

  show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_button_clicked()
{
  std::cout << "The Button was clicked: state="
      << (m_button.get_active() ? "true" : "false")
      << std::endl;
}

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

#include "examplewindow.h"
#include <gtkmm/application.h>

int main(int argc, char *argv[])
{
  Glib::RefPtr<Gtk::Application> app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

  ExampleWindow window;

  //Shows the window and returns when it is closed.
  return app->run(window);
}

Bouton radio
De même que les cases à cocher, les boutons radio héritent aussi des propriétés des Gtk::ToggleButton, mais les boutons radio fonctionnent en groupe et, dans un groupe, un seul et unique bouton radio peut être sélectionné à un moment donné.

Groupes
Il y a deux façons de définir un groupe de boutons radio. La première est de créer les boutons et de définir leur groupement après-coup. Seuls les deux premiers constructeurs sont utilisés dans ce cas. Dans l'exemple suivant, nous créons une nouvelle classe de fenêtre nommée RadioButtons dans laquelle nous plaçons trois boutons radio :

class RadioButtons : public Gtk::Window
{
public:
    RadioButtons();

protected:
    Gtk::RadioButton m_rb1, m_rb2, m_rb3;
};

RadioButtons::RadioButtons()
  : m_rb1("Bouton1"),
    m_rb2("Bouton2"),
    m_rb3("Bouton3")
{
    Gtk::RadioButton::Group group = m_rb1.get_group();
    m_rb2.set_group(group);
    m_rb3.set_group(group);
}

Nous indiquons à gtkmm de placer les trois objets RadioButton dans un même groupe en obtenant un pointeur sur le groupe avec get_group() et en utilisant set_group() pour faire en sorte que les autres RadioButton partagent le même groupe.
Note that you can't just do

m_rb2.set_group(m_rb1.get_group()); //doesn't work

because the group is modified by set_group() and therefore non-const.
La deuxième façon pour grouper des boutons radio consiste à créer un groupement au préalable, puis y intégrer les boutons. Voici un exemple :

class RadioButtons : public Gtk::Window
{
public:
    RadioButtons();
};

RadioButtons::RadioButtons()
{
    Gtk::RadioButton::Group group;
    Gtk::RadioButton *m_rb1 = Gtk::manage(
      new Gtk::RadioButton(group,"Bouton1"));
    Gtk::RadioButton *m_rb2 = manage(
      new Gtk::RadioButton(group,"Bouton2"));
    Gtk::RadioButton *m_rb3 = manage(
      new Gtk::RadioButton(group,"Bouton3"));
}

Nous générons un nouveau groupe par une simple déclaration de variable, group, du type Gtk::RadioButton::Group, puis nous créons trois boutons radio avec le constructeur indiquant qu'ils font partie du groupe group.

Fonctions membres
À leur création, les objets de la classe RadioButtons sont « inactifs », donc, lors de la création du groupe, tous les boutons sont désactivés. N'oubliez donc pas d'en activer un avec set_active() :
Reference

Exemple
L'exemple suivant montre l'utilisation de la classe RadioButton :

Bouton radio
Source Code
File: radiobuttons.h (For use with gtkmm 3, not gtkmm 2)

#ifndef GTKMM_EXAMPLE_RADIOBUTTONS_H
#define GTKMM_EXAMPLE_RADIOBUTTONS_H

#include <gtkmm/box.h>
#include <gtkmm/window.h>
#include <gtkmm/radiobutton.h>
#include <gtkmm/separator.h>

class RadioButtons : public Gtk::Window
{
public:
  RadioButtons();
  virtual ~RadioButtons();

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

  //Child widgets:
  Gtk::Box m_Box_Top, m_Box1, m_Box2;
  Gtk::RadioButton m_RadioButton1, m_RadioButton2, m_RadioButton3;
  Gtk::Separator m_Separator;
  Gtk::Button m_Button_Close;
};

#endif //GTKMM_EXAMPLE_RADIOBUTTONS_H

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

#include "radiobuttons.h"


RadioButtons::RadioButtons() :
  m_Box_Top(Gtk::ORIENTATION_VERTICAL),
  m_Box1(Gtk::ORIENTATION_VERTICAL, 10),
  m_Box2(Gtk::ORIENTATION_VERTICAL, 10),
  m_RadioButton1("button1"),
  m_RadioButton2("button2"),
  m_RadioButton3("button3"),
  m_Button_Close("close")
{
  // Set title and border of the window
  set_title("radio buttons");
  set_border_width(0);

  // Put radio buttons 2 and 3 in the same group as 1:
  Gtk::RadioButton::Group group = m_RadioButton1.get_group();
  m_RadioButton2.set_group(group);
  m_RadioButton3.set_group(group);

  // Add outer box to the window (because the window
  // can only contain a single widget)
  add(m_Box_Top);

  //Put the inner boxes and the separator in the outer box:
  m_Box_Top.pack_start(m_Box1);
  m_Box_Top.pack_start(m_Separator);
  m_Box_Top.pack_start(m_Box2);

  // Set the inner boxes' borders
  m_Box2.set_border_width(10);
  m_Box1.set_border_width(10);

  // Put the radio buttons in Box1:
  m_Box1.pack_start(m_RadioButton1);
  m_Box1.pack_start(m_RadioButton2);
  m_Box1.pack_start(m_RadioButton3);

  // Set the second button active
  m_RadioButton2.set_active();

  // Put Close button in Box2:
  m_Box2.pack_start(m_Button_Close);

  // Make the button the default widget
  m_Button_Close.set_can_default();
  m_Button_Close.grab_default();

  // Connect the clicked signal of the button to
  // RadioButtons::on_button_clicked()
  m_Button_Close.signal_clicked().connect(sigc::mem_fun(*this,
              &RadioButtons::on_button_clicked) );

  // Show all children of the window
  show_all_children();
}

RadioButtons::~RadioButtons()
{
}

void RadioButtons::on_button_clicked()
{
  hide(); //to close the application.
}

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

#include "radiobuttons.h"
#include <gtkmm/application.h>

int main(int argc, char *argv[])
{
  Glib::RefPtr<Gtk::Application> app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

  RadioButtons buttons;

  //Shows the window and returns when it is closed.
  return app->run(buttons);
}