path: root/src/gtkext/gtkbufferview.c

/* OpenIDA - Outil d'analyse de fichiers binaires
 * gtkbufferview.c - affichage de tampons de lignes
 *
 * Copyright (C) 2010-2013 Cyrille Bagard
 *
 *  This file is part of OpenIDA.
 *
 *  OpenIDA is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  OpenIDA is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
 */


#include "gtkbufferview-int.h"


#include <gdk/gdkkeysyms.h>


#include "../glibext/chrysamarshal.h"



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


/* 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 *);

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

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

/* Fournit la taille de composant requise pour un plein rendu. */
static void gtk_buffer_view_size_request(GtkWidget *, GtkRequisition *);

/* S'adapte à la surface concédée par le composant parent. */
static void gtk_buffer_view_size_allocate(GtkWidget *, GtkAllocation *);

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

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

/* Indique la position d'affichage d'une adresse donnée. */
static bool gtk_buffer_view_get_address_coordinates(const GtkBufferView *, vmpa_t, gint *, gint *);

/* Réagit à un défilement quelconque. */
static void gtk_buffer_view_scroll(GtkBufferView *);

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



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


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

/* Bascule et relance l'affichage du curseur. */
static gboolean gtk_buffer_view_refresh_caret(GtkBufferView *);



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


/* Détermine le type du composant d'affichage de tampon de lignes. */
G_DEFINE_TYPE(GtkBufferView, gtk_buffer_view, GTK_TYPE_VIEW_PANEL)


/******************************************************************************
*                                                                             *
*  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)
{
    GtkWidgetClass *widget_class;           /* Classe version Widget       */

    widget_class = GTK_WIDGET_CLASS(class);

    widget_class->focus = gtk_buffer_view_focus;
    widget_class->button_press_event = gtk_buffer_view_button_press;
    widget_class->size_request = gtk_buffer_view_size_request;
    widget_class->size_allocate = gtk_buffer_view_size_allocate;
    widget_class->expose_event = gtk_buffer_view_expose;
    widget_class->key_press_event = gtk_buffer_view_key_press;

    g_signal_new("caret-moved",
                 GTK_TYPE_BUFFER_VIEW,
                 G_SIGNAL_RUN_LAST,
                 G_STRUCT_OFFSET(GtkBufferViewClass, caret_moved),
                 NULL, NULL,
                 g_cclosure_user_marshal_VOID__UINT64,
                 G_TYPE_NONE, 1, G_TYPE_UINT64);

}


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

static void gtk_buffer_view_init(GtkBufferView *view)
{
    GtkViewPanel *viewpanel;                /* Instance parente            */

    viewpanel = GTK_VIEW_PANEL(view);

    viewpanel->get_coordinates = (get_addr_coordinates_fc)gtk_buffer_view_get_address_coordinates;
    viewpanel->scroll = (scroll_fc)gtk_buffer_view_scroll;
    viewpanel->cache_glance = (cache_glance_fc)gtk_buffer_view_cache_glance;

    view->caret.x = 10;
    view->caret.y = 10;
    view->caret.width = 100;
    view->caret.height = 100;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : widget = composant GTK visé par l'opération.                 *
*                dir    = sens de l'opération : perte ou gain de focus.       *
*                                                                             *
*  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_view_focus(GtkWidget *widget, GtkDirectionType direction)
{
    GtkBufferView *view;                    /* Autre version du composant  */
    gboolean has_focus;                     /* Etat courant                */

    view = GTK_BUFFER_VIEW(widget);
    has_focus = gtk_widget_is_focus(widget);

    if (has_focus)
        restart_caret_blinking(view);

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

        view->show_caret = true;
        gtk_buffer_view_refresh_caret(view);

    }

    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_view_button_press(GtkWidget *widget, GdkEventButton *event)
{
    GtkBufferView *view;                    /* Autre version du composant  */
    gint real_x;                            /* Abscisse absolue réelle     */
    gint real_y;                            /* Ordonnée absolue réelle     */
    vmpa_t addr;                            /* Position mémoire associée   */
    GdkRectangle new;                       /* Nouvel emplacement calculé  */

    view = GTK_BUFFER_VIEW(widget);

    gtk_widget_grab_focus(widget);

    real_x = event->x;
    real_y = event->y;
    gtk_buffer_view_compute_real_coord(view, &real_x, &real_y);

    printf(" mouse :: (%g ; %g) -> (%d ; %d)\n",
           event->x, event->y,
           real_x, real_y);

    addr = g_buffer_view_compute_caret(view->buffer_view, real_x, real_y, &new);

    if (addr != VMPA_INVALID)
    {
        //gtk_buffer_view_compute_fake_coord(view, &view->caret.x, &view->caret.y);


        printf(" mouse --old-- :: (%d ; %d)\n",
               view->caret.x, view->caret.y);

        gtk_widget_queue_draw_area(GTK_WIDGET(view), view->caret.x, view->caret.y,
                                   view->caret.width, view->caret.height);

        view->caret = new;
        view->caret_addr = addr;

        restart_caret_blinking(view);

    }

    return FALSE;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : view  = composant GTK à consulter.                           *
*                event = informations liées à l'événement.                    *
*                                                                             *
*  Description : Transcrit les coordonnées à l'écran en coordonnées absolues. *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void gtk_buffer_view_compute_fake_coord(GtkBufferView *view, gint *x, gint *y)
{
    if (GTK_VIEW_PANEL(view)->hadjustment != NULL)
        *x -= gtk_adjustment_get_value(GTK_VIEW_PANEL(view)->hadjustment);

    if (GTK_VIEW_PANEL(view)->vadjustment != NULL)
        *y += gtk_adjustment_get_value(GTK_VIEW_PANEL(view)->vadjustment);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : view  = composant GTK à consulter.                           *
*                event = informations liées à l'événement.                    *
*                                                                             *
*  Description : Transcrit les coordonnées absolues en coordonnées à l'écran. *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void gtk_buffer_view_compute_real_coord(GtkBufferView *view, gint *x, gint *y)
{
    if (x != NULL && GTK_VIEW_PANEL(view)->hadjustment != NULL)
        *x += gtk_adjustment_get_value(GTK_VIEW_PANEL(view)->hadjustment);

    if (y != NULL && GTK_VIEW_PANEL(view)->vadjustment != NULL)
        *y += gtk_adjustment_get_value(GTK_VIEW_PANEL(view)->vadjustment);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : widget      = composant GTK à consulter.                     *
*                requisition = dimensions souhaitées. [OUT]                   *
*                                                                             *
*  Description : Fournit la taille de composant requise pour un plein rendu.  *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_view_size_request(GtkWidget *widget, GtkRequisition *requisition)
{
    GtkBufferView *view;                    /* Autre version du composant  */

    view = GTK_BUFFER_VIEW(widget);

    if (view->buffer_view != NULL)
        g_buffer_view_get_size(view->buffer_view,
                               &requisition->width, &requisition->height,
                               *GTK_VIEW_PANEL(view)->display_addr,
                               *GTK_VIEW_PANEL(view)->display_code);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : view       = composant GTK à mettre à jour.                  *
*                allocation = étendue accordée à la vue.                      *
*                                                                             *
*  Description : S'adapte à la surface concédée par le composant parent.      *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_view_size_allocate(GtkWidget *widget, GtkAllocation *allocation)
{
    GtkViewPanel *panel;                    /* Autre version du composant  */
    GtkBufferView *view;                    /* Encore une autre version    */
    gint width;                             /* Largeur de l'objet actuelle */
    gint height;                            /* Hauteur de l'objet actuelle */
    GtkAllocation valloc;                   /* Surface utilisable          */
    gboolean changed;                       /* Changement de valeur ?      */

    /* Mise à jour GTK */

    widget->allocation = *allocation;

    if (gtk_widget_get_realized(widget))
        gdk_window_move_resize(widget->window,
                               allocation->x, allocation->y,
                               allocation->width, allocation->height);

    panel = GTK_VIEW_PANEL(widget);

    if (panel->hadjustment == NULL || panel->vadjustment == NULL)
        return;

    view = GTK_BUFFER_VIEW(widget);

    g_buffer_view_get_size(view->buffer_view, &width, &height,
                           *panel->display_addr, *panel->display_code);

    gtk_view_panel_compute_allocation(panel, &valloc);

    /* Défilement horizontal */

    panel->hadjustment->page_size = valloc.width;
    panel->hadjustment->step_increment = valloc.width * 0.1;
    panel->hadjustment->page_increment = valloc.width * 0.9;

    panel->hadjustment->upper = MAX(width, valloc.width);

    gtk_view_panel_reclamp_adjustment(panel->hadjustment, &changed);

    gtk_adjustment_changed(panel->hadjustment);

    if (changed)
        gtk_adjustment_value_changed(panel->hadjustment);

    /* Défilement vertical */

    panel->vadjustment->page_size = valloc.height;
    panel->vadjustment->step_increment = view->line_height;
    panel->vadjustment->page_increment = panel->vadjustment->step_increment * 10.0;

    panel->vadjustment->upper = MAX(height, valloc.height);

    gtk_view_panel_reclamp_adjustment(panel->vadjustment, &changed);

    gtk_adjustment_changed(panel->vadjustment);

    if (changed)
        gtk_adjustment_value_changed(panel->vadjustment);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : view  = composant GTK à redessiner.                          *
*                event = informations liées à 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_view_expose(GtkWidget *widget, GdkEventExpose *event)
{
    GtkBufferView *view;                    /* Autre version du composant  */
    GtkViewPanel *pview;                    /* Autre version du composant  */
    GtkStyle *style;                        /* Style associé au composant  */
    GdkDrawable *drawable;                  /* Surface de dessin           */
    gint fake_x;                            /* Abscisse virtuelle          */
    gint fake_y;                            /* Ordonnée virtuelle          */
    GtkStateType state;                     /* Etat du composant           */
    GtkViewPanelClass *parent_class;        /* Version pure du parent      */

    view = GTK_BUFFER_VIEW(widget);
    widget = GTK_WIDGET(view);
    pview = GTK_VIEW_PANEL(widget);

    drawable = GDK_DRAWABLE(event->window);

    gdk_window_begin_paint_region(drawable, event->region);

    gdk_gc_set_clip_region(pview->gc, event->region);

    style = gtk_widget_get_style(GTK_WIDGET(view));

    fake_x = 0;
    fake_y = 0;
    gtk_buffer_view_compute_fake_coord(view, &fake_x, &fake_y);

    /* Dessin de la marge gauche */

    state = gtk_widget_get_state(widget);

    gdk_gc_set_foreground(pview->gc, &style->mid[state]);

    gdk_draw_rectangle(drawable, pview->gc, TRUE,
                       fake_x, event->area.y, view->left_margin, event->area.y + event->area.height);

    gdk_gc_set_foreground(pview->gc, &style->dark[state]);

    gdk_draw_line(drawable, pview->gc,
                  fake_x + view->left_margin, event->area.y,
                  fake_x + view->left_margin, event->area.y + event->area.height);

    /* Eventuelle bordure globale */

    parent_class = g_type_class_peek(g_type_parent(GTK_TYPE_BUFFER_VIEW));

    GTK_WIDGET_CLASS(parent_class)->expose_event(widget, event);

    /* Impression du désassemblage */

    if (view->buffer_view != NULL)
        g_buffer_view_draw(view->buffer_view, event, pview->gc, fake_x, fake_y,
                           *pview->display_addr, *pview->display_code);

    gdk_window_end_paint(drawable);

    return TRUE;

}


/******************************************************************************
*                                                                             *
*  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_view_key_press(GtkWidget *widget, GdkEventKey *event)
{
    gboolean result;                        /* Suites à renvoyer           */
    bool ctrl;                              /* Statut de la touche Contrôle*/

    result = FALSE;

    ctrl = (event->state & GDK_CONTROL_MASK);

    switch (event->keyval)
    {
        case GDK_KEY_Left:
            result = TRUE;
            break;
        case GDK_KEY_Up:
            result = TRUE;
            break;
        case GDK_KEY_Right:
            result = TRUE;
            break;
        case GDK_KEY_Down:
            result = TRUE;
            break;
    }


    printf("ctrl ? %d -- keyval = %d -->> %d\n", ctrl, event->keyval, result);


    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : view = composant GTK à consulter.                            *
*                addr = adresse à présenter à l'écran.                        *
*                x    = position horizontale au sein du composant. [OUT]      *
*                y    = position verticale au sein du composant. [OUT]        *
*                                                                             *
*  Description : Indique la position d'affichage d'une adresse donnée.        *
*                                                                             *
*  Retour      : true si l'adresse fait partie du composant, false sinon.     *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static bool gtk_buffer_view_get_address_coordinates(const GtkBufferView *view, vmpa_t addr, gint *x, gint *y)
{
    return g_buffer_view_get_address_coordinates(view->buffer_view, addr, x, y);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : view  = composant GTK à mettre à jour.                       *
*                                                                             *
*  Description : Réagit à un défilement quelconque.                           *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void gtk_buffer_view_scroll(GtkBufferView *view)
{
    gtk_widget_queue_draw(GTK_WIDGET(view));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : view  = 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_view_cache_glance(GtkBufferView *view, 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  : view   = composant GTK à mettre à jour.                      *
*                buffer = tampon de lignes à encadrer.                        *
*                addr   = indique si les positions doivent être affichées.    *
*                code   = indique si le code binaire doit être affiché.       *
*                                                                             *
*  Description : Prend acte de l'association d'un tampon de lignes.           *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void gtk_buffer_view_attach_buffer(GtkBufferView *view, GBufferView *buffer, bool *addr, bool *code)
{
    gint width;                             /* Largeur de l'objet actuelle */
    gint height;                            /* Hauteur de l'objet actuelle */

    if (view->buffer != NULL)
    {
        g_object_unref(G_OBJECT(view->buffer));
        g_object_unref(G_OBJECT(view->buffer_view));
    }

    view->buffer = g_buffer_view_get_buffer(buffer);
    g_object_ref(G_OBJECT(view->buffer));

    view->buffer_view = buffer;

    //gdk_threads_enter();

    /* Taille des marges */

    view->line_height = g_buffer_view_get_line_height(view->buffer_view);
    view->left_margin = 2 * view->line_height;
    view->left_text = -2.5 * view->line_height;

    /* Validation finale */

    g_buffer_view_get_size(view->buffer_view, &width, &height, *addr, *code);

    width += -view->left_text + 1;
    height += 1;

    //gtk_widget_set_size_request(GTK_WIDGET(view), width, height);

    gtk_widget_queue_draw(GTK_WIDGET(view));

    //gdk_flush ();
    //gdk_threads_leave();

}


/******************************************************************************
*                                                                             *
*  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_buffer(const GtkBufferView *view)
{
    return view->buffer_view;

}





/* ---------------------------------------------------------------------------------- */
/*                             CONVERSIONS DE COORDONNEES                             */
/* ---------------------------------------------------------------------------------- */


/******************************************************************************
*                                                                             *
*  Paramètres  : view = composant GTK à consulter.                            *
*                x    = abscisse à ajuster. [OUT]                             *
*                x    = ordonnée à ajuster. [OUT]                             *
*                                                                             *
*  Description : Transcrit les coordonnées absolues en coordonnées à l'écran. *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void gtk_buffer_view_compute_relative_coords(GtkBufferView *view, gint *x, gint *y)
{
    if (x != NULL && GTK_VIEW_PANEL(view)->hadjustment != NULL)
        *x -= gtk_adjustment_get_value(GTK_VIEW_PANEL(view)->hadjustment);

    if (y != NULL && GTK_VIEW_PANEL(view)->vadjustment != NULL)
        *y -= gtk_adjustment_get_value(GTK_VIEW_PANEL(view)->vadjustment);

}





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


/******************************************************************************
*                                                                             *
*  Paramètres  : view = composant GTK à manipuler.                            *
*                                                                             *
*  Description : Redémarre l'affichage du curseur à l'emplacement courant.    *
*                                                                             *
*  Retour      : TRUE pour poursuivre les basculements automatiques.          *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void restart_caret_blinking(GtkBufferView *view)
{
    if (view->caret_addr == VMPA_INVALID)
        return;

    if (view->caret_timer != 0)
        g_source_remove(view->caret_timer);

    view->caret_timer = g_timeout_add_seconds(1, (GSourceFunc)gtk_buffer_view_refresh_caret, view);

    view->show_caret = false;
    gtk_buffer_view_refresh_caret(view);

    g_signal_emit_by_name(view, "caret-moved", view->caret_addr);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : view = composant GTK à manipuler.                            *
*                                                                             *
*  Description : Bascule et relance l'affichage du curseur.                   *
*                                                                             *
*  Retour      : TRUE pour poursuivre les basculements automatiques.          *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static gboolean gtk_buffer_view_refresh_caret(GtkBufferView *view)
{
    GtkWidget *widget;                      /* Autre version du composant  */
    GdkRectangle area;                      /* Région adaptée à traiter    */
    GdkDrawable *drawable;                  /* Surface de dessin           */
    GtkStyle *style;                        /* Style associé au composant  */
    GtkStateType state;                     /* Etat du composant           */
    GdkGC *gc;                              /* Contexte graphique          */

    widget = GTK_WIDGET(view);

    area = view->caret;
    gtk_buffer_view_compute_relative_coords(view, &area.x, &area.y);

    /* Réinitialisation de la surface */
    if (view->show_caret)
    {
        view->show_caret = false;
        gtk_widget_queue_draw_area(widget, area.x, area.y, area.width, area.height);
    }

    /* Dessin */
    else
    {
        view->show_caret = true;

        drawable = GDK_DRAWABLE(widget->window);
        state = gtk_widget_get_state(widget);
        style = gtk_widget_get_style(widget);

        gc = gdk_gc_new(drawable);
        gdk_gc_set_foreground(gc, &style->text[state]);

        gdk_draw_rectangle(drawable, gc, TRUE, area.x, area.y, area.width, area.height);

        gdk_gc_destroy(gc);

    }

    return TRUE;

}