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.
- IX.II.I. Utilisation d'un modèle
- IX.II.II. Ajout de colonnes à la vue
- IX.II.III. Plus d'une colonne de modèle par colonne de vue
- IX.II.IV. Détails pour la définition du CellRenderer
- IX.II.V. Cellules modifiables
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.
Then use append_column() to add the view Column to the View. Notice that Gtk::TreeView::append_column() is overridden to accept either a prebuilt Gtk::TreeView::Column widget, or just the TreeModelColumn from which it generates an appropriate Gtk::TreeView::Column widget.
Here is some example code from gtkmm/demos/gtk-demo/example_icontheme.cc, which has a pixbuf icon and a text name in the same column:
Gtk::TreeView::Column* pColumn = Gtk::manage(new Gtk::TreeView::Column("Icon Name")); // m_columns.icon and m_columns.iconname are columns in the model. // pColumn is the column in the TreeView: pColumn->pack_start(m_columns.icon, /* expand= */ false); pColumn->pack_start(m_columns.iconname); m_TreeView.append_column(*pColumn);
IX.II.IV. Détails pour la définition du CellRenderer
The default CellRenderers and their default behaviour will normally suffice, but you might occasionally need finer control. For instance, this example code from gtkmm/demos/gtk-demo/example_treeview_treestore.cc, appends a Gtk::CellRenderer widget and instructs it to render the data from various model columns through various aspects of its appearance.
int cols_count = m_TreeView.append_column_editable("Alex", m_columns.alex); Gtk::TreeViewColumn* pColumn = m_TreeView.get_column(cols_count-1); if(pColumn) { Gtk::CellRendererToggle* pRenderer = static_cast<Gtk::CellRendererToggle*>(pColumn->get_first_cell()); 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.
Cells in a TreeView can be edited in-place by the user. To allow this, use the Gtk::TreeView insert_column_editable() and append_column_editable() methods instead of insert_column() and append_column(). When these cells are edited the new values will be stored immediately in the Model. Note that these methods are templates which can only be instantiated for simple column types such as Glib::ustring, int, and 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.
To achieve this, you should use the normal Gtk::TreeView insert_column() and append_column() methods, then use get_column_cell_renderer() to get the Gtk::CellRenderer used by that column.
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.