Drag and Drop entre un icon view et une box

Bonjour,
je tourne en rond, je ne trouve pas beaucoup d'info sur le drag and drop entre objet de différents types.
Voici mon code simplifié :

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
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
 
#include <stdlib.h>
#include <gtk/gtk.h>
#include <gtk/gtkbbox.h>
#include <string.h>
#include "fonction.h"
#include "fonction_dnd.h"
 
 
// fonction dnd
static gboolean cb_drag_drop( GtkWidget      *icon,
              GdkDragContext *context,
              gint            x,
              gint            y,
              guint           time,
              gpointer        data )
{
    GdkAtom target_type;
    g_print( "Detection du drop sur  %s\n", gtk_widget_get_name( icon ) );
 
    target_type = GDK_POINTER_TO_ATOM( context->targets->data );
    gtk_drag_get_data( icon, context, target_type, time );
 
    return( TRUE );
}
int main (int argc, char **argv)
{
 
 //afficher_contenu_dosssier(".");
/// Initialisation de GTK+ */
gtk_init (&argc, &argv);
 
   ///variables
 
 // Box conteneur
      GtkWidget *v_box_0 = gtk_vbox_new (FALSE, 0);
      GtkWidget *h_box_1 = gtk_hbox_new (FALSE, 0);
      GtkWidget *p_window =  gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
 
    // liste des entrées pour le Dnd
     static GtkTargetEntry *target = NULL;
 
    if( ! target )
    {
        target = g_slice_new(GtkTargetEntry);
        target->target = "InternalTarget";
        target->flags  = GTK_TARGET_SAME_APP;
        target->info   = 0;
    }
 
 
/// Image sélectionnée et propriétés
  GtkWidget *v_box_image = gtk_vbox_new (FALSE, 0);
 
      Image_struc_cb* image_st;image_st = g_malloc(sizeof(Image_struc_cb));
      image_st->pBox=gtk_hbox_new (FALSE, 0);
 
 
      gtk_box_pack_start(GTK_BOX(h_box_1), v_box_image, FALSE, FALSE, 0);
      gtk_box_pack_end(GTK_BOX(v_box_0), h_box_1, TRUE, TRUE, 20);
 
 
  ///liste d'images
  GtkWidget *v_box_bibli = gtk_vbox_new (FALSE, 0);
  GtkWidget *scrolled_window=gtk_scrolled_window_new (NULL, NULL);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),GTK_POLICY_NEVER,  GTK_POLICY_AUTOMATIC);
  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),GTK_SHADOW_IN);
  GtkWidget *icon_view=gtk_icon_view_new_with_model (afficher_contenu_dosssier ("./mes_images"));
 
/// ///Configuration du drag and drop
 
GtkWidget *v_box_for_image = gtk_vbox_new (FALSE, 0);
 
 
ajoute_image_dnd(v_box_for_image,"./image1.jpg");
ajoute_image_dnd(v_box_for_image,"./image2.png");
 
 
 
 
/* DnD setup */
    gtk_icon_view_enable_model_drag_source( GTK_ICON_VIEW( icon_view ),
                                            GDK_BUTTON1_MASK, target, 1,
                                            GDK_ACTION_MOVE );
    gtk_icon_view_enable_model_drag_dest( GTK_ICON_VIEW( icon_view ), target, 1,
                                          GDK_ACTION_MOVE );
 
    g_signal_connect( G_OBJECT( icon_view ), "drag-drop",     G_CALLBACK( cb_drag_drop ), NULL );
 
 
 
  gtk_container_add (GTK_CONTAINER (scrolled_window), icon_view);
  gtk_box_pack_start(GTK_BOX(v_box_bibli), scrolled_window, TRUE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(h_box_1), v_box_for_image, TRUE, TRUE, 0);
  gtk_box_pack_end(GTK_BOX(h_box_1), v_box_bibli, TRUE, TRUE, 0);
 
 
  gtk_icon_view_set_text_column (GTK_ICON_VIEW (icon_view), COL_DISPLAY_NAME);
  gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (icon_view), COL_PIXBUF);
  gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (icon_view), GTK_SELECTION_MULTIPLE);
  gtk_icon_view_set_item_width (GTK_ICON_VIEW(icon_view),100);// taille du texte
 
 
                                        // Ajout des box et conteneur
gtk_container_add (GTK_CONTAINER (p_window), v_box_0);
 
 
/// Creation de la fenetre principale de notre application */
g_signal_connect (G_OBJECT (p_window), "destroy", gtk_main_quit, NULL);
gtk_window_set_position (GTK_WINDOW (p_window), GTK_WIN_POS_CENTER);
//gtk_widget_size_allocate(p_window,20);
 
 
            /// Creation du bouton "Quitter" */
            {
            GtkWidget *p_button = NULL;
            p_button = gtk_button_new_from_stock (GTK_STOCK_QUIT);
            g_signal_connect (G_OBJECT (p_button), "clicked", gtk_main_quit, NULL);
            gtk_box_pack_start (GTK_BOX (v_box_0), p_button, FALSE, FALSE, 0);
            }
 
/// Affichage de la fenetre principale
gtk_widget_show_all (p_window);
/// Lancement de la boucle principale
gtk_main ();
return 0;
 
}

Fonction.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
 
 
#include <stdlib.h>
#include <gtk/gtk.h>
#include <gtk/gtkbbox.h>
#include <string.h>
#include <glib/gprintf.h>
#include "fonction.h"
 
 
 
/// Afficher le contenu d'un dossier
GtkTreeModel* afficher_contenu_dosssier(char* chemin){
    GtkListStore *list_store;list_store = gtk_list_store_new (NUM_COLS, G_TYPE_STRING, GDK_TYPE_PIXBUF);
  GdkPixbuf *pix ;
  GtkTreeIter iter;
GDir* monDossier=g_dir_open(chemin, 0, NULL);
G_CONST_RETURN gchar* file= g_dir_read_name(monDossier);
gchar nom_de_extension[]=".tiff";
gchar chemin_pix[40];
static GtkTargetEntry *target = NULL;
 
// Affiche tous les fichiers et dossiers contenus dans monDossier sur la sortie standard
while(file != NULL)
{
 
if (g_str_has_suffix(file, nom_de_extension)){
                sprintf(chemin_pix,"%s/%s",chemin,file);
 
                pix = gdk_pixbuf_new_from_file_at_size (chemin_pix,70,70, NULL);
 
                gtk_list_store_append (list_store, &iter);
                gtk_list_store_set (list_store, &iter, COL_DISPLAY_NAME, file, COL_PIXBUF, pix , -1);
 
//ajoute les élements du icon_view dans le target_entry
 
 
    if( ! target )
    {
        target = g_slice_new(GtkTargetEntry);
        target->target = "InternalTarget";
        target->flags  = GTK_TARGET_SAME_APP;
        target->info   = 0;
    }
 
 
                                        }
 
		file = g_dir_read_name(monDossier);
 
}
 return GTK_TREE_MODEL (list_store);
}

fonction.h

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
 
#include <stdlib.h>
#include <gtk/gtk.h>
#include <gtk/gtkbbox.h>
#include <string.h>
#include <glib/gprintf.h>
 
/* struct de base */
typedef struct
{
   GtkWidget *pBox;
   GtkWidget *wid1;
   GtkWidget *wid2;
   GtkWidget *wid3;
   const char *chemin_image;
 
    GdkPixbuf *wid_PixBuf1;
   GdkPixbuf *wid_PixBuf2;
 
}
Image_struc_cb;
 
 
///\enum enum
enum
{
  COL_DISPLAY_NAME,
  COL_PIXBUF,
  NUM_COLS
};
 
GtkTreeModel* afficher_contenu_dosssier(char* chemin);

Et le plus important :

fonction pour le drag and drop : fonction_dnd.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
 
#include <gtk/gtk.h>
#include <string.h>
#include "fonction_dnd.h"
 
void drag_data_received (GtkWidget        *widget,
                    GdkDragContext   *context,
                    gint              x,
                    gint              y,
                    GtkSelectionData *selection_data,
                    guint             info,
                    guint32           time,
                    gpointer          data)
{
  GdkPixbuf *pixbuf;
 
  if (selection_data->length > 0)
    {
      pixbuf = gtk_selection_data_get_pixbuf (selection_data);
      gtk_image_set_from_pixbuf (GTK_IMAGE (data), pixbuf);
      g_object_unref (pixbuf);
    }
}
GdkPixbuf *get_image_pixbuf (GtkImage *image)
{
  gchar *stock_id;
  GtkIconSize size;
 
  switch (gtk_image_get_storage_type (image))
    {
    case GTK_IMAGE_PIXBUF:
      return g_object_ref (gtk_image_get_pixbuf (image));
    case GTK_IMAGE_STOCK:
      gtk_image_get_stock (image, &stock_id, &size);
      return gtk_widget_render_icon (GTK_WIDGET (image),
                                     stock_id, size, NULL);
    default:
      g_warning ("Image storage type %d not handled",
                 gtk_image_get_storage_type (image));
      return NULL;
    }
}
 
void
drag_begin (GtkWidget      *widget,
            GdkDragContext *context,
            gpointer        data)
{
 
 
  GdkPixbuf *pixbuf;
 
  pixbuf = get_image_pixbuf (GTK_IMAGE (data));
  gtk_drag_set_icon_pixbuf (context, pixbuf, -2, -2);
  g_object_unref (pixbuf);
}
 
 
void
drag_data_get  (GtkWidget        *widget,
                GdkDragContext   *context,
                GtkSelectionData *selection_data,
                guint             info,
                guint             time,
                gpointer          data)
{
  GdkPixbuf *pixbuf;
 
  pixbuf = get_image_pixbuf (GTK_IMAGE (data));
  gtk_selection_data_set_pixbuf (selection_data, pixbuf);
  g_object_unref (pixbuf);
}
 
// déclare une source en tant qu'élement pouvant être cliqué
void make_dragable_source(GtkWidget* ebox, GtkWidget* image)
{
     gtk_drag_source_set (ebox, GDK_BUTTON1_MASK, NULL, 0, GDK_ACTION_COPY);
      gtk_drag_source_add_image_targets (ebox);
      g_signal_connect (ebox, "drag-begin", G_CALLBACK (drag_begin), image);
      g_signal_connect (ebox, "drag-data-get", G_CALLBACK (drag_data_get), image);
}
 
// déclare un élément pouvant recevoir un "cliquer-déposer"
void accept_drop(GtkWidget* ebox, GtkWidget* image)
{
 gtk_drag_dest_set (ebox, GTK_DEST_DEFAULT_ALL,NULL, 0, GDK_ACTION_COPY);
      gtk_drag_dest_add_image_targets (ebox);
      g_signal_connect (ebox, "drag-data-received",
                        G_CALLBACK (drag_data_received), image);
                        }
 
 
 
/// Ajoute une image drag and drop dans une box
void ajoute_image_dnd(GtkWidget* box, gchar* chemin_image)
{
  GdkPixbuf * image_from_box_pixbuf= gdk_pixbuf_new_from_file_at_size(chemin_image,100,100,NULL);
  GtkWidget * image_from_box=gtk_image_new_from_pixbuf(image_from_box_pixbuf);
 GtkWidget *ebox;
  ebox = gtk_event_box_new ();
    /* make ebox a drag source */
        make_dragable_source(ebox, image_from_box);
      /* accept drops on ebox*/
      accept_drop(ebox, image_from_box);
 
gtk_container_add (GTK_CONTAINER (ebox), image_from_box);
  gtk_box_pack_start(GTK_BOX(box), ebox, FALSE, FALSE, 10);
  }

fonction_dnd.h

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
 
#include <gtk/gtk.h>
#include <string.h>
 
void drag_data_received (GtkWidget        *widget,
                    GdkDragContext   *context,
                    gint              x,
                    gint              y,
                    GtkSelectionData *selection_data,
                    guint             info,
                    guint32           time,
                    gpointer          data);
 
void
drag_data_get  (GtkWidget        *widget,
                GdkDragContext   *context,
                GtkSelectionData *selection_data,
                guint             info,
                guint             time,
                gpointer          data);
 
 
void
drag_begin (GtkWidget      *widget,
            GdkDragContext *context,
            gpointer        data);
 
 
GdkPixbuf *get_image_pixbuf (GtkImage *image);
 
void make_dragable_source(GtkWidget *ebox, GtkWidget *image);
 
 
 
void accept_drop(GtkWidget* ebox, GtkWidget* image);
 
void ajoute_image_dnd(GtkWidget* box, gchar* chemin_image);

Il ne me manque qu'une ou deux bonnes instructions je pense. Le but est de détecter le drop de l'icon_view dans la box en affichant par exemple le nom de l'image droppée. Je détecte le drop de l'icon_view dans lui même, mais c'est tout.
Merci pour votre aide.