Détection d'un clic droit avec GTK

**Warno** · 13/05/2009, 01h09

Bonjour,

Je suis assez novice en programmation avec GTK.
Je voudrais tout simplement faire appel à une fonction lorsque l'utilisateur clique avec le bouton droit de sa souris sur un bouton.

J'ai déjà fait quelques recherches à droite à gauche, et je me suis rendu compte que ce n'était pas possible de faire un callback de façon directe (seul l'évènement "clicked" existe, sans distinction du clic droit ou gauche.)
Toujours pendant ces recherches, j'ai fait la découverte d'une fonction apparemment bien pratique : gtk_get_current_event

Seulement voilà, elle retourne un pointeur sur une variable du type "GdkEvent"

En cherchant dans la documentation de GTK, j'ai trouvé ça (ça décrit la structure du type), mais ça ne m'aide pas vraiment...
Concrètement, où se trouve l'information de clic droit dans cette énorme structure qu'est le type GdkEvent ?
Comment construire un simple if(clicdroit) en C ?

Merci de vos réponses.

**kamouminator** · 13/05/2009, 02h03

c'est une union et pas une structure...maintenant la question est: quel est le type effectivement recu ^^
ne connaissant pas vraiment GTK et en lisant rapidemen le lien que tu a fourni je dirait que c'est button
et que pour connaitre quel bouton est enfoncé il suffi de comparer
button.type à GDK_BUTTON_PRESS, GDK_2BUTTON_PRESS, GDK_3BUTTON_PRESS, GDK_BUTTON_RELEASE

comparaison bit a bit evidemment !

http://www.gtk-server.org/gtk1/gdk/g...GDKEVENTBUTTON

**teuf13** · 13/05/2009, 10h47

L'évènement "clicked" passe un GdkEvent à la fonction de callback, donc tu peux filtrer à ce niveau là les clics gauche/droit/double-clic/...

**Warno** · 13/05/2009, 21h47

Salut à vous deux !

Merci beaucoup d'avoir pris le temps de répondre.

J'ai un peu avancé dans ce que je voulais faire, mais je n'y suis pas parvenu.
En effet, l'évènement "clicked" passe par un GdkEvent, qui est une union (et pas une structure, mea culpa là dessus), qui contient un champ "button" qui lui, est une structure, qui elle même contient un champ "button" de type guid. (pfiou !)
Ensuite, après avoir récupéré ce "button", de type guid, j'ai trouvé dans la documentation des valeurs de retour (merci pour le lien kamouminator) :

Envoyé par documentation

guint button
The button which was pressed or released, numbered from 1 to 5. Normally button 1 is the left mouse button, 2 is the middle button, and 3 is the right button. On 2-button mice, the middle button can often be simulated by pressing both mouse buttons together.

J'ai alors écrit le code suivant pour détecter un clic droit sur mon bouton :

Code GTK :

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
 
#include <stdlib.h>
#include <gtk/gtk.h>
 
void fonctionTest(GtkWidget *widget, gpointer data){
 /* Variables */
    GtkWidget *texte = NULL;
 
    texte = gtk_label_new("Quoi ? Aucun clic de detecte...");
    GdkEvent * unionCompliquee = gtk_get_current_event();
    guint typeClic=(*unionCompliquee).button.button ;
 
    if(typeClic==3){  /* Cas du clic droit */
    texte = gtk_label_new("Vous venez de cliquer sur le bouton droit");
    }
    if( typeClic ==1){  /* Cas du clic gauche */
    texte = gtk_label_new("Vous venez de cliquer sur le bouton gauche");
    }
    GtkWidget * autreFenetre = NULL;
    autreFenetre = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_container_add(GTK_CONTAINER(autreFenetre), texte);
 /* Affichage */
    gtk_widget_show_all(autreFenetre);
}
 
int main(int argc, char **argv)
{
    /* Variables */
    GtkWidget * MainWindow = NULL;
    GtkWidget * btnTest = NULL;
 
    /* Initialisation de GTK+ */
    gtk_init(&argc, &argv);
 
    /* Création de la fenêtre */
    MainWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    char *titre="Une fenetre tres simpliste";
    gtk_window_set_title(GTK_WINDOW(MainWindow), titre);
    gtk_window_set_position(GTK_WINDOW(MainWindow), GTK_WIN_POS_CENTER);
 
    /*Creation d'un bouton */
 btnTest = gtk_button_new_with_label("Tester les clics");
 g_signal_connect(G_OBJECT(btnTest), "clicked", G_CALLBACK(fonctionTest), NULL);
 gtk_container_add(GTK_CONTAINER(MainWindow), btnTest);
    g_signal_connect(G_OBJECT(MainWindow), "delete-event", G_CALLBACK(gtk_main_quit), NULL);
 
    /* Affichage */
    gtk_widget_show_all(MainWindow);
    gtk_main();
 
    /* On quitte.. */
    return EXIT_SUCCESS;
}

Je m'attendait à avoir quelquechose qui fonctionne...et en fait, ça ne fonctionne qu'à moitié :
- Lors d'un clic gauche sur le bouton test, le message "Vous venez de cliquer sur le bouton gauche" s'affiche bien dans la fenêtre
- Lors d'un clic droit, rien ne se passe, aucune fenêtre ne s'ouvre ! Le clic droit ne génère pas de signal "clicked" ? (sinon, ça devrait au moins afficher " Quoi ? Aucun clic de detecte...")

Merci de vos réponses.

**kamouminator** · 14/05/2009, 16h52

guint button
The button which was pressed or released, numbered from 1 to 5. Normally button 1 is the left mouse button, 2 is the middle button, and 3 is the right button. On 2-button mice, the middle button can often be simulated by pressing both mouse buttons together.

ca me parrait un peut bizar...comment detecterai tu si deux boutons sont appuiés ?
désolé de repondre par une question ^^

**Warno** · 14/05/2009, 16h56

Effectivement, autre bonne question....

Si quelqu'un pouvait apporter un élément de réponse à une des questions, ou aux deux ça serait très appréciable !

Merci de votre aide.

**kamouminator** · 14/05/2009, 17h03

tu devrai peut etre verifier d'abord si le type est un GDK_BUTTON_PRESS puis si c'est le cas tester les types de bouton...non ?
ou est tu sur qu'a chaque fois que tu appelera gtk_get_current_event() ca te retournera effectivement un bouton ?
je pense que le fait d'avoir defini le type au debut de toutes les structures possible est fais dans ce sens !

**Warno** · 14/05/2009, 17h16

Salut !

J'ai vérifié que c'était bien du bon type, mais mon problème reste le même : la callback n'est même pas déclenchée par un clic droit (la fonction "fonctionTest" n'est pas appelée, puisqu'aucune fenêtre n'est créee lors d'un clic droit sur mon bouton).
Est-ce que les boutons ne peuvent s'activer qu'avec des clics gauche ? Le signal "clicked" ne s'applique-t-il qu'au clic gauche ?

Bref, je suis un peu perdu là...

**teuf13** · 14/05/2009, 17h36

Ouep, clicked c'est peut être que pour un clic gauche. T'as un button-press-event qui existe aussi

**Warno** · 14/05/2009, 18h49

Merci beaucoup, c'était ça : le signal n'était pas le bon.
Mon programme du dessus marche avec le signal "button-press-event".

Je suis un peu perfectionniste, et j'aimerais ne pas ouvrir une nouvelle fenêtre à chaque clic (gauche ou droit sur mon bouton).
Ceci implique donc de passer en paramètre un pointeur sur un label de la fenêtre principale lors du callback de "fonctionTest".
J'ai écrit pour cela le petit programme ci-dessous :

Code C/GTK+ :

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
 
#include <stdlib.h>
#include <gtk/gtk.h>
 
void fonctionTest(GtkWidget *widget, gpointer data){
 /* Variables */
    GtkWidget * txt ;
    txt=(GtkWidget *) data;
    gtk_label_set_label( GTK_LABEL(txt) ,"Quoi ? Ca n'est ni le clic droit ni le clic gauche...");
    GdkEvent * unionCompliquee = gtk_get_current_event();
    guint typeClic=(*unionCompliquee).button.button ;
 
    if(typeClic==3){  /* Cas du clic droit */
    gtk_label_set_label(GTK_LABEL(txt), "Clic droit");
    }
    if( typeClic ==1){  /* Cas du clic gauche */
    gtk_label_set_label(GTK_LABEL(txt), "Clic gauche");
    }
 
}
 
int main(int argc, char **argv)
{
    /* Variables */
    GtkWidget * pMainWindow = NULL;
    GtkWidget * pbtn = NULL;
 
    /* Initialisation de GTK+ */
    gtk_init(&argc, &argv);
 
    /* Création de la fenêtre */
    pMainWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    char *titre="Une fenetre tres simpliste";
    gtk_window_set_title(GTK_WINDOW(pMainWindow), titre);
    gtk_window_set_position(GTK_WINDOW(pMainWindow), GTK_WIN_POS_CENTER);
 
    /*Creation d'un bouton */
 pbtn = gtk_button_new_with_label("Quel est le clic ?");
 gtk_container_add(GTK_CONTAINER(pMainWindow), pbtn);
 
    /*Initialisation du label*/
 GtkWidget *texte = NULL;
 texte = gtk_label_new("");
    /*Mise en place des callbacks*/
 
 g_signal_connect(G_OBJECT(pbtn), "button-press-event", G_CALLBACK(fonctionTest), (gpointer) texte);
 g_signal_connect(G_OBJECT(pMainWindow), "delete-event", G_CALLBACK(gtk_main_quit), NULL);
 
    /* Affichage */
    gtk_widget_show_all(pMainWindow);
    gtk_main();
 
    /* On quitte.. */
    return EXIT_SUCCESS;
}

Le code passe au compilateur, mais il s'arrête brutalement au moindre clic sur le bouton test...vous avez des idées ?

Merci encore.

**teuf13** · 14/05/2009, 19h59

Oui, le 2ème argument pour ton callback, c'est un GdkEvent (que tu peux utiliser pour voir quel type de clic a eu lieu). Le gpointer user_data ça sera le 3ème argumetn

(de mémoire)

**Warno** · 14/05/2009, 21h25

Salut !

Il me semble que les callbacks ont toujours 4 paramètres non ?

Code tuto :

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

1
2
 
gulong g_signal_connect(gpointer *object, const gchar *name, GCallback func, gpointer func_data );

Quand au prototype de la fonction appelée, c'est bien :

Code tuto :

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

1
2
 
void nom_de_la_fonction(GtkWidget *widget, gpointer data)

Je ne vois pas précisément où est mon erreur : en paramètre, je passe l'adresse d'un label , et je récupère mon label en faisant un cast de mon gpointer.

Tu pourrais m'indiquer où est l'erreur ?
(j'ai essayé de passer &texte plutôt que texte, changer quelques trucs au pif, sans succès)

Merci.

**gerald3d** · 14/05/2009, 21h43

Prototype du CallBack pour le signal "button_press_event":

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
gboolean            user_function                      (GtkWidget      *widget,
                                                        GdkEventButton *event,
                                                        gpointer        user_data)      : Run Last
The ::button-press-event signal will be emitted when a button (typically from a mouse) is pressed.
 
To receive this signal, the GdkWindow associated to the widget needs to enable the GDK_BUTTON_PRESS_MASK mask.
 
This signal will be sent to the grab widget if there is one.
 
widget*:
 
the object which received the signal.
event*:
 
the GdkEventButton which triggered this signal
user_data*:
 
user data set when the signal handler was connected.
Returns*:
 
TRUE to stop other handlers from being invoked for the event. FALSE to propagate the event further.

Prototype du CallBack pour le signal "delete-event":

Code :

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

1
2
3
gboolean            user_function                      (GtkWidget *widget,
                                                        GdkEvent  *event,
                                                        gpointer   user_data)

Il y a des différences selon les signaux. Toujours faire attention à ca lors de la construction.

**teuf13** · 15/05/2009, 01h24

Merci Gerald, tu viens de me faire gagner 5 minutes de sommeil en copiant ces infos à ma place

**Warno** · 15/05/2009, 09h13

Bonjour,

Merci encore pour les réponses fournies : mon petit programme de test MARCHE !

Je vous donne le code de la solution : (pour les suivants)

Code C/GTK+ :

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
 
#include <stdlib.h>
#include <gtk/gtk.h>
 
gboolean fonctionTest(GtkWidget *widget,GdkEvent * unionCompliquee, gpointer data){
 /* Variables */
    GtkWidget * txt ;
    txt=(GtkWidget *) data;
    gtk_label_set_label( GTK_LABEL(txt) ,"Quoi ? Ca n'est ni le clic droit ni le clic gauche..");
    unionCompliquee = gtk_get_current_event();
    guint typeClic=(*unionCompliquee).button.button ;
 
    if(typeClic==3){  /* Cas du clic droit */
    gtk_label_set_label(GTK_LABEL(txt), "Clic droit");
    }
    if( typeClic ==1){  /* Cas du clic gauche */
    gtk_label_set_label(GTK_LABEL(txt), "Clic gauche");
    }
     gtk_widget_show(txt);
    return TRUE;
 
}
 
int main(int argc, char **argv)
{
    /* Variables */
    GtkWidget * pMainWindow = NULL;
    GtkWidget * pbtn = NULL;
    GtkWidget *pVBox;
 
    /* Initialisation de GTK+ */
    gtk_init(&argc, &argv);
 
    /* Création de la fenêtre */
    pMainWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    char *titre="Une fenetre tres simpliste";
    gtk_window_set_title(GTK_WINDOW(pMainWindow), titre);
    gtk_window_set_position(GTK_WINDOW(pMainWindow), GTK_WIN_POS_CENTER);
 
        /* Creation de la GtkBox verticale */
    pVBox = gtk_vbox_new(TRUE, 0);
    /* Ajout de la GtkVBox dans la fenetre */
    gtk_container_add(GTK_CONTAINER(pMainWindow), pVBox);
 
    /*Creation d'un bouton */
 pbtn = gtk_button_new_with_label("Quel est le clic ?");
gtk_box_pack_start(GTK_BOX(pVBox), pbtn, TRUE, FALSE, 0);
 
    /*Initialisation du label*/
 GtkWidget *texte = NULL;
 texte = gtk_label_new("initial");
 gtk_box_pack_start(GTK_BOX(pVBox), texte, TRUE, TRUE, 0);
 gtk_widget_show_all(pMainWindow);
    /*Mise en place des callbacks*/
gtk_widget_set_events(pbtn, GDK_BUTTON_PRESS_MASK);
 g_signal_connect(G_OBJECT(pbtn), "button-press-event", G_CALLBACK(fonctionTest),(gpointer) texte);
 g_signal_connect(G_OBJECT(pMainWindow), "delete-event", G_CALLBACK(gtk_main_quit), NULL);
 
    /* Affichage */
 
    gtk_main();
 
    /* On quitte.. */
    return EXIT_SUCCESS;
}

Merci beaucoup de votre aide !

**teuf13** · 15/05/2009, 10h08

Tu peux supprmier l'appel à gdk_get_current_event vu qu'on te passe l'évènement en argument. Et en fait le type de l'argument est GdkEventButton passé à ta fonction callback, donc tu peux directement faire evt->button.

**Warno** · 15/05/2009, 11h26

Ouaip ! T'as raison, ça marche toujours !

Allez, le code corrigé :

Code C/GTK+ :

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
 
#include <stdlib.h>
#include <gtk/gtk.h>
 
gboolean fonctionTest(GtkWidget *widget,GdkEvent * unionCompliquee, gpointer data){
 /* Variables */
    GtkWidget * txt ;
    txt=(GtkWidget *) data;
    gtk_label_set_label( GTK_LABEL(txt) ,"Quoi ? Ca n'est ni le clic droit ni le clic gauche..");
    guint typeClic=unionCompliquee->button.button ; // récupération du type de clic à partir de l'argument de la fonction
 
    if(typeClic==3){  /* Cas du clic droit */
    gtk_label_set_label(GTK_LABEL(txt), "Clic droit");
    }
    if( typeClic ==1){  /* Cas du clic gauche */
    gtk_label_set_label(GTK_LABEL(txt), "Clic gauche");
    }
     gtk_widget_show(txt);
    return TRUE;
 
}
 
int main(int argc, char **argv)
{
    /* Variables */
    GtkWidget * pMainWindow = NULL;
    GtkWidget * pbtn = NULL;
    GtkWidget *pVBox;
 
    /* Initialisation de GTK+ */
    gtk_init(&argc, &argv);
 
    /* Création de la fenêtre */
    pMainWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    char *titre="Une fenetre tres simpliste";
    gtk_window_set_title(GTK_WINDOW(pMainWindow), titre);
    gtk_window_set_position(GTK_WINDOW(pMainWindow), GTK_WIN_POS_CENTER);
 
        /* Creation de la GtkBox verticale */
    pVBox = gtk_vbox_new(TRUE, 0);
    /* Ajout de la GtkVBox dans la fenetre */
    gtk_container_add(GTK_CONTAINER(pMainWindow), pVBox);
 
    /*Creation d'un bouton */
 pbtn = gtk_button_new_with_label("Quel est le clic ?");
gtk_box_pack_start(GTK_BOX(pVBox), pbtn, TRUE, FALSE, 0);
 
    /*Initialisation du label*/
 GtkWidget *texte = NULL;
 texte = gtk_label_new("");
 gtk_box_pack_start(GTK_BOX(pVBox), texte, TRUE, TRUE, 0);
 gtk_widget_show_all(pMainWindow);
    /*Mise en place des callbacks*/
gtk_widget_set_events(pbtn, GDK_BUTTON_PRESS_MASK);
 g_signal_connect(G_OBJECT(pbtn), "button-press-event", G_CALLBACK(fonctionTest),(gpointer) texte);
 g_signal_connect(G_OBJECT(pMainWindow), "delete-event", G_CALLBACK(gtk_main_quit), NULL);
 
    /* Affichage */
 
    gtk_main();
 
    /* On quitte.. */
    return EXIT_SUCCESS;
}

A+

**teuf13** · 15/05/2009, 12h07

Je ferais même

Code :

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

1
2
3
4
 
gboolean fonctionTest(GtkWidget *widget,GdkEventButton * event, gpointer data){
 
    guint typeClic=event->button ; // récupération du type de clic à partir de l'argument de la fonction

**Warno** · 15/05/2009, 17h02

Envoyé par teuf13

Je ferais même

Code :

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

1
2
3
4
 
gboolean fonctionTest(GtkWidget *widget,GdkEventButton * event, gpointer data){
 
    guint typeClic=event->button ; // récupération du type de clic à partir de l'argument de la fonction

J'ai essayé, et il aime pas trop...en fait event->button est une structure et pas un guint apparemment.

Autre question : à quoi sert le mask (j'ai essayé de l'enlever, et ça marche sans) ?

A+

**teuf13** · 15/05/2009, 17h35

Si 'event' est de type GdkEventButton, event->button est un guint.
De quel mask parles-tu ?

Détection d'un clic droit avec GTK

GTK+ avec C & C++

Discussions similaires

Partager

Partager