Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

  1. #1
    Membre actif
    Homme Profil pro
    Inscrit en
    septembre 2003
    Messages
    506
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : septembre 2003
    Messages : 506
    Points : 248
    Points
    248
    Par défaut [gtkmm] filtre fichier treemodelfilter set_func_visible
    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

  2. #2
    Rédacteur

    Avatar de gege2061
    Femme Profil pro
    Administrateur de base de données
    Inscrit en
    juin 2004
    Messages
    5 840
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 36
    Localisation : France

    Informations professionnelles :
    Activité : Administrateur de base de données

    Informations forums :
    Inscription : juin 2004
    Messages : 5 840
    Points : 11 334
    Points
    11 334
    Par défaut
    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]

  3. #3
    Rédacteur

    Avatar de gege2061
    Femme Profil pro
    Administrateur de base de données
    Inscrit en
    juin 2004
    Messages
    5 840
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 36
    Localisation : France

    Informations professionnelles :
    Activité : Administrateur de base de données

    Informations forums :
    Inscription : juin 2004
    Messages : 5 840
    Points : 11 334
    Points
    11 334
    Par défaut
    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);
    }

  4. #4
    Membre actif
    Homme Profil pro
    Inscrit en
    septembre 2003
    Messages
    506
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : septembre 2003
    Messages : 506
    Points : 248
    Points
    248
    Par défaut
    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 :'(

  5. #5
    Rédacteur

    Avatar de gege2061
    Femme Profil pro
    Administrateur de base de données
    Inscrit en
    juin 2004
    Messages
    5 840
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 36
    Localisation : France

    Informations professionnelles :
    Activité : Administrateur de base de données

    Informations forums :
    Inscription : juin 2004
    Messages : 5 840
    Points : 11 334
    Points
    11 334
    Par défaut
    Citation Envoyé par drKzs
    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

    Citation Envoyé par drKzs
    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

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. JFileChooser et filtre fichier
    Par ticNFA dans le forum IO
    Réponses: 2
    Dernier message: 28/09/2011, 08h21
  2. [c++] filtre fichiers
    Par drKzs dans le forum C++
    Réponses: 4
    Dernier message: 25/01/2007, 20h08
  3. [FileChooser] filtre type *fichier.ext
    Par Terminator dans le forum AWT/Swing
    Réponses: 3
    Dernier message: 26/04/2006, 21h39
  4. Sélectionner un fichier à partir d'une liste filtrée
    Par Lenaick dans le forum C++Builder
    Réponses: 7
    Dernier message: 14/03/2006, 11h16
  5. Réponses: 2
    Dernier message: 03/06/2005, 11h01

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo