Discussion :

[lrgtk]

bonsoir

je n'arrive pas a psser plusieur pointeur dans un g_signal_connect

ex> signal :

Code :

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

1
2
 
g_signal_connect(G_OBJECT(Button1), "clicked", G_CALLBACK(Selection_de_fichier),Label1,Label2);

la fonction :

Code :

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

1
2
3
4
5
6
7
8
9
 
void Selection_de_fichier(GtkWidget * Widget, gpointer dataA, gpointer dataB)
{
creation d'une fenetre de selection de fichier et recuperation du chemin du fichier
 
modification du contenu du Label1 avec
gtk_label_set_label(data, chemin);
fonctionne avec 1 pointer mais pas avec 2 pointer
}

merci d'avance pour votre aide

[Franck.H]

Réponse dans la FAQ : Comment passer plusieurs paramètres à une fonction callback ?

[lrgtk]

deja vu!

mes widget sont deja declares ! pas compilation
a quoi sert my_window_new() ? pas trouver info sur google

un notre conseil a me donner ?

[Franck.H]

deja vu!

mes widget sont deja declares ! pas compilation

Bin montre ton code alors sinon on pourra rien pour toi. Au moins le code qui cible le problème si le code est trop gros mais qu'il reste compilable, au pire fait un petit programme factice qui montre le problème !

a quoi sert my_window_new() ? pas trouver info sur google

Ca.. ... bin c'est juste un exemple ! L'auteur illustre simplement l'appel d'une fonction créant une fenêtre par rapport à la classe qu'il a déclaré par le biais d'une structure, c'est factice rien de plus !

[liberforce]

mes widget sont deja declares ! pas compilation

Ce qui signifie ?

[lrgtk]

dans l'exemple : Comment passer plusieurs paramètres à une fonction callback ?
les widget sont declare dans la structure

mes widget sont deja declare et utiliser avant la structure

si vous pouvez donne un exemple sa m'aiderais à comprendre !

[liberforce]

Bon, c'est vrai que l'exemple de la FAQ est assez pourri et contient en plus plein d'erreurs. Ta question revient souvent sur le forum, c'est donc que l'exemple n'est pas clair. Si un modérateur passe par là, il vaudrait mieux le remplacer.

Voilà un programme qui inverse les lettres du titre de la fenêtre quand on clique sur un bouton. Cela montre comment accéder à n'importe quel membre de la structure qui contient tes éléments graphiques (et ou d'autres données d'ailleurs).

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
#include <gtk/gtk.h>
 
/* Structure regroupant tous les éléments de l'interface graphique 
 * GUI (Graphical User Interface) = IHM (Interface Homme Machine)
 * Vos fenêtres quoi :-) */
typedef struct
{
	GtkWidget* main_window;  /* La fenêtre principale */
	GtkWidget* button;       /* Un bouton */
} Gui;
 
/* La fonction de rappel (callback) appelée quand on clique sur le bouton */
static void on_button_clicked (GtkButton *button, gpointer user_data)
{
	/* On commence par récuperer le pointeur vers notre interface graphique.
	 * De cette manière on peut accéder à tout le contenu de la structure. 
	 * Le paramètre user_data correspond au dernier paramètre de 
	 * g_signal_connect */
	Gui* gui = user_data;
	gchar *title;
 
	/* On copie le titre de la fenêtre, on l'inverse et on remplace 
	 * l'ancien titre */
	title = g_strdup (gtk_window_get_title (GTK_WINDOW (gui->main_window)));
	g_strreverse (title);
	gtk_window_set_title (GTK_WINDOW (gui->main_window), title);
	g_free (title);
}
 
/* Fonction qui crée tous les éléments de notre interface graphique */
Gui * gui_new (void)
{
	Gui *gui;
	gui = g_new (Gui, 1);
	gui->main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title (GTK_WINDOW (gui->main_window), "Hello World !");
	gtk_window_set_default_size (GTK_WINDOW (gui->main_window), 320, 240);
	gui->button = gtk_button_new_with_label ("Cliquez moi !");
	gtk_container_add (GTK_CONTAINER (gui->main_window), gui->button);
	return gui;
}
 
int main (int argc, char **argv)
{
	Gui *gui;
 
	gtk_init (&argc, &argv);
 
       	gui = gui_new ();
	g_signal_connect (G_OBJECT (gui->main_window), "delete-event", gtk_main_quit, NULL);
	g_signal_connect (G_OBJECT (gui->button), "clicked", G_CALLBACK (on_button_clicked), gui);
	gtk_widget_show_all (gui->main_window);
	gtk_main ();
 
	return 0;
}

[gege2061]

Bon, c'est vrai que l'exemple de la FAQ est assez pourri et contient en plus plein d'erreurs.

L'exemple n'est pas pourri, simplement incomplet. Il ne me semble pas utile de rajouter 100 lignes de codes pour le rendre fonctionnel alors que ce n'est pas le sujet de la question.

[liberforce]

L'exemple n'est pas pourri, simplement incomplet. Il ne me semble pas utile de rajouter 100 lignes de codes pour le rendre fonctionnel alors que ce n'est pas le sujet de la question.

Excuse moi d'insister, mais l'exemple est pourri. Même complété, il ne compilerait pas. Il contient plusieurs erreurs (déclaration de structures au lieu de pointeurs vers ces structures), et utilise une fonction sans la définir (ce qui fait que les débutants se demandent à juste titre à quoi correspond my_window_new).

Mon but n'était pas de refaire un exemple pour la FAQ, mais d'avoir un exemple compilable pour celui qui a ouvert le topic, c'est pour cela qu'il est plus exhaustif.

[BSans]

Une réponse peut-être un peu tardive, mais ceci ne répondrait-il pas à la question :

Code C :

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
 
void
ma_fonction (GtkButton *button, gpointer *user_data)
{
    GtkWidget *pWid1 = user_data[0];
    GtkWidget *pWid2 = user_data[1];
    /* do something */
}
 
int
main (int argc, char **argv)
{
    gtk_init (&argc, &argv);
 
    GtkWidget *pWidInit1, *pWidInit2;
    GtkWidget *pButton;
 
/* ici on déclare nos variables */
 
    gpointer *data = g_new (gpointer, 2);
    data[0] = pWidInit1;
    data[1] = pWidInit2;
 
    g_signal_connect (G_OBJECT (pButton), "clicked", G_CALLBACK (ma_fonction), data);
 
    gtk_main();
}

[liberforce]

Oui mais ce n'est pas idéal...
Exemple, si tu rajoutes plusieurs champs, tu as plus de chances de te tromper dans les indices, d'oublier d'allouer plus de mémoire pour ton tableau de pointeurs, etc... En plus tu ne peux ajouter que des pointeurs, si tu veux ajouter des valeurs numériques que tu souhaites conserver aussi, tu vas devoir caster dans tous les sens, pour les mettre dans le tableau, et pour les récupérer. Dans tous les cas de figure, une structure t'évite ce genre de soucis et reste la meilleure solution et la plus lisible...

[BSans]

Pour ce qui est de passer des valeurs numériques, il existe les macros GTK kivontbien :

GINT_TO_POINTEUR(val) -> GPOINTER_TO_INT(val)

Après, si tu ajoutes des champs dans ta structure, c'est que probablement tu veux ajouter un/des traitement(s) dans ta callback, donc dans tous les cas, ça implique une "relecture" du code.

Cependant, il est vrai que ça sous-entend de connaître la déclaration du pointeur, etc. et que donc dans certains projets où il y a plusieurs développeurs ça peut être contraignant.

[liberforce]

Je connais ces macros (GLib et pas GTK) mais ça ne change rien au problème : tu dois les utiliser pour écrire les valeurs d'un côté, et pour les lire de l'autre côté, ce qui est tout sauf pratique. Au passage, elles n'existent que pour les int ou unsigned int : il n'y a rien pour les flottants ou les doubles.

De plus :
- si tu veux rajouter une valeur au milieu des autres, tu dois changer tous tes indices d'un côté comme de l'autre.
- quand tu dois lire une valeur, tu dois retrouver dans ton code l'indice auquel tu l'as écrite au risque de te tromper (sans erreur de compilation) de valeur.

Non, vraiment, seul à coder ou pas, je n'utiliserai pas cette solution tant elle nuit à la lisibilité du code.