path: root/src/gtkext/bufferview.c

/* Chrysalide - Outil d'analyse de fichiers binaires
 * bufferview.c - affichage de tampons de lignes
 *
 * Copyright (C) 2016-2024 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 Chrysalide.  If not, see <http://www.gnu.org/licenses/>.
 */


#include "bufferview.h"


#include "bufferview-int.h"





/* ------------------------- BASES D'UN COMPOSANT GRAPHIQUE ------------------------- */


/* Procède à l'initialisation de l'afficheur de tampons. */
static void gtk_buffer_view_class_init(GtkBufferViewClass *);

/* Procède à l'initialisation de l'afficheur de tampons. */
static void gtk_buffer_view_init(GtkBufferView *);

/* Supprime toutes les références externes. */
static void gtk_buffer_view_dispose(GtkBufferView *);

/* Procède à la libération totale de la mémoire. */
static void gtk_buffer_view_finalize(GtkBufferView *);




/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */


/* Prend acte de la taille allouée au composant d'affichage. */
static void gtk_buffer_view_size_allocate(GtkWidget *, int, int, int);

/* Réagit à un défilement chez une barre associée au composant. */
static void gtk_buffer_view_adjust_scroll_value(GtkBufferView *, GtkOrientation, GtkAdjustment *);



/* ---------------------------------------------------------------------------------- */
/*                           BASES D'UN COMPOSANT GRAPHIQUE                           */
/* ---------------------------------------------------------------------------------- */


/* Détermine le type du composant d'affichage générique. */
G_DEFINE_TYPE(GtkBufferView, gtk_buffer_view, GTK_TYPE_CONTENT_VIEW);


/******************************************************************************
*                                                                             *
*  Paramètres  : class = classe GTK à initialiser.                            *
*                                                                             *
*  Description : Procède à l'initialisation de l'afficheur de tampons.        *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_view_class_init(GtkBufferViewClass *class)
{
    GObjectClass *object;                   /* Autre version de la classe  */
    GtkWidgetClass *widget;                 /* Classe version Widget       */
    GtkContentViewClass *content;           /* Base d'affichage            */

    object = G_OBJECT_CLASS(class);

    object->dispose = (GObjectFinalizeFunc/* ! */)gtk_buffer_view_dispose;
    object->finalize = (GObjectFinalizeFunc)gtk_buffer_view_finalize;

    widget = GTK_WIDGET_CLASS(class);

    widget->size_allocate = gtk_buffer_view_size_allocate;

    content = GTK_CONTENT_VIEW_CLASS(class);

    content->adjust = (adjust_scroll_value_fc)gtk_buffer_view_adjust_scroll_value;



#if 0

    widget_class->focus_in_event = gtk_buffer_view_focus;
    widget_class->focus_out_event = gtk_buffer_view_focus;
    widget_class->button_press_event = gtk_buffer_view_button_press;
    widget_class->draw = gtk_buffer_view_draw;
    widget_class->key_press_event = gtk_buffer_view_key_press;

    panel_class = GTK_DISPLAY_PANEL_CLASS(class);

    panel_class->compute_size = (compute_requested_size_fc)gtk_buffer_view_compute_requested_size;
    panel_class->compute_inc = (compute_scroll_inc_fc)gtk_buffer_view_compute_scroll_inc;
    panel_class->adjust = (adjust_scroll_value_fc)gtk_buffer_view_adjust_scroll_value;
    panel_class->get_coordinates = (get_coordinates_fc)gtk_buffer_view_get_cursor_coordinates;
    panel_class->get_active = (get_active_object_fc)gtk_buffer_view_get_active_object;
    panel_class->move_caret_to = (move_caret_to_fc)_gtk_buffer_view_move_caret_to;
    panel_class->cache_glance = (cache_glance_fc)gtk_buffer_view_cache_glance;

    panel_class->get_cursor = (get_cursor_fc)gtk_buffer_view_get_cursor;

    /* Signaux */

    g_signal_new("reach-limit",
                 GTK_TYPE_BUFFER_DISPLAY,
                 G_SIGNAL_RUN_LAST,
                 G_STRUCT_OFFSET(GtkBufferViewClass, reach_limit),
                 NULL, NULL,
                 g_cclosure_marshal_VOID__ENUM,
                 G_TYPE_NONE, 1, GTK_TYPE_SCROLL_TYPE);

    g_signal_new("prepare-collapsing",
                 GTK_TYPE_BUFFER_DISPLAY,
                 G_SIGNAL_RUN_LAST,
                 G_STRUCT_OFFSET(GtkBufferViewClass, prepare_collapsing),
                 NULL, NULL,
                 g_cclosure_marshal_VOID__BOOLEAN,
                 G_TYPE_NONE, 1, G_TYPE_BOOLEAN);

#endif

}


/******************************************************************************
*                                                                             *
*  Paramètres  : display = composant GTK à initialiser.                       *
*                                                                             *
*  Description : Procède à l'initialisation de l'afficheur de tampons.        *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_view_init(GtkBufferView *view)
{
    view->view = NULL;
    view->style = g_token_style_new(GTK_WIDGET(view));

    view->virt_top = 0;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : display = instance d'objet GLib à traiter.                   *
*                                                                             *
*  Description : Supprime toutes les références externes.                     *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_view_dispose(GtkBufferView *view)
{
#if 0

    if (display->caret_timer != 0)
    {
        g_source_remove(display->caret_timer);
        display->caret_timer = 0;
    }

    g_clear_object(&display->cursor);

    g_clear_object(&display->builder);
    g_clear_object(&display->bar);

#endif




    g_clear_object(&view->view);
    g_clear_object(&view->style);

    G_OBJECT_CLASS(gtk_buffer_view_parent_class)->dispose(G_OBJECT(view));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : display = instance d'objet Gtk à traiter.                    *
*                                                                             *
*  Description : Procède à la libération totale de la mémoire.                *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_view_finalize(GtkBufferView *view)
{
    G_OBJECT_CLASS(gtk_buffer_view_parent_class)->finalize(G_OBJECT(view));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : view = composant GTK à consulter.                            *
*                                                                             *
*  Description : Fournit la vue associée au tampon de lignes courant.         *
*                                                                             *
*  Retour      : Vue mise en place.                                           *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GBufferView *gtk_buffer_view_get_view(const GtkBufferView *view)
{
    GBufferView *result;                    /* Instance à retourner        */

    result = view->view;

    ref_object(result);

    return result;

}
























/* ---------------------------------------------------------------------------------- */
/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
/* ---------------------------------------------------------------------------------- */


/******************************************************************************
*                                                                             *
*  Paramètres  : widget = composant GTK à examiner.                           *
*                width  = largeur affectée au composant graphique.            *
*                height = hauteur affectée au composant graphique.            *
*                baseline = ligne de base affectée au composant graphique.    *
*                                                                             *
*  Description : Prend acte de la taille allouée au composant d'affichage.    *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_view_size_allocate(GtkWidget *widget, int width, int height, int baseline)
{
    GtkContentView *base;                   /* Version de base             */
    GtkBufferView *view;                    /* Version spécialisée         */
    int full_width;                         /* Largeur idéale complète     */
    int full_height;                        /* Hauteur idéale complète     */
    int *min_widths;                        /* Largeurs minimales imposées */
    int *min_heights;                       /* Hauteurs minimales imposées */
    size_t i;                               /* Boucle de parcours          */
    int upper;                              /* Valeur maximale retenue     */
    GtkAdjustment *adj;                     /* Ajustement à mettre à jour  */
    int line_height;                        /* Hauteur d'une ligne unique  */
    int lines_per_page;                     /* Nombre de lignes sur l'écran*/
    GtkAllocation allocated;                /* Zone allouée                */
    GWidthTracker *tracker;                 /* Collecteur de largeurs      */

    base = GTK_CONTENT_VIEW(widget);
    view = GTK_BUFFER_VIEW(widget);

    /* Détermination de la surface idéale à afficher */

    g_buffer_view_compute_size(view->view, &full_width, &full_height);

    min_widths = alloca(base->sub_count * sizeof(int));
    min_heights = alloca(base->sub_count * sizeof(int));

    for (i = 0; i < base->sub_count; i++)
    {
        gtk_widget_measure(base->sub_children[i], GTK_ORIENTATION_HORIZONTAL, -1,
                           &min_widths[i], NULL, NULL, NULL);
        full_width += min_widths[i];

        gtk_widget_measure(base->sub_children[i], GTK_ORIENTATION_VERTICAL, -1,
                           &min_heights[i], NULL, NULL, NULL);
        full_height += min_heights[i];

    }

    /* Définition des besoins en défilement */

    upper = MAX(width, full_width);

    adj = base->adjustments[GTK_ORIENTATION_HORIZONTAL];

    gtk_adjustment_configure(adj,
                             gtk_adjustment_get_value(adj),
                             0, upper,
                             0.1 * width,
                             0.9 * width,
                             width);

    upper = MAX(height, full_height);

    line_height = g_token_style_get_line_height(view->style);

    lines_per_page = height / line_height;
    if (lines_per_page == 0) lines_per_page = 1;

    adj = base->adjustments[GTK_ORIENTATION_VERTICAL];

    gtk_adjustment_configure(adj,
                             gtk_adjustment_get_value(adj),
                             0, upper,
                             line_height * lines_per_page,
                             line_height * lines_per_page * 10,
                             height);

    /* Placement des composants d'affichage */

    tracker = g_buffer_view_get_tracker(view->view);

    allocated.x = 0;
    allocated.y = 0;
    allocated.height = height;

    for (i = 0; i < base->sub_count; i++)
    {
        allocated.width = g_width_tracker_get_column_min_width(tracker, i);

        if ((i + 1) == base->sub_count && allocated.width < (width - allocated.x))
            allocated.width = width - allocated.x;

        gtk_widget_size_allocate(base->sub_children[i], &allocated, baseline);

        allocated.x += allocated.width;

    }

    unref_object(tracker);

    /* Mise à jour des éléments plus internes */

    GTK_WIDGET_CLASS(gtk_buffer_view_parent_class)->size_allocate(widget, width, height, baseline);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : view        = panneau d'affichage concerné.                  *
*                orientation = indication sur le défilement à traiter.        *
*                adj         = nouvel ajustement à prendre en compte.         *
*                                                                             *
*  Description : Réagit à un défilement chez une barre associée au composant. *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_view_adjust_scroll_value(GtkBufferView *view, GtkOrientation orientation, GtkAdjustment *adj)
{
    GtkContentView *base;                   /* Version de base             */
    size_t i;                               /* Boucle de parcours          */

    base = GTK_CONTENT_VIEW(view);

    if (orientation == GTK_ORIENTATION_HORIZONTAL)
        printf("TODO...\n");

    else
    {
        view->virt_top = gtk_adjustment_get_value(adj);

        for (i = 0; i < base->sub_count; i++)
            gtk_widget_queue_draw(base->sub_children[i]);

    }

}








#if 0

#include <assert.h>


#include "easygtk.h"
#include "gtkbufferdisplay-int.h"
#include "../core/params.h"
#include "../glibext/gbinarycursor.h" // REMME



/* -------------------------- INTERACTION DIRECTE AVEC GTK -------------------------- */


/* Procède à l'initialisation de l'afficheur de tampons. */
//static void gtk_buffer_display_class_init(GtkBufferDisplayClass *);

/* Procède à l'initialisation de l'afficheur de tampons. */
//static void gtk_buffer_display_init(GtkBufferDisplay *);

/* Supprime toutes les références externes. */
//static void gtk_buffer_display_dispose(GtkBufferDisplay *);

/* Procède à la libération totale de la mémoire. */
//static void gtk_buffer_display_finalize(GtkBufferDisplay *);

/* Intègre le focus dans le rendu du composant. */
static gboolean gtk_buffer_display_focus(GtkWidget *, GdkEventFocus *);

/* Assure la gestion des clics de souris sur le composant. */
static gboolean gtk_buffer_display_button_press(GtkWidget *, GdkEventButton *);

/* Met à jour l'affichage de la visualisation de code buffer. */
static gboolean gtk_buffer_display_draw(GtkWidget *, cairo_t *);

/* Prend en compte une frappe de touche sur le composant. */
static gboolean gtk_buffer_display_key_press(GtkWidget *, GdkEventKey *);

/* Indique les dimensions de travail du composant d'affichage. */
static void gtk_buffer_display_compute_requested_size(GtkBufferDisplay *, gint *, gint *);

/* Détermine la taille des bonds lors de défilements. */
static void gtk_buffer_display_compute_scroll_inc(GtkBufferDisplay *, gint, GtkOrientation, gdouble *, gdouble *);

/* Réagit à un défilement chez une barre associée au composant. */
static void gtk_buffer_display_adjust_scroll_value(GtkBufferDisplay *, GtkAdjustment *, GtkOrientation);

/* Indique la position d'affichage d'un emplacement donné. */
static bool gtk_buffer_display_get_cursor_coordinates(const GtkBufferDisplay *, const GLineCursor *, gint *, gint *, ScrollPositionTweak);

/* Fournit l'élément actif lié à la position courante. */
GObject *gtk_buffer_display_get_active_object(const GtkBufferDisplay *);

/* Place en cache un rendu destiné à l'aperçu graphique rapide. */
static void gtk_buffer_display_cache_glance(GtkBufferDisplay *, cairo_t *, const GtkAllocation *, double);

/* Fournit le position courante dans un panneau de chargement. */
static GLineCursor *gtk_buffer_display_get_cursor(const GtkBufferDisplay *);



/* ------------------------------ ANIMATION DU CURSEUR ------------------------------ */


/* Déplace le curseur à un emplacement défini. */
static bool _gtk_buffer_display_move_caret_to(GtkBufferDisplay *, gint, gint);

/* Déplace le curseur en effaçant son éventuelle position. */
static void gtk_buffer_display_relocate_caret(GtkBufferDisplay *, const cairo_rectangle_int_t *, GLineCursor *);

/* Assure le clignotement du curseur à l'emplacement courant. */
static gboolean gtk_buffer_display_refresh_caret(GtkBufferDisplay *);

/* Redémarre l'affichage du curseur à l'emplacement courant. */
static void gtk_buffer_display_restart_caret_blinking(GtkBufferDisplay *);

/* Prépare l'actualisation de tout ou une partie de l'affichage. */
static void gtk_buffer_display_queue_draw_caret(GtkBufferDisplay *, cairo_rectangle_int_t *);

/* Affiche le curseur à l'écran, s'il doit l'être. */
static void gtk_buffer_display_draw_caret(GtkBufferDisplay *, cairo_t *);



/* ------------------------- INCLUSION D'UNE BARRE D'OUTILS ------------------------- */


/* Place correctement la barre d'outils pour bloc. */
static void gtk_buffer_display_move_block_bar(GtkBufferDisplay *);

/* Accompagne le début du survol d'un élément de barre d'outils. */
static gboolean on_block_bar_enter_notify(GtkWidget *, GdkEventCrossing *, GtkBufferDisplay *);

/* Accompagne la fin du survol d'un élément de barre d'outils. */
static gboolean on_block_bar_leave_notify(GtkWidget *, GdkEventCrossing *, GtkBufferDisplay *);

/* Accompagne le début du survol du bouton de compression. */
static gboolean on_block_bar_collapsing_enter(GtkWidget *, GdkEventCrossing *, GtkBufferDisplay *);

/* Accompagne la fin du survol du bouton de compression. */
static gboolean on_block_bar_collapsing_leave(GtkWidget *, GdkEventCrossing *, GtkBufferDisplay *);



/* ---------------------------------------------------------------------------------- */
/*                            INTERACTION DIRECTE AVEC GTK                            */
/* ---------------------------------------------------------------------------------- */


/* Détermine le type du composant d'affichage de tampon de lignes. */
G_DEFINE_TYPE(GtkBufferDisplay, gtk_buffer_display, GTK_TYPE_DISPLAY_PANEL)


/******************************************************************************
*                                                                             *
*  Paramètres  : class = classe GTK à initialiser.                            *
*                                                                             *
*  Description : Procède à l'initialisation de l'afficheur de tampons.        *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_display_class_init(GtkBufferDisplayClass *class)
{
    GObjectClass *object;                   /* Autre version de la classe  */
    GtkWidgetClass *widget_class;           /* Classe version Widget       */
    GtkDisplayPanelClass *panel_class;      /* Classe parente              */

    object = G_OBJECT_CLASS(class);

    object->dispose = (GObjectFinalizeFunc/* ! */)gtk_buffer_display_dispose;
    object->finalize = (GObjectFinalizeFunc)gtk_buffer_display_finalize;

    widget_class = GTK_WIDGET_CLASS(class);

    widget_class->focus_in_event = gtk_buffer_display_focus;
    widget_class->focus_out_event = gtk_buffer_display_focus;
    widget_class->button_press_event = gtk_buffer_display_button_press;
    widget_class->draw = gtk_buffer_display_draw;
    widget_class->key_press_event = gtk_buffer_display_key_press;

    panel_class = GTK_DISPLAY_PANEL_CLASS(class);

    panel_class->compute_size = (compute_requested_size_fc)gtk_buffer_display_compute_requested_size;
    panel_class->compute_inc = (compute_scroll_inc_fc)gtk_buffer_display_compute_scroll_inc;
    panel_class->adjust = (adjust_scroll_value_fc)gtk_buffer_display_adjust_scroll_value;
    panel_class->get_coordinates = (get_coordinates_fc)gtk_buffer_display_get_cursor_coordinates;
    panel_class->get_active = (get_active_object_fc)gtk_buffer_display_get_active_object;
    panel_class->move_caret_to = (move_caret_to_fc)_gtk_buffer_display_move_caret_to;
    panel_class->cache_glance = (cache_glance_fc)gtk_buffer_display_cache_glance;

    panel_class->get_cursor = (get_cursor_fc)gtk_buffer_display_get_cursor;

    /* Signaux */

    g_signal_new("reach-limit",
                 GTK_TYPE_BUFFER_DISPLAY,
                 G_SIGNAL_RUN_LAST,
                 G_STRUCT_OFFSET(GtkBufferDisplayClass, reach_limit),
                 NULL, NULL,
                 g_cclosure_marshal_VOID__ENUM,
                 G_TYPE_NONE, 1, GTK_TYPE_SCROLL_TYPE);

    g_signal_new("prepare-collapsing",
                 GTK_TYPE_BUFFER_DISPLAY,
                 G_SIGNAL_RUN_LAST,
                 G_STRUCT_OFFSET(GtkBufferDisplayClass, prepare_collapsing),
                 NULL, NULL,
                 g_cclosure_marshal_VOID__BOOLEAN,
                 G_TYPE_NONE, 1, G_TYPE_BOOLEAN);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : display = composant GTK à initialiser.                       *
*                                                                             *
*  Description : Procède à l'initialisation de l'afficheur de tampons.        *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_display_init(GtkBufferDisplay *display)
{
    display->cursor = NULL;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : display = instance d'objet GLib à traiter.                   *
*                                                                             *
*  Description : Supprime toutes les références externes.                     *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_display_dispose(GtkBufferDisplay *display)
{
    if (display->caret_timer != 0)
    {
        g_source_remove(display->caret_timer);
        display->caret_timer = 0;
    }

    g_clear_object(&display->view);

    g_clear_object(&display->cursor);

    g_clear_object(&display->builder);
    g_clear_object(&display->bar);

    G_OBJECT_CLASS(gtk_buffer_display_parent_class)->dispose(G_OBJECT(display));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : display = instance d'objet Gtk à traiter.                    *
*                                                                             *
*  Description : Procède à la libération totale de la mémoire.                *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_display_finalize(GtkBufferDisplay *display)
{
    G_OBJECT_CLASS(gtk_buffer_display_parent_class)->finalize(G_OBJECT(display));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : widget = composant GTK visé par l'opération.                 *
*                event  = informations liées à l'événement.                   *
*                                                                             *
*  Description : Intègre le focus dans le rendu du composant.                 *
*                                                                             *
*  Retour      : FALSE pour poursuivre la propagation de l'événement.         *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static gboolean gtk_buffer_display_focus(GtkWidget *widget, GdkEventFocus *event)
{
    GtkBufferDisplay *display;              /* Autre version du composant  */
    gboolean has_focus;                     /* Etat courant                */

    display = GTK_BUFFER_DISPLAY(widget);
    has_focus = event->in;

    if (has_focus)
        gtk_buffer_display_restart_caret_blinking(display);

    else if (display->caret_timer != 0)
    {
        g_source_remove(display->caret_timer);
        display->caret_timer = 0;

        display->show_caret = true;
        gtk_buffer_display_queue_draw_caret(display, NULL);

    }

    return TRUE;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : widget = composant GTK visé par l'opération.                 *
*                event  = informations liées à l'événement.                   *
*                                                                             *
*  Description : Assure la gestion des clics de souris sur le composant.      *
*                                                                             *
*  Retour      : FALSE pour poursuivre la propagation de l'événement.         *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static gboolean gtk_buffer_display_button_press(GtkWidget *widget, GdkEventButton *event)
{
    GtkBufferDisplay *display;              /* Autre version du composant  */
    GBufferCache *cache;                    /* Contenu représenté          */
    gint left_margin;                       /* Limite entre zones réactives*/
    gint real_x;                            /* Abscisse absolue réelle     */
    gint real_y;                            /* Ordonnée absolue réelle     */

    display = GTK_BUFFER_DISPLAY(widget);

    real_x = event->x;
    real_y = event->y;
    gtk_display_panel_compute_real_coord(GTK_DISPLAY_PANEL(display), &real_x, &real_y);

    cache = g_buffer_view_get_cache(display->view);

    left_margin = g_buffer_cache_get_left_margin(cache);

    g_object_unref(G_OBJECT(cache));

    if (real_x < left_margin)
    {
        /* TODO */
    }
    else
        _gtk_buffer_display_move_caret_to(display, real_x, real_y);

    gtk_widget_grab_focus(widget);

    return FALSE;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : widget = composant GTK à redessiner.                         *
*                cr     = contexte graphique associé à l'événement.           *
*                                                                             *
*  Description : Met à jour l'affichage de la visualisation de code buffer.   *
*                                                                             *
*  Retour      : FALSE pour poursuivre la propagation de l'événement.         *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static gboolean gtk_buffer_display_draw(GtkWidget *widget, cairo_t *cr)
{
    GtkBufferDisplay *display;              /* Autre version du composant  */
    GtkDisplayPanel *parent;                /* Autre version du composant  */
    GdkWindow *window;                      /* Fenêtre à redessiner        */
    GtkAllocation allocation;               /* Aire complète du composant  */
    cairo_region_t *region;                 /* Région visible à redessiner */
    cairo_rectangle_int_t area;             /* Surface correspondante      */
    GtkStyleContext *context;               /* Contexte du thème actuel    */
    gint virt_x;                            /* Abscisse virtuelle          */
    gint virt_y;                            /* Ordonnée virtuelle          */
    GBufferCache *cache;                    /* Contenu représenté          */
    gint left_margin;                       /* Marge gauche + espace       */
    bool sel_line;                          /* Souslignage de la sélection */
    gint *selected;                         /* Ordonnée d'une sélection    */

    display = GTK_BUFFER_DISPLAY(widget);
    parent = GTK_DISPLAY_PANEL(widget);

    window = gtk_widget_get_window(widget);

    cairo_save(cr);

    gtk_cairo_transform_to_window(cr, widget, window);

    if (parent->export)
    {
        gtk_widget_get_allocation(widget, &allocation);

        area.x = 0;
        area.y = 0;
        area.width = allocation.width;
        area.height = allocation.height;

    }
    else
    {
        region = gdk_window_get_clip_region(window);
        cairo_region_get_extents(region, &area);
        cairo_region_destroy(region);
    }

    context = gtk_widget_get_style_context(widget);

    if (parent->show_border)
    {
        gtk_widget_get_allocation(widget, &allocation);

        allocation.x = 0;
        allocation.y = 0;

        gtk_display_panel_define_border_path(parent, cr, &allocation);
        cairo_clip(cr);

    }

    /* Décalage pour le défilement horizontal */

    virt_x = 0;
    virt_y = 0;
    gtk_display_panel_compute_fake_coord(parent, &virt_x, &virt_y);

    cairo_save(cr);

    cairo_translate(cr, virt_x, 0);

    /* Récupération de la limite utile */

    cache = g_buffer_view_get_cache(display->view);

    left_margin = g_buffer_cache_get_left_margin(cache) * parent->scale;

    g_object_unref(G_OBJECT(cache));

    /* Dessin de la marge gauche */

    gtk_style_context_save(context);

    gtk_style_context_add_class(context, GTK_STYLE_CLASS_SIDEBAR);

    gtk_render_background(context, cr, 0, area.y, left_margin, area.height);

    gtk_style_context_restore(context);

    /* Fond de la zone de texte */

    gtk_style_context_save(context);

    gtk_style_context_add_class(context, GTK_STYLE_CLASS_VIEW);

    gtk_style_context_add_class(context, "graph-block-background");

    gtk_render_background(context, cr, left_margin, area.y, area.width, area.height);

    gtk_style_context_restore(context);

    if (parent->show_border)
    {
        gtk_style_context_save(context);

        gtk_style_context_add_class(context, "graph-block");

        gtk_render_background(context, cr, left_margin, area.y, area.width, area.height);

        gtk_style_context_restore(context);

    }

    /* Ligne de séparation */

    gtk_style_context_save(context);

    gtk_style_context_add_class(context, GTK_STYLE_CLASS_FRAME);

    gtk_render_frame(context, cr, - 0.5, area.y - 1, left_margin + 0.5, area.height + 2);

    gtk_style_context_restore(context);

    /* Eventuelle bordure globale */

    if (parent->show_border)
        gtk_display_panel_draw_border(parent, cr);

    /* Impression du désassemblage */

    cairo_save(cr);

    cairo_scale(cr, parent->scale, parent->scale);

    if (display->view != NULL)
    {
        g_generic_config_get_value(get_main_configuration(), MPK_SELECTION_LINE, &sel_line);
        sel_line &= gtk_widget_has_focus(widget);

        if (!sel_line || display->cursor == NULL || !g_line_cursor_is_valid(display->cursor) || parent->export)
            selected = NULL;
        else
        {
            selected = (gint []) { display->caret.y };
            gtk_display_panel_compute_relative_coords(parent, NULL, selected);
        }

        area.x -= virt_x;
        virt_y += area.y;

        g_buffer_view_draw(display->view, cr, virt_y, &area, parent->options,
                           selected, parent->scale, parent->export);

    }

    cairo_restore(cr);

    /* Curseur clignotant ? */

    cairo_restore(cr);

    if (gtk_widget_is_focus(widget))
        gtk_buffer_display_draw_caret(display, cr);

    cairo_restore(cr);

    /* Dessin des composants contenus */

    cairo_save(cr);

    cairo_scale(cr, parent->scale, parent->scale);

    GTK_WIDGET_CLASS(gtk_buffer_display_parent_class)->draw(widget, cr);

    cairo_restore(cr);

    return FALSE;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : widget = composant visé par l'opération.                     *
*                event  = informations liées à l'événement.                   *
*                                                                             *
*  Description : Prend en compte une frappe de touche sur le composant.       *
*                                                                             *
*  Retour      : FALSE pour poursuivre la propagation de l'événement.         *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static gboolean gtk_buffer_display_key_press(GtkWidget *widget, GdkEventKey *event)
{
    gboolean result;                        /* Suites à renvoyer           */
    GdkScrollDirection dir;                 /* Direction du déplacement    */
    GtkBufferDisplay *display;              /* Autre version du composant  */
    GtkDisplayPanel *panel;                 /* Autre version du composant  */
    bool ctrl;                              /* Statut de la touche Contrôle*/
    cairo_rectangle_int_t area;             /* Emplacement de curseur #1   */
    GLineCursor *cursor;                    /* Emplacement de curseur #2   */
    bool status;                            /* Validité d'un déplacement   */

    switch (event->keyval)
    {
        case GDK_KEY_Left:
            dir = GDK_SCROLL_LEFT;
            result = TRUE;
            break;

        case GDK_KEY_Up:
            dir = GDK_SCROLL_UP;
            result = TRUE;
            break;

        case GDK_KEY_Right:
            dir = GDK_SCROLL_RIGHT;
            result = TRUE;
            break;

        case GDK_KEY_Down:
            dir = GDK_SCROLL_DOWN;
            result = TRUE;
            break;

        default:
            result = FALSE;
            break;

    }

    if (result)
    {
        display = GTK_BUFFER_DISPLAY(widget);
        panel = GTK_DISPLAY_PANEL(widget);

        ctrl = (event->state & GDK_CONTROL_MASK);
        area = display->caret;

        status = g_buffer_view_move_caret(display->view, ctrl, dir, panel->options, &area, &cursor);

        if (status)
        {
            gtk_buffer_display_relocate_caret(display, &area, cursor);
            g_loaded_panel_scroll_to_cursor(G_LOADED_PANEL(panel), cursor, SPT_RAW, false);
        }
        else
            g_signal_emit_by_name(display, "reach-limit", dir);

    }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : display = composant GTK à consulter.                         *
*                width   = largeur requise à renseigner ou NULL. [OUT]        *
*                height  = hauteur requise à renseigner ou NULL. [OUT]        *
*                                                                             *
*  Description : Indique les dimensions de travail du composant d'affichage.  *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_display_compute_requested_size(GtkBufferDisplay *display, gint *width, gint *height)
{
    gint extra;                             /* Eventuel supplément largeur */

    if (width != NULL)
    {
        if (display->view != NULL)
        {
            *width = g_buffer_view_get_width(display->view, GTK_DISPLAY_PANEL(display)->options);

            if (display->bar != NULL)
            {
                gtk_widget_get_preferred_width(display->bar, NULL, &extra);
                *width += extra;
            }

        }

        else
            *width = 0;
    }

    if (height != NULL)
    {
        if (display->view != NULL)
            *height = g_buffer_view_get_height(display->view);
        else
            *height = 0;
    }

}


/******************************************************************************
*                                                                             *
*  Paramètres  : display     = composant GTK d'affichage à consulter.         *
*                size        = taille de l'espace dans la direction donnée.   *
*                orientation = indication sur le défilement à traiter.        *
*                step        = valeur d'un petit pas de défilement. [OUT]     *
*                page        = valeur d'un grand pas de défilement. [OUT]     *
*                                                                             *
*  Description : Détermine la taille des bonds lors de défilements.           *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_display_compute_scroll_inc(GtkBufferDisplay *display, gint size, GtkOrientation orientation, gdouble *step, gdouble *page)
{
    GBufferCache *cache;                    /* Gestionnaire de lignes      */

    if (orientation == GTK_ORIENTATION_VERTICAL && display->view != NULL)
    {
        cache = g_buffer_view_get_cache(display->view);

        *step = g_buffer_cache_get_line_height(cache);
        *page = *step * 10;

        g_object_unref(G_OBJECT(cache));

    }

    else
        GTK_DISPLAY_PANEL_CLASS(gtk_buffer_display_parent_class)->compute_inc(GTK_DISPLAY_PANEL(display),
                                                                           size, orientation, step, page);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : display     = panneau d'affichage concerné.                  *
*                adj         = défilement dont une valeur a changé.           *
*                orientation = indication sur le défilement à traiter.        *
*                                                                             *
*  Description : Réagit à un défilement chez une barre associée au composant. *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_display_adjust_scroll_value(GtkBufferDisplay *display, GtkAdjustment *adj, GtkOrientation orientation)
{
    GtkWidget *widget;                      /* Autre vision du composant   */

    widget = GTK_WIDGET(display);

    if (gtk_widget_get_realized(widget))
        gdk_window_invalidate_rect(gtk_widget_get_window(widget), NULL, FALSE);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : display = composant GTK à consulter.                         *
*                cursor  = emplacement à présenter à l'écran.                 *
*                x       = position horizontale au sein du composant. [OUT]   *
*                y       = position verticale au sein du composant. [OUT]     *
*                tweak   = adaptation finale à effectuer.                     *
*                                                                             *
*  Description : Indique la position d'affichage d'un emplacement donné.      *
*                                                                             *
*  Retour      : true si l'adresse fait partie du composant, false sinon.     *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static bool gtk_buffer_display_get_cursor_coordinates(const GtkBufferDisplay *display, const GLineCursor *cursor, gint *x, gint *y, ScrollPositionTweak tweak)
{
    bool result;                            /* Bilan à remonter            */
    bool need_code;                         /* Recherche plus raffinée     */
    GBufferCache *cache;                    /* Gestionnaire de lignes      */
    int height;                             /* Hauteur allouée             */

    need_code = (tweak == SPT_BOTTOM);

    cache = g_buffer_view_get_cache(display->view);

    result = g_buffer_view_get_cursor_coordinates(display->view, cursor, need_code, x, y);

    if (result)
    {
        *x += g_buffer_view_get_margin(display->view, GTK_DISPLAY_PANEL(display)->options);

        height = gtk_widget_get_allocated_height(GTK_WIDGET(display));

        switch (tweak)
        {
            case SPT_RAW:
                break;

            case SPT_TOP:
                break;

            case SPT_CENTER:
                *y -= (height / 2);
                break;

            case SPT_BOTTOM:
                *y -= height;
                *y += g_buffer_cache_get_line_height(cache);
                break;

        }

    }

    g_object_unref(G_OBJECT(cache));

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : display = composant GTK à consulter.                         *
*                                                                             *
*  Description : Fournit l'élément actif lié à la position courante.          *
*                                                                             *
*  Retour      : Objet actif courant ou NULL si aucun.                        *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GObject *gtk_buffer_display_get_active_object(const GtkBufferDisplay *display)
{
    GObject *result;                        /* Trouvaille à retourner      */

    /* Si aucune position n'est définie... */
    if (display->cursor == NULL || !g_line_cursor_is_valid(display->cursor))
        result = NULL;

    else
        result = g_buffer_view_find_creator(display->view,
                                            display->caret.x, display->caret.y,
                                            GTK_DISPLAY_PANEL(display)->options);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : display = composant GTK à manipuler.                         *
*                cairo   = assistant pour la création de rendus.              *
*                area    = taille de la surface réduite à disposition.        *
*                scale   = échelle vis à vis de la taille réelle.             *
*                                                                             *
*  Description : Place en cache un rendu destiné à l'aperçu graphique rapide. *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_display_cache_glance(GtkBufferDisplay *display, cairo_t *cairo, const GtkAllocation *area, double scale)
{
    cairo_set_line_width(cairo, 1);
    cairo_set_source_rgb(cairo, 0.4, 0.4, 0.4);

    cairo_rectangle(cairo, area->x + 0.5, area->y + 0.5, area->width - 1, area->height - 1);

    cairo_stroke(cairo);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : display = composant GTK à consulter.                         *
*                                                                             *
*  Description : Fournit le position courante dans un panneau de chargement.  *
*                                                                             *
*  Retour      : Informations relatives à la position du curseur.             *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static GLineCursor *gtk_buffer_display_get_cursor(const GtkBufferDisplay *display)
{
    GLineCursor *result;                    /* Contenu à retourner         */

    if (display->cursor != NULL)
    {
        result = display->cursor;
        g_object_ref(G_OBJECT(result));
    }
    else
        result = g_binary_cursor_new();

    return result;

}




/* ---------------------------------------------------------------------------------- */
/*                                ANIMATION DU CURSEUR                                */
/* ---------------------------------------------------------------------------------- */


/******************************************************************************
*                                                                             *
*  Paramètres  : display = composant GTK à consulter.                         *
*                cursor  = définition générique d'une localisation à l'écran. *
*                                                                             *
*  Description : Détermine si une position est comprise dans l'affichage.     *
*                                                                             *
*  Retour      : true si le composant comprend bien la localisation fournie.  *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool gtk_buffer_display_contain_cursor(const GtkBufferDisplay *display, const GLineCursor *cursor)
{
    bool result;                            /* Bilan à retourner           */
    GLineCursor *start;                     /* Position initiale du tampon */
    GLineCursor *end;                       /* Position finale du tampon   */
    int status;                             /* Bilan d'une comparaison     */

    g_buffer_view_get_restrictions(display->view, &start, &end);

    if (start == NULL && end == NULL)
        result = NULL;

    else
    {
        status = g_line_cursor_compare(start, cursor);

        if (status > 0)
            result = false;

        else
        {
            status = g_line_cursor_compare(cursor, end);

            result = (status < 0);

        }

        g_object_unref(G_OBJECT(start));
        g_object_unref(G_OBJECT(end));

    }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : display = composant GTK à manipuler.                         *
*                x       = abscisse proposée pour le nouvel emplacement.      *
*                y       = ordonnée proposée pour le nouvel emplacement.      *
*                                                                             *
*  Description : Déplace le curseur à un emplacement défini.                  *
*                                                                             *
*  Retour      : true si un traitement a été effectué, false sinon.           *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static bool _gtk_buffer_display_move_caret_to(GtkBufferDisplay *display, gint x, gint y)
{
    bool result;                            /* Bilan à retourner           */
    GtkDisplayPanel *panel;                 /* Autre version du composant  */
    cairo_rectangle_int_t new;              /* Nouvel emplacement calculé  */
    GLineCursor *cursor;                    /* Emplacement de curseur      */

    panel = GTK_DISPLAY_PANEL(display);

    result = g_buffer_view_compute_caret_full(display->view, x, y, panel->options, &new, &cursor);

    if (result)
        gtk_buffer_display_relocate_caret(display, &new, cursor);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : display   = composant GTK à manipuler.                       *
*                beginning = précise le coin où se retrouvera le curseur.     *
*                same_x    = tente de conserver une même abscisse ou NULL ?   *
*                                                                             *
*  Description : Déplace le curseur à un emplacement en extrémité.            *
*                                                                             *
*  Retour      : true si un traitement a été effectué, false sinon.           *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool gtk_buffer_display_move_caret_to(GtkBufferDisplay *display, bool beginning, gint *same_x)
{
    bool result;                            /* Bilan à remonter            */
    GBufferCache *cache;                    /* Contenu représenté          */
    gint left_margin;                       /* Limite entre zones réactives*/
    gint x;                                 /* Abscisse d'emplacement      */
    gint y;                                 /* Ordonnée d'emplacement      */

    if (beginning)
    {
        cache = g_buffer_view_get_cache(display->view);

        left_margin = g_buffer_cache_get_left_margin(cache);

        g_object_unref(G_OBJECT(cache));

        x = same_x != NULL ? *same_x : left_margin * 2;
        y = 0;

    }
    else
    {
        if (same_x != NULL)
            x = *same_x;
        else
            gtk_widget_get_preferred_width(GTK_WIDGET(display), NULL, &x);

        gtk_widget_get_preferred_height(GTK_WIDGET(display), NULL, &y);
        y--;

    }

    result = _gtk_buffer_display_move_caret_to(display, x, y);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : display = composant GTK à manipuler.                         *
*                area    = emplacement pour le dessin d'un curseur.           *
*                cursor  = emplacement représenté dans un tampon interne.     *
*                                                                             *
*  Description : Déplace le curseur en effaçant son éventuelle position.      *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_display_relocate_caret(GtkBufferDisplay *display, const cairo_rectangle_int_t *area, GLineCursor *cursor)
{
    bool clear_old;                         /* Effacement chirurgical      */
    cairo_rectangle_int_t old_area;         /* Mémorisation de l'ancien    */
    bool need_redraw;                       /* Besoin de rafraîchissement ?*/

    if (display->cursor != NULL && g_line_cursor_is_valid(display->cursor))
    {
        clear_old = true;
        old_area = display->caret;
    }
    else
        clear_old = false;

    if (display->cursor != NULL)
        g_object_unref(G_OBJECT(display->cursor));

    display->caret = *area;
    display->cursor = cursor;

    if (GTK_BUFFER_DISPLAY_GET_CLASS(display)->notify_caret != NULL)
        need_redraw = GTK_BUFFER_DISPLAY_GET_CLASS(display)->notify_caret(display, area);
    else
        need_redraw = false;

    if (display->cursor != NULL && g_line_cursor_is_valid(display->cursor))
        gtk_buffer_display_restart_caret_blinking(display);

    if (need_redraw)
        gtk_buffer_display_queue_draw_caret(display, NULL);

    else if (clear_old)
        gtk_buffer_display_queue_draw_caret(display, &old_area);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : display = composant GTK à manipuler.                         *
*                                                                             *
*  Description : Assure le clignotement du curseur à l'emplacement courant.   *
*                                                                             *
*  Retour      : TRUE pour poursuivre le clignotement.                        *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static gboolean gtk_buffer_display_refresh_caret(GtkBufferDisplay *display)
{
    /* Bascule l'affichage */
    display->show_caret = !display->show_caret;

    assert(display->cursor != NULL && g_line_cursor_is_valid(display->cursor));

    if (!display->show_caret)
        gtk_buffer_display_queue_draw_caret(display, &display->caret);
    else
        gtk_buffer_display_queue_draw_caret(display, NULL);

    return TRUE;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : display = composant GTK à manipuler.                         *
*                                                                             *
*  Description : Redémarre l'affichage du curseur à l'emplacement courant.    *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_display_restart_caret_blinking(GtkBufferDisplay *display)
{

    GtkSettings *settings;                  /* Propriétés du système       */
    guint interval;                         /* Fréquence d'actualisation   */

    if (display->caret_timer != 0)
    {
        g_source_remove(display->caret_timer);
        display->caret_timer = 0;
    }

    if (display->cursor != NULL && g_line_cursor_is_valid(display->cursor))
    {
        settings = gtk_settings_get_default();

        g_object_get(settings, "gtk-cursor-blink-time", &interval, NULL);

        display->show_caret = true;

        g_object_ref(G_OBJECT(display));

        display->caret_timer = gdk_threads_add_timeout_full(G_PRIORITY_DEFAULT, interval,
                                                            (GSourceFunc)gtk_buffer_display_refresh_caret,
                                                            display, g_object_unref);

    }

    if (display->cursor != NULL)
        g_signal_emit_by_name(display, "cursor-moved", display->cursor);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : display = composant GTK à manipuler.                         *
*                area    = emplacement du curseur ou NULL toute la région.    *
*                                                                             *
*  Description : Prépare l'actualisation de tout ou une partie de l'affichage.*
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_display_queue_draw_caret(GtkBufferDisplay *display, cairo_rectangle_int_t *area)
{
    GtkWidget *widget;                      /* Autre version du composant  */
    cairo_rectangle_int_t rect;             /* Zone rectangulaire relative */
    cairo_region_t *region;                 /* Zone précise à redessiner   */

    widget = GTK_WIDGET(display);

    if (area == NULL)
        gtk_widget_queue_draw(widget);

    else
    {
        rect = *area;
        gtk_display_panel_compute_relative_coords(GTK_DISPLAY_PANEL(display), &rect.x, &rect.y);

        region = cairo_region_create_rectangle(&rect);
        gtk_widget_queue_draw_region(widget, region);
        cairo_region_destroy(region);

    }

    /**
     * Pour une raison non comprise, le redessin n'est pris en compte que
     * si le parent est concerné également...
     */

    widget = gtk_widget_get_parent(widget);

    if (GTK_IS_SCROLLED_WINDOW(widget))
        gtk_widget_queue_draw(widget);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : display = composant GTK à manipuler.                         *
*                cr     = contexte graphique disponible pour l'opération.     *
*                                                                             *
*  Description : Affiche le curseur à l'écran, s'il doit l'être.              *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_display_draw_caret(GtkBufferDisplay *display, cairo_t *cr)
{
    cairo_rectangle_int_t area;             /* Zone adaptée à traiter      */
    cairo_region_t *region;                 /* Région définie associée     */
    GtkWidget *widget;                      /* Autre version du composant  */
    GdkRGBA *color;                         /* Couleur du curseur          */

    if (display->cursor != NULL && g_line_cursor_is_valid(display->cursor) && display->show_caret)
    {
        area = display->caret;
        gtk_display_panel_compute_relative_coords(GTK_DISPLAY_PANEL(display), &area.x, &area.y);

        region = cairo_region_create_rectangle(&area);

        widget = GTK_WIDGET(display);

        gtk_style_context_get(gtk_widget_get_style_context(widget),
                              gtk_widget_get_state_flags(widget),
                              GTK_STYLE_PROPERTY_COLOR, &color, NULL);

        cairo_set_source_rgb(cr, color->red, color->green, color->blue);

        cairo_rectangle(cr, area.x, area.y, area.width, area.height);
        cairo_fill(cr);

        cairo_region_destroy(region);

    }

}



/* ---------------------------------------------------------------------------------- */
/*                           INCLUSION D'UNE BARRE D'OUTILS                           */
/* ---------------------------------------------------------------------------------- */


/******************************************************************************
*                                                                             *
*  Paramètres  : display = panneau d'affichage concerné.                      *
*                                                                             *
*  Description : Ajoute une nouvelle barre d'outils pour bloc au composant.   *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void gtk_buffer_display_add_block_bar(GtkBufferDisplay *display)
{
    GtkWidget *bar;                         /* Barre d'outils à intégrer   */

    assert(display->builder == NULL);

    display->builder = gtk_builder_new_from_resource("/org/chrysalide/gtkext/blockbar.ui");

    bar = GTK_WIDGET(gtk_builder_get_object(display->builder, "blockbar"));

    display->bar = bar;
    g_object_ref(G_OBJECT(bar));

    g_object_ref(G_OBJECT(bar));
    gtk_widget_unparent(bar);

    gtk_fixed_put(GTK_FIXED(display), bar, 0, 0);

    gtk_builder_add_callback_symbols(display->builder,
                                     BUILDER_CALLBACK(on_block_bar_enter_notify),
                                     BUILDER_CALLBACK(on_block_bar_leave_notify),
                                     BUILDER_CALLBACK(on_block_bar_collapsing_enter),
                                     BUILDER_CALLBACK(on_block_bar_collapsing_leave),
                                     NULL);

    gtk_builder_connect_signals(display->builder, display);

    gtk_buffer_display_move_block_bar(display);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : display = panneau d'affichage concerné.                      *
*                                                                             *
*  Description : Place correctement la barre d'outils pour bloc.              *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_display_move_block_bar(GtkBufferDisplay *display)
{
    GtkWidget *bar;                         /* Barre d'outils courante     */
    gint width;                             /* Largeur requise à vide      */

    bar = display->bar;
    display->bar = NULL;

    gtk_buffer_display_compute_requested_size(display, &width, NULL);

    display->bar = bar;

    gtk_fixed_move(GTK_FIXED(display), bar, width, (int)BORDER_CORNER_RADIUS / 2);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : widget  = composant graphique concerné par l'opération.      *
*                event   = informations liées à l'événement.                  *
*                display = panneau d'affichage impliqué par l'action.         *
*                                                                             *
*  Description : Accompagne le début du survol d'un élément de barre d'outils.*
*                                                                             *
*  Retour      : FALSE pour poursuivre la propagation de l'événement.         *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static gboolean on_block_bar_enter_notify(GtkWidget *widget, GdkEventCrossing *event, GtkBufferDisplay *display)
{
    gtk_widget_set_opacity(widget, 1.0);

    return FALSE;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : widget  = composant graphique concerné par l'opération.      *
*                event   = informations liées à l'événement.                  *
*                display = panneau d'affichage impliqué par l'action.         *
*                                                                             *
*  Description : Accompagne la fin du survol d'un élément de barre d'outils.  *
*                                                                             *
*  Retour      : FALSE pour poursuivre la propagation de l'événement.         *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static gboolean on_block_bar_leave_notify(GtkWidget *widget, GdkEventCrossing *event, GtkBufferDisplay *display)
{
    gtk_widget_set_opacity(widget, 0.6);

    return FALSE;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : widget  = composant graphique concerné par l'opération.      *
*                event   = informations liées à l'événement.                  *
*                display = panneau d'affichage impliqué par l'action.         *
*                                                                             *
*  Description : Accompagne le début du survol du bouton de compression.      *
*                                                                             *
*  Retour      : FALSE pour poursuivre la propagation de l'événement.         *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static gboolean on_block_bar_collapsing_enter(GtkWidget *widget, GdkEventCrossing *event, GtkBufferDisplay *display)
{
    g_signal_emit_by_name(display, "prepare-collapsing", FALSE);

    return FALSE;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : widget  = composant graphique concerné par l'opération.      *
*                event   = informations liées à l'événement.                  *
*                display = panneau d'affichage impliqué par l'action.         *
*                                                                             *
*  Description : Accompagne la fin du survol du bouton de compression.        *
*                                                                             *
*  Retour      : FALSE pour poursuivre la propagation de l'événement.         *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static gboolean on_block_bar_collapsing_leave(GtkWidget *widget, GdkEventCrossing *event, GtkBufferDisplay *display)
{
    g_signal_emit_by_name(display, "prepare-collapsing", TRUE);

    return FALSE;

}

#endif