probleme avec un bouton en gtk

Version imprimable

1 pièce(s) jointe(s)

Bonjour à tous

Voila : pour m amuser, j'ai voulu découvrir le C; puis pour faire un petit programme avec des boutons où il faut cliquer, j'ai décidé de m'essayer aux bibliothèques gtk ; je suis donc débutant et autodidacte dans ces 2 domaines.
J'essaye depuis plusieurs semaines des faire un petit programme qui permettrait de déplacer un texte écrit dans un widget entry pour l'afficher en label sur un bouton gtk ; il existe une technique utilisant des box qui marche, mais comme le programme que je voudrais faire (plus tard) doit avoir beaucoup de boutons, je voulais me servir du gtk table qui permet, selon moi, de mieux placer ses boutons; j'ai donc fait le code d'essai suivant:

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
#include <stdlib.h>
#include <gtk/gtk.h>
void on_activate_entry(GtkWidget *pEntry, gpointer data);
 
 
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pTable;
     GtkWidget *pEntry;
      GtkWidget *pLabel;
      gchar* sUtf8;
 
 
    /* nombtre de boutons */
    GtkWidget *pButton[4];
char test[]="gasp";
    gtk_init(&argc, &argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    /* dimension fenetre */
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 300, 300);
     /* titre fenetre */
    gtk_window_set_title(GTK_WINDOW(pWindow), "marche pas");
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 /* Creation du GtkEntry */
    pEntry = gtk_entry_new();
 
    /* Creation et insertion de la table 4 lignes 6 colonnes */
    pTable=gtk_table_new(4,6,TRUE);
    gtk_container_add(GTK_CONTAINER(pWindow), GTK_WIDGET(pTable));
 
  /* Creation du label avec     g_locale_to_utf8 */
    sUtf8 = g_locale_to_utf8("salut", -1, NULL, NULL, NULL);
    pLabel=gtk_label_new(sUtf8);
g_free(sUtf8);
 
 
 
 
    /* Creation des boutons */
    /* le bouton 0 devrait afficger salut et changer lorsque l on fait entrer */
    pButton[0]= gtk_button_new_with_label( pLabel);/* ici mon plabel doit poser probleme*/
 
    pButton[1]= gtk_button_new_with_label(test);
    pButton[2]= gtk_button_new_with_label("chiffre2");
 
 
 
    /* Insertion des boutons  */
    gtk_table_attach(GTK_TABLE(pTable), pButton[0],
        2, 4, 0, 1,
        GTK_EXPAND | GTK_FILL, GTK_EXPAND,
        0, 0);
    gtk_table_attach_defaults(GTK_TABLE(pTable), pButton[1],
        1, 2, 1, 2);
    gtk_table_attach(GTK_TABLE(pTable), pButton[2],
        4, 5, 1, 2,
        GTK_EXPAND, GTK_EXPAND | GTK_FILL,
        0, 0);
 
 
 
    gtk_table_attach_defaults(GTK_TABLE(pTable), pEntry,
        2, 4, 3, 4);
 
    /* Connexion du signal "activate" du GtkEntry */
    g_signal_connect(G_OBJECT(pEntry), "activate", G_CALLBACK(on_activate_entry), (GtkWidget*) pLabel);
 
    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)
{printf("test reussi\n");
    const gchar *sText;
 
    /* Recuperation du texte contenu dans le GtkEntry */
    sText = gtk_entry_get_text(GTK_ENTRY(pEntry));
    printf("%s\n",sText);
 
    /* Modification du texte contenu dans le GtkLabel */
    gtk_label_set_text(GTK_LABEL((GtkWidget*)data), sText);
}

mais voila, à la ligne du pbutton[0], je n'arrive pas à faire afficher mon plabell, qui ne doit donc pas être du bon type ; j'ai regardé plein de trucs sur internet, mais je ne comprends pas ce qu'il faut faire pour faire que le plabell soit modifiable, et même, qu'il affiche salut dès le début; mon résultat est le suivant ; merci de votre aide.

12/12/2016, 13h22
liberforce

Bonjour,

Code:

pButton[0]= gtk_button_new_with_label( pLabel);/* ici mon plabel doit poser probleme*/

ton pLabel est un GtkWidget. gtk_button_new_with_label attend une chaîne de caractère. donc soit tu fais:

Code:

pButton[0]= gtk_button_new_with_label("salut");

ou

Code:

pButton[0]= pLabel;
13/12/2016, 11h51
vulcain1972

1 pièce(s) jointe(s)

c est mieux

merci de ta reponse liberforce;quand je fais la modif ,j obtient ceci
Pièce jointe 228199
c est mieux , mais j aimerais savoir comment garder le boutton là ou il y a mon pLabel qui s affiche (là où il y a "salut ") car j aimerais pouvoir faire changer l affichage du texte dans le bouton en appuyant sur ce bouton ;actuellement ,soit j ai comme avant un bouton qui affiche n importe quoi , soit j ai donc comme maintenant ,le bon affichage , mais plus de bouton;je voudrais combiner les 2,en gardant la disposition des boutons grace aux tables;peut etre que c est pas clair, mais j espere que vous pourrez me donner la solution;encore merci de votre aide, et encore merci a liberforce

Bonjour.

Tu confonds deux types de widgets : les GtkButton et les GtkLabel.

Puisque tu crées des GtkButton ils affichent en leur sein un label, et non un GtkLabel. Il affichent un texte pour faire simple.
Les GtkButton disposent d'une fonction qui permet de changer ce texte sans aucune autre modification : gtk_button_set_label();
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 void gtk_button_set_label (GtkButton *button, const gchar *label); Sets the text of the label of the button to str . This text is also used to select the stock item if gtk_button_set_use_stock() is used. This will also clear any previously set labels. Parameters button a GtkButton label a string
Pour pouvoir modifier le texe lors de l'appui sur le bouton il te faut connecter le signal qui est émit par le bouton à une fonction qui a un prototype adapté à ce signal. À l'intérieur de celle-ci tu récupère le pointeur du GtkButton. Tu peux alors utiliser la fonction pré-citée pour modifier son texte affiché comme bon te semble.

14/12/2016, 11h52
vulcain1972

salut , c est toujours moi:
bon ,merci pour les reponses , mais je doit bien reconnaitre que je nage complet;j essaye des trucs en fonction des indications que vous me donnez , mais je n y arrive pas; je vais continuer a essayer ,mais si des fois vous aviez la possibilité de me donner le code solution , je ne serais evidement pas contre;par exemple , quand je clique sur entrée dans mon programme , je recupere bien mon texte dans stext, mais a partir de là,je n arrive pas a le faire repasser dans"main" pour faire a ce moment là un gtk_button_set_label() qui serait salvateur; je l ai dit , je suis debutant;merci de votre aide et de l aide deja apportée;

Bonjour.

On va prendre un peu de temps pour essayer d'éclaircir un peu ta lanterne :).

Avant toute chose, parlons un peu de typographie et de présentation en générale.

Pour commencer, lorsque tu postes sur ce forum évites les phrases à rallonge. N'hésites pas à utiliser la touche "Entrer" pour aérer ton texte. Ce sera beaucoup plus digeste pour les lecteurs que nous sommes ;).
Ensuite, lorsque tu places du code source encadres-le avec les balises CODE /CODE chacune encadrée par des [ ]. Il te suffit de copier ton code source, de le sélectionner et ensuite de cliquer sur l'icône # qui figure au dessus de la fenêtre texte que tu utilises.

Ceci étant, revenons au sujet qui te préoccupes.

Remarques préliminaires :

La manière et le style utilisé pour écrire du code source sont propre à chacun. Cependant au fil du temps c'est imposé une forme typographique générale, dont chacun s'accommode comme bon lui semble.

Quelques règles de base :

évites de placer des fonctions après la fonction main();. Ça ne change rien à l'exécution du code mais on n'est pas très habitué à aller chercher du code après la fonction principale,
indentes ton code. Utilises des espaces pour chaque ligne pour aligner les différents blocs entre eux. Ça rend le code un peu plus facile à lire,
lorsque tu déclares une fonction avec son code source (pas son prototype), sépares par une ligne le type retourné de son nom et de ses paramètres.
...

Tu pourras trouver sur le net des sujets qui traitent de ce sujet si cela t'intéresse.

Pour donner un exemple de tout ça voila un bout de ton code non modifié puis modifié:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 /* Fonction callback execute lors du signal "activate" */ void on_activate_entry(GtkWidget *pEntry, gpointer data) {printf("test reussi\n"); const gchar *sText; /* Recuperation du texte contenu dans le GtkEntry */ sText = gtk_entry_get_text(GTK_ENTRY(pEntry)); printf("%s\n",sText); /* Modification du texte contenu dans le GtkLabel */ gtk_label_set_text(GTK_LABEL((GtkWidget*)data), sText); }
La version modifiée :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 /* Fonction callback execute lors du signal "activate" */ void on_activate_entry(GtkWidget *pEntry, gpointer data) { printf("test reussi\n"); const gchar *sText; /* Recuperation du texte contenu dans le GtkEntry */ sText = gtk_entry_get_text(GTK_ENTRY(pEntry)); printf("%s\n",sText); /* Modification du texte contenu dans le GtkLabel */ gtk_label_set_text(GTK_LABEL((GtkWidget*)data), sText); }
Passons maintenant à la question de départ.

Pour y répondre plutôt que de partir de ton code je vais utiliser un code exemple minimaliste.

Je vais créer une fenêtre principale, c'est le minimum tu me diras :), avec un seul bouton à l'intérieur. Ce bouton aura deux labels possibles :

appui 1,
appui 2

À chaque appui sur le bouton le label affiché à l'intérieur basculera de l'un à l'autre.

Voila le code complet :
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 #include <stdlib.h> #include <gtk/gtk.h> void on_button_clicked (GtkButton *button, gpointer user_data) { /* Récupération du label actuellement affiché */ const gchar *label = gtk_button_get_label (button); /* Comparaison de ce label avec le label "appui 2". * Changement du label du bouton selon le résultat obtenu. */ if (g_strcmp0(label, "appui 2")) gtk_button_set_label (button, "appui 2"); else gtk_button_set_label (button, "appui 1"); } gint main(int argc, char **argv) { GtkWidget *window = NULL; GtkWidget *button = NULL; gtk_init(&argc, &argv); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); /* dimension fenetre */ gtk_window_set_default_size(GTK_WINDOW(window), 300, 300); /* titre fenetre */ gtk_window_set_title(GTK_WINDOW(window), "marche bien :)"); /* Affectation de la fonction gtk_main_quit(); au signal "destroy" */ g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL); /* Creation du bouton */ button = gtk_button_new_with_label ("appui 1"); /* Insertion du bouton dans la fenêtre princaple */ gtk_container_add (GTK_CONTAINER(window), button); /* Connexion de la fonction on_button_clicked (); au signal "clicked pour button */ g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(on_button_clicked), NULL); gtk_widget_show_all(window); gtk_main(); return EXIT_SUCCESS; }
Tu remarqueras que je ne cherche pas à revenir dans la fonction principale pour récupérer quoi que ce soit. Tu ne pourras pas y arriver. Le principe de la programmation événementielle et que ton programme tourne dans une boucle infinie qui est initialisée ici par la fonction gtk_main();.

Maintenant corsons un peu l'exercice. Nous allons placer deux boutons dans notre fenêtre principale. À chaque appui sur l'un des boutons, le label de l'autre prendra le nom du bouton appuyé. On approche ici les problématiques que tu rencontres.

Pour réussir ce tour de force je vais déclarer une structure qui contiendra tous les pointeurs dont je vais avoir besoin de propager à mes fonctions callback (fonctions attachées à des signaux). Ainsi je pourrais modifier ces pointeurs comme bon me semble. Autre avantage, je ne serais pas obligé de déclarer des variables en globale (en dehors de toutes les fonctions).

Voici ma structure :
Code:

1 2 3 4 typedef struct { GtkWidget *button1; GtkWidget *button2; } SData;
Dans la fonction main(); je peux supprimer la déclaration du bouton précédent et déclarer une variable locale du type de ma structure :
Code:

1 2 3 4 5 6 gint main(int argc, char **argv) { GtkWidget *window = NULL; SData data; ...
Je vais modifier ma fenêtre principale pour accueillir un GtkHbox dans lequel je place mes deux boutons.

Le plus simple maintenant serait de connecter une fonction callback différente à chaque bouton. Histoire de pousser un peu le bouchon, on n'en aura qu'une ! 8O
Il va nous falloir dans cette fonction être capable de déterminer quel bouton la appelé. la solution est finalement assez simple. Dans la fonction callback on récupère en premier argument le pointeur du bouton appelant. Il nous suffira de comparer ce pointeur avec ceux inscrits dans la variable data que je vais transmettre en donnée utilisateur.

Mais revenons d'abord à notre fonction principale. Voila le nouveau code pour prendre en compte les modifications :
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 gint main(int argc, char **argv) { GtkWidget *window = NULL; SData data; gtk_init(&argc, &argv); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); /* dimension fenetre */ gtk_window_set_default_size(GTK_WINDOW(window), 300, 300); /* titre fenetre */ gtk_window_set_title(GTK_WINDOW(window), "marche bien :)"); /* Affectation de la fonction gtk_main_quit(); au signal "destroy" */ g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL); /* Création d'une boite horizontale et insertion dans la window */ GtkWidget *hbox = gtk_hbox_new (TRUE, 5); gtk_container_add (GTK_CONTAINER(window), hbox); /* Creation des deux boutons */ data.button1 = gtk_button_new_with_label ("appui bouton 1"); data.button2 = gtk_button_new_with_label ("appui bouton 2"); /* Insertion des deux boutons dans la hbox */ gtk_box_pack_start_defaults (GTK_BOX (hbox),data.button1); gtk_box_pack_start_defaults (GTK_BOX (hbox),data.button2); /* Connexion de la fonction on_button_clicked (); au signal "clicked pour les deux buttons */ g_signal_connect(G_OBJECT(data.button1), "clicked", G_CALLBACK(on_button_clicked), &data); g_signal_connect(G_OBJECT(data.button2), "clicked", G_CALLBACK(on_button_clicked), &data); gtk_widget_show_all(window); gtk_main(); return EXIT_SUCCESS; }
Lors de la connexion du signal "clicked" tu remarqueras que je transmets le pointeur de la variable data à la fonction on_button_clicked();.

Il nous ne reste plus qu'à modifier la fonction callback. À son exécution je compare le pointeur reçu avec les pointeurs de deux boutons. Une fois trouvé j'applique les modifications des labels en conséquence.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 void on_button_clicked (GtkButton *button, SData *data) { if (GTK_WIDGET(button)==data->button1) { /* Le bouton actuel reprend son propre nom * et modifie le label de l'autre bouton. */ gtk_button_set_label (button, "appui bouton 1"); gtk_button_set_label (GTK_BUTTON(data->button2), "appui bouton 1"); } else { /* Le bouton actuel reprend son propre nom * et modifie le label de l'autre bouton. */ gtk_button_set_label (button, "appui bouton 2"); gtk_button_set_label (GTK_BUTTON(data->button1), "appui bouton 2"); } }
Tout ceci ne vaut qu'exemple pour la compréhension. Il y a plusieurs notions dont l'utilisation accrue des pointeurs.

Si tu as des interrogations, n’hésites pas à demander.

15/12/2016, 11h02
vulcain1972

Bonjour a tous
Merci a Gerald3d pour ses conseils
J ai effectivement des ameliorations a faire coté presentation
Le bouton "entrée" peut etre utile de ce coté là;)
Bon , je vais travailler tout ce qui est dit ici,car ça fait pas mal de truc a comprendre pour moi
Cepandant,si j ai bien compris ,ce qui n est pas encore garantit,il n est donc pas possible de faire changer un label dans un bouton autrement qu en utilisant gtk_button_set_label ,mais ,du coup ,il faut le faire avec des "textes" pré-determinés
Ainsi ,si ,par exemple , je voulais faire défiler un compte a rebours de 500 a 0 secondes dans un bouton ,en demandant a l utilisateur de cliquer dessus quand il voit la valeur 25 ,par exemple, cela ne serait possible que en programmant avec gtk_button_set_label la totalité des possibilités d affichage des valeurs de 500 a 0? (oups j ai pas fait assez de "enter":D)
sinon ,je vais cogiter tout le reste
Encore merci a tous ,et plus particulierement a Gerald3d et liberforce pour le temps passé a m aider
15/12/2016, 16h56
gerald3d

Il est tout à fait possible de faire ton compte à rebours sans être obligé de pré-programmer les cinq cents textes, comme tu le suggères.

Par contre oui je suis d'accord avec toi. Le seul moyen de changer le label d'un bouton est de passer par la fonction adéquate. Il y aurait bien un autre moyen mais tu perdrais la compatibilité de ton application lors d'un changement de version de la bibliothèque Gtk+. Il te faudrait en plus connaître la popote interne de Gtk+ pour le faire. Il n'y a donc aucun intérêt à essayer.