path: root/src/analysis/project.c

/* Chrysalide - Outil d'analyse de fichiers binaires
 * project.c - gestion d'un groupe de fichiers binaires
 *
 * Copyright (C) 2015-2017 Cyrille Bagard
 *
 *  This file is part of Chrysalide.
 *
 *  Chrysalide 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.
 *
 *  Chrysalide 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
 */


#include "project.h"


#include <assert.h>
#include <inttypes.h>
#include <malloc.h>
#include <string.h>


#include <i18n.h>


#include "loading.h"
#include "../common/xml.h"
#include "../core/global.h"
#include "../core/params.h"
#include "../glibext/signal.h"
#include "../gtkext/easygtk.h"
#include "../glibext/delayed-int.h"
#include "../gtkext/gtkblockdisplay.h"
#include "../gtkext/gtkgraphdisplay.h"
#include "../gui/core/panels.h"
#include "../gui/panels/log.h"
#include "../gui/panels/panel.h"
#include "../format/format.h"



/* ------------------------- DEFINITION D'UN PROJET INTERNE ------------------------- */


/* Conservation d'un contenu chargé */
typedef struct _loaded_content
{
    GBinContent *content;                   /* Contenu binaire en place    */
    ProjectContentState state;              /* Renseigne le type de contenu*/

} loaded_content;

/* Conservation d'un binaire chargé */
typedef struct _loaded_binary
{
    GLoadedBinary *binary;                  /* Binaire en question         */

    GPanelItem **items;                     /* Supports d'affichage final  */
    size_t count;                           /* Nombre de ces supports      */

} loaded_binary;


/* Projet d'étude regroupant les binaires analysés (instance) */
struct _GStudyProject
{
    GObject parent;                         /* A laisser en premier        */

    char *filename;                         /* Lieu d'enregistrement       */

    loaded_content *contents;               /* Contenus binaires chargés   */
    size_t contents_count;                  /* Nombre de ces contenus      */
    GMutex cnt_mutex;                       /* Modification de la liste    */

    loaded_binary **binaries;               /* Fichiers binaires associés  */
    size_t binaries_count;                  /* Nombre de ces fichiers      */
    GMutex bin_mutex;                       /* Modification de la liste    */

};


/* Projet d'étude regroupant les binaires analysés  (classe) */
struct _GStudyProjectClass
{
    GObjectClass parent;                    /* A laisser en premier        */

};


/* Initialise la classe des projets d'étude. */
static void g_study_project_class_init(GStudyProjectClass *);

/*Initialise une instance de projet d'étude. */
static void g_study_project_init(GStudyProject *);

/* Supprime de l'écran un projet en place. */
static void g_study_project_hide(const GStudyProject *);

/* Assure un positionnement initial idéal. */
static gboolean scroll_for_the_first_time(GtkWidget *, GdkEvent *, GLoadedBinary *);



/* ----------------------- VUES ET BASCULEMENT ENTRE LES VUES ----------------------- */


/* Met en place un ensemble de vues pour un binaire. */
GPanelItem *_setup_new_panel_item_for_binary(GStudyProject *, GLoadedBinary *, BinaryView, GtkDisplayPanel **);



/* ---------------------------------------------------------------------------------- */
/*                           DEFINITION D'UN PROJET INTERNE                           */
/* ---------------------------------------------------------------------------------- */


/* Indique le type défini pour un projet d'étude. */
G_DEFINE_TYPE(GStudyProject, g_study_project, G_TYPE_OBJECT);


/******************************************************************************
*                                                                             *
*  Paramètres  : klass = classe à initialiser.                                *
*                                                                             *
*  Description : Initialise la classe des projets d'étude.                    *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_study_project_class_init(GStudyProjectClass *klass)
{

}


/******************************************************************************
*                                                                             *
*  Paramètres  : project = instance à initialiser.                            *
*                                                                             *
*  Description : Initialise une instance de projet d'étude.                   *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_study_project_init(GStudyProject *project)
{
    g_mutex_init(&project->cnt_mutex);

    g_mutex_init(&project->bin_mutex);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : -                                                            *
*                                                                             *
*  Description : Crée un nouveau projet vierge.                               *
*                                                                             *
*  Retour      : Instance mise en place.                                      *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GStudyProject *g_study_project_new(void)
{
    GStudyProject *result;                  /* Composant à retourner       */

    result = g_object_new(G_TYPE_STUDY_PROJECT, NULL);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : filename = chemin d'accès au fichier à charger.              *
*                                                                             *
*  Description : Crée un projet à partir du contenu XML d'un fichier.         *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GStudyProject *g_study_project_open(const char *filename)
{
    GStudyProject *result;                  /* Adresse à retourner         */
    xmlDocPtr xdoc;                         /* Structure XML chargée       */
    xmlXPathContextPtr context;             /* Contexte pour les XPath     */
    unsigned int root_contents;             /* Quantité de contenus majeurs*/
    GAsyncQueue *sema;                      /* Sémaphore taisant son nom   */
    xmlXPathObjectPtr xobject;              /* Cible d'une recherche       */
    unsigned int i;                         /* Boucle de parcours          */
    size_t access_len;                      /* Taille d'un chemin interne  */
    char *access;                           /* Chemin pour une sous-config.*/
    GBinContent *content;                   /* Contenu binaire retrouvé    */
    long state;                             /* Etat de ce contenu binaire  */
    bool status;                            /* Bilan d'une lecture         */
    GDelayedStudy *dstudy;                  /* Etude complémentaire à mener*/
    GBinaryLoader *loader;                  /* Dispositif de chargement    */
    GWorkQueue *queue;                      /* Gestionnaire de différés    */

    if (!open_xml_file(filename, &xdoc, &context)) return NULL;

    result = g_study_project_new();

    result->filename = strdup(filename);

    /* Préparations aux traitements parallèles */

    root_contents = 0;

    sema = g_async_queue_new();

    void ack_content_processing(GDelayedStudy *dstudy, GAsyncQueue *aqueue)
    {
        g_async_queue_push(aqueue, GINT_TO_POINTER(1));
    }

    /* Chargement des contenus binaires attachés */

    xobject = get_node_xpath_object(context, "/ChrysalideProject/Contents/Content");

    for (i = 0; i < XPATH_OBJ_NODES_COUNT(xobject); i++)
    {
        access_len = strlen("/ChrysalideProject/Contents/Content[position()=") + SIZE_T_MAXLEN + strlen("]") + 1;

        access = calloc(access_len, sizeof(char));
        snprintf(access, access_len, "/ChrysalideProject/Contents/Content[position()=%u]", i + 1);

        content = g_binary_content_new_from_xml(context, access, filename);
        status = get_node_prop_long_value(context, access, "state", &state);

        free(access);

        if (content == NULL)
        {
            log_variadic_message(LMT_ERROR, _("Unable to load the binary content #%u ; skipping..."), i);
            continue;
        }

        if (!status)
        {
            log_variadic_message(LMT_ERROR, _("Bad state for content '%s' ; skipping..."),
                                 g_binary_content_describe(content, true));
            continue;
        }

        /* Le contenu peut être un conteneur ? */
        if (state == PCS_ROOT)
        {
            dstudy = g_delayed_study_new(result, content, state);
            g_signal_connect(dstudy, "work-completed", G_CALLBACK(ack_content_processing), sema);

            g_delayed_study_preload_only(dstudy);

            root_contents++;

            study_new_content(dstudy);

        }

    }

    if(xobject != NULL)
        xmlXPathFreeObject(xobject);

    /* Attente pour la réception de contenus supplémentaires éventuels */

    for (i = 0; i < root_contents; i++)
        g_async_queue_pop(sema);

    g_async_queue_unref(sema);

    /* Chargement des binaires analysés */

    xobject = get_node_xpath_object(context, "/ChrysalideProject/Binaries/Binary");

    for (i = 0; i < XPATH_OBJ_NODES_COUNT(xobject); i++)
    {
        access_len = strlen("/ChrysalideProject/Binaries/Binary[position()=") + SIZE_T_MAXLEN + strlen("]") + 1;

        access = calloc(access_len, sizeof(char));
        snprintf(access, access_len, "/ChrysalideProject/Binaries/Binary[position()=%u]", i + 1);

        loader = g_binary_loader_new_from_xml(filename, access, result);

        free(access);

        queue = get_work_queue();
        g_work_queue_schedule_work(queue, G_DELAYED_WORK(loader), DEFAULT_WORK_GROUP);

    }

    if(xobject != NULL)
        xmlXPathFreeObject(xobject);

    /* Fin du chargement */

    close_xml_file(xdoc, context);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : project  = project à sauvegarder.                            *
*                filename = nom de fichier à utiliser ou NULL pour l'existant.*
*                                                                             *
*  Description : Procède à l'enregistrement d'un projet donné.                *
*                                                                             *
*  Retour      : true si l'enregistrement s'est déroule sans encombre.        *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_study_project_save(GStudyProject *project, const char *filename)
{
    bool result;                            /* Bilan à retourner           */
    xmlDocPtr xdoc;                         /* Document XML à créer        */
    xmlXPathContextPtr context;             /* Contexte pour les recherches*/
    const char *final;                      /* Lieu d'enregistrement final */
    size_t i;                               /* Boucle de parcours          */
    size_t access_len;                      /* Taille d'un chemin interne  */
    char *access;                           /* Chemin pour une sous-config.*/

    result = create_new_xml_file(&xdoc, &context);

    result &= (ensure_node_exist(xdoc, context, "/ChrysalideProject") != NULL);

    final = filename != NULL ? filename : project->filename;

    /* Enregistrement des contenus binaires attachés */

    for (i = 0; i < project->contents_count && result; i++)
    {
        if (project->contents[i].state == PCS_INTERNAL) continue;

        access_len = strlen("/ChrysalideProject/Contents/Content[position()=") + SIZE_T_MAXLEN + strlen("]") + 1;

        access = calloc(access_len, sizeof(char));
        snprintf(access, access_len, "/ChrysalideProject/Contents/Content[position()=%zu]", i + 1);

        result = g_binary_content_save(project->contents[i].content, xdoc, context, access, final);

        if (result)
            result = add_long_attribute_to_node(xdoc, context, access, "state", project->contents[i].state);

        free(access);

    }

    /* Enregistrement des binaires analysés */

    for (i = 0; i < project->binaries_count && result; i++)
    {
        access_len = strlen("/ChrysalideProject/Binaries/Binary[position()=") + SIZE_T_MAXLEN + strlen("]") + 1;

        access = calloc(access_len, sizeof(char));
        snprintf(access, access_len, "/ChrysalideProject/Binaries/Binary[position()=%zu]", i + 1);

        result = g_loaded_binary_save(project->binaries[i]->binary, xdoc, context, access);

        free(access);

    }

    /* Sauvegarde finale */

    result &= save_xml_file(xdoc, final);

    if (result && filename != NULL)
    {
        if (project->filename != NULL) free(project->filename);
        project->filename = strdup(filename);

    }

    close_xml_file(xdoc, context);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : project = project à consulter.                               *
*                                                                             *
*  Description : Indique le chemin du fichier destiné à la sauvegarde.        *
*                                                                             *
*  Retour      : Chemin de fichier pour l'enregistrement ou NULL si indéfini. *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

const char *g_study_project_get_filename(const GStudyProject *project)
{
    return project->filename;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : project = projet dont le contenu est à compléter.            *
*                content = contenu binaire à mémoriser pour le projet.        *
*                state   = état du contenu à conserver.                       *
*                                                                             *
*  Description : Assure l'intégration d'un contenu binaire dans un projet.    *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_study_project_add_binary_content(GStudyProject *project, GBinContent *content, ProjectContentState state)
{
    loaded_content *new;                    /* Nouveau contenu à définir   */

    g_mutex_lock(&project->cnt_mutex);

    project->contents = (loaded_content *)realloc(project->contents,
                                                  ++project->contents_count * sizeof(loaded_content));

    new = &project->contents[project->contents_count - 1];

    g_object_ref(G_OBJECT(content));

    new->content = content;
    new->state = state;

    g_mutex_unlock(&project->cnt_mutex);


}


/******************************************************************************
*                                                                             *
*  Paramètres  : project = projet dont le contenu est à compléter.            *
*                hash    = empreinte du contenu à retrouver.                  *
*                                                                             *
*  Description : Recherche un contenu binaire du projet selon son empreinte.  *
*                                                                             *
*  Retour      : Contenu avec propriété transférée ou NULL en cas d'échec.    *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GBinContent *g_study_project_find_binary_content_by_hash(GStudyProject *project, const char *hash)
{
    GBinContent *result;                    /* Trouvaille à retourner      */
    size_t i;                               /* Boucle de parcours          */
    GBinContent *iter;                      /* Contenu binaire analysé     */
    const gchar *other;                     /* Autre empreinte à comparer  */

    result = NULL;

    g_mutex_lock(&project->cnt_mutex);

    for (i = 0; i < project->contents_count && result == NULL; i++)
    {
        iter = project->contents[i].content;
        other = g_binary_content_get_checksum(iter);

        if (strcmp(hash, other) == 0)
        {
            g_object_ref(G_OBJECT(iter));
            result = iter;
        }

    }

    g_mutex_unlock(&project->cnt_mutex);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : loader  = travail de chargement mené à bien.                 *
*                project = lieu d'intégration des résultats obtenus.          *
*                                                                             *
*  Description : Acquitte la fin d'un chargement différé et complet.          *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void ack_loaded_binary(GBinaryLoader *loader, GStudyProject *project)
{
    GLoadedBinary *binary;                  /* Binaire désormais en place  */

    binary = g_binary_loader_get_result(loader);

    if (binary != NULL)
    {
        g_signal_connect_to_main(binary, "disassembly-done",
                                 G_CALLBACK(g_study_project_add_loaded_binary), project,
                                 g_cclosure_marshal_VOID__VOID);

        g_loaded_binary_analyse(binary);

    }

}


/******************************************************************************
*                                                                             *
*  Paramètres  : binary  = élément binaire tout juste désassemblé.            *
*                project = projet dont le contenu est à compléter.            *
*                                                                             *
*  Description : Assure l'intégration d'un élément binaire dans un projet.    *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_study_project_add_loaded_binary(GLoadedBinary *binary, GStudyProject *project)
{
    /* FIXME : remplacer cette fonction par un "swap" */
    g_study_project_attach_binary(project, binary);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : widget = composant d'affichage nouvellement porté à l'écran. *
*                event  = informations liées à l'événement.                   *
*                binary = fichier binaire à associer au projet actuel.        *
*                                                                             *
*  Description : Assure un positionnement initial idéal.                      *
*                                                                             *
*  Retour      : FALSE.                                                       *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static gboolean scroll_for_the_first_time(GtkWidget *widget, GdkEvent *event, GLoadedBinary *binary)
{
    GExeFormat *format;                 /* Format associé au binaire       */
    vmpa2t target;                      /* Position initiale à viser       */

    g_signal_handlers_disconnect_by_func(widget, G_CALLBACK(scroll_for_the_first_time), binary);

    format = g_loaded_binary_get_format(binary);

    if (g_exe_format_get_main_address(format, &target))
        gtk_display_panel_request_move(GTK_DISPLAY_PANEL(widget), &target);

    g_object_unref(G_OBJECT(format));

    return FALSE;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : project = project à effacer de la mémoire.                   *
*                binary  = fichier binaire à associer au projet actuel.       *
*                                                                             *
*  Description : Attache un fichier donné à un projet donné.                  *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_study_project_attach_binary(GStudyProject *project, GLoadedBinary *binary)
{
    loaded_binary *new;                     /* Nouveau binaire à présenter */
    GtkDisplayPanel *display;               /* Composant d'affichage       */
    GPanelItem *panel;                      /* Nouveau panneau associé     */

    /* Mise en place */

    new = (loaded_binary *)calloc(1, sizeof(loaded_binary));

    new->binary = binary;

    /* Enregistrement dans le projet */

    g_mutex_lock(&project->bin_mutex);

    project->binaries = (loaded_binary **)realloc(project->binaries,
                                                  ++project->binaries_count * sizeof(loaded_binary *));

    project->binaries[project->binaries_count - 1] = new;

    /* Premier affichage */

    panel = _setup_new_panel_item_for_binary(project, binary, BVW_BLOCK, &display);

    g_mutex_unlock(&project->bin_mutex);

    g_signal_connect(display, "size-allocate", G_CALLBACK(scroll_for_the_first_time), binary);

    g_panel_item_dock(panel);

    update_project_area(project);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : project = project à effacer de la mémoire.                   *
*                binary  = fichier binaire à dissocier au projet actuel.      *
*                                                                             *
*  Description : Détache un fichier donné à un projet donné.                  *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_study_project_detach_binary(GStudyProject *project, GLoadedBinary *binary)
{
    //GtkDockPanel *dpanel;                   /* Support de panneaux         */
    //GDockItem *ditem;                       /* Support d'affichage utilisé */
    size_t i;                               /* Boucle de parcours          */

    //dpanel = GTK_DOCK_PANEL(g_object_get_data(project->ref, "binpanel"));
    //ditem = gtk_dock_panel_get_item_from_binary(project, binary); FIXME !!

    //gtk_dock_panel_remove_item(dpanel, ditem);



    for (i = 0; i < project->binaries_count; i++)
        if (project->binaries[i]->binary == binary) break;

    if ((i + 1) < project->binaries_count)
        memmove(&project->binaries[i], &project->binaries[i + 1], (project->binaries_count - i - 1) * sizeof(loaded_binary *));

    project->binaries = (loaded_binary **)realloc(project->binaries,
                                                   --project->binaries_count * sizeof(loaded_binary *));

    update_project_area(project);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : project = projet dont le contenu est à afficher.             *
*                                                                             *
*  Description : Met en place un projet à l'écran.                            *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_study_project_display(const GStudyProject *project)
{
    size_t i;                               /* Boucle de parcours #1       */
    loaded_binary *handled;                 /* Binaire prise en compte     */
    size_t j;                               /* Boucle de parcours #2       */

    for (i = 0; i < project->binaries_count; i++)
    {
        handled = project->binaries[i];

        for (j = 0; j < handled->count; j++)
            g_panel_item_dock(handled->items[j]);

    }

}


/******************************************************************************
*                                                                             *
*  Paramètres  : project = projet dont le contenu est à cacher.               *
*                                                                             *
*  Description : Supprime de l'écran un projet en place.                      *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_study_project_hide(const GStudyProject *project)
{
    size_t i;                               /* Boucle de parcours #1       */
    loaded_binary *handled;                 /* Binaire prise en compte     */
    size_t j;                               /* Boucle de parcours #2       */

    for (i = 0; i < project->binaries_count; i++)
    {
        handled = project->binaries[i];

        for (j = 0; j < handled->count; j++)
            g_panel_item_undock(handled->items[j]);

    }

}


/******************************************************************************
*                                                                             *
*  Paramètres  : project = projet dont le contenu est à afficher.             *
*                count = nombre de binaires pris en compte. [OUT]             *
*                                                                             *
*  Description : Fournit l'ensemble des binaires associés à un projet.        *
*                                                                             *
*  Retour      : Liste à libérer de la mémoire.                               *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GLoadedBinary **g_study_project_get_binaries(const GStudyProject *project, size_t *count)
{
    GLoadedBinary **result;                 /* Tableau à retourner         */
    size_t i;                               /* Boucle de parcours          */

    *count = project->binaries_count;
    result = (GLoadedBinary **)calloc(*count, sizeof(GLoadedBinary *));

    for (i = 0; i < *count; i++)
    {
        result[i] = project->binaries[i]->binary;
        g_object_ref(G_OBJECT(result[i]));
    }

    return result;

}



/* ---------------------------------------------------------------------------------- */
/*                         VUES ET BASCULEMENT ENTRE LES VUES                         */
/* ---------------------------------------------------------------------------------- */


/******************************************************************************
*                                                                             *
*  Paramètres  : project = zone d'inscription du nouveau panneau.             *
*                binary  = fichier binaire dont les vues sont à créer.        *
*                wanted  = interface de visualisation demandée.               *
*                panel   = interface de visualisation principale. [OUT]       *
*                                                                             *
*  Description : Met en place un ensemble de vues pour un binaire.            *
*                                                                             *
*  Retour      : Panneau mis en place et prêt à être inséré.                  *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GPanelItem *_setup_new_panel_item_for_binary(GStudyProject *project, GLoadedBinary *binary, BinaryView wanted, GtkDisplayPanel **panel)
{
    GPanelItem *result;                     /* Nouveau panneau à renvoyer  */
    size_t k;                               /* Boucle de parcours #3       */
    loaded_binary *handled;                 /* Dossier de suivi à compléter*/
    GtkDisplayPanel *displays[BVW_COUNT];   /* Composants pour l'affichage */
    BinaryView i;                           /* Boucle de parcours #1       */
    GtkWidget *display;                     /* Affichage du binaire        */
    GtkWidget *scroll;                      /* Surface d'exposition        */
    GtkWidget *selected;                    /* Interface de prédilection   */
    const char *name;                       /* Titre associé au binaire    */
    const char *lname;                      /* Description du binaire      */
    BinaryView j;                           /* Boucle de parcours #2       */

    /* Recherche du dossier correspondant */

    for (k = 0; k < project->binaries_count; k++)
        if (project->binaries[k]->binary == binary)
            break;

    assert(k < project->binaries_count);

    handled = project->binaries[k];

    /* Créations */

    for (i = 0; i < BVW_COUNT; i++)
    {
        /* Préparation du support visuel */

        switch (i)
        {
            case BVW_BLOCK:
                display = gtk_block_display_new();
                break;
            case BVW_GRAPH:
                display = gtk_graph_display_new();
                break;
            default: /* GCC ! */
                break;
        }

        gtk_widget_show(display);

        displays[i] = GTK_DISPLAY_PANEL(display);

        gtk_display_panel_attach_binary(displays[i], binary, i);

        /* Intégration finale dans un support défilant */

        scroll = qck_create_scrolled_window(NULL, NULL);
        gtk_container_add(GTK_CONTAINER(scroll), display);

        if (i == wanted)
        {
            selected = scroll;
            *panel = GTK_DISPLAY_PANEL(display);
        }

    }

    /* Support graphique final */

    name = g_loaded_binary_get_name(binary, false);
    lname = g_loaded_binary_get_name(binary, true);

    result = g_panel_item_new(PIP_BINARY_VIEW, name, lname, selected, true, "N");
    register_panel_item(result, get_main_configuration());

    handled->items = (GPanelItem **)realloc(handled->items, ++handled->count * sizeof(GPanelItem *));
    handled->items[handled->count - 1] = result;

    /* Etablissement des liens */

    for (i = 0; i < BVW_COUNT; i++)
        for (j = 0; j < BVW_COUNT; j++)
        {
            if (j == i)
                continue;

            switch (j)
            {
                case BVW_BLOCK:
                    g_object_set_data(G_OBJECT(displays[i]), "block_alt_view", displays[j]);
                    break;
                case BVW_GRAPH:
                    g_object_set_data(G_OBJECT(displays[i]), "graph_alt_view", displays[j]);
                    break;
                default: /* GCC ! */
                    break;
            }

        }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : project = zone d'inscription du nouveau panneau.             *
*                binary  = fichier binaire dont les vues sont à créer.        *
*                wanted  = interface de visualisation demandée.               *
*                panel   = interface de visualisation principale. [OUT]       *
*                                                                             *
*  Description : Met en place un ensemble de vues pour un binaire.            *
*                                                                             *
*  Retour      : Panneau mis en place et prêt à être inséré.                  *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GPanelItem *setup_new_panel_item_for_binary(GStudyProject *project, GLoadedBinary *binary, BinaryView wanted, GtkDisplayPanel **panel)
{
    GPanelItem *result;                     /* Nouveau panneau à renvoyer  */

    /**
     * La liste des binaires pris en charge ne doit pas évoluer en cours
     * de traitement. On place donc le verrou adapté...
     */

    g_mutex_lock(&project->bin_mutex);

    result = _setup_new_panel_item_for_binary(project, binary, wanted, panel);

    g_mutex_unlock(&project->bin_mutex);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : panel = panneau affichant un contenu binaire.                *
*                                                                             *
*  Description : Fournit la station d'accueil d'un panneau d'affichage.       *
*                                                                             *
*  Retour      : Composant GTK fourni sans transfert de propriété.            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GtkDockStation *get_dock_station_for_view_panel(GtkDisplayPanel *panel)
{
    GtkWidget *result;                      /* Support trouvé à retourner  */

    /**
     * La hiérarchie des composants empilés est la suivante :
     *
     *  - GtkBlockView / GtkGraphView / GtkSourceView (avec GtkViewport intégré)
     *  - GtkScrolledWindow
     *  - GtkDockStation
     *
     */

    result = gtk_widget_get_parent(GTK_WIDGET(panel));  /* ScrolledWindow */
    result = gtk_widget_get_parent(result);             /* DockStation */

    return GTK_DOCK_STATION(result);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : panel = panneau affichant un contenu binaire.                *
*                                                                             *
*  Description : Fournit le support défilant d'un panneau d'affichage.        *
*                                                                             *
*  Retour      : Composant GTK fourni sans transfert de propriété.            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GtkWidget *get_scroll_window_for_view_panel(GtkDisplayPanel *panel)
{
    GtkWidget *result;                      /* Support trouvé à retourner  */

    /**
     * La hiérarchie des composants empilés est la suivante :
     *
     *  - GtkBlockView / GtkGraphView / GtkSourceView (avec GtkViewport intégré)
     *  - GtkScrolledWindow
     *  - GtkDockStation
     *
     */

    result = gtk_widget_get_parent(GTK_WIDGET(panel));  /* ScrolledWindow */

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : panel = panneau affichant un contenu binaire.                *
*                view  = autre vision recherchée.                             *
*                                                                             *
*  Description : Fournit une vision alternative d'un panneau d'affichage.     *
*                                                                             *
*  Retour      : Composant GTK fourni sans transfert de propriété.            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GtkDisplayPanel *get_alt_view_for_view_panel(GtkDisplayPanel *panel, BinaryView view)
{
    GtkDisplayPanel *result;                /* Panneau visé à renvoyer     */

    switch (view)
    {
        case BVW_BLOCK:
            result = GTK_DISPLAY_PANEL(g_object_get_data(G_OBJECT(panel), "block_alt_view"));
            break;
        case BVW_GRAPH:
            result = GTK_DISPLAY_PANEL(g_object_get_data(G_OBJECT(panel), "graph_alt_view"));
            break;
        default:
            assert(false);
            result = NULL;
            break;
    }

    if (result != NULL)
        g_object_ref(G_OBJECT(result));

    return result;

}



/* ---------------------------------------------------------------------------------- */
/*                           GESTION GLOBALISEE DES PROJETS                           */
/* ---------------------------------------------------------------------------------- */


/******************************************************************************
*                                                                             *
*  Paramètres  : project = éventuel adresse à renvoyer désormais.             *
*                                                                             *
*  Description : Fournit l'adresse du projet courant.                         *
*                                                                             *
*  Retour      : Adresse du projet ouvert ou NULL si aucun (!).               *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GStudyProject *_get_current_study_project(GStudyProject *project)
{
    static GStudyProject *result = NULL;    /* Adresse à retourner         */

    if (project != NULL)
    {
        if (result != NULL)
        {
            g_study_project_hide(result);
            g_object_unref(G_OBJECT(result));
        }

        result = project;

    }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : -                                                            *
*                                                                             *
*  Description : Fournit le gestionnaire des projets connus.                  *
*                                                                             *
*  Retour      : Instance de gestion unique.                                  *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GtkRecentManager *get_project_manager(void)
{
    static GtkRecentManager *result = NULL; /* Singleton à retourner       */

    if (result == NULL)
    {
        result = gtk_recent_manager_get_default();
        //gtk_recent_manager_purge_items(result, NULL);
    }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : project = projet à traiter.                                  *
*                                                                             *
*  Description : Place un projet au sommet de la pile des projets récents.    *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void push_project_into_recent_list(const GStudyProject *project)
{
    GtkRecentManager *manager;              /* Gestionnaire global         */
    char *qualified;                        /* Chemin avec 'file://'       */
    GtkRecentData recent;                   /* Données complètes           */

    if (project->filename == NULL)
        return;

    /* Constitution de la liste des projets récents */

    manager = get_project_manager();

    qualified = (char *)calloc(strlen("file://") + strlen(project->filename) + 1, sizeof(char));

    strcpy(qualified, "file://");
    strcat(qualified, project->filename);

    memset(&recent, 0, sizeof(GtkRecentData));

    recent.mime_type = "application/chrysalide.project";
    recent.app_name = "Chrysalide";
    recent.app_exec = "chrysalide %f";

    gtk_recent_manager_add_full(manager, qualified, &recent);

    free(qualified);

    /* Pour la prochaine ouverture du programme... */

    g_generic_config_set_value(get_main_configuration(), MPK_LAST_PROJECT, project->filename);

}