Label, cacher lettres

**Captare** · 09/04/2009, 15h46

Re-bonjour,

Excusez moi d'encore vous déranger

, mais j'ai un nouveau problème, et je voudrais aussi avoir vos avis.

Je viens donc de commencer à apprendre le GTK+, c'est ma première lib graphique.
J'essaye donc de coder le jeu du pendu en GTK+. Voici mon code en entier :

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
#include <stdlib.h>
#include <gtk/gtk.h>
 
void search(GtkWidget *entry, gpointer data);
 
gchar text[] = "salut";
 
int main (int argc, char *argv[])
{
    GtkWidget *main_window;
    GtkWidget *main_box;
    GtkWidget *entry;
    /* GtkWidget *label; */
 
    gtk_init(&argc,  &argv);
 
    /* Main Window */
    {
        main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
        gtk_window_set_default_size(GTK_WINDOW(main_window), 400, 600);
        gtk_window_set_title(GTK_WINDOW(main_window), "Pendu");
        g_signal_connect(G_OBJECT(main_window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    }
 
    /* Main Box */
    {
        main_box = gtk_hbox_new(FALSE, 0);
        gtk_container_add(GTK_CONTAINER(main_window), main_box);
    }
 
    /* Entry */
    {
        entry = gtk_entry_new();
        gtk_box_pack_end(GTK_BOX(main_box), entry, FALSE, FALSE, 0);
        gtk_entry_set_max_length(GTK_ENTRY(entry), 1);
        g_signal_connect(G_OBJECT(entry), "activate", G_CALLBACK(search), (GtkWidget*)main_window);
    }
 
 
    gtk_widget_show_all(main_window);
    gtk_main();
 
    return 0;
}
 
void search(GtkWidget *entry, gpointer data)
{
    const gchar *text_enter;
    int i = 0;
    GtkWidget *dialog_ok;
    GtkWidget *dialog_non;
 
    text_enter = gtk_entry_get_text(GTK_ENTRY(entry));
 
    while (i < 5)
    {
        if (text_enter[0] == text[i])
        {
            dialog_ok = gtk_message_dialog_new(GTK_WINDOW(data),
                                               GTK_DIALOG_MODAL,
                                               GTK_MESSAGE_INFO,
                                               GTK_BUTTONS_OK,
                                               "Bien joue !\n Bonne lettre !\n");
 
            gtk_dialog_run(GTK_DIALOG(dialog_ok));
            gtk_widget_destroy(dialog_ok);
        }
       else
        {
            dialog_non = gtk_message_dialog_new(GTK_WINDOW(data),
                                                GTK_DIALOG_MODAL,
                                                GTK_MESSAGE_INFO,
                                                GTK_BUTTONS_OK,
                                                "Desole...\n Ce n'est pas une bonne lettre !\n");
 
            gtk_dialog_run(GTK_DIALOG(dialog_non));
            gtk_widget_destroy(dialog_non);
        }
 
        i++;
    }
}

Mais j'ai un problème, que la lettre soit bonne ou mauvaise, le dialog_non ne cesse de s'afficher

, ça provient surement de la deuxième condition mais je vois pas ce qui cloche. Voyez-vous d'autres problèmes dans mon code ?

J'aimerais avoir une précision sur :

Code :

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

g_signal_connect(G_OBJECT(entry), "activate", G_CALLBACK(search), (GtkWidget*)main_window);

le quatrième paramètre, j'ai bien le droit de faire ce cast, sinon il va bien avoir une erreur ?

**skip78** · 09/04/2009, 16h16

On va commencer par le commencement, tu as d'autres problemes plus profonds

Deja les accolades pour séparer les différentes parties dans le main, c'est trés moyen je pense.

Aprés, un truc plus spécifique à GTK, je vois que tu as voulu déclarer text en global.

Ton raisonnement à normalement été le suivant :
Je veux initialiser text dans une fonction (surement le main), et le tester dans une callback par exemple. Or je passe deja ma fenetre en argument dans la callback, qui n'en prend qu'un, donc je dois créer text en global.

=> L'astuce utilisée en GTK est de créer une structure, contenant la fenêtre elle même, et tous ses éléments, afin d'avoir accès à l'ensemble des ressources lors de chaque appel de fonction.

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
 
// Dans le .h :
typedef struct APP
{
    GtkWindow* window;
    GtkWidget* entry;
    gchar* text;
}APP;
 
 
// Dans le main :
APP *app;
app = (APP*)malloc(sizeof(APP));
 
app->window = gtk_window_new();
app->text = "salut";
app->entry = gtk_entry_new();
 
(...)
 
g_signal_connect(G_OBJECT(app->entry), "activate", G_CALLBACK(search), app);
 
// Dans le callback :
void search(GtkWidget *entry, gpointer data)
{
    APP* app = (APP*)data;
 
    // Tu fait tes opérations en utilisant app de la facon suivante :
    printf("text = %s\n", app->text);
 
    (...)
 
    // Par ailleurs, je préfères ne pas utiliser du tout le premier paramètre de la callback :
    text_enter = gtk_entry_get_text(GTK_ENTRY(app->entry));
 
    (...)
}

Ca parait pas trés important de procéder ainsi pour l'instant, mais trés vite ca devient indispensable, et si tu n'y penses pas avant, ca te promet de belles prises de tête un peu plus tard

Par ailleurs j'ai répondu indirectement à ton interrogation sur le cast de window.

Je poursuivrais en te conseillant d'utiliser for(i=0 ; i<5 ; i++) à la place de ton while, et pour savoir ce qui va pas, de faire des tests basiques tels que l'affichage console de text et de text_entre[0].

**skip78** · 09/04/2009, 16h35

Pour le problème que tu rencontres en tant que tel, il devrait te sauter aux yeux (je viens de tester ton code, si tu met s, il te dis une fois "ok" puis 4 fois "pas ok")

C'est donc qu'il voit bien que c'est bon, mais ta boucle est mal pensée puisqu'il y reste et affiche ensuite que c'est pas bon pour les autres lettres.

Met plutot un booleen genre :

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
 
gboolean lettre_ok = FALSE;
 
for(i=0 ; i<strlen(app->text) ; i++)
{
    if (text_enter[0] == app->text[i]) lettre_ok = TRUE;
}
 
if (lettre_ok)
{
    dialog_ok = gtk_message_dialog_new(GTK_WINDOW(data),
                                       GTK_DIALOG_MODAL,
                                       GTK_MESSAGE_INFO,
                                       GTK_BUTTONS_OK,
                                       "Bien joue !\n Bonne lettre !\n");
 
    gtk_dialog_run(GTK_DIALOG(dialog_ok));
    gtk_widget_destroy(dialog_ok);
}
else
{
    dialog_non = gtk_message_dialog_new(GTK_WINDOW(data),
                                        GTK_DIALOG_MODAL,
                                        GTK_MESSAGE_INFO,
                                        GTK_BUTTONS_OK,
                                        "Desole...\n Ce n'est pas une bonne lettre !\n");
 
    gtk_dialog_run(GTK_DIALOG(dialog_non));
    gtk_widget_destroy(dialog_non);
}

**teuf13** · 09/04/2009, 16h45

Ta boucle ne marchera pas si tu as des caractères accentués

**Captare** · 09/04/2009, 16h55

Merci pour toutes ces précisions

Je vais essayer de tout remettre au propre. Je vous tiens au courant.

skip78 : concernant le cast de window, j'en déduis pas tes explications qu'il est inutile puisque tu le fais dans le code de la fonction. Pourtant j'ai vu beaucoup de code avec des casts dans l'appel de la fonction callback

**skip78** · 09/04/2009, 19h01

En fait te dire que j'avais répondu à ta question était faux

Le cast est trés important si tu te sers directement de la variable passée en argument.

Mais je préfère faire une copie du pointeur, donc pas besoin de cast dans l'appel puisque je le fais durant la copie (app = (APP*)user_data; )

@teuf : LoL

=> en effet, ne pas oublier de gérer l'utf8 => g_utf8_strlen à la place de strlen

**teuf13** · 09/04/2009, 19h24

Envoyé par skip78

@teuf : LoL

=> en effet, ne pas oublier de gérer l'utf8 => g_utf8_strlen à la place de strlen

C'est plus compliqué que ça, dans ce cas app->text[i] est le i ème octet de la chaîne, pas le i ème caractère. Dans la chaîne char * foo = "éàù"; foo[1] est la fin du caractère 'é', le caractère 'à' commence à foo[2].