Provided a nice way to get a small preview of the current graph.

git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@280 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a

19 files changed, 921 insertions, 665 deletions

diff --git a/ChangeLog b/ChangeLog
index 6fece21..733b96a 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,44 @@
+12-11-10  Cyrille Bagard <nocbos@gmail.com>
+
+	* src/gtkext/graph/node.c:
+	Store sizes in the destination graph view when defining children position.
+
+	* src/gtkext/gtkgraphview.c:
+	* src/gtkext/gtkgraphview.h:
+	Draw preview of graph views. Store the size of all children. Remove
+	the old code of previous versions.
+
+	* src/gtkext/gtklinkrenderer.c:
+	* src/gtkext/gtklinkrenderer.h:
+	Allow to draw links without arrow.
+
+	* src/gtkext/gtkviewpanel.c:
+	* src/gtkext/gtkviewpanel.h:
+	* src/gtkext/gtkviewpanel-int.h:
+	Draw preview of view panels.
+
+	* src/gui/editem.c:
+	* src/gui/editem.h:
+	* src/gui/editem-int.h:
+	Notify when a view changes its content.
+
+	* src/gui/panels/glance.c:
+	* src/gui/panels/glance.h:
+	Provide a nice way to get a small preview of the current graph.
+
+	* src/gui/panels/Makefile.am:
+	Add the glance.[ch] files to libguipanels_la_SOURCES.
+
+	* src/gui/panels/panel.c:
+	Load the glance panel.
+
+	* src/gui/panels/symbols.c:
+	Change the location of the panel ("e" -> "eM") for a better rendering.
+
+	* src/panels/glimpse.c:
+	* src/panels/glimpse.h:
+	Moved and renamed entries.
+
 12-11-06  Cyrille Bagard <nocbos@gmail.com>
 
 	* src/arch/dalvik/instruction.c:
diff --git a/src/gtkext/graph/node.c b/src/gtkext/graph/node.c
index f3e6352..e2af8f7 100644
--- a/src/gtkext/graph/node.c
+++ b/src/gtkext/graph/node.c
@@ -252,13 +252,13 @@ void g_graph_node_place(GGraphNode *node, GtkGraphView *view, gint x, gint y)
     x -= requisition.width / 2;
     y -= requisition.height / 2;
 
-    gtk_graph_view_put(view, node->view, x, y);
-
     node->alloc.x = x;
     node->alloc.y = y;
     node->alloc.width = requisition.width;
     node->alloc.height = requisition.height;
 
+    gtk_graph_view_put(view, node->view, &node->alloc);
+
 }
 
 
diff --git a/src/gtkext/gtkgraphview.c b/src/gtkext/gtkgraphview.c
index c0ea347..e1a943b 100644
--- a/src/gtkext/gtkgraphview.c
+++ b/src/gtkext/gtkgraphview.c
@@ -28,6 +28,7 @@
 #include "gtkbufferview.h"
 #include "gtkviewpanel-int.h"
 #include "graph/layout.h"
+#include "../gui/editem.h"
 
 
 
@@ -43,6 +44,7 @@ struct _GtkGraphView
     vmpa_t end;                             /* Fin de la portion affichée  */
 
     GtkViewPanel **childs;                  /* Liste des sous-blocs        */
+    GtkAllocation *allocs;                  /* Emplacements prévisibles    */
     size_t childs_count;                    /* Taille de cette liste       */
 
     GtkLinkRenderer **links;                /* Liste des liens graphiques  */
@@ -83,6 +85,9 @@ static bool gtk_graph_view_get_address_coordinates(const GtkGraphView *, vmpa_t,
 /* Réagit à un défilement quelconque. */
 static void gtk_graph_view_scroll(GtkGraphView *);
 
+/* Place en cache un rendu destiné à l'aperçu graphique rapide. */
+static void gtk_graph_view_cache_glance(GtkGraphView *, cairo_t *);
+
 /* Supprime tout contenu de l'afficheur de code en graphique. */
 static void gtk_graph_view_reset(GtkGraphView *);
 
@@ -142,6 +147,7 @@ static void gtk_graph_view_init(GtkGraphView *view)
     viewpanel->define = (define_address_fc)gtk_graph_view_define_main_address;
     viewpanel->get_coordinates = (get_addr_coordinates_fc)gtk_graph_view_get_address_coordinates;
     viewpanel->scroll = (scroll_fc)gtk_graph_view_scroll;
+    viewpanel->cache_glance = (cache_glance_fc)gtk_graph_view_cache_glance;
 
     //binview = GTK_BIN_VIEW(view);
 
@@ -335,6 +341,9 @@ static void gtk_graph_view_define_main_address(GtkGraphView *view, vmpa_t addr)
                 view->childs = gtk_graph_view_load_nodes(view, GTK_VIEW_PANEL(view)->binary,
                                                          start, end);
 
+                view->allocs = (GtkAllocation *)calloc(view->childs_count,
+                                                       sizeof(GtkAllocation));
+
                 build_graph_view(view, view->childs, view->childs_count);
 
                 break;
@@ -343,6 +352,8 @@ static void gtk_graph_view_define_main_address(GtkGraphView *view, vmpa_t addr)
 
         }
 
+        change_editor_items_current_view_content(GTK_VIEW_PANEL(view));
+
     }
 
 }
@@ -396,9 +407,10 @@ static void gtk_graph_view_scroll(GtkGraphView *view)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : -                                                            *
+*  Paramètres  : view  = composant GTK à manipuler.                           *
+*                cairo = assistant pour la création de rendus.                *
 *                                                                             *
-*  Description : Crée un nouveau composant pour l'affichage en graphique.     *
+*  Description : Place en cache un rendu destiné à l'aperçu graphique rapide. *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -406,17 +418,48 @@ static void gtk_graph_view_scroll(GtkGraphView *view)
 *                                                                             *
 ******************************************************************************/
 
-GtkWidget *gtk_graph_view_new(void)
+static void gtk_graph_view_cache_glance(GtkGraphView *view, cairo_t *cairo)
 {
-    return g_object_new(GTK_TYPE_GRAPH_VIEW, NULL);
+    size_t i;                               /* Boucle de parcours          */
+    GtkAllocation *alloc;                   /* Emplacement d'un bloc       */
 
-}
+    cairo_set_line_width(cairo, 2);
+    cairo_set_source_rgb(cairo, 0, 0, 0);
+
+    for (i = 0; i < view->childs_count; i++)
+    {
+        alloc = &view->allocs[i];
 
+        cairo_rectangle(cairo, alloc->x, alloc->y,
+                        alloc->width, alloc->height);
 
+        cairo_stroke(cairo);
+
+    }
+
+    for (i = 0; i < view->links_count; i++)
+        _gtk_link_renderer_draw(view->links[i], cairo, false);
+
+}
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Crée un nouveau composant pour l'affichage en graphique.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
+GtkWidget *gtk_graph_view_new(void)
+{
+    return g_object_new(GTK_TYPE_GRAPH_VIEW, NULL);
 
+}
 
 
 /******************************************************************************
@@ -435,9 +478,18 @@ GtkWidget *gtk_graph_view_new(void)
 *                                                                             *
 ******************************************************************************/
 
-void gtk_graph_view_put(GtkGraphView *view, GtkWidget *widget, gint x, gint y)
+void gtk_graph_view_put(GtkGraphView *view, GtkWidget *widget, const GtkAllocation *alloc)
 {
-    gtk_fixed_put(view->support, widget, x, y);
+    size_t i;                               /* Boucle de parcours          */
+
+    for (i = 0; i < view->childs_count; i++)
+        if (GTK_WIDGET(view->childs[i]) == widget)
+        {
+            view->allocs[i] = *alloc;
+            break;
+        }
+
+    gtk_fixed_put(view->support, widget, alloc->x, alloc->y);
 
 }
 
@@ -505,6 +557,8 @@ static void gtk_graph_view_reset(GtkGraphView *view)
     {
         free(view->childs);
         view->childs = NULL;
+        free(view->allocs);
+        view->allocs = NULL;
 
         view->childs_count = 0;
 
@@ -513,11 +567,6 @@ static void gtk_graph_view_reset(GtkGraphView *view)
 }
 
 
-
-
-
-
-
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : view   = composant d'affichage GTK à mettre à jour.          *
@@ -627,451 +676,3 @@ static GtkViewPanel **gtk_graph_view_load_nodes(GtkGraphView *view, GLoadedBinar
     return result;
 
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#if 0
-
-#include "gtkbinview-int.h"
-#include "gtkblockview.h"
-#include "../format/format.h"
-#include "../graph/layout.h"
-
-
-#include <malloc.h>
-
-
-
-/* Représentation de code binaire sous forme graphique (instace) */
-struct _GtkGraphView
-{
-    GtkBinView parent;                      /* A laisser en premier        */
-    GtkFixed *support;                      /* Support des vues en bloc    */
-
-    GtkRequisition requisition;             /* Espace requis d'affichage   */
-
-    vmpa_t start;                           /* Début de la portion vue     */
-    vmpa_t end;                             /* Fin de la portion affichée  */
-
-    GtkBinView **childs;                    /* Liste des sous-blocs        */
-    size_t childs_count;                    /* Taille de cette liste       */
-
-    size_t ready;                           /* Construction complète       */
-    GMutex *mutex;                          /* Accès à la variable         */
-    GCond *cond;                            /* Attente de changement       */
-
-    GtkLinkRenderer **links;                /* Liste des liens graphiques  */
-    size_t links_count;                     /* Nombre de ces liens         */
-
-};
-
-/* Représentation de code binaire sous forme graphique (classe) */
-struct _GtkGraphViewClass
-{
-    GtkBinViewClass parent;                 /* A laisser en premier        */
-
-};
-
-
-/* Initialise la classe générique des graphiques de code. */
-static void gtk_graph_view_class_init(GtkGraphViewClass *);
-
-/* Initialise une instance d'afficheur de code en graphique. */
-static void gtk_graph_view_init(GtkGraphView *);
-
-/* Définit les lignes du graphique de représentation. */
-static void gtk_graph_view_set_rendering_lines(GtkGraphView *, GRenderingLine *, GRenderingLine *);
-
-/* Réagit à la sélection externe d'une adresse. */
-static void gtk_graph_view_define_main_address(GtkGraphView *, vmpa_t);
-
-/* Indique la position d'affichage d'une adresse donnée. */
-static bool gtk_graph_view_get_address_coordinates(const GtkGraphView *, vmpa_t, gint *, gint *);
-
-/* Définit la liste complète des éléments du futur graphique. */
-static GtkBinView **gtk_graph_view_load_nodes(GtkGraphView *, GLoadedBinary *, GRenderingLine *, GRenderingLine *);
-
-/* Prend note de la fin d'une construction d'une visualisation. */
-static void notify_graph_view(GtkBinView *, GtkGraphView *);
-
-
-/* Détermine le type du composant d'affichage en graphique. */
-G_DEFINE_TYPE(GtkGraphView, gtk_graph_view, GTK_TYPE_BIN_VIEW)
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : klass = classe GTK à initialiser.                            *
-*                                                                             *
-*  Description : Initialise la classe générique des graphiques de code.       *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void gtk_graph_view_class_init(GtkGraphViewClass *klass)
-{
-    GtkWidgetClass *widget_class;           /* Classe version Widget       */
-
-    widget_class = (GtkWidgetClass *)klass;
-
-    widget_class->size_request = gtk_graph_view_size_request;
-    widget_class->size_allocate = gtk_graph_view_size_allocate;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : view = instance GTK à initialiser.                           *
-*                                                                             *
-*  Description : Initialise une instance d'afficheur de code en graphique.    *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void gtk_graph_view_init(GtkGraphView *view)
-{
-    GtkViewPanel *viewpanel;                /* Instance parente #1         */
-    GtkBinView *binview;                    /* Instance parente #2         */
-    GdkColor white;                         /* Couleur de fond normale     */
-
-    viewpanel = GTK_VIEW_PANEL(view);
-
-    viewpanel->scroll = (scroll_fc)gtk_graph_view_scroll;
-
-    binview = GTK_BIN_VIEW(view);
-
-    binview->set_lines = (set_rendering_lines_fc)gtk_graph_view_set_rendering_lines;
-    binview->define_address = (define_main_address_fc)gtk_graph_view_define_main_address;
-    binview->get_coordinates = (get_addr_coordinates_fc)gtk_graph_view_get_address_coordinates;
-
-    view->support = GTK_FIXED(gtk_fixed_new());
-    gtk_fixed_set_has_window(view->support, TRUE);
-
-    g_signal_connect(G_OBJECT(view->support), "expose-event",
-                     G_CALLBACK(gtk_graph_view_expose), view);
-
-    gtk_widget_show(GTK_WIDGET(view->support));
-
-    gdk_color_white(gtk_widget_get_colormap(GTK_WIDGET(view->support)), &white);
-    gtk_widget_modify_bg(GTK_WIDGET(view->support), GTK_STATE_NORMAL, &white);
-
-    gtk_fixed_put(GTK_FIXED(view), GTK_WIDGET(view->support), 0, 0);
-
-    view->mutex = g_mutex_new();
-    view->cond = g_cond_new();
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : view  = composant GTK à mettre à jour.                       *
-*                lines = informations à intégrer.                             *
-*                last  = dernière ligne à intégrer ou NULL pour toutes.       *
-*                                                                             *
-*  Description : Définit les lignes du graphique de représentation.           *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void gtk_graph_view_set_rendering_lines(GtkGraphView *view, GRenderingLine *lines, GRenderingLine *last)
-{
-    gtk_graph_view_reset(view);
-
-    g_signal_emit_by_name(view, "lines-set");
-
-}
-
-
-
-
-
-
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : view = composant GTK à mettre à jour.                        *
-*                addr = adresse sélectionnée de manière externe.              *
-*                                                                             *
-*  Description : Réagit à la sélection externe d'une adresse.                 *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void gtk_graph_view_define_main_address(GtkGraphView *view, vmpa_t addr)
-{
-    GExeFormat *format;                     /* Type de fichier chargé      */
-    GBinRoutine **routines;                 /* Liste des routines trouvées */
-    size_t routines_count;                  /* Nombre de ces routines      */
-    size_t i;                               /* Boucle de parcours          */
-    vmpa_t start;                           /* Début d'une routine         */
-    vmpa_t end;                             /* Fin d'une routine           */
-    GRenderingLine *first;                  /* Première ligne à traiter    */
-    GRenderingLine *last;                   /* Dernière ligne à traiter    */
-
-    if (!(view->start <= addr && addr < view->end))
-    {
-        gtk_graph_view_reset(view);
-
-        format = g_loaded_binary_get_format(GTK_BIN_VIEW(view)->binary);
-        routines = g_binary_format_get_routines(G_BIN_FORMAT(format), &routines_count);
-
-        for (i = 0; i < routines_count; i++)
-        {
-            start = g_binary_routine_get_address(routines[i]);
-            end = start + g_binary_routine_get_size(routines[i]);
-
-            if (start <= addr && addr < end)
-            {
-                view->start = start;
-                view->end = end;
-
-                first = g_rendering_line_find_by_address(GTK_BIN_VIEW(view)->lines, GTK_BIN_VIEW(view)->last, start);
-                last = g_rendering_line_find_by_address(GTK_BIN_VIEW(view)->lines, GTK_BIN_VIEW(view)->last, end - 1);
-
-                view->childs = gtk_graph_view_load_nodes(view, GTK_BIN_VIEW(view)->binary, first, last);
-
-                build_graph_view(view, view->childs, view->childs_count);
-
-                break;
-
-            }
-
-        }
-
-    }
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : view = composant GTK à consulter.                            *
-*                addr = adresse à présenter à l'écran.                        *
-*                x    = position horizontale au sein du composant. [OUT]      *
-*                y    = position verticale au sein du composant. [OUT]        *
-*                                                                             *
-*  Description : Indique la position d'affichage d'une adresse donnée.        *
-*                                                                             *
-*  Retour      : TRUE si l'adresse fait partie du composant, FALSE sinon.     *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool gtk_graph_view_get_address_coordinates(const GtkGraphView *view, vmpa_t addr, gint *x, gint *y)
-{
-    bool result;                            /* Bilan à retourner           */
-    size_t i;                               /* Boucle de parcours          */
-
-    result = false;
-
-    *x = 0;
-    *y = 0;
-
-    for (i = 0; i < view->childs_count && !result; i++)
-        if (view->childs[i]->get_coordinates(view->childs[i], addr, x, y))
-        {
-            *x += GTK_WIDGET(view->childs[i])->allocation.x;
-            *y += GTK_WIDGET(view->childs[i])->allocation.y;
-            result = true;
-        }
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : view   = composant d'affichage GTK à mettre à jour.          *
-*                binary = contenu binaire à l'origine des lignes.             *
-*                first  = première ligne à analyser.                          *
-*                last   = dernière ligne à analyser.                          *
-*                                                                             *
-*  Description : Définit la liste complète des éléments du futur graphique.   *
-*                                                                             *
-*  Retour      : Liste d'éléments du graphique à placer.                      *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static GtkBinView **gtk_graph_view_load_nodes(GtkGraphView *view, GLoadedBinary *binary, GRenderingLine *first, GRenderingLine *last)
-{
-#if 0
-    GtkBinView **result;                    /* Liste à retourner           */
-    size_t *count;                          /* Nombre d'éléments créés.    */
-    GRenderingLine *begin;                  /* Début d'un groupe de lignes */
-    GRenderingLine *end;                    /* Fin d'un groupe de lignes   */
-    GRenderingLine *iter;                   /* Boucle de parcours          */
-
-    result = NULL;
-
-    view->ready = 0;
-
-    count = &view->childs_count;
-    *count = 0;
-
-    /**
-     * Comme la fonction est appelée depuis un événement et utilise des threads et GTK,
-     * on doit lever temporairement le verrou GDK.
-     */
-    gdk_flush ();
-    gdk_threads_leave();
-
-    begin = NULL;
-
-    for (iter = first; iter != NULL; iter = g_rendering_line_get_next_iter(first, iter, last))
-    {
-        if (begin != NULL && g_rendering_line_has_sources(iter))
-        {
-            result = (GtkBinView **)realloc(result, ++(*count) * sizeof(GtkBinView *));
-
-            result[*count - 1] = GTK_BIN_VIEW(gtk_block_view_new(MRD_GRAPH));
-
-            g_signal_connect(result[*count - 1], "lines-set", G_CALLBACK(notify_graph_view), view);
-
-            gtk_bin_view_show_border(result[*count - 1], true);
-            gtk_bin_view_set_rendering_lines(result[*count - 1], binary, begin, end);
-
-            begin = NULL;
-
-        }
-
-        if (begin == NULL) begin = iter;
-        end = iter;
-
-        if (g_rendering_line_has_destinations(iter))
-        {
-            result = (GtkBinView **)realloc(result, ++(*count) * sizeof(GtkBinView *));
-
-            result[*count - 1] = GTK_BIN_VIEW(gtk_block_view_new(MRD_GRAPH));
-
-            g_signal_connect(result[*count - 1], "lines-set", G_CALLBACK(notify_graph_view), view);
-
-            gtk_bin_view_show_border(result[*count - 1], true);
-            gtk_bin_view_set_rendering_lines(result[*count - 1], binary, begin, end);
-
-            begin = NULL;
-
-        }
-
-    }
-
-    if (begin != NULL)
-    {
-        result = (GtkBinView **)realloc(result, ++(*count) * sizeof(GtkBinView *));
-
-        result[*count - 1] = GTK_BIN_VIEW(gtk_block_view_new(MRD_GRAPH));
-
-        g_signal_connect(result[*count - 1], "lines-set", G_CALLBACK(notify_graph_view), view);
-
-        gtk_bin_view_show_border(result[*count - 1], true);
-        gtk_bin_view_set_rendering_lines(result[*count - 1], binary, begin, end);
-
-    }
-
-    /* Attente de la fin de construction */
-    g_mutex_lock(view->mutex);
-    while (view->ready < *count)
-        g_cond_wait(view->cond, view->mutex);
-    g_mutex_unlock(view->mutex);
-
-    gdk_threads_enter();
-
-    return result;
-#endif
-    return NULL;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : view   = composant d'affichage prêt à utilisation.           *
-*                parent = composant d'affichage supérieur.                    *
-*                                                                             *
-*  Description : Prend note de la fin d'une construction d'une visualisation. *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void notify_graph_view(GtkBinView *view, GtkGraphView *parent)
-{
-    g_mutex_lock(parent->mutex);
-
-    parent->ready++;
-
-    g_cond_signal(parent->cond);
-    g_mutex_unlock(parent->mutex);
-
-    g_signal_handlers_disconnect_by_func(view, G_CALLBACK(notify_graph_view), parent);
-
-    gtk_widget_show(GTK_WIDGET(view));
-
-}
-
-
-
-#endif
diff --git a/src/gtkext/gtkgraphview.h b/src/gtkext/gtkgraphview.h
index 9e66fe8..ca164e8 100644
--- a/src/gtkext/gtkgraphview.h
+++ b/src/gtkext/gtkgraphview.h
@@ -54,7 +54,7 @@ GType gtk_graph_view_get_type(void);
 GtkWidget *gtk_graph_view_new(void);
 
 /* Place une vue sous forme de bloc dans le graphique. */
-void gtk_graph_view_put(GtkGraphView *, GtkWidget *, gint, gint);
+void gtk_graph_view_put(GtkGraphView *, GtkWidget *, const GtkAllocation *);
 
 /* Définit les liens graphiques à présenter avec la vue. */
 void gtk_graph_view_attach_links(GtkGraphView *, GtkLinkRenderer **, size_t);
diff --git a/src/gtkext/gtklinkrenderer.c b/src/gtkext/gtklinkrenderer.c
index 2913c19..43eda38 100644
--- a/src/gtkext/gtklinkrenderer.c
+++ b/src/gtkext/gtklinkrenderer.c
@@ -149,10 +149,34 @@ GtkObject *gtk_link_renderer_new(LinkColor color, GdkPoint *points, size_t count
 void gtk_link_renderer_draw(const GtkLinkRenderer *renderer, GdkDrawable *drawable, GdkGC *gc)
 {
     cairo_t *cairo;                         /* Gestionnaire de rendu       */
-    size_t i;                               /* Boucle de parcours          */
 
     cairo = gdk_cairo_create(drawable);
 
+    _gtk_link_renderer_draw(renderer, cairo, true);
+
+    cairo_destroy(cairo);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : renderer = moteur de rendu à manipuler.                      *
+*                cairo    = assistant pour le rendu graphique.                *
+*                arrow    = indique le besoin en flèche à l'arrivée.          *
+*                                                                             *
+*  Description : Dessine les liens graphiques enregistrés dans le moteur.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void _gtk_link_renderer_draw(const GtkLinkRenderer *renderer, cairo_t *cairo, bool arrow)
+{
+    size_t i;                               /* Boucle de parcours          */
+
     switch (renderer->color)
     {
         default:
@@ -167,7 +191,11 @@ void gtk_link_renderer_draw(const GtkLinkRenderer *renderer, GdkDrawable *drawab
             break;
     }
 
-    cairo_set_line_width(cairo, 1);
+    /**
+     * Si on ne veut pas de flèche, on doit se destiner à un aperçu...
+     * Dans ce cas, pour plus de lisibilité, on double la taille d'impression.
+     */
+    cairo_set_line_width(cairo, arrow ? 1 : 2);
 
     cairo_move_to(cairo, renderer->points[0].x, renderer->points[0].y);
 
@@ -176,13 +204,12 @@ void gtk_link_renderer_draw(const GtkLinkRenderer *renderer, GdkDrawable *drawab
 
     cairo_stroke(cairo);
 
-    draw_link_arrow(cairo,
-                    renderer->points[renderer->count - 2].x,
-                    renderer->points[renderer->count - 2].y,
-                    renderer->points[renderer->count - 1].x,
-                    renderer->points[renderer->count - 1].y);
-
-    cairo_destroy(cairo);
+    if (arrow)
+        draw_link_arrow(cairo,
+                        renderer->points[renderer->count - 2].x,
+                        renderer->points[renderer->count - 2].y,
+                        renderer->points[renderer->count - 1].x,
+                        renderer->points[renderer->count - 1].y);
 
 }
 
diff --git a/src/gtkext/gtklinkrenderer.h b/src/gtkext/gtklinkrenderer.h
index 95cdea6..574bd1d 100644
--- a/src/gtkext/gtklinkrenderer.h
+++ b/src/gtkext/gtklinkrenderer.h
@@ -25,6 +25,7 @@
 #define _GTKEXT_GTKLINKRENDERER_H
 
 
+#include <stdbool.h>
 #include <gdk/gdk.h>
 #include <gtk/gtkobject.h>
 
@@ -66,6 +67,9 @@ GtkObject *gtk_link_renderer_new(LinkColor, GdkPoint *, size_t);
 /* Dessine les liens graphiques enregistrés dans le moteur. */
 void gtk_link_renderer_draw(const GtkLinkRenderer *, GdkDrawable *, GdkGC *);
 
+/* Dessine les liens graphiques enregistrés dans le moteur. */
+void _gtk_link_renderer_draw(const GtkLinkRenderer *, cairo_t *, bool);
+
 
 
 #endif  /* _GTKEXT_GTKLINKRENDERER_H */
diff --git a/src/gtkext/gtkviewpanel-int.h b/src/gtkext/gtkviewpanel-int.h
index 6e6cbaf..ee14067 100644
--- a/src/gtkext/gtkviewpanel-int.h
+++ b/src/gtkext/gtkviewpanel-int.h
@@ -45,6 +45,10 @@ typedef bool (* get_addr_coordinates_fc) (const GtkViewPanel *, vmpa_t, gint *,
 /* Réagit à un défilement quelconque. */
 typedef void (* scroll_fc) (GtkViewPanel *);
 
+/* Place en cache un rendu destiné à l'aperçu graphique rapide. */
+typedef void (* cache_glance_fc) (GtkViewPanel *, cairo_t *);
+
+
 
 /* Composant d'affichage générique (instance) */
 struct _GtkViewPanel
@@ -63,6 +67,7 @@ struct _GtkViewPanel
     define_address_fc define;               /* Centrage sur une partie     */
     get_addr_coordinates_fc get_coordinates;/* Conversion adresse <-> pos. */
     scroll_fc scroll;                       /* Défilement du contenu       */
+    cache_glance_fc cache_glance;           /* Cache de la mignature       */
 
     bool *display_addr;                     /* Affichage des adresses ?    */
     bool *display_code;                     /* Affichage du code binaire ? */
diff --git a/src/gtkext/gtkviewpanel.c b/src/gtkext/gtkviewpanel.c
index 0ab4f72..3c9ef6b 100644
--- a/src/gtkext/gtkviewpanel.c
+++ b/src/gtkext/gtkviewpanel.c
@@ -500,7 +500,7 @@ bool gtk_view_panel_contain_address(const GtkViewPanel *panel, vmpa_t addr)
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : panel = composant GTK à manipuler.                           *
-*                addr = adresse à présenter à l'écran.                        *
+*                addr  = adresse à présenter à l'écran.                       *
 *                                                                             *
 *  Description : S'assure qu'une adresse donnée est visible à l'écran.        *
 *                                                                             *
@@ -538,3 +538,24 @@ void gtk_view_panel_scroll_to_address(GtkViewPanel *panel, vmpa_t addr)
     }
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : panel = composant GTK à manipuler.                           *
+*                cairo = assistant pour la création de rendus.                *
+*                                                                             *
+*  Description : Place en cache un rendu destiné à l'aperçu graphique rapide. *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void gtk_view_panel_cache_glance(GtkViewPanel *panel, cairo_t *cairo)
+{
+    if (panel->cache_glance != NULL)
+        panel->cache_glance(panel, cairo);
+
+}
diff --git a/src/gtkext/gtkviewpanel.h b/src/gtkext/gtkviewpanel.h
index 7b883be..3de5fab 100644
--- a/src/gtkext/gtkviewpanel.h
+++ b/src/gtkext/gtkviewpanel.h
@@ -77,6 +77,9 @@ bool gtk_view_panel_contain_address(const GtkViewPanel *, vmpa_t);
 /* S'assure qu'une adresse donnée est visible à l'écran. */
 void gtk_view_panel_scroll_to_address(GtkViewPanel *, vmpa_t);
 
+/* Place en cache un rendu destiné à l'aperçu graphique rapide. */
+void gtk_view_panel_cache_glance(GtkViewPanel *, cairo_t *);
+
 
 
 #endif  /* _GTK_VIEWPANEL_H */
diff --git a/src/gui/editem-int.h b/src/gui/editem-int.h
index 8ab0c43..594b6fd 100644
--- a/src/gui/editem-int.h
+++ b/src/gui/editem-int.h
@@ -60,6 +60,7 @@ struct _GEditorItem
 
     update_item_binary_fc update_binary;    /* Changement de binaire       */
     update_item_view_fc update_view;        /* Rechargement dû à une vue   */
+    update_item_view_fc update_content;     /* Rechargement dû à un contenu*/
     update_project_fc update_project;       /* Actualisation des binaires  */
 
 };
diff --git a/src/gui/editem.c b/src/gui/editem.c
index 1d542a3..ad14e42 100644
--- a/src/gui/editem.c
+++ b/src/gui/editem.c
@@ -230,6 +230,30 @@ void change_editor_items_current_view(GObject *ref, GtkViewPanel *view)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : ref  = espace de référencement global.                       *
+*                view = nouveau panneau d'affichage actif.                    *
+*                                                                             *
+*  Description : Lance une actualisation du fait d'un changement de contenu.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void change_editor_items_current_view_content(GtkViewPanel *view)
+{
+    GEditorItem *iter;                     /* Boucle de parcours          */
+
+    editem_list_for_each(iter, _editem_list)
+        if (iter->update_content != NULL)
+            iter->update_content(iter, view);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : project = projet concerné par l'évolution.                   *
 *                                                                             *
 *  Description : Lance une actualisation relative à l'étendue du projet.      *
diff --git a/src/gui/editem.h b/src/gui/editem.h
index 4bb1cd3..9b9ee20 100644
--- a/src/gui/editem.h
+++ b/src/gui/editem.h
@@ -79,6 +79,9 @@ void change_editor_items_current_binary(GObject *, GLoadedBinary *);
 /* Lance une actualisation du fait d'un changement de vue. */
 void change_editor_items_current_view(GObject *, GtkViewPanel *);
 
+/* Lance une actualisation du fait d'un changement de contenu. */
+void change_editor_items_current_view_content(GtkViewPanel *);
+
 /* Lance une actualisation relative à l'étendue du projet. */
 void update_project_area(GStudyProject *);
 
diff --git a/src/gui/panels/Makefile.am b/src/gui/panels/Makefile.am
index f2ea661..ac90bf1 100644
--- a/src/gui/panels/Makefile.am
+++ b/src/gui/panels/Makefile.am
@@ -2,6 +2,7 @@
 noinst_LTLIBRARIES  = libguipanels.la
 
 libguipanels_la_SOURCES =				\
+	glance.h glance.c					\
 	log.h log.c							\
 	panel.h panel.c						\
 	strings.h strings.c					\
diff --git a/src/gui/panels/glance.c b/src/gui/panels/glance.c
new file mode 100644
index 0000000..fb1723a
--- /dev/null
+++ b/src/gui/panels/glance.c
@@ -0,0 +1,645 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * glance.c - panneau d'aperçu rapide
+ *
+ * Copyright (C) 2009-2012 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+
+#include "glance.h"
+
+
+#include <gtk/gtk.h>
+
+
+#include "panel-int.h"
+
+
+
+/* Panneau d'aperçu rapide (instance) */
+struct _GGlancePanel
+{
+    GPanelItem parent;                      /* A laisser en premier        */
+
+    GtkViewPanel *view;                     /* Vue à représenter           */
+    GtkRequisition req;                     /* Pleine taille de la source  */
+    GtkScrolledWindow *support;             /* Support défilant associé    */
+
+    double scale;                           /* Ratio de réduction          */
+
+	cairo_surface_t *cache;                 /* Cache grandeur nature       */
+    GtkAllocation painting;                 /* Zone réservée pour l'aperçu */
+    GtkAllocation visible;                  /* Sous-partie visible         */
+
+    double red;                             /* Conversion Gdk -> Cairo #1  */
+    double green;                           /* Conversion Gdk -> Cairo #2  */
+    double blue;                            /* Conversion Gdk -> Cairo #3  */
+
+    gdouble start_x;                        /* Abscisse du point de souris */
+    gdouble start_y;                        /* Ordonnée du point de souris */
+    bool valid;                             /* Point de départ visible ?   */
+    gdouble ref_h;                          /* Position horizontale de ref.*/
+    gdouble ref_v;                          /* Position verticale de ref.  */
+
+};
+
+
+/* Panneau d'aperçu rapide (classe) */
+struct _GGlancePanelClass
+{
+    GPanelItemClass parent;                 /* A laisser en premier        */
+
+};
+
+
+
+/* Initialise la classe des panneaux d'aperçu rapide. */
+static void g_glance_panel_class_init(GGlancePanelClass *);
+
+/* Initialise une instance de panneau d'aperçu rapide. */
+static void g_glance_panel_init(GGlancePanel *);
+
+/* Définit une fois et au bon moment le fond de l'aperçu rapide. */
+static void define_glance_bg(GtkWidget *, GGlancePanel *);
+
+/* Lance une actualisation du fait d'un changement de support. */
+static void update_glance_panel_for_view(GGlancePanel *, GtkViewPanel *);
+
+/* Réagit à la préparation du défilement du support original. */
+static void on_view_scroll_setup(GtkAdjustment *, GGlancePanel *);
+
+/* Réagit à un défilement du support original. */
+static void on_view_scrolled(GtkAdjustment *, GGlancePanel *);
+
+/* Réagit à un changement de taille de l'espace de rendu. */
+static void on_glance_resize(GtkWidget *, GdkRectangle *, GGlancePanel *);
+
+/* Calcule l'emplacement du rendu maniature et son échelle. */
+static void compute_glance_scale(GGlancePanel *);
+
+/* Lance une actualisation du fait d'un changement de vue. */
+static void update_glance_panel_for_view_content(GGlancePanel *, GtkViewPanel *);
+
+/* Met à jour l'affichage de l'aperçu rapide à présenter. */
+static gboolean redraw_glance_area(GtkWidget *, GdkEventExpose *, GGlancePanel *);
+
+/* Assure la gestion des clics de souris sur l'aperçu. */
+static gboolean on_button_press_over_glance(GtkWidget *, GdkEventButton *, GGlancePanel *);
+
+/* Assure la gestion du déplacement de la souris sur l'aperçu. */
+static gboolean on_mouse_motion_over_glance(GtkWidget *, GdkEventMotion *, GGlancePanel *);
+
+
+
+/* Indique le type définit pour un panneau d'aperçu rapide. */
+G_DEFINE_TYPE(GGlancePanel, g_glance_panel, G_TYPE_PANEL_ITEM);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des panneaux d'aperçu rapide.           *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_glance_panel_class_init(GGlancePanelClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : panel = instance à initialiser.                              *
+*                                                                             *
+*  Description : Initialise une instance de panneau d'aperçu rapide.          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_glance_panel_init(GGlancePanel *panel)
+{
+    GEditorItem *base;                      /* Version basique d'instance  */
+    GtkWidget *area;                        /* Surface de dessin réelle    */
+
+    base = G_EDITOR_ITEM(panel);
+
+    base->name = _("Glance");
+
+    area = gtk_drawing_area_new();
+    g_signal_connect(G_OBJECT(area), "realize", G_CALLBACK(define_glance_bg), panel);
+    gtk_widget_show(area);
+
+    base->widget = gtk_event_box_new();
+    gtk_container_add(GTK_CONTAINER(base->widget), area);
+    gtk_widget_show(base->widget);
+
+    base->update_view = (update_item_view_fc)update_glance_panel_for_view;
+    base->update_content = (update_item_view_fc)update_glance_panel_for_view_content;
+
+    gtk_widget_set_size_request(base->widget, 300, 300);
+
+    g_signal_connect(G_OBJECT(area), "expose_event",
+                      G_CALLBACK(redraw_glance_area), panel);
+    g_signal_connect(G_OBJECT(area), "size-allocate",
+                      G_CALLBACK(on_glance_resize), panel);
+
+    g_signal_connect(G_OBJECT(base->widget), "button-press-event",
+                      G_CALLBACK(on_button_press_over_glance), panel);
+    g_signal_connect(G_OBJECT(base->widget), "motion-notify-event",
+                      G_CALLBACK(on_mouse_motion_over_glance), panel);
+
+}
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : ref = espace de référencement global.                        *
+*                                                                             *
+*  Description : Crée un panneau d'aperçu rapide.                             *
+*                                                                             *
+*  Retour      : Adresse de la structure mise en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GEditorItem *g_glance_panel_new(GObject *ref)
+{
+    GEditorItem *result;                    /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_GLANCE_PANEL, NULL);
+
+    g_panel_item_init_ext(G_PANEL_ITEM(result), ref, PANEL_GLANCE_ID,
+                          _("Glance"), G_EDITOR_ITEM(result)->widget, "es");
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : widget = composant GTK en préparation.                       *
+*                panel  = informations liées au panneau associé.              *
+*                                                                             *
+*  Description : Définit une fois et au bon moment le fond de l'aperçu rapide.*
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void define_glance_bg(GtkWidget *widget, GGlancePanel *panel)
+{
+    gtk_widget_modify_bg(widget, GTK_STATE_NORMAL,
+                         &widget->style->mid[GTK_STATE_NORMAL]);
+
+    panel->red = widget->style->mid[GTK_STATE_NORMAL].red / USHRT_MAX;
+    panel->green = widget->style->mid[GTK_STATE_NORMAL].green / USHRT_MAX;
+    panel->blue = widget->style->mid[GTK_STATE_NORMAL].blue / USHRT_MAX;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : ref = espace de référencement global.                        *
+*                                                                             *
+*  Description : Construit et intègre un panneau d'affichage des symboles.    *
+*                                                                             *
+*  Retour      : Adresse du panneau mis en place.                             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GPanelItem *create_glance_panel(GObject *ref)
+{
+    GEditorItem *result;                    /* Elément réactif à renvoyer  */
+
+    result = g_glance_panel_new(ref);
+
+    /* Enregistre correctement le tout */
+    register_editor_item(result);
+
+    return G_PANEL_ITEM(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : panel = panneau à actualiser.                                *
+*                view  = nouveau panneau d'affichage actif.                   *
+*                                                                             *
+*  Description : Lance une actualisation du fait d'un changement de support.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void update_glance_panel_for_view(GGlancePanel *panel, GtkViewPanel *view)
+{
+    GtkWidget *parent;                      /* Support défilant de la vue  */
+    GtkAdjustment *adj;                     /* Gestionnaire du défilement  */
+
+    if (panel->view != NULL)
+    {
+        g_object_unref(panel->view);
+        panel->view = NULL;
+
+        g_object_unref(panel->support);
+        panel->support = NULL;
+
+        if (panel->cache != NULL)
+        {
+            cairo_surface_destroy(panel->cache);
+            panel->cache = NULL;
+        }
+
+    }
+
+    parent = gtk_widget_get_parent(GTK_WIDGET(view));
+    if (!GTK_IS_SCROLLED_WINDOW(parent)) return;
+
+    panel->view = view;
+    g_object_ref(panel->view);
+
+    panel->support = GTK_SCROLLED_WINDOW(parent);
+    g_object_ref(panel->support);
+
+    adj = gtk_scrolled_window_get_hadjustment(panel->support);
+    g_signal_connect(G_OBJECT(adj), "changed", G_CALLBACK(on_view_scroll_setup), panel);
+    g_signal_connect(G_OBJECT(adj), "value-changed", G_CALLBACK(on_view_scrolled), panel);
+
+    adj = gtk_scrolled_window_get_vadjustment(panel->support);
+    g_signal_connect(G_OBJECT(adj), "changed", G_CALLBACK(on_view_scroll_setup), panel);
+    g_signal_connect(G_OBJECT(adj), "value-changed", G_CALLBACK(on_view_scrolled), panel);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : adj   = contrôle du défilement modifié.                      *
+*                panel = panneau de l'aperçu à actualiser.                    *
+*                                                                             *
+*  Description : Réagit à la préparation du défilement du support original.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void on_view_scroll_setup(GtkAdjustment *adj, GGlancePanel *panel)
+{
+    GtkAdjustment *hadj;                    /* Gestionnaire du défilement  */
+    GtkAdjustment *vadj;                    /* Gestionnaire du défilement  */
+
+    hadj = gtk_scrolled_window_get_hadjustment(panel->support);
+    vadj = gtk_scrolled_window_get_vadjustment(panel->support);
+
+    if (hadj->page_size == 0 || vadj->page_size == 0)
+        return;
+
+    compute_glance_scale(panel);
+
+    on_view_scrolled(adj, panel);
+
+    gtk_widget_size_request(GTK_WIDGET(panel->view), &panel->req);
+
+    panel->req.width += hadj->value;
+    panel->req.height += vadj->value;
+
+    update_glance_panel_for_view_content(panel, panel->view);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : adj   = contrôle du défilement modifié.                      *
+*                panel = panneau de l'aperçu à actualiser.                    *
+*                                                                             *
+*  Description : Réagit à un défilement du support original.                  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void on_view_scrolled(GtkAdjustment *adj, GGlancePanel *panel)
+{
+    GtkAdjustment *hadj;                    /* Gestionnaire du défilement  */
+    GtkAdjustment *vadj;                    /* Gestionnaire du défilement  */
+
+    hadj = gtk_scrolled_window_get_hadjustment(panel->support);
+    vadj = gtk_scrolled_window_get_vadjustment(panel->support);
+
+    if (hadj->page_size == 0 || vadj->page_size == 0)
+        return;
+
+    panel->visible.x = panel->painting.x + hadj->value * panel->scale;
+    panel->visible.y = panel->painting.y + vadj->value * panel->scale;
+    panel->visible.width = hadj->page_size * panel->scale;
+    panel->visible.height = vadj->page_size * panel->scale;
+
+    gtk_widget_queue_draw(G_EDITOR_ITEM(panel)->widget);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : widget = composant GTK ayant changé de taille.               *
+*                alloc  = nouvel espace mis à disposition.                    *
+*                panel  = panneau de l'aperçu à actualiser.                   *
+*                                                                             *
+*  Description : Réagit à un changement de taille de l'espace de rendu.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void on_glance_resize(GtkWidget *widget, GdkRectangle *allocation, GGlancePanel *panel)
+{
+    if (panel->view != NULL)
+    {
+        on_view_scroll_setup(NULL, panel);
+        update_glance_panel_for_view_content(panel, panel->view);
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : panel = panneau à actualiser.                                *
+*                                                                             *
+*  Description : Calcule l'emplacement du rendu maniature et son échelle.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void compute_glance_scale(GGlancePanel *panel)
+{
+    GtkAllocation available;                /* Surface disponible totale   */
+    gint border;                            /* Taille de la bordure        */
+    double sx;                              /* Echelle sur l'axe X         */
+    double sy;                              /* Echelle sur l'axe Y         */
+
+    /* Superficies niveau GTK... */
+
+    gtk_widget_get_allocation(G_EDITOR_ITEM(panel)->widget, &available);
+
+    border = MIN(2, G_EDITOR_ITEM(panel)->widget->style->xthickness);
+    if (border > 0)
+    {
+        available.x = border;
+        available.width -= 2 * border;
+    }
+
+    border = MIN(2, G_EDITOR_ITEM(panel)->widget->style->ythickness);
+    if (border > 0)
+    {
+        available.y = border;
+        available.height -= 2 * border;
+    }
+
+    /* Calcul des ratios et emplacements */
+
+    sx = (1.0 * available.width) / panel->req.width;
+    sy = (1.0 * available.height) / panel->req.height;
+
+    if (sx < sy)
+    {
+        panel->scale = sx;
+        panel->painting.width = available.width;
+        panel->painting.height = panel->req.height * panel->scale;
+    }
+    else
+    {
+        panel->scale = sy;
+        panel->painting.width = panel->req.width * panel->scale;
+        panel->painting.height = available.height;
+    }
+
+    panel->painting.x = available.x + (available.width - panel->painting.width) / 2;
+    panel->painting.y = available.y + (available.height - panel->painting.height) / 2;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : panel = panneau à actualiser.                                *
+*                view  = nouveau panneau d'affichage actif.                   *
+*                                                                             *
+*  Description : Lance une actualisation du fait d'un changement de vue.      *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void update_glance_panel_for_view_content(GGlancePanel *panel, GtkViewPanel *view)
+{
+    cairo_t *cairo;                         /* Assistant pour le dessin    */
+
+    /* Mise en place d'un cache adapté */
+
+    if (panel->cache != NULL)
+        cairo_surface_destroy(panel->cache);
+
+    panel->cache = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
+                                              panel->painting.width,
+                                              panel->painting.height);
+
+    cairo = cairo_create(panel->cache);
+
+    cairo_scale(cairo, panel->scale, panel->scale);
+
+    /* Dessin de l'aperçu représentatif */
+
+    gtk_view_panel_cache_glance(view, cairo);
+
+    cairo_destroy(cairo);
+
+    gtk_widget_queue_draw(G_EDITOR_ITEM(panel)->widget);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : widget = composant GTK à redessiner.                         *
+*                event  = informations liées à l'événement.                   *
+*                panel  = informations liées au panneau associé.              *
+*                                                                             *
+*  Description : Met à jour l'affichage de l'aperçu rapide à présenter.       *
+*                                                                             *
+*  Retour      : FALSE pour poursuivre la propagation de l'événement.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static gboolean redraw_glance_area(GtkWidget *widget, GdkEventExpose *event, GGlancePanel *panel)
+{
+    GtkAllocation available;                /* Surface disponible totale   */
+    cairo_t *cairo;                         /* Gestionnaire de rendu       */
+
+    /* Dessin de la bordure */
+
+    gtk_widget_get_allocation(widget, &available);
+
+    gtk_paint_box(widget->style, event->window, widget->state,
+                  GTK_SHADOW_IN, &event->area, NULL, NULL,
+                  0, 0, available.width, available.height);
+
+    /* Dessin de l'aperçu */
+
+    if (panel->cache != NULL)
+    {
+        cairo = gdk_cairo_create(widget->window);
+
+        cairo_rectangle(cairo, panel->visible.x, panel->visible.y,
+                        panel->visible.width, panel->visible.height);
+
+        cairo_clip(cairo);
+
+        cairo_set_source_rgb(cairo, 1.0, 1.0, 1.0);
+
+        cairo_rectangle(cairo, panel->painting.x, panel->painting.y,
+                        panel->painting.width, panel->painting.height);
+
+        cairo_fill(cairo);
+
+        cairo_reset_clip(cairo);
+
+        cairo_set_source_surface(cairo, panel->cache, panel->painting.x, panel->painting.y);
+        cairo_paint(cairo);
+
+        cairo_destroy(cairo);
+
+    }
+
+    return TRUE;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : widget = composant GTK visé par l'opération.                 *
+*                event  = informations liées à l'événement.                   *
+*                panel  = informations liées au panneau associé.              *
+*                                                                             *
+*  Description : Assure la gestion des clics de souris sur l'aperçu.          *
+*                                                                             *
+*  Retour      : FALSE pour poursuivre la propagation de l'événement.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static gboolean on_button_press_over_glance(GtkWidget *widget, GdkEventButton *event, GGlancePanel *panel)
+{
+    GtkAdjustment *hadj;                    /* Gestionnaire du défilement  */
+    GtkAdjustment *vadj;                    /* Gestionnaire du défilement  */
+
+    if (panel->view != NULL && event->button == 1)
+    {
+        panel->start_x = event->x;
+        panel->start_y = event->y;
+
+        hadj = gtk_scrolled_window_get_hadjustment(panel->support);
+        vadj = gtk_scrolled_window_get_vadjustment(panel->support);
+
+        panel->ref_h = hadj->value;
+        panel->ref_v = vadj->value;
+
+        panel->valid = (panel->visible.x <= panel->start_x
+                        && panel->start_x < (panel->visible.x + panel->visible.width)
+                        && panel->visible.y <= panel->start_y
+                        && panel->start_y < (panel->visible.y + panel->visible.height));
+
+    }
+
+    return FALSE;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : widget = composant GTK visé par l'opération.                 *
+*                event  = informations liées à l'événement.                   *
+*                panel  = informations liées au panneau associé.              *
+*                                                                             *
+*  Description : Assure la gestion du déplacement de la souris sur l'aperçu.  *
+*                                                                             *
+*  Retour      : FALSE pour poursuivre la propagation de l'événement.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static gboolean on_mouse_motion_over_glance(GtkWidget *widget, GdkEventMotion *event, GGlancePanel *panel)
+{
+    gdouble diff_x;                         /* Evolution sur les abscisses */
+    gdouble diff_y;                         /* Evolution sur les ordonnées */
+    GtkAdjustment *hadj;                    /* Gestionnaire du défilement  */
+    GtkAdjustment *vadj;                    /* Gestionnaire du défilement  */
+
+    if (panel->view != NULL && event->state & GDK_BUTTON1_MASK && panel->valid)
+    {
+        diff_x = (event->x - panel->start_x) / panel->scale;
+        diff_y = (event->y - panel->start_y) / panel->scale;
+
+        hadj = gtk_scrolled_window_get_hadjustment(panel->support);
+        vadj = gtk_scrolled_window_get_vadjustment(panel->support);
+
+        gtk_adjustment_set_value(hadj, panel->ref_h + diff_x);
+        gtk_adjustment_set_value(vadj, panel->ref_v + diff_y);
+
+    }
+
+    return FALSE;
+
+}
diff --git a/src/gui/panels/glance.h b/src/gui/panels/glance.h
new file mode 100644
index 0000000..4136f46
--- /dev/null
+++ b/src/gui/panels/glance.h
@@ -0,0 +1,67 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * glance.h - prototypes pour le panneau d'aperçu rapide
+ *
+ * Copyright (C) 2009-2012 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+
+#ifndef _PANEL_GLANCE_H
+#define _PANEL_GLANCE_H
+
+
+#include <i18n.h>
+
+
+#include "panel.h"
+
+
+
+#define PANEL_GLANCE_ID _("Glance")
+
+
+
+#define G_TYPE_GLANCE_PANEL               g_glance_panel_get_type()
+#define G_GLANCE_PANEL(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_glance_panel_get_type(), GGlancePanel))
+#define G_IS_GLANCE_PANEL(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_glance_panel_get_type()))
+#define G_GLANCE_PANEL_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_GLANCE_PANEL, GGlancePanelClass))
+#define G_IS_GLANCE_PANEL_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_GLANCE_PANEL))
+#define G_GLANCE_PANEL_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_GLANCE_PANEL, GGlancePanelClass))
+
+
+/* Panneau d'aperçu rapide (instance) */
+typedef struct _GGlancePanel GGlancePanel;
+
+/* Panneau d'aperçu rapide (classe) */
+typedef struct _GGlancePanelClass GGlancePanelClass;
+
+
+
+/* Indique le type définit pour un panneau d'aperçu rapide. */
+GType g_glance_panel_get_type(void);
+
+/* Crée un panneau d'aperçu rapide. */
+GEditorItem *g_glance_panel_new(GObject *);
+
+/* Construit et intègre un panneau d'aperçu rapide. */
+GPanelItem *create_glance_panel(GObject *);
+
+
+
+#endif  /* _PANEL_GLANCE_H */
diff --git a/src/gui/panels/panel.c b/src/gui/panels/panel.c
index 3ad60b6..5718567 100644
--- a/src/gui/panels/panel.c
+++ b/src/gui/panels/panel.c
@@ -30,6 +30,7 @@
 #include <sys/param.h>
 
 
+#include "glance.h"
 #include "log.h"
 #include "panel-int.h"
 #include "strings.h"
@@ -360,6 +361,9 @@ void load_main_panels(GObject *ref)
     item = create_strings_panel(ref);
     g_panel_item_dock(item);
 
+    item = create_glance_panel(ref);
+    g_panel_item_dock(item);
+
 }
 
 
diff --git a/src/gui/panels/symbols.c b/src/gui/panels/symbols.c
index 87cdfa4..0073318 100644
--- a/src/gui/panels/symbols.c
+++ b/src/gui/panels/symbols.c
@@ -297,7 +297,7 @@ GEditorItem *g_symbols_panel_new(GObject *ref)
     result = g_object_new(G_TYPE_SYMBOLS_PANEL, NULL);
 
     g_panel_item_init_ext(G_PANEL_ITEM(result), ref, PANEL_SYMBOLS_ID,
-                          _("Binary symbols"), G_EDITOR_ITEM(result)->widget, "e");
+                          _("Binary symbols"), G_EDITOR_ITEM(result)->widget, "eM");
 
     return result;
 
diff --git a/src/panels/glimpse.c b/src/panels/glimpse.c
deleted file mode 100644
index c284238..0000000
--- a/src/panels/glimpse.c
+++ /dev/null
@@ -1,131 +0,0 @@
-
-/* OpenIDA - Outil d'analyse de fichiers binaires
- * glimpse.c - panneau d'aperçu de graphiques
- *
- * Copyright (C) 2009 Cyrille Bagard
- *
- *  This file is part of OpenIDA.
- *
- *  OpenIDA is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  OpenIDA is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- */
-
-
-#include "glimpse.h"
-
-
-#include "panel-int.h"
-
-
-
-
-#define _(str) str
-
-
-
-
-/* Panneau d'aperçu de graphiques (instance) */
-struct _GGlimpsePanel
-{
-    GEditorPanel parent;                    /* A laisser en premier        */
-
-};
-
-
-
-/* Panneau d'aperçu de graphiques (classe) */
-struct _GGlimpsePanelClass
-{
-    GEditorPanelClass parent;               /* A laisser en premier        */
-
-};
-
-
-
-/* Initialise la classe des panneaux d'aperçu de graphiques. */
-static void g_glimpse_panel_class_init(GGlimpsePanelClass *);
-
-/* Initialise une instance de panneau d'aperçu de graphiques. */
-static void g_glimpse_panel_init(GGlimpsePanel *);
-
-
-
-
-/* Indique le type définit pour un panneau d'aperçu de graphiques. */
-G_DEFINE_TYPE(GGlimpsePanel, g_glimpse_panel, G_TYPE_EDITOR_PANEL);
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
-*                                                                             *
-*  Description : Initialise la classe des panneaux d'aperçu de graphiques.    *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_glimpse_panel_class_init(GGlimpsePanelClass *klass)
-{
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : panel = instance à initialiser.                              *
-*                                                                             *
-*  Description : Initialise une instance de panneau d'aperçu de graphiques.   *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_glimpse_panel_init(GGlimpsePanel *panel)
-{
-    GEditorPanel *base;                     /* Version basique d'instance  */
-
-    base = G_EDITOR_PANEL(panel);
-
-    base->name = _("Glimpse");
-    base->widget = qck_create_button(NULL, NULL, "test", NULL, NULL);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Crée un panneau d'aperçu de graphiques.                      *
-*                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GEditorPanel *g_glimpse_panel_new(void)
-{
-    GEditorPanel *result;                   /* Structure à retourner       */
-
-    result = g_object_new(G_TYPE_GLIMPSE_PANEL, NULL);
-
-    return G_EDITOR_PANEL(result);
-
-}
diff --git a/src/panels/glimpse.h b/src/panels/glimpse.h
deleted file mode 100644
index 5370569..0000000
--- a/src/panels/glimpse.h
+++ /dev/null
@@ -1,60 +0,0 @@
-
-/* OpenIDA - Outil d'analyse de fichiers binaires
- * glimpse.h - prototypes pour le panneau d'aperçu de graphiques
- *
- * Copyright (C) 2009 Cyrille Bagard
- *
- *  This file is part of OpenIDA.
- *
- *  OpenIDA is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  OpenIDA is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- */
-
-
-#ifndef _PANEL_GLIMPSE_H
-#define _PANEL_GLIMPSE_H
-
-
-#include <glib-object.h>
-
-
-#include "panel.h"
-
-
-
-#define G_TYPE_GLIMPSE_PANEL               g_glimpse_panel_get_type()
-#define G_GLIMPSE_PANEL(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_glimpse_panel_get_type(), GGlimpsePanel))
-#define G_IS_GLIMPSE_PANEL(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_glimpse_panel_get_type()))
-#define G_GLIMPSE_PANEL_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_GLIMPSE_PANEL, GGlimpsePanelClass))
-#define G_IS_GLIMPSE_PANEL_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_GLIMPSE_PANEL))
-#define G_GLIMPSE_PANEL_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_GLIMPSE_PANEL, GGlimpsePanelClass))
-
-
-/* Panneau d'aperçu de graphiques (instance) */
-typedef struct _GGlimpsePanel GGlimpsePanel;
-
-/* Panneau d'aperçu de graphiques (classe) */
-typedef struct _GGlimpsePanelClass GGlimpsePanelClass;
-
-
-
-/* Indique le type définit pour un panneau d'aperçu de graphiques. */
-GType g_glimpse_panel_get_type(void);
-
-/* Crée un panneau d'aperçu de graphiques. */
-GEditorPanel *g_glimpse_panel_new(void);
-
-
-
-#endif  /* _PANEL_GLIMPSE_H */