Discussion :

[Arabesque356]

Bonjour,

j'ai commencé à apprendre à utiliser GTK+ récemment.

Pour le moment, je souhaiterai, lorsque je clique sur un bouton de ma fenêtre principale, pouvoir ouvrir une autre fenêtre tout en fermant automatiquement la première.

J'arrive bien à ouvrir la seconde fenêtre mais je ne parviens pas à fermer la première fenêtre en même temps.

Du coup j'arrive à 3 fenêtres ouvertes en même temps avant que le programme ne se ferme.

Voici mon code (pour la fonction recuperationDuPseudo c'est normal si le champ Entry n'est pas encore mis j'aimerais régler ce premier problème d'abord):
Actuellement le schéma actuel du programme c'est :
Fenêtre principale -> Fenêtre recuperationDuPseudo -> Fenêtre auRevoir

Si vous avez des questions, n'hésitez pas.

Pour le moment ce programme ne sert à rien je vous l'accorde.
C'est surtout un programme d'apprentissage et de concrétisation pour moi.

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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
#include <stdlib.h>
#include <gtk/gtk.h>
#include "prototype.h"
 
 
// Programme principal
int main(int argc, char **argv)
{
    // Initialisation du pointeur de la fenêtre principale
    GtkWidget * Fenetre = NULL;
    GtkWidget * codeBarre = NULL;
    GtkWidget * boutonAccesJeu = NULL;
    GtkWidget * boiteABoutonsVerticale = NULL;
    gchar* demarrer = NULL;
 
    /* Initialisation de GTK+ */
    gtk_init(&argc, &argv);
 
    // Création de la fenêtre
    Fenetre = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 
    // On donne un titre à la fenêtre
    gtk_window_set_title(GTK_WINDOW(Fenetre), "Gestionnaire de commandes Code-Barre");
 
    // On définit la taille par défaut
    gtk_window_set_default_size(GTK_WINDOW(Fenetre), 400, 200);
 
    // On place la fenêtre au moment de son appel
    gtk_window_set_position(GTK_WINDOW(Fenetre), GTK_WIN_POS_CENTER);
 
    // Création de la boîte verticale
    boiteABoutonsVerticale = gtk_vbox_new(TRUE, 0);
    gtk_container_add(GTK_CONTAINER(Fenetre), boiteABoutonsVerticale);
 
    // Formatagre de la chaîne
    demarrer = g_locale_to_utf8("Démarrer la partie", -1, NULL, NULL, NULL);
 
    // Création du bouton d'accès au jeu
    boutonAccesJeu = gtk_button_new_with_label(demarrer);
 
    // Création du texte de bienvenue
    codeBarre = gtk_label_new("<span font_family=\"Arial Black\" size=\"xx-large\" foreground=\"#000000\">Code-Barre</span>\nBienvenue dans ce programme ");
    gtk_label_set_use_markup(GTK_LABEL(codeBarre), TRUE);
    gtk_label_set_justify(GTK_LABEL(codeBarre), GTK_JUSTIFY_CENTER);
 
    // Ajout des boutons à la GTK BOX
    gtk_box_pack_start(GTK_BOX(boiteABoutonsVerticale), codeBarre, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(boiteABoutonsVerticale), boutonAccesJeu, FALSE, FALSE, 0);
 
    // Affichage de la fenêtre
    gtk_widget_show_all(Fenetre);
 
    // En attente d'un évènement
    g_signal_connect(G_OBJECT(Fenetre), "destroy", G_CALLBACK(auRevoir), NULL);
    g_signal_connect(G_OBJECT(boutonAccesJeu), "clicked", G_CALLBACK(recuperationDuPseudo), G_OBJECT(Fenetre));
 
    // Lancement de la boucle infinie
    gtk_main();
    // Libération de la mémoire liée à l'utilisation du texte converti
    g_free(demarrer);
 
    return EXIT_SUCCESS;
}
 
// Récupération du pseudo nécessaire au bon fonctionnement du programme
void recuperationDuPseudo(GtkWidget *Fenetre, gpointer data)
{
    // Initialisation de toutes les variables nécessaires
    GtkWidget * recupPseudo = NULL;
    GtkWidget * box = NULL;
    GtkWidget * explication = NULL;
    // GtkWidget * champ = NULL;
    // GtkWidget * boutonValidation = NULL;
 
    gchar * titreDeLaFenetre = NULL;
    gchar * explicationAConvertir = NULL;
 
    // Conversion des chaînes accentuées.
    titreDeLaFenetre = g_locale_to_utf8("Récupération du pseudo", -1, NULL, NULL, NULL);
    explicationAConvertir = g_locale_to_utf8("Avant de commencer la partie, merci de renseigner votre pseudo.\nAfin que nous puissions mieux vous féliciter (si vous finissez avec succès la partie sinon c'est nada.", -1, NULL, NULL, NULL);
 
    // Création de la fenêtre
    recupPseudo = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(recupPseudo), titreDeLaFenetre);
    gtk_window_set_default_size(GTK_WINDOW(recupPseudo), 500, 150);
    gtk_window_set_position(GTK_WINDOW(recupPseudo), GTK_WIN_POS_CENTER);
 
    // Création de la box et ajout à la fenêtre
    box = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(recupPseudo), box);
    // Création des widgets
    explication = gtk_label_new(explicationAConvertir);
 
    gtk_box_pack_start(GTK_BOX(box), explication, FALSE, FALSE, 0);
 
    // On affiche l'ensemble de la fenêtre
    gtk_widget_show_all(recupPseudo);
 
    g_signal_connect(G_OBJECT(recupPseudo), "delete-event", G_CALLBACK(auRevoir), NULL);
 
 
    g_free(titreDeLaFenetre);
    g_free(explicationAConvertir);
}
 
void auRevoir(GtkWidget *widget, gpointer data)
{
        GtkWidget * FenetreDeux = NULL;
        GtkWidget * Merci = NULL;
        gchar* TexteConverti = NULL;
 
        FenetreDeux = gtk_window_new(GTK_WINDOW_TOPLEVEL);
        gtk_window_set_title(GTK_WINDOW(FenetreDeux), "Au revoir !");
        gtk_window_set_default_size(GTK_WINDOW(FenetreDeux), 400, 100);
        gtk_window_set_position(GTK_WINDOW(FenetreDeux), GTK_WIN_POS_CENTER);
 
        TexteConverti = g_locale_to_utf8("Merci d'avoir utilisé ce programme.\nAussi modeste soit-il.\nCliquez sur la croix de cette fenêtre pour fermer le programme.", -1, NULL, NULL, NULL);
        Merci = gtk_label_new(TexteConverti);
        g_free(TexteConverti);
        gtk_container_add(GTK_CONTAINER(FenetreDeux), Merci);
 
        gtk_widget_show_all(FenetreDeux);
 
        g_signal_connect(G_OBJECT(FenetreDeux), "delete-event", G_CALLBACK(gtk_main_quit), NULL);
 
        g_free(TexteConverti);
}

Merci d'avance pour toutes vos réponses.

[gerald3d]

Dans la fonction void recuperationDuPseudo(GtkWidget *Fenetre, gpointer data)
ajoute un gtk_widget_destroy((GtkWidget*)data);.
Comme tu transmets le pointeur de la fenêtre principale au Callback cette instruction va détruire Fenetre.

[Arabesque356]

Génial merci beaucoup.

Au début comme un idiot j'aurais mis :

gtk_widget_destroy(GTK_CONTAINER(Fenetre));

tout en me demandant pourquoi le compilateur m'aurait indiqué qu'il ne savait pas de quel widget il s'agissait dans la fonction.

En fait il suffit de mettre le prototype j'aurais pas pensé que tout ça pouvait se faire si facilement.

Mais visiblement si donc je vais pas m'en plaindre.

Sinon pensez-vous que le fait de coder "fenêtre par fenêtre" ne soit pas trop lourd ?
Tant qu'à faire si je peux prendre des bonnes habitudes dès le départ...

[gerald3d]

Ceci n'est pas parole d'évangile, mais oui je pense qu'il vaut mieux coder fenêtre par fenêtre.
J'entends par là un fichier source .c, un fichier d'entête .h associé dans lequel on pourra trouver une structure regroupant tous les widgets nécessaires à la construction de l'interface.

Plus tard, lorsque l'API GTK+ sera maitrisé, alors il sera temps de passer à la phase suivante avec l'utilisation de Glade. Mais c'est un autre sujet.

[Arabesque356]

Par contre j'ai constaté qu'il faut absolument le signal destroy pour que la fenêtre se ferme et pas delete-event.

Merci encore pour toute l'aide apportée.

J'espère ne pas trop avoir besoin d'utiliser le forum car ça va faire un peu boulet () mais j'avoue que là je n'avais trouvé nul part explicitement comment faire.