Discussion :

[fgh39]

Bonjour
Je dois réaliser un programme permettant d'afficher, copier et trier une liste d'informations avec plusieurs lignes et colonnes.
Pour cela je pense devoir utiliser la fonction gtktreeview qui permet d'afficher, de trier les lignes voire colonnes et de les copier rapidement (à la souris).
Hélas ça fait quelques mois que je cherche et je ne trouve pas d'exemples de code source contenant l'ensemble des fonctions gtktreeview + sélectionner des lignes et-ou colonnes de façon a l'adapter à mes besoins. Je ne me suis pas encore bien intéressé au filtrage des lignes.

J'ai trouvé ce code (code1) qui me permet de générer un gtkteeview, et un autre bout de code (code2) plus loin dans ce post, qui semble t il ... me permettrait de sélectionner des lignes, mais je ne comprends pas comment assembler ces 2 bouts de codes.

Il n'y aurait pas un tuto si possible en Français expliquant comment on manipules gtktreeview, gtklist_store et leurs options, ou un exemple ?

J'ai recherché sur le web et on trouve des infos mais avec du python, du vala, php, ... etc, mais c'est le C qui nous intéresse.

(code1)

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
 
 
/* 
 * Compile with:
 *  gcc -o helloworld helloworld.c `pkg-config --cflags --libs gtk+-2.0`
 *
 */
 
#include <gtk/gtk.h>
 
enum
{
  COL_NAME = 0,
  COL_AGE,
  NUM_COLS
} ;
 
 
static GtkTreeModel *
create_and_fill_model (void)
{
  GtkListStore  *store;
  GtkTreeIter    iter;
 
  store = gtk_list_store_new (NUM_COLS, G_TYPE_STRING, G_TYPE_UINT);
 
  /* Append a row and fill in some data */
  gtk_list_store_append (store, &iter);
  gtk_list_store_set (store, &iter,
                      COL_NAME, "Heinz El-Mann",
                      COL_AGE, 51,
                      -1);
 
  /* append another row and fill in some data */
  gtk_list_store_append (store, &iter);
  gtk_list_store_set (store, &iter,
                      COL_NAME, "Jane Doe",
                      COL_AGE, 23,
                      -1);
 
  /* ... and a third row */
  gtk_list_store_append (store, &iter);
  gtk_list_store_set (store, &iter,
                      COL_NAME, "Joe Bungop",
                      COL_AGE, 91,
                      -1);
 
  return GTK_TREE_MODEL (store);
}
 
static GtkWidget *
create_view_and_model (void)
{
  GtkCellRenderer     *renderer;
  GtkTreeModel        *model;
  GtkWidget           *view;
 
  view = gtk_tree_view_new ();
 
  /* --- Column #1 --- */
 
  renderer = gtk_cell_renderer_text_new ();
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view),
                                               -1,      
                                               "Name",  
                                               renderer,
                                               "text", COL_NAME,
                                               NULL);
 
  /* --- Column #2 --- */
 
  renderer = gtk_cell_renderer_text_new ();
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view),
                                               -1,      
                                               "Age",  
                                               renderer,
                                               "text", COL_AGE,
                                               NULL);
 
  model = create_and_fill_model ();
 
  gtk_tree_view_set_model (GTK_TREE_VIEW (view), model);
 
  /* The tree view has acquired its own reference to the
   *  model, so we can drop ours. That way the model will
   *  be freed automatically when the tree view is destroyed */
 
  g_object_unref (model);
 
  return view;
}
 
 
int
main (int argc, char **argv)
{
  GtkWidget *window;
  GtkWidget *view;
 
  gtk_init (&argc, &argv);
 
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  g_signal_connect (window, "delete_event", gtk_main_quit, NULL); /* dirty */
 
  view = create_view_and_model ();
 
  gtk_container_add (GTK_CONTAINER (window), view);
 
  gtk_widget_show_all (window);
 
  gtk_main ();
 
  return 0;
}

**********************************************************************************************************************
(code2)

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
 
 
  ...
 
  GtkTreeSelection *selection;
  GtkTreeModel     *model;
  GtkTreeIter       iter;
 
  /* This will only work in single or browse selection mode! */
 
  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
  if (gtk_tree_selection_get_selected(selection, &model, &iter))
  {
    gchar *name;
 
    gtk_tree_model_get (model, &iter, COL_NAME, &name, -1);
 
    g_print ("selected row is: %s\n", name);
 
    g_free(name);
  }
  else
  {
    g_print ("no row selected.\n");
  }
 
  ...

Merci d'avance

[pvincent]

L'exemple suivant:
https://www.samomoi.com/c/GtkTreeview.php
me semble être complet et en français

[fgh39]

merci, je vais voir ça

[turboiii]

Bonjour à tous,

Concernant la sélection de lignes pour jouer avec il faut 2 choses avec Gtk

mettre en place un gestionnaire de signal qui lorsque l'utilisateur aura fait quelque chose sur le treeview il faudra répondre et faire quelque chose.

par exemple rajouter

Code :

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

g_signal_connect(view, "row-activated", (GCallback) view_onRowActivated, NULL);

Ensuite écrire un Callback

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
void  view_onRowActivated (GtkTreeView        *treeview,
				   GtkTreePath        *path,
				   GtkTreeViewColumn  *col,
				   gpointer            userdata)
{
	GtkTreeModel *model;
	GtkTreeIter   iter;
 
	g_print ("A row has been double-clicked!\n");
 
	model = gtk_tree_view_get_model(treeview);
 
	if (gtk_tree_model_get_iter(model, &iter, path))
	{
	   gchar *name;
 
	   gtk_tree_model_get(model, &iter, colonne_nom, &name, -1);
 
	   g_print ("Double-clicked row contains name %s\n", name);
 
	   g_free(name);
	}
}

voici ce qu'on obtiens dans le terminal

Code :

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

1
2
3
4
5
6
A row has been double-clicked!
Double-clicked row contains name Hassane
A row has been double-clicked!
Double-clicked row contains name Abdoulkassim
A row has been double-clicked!
Double-clicked row contains name Dubois

Toute ton appli va devoir être conçu de cette manière. Sans rentrer dans le détail du protocole de Gtk quel que soit le langage utilisé
Théorie des signaux Gtk
La composition de l'interface graphique a de quoi poser quelques questions d'organisation. On ne peut pas connaître d'avance l'ordre des actions de l'utilisateur dans un interface complexe.
Par conséquent, il faut mettre en place un système qui prévoit les événements que l'utilisateur va provoquer avec la souris ou le clavier. Ceci doit être établi à l'avance. Une boucle infinie devra être lancée et tourner en attente d'une action.
par exemple ici

Code :

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

g_signal_connect(view, "row-activated", (GCallback) view_onRowActivated, NULL);

view est le nom du widget qui a été créé au moment de la construction. Il y a de nombreux widgets qui utilisent des signaux pour communiquer avec d'autres domaines de l'application, par exemple un bouton. Chaque widget dispose de ses propres événements qui peuvent être émis. Il est également possible que notre application émette aussi des événements qui seront gérés par une autre partie de l'application, le contrôle est donnée à la partie de programme prévue pour agir à l'événement donné, puis retourne dans la boucle d'attente jusqu'au prochain événement.

ici un Treeview va émettre un signal, nous allons traiter l'événement "row-activated". Cela signifie que lors d'un double clic , le signal est émis. l'argument data sera transmis a un callback view_onRowActivated qui doit prévoir de le traiter. On devra retrouver quelque part une fonction du type*:

Code :

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

1
2
3
4
void  view_onRowActivated (GtkTreeView        *treeview,
				   GtkTreePath        *path,
				   GtkTreeViewColumn  *col,
				   gpointer            userdata)

view_onRowActivated va faire quelque chose puis une fois terminé rend la main à la boucle d'attente principale qui va attendre jusqu'au prochain signal émis. Mais la grosse astuce est évidemment de prévoir quels sont les événements attendus et en quelques sorte de les capturer pour faire quelques choses.

concernant des supports tu as celui qui est en Gtk2 mais qui moyennant un petit effort peut être converti en gtk 3
https://gtk.developpez.com/cours/listes-arbres/

Ensuite tu as aussi
http://scentric.net/tutorial/ c'est du gtk2 mais absolument tout y est. C'est gigantesque .

dont cette partie que j'ai utilisée pour l'exemple http://scentric.net/tutorial/sec-sel...ble-click.html

Toute la difficulté est de savoir commencer par quel bout
le code complet fonctionnel et débuggué cité précédemment https://www.samomoi.com/c/GtkTreeview.phpavec le callback

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
#include <gtk/gtk.h>  
 
//treeview.c
/*  Compile with:
*  gcc -std=c11 -Wall -fmax-errors=10 -Wextra treeview.c -o treeview `pkg-config --cflags --libs gtk+-3.0 `
*/
enum{  
	colonne_nom = 0,  
	colonne_prenom,  
	colonne_pays,  
	n_colonnes  
};  
 
void model_data_new(GtkTreeModel* store,const gchar* nom, const gchar* prenom, const gchar* pays)  
{  
	GtkTreeIter iter;  
	gtk_list_store_append(GTK_LIST_STORE(store), &iter);  
	gtk_list_store_set(GTK_LIST_STORE(store), &iter,  
					   colonne_nom, nom,  
					   colonne_prenom, prenom,  
					   colonne_pays, pays,  
					   -1);  
}  
 
GtkTreeModel* create_model() {  
	GtkListStore  *store;  
	store = gtk_list_store_new (n_colonnes, G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING);  
	return GTK_TREE_MODEL(store);  
}  
 
void arrange_tree_view(GtkWidget* view) 
{  
	GtkCellRenderer* renderer;  
 
	// colonne 1: nom  
	renderer = gtk_cell_renderer_text_new ();  
	gtk_tree_view_insert_column_with_attributes(  
		GTK_TREE_VIEW(view), -1, "nom", renderer, "text", colonne_nom, NULL);  
 
	// colonne 2: prenom  
	gtk_tree_view_insert_column_with_attributes(  
		GTK_TREE_VIEW(view), -1, "prenom", renderer, "text", colonne_prenom, NULL);  
 
	// colonne 3: pays  
	gtk_tree_view_insert_column_with_attributes(  
		GTK_TREE_VIEW(view), -1, "pays", renderer, "text", colonne_pays, NULL);  
}  
 
void  view_onRowActivated (GtkTreeView        *treeview,
				   GtkTreePath        *path,
				   GtkTreeViewColumn  *col,
				   gpointer            userdata)
{
	GtkTreeModel *model;
	GtkTreeIter   iter;
 
	g_print ("A row has been double-clicked!\n");
 
	model = gtk_tree_view_get_model(treeview);
 
	if (gtk_tree_model_get_iter(model, &iter, path))
	{
	   gchar *name;
 
	   gtk_tree_model_get(model, &iter, colonne_nom, &name, -1);
 
	   g_print ("Double-clicked row contains name %s\n", name);
 
	   g_free(name);
	}
}
int main( int argc,  char *argv[] ) {  
	GtkWidget * mafenetre;  
 
	/* Ceci est appelé dans toutes les applications GTK. Les arguments sont analysés 
	À partir de la ligne de commande et sont retournés à l'application. */  
	gtk_init ( &argc, &argv );  
 
	mafenetre=gtk_window_new(GTK_WINDOW_TOPLEVEL);  
	gtk_window_set_title(GTK_WINDOW(mafenetre), "Samomoi");  
	gtk_window_set_position(GTK_WINDOW(mafenetre), GTK_WIN_POS_CENTER);  
	gtk_window_set_default_size(GTK_WINDOW(mafenetre), 400, 100);  
	gtk_window_set_icon_from_file(GTK_WINDOW(mafenetre), "gtk-logo-rgb.gif", NULL);  
 
	g_signal_connect( G_OBJECT( mafenetre ), "destroy", gtk_main_quit, NULL);  
 
 
	GtkWidget* view;  
	view = gtk_tree_view_new();  
	gtk_container_add( GTK_CONTAINER(mafenetre), view);  
 
	// Orgganisation du vue  
	arrange_tree_view(view);  
 
	// fixation de modèle  
	GtkTreeModel* store = create_model();  
	gtk_tree_view_set_model ( GTK_TREE_VIEW(view),  store);  
	model_data_new(store, "Karihila", "Ali", "Comores");  
	model_data_new(store, "Hassane", "Yousouf", "Maroc");  
	model_data_new(store, "Abdoulkassim", "dajaber", "Algerie");  
	model_data_new(store, "Bakayoko", "Justin", "Cote D'ivoire");  
	model_data_new(store, "Dubois", "Josephine", "France");  
	g_object_unref( store );   
 
	g_signal_connect(view, "row-activated", (GCallback) view_onRowActivated, NULL);
 
	gtk_widget_show_all ( mafenetre );  
 
 
	gtk_main ();  
 
	return 0;  
}

[fgh39]

Bonjour, et merci beaucoup turboiii.

Comme les treeview sont un gros morceau, je me suis orienté vers plus simple (voire je ré apprends le c et gtk+).

Je vous tiens au courant.