Discussion :

[drKzs]

bonjour,

J'utilise un treeModel pour representer une arborescence de fichiers, et je souhaite maintenant réaliser un filtre, suite à choix de l'utilisateur via un combobox.
Je souhaite utiliser un treeModelfilter, avec la fonction set_visible_func qui appellera un callback is_visible_file.
Mon problème, est que je ne comprend pas comment je peux passer le résultat de ma combo box (par exemple l'utilisateur ne souhaite que les fichiers txt) au callback, car le prototype du callback ne doit comprendre il me semble qu'un Gtk::TreeIter, et pas d'autre argument...

Mais il est très possible que je n'ai pas compris la doc

Si cela est effectivement impossible, je peux récupérer le choix de l'utilisateur via un pointeur, mais c'est quand même moins élégant...

Merci

[gege2061]

Bonjour,

toutes les fonctions callback ont un dernier argument de type gpointer qui te permet de passer des données personnelle (à renseigner avec la fonction g_signal_connect). Dans ton cas tu peux passer le GtkComboBox.

Je vais être casse pied à force mais, le mieux serait de créer un nouveau widget, par exemple FilterTreeView qui hérite de GtkVBox et qui contient une GtkComboBox et un GtkTreeView. Tu garde en privé les pointeurs sur ces deux widgets et c'est fini

[edit]En plus que tu utilise gtkmm, tu n'as pas d'excuses ![/edit]

[gege2061]

Voilà histoire de convaincre ce qui n'ont pas essayé l'héritage avec GTK+, voici ton problème résolu... mais en C A noter tout de même que le filtre est assez simple puisqu'il regarde s'il trouve ".txt" (par exemple) dans le nom donc si tu as un fichier fichier.txt.avi il sera caché alors que c'est un fichier avi, mais ça peut s'améliorer très facilement

Seul problème (au niveau conception), c'est que le FilterTreeView hérite de GtkVBox donc il est impossible d'utiliser directement (on peut toujours créer un geter) les fonctions dédiées aux GtkTreeView, ce qui paraitrait logique puisque que c'est un GtkTreeView avec une fonction de filtre.

main.c

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
#include <gtk/gtk.h>
 
#include "FilterTreeView.h"
 
int main (int argc, char **argv)
{
  gtk_init (&argc, &argv);
  {
    GtkWidget *p_window = NULL;
    GtkWidget *p_tree_view = NULL;
 
    p_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    g_signal_connect (G_OBJECT (p_window), "delete-event", G_CALLBACK (gtk_main_quit), NULL);
    p_tree_view = filter_tree_view_new ();
    gtk_container_add (GTK_CONTAINER (p_window), p_tree_view);
    gtk_widget_show_all (p_window);
  }
  gtk_main ();
  return 0;
}

FilterTreeView.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#ifndef H_NJ_FILTER_TREE_FILTER_20070127
#define H_NJ_FILTER_TREE_FILTER_20070127
 
#include <gtk/gtkvbox.h>
 
G_BEGIN_DECLS
 
#define TYPE_FILTER_TREE_VIEW			       (filter_tree_view_get_type ())
#define FILTER_TREE_VIEW(obj)			       (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_FILTER_TREE_VIEW, FilterTreeView))
#define FILTER_TREE_VIEW_CLASS(klass)		 (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_FILTER_TREE_VIEW, FilterTreeViewClass))
#define IS_FILTER_TREE_VIEW(obj)		     (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_FILTER_TREE_VIEW))
#define IS_FILTER_TREE_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_FILTER_TREE_VIEW))
#define FILTER_TREE_VIEW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_FILTER_TREE_VIEW, FilterTreeViewClass))
 
typedef struct _FilterTreeView      FilterTreeView;
typedef struct _FilterTreeViewClass FilterTreeViewClass;
 
struct _FilterTreeView
{
  GtkVBox parent;
};
 
struct _FilterTreeViewClass
{
  GtkVBoxClass parent_class;
};
 
GType filter_tree_view_get_type (void) G_GNUC_CONST;
 
GtkWidget *filter_tree_view_new (void);
 
 
G_END_DECLS
 
#endif /* not H_NJ_FILTER_TREE_FILTER_20070127 */

FilterTreeView.c

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
#include "FilterTreeView.h"
 
#include <string.h>
#include <gtk/gtk.h>
 
#define FILTER_TREE_VIEW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
                                             TYPE_FILTER_TREE_VIEW,        \
                                             FilterTreeViewPrivate))
 
typedef struct _FilterTreeViewPrivate FilterTreeViewPrivate;
 
struct _FilterTreeViewPrivate
{
  GtkComboBox *p_combo_box;
  GtkTreeModelFilter *filter;
};
 
static void filter_tree_view_destroy (GtkObject *object)
{
  FilterTreeViewClass *klass;
 
  g_return_if_fail (object != NULL);
  g_return_if_fail (IS_FILTER_TREE_VIEW (object));
 
  klass = gtk_type_class (gtk_widget_get_type ());
  (*GTK_OBJECT_CLASS (klass)->destroy) (object);
}
 
static void filter_tree_view_class_init (FilterTreeViewClass *klass)
{
  GtkObjectClass *object_class;
 
  g_return_if_fail (klass != NULL);
 
  object_class = (GtkObjectClass *)klass;
  object_class->destroy = filter_tree_view_destroy;
  g_type_class_add_private (klass, sizeof (FilterTreeViewPrivate));
}
 
static void filter_tree_view_init (FilterTreeView *this)
{
  g_return_if_fail (this != NULL);
}
 
static void fill_combo_box (GtkComboBox *p_combo_box)
{
  g_return_if_fail (p_combo_box != NULL);
 
  gtk_combo_box_append_text (p_combo_box, "");
  gtk_combo_box_append_text (p_combo_box, ".txt");
}
 
static void fill_tree_view (GtkListStore *p_list_store)
{
  gint i;
  gchar *items[] = {"fichier.txt", "fichier.ogg", "fichier.odt", NULL};
  GtkTreeIter iter;
 
  g_return_if_fail (p_list_store != NULL);
 
  for (i = 0; items[i] != NULL; i++)
  {
    gtk_list_store_append (p_list_store, &iter);
    gtk_list_store_set (p_list_store, &iter, 0, items[i], -1);
  }
}
 
static gboolean filter_func (GtkTreeModel *p_tree_model, GtkTreeIter *iter, gpointer data)
{
  gboolean visible = TRUE;
  FilterTreeView *this = NULL;
  gchar *item = NULL;
 
  g_return_val_if_fail (IS_FILTER_TREE_VIEW (data), visible);
  this = data;
 
  gtk_tree_model_get (p_tree_model, iter, 0, &item, -1);
  if (item)
  {
    gchar *select_item = NULL;
    FilterTreeViewPrivate *priv = NULL;
 
    priv = FILTER_TREE_VIEW_GET_PRIVATE (this);
 
    select_item = gtk_combo_box_get_active_text (priv->p_combo_box);
    if (select_item && select_item[0] != '\0' && strstr (item, select_item) == NULL)
    {
        visible = FALSE;
    }
    g_free (item), item = NULL;
    g_free (select_item), select_item = NULL;
  }
 
  return visible;
}
 
static void cb_refresh (GtkWidget *p_widget, FilterTreeView *this)
{
  FilterTreeViewPrivate *priv = NULL;
 
  g_return_if_fail (IS_FILTER_TREE_VIEW (this));
 
  priv = FILTER_TREE_VIEW_GET_PRIVATE (this);
 
  gtk_tree_model_filter_refilter (priv->filter);
}
 
G_DEFINE_TYPE (FilterTreeView, filter_tree_view, GTK_TYPE_VBOX)
 
GtkWidget *filter_tree_view_new (void)
{
  FilterTreeView *this = NULL;
 
  this = gtk_type_new (filter_tree_view_get_type ());
  gtk_box_set_homogeneous (GTK_BOX (this), FALSE);
  {
    GtkWidget *p_hbox = NULL;
    GtkWidget *p_button = NULL;
    FilterTreeViewPrivate *priv = NULL;
 
    priv = FILTER_TREE_VIEW_GET_PRIVATE (this);
 
    p_hbox = gtk_hbox_new (FALSE, 0);
    gtk_box_pack_start (GTK_BOX (this), GTK_WIDGET (p_hbox), FALSE, FALSE, 0);
 
    priv->p_combo_box = GTK_COMBO_BOX (gtk_combo_box_new_text ());
    fill_combo_box (priv->p_combo_box);
    gtk_box_pack_start (GTK_BOX (p_hbox), GTK_WIDGET (priv->p_combo_box), TRUE, TRUE, 0);
 
    p_button = gtk_button_new_from_stock (GTK_STOCK_REFRESH);
    g_signal_connect (G_OBJECT (p_button), "clicked", G_CALLBACK (cb_refresh), this);
    gtk_box_pack_start (GTK_BOX (p_hbox), GTK_WIDGET (p_button), FALSE, FALSE, 0);
 
    {
      GtkCellRenderer *renderer = NULL;
      GtkTreeViewColumn *column = NULL;
      GtkListStore *p_list_store = NULL;
      GtkWidget *p_tree_view = NULL;
 
      p_list_store = GTK_LIST_STORE (gtk_list_store_new (1, G_TYPE_STRING));
      priv->filter = GTK_TREE_MODEL_FILTER (gtk_tree_model_filter_new (GTK_TREE_MODEL (p_list_store), NULL));
      gtk_tree_model_filter_set_visible_func (priv->filter, filter_func, this, NULL);
      p_tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (priv->filter));
 
      renderer = gtk_cell_renderer_text_new ();
      column = gtk_tree_view_column_new_with_attributes ("FilterTreeView",
                                                         renderer, "text",
                                                         0, NULL);
      gtk_tree_view_append_column (GTK_TREE_VIEW (p_tree_view), column);
      fill_tree_view (p_list_store);
      gtk_box_pack_start (GTK_BOX (this), p_tree_view, TRUE, TRUE, 0);
    }
  }
  return GTK_WIDGET (this);
}

[drKzs]

hmm merci bien pour cet exemple
en effet, c'est une bonne idée pour le combo et le treeview, mais débutant en C++, et en Gtkmm, je crois que je vais commencer par bien garder mes types distincts, une combo box, et une treeview filtré On va dire que je suis un peu frileux au départ

Pour ce qui est du filtre effectivement c pas trop compliqué, il y a juste à repérer le dernier point du nom du fichier, donc la difficulté n'est pas là...

En revanche pour le callback, il me semble bien qu'avec gtkmm, il n'y a qu'un TreeIter en parametre.... Et rien d'autre :'(

[gege2061]

débutant en C++, et en Gtkmm, je crois que je vais commencer par bien garder mes types distincts, une combo box, et une treeview filtré

Il ne faut pas avoir peur, en C++ c'est beaucoup plus simple puisque c'est de l'orienté objet. Tu as juste à faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
class FilterTreeView : Gtk::VBox
{
  private:
    void cb_refresh ();
    void filter_func ();
    void fill_tree_view ();
    void fill_combo_box ();
    Gtk::ComboBox *combo_box;
    Gtk::TreeModelFilter *filter;
  public:
    FilterTreeView ();
}

(les propotypes ne sont pas complets)

Tout le reste c'est des bidouilles de Ciste pour imiter la programmation OO, donc tu n'en as pas besoin

En revanche pour le callback, il me semble bien qu'avec gtkmm, il n'y a qu'un TreeIter en parametre.... Et rien d'autre :'(

Effectivement : SlotVisible