Discussion :

[vulcain1972]

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 :

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
#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.

[liberforce]

Bonjour,

Code :

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

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 :

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

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

ou

Code :

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

pButton[0]= pLabel;

[vulcain1972]

merci de ta reponse liberforce;quand je fais la modif ,j obtient ceci

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

[gerald3d]

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 :

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

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.

[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;

[gerald3d]

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 :

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

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 :

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

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 :

1. appui 1,
2. appui 2

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

Voila le code complet :

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
#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 :

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

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 :

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

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 !
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 :

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
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 :

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
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.