"Lisibilité" d'un GtkEntry

Version imprimable

Bonjour,

Pour mon interface graphique, j'ai notamment besoin d'une zone de saisie de texte.

Code:

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
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pEntry;
    GtkWidget *pHBox;
    GtkWidget *pLabel;
    GtkWidget *pBouton;
    GtkWidget *pImage;
 
    gtk_init(&argc,&argv);
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    pHBox = gtk_hbox_new(FALSE, 10);
    gtk_container_add(GTK_CONTAINER(pWindow), GTK_WIDGET(pHBox));
    pLabel[] = gtk_label_new("Page à ouvrir : ");
    /*Zone de saisie d'adresse de page Web*/
    pEntry = gtk_entry_new();
    /*Image correspondant au logiciel utilisé*/
    pImage = gtk_image_new_from_file("./image.png");
    /*Bouton d'action vide*/
    pBouton[0] = gtk_button_new();
    /*Utilisation du bouton vide comme container pour mettre l'icône du logiciel*/
    gtk_container_add(GTK_CONTAINER(pBouton), (GtkWidget*)pImage);
    /*Connexion des signaux potentiels au bouton et à la zone de texte : */
    /*LancePage est branchée sur le signal "clicked" du bouton*/
    g_signal_connect(G_OBJECT(pButton[0]), "clicked", G_CALLBACK(LancePage), (GtkWidget*) pHBox);
    /*LancePage est branchée sur le signal "activate" (touche [Entrée]) de la zone de texte*/
    g_signal_connect (G_OBJECT (pEntry), "activate", G_CALLBACK (LancePage), (GtkWidget*) pHBox);
}

Est-on obligé d'enfermer l'Entry dans une Box avec le bouton pour pouvoir extraire le texte saisi par l'utilisateur ?
Merci de vos réponses.

29/07/2009, 09h40
teuf13

Non, tu peux lire le texte contenu dans une GtkEntry à partir de n'importe quel callback, pas forcément un associé à un appui sur un bouton.

Certes oui, mais quelle est la technique pour extraire les données du GtkEntry, s'il n'est pas dans une Box ?
Tous les exemples que j'ai pu voir encapsulaient l'Entry et le Bouton dans une Box, envoyaient la Box en paramètre :

Code:

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
 
#include <stdlib.h>
#include <gtk/gtk.h>
 
void on_activate_entry(GtkWidget *pEntry, gpointer data);
void on_copier_button(GtkWidget *pButton, gpointer data);
 
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pVBox;
    GtkWidget *pEntry;
    GtkWidget *pButton;
    GtkWidget *pLabel;
 
    gtk_init(&argc, &argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Le widget GtkEntry");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
    pVBox = gtk_vbox_new(TRUE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
 
    /* Creation du GtkEntry */
    pEntry = gtk_entry_new();
    /* Insertion du GtkEntry dans la GtkVBox */
    gtk_box_pack_start(GTK_BOX(pVBox), pEntry, TRUE, FALSE, 0);
 
    pButton = gtk_button_new_with_label("Copier");
    gtk_box_pack_start(GTK_BOX(pVBox), pButton, TRUE, FALSE, 0);
 
    pLabel = gtk_label_new(NULL);
    gtk_box_pack_start(GTK_BOX(pVBox), pLabel, TRUE, FALSE, 0);
 
    /* Connexion du signal "activate" du GtkEntry */
    g_signal_connect(G_OBJECT(pEntry), "activate", G_CALLBACK(on_activate_entry), (GtkWidget*) pLabel);
 
    /* Connexion du signal "clicked" du GtkButton */
    /* La donnee supplementaire est la GtkVBox pVBox */
    g_signal_connect(G_OBJECT(pButton), "clicked", G_CALLBACK(on_copier_button), (GtkWidget*) pVBox);
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}
 
/* Fonction callback execute lors du signal "activate" */
void on_activate_entry(GtkWidget *pEntry, gpointer data)
{
    const gchar *sText;
 
    /* Recuperation du texte contenu dans le GtkEntry */
    sText = gtk_entry_get_text(GTK_ENTRY(pEntry));
 
    /* Modification du texte contenu dans le GtkLabel */
    gtk_label_set_text(GTK_LABEL((GtkWidget*)data), sText);
}
 
/* Fonction callback executee lors du signal "clicked" */
void on_copier_button(GtkWidget *pButton, gpointer data)
{
    GtkWidget *pTempEntry;
    GtkWidget *pTempLabel;
    GList *pList;
    const gchar *sText;
 
    /* Recuperation de la liste des elements que contient la GtkVBox */
    pList = gtk_container_get_children(GTK_CONTAINER((GtkWidget*)data));
 
    /* Le premier element est le GtkEntry */
    pTempEntry = GTK_WIDGET(pList->data);
 
    /* Passage a l element suivant : le GtkButton */
    pList = g_list_next(pList);
 
    /* Passage a l element suivant : le GtkLabel */
    pList = g_list_next(pList);
 
    /* Cet element est le GtkLabel */
    pTempLabel = GTK_WIDGET(pList->data);
 
    /* Recuperation du texte contenu dans le GtkEntry */
    sText = gtk_entry_get_text(GTK_ENTRY(pTempEntry));
 
    /* Modification du texte contenu dans le GtkLabel */
    gtk_label_set_text(GTK_LABEL(pTempLabel), sText);
 
    /* Liberation de la memoire utilisee par la liste */
    g_list_free(pList);
}

(cf. http://gtk.developpez.com/cours/gtk2....de.saisie.php )

29/07/2009, 14h29
teuf13

Tu peux utiliser l'argument gpointer user_data pour passer un pointeur sur ta GtkEntry par exemple.
30/07/2009, 00h22
liberforce

Ok, leur exemple n'est absolument pas représentatif d'une bonne pratique, c'est juste un exemple. En temps normal tu crées une structure qui contiendra chacun des éléments de ton interface, et si tu as besoin d'interragir avec un widget A à partir de la callback d'un évènement sur un widget B, tu passes soit le widget A (si tu ne doit agir qu'avec A et B), soit la structure complète en paramètre du signal. C'est à cela que sert le paramètre gpointer user_data.

Au passage le tutoriel est vraiment moisi.
30/07/2009, 09h51
cypher.sephiroth

Citation:

Envoyé par liberforce

Ok, leur exemple n'est absolument pas représentatif d'une bonne pratique, c'est juste un exemple. En temps normal tu crées une structure qui contiendra chacun des éléments de ton interface, et si tu as besoin d'interragir avec un widget A à partir de la callback d'un évènement sur un widget B, tu passes soit le widget A (si tu ne doit agir qu'avec A et B), soit la structure complète en paramètre du signal. C'est à cela que sert le paramètre gpointer user_data.

D'accord.

Citation:

Au passage le tutoriel est vraiment moisi.

Ne leur jetons pas la pierre, il a le mérite d'exister, et de m'avoir permis d'utiliser le GtkEntry.