La vue

La vue est l'élément graphique (Gtk::TreeView) qui affiche concrètement les données du modèle (Gtk::TreeModel) et qui autorise l'utilisateur à interagir. Elle peut afficher, de diverses manières, toutes les colonnes du modèle ou seulement quelques unes.

Référence

IX.II.I. Utilisation d'un modèle

Vous pouvez définir le modèle Gtk::TreeModel à la construction de l'objet vue Gtk::TreeView ou bien vous pouvez utiliser la fonction membre set_model(), comme suit :

m_TreeView.set_model(m_refListStore);

IX.II.II. Ajout de colonnes à la vue

Vous pouvez utiliser la fonction membre append_column() pour demander à la vue d'afficher certaines colonnes du modèle, dans un certain ordre, avec un certain intitulé.

m_TreeView.append_column("Messages", m_Columns.m_col_text);

En utilisant cette simple surdéfinition de append_column(), l'objet TreeView affiche la donnée du modèle avec un CellRenderer approprié. Par exemple, les chaînes littérales et les nombres sont affichés dans un simple contrôle Gtk::Entry et les booléens dans un Gtk::CheckButton. Cela correspond aux besoins habituels. Pour des colonnes relatives à d'autres types, vous pouvez, soit connecter une fonction de rappel qui convertit avec TreeViewColumn::set_cell_data_func() le type en chaîne littérale le représentant, soit créer par dérivation un CellRenderer personnalisé. Notez que le type (unsigned) short n'est pas pris en charge par défaut — à la place, vous pouvez utiliser le type (unsigned) int ou (unsigned) long.

IX.II.III. Plus d'une colonne de modèle par colonne de vue

Pour afficher à l'écran plus d'une colonne du modèle dans une colonne de vue, vous aurez besoin de créer un élément graphique TreeView::Column manuellement et d'utiliser la fonction membre pack_start() pour y ajouter les colonnes du modèle.

Ensuite, avec append_column(), ajoutez la colonne à la vue. Vous noterez que Gtk::View::append_column() a été surdéfini pour accepter, soit un élément graphique Gtk::View::Column préalablement construit, soit uniquement un TreeModelColumn à partir duquel cette fonction membre génére un élément graphique Gtk::View::Column approprié.

Voici quelques exemples de code extraits de demos/gtk-demo/example_stockbrowser.cc, qui possède une icône pixelisée et du texte dans une même colonne :

Gtk::TreeView::Column* pColumn =
    Gtk::manage( new Gtk::TreeView::Column("Symbole") );

// m_columns.icon et m_columns.symbol sont des colonnes du modèle.
// pColumn est la colonne dans l'objet TreeView :
pColumn->pack_start(m_columns.icon, false); //false = ne pas développer.
pColumn->pack_start(m_columns.symbol);

m_TreeView.append_column(*pColumn);

IX.II.IV. Détails pour la définition du CellRenderer

Le comportement par défaut de la classe CellRenderers suffit en règle générale, mais vous pouvez dans certains cas avoir besoin d'un contrôle plus fin. Ainsi, cet exemple de code, pris dans demos/gtk-demo/example_treestore.cc, construit manuellement un élément graphique Gtk::CellRenderer et le programme pour qu'il effectue un rendu avec variations d'aspect selon les données des diverses colonnes du modèle.

Gtk::CellRendererToggle* pRenderer =
    Gtk::manage( new Gtk::CellRendererToggle() );
int cols_count = m_TreeView.append_column("Alex", *pRenderer);
Gtk::TreeViewColumn* pColumn = m_TreeView.get_column(cols_count-1);
if(pColumn)
{
  pColumn->add_attribute(pRenderer->property_active(),
      m_columns.alex);
  pColumn->add_attribute(pRenderer->property_visible(),
      m_columns.visible);
  pColumn->add_attribute(pRenderer->property_activatable(),
      m_columns.world);

Vous pouvez aussi connecter les signaux du CellRenderer pour détecter des actions utilisateur. Par exemple :

Gtk::CellRendererToggle* pRenderer =
    Gtk::manage( new Gtk::CellRendererToggle() );
pRenderer->signal_toggled().connect(
    sigc::bind( sigc::mem_fun(*this,
        &Example_TreeView_TreeStore::on_cell_toggled), m_columns.dave)
);

IX.II.V. Cellules modifiables

IX.II.V.I. Cellules modifiables à enregistrement automatique.

Des cellules d'un objet TreeView peuvent être modifiées in-situ par l'utilisateur. Pour permettre ce comportement, utilisez les fonctions membres Gtk::TreeViewinsert_column_editable() et append_column_editable() au lieu de insert_column() et append_column(). Quand ces colonnes sont modifiées, les nouvelles valeurs sont immédiatement enregistrées dans le modèle. Notez que ces fonctions membres sont des prototypes qui ne peuvent être utilisés que dans le cas de types de colonnes simples tels que des Glib::ustring, des int et des long.

IX.II.V.II. Implémentation d'une logique personnalisée pour les cellules modifiables.

Toutefois, vous pouvez vouloir que les nouvelles valeurs ne soient pas immédiatement enregistrées. Vous voulez, par exemple, limiter la saisie à certains caractères ou plages de valeurs.

Pour réaliser cela, utilisez les fonctions membres normales Gtk::TreeViewinsert_column() et append_column(), puis, avec get_column_cell_renderer(), obtenez le pointeur sur le Gtk::CellRenderer utilisé par cette colonne.

Ensuite vous ferez un forçage du type de ce pointeur Gtk::CellRenderer* vers un CellRenderer donné, conforme à vos attentes. Vous utilisez ainsi une API particulière.

Par exemple, pour un CellRendererText, vous définissez la propriété editable égale à true, comme ceci :

cell.property_editable() = true;

Pour un « CellRendererToggle », vous paramétrez la propriété activatable à la place.

Vous pouvez alors connecter le signal « edited » approprié, par exemple, connecter à Gtk::CellRendererText::signal_edited() ou Gtk::CellRendererToggle::signal_toggled(). Si la colonne comprend plus d'un CellRenderer, vous aurez besoin d'utiliser Gtk::TreeView::get_column(), puis d'appeler get_cell_renderers() sur cette colonne de la vue.

Dans le gestionnaire de signal, vous devriez examiner la nouvelle valeur et l'enregistrer dans le modèle si vous la jugez appropriée pour l'application.

Le modèle Itération parmi les colonnes du modèle

À propos