probleme d'evenements.. avec plusieurs fenetres :(

Bonjour,

Voila je fait une petite appli MVC qui sert a rien pour un exposé...

J'ai un model de treeview, et 2 vue dans 2 fenetres separées...

J'ai aussi une fonction apply_control(myview* v) qui rajoute les callbacks...

Le probleme c'est que peux appliquer cette fonction à ma 1ere vue comme à la 2nde, les callback ne sont enregistré que sur la 2nde vue (la 2nde fenetre) alors que chaque vue a une structure bien separée, aucune chance que les 2 structures pointes vers la même fenetre... :/

Alors je pige pas trop, une idée?

Citation:

Envoyé par djynwk

Alors je pige pas trop, une idée?

Oui... montre ton code comlet et compilable :lol: Si le code est trop gros, montre ce dont tu parles ou bien un code réduit au minimum mais compilable ;)

1 pièce(s) jointe(s)

Voila voila :) bon c'est un peu long mais je pensse que c'est bien commenté; je me suis basé sur les tutos du site ..

main.c:

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
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <gtk/gtk.h>
#include "jtree_model.h"
#include "jtree_vue.h"
#include "jtree_control.h"
 
 
 
int main(int argc, char **argv)
{
    struct jtree_vue myview;
 
   gtk_init(&argc, &argv);
   struct jtree_model *the_mod = makeMod();
 
   struct jtree_vue *the_view0 = makeView0(*the_mod, "vue 1");
 
 
   struct jtree_vue *the_view1 = makeView1(*the_mod, "vue 2");
   apply_control(the_view0); // <- sa c nwk.. :/
   //if (the_view0->pWindow == the_view1->pWindow) printf("t11111111");
   //else printf("t111111115454");
 
 
    gtk_main();
    return EXIT_SUCCESS;
}

jtree_vue.c

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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
#include "jtree_vue.h"
 
jtree_vue* makeView0(jtree_model mod, char* titre){
 
    struct jtree_vue myview = *(jtree_vue*)g_malloc(sizeof(jtree_vue));
 
    /* Creation de la fenetre principale */
    myview.pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_default_size(GTK_WINDOW(myview.pWindow), 320, 600);
    gtk_window_set_title(GTK_WINDOW(myview.pWindow), titre);
    gtk_window_move(GTK_WINDOW(myview.pWindow), 20, 20);
 
    /* Creation de la vue du tree */
    myview.pTreeView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(mod.pTreeStore));
   // myview.pTreeView.set_reorderable();
    /* Creation de la box horiz (main) */
    myview.main_box = gtk_vbox_new (0, 2);
    /* Creation de la 1ere box vert */
    //myview.v_box1 = gtk_vbox_new (1, 2);
    /* Creation de la 2nde box vert */
    //myview.v_box2 = gtk_vbox_new (1, 2);
 
    // ------------------------------- menu
    myview.menuBar = GTK_MENU_BAR (gtk_menu_bar_new ());
    myview.menuFichier = gtk_menu_new ();
    myview.menuItems[0] = gtk_menu_item_new_with_mnemonic ("_Fichier");
    myview.menuItems[1] = gtk_menu_item_new_with_mnemonic ("_Quitter");
    myview.menuItems[2] = gtk_menu_item_new_with_mnemonic ("_About");
    gtk_menu_item_set_submenu (GTK_MENU_ITEM ( myview.menuItems[0]), myview.menuFichier);
    gtk_menu_shell_append (GTK_MENU_SHELL (myview.menuBar),  myview.menuItems[0]);
    gtk_menu_shell_append (GTK_MENU_SHELL (myview.menuFichier),  myview.menuItems[1]);
    gtk_menu_shell_append (GTK_MENU_SHELL (myview.menuBar),  myview.menuItems[2]);
 
    /* Creation de la premiere colonne */
    myview.pCellRenderer = gtk_cell_renderer_pixbuf_new();
    myview.pColumn = gtk_tree_view_column_new_with_attributes("Image",
        myview.pCellRenderer,
        "pixbuf", BMP_COLUMN,
        NULL);
 
    /* Ajout de la colonne à la vue */
    gtk_tree_view_append_column(GTK_TREE_VIEW(myview.pTreeView), myview.pColumn);
 
    /* Creation de la deuxieme colonne */
    myview.pCellRenderer = gtk_cell_renderer_text_new();
    myview.pColumn = gtk_tree_view_column_new_with_attributes("Label",
        myview.pCellRenderer,
        "text", TEXT_COLUMN,
        NULL);
 
    /* Ajout de la colonne à la vue */
    gtk_tree_view_append_column(GTK_TREE_VIEW(myview.pTreeView), myview.pColumn);
 
    /* Ajout de la vue a la fenetre */
    myview.pScrollbar = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(myview.pScrollbar),
        GTK_POLICY_AUTOMATIC,
        GTK_POLICY_AUTOMATIC);
    gtk_container_add(GTK_CONTAINER(myview.pScrollbar), myview.pTreeView);
 
    //gtk_container_add (GTK_CONTAINER ( myview.main_box), myview.v_box1);
    //gtk_container_add (GTK_CONTAINER ( myview.main_box), myview.v_box2);
 
    gtk_box_pack_start (GTK_BOX (myview.main_box), GTK_WIDGET (myview.menuBar), FALSE, FALSE, 0);
    gtk_container_add(GTK_CONTAINER(myview.main_box), myview.pScrollbar);
    gtk_container_add (GTK_CONTAINER (myview.pWindow), myview.main_box);
    gtk_widget_show_all(myview.pWindow);
    struct jtree_vue *m = &myview;
    return m;
}
 
 
jtree_vue* makeView1(jtree_model mod, char* titre){
 
    struct jtree_vue myview = *(jtree_vue*)g_malloc(sizeof(jtree_vue));
 
    /* Creation de la fenetre principale */
    myview.pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_default_size(GTK_WINDOW(myview.pWindow), 320, 600);
    gtk_window_set_title(GTK_WINDOW(myview.pWindow), titre);
    gtk_window_move(GTK_WINDOW(myview.pWindow), 400, 20);
 
    /* Creation de la vue */
    myview.pTreeView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(mod.pTreeStore));
   // myview.pTreeView.set_reorderable();
    /* Creation de la box horiz (main) */
    myview.main_box = gtk_vbox_new (0, 3);
    /* Creation de la 1ere box vert */
    //myview.v_box1 = gtk_vbox_new (1, 2);
    /* Creation de la 2nde box vert */
    //myview.v_box2 = gtk_vbox_new (1, 2);
 
    // ------------------------------- menu
    myview.menuBar = GTK_MENU_BAR (gtk_menu_bar_new ());
    myview.menuFichier = gtk_menu_new ();
    myview.menuItems[0] = gtk_menu_item_new_with_mnemonic ("_Fichier");
    myview.menuItems[1] = gtk_menu_item_new_with_mnemonic ("_Quitter");
    myview.menuItems[2] = gtk_menu_item_new_with_mnemonic ("_About");
    gtk_menu_item_set_submenu (GTK_MENU_ITEM ( myview.menuItems[0]), myview.menuFichier);
    gtk_menu_shell_append (GTK_MENU_SHELL (myview.menuBar),  myview.menuItems[0]);
    gtk_menu_shell_append (GTK_MENU_SHELL (myview.menuFichier),  myview.menuItems[1]);
    gtk_menu_shell_append (GTK_MENU_SHELL (myview.menuBar),  myview.menuItems[2]);
 
 
    GdkColor color;
    GtkWidget *p_widget = NULL;
 
    /* Creation du widget */
 
    color.pixel = 32;
    color.red = 65535;
    color.green = 0;
    color.blue = 0;
    gtk_widget_modify_bg (myview.menuBar, GTK_STATE_NORMAL, &color);
 
    /* Creation de la premiere colonne */
    myview.pCellRenderer = gtk_cell_renderer_pixbuf_new();
    myview.pColumn = gtk_tree_view_column_new_with_attributes("Image",
        myview.pCellRenderer,
        "pixbuf", BMP_COLUMN,
        NULL);
 
    /* Ajout de la colonne à la vue */
    gtk_tree_view_append_column(GTK_TREE_VIEW(myview.pTreeView), myview.pColumn);
 
    /* Creation de la deuxieme colonne */
    myview.pCellRenderer = gtk_cell_renderer_text_new();
    myview.pColumn = gtk_tree_view_column_new_with_attributes("Label",
        myview.pCellRenderer,
        "text", TEXT_COLUMN,
        NULL);
 
    /* Ajout de la colonne à la vue */
    gtk_tree_view_append_column(GTK_TREE_VIEW(myview.pTreeView), myview.pColumn);
 
    /* Ajout de la vue a la fenetre */
    myview.pScrollbar = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(myview.pScrollbar),
        GTK_POLICY_AUTOMATIC,
        GTK_POLICY_AUTOMATIC);
    gtk_container_add(GTK_CONTAINER(myview.pScrollbar), myview.pTreeView);
 
    /* Creation de la barre d'outils */
   myview.pToolbar = gtk_toolbar_new();
 
   /* Creation a partir de stock */
   gtk_toolbar_insert_stock(GTK_TOOLBAR(myview.pToolbar),
      GTK_STOCK_NEW,
      "Ajouter",
      NULL,
      NULL,
      NULL,
      -1);
   /* Insertion d'un espace */
   gtk_toolbar_append_space(GTK_TOOLBAR(myview.pToolbar));
 
   gtk_toolbar_insert_stock(GTK_TOOLBAR(myview.pToolbar),
      GTK_STOCK_NEW,
      "Supprimer",
      NULL,
      NULL,
      NULL,
      -1);
 
   /* Modification de la taille des icones */
   gtk_toolbar_set_icon_size(GTK_TOOLBAR(myview.pToolbar),
      GTK_ICON_SIZE_BUTTON);
   /* Affichage uniquement des icones */
   gtk_toolbar_set_style(GTK_TOOLBAR(myview.pToolbar),
      GTK_TOOLBAR_ICONS);
 
 
    gtk_box_pack_start (GTK_BOX (myview.main_box), GTK_WIDGET (myview.menuBar), FALSE, FALSE, 0);
    gtk_container_add (GTK_CONTAINER (myview.main_box), myview.pToolbar); 
    gtk_container_add (GTK_CONTAINER (myview.main_box), myview.pScrollbar);
    gtk_container_add (GTK_CONTAINER (myview.pWindow), myview.main_box);
 
    /* Permet de definir la taille des widget, ici defini la toolbar */
    gtk_box_set_child_packing  (GTK_CONTAINER (myview.main_box),
                                                         myview.pToolbar,
                                                         0,
                                                         0,
                                                         2,
                                                         GTK_PACK_START);
    gtk_widget_show_all(myview.pWindow);
 
    struct jtree_vue *m = &myview;
    return m;
}

jtree_model.c

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
 
#include "jtree_model.h"
 
 
jtree_model* makeMod(){
 
    struct jtree_model the_model;
    /* Creation du modele */
    the_model.pTreeStore = gtk_tree_store_new(N_COLUMN, GDK_TYPE_PIXBUF, G_TYPE_STRING);
 
 
    gchar * sTexte = (gchar*)g_malloc(16);
    the_model.imgs = (GdkPixbuf**)malloc(sizeof(GdkPixbuf *)*2);
 
 
    gint i;
 
 
    /* Chargement des images */
    the_model.imgs[0] = gdk_pixbuf_scale_simple (gdk_pixbuf_new_from_file ("/_skinz/_pngs/7540-babasse-karine.png", 0),
                                           72,
                                           72,
                                           GDK_INTERP_NEAREST);
    the_model.imgs[1] = gdk_pixbuf_scale_simple (gdk_pixbuf_new_from_file ("/_skinz/_pngs/7547-babasse-Kaioternet.png", 0),
                                           48,
                                           48,
                                           GDK_INTERP_NEAREST);
 
    /* Insertion des elements */
    for(i = 0 ; i < 10 ; ++i)
    {
        GtkTreeIter pIter;
        GtkTreeIter pIter2;
        GtkTreeIter pIter3;
        gint j;
 
        g_sprintf(sTexte, "Ordinateur %d", i);
 
        /* Creation de la nouvelle ligne */
        gtk_tree_store_append(the_model.pTreeStore, &pIter, NULL);
 
        /* Mise a jour des donnees */
        gtk_tree_store_set(the_model.pTreeStore, &pIter,
            BMP_COLUMN, ((i%2)? the_model.imgs[0] : the_model.imgs[1]),
            TEXT_COLUMN, sTexte,
            -1);
        if (i%2)
        for(j = 0 ; j < 2 ; ++j)
        {
            g_sprintf(sTexte, "Repertoire %d", j);
 
            /* Creation de la nouvelle ligne enfant */
            gtk_tree_store_append(the_model.pTreeStore, &pIter2, &pIter);
 
            /* Mise a jour des donnees */
            gtk_tree_store_set(the_model.pTreeStore, &pIter2,
                BMP_COLUMN, ((j%2)? the_model.imgs[0] : the_model.imgs[1]),
                TEXT_COLUMN, sTexte,
                -1);
            gint r;
            if (j%2) for(r = 0 ; r < 2 ; ++r){
                g_sprintf(sTexte, "Fichier %d", r);
 
                /* Creation de la nouvelle ligne enfant */
                gtk_tree_store_append(the_model.pTreeStore, &pIter3, &pIter2);
 
                /* Mise a jour des donnees */
                gtk_tree_store_set(the_model.pTreeStore, &pIter3,
                    BMP_COLUMN, the_model.imgs[1],
                    TEXT_COLUMN, sTexte,
                    -1);
            }
        }
    }
 
    g_free(sTexte);
 
    g_object_unref(the_model.imgs[0]);
    g_object_unref(the_model.imgs[1]);
 
    struct jtree_model *t = &the_model;
    return t;
}
 
void buildExemple(jtree_model* mod){
 
}

jtree_control.c:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include "jtree_control.h"
 
int apply_control(jtree_vue* thevue){
 
    g_signal_connect(G_OBJECT(thevue->pWindow), "destroy", G_CALLBACK(onDestroy), NULL);
    g_signal_connect(G_OBJECT(thevue->menuItems[1]), "activate", G_CALLBACK(onDestroy2), NULL);
    return 0;
}
 
void onDestroy(GtkWidget * widget,gpointer pdata){
 
     gtk_main_quit();
}
 
void onDestroy2(GtkWidget * widget,gpointer pdata){
 
     gtk_main_quit();
}

la aussi g une erreur chelou : dés que je met les 2 callback sa me sort ça :

Code:

1
2
3
4
5
 
(Projet2.exe:2900): GLib-GObject-WARNING **: invalid (NULL) pointer instance
 
(Projet2.exe:2900): GLib-GObject-CRITICAL **: file gsignal.c: line 1634 (g_signal_connect_data): ass
ertion `G_TYPE_CHECK_INSTANCE (instance)' failed

Mercii :)

Pourquoi ne pas transmettre directement le pointeur du modèle ?

Code:

jtree_vue* makeView0(jtree_model * mod, char* titre)

et alors:
Code:

1 2 struct jtree_vue *the_view0 = makeView0(the_mod, "vue 1"); struct jtree_vue *the_view1 = makeView1(the_mod, "vue 2");
Idem pour la fonction makeMod, elle retourne un pointeur alors pourquoi ne pas directement travailler avec un pointeur ? La variable que tu utilise étant locale à la fonction, normalement les données sont détruites une fois la fonction terminée. Donc, créé directement un pointeur, pointeur que tu renvoie par la fonction, il faut bien sûr allouer un espace pour cette adresse:
Code:

1 2 3 4 5 6 7 8 9 jtree_model* makeMod(){ struct jtree_model * the_model; the_model = g_malloc (sizeof (* the_model)); if (the_model != NULL) { /* Ton code ici ! */ }
C'est bien mieux ainsi et moins risqué !

Ici c'est pareil, c'est un peu du n'importe quoi:

Code:

struct jtree_vue myview = *(jtree_vue*)g_malloc(sizeof(jtree_vue));

:cfou: Pourquoi pas directement travailler avec un pointeur ?

Code:

struct jtree_vue * myview = g_malloc (sizeof (* myview));

Il faut je pense revoir un peu quelques notions de C standard !

PS : Je n'ai pas encore lu tout le code...

loooool

enfait c vrai notre c etai un peu rouillé ^^

c'est aprés avoir mal declaré mes structure (on mettai qu'une fois le nom de la structure ^^ ) qu'on a bidouillé dans tous les sens pour utiliser ces struct ^^

aprés cause la flemme les magouille de pointeurs :)

Et la j'ai netooyé comme tu me le consseillai et sa marche les event sont bien referencé :) Merci bcp !!!!

Ps: c'est quant meme bizzard comme resultat ; les magouille de pointeur etai pas jolie mais elle me semblai fonctionnelle ^^

Citation:

Envoyé par djynwk

Ps: c'est quant meme bizzard comme resultat ; les magouille de pointeur etai pas jolie mais elle me semblai fonctionnelle ^^

C'était à première vue qu'une impression alors :aie: Il faut être très vigilant avec les pointeurs et leur utilisation, le C ne se programme pas au hasard donc relis un peu tes cours, ca ne t'en sera que plus bénéfique ;)

Par ailleurs, si tu avais un typedef sur la structure tu n'aurais plus besoin de spécifier le mot clé struct à chaque fois:
Code:

1 2 3 4 5 typedef struct { /* Le contenu de ta structure: */ } jtree_vue;
Ce qui pourrais ensuite donner dans ton code:

Code:

jtree_vue * myview = g_malloc (sizeof (* myview));

au lieu de:

Code:

struct jtree_vue * myview = g_malloc (sizeof (* myview));

;)