Erreur lors de l'appel à une fonction

Version imprimable

08/12/2010, 23h55
wadja_86

Erreur lors de l'appel à une fonction

salut tout le monde ,
en fait j'ai un petit souci , je veux créer une interface qui contient un bouton et une image d'une lampe éteinte lorsque j'appuie sur ce bouton la lampe s'allume bien sur elle s'allume puisque lorsque j'appuie sur ce bouton une autre image (image d'une lampe allumé) sera superposé sur l'image d'origine

mon problème lorsque j'effectue cette tache j'appele une fonction qui contient gtk_table_attach (....)

une erreur se produit

Citation:

gtk_table_attach :assertion 'child-> parent == NULL 'failed

qu'est ce que je dois faire pour corriger l'erreur ?
09/12/2010, 09h24
gerald3d

Apparemment tu utilises un pointeur invalide comme parent, ou bien tu essaies d'insérer un widget dans un parent qui en contient déjà un.

plus de détailles merci..

bjr merci pour la réponse ,
en fait j'ai essayé de laisser l'espace à ce widget seulement é sa marche pas je vais vous laissez mon code (c'est petit code est ce que vous pouvez me dire c'st quoi le prob s'il vous plait ) et pourquoi lorsque je met deux image superposé tout marche correctement et lorsque je le fait dans un bouton une erreur arrive
merci

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
95
96
97
98
99
100
 
 
#include <stdlib.h>
#include <gtk/gtk.h>
void OnDestroy(GtkWidget *pWidget, gpointer pData);
void affiche (GtkWidget *pWidget, gpointer pData);
 
int main(int argc,char **argv)
{
 /* Declaration du widget */
    GtkWidget *pWindow;
    GtkWidget *pTable;
    GtkWidget *pButton;
    GtkWidget *pFrame;
    GtkWidget *pFrame1;
    GtkWidget *pImage;
    GtkWidget *pImage1;
    GtkWidget *pImage2;
    gtk_init(&argc,&argv);
    /* Creation de la fenetre */
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    /*crÃ©ation de la table*/
    pTable=gtk_table_new(3,2,TRUE);
 
 
    gtk_container_add(GTK_CONTAINER(pWindow), GTK_WIDGET(pTable));
 
 
    /*crÃ©ation de la frame*/
    pFrame = gtk_frame_new("Service");
    pFrame1 = gtk_frame_new("Lampe");
    /*crÃ©taion de l'image*/
    pImage = gtk_image_new_from_file("./index.jpg");
    pImage1 = gtk_image_new_from_file("./light-off.png");
    pImage2 = gtk_image_new_from_file("./light-on.png");
    /*crÃ©ation d'un bouton*/
    pButton= gtk_button_new();
    gtk_button_set_image(GTK_BUTTON(pButton),pImage);
 
 
 
 
void affiche (GtkWidget *pWidget, gpointer pData)
   {
 
    gtk_table_attach(GTK_TABLE(pTable), pImage1,
        0, 1, 0, 3,
        GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL ,
        0, 0);
 
    }
 
       gtk_table_attach(GTK_TABLE(pTable), pImage2,
        0, 1, 0, 3,
        GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL ,
        0, 0);
 
    gtk_table_attach(GTK_TABLE(pTable), pFrame,
        1, 2, 0, 3,
        GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL ,
        0, 0);
 
 
    gtk_table_attach(GTK_TABLE(pTable), pFrame1,
        0, 1, 0, 3,
        GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL ,
        0, 0);
 
    /* Insertion des boutons */
    gtk_table_attach(GTK_TABLE(pTable), pButton,
        1, 2, 2, 3,
        GTK_EXPAND, GTK_EXPAND ,
        0, 0);
    /* Definition de la position */
    gtk_window_set_position(GTK_WINDOW(pWindow), GTK_WIN_POS_CENTER);
    /* Definition de la taille de la fenetre */
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 500, 320);
    /* Titre de la fenetre */
    gtk_window_set_title(GTK_WINDOW(pWindow), "Chapitre Fenetre");
    /* Connexion du signal "destroy" */
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(OnDestroy), NULL);
 
   g_signal_connect(G_OBJECT(pButton), "clicked", G_CALLBACK(affiche),NULL);
 
 
 
 
    /* Affichage de la fenetre */
    gtk_widget_show_all(pWindow);
    /* Demarrage de la boucle evenementielle */
    gtk_main();
 
    return EXIT_SUCCESS;
   }
 
   void OnDestroy(GtkWidget *pWidget, gpointer pData)
   {
    /* Arret de la boucle evenementielle */
    gtk_main_quit();
   }

09/12/2010, 10h39
gerald3d

Commences par créer une structure dans laquelle tu places tous les widgets dont tu as besoin d'accéder en tout du programme.
Ensuite déclares une donnée du type de la structure déclarée que tu initialises avec les différents widgets.
Pour finir transmets à tous tes CallBack cette variable. Comme ca tu pourras modifier ce que tu veux n'importe où.

Ensuite si tu veux changer une image dans un GtkTable il faut commencer par détruire l'image actuelle avant de vouloir en insérer une nouvelle.

J'ai repris ton code pour te montrer comment procéder.

J'ai donc créé une structure englobante. Elle contient tous les widgets de l'interface. Certains pourraient ne pas en faire partie puisqu'ils ne sont pas sollicités hormis lors de la construction.

J'ai ensuite revu ta manière de charger les images. Plutôt que d'utiliser directement des GtkImage je suis passé par les GdkPixbuf. Dans le GtkTable j'ai inséré un seul GtkImage générique qui prendra lors de l'appui sur le bouton soit le pixbuf 1 soit le pixbuf 2.
Cette méthode à l'avantage de ne charger qu'une seule fois les images depuis le disque dur et aussi évite la destruction/construction permanente des widgets.

Voila le code exemple. Bonne lecture...

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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
#include <stdlib.h>
#include <gtk/gtk.h>
 
typedef struct
{
  GtkWidget *pWindow;
  GtkWidget *pTable;
  GtkWidget *pButton;
  GtkWidget *pFrame;
  GtkWidget *pFrame1;
  GtkWidget *pImage;
  GdkPixbuf *Pix1;
  GdkPixbuf *Pix2;
} SGlobalData;
 
void OnDestroy(GtkWidget *pWidget, gpointer pData);
void affiche (GtkButton *pWidget, gpointer pData);
 
int
main(int argc,char **argv)
{
  SGlobalData data;
 
  gtk_init(&argc,&argv);
  /* Creation de la fenetre */
  data.pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  /*crÃ©ation de la table*/
  data.pTable=gtk_table_new(3,2,TRUE);
 
 
  gtk_container_add(GTK_CONTAINER(data.pWindow), GTK_WIDGET(data.pTable));
 
 
  /*création de la frame*/
  data.pFrame = gtk_frame_new("Service");
  data.pFrame1 = gtk_frame_new("Lampe");
  /*création de l'image*/
  data.Pix1 = gdk_pixbuf_new_from_file("./light-off.png", NULL);
  data.Pix2 = gdk_pixbuf_new_from_file("./light-on.png", NULL);
  data.pImage = gtk_image_new_from_pixbuf(data.Pix1);
 
  /*création d'un bouton*/
  data.pButton= gtk_button_new_from_stock(GTK_STOCK_INDEX);
 
  gtk_table_attach(GTK_TABLE(data.pTable), data.pImage,
  0, 1, 0, 3,
  GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL ,
  0, 0);
 
  gtk_table_attach(GTK_TABLE(data.pTable), data.pFrame,
  1, 2, 0, 3,
  GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL ,
  0, 0);
 
 
  gtk_table_attach(GTK_TABLE(data.pTable), data.pFrame1,
  0, 1, 0, 3,
  GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL ,
  0, 0);
 
  /* Insertion des boutons */
  gtk_table_attach(GTK_TABLE(data.pTable), data.pButton,
  1, 2, 2, 3,
  GTK_EXPAND, GTK_EXPAND ,
  0, 0);
  /* Definition de la position */
  gtk_window_set_position(GTK_WINDOW(data.pWindow), GTK_WIN_POS_CENTER);
  /* Definition de la taille de la fenetre */
  gtk_window_set_default_size(GTK_WINDOW(data.pWindow), 500, 320);
  /* Titre de la fenetre */
  gtk_window_set_title(GTK_WINDOW(data.pWindow), "Chapitre Fenetre");
  /* Connexion du signal "destroy" */
  g_signal_connect(G_OBJECT(data.pWindow), "destroy", G_CALLBACK(OnDestroy), &data);
 
  g_signal_connect(G_OBJECT(data.pButton), "clicked", G_CALLBACK(affiche), &data);
 
  /* Affichage de la fenetre */
  gtk_widget_show_all(data.pWindow);
  /* Demarrage de la boucle evenementielle */
  gtk_main();
 
  return EXIT_SUCCESS;
}
 
void
OnDestroy(GtkWidget *pWidget, gpointer pData)
{
  SGlobalData *data = (SGlobalData*) pData;
 
  /* Libération de la mémoire */
  g_object_unref(data->Pix1);
  g_object_unref(data->Pix2);
 
  /* Arret de la boucle evenementielle */
  gtk_main_quit();
}
 
 
void
affiche (GtkButton *pWidget, gpointer pData)
{
  SGlobalData *data = (SGlobalData*) pData;
 
  /* Petit test pour créer une bascule de l'image affichée */
  if ((gpointer)gtk_image_get_pixbuf(GTK_IMAGE(data->pImage))==(gpointer)data->Pix1)
    gtk_image_set_from_pixbuf(GTK_IMAGE(data->pImage), data->Pix2);
  else
    gtk_image_set_from_pixbuf(GTK_IMAGE(data->pImage), data->Pix1);
}

ça marche toujours pas ..

j'ai changer le code comme vous avez dit et sa marche tjr pas une erreur se produit assertion gtk_is_table (table) failed
que doit je faire

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 OnDestroy(GtkWidget *pWidget, gpointer pData);
void affiche (GtkWidget *pWidget, gpointer pData);
 
int main(int argc,char **argv)
{
 
struct outils 
{
 /* Declaration du widget */
    GtkWidget *pWindow;
    GtkWidget *pTable;
    GtkWidget *pButton;
    GtkWidget *pFrame; 
    GtkWidget *pFrame1;
    GtkWidget *pImage;
    GtkWidget *pImage1;
    GtkWidget *pImage2;
};
 
struct outils obj ;
    gtk_init(&argc,&argv);
    /* Creation de la fenetre */
    obj.pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    /*création de la table*/
    obj.pTable=gtk_table_new(3,2,TRUE);
 
 
    gtk_container_add(GTK_CONTAINER(obj.pWindow), GTK_WIDGET(obj.pTable));
 
 
    /*création de la frame*/
    obj.pFrame = gtk_frame_new("Service");
    obj.pFrame1 = gtk_frame_new("Lampe");
    /*crétaion de l'image*/
    obj.pImage = gtk_image_new_from_file("./index.jpg");
    obj.pImage1 = gtk_image_new_from_file("./light-off.png");
    obj.pImage2 = gtk_image_new_from_file("./light-on.png");
    /*création d'un bouton*/
    obj.pButton= gtk_button_new();
    gtk_button_set_image(GTK_BUTTON(obj.pButton),obj.pImage);
 
void affiche (GtkWidget *pWidget, struct outils obj)
 
   {
    gtk_table_attach(GTK_TABLE(obj.pTable),obj.pImage2 ,
        0, 1, 0, 3,
        GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL ,
        0, 0);   
 
   }
 
 
    gtk_table_attach(GTK_TABLE(obj.pTable), obj.pFrame,
        1, 2, 0, 3,
        GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL ,
        0, 0);
 
 
 
    /* Insertion des boutons */
    gtk_table_attach(GTK_TABLE(obj.pTable), obj.pButton,
        1, 2, 2, 3,
        GTK_EXPAND, GTK_EXPAND ,
        0, 0);
    /* Definition de la position */
    gtk_window_set_position(GTK_WINDOW(obj.pWindow), GTK_WIN_POS_CENTER);
    /* Definition de la taille de la fenetre */
    gtk_window_set_default_size(GTK_WINDOW(obj.pWindow), 500, 320);
    /* Titre de la fenetre */
    gtk_window_set_title(GTK_WINDOW(obj.pWindow), "Chapitre Fenetre");
    /* Connexion du signal "destroy" */
    g_signal_connect(G_OBJECT(obj.pWindow), "destroy", G_CALLBACK(OnDestroy), NULL);
 
    g_signal_connect(G_OBJECT(obj.pButton), "clicked", G_CALLBACK(affiche),NULL);
 
 
 
 
    /* Affichage de la fenetre */
    gtk_widget_show_all(obj.pWindow);
    /* Demarrage de la boucle evenementielle */
    gtk_main();
 
    return EXIT_SUCCESS;
   }
 
   void OnDestroy(GtkWidget *pWidget, gpointer pData)
   {
    /* Arret de la boucle evenementielle */
    gtk_main_quit();
   }

09/12/2010, 11h50
liberforce
Tu ne peux pas "superposer" de widget comme cela. Au lieu d'essayer de rajouter un nouveau widget dans ta table, réutilise plutôt le GtkImage que tu as déjà inséré et qui affiche ta lampe éteinte, et modifie l'image qu'il utilise.
1. Tu charges tes deux images sous forme de pixbuf (pixel buffer), avec gtk_pixbuf_new_from_file.
2. Tu crées initialement ton GtkImage à partir de ton GtkPixbuf correspondant à la lampe éteinte.
3. Quand tu appuie sur le bouton, tu utilises gtk_image_set_from_pixbuf pour modifier l'image affichée par le GtkImage.
09/12/2010, 12h00
gerald3d
Citation:
Envoyé par liberforce

Tu ne peux pas "superposer" de widget comme cela. Au lieu d'essayer de rajouter un nouveau widget dans ta table, réutilise plutôt le GtkImage que tu as déjà inséré et qui affiche ta lampe éteinte, et modifie l'image qu'il utilise.

Tu charges tes deux images sous forme de pixbug (pixel buffer), avec gtk_pixbuf_new_from_file.
Tu crées initialement ton GtkImage à partir de ton GtkPixbuf correspondant à la lampe éteinte.
Quand tu appuie sur le bouton, tu utilises gtk_image_set_from_pixbuf pour modifier l'image affichée par le GtkImage.
Je lui est donné cette solution 2 posts au dessus ;). Mais ca fait toujours plaisir de voir que d'autres pensent comme vous :P.
09/12/2010, 12h18
liberforce

Citation:

Envoyé par gerald3d

Je lui est donné cette solution 2 posts au dessus ;). Mais ca fait toujours plaisir de voir que d'autres pensent comme vous :P.

J'ai lu uniquement le début et la fin de la discussion :mouarf: