path: root/src/glibext/gbuffersegment.c

/* Chrysalide - Outil d'analyse de fichiers binaires
 * gbuffersegment.c - concentration d'un fragment de caractères aux propriétés communes
 *
 * Copyright (C) 2010-2014 Cyrille Bagard
 *
 *  This file is part of Chrysalide.
 *
 *  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 "gbuffersegment.h"


#include <stdbool.h>
#include <stdlib.h>
#include <string.h>


#include "../common/fnv1a.h"
#include "../gtkext/gtkblockview.h"
#include "../gtkext/support.h"



/* Utilisation du champ pixel des couleurs cachées */
#define COLOR_NOT_SET   0
#define COLOR_SET       1

/* Propriétés de rendu */
typedef struct _rendering_pattern_t
{
    GdkColor foreground;                    /* Couleur d'impression        */

    cairo_font_slant_t slant;               /* Style d'impression          */
    cairo_font_weight_t weight;             /* Poids de la police          */

} rendering_pattern_t;

/* Compléments à Cairo */

#define CAIRO_FONT_SLANT_COUNT  3
#define CAIRO_FONT_WEIGHT_COUNT 2

#define CAIRO_FONTS_COUNT (CAIRO_FONT_SLANT_COUNT * CAIRO_FONT_WEIGHT_COUNT)
#define CAIRO_FONT_INDEX(s, w) ((s) * CAIRO_FONT_SLANT_COUNT + (w))

/* Fragment de caractères aux propriétés communes (instance) */
struct _GBufferSegment
{
    GObject parent;                         /* A laisser en premier        */

    char *text;                             /* Texte brut conservé         */
    fnv64_t hash;                           /* Empreinte pour comparaisons */

    rendering_pattern_t *pattern;           /* Propriétés du rendu         */

    SegRenderingStyle style;                /* Apparence du segment        */

    GdkColor cache_bg;                      /* Fond d'impression           */
    GdkColor alt_fg;                        /* Couleur d'impression bis    */
    GdkColor *used_fg;                      /* Couleur d'impression utile  */

    cairo_text_extents_t extents;           /* Dimensions du texte         */

};

/* Fragment de caractères aux propriétés communes (classe) */
struct _GBufferSegmentClass
{
    GObjectClass parent;                    /* A laisser en premier        */

    cairo_t *font_ctxts[CAIRO_FONTS_COUNT]; /* Contextes de police         */
    rendering_pattern_t patterns[RTT_COUNT];/* Modèles d'impression        */

};


/* Procède à l'initialisation d'une classe de fragment de texte. */
static void g_buffer_segment_class_init(GBufferSegmentClass *);

/* Procède à l'initialisation d'un fragment de texte. */
static void g_buffer_segment_init(GBufferSegment *);

/* Définit les dernières propriétés de rendu restantes. */
static void g_buffer_segment_prepare(GBufferSegment *, const char *);



/* Détermine le type du fragment de caractères aux propriétés communes. */
G_DEFINE_TYPE(GBufferSegment, g_buffer_segment, G_TYPE_OBJECT);


/******************************************************************************
*                                                                             *
*  Paramètres  : class = classe de composant GTK à initialiser.               *
*                                                                             *
*  Description : Procède à l'initialisation d'une classe de fragment de texte.*
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_buffer_segment_class_init(GBufferSegmentClass *class)
{
    gchar *filename;                        /* Accès à une image 1x1       */
    cairo_font_slant_t s;                   /* Boucle de parcours #1       */
    cairo_font_weight_t w;                  /* Boucle de parcours #2       */
    cairo_t **cr;                           /* Contexte à créer            */
    cairo_surface_t *surface;               /* Surface pour dessin Cairo   */

    /* Contextes pour les mesures initiales */

    filename = find_pixmap_file("nil.png");
    if (filename == NULL) abort();

    for (s = CAIRO_FONT_SLANT_NORMAL; s < CAIRO_FONT_SLANT_COUNT; s++)
        for (w = CAIRO_FONT_WEIGHT_NORMAL; w < CAIRO_FONT_WEIGHT_COUNT; w++)
        {
            cr = &class->font_ctxts[CAIRO_FONT_INDEX(s, w)];

            surface = cairo_image_surface_create_from_png(filename);
            *cr = cairo_create(surface);
            cairo_surface_destroy(surface);

            cairo_select_font_face(*cr, "mono", s, w);
            cairo_set_font_size(*cr, 13);

        }

    g_free(filename);

    /* Propriétés d'impression */

#define GET_RESET_PATTERN(tp)                           \
    ({                                                  \
        rendering_pattern_t *__p;                       \
        __p = &class->patterns[RTT_ ## tp];             \
        memset(__p, 0, sizeof(rendering_pattern_t));    \
        __p;                                            \
    })

#define DEFINE_SIMPLE_PATTERN(rtt)                      \
    do                                                  \
    {                                                   \
        rendering_pattern_t *__ptn;                     \
        __ptn = GET_RESET_PATTERN(rtt);                 \
        __ptn->slant = CAIRO_FONT_SLANT_NORMAL;         \
        __ptn->weight = CAIRO_FONT_WEIGHT_NORMAL;       \
        __ptn->foreground.pixel = COLOR_NOT_SET;        \
    }                                                   \
    while (0)

#define DEFINE_PATTERN(rtt, s, w, r, g, b)              \
    do                                                  \
    {                                                   \
        rendering_pattern_t *__ptn;                     \
        __ptn = GET_RESET_PATTERN(rtt);                 \
        __ptn->slant = CAIRO_FONT_SLANT_ ## s;          \
        __ptn->weight = CAIRO_FONT_WEIGHT_ ## w;        \
        __ptn->foreground.red = r;                      \
        __ptn->foreground.green = g;                    \
        __ptn->foreground.blue = b;                     \
        __ptn->foreground.pixel = COLOR_SET;            \
    }                                                   \
    while (0)

    DEFINE_PATTERN(RAW,         NORMAL, NORMAL, 0, 0, 0);
    DEFINE_PATTERN(COMMENT,     NORMAL, NORMAL, 14335, 45311, 23551);
    DEFINE_PATTERN(INDICATION,  ITALIC, NORMAL, 33410, 33410, 33410);
    DEFINE_PATTERN(RAW_CODE,    NORMAL, NORMAL, 48895, 48895, 48895);
    DEFINE_PATTERN(INSTRUCTION, NORMAL, NORMAL, 0, 0, 0);
    DEFINE_PATTERN(IMMEDIATE,   NORMAL, NORMAL, 41215, 8447, 61695);
    DEFINE_PATTERN(REGISTER,    NORMAL, NORMAL, 16895, 16895, 53759);
    DEFINE_PATTERN(PUNCT,       NORMAL, BOLD,   0, 0, 0);
    DEFINE_PATTERN(HOOK,        NORMAL, BOLD,   0, 0, 0);
    DEFINE_PATTERN(SIGNS,       NORMAL, BOLD,   0, 0, 0);
    DEFINE_SIMPLE_PATTERN(LTGT);
    DEFINE_PATTERN(SECTION,     NORMAL, NORMAL, 51200, 2560, 2560);
    DEFINE_SIMPLE_PATTERN(SEGMENT);
    DEFINE_PATTERN(STRING,      NORMAL, NORMAL, 52224, 32256, 0);
    DEFINE_PATTERN(VAR_NAME,    NORMAL, NORMAL, 0, 0, 0);
    DEFINE_PATTERN(KEY_WORD,    NORMAL, NORMAL, 0, 0, 0);
    DEFINE_PATTERN(ERROR,       NORMAL, BOLD,   65535, 0, 0);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : segment = composant GTK à initialiser.                       *
*                                                                             *
*  Description : Procède à l'initialisation d'un fragment de texte.           *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_buffer_segment_init(GBufferSegment *segment)
{

}


/******************************************************************************
*                                                                             *
*  Paramètres  : type   = propriétés de la zone de texte.                     *
*                text   = chaîne de caractères à traiter.                     *
*                length = quantité de ces caractères.                         *
*                                                                             *
*  Description : Crée un nouveau fragment de texte avec des propriétés.       *
*                                                                             *
*  Retour      : Composant GTK créé.                                          *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GBufferSegment *g_buffer_segment_new(RenderingTagType type, const char *text, size_t length)
{
    GBufferSegment *result;                 /* Composant à retourner       */
    GBufferSegmentClass *class;             /* Stockage de styles préparés */ 

    result = g_object_new(G_TYPE_BUFFER_SEGMENT, NULL);

    result->text = strdup(text);
    result->hash = fnv_64a_hash(text);

    class = G_BUFFER_SEGMENT_GET_CLASS(result);
    result->pattern = &class->patterns[type];

    g_buffer_segment_prepare(result, text);

    g_buffer_segment_set_style(result, SRS_CLASSIC);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : segment = instance de segment à affiner.                     *
*                text    = chaîne de caractères à traiter.                    *
*                                                                             *
*  Description : Définit les dernières propriétés de rendu restantes.         *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_buffer_segment_prepare(GBufferSegment *segment, const char *text)
{
    GBufferSegmentClass *class;             /* Classe associée à l'instance*/
    cairo_font_slant_t slant;               /* Style d'impression          */
    cairo_font_weight_t weight;             /* Poids de la police          */
    cairo_t *cr;                            /* Contexte de rendu           */

    /* Taille */

    class = G_BUFFER_SEGMENT_GET_CLASS(segment);

    slant = segment->pattern->slant;
    weight = segment->pattern->weight;

    cr = class->font_ctxts[CAIRO_FONT_INDEX(slant, weight)];

    cairo_text_extents(cr, text, &segment->extents);

    /* Couleurs */

    segment->alt_fg.red = 65535 - segment->pattern->foreground.red;
    segment->alt_fg.green = 65535 - segment->pattern->foreground.green;
    segment->alt_fg.blue = 65535 - segment->pattern->foreground.blue;
    segment->alt_fg.pixel = segment->pattern->foreground.pixel;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : segment = fragment de texte à consulter.                     *
*                ref     = segment de référence servant à la comparaison.     *
*                                                                             *
*  Description : Indique si les textes de deux segments sont identiques.      *
*                                                                             *
*  Retour      : Bilan de la comparaison.                                     *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_buffer_segment_compare(const GBufferSegment *segment, const GBufferSegment *ref)
{
    bool result;                            /* Bilan à retourner           */

    result = (cmp_fnv_64a(segment->hash, ref->hash) == 0);

    result &= (strcmp(segment->text, ref->text) == 0);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : segment = fragment de texte à consulter.                     *
*                                                                             *
*  Description : Fournit le texte brut conservé dans le segment.              *
*                                                                             *
*  Retour      : Texte conservé en interne.                                   *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

const char *g_buffer_segment_get_text(const GBufferSegment *segment)
{
    return segment->text;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : segment = fragment de texte à consulter.                     *
*                                                                             *
*  Description : Fournit la quantité de pixels requise pour l'impression.     *
*                                                                             *
*  Retour      : Largeur requise par la colonne, en pixel.                    *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

gint g_buffer_segment_get_width(const GBufferSegment *segment)
{
    return segment->extents.x_advance;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : segment = fragment de texte à consulter.                     *
*                x       = position horizontale au niveau du segment.         *
*                                                                             *
*  Description : Fournit la position idéale pour un marqueur.                 *
*                                                                             *
*  Retour      : Position dans le segment donné.                              *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

gint g_buffer_segment_get_caret_position(const GBufferSegment *segment, gint x)
{
    gint result;                            /* Position à retourner        */
    gint width;                             /* Largeur du segment          */
    gint char_width;                        /* Largeur de police fixe      */

    width = g_buffer_segment_get_width(segment);

    if (x <= 0)
        result = 0;

    else if (x >= width)
        result = width;

    else
    {
        char_width = width / strlen(segment->text);

        result = (x / char_width) * char_width;
        if ((x % char_width) > (char_width / 2))
            result += char_width;

    }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : segment = fragment de texte à manipuler.                     *
*                style   = style de rendu pour le segment.                    *
*                                                                             *
*  Description : Module l'apparence finale du composant.                      *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_buffer_segment_set_style(GBufferSegment *segment, SegRenderingStyle style)
{
    segment->style = style;

    switch (style)
    {
        default:
        case SRS_CLASSIC:
            segment->used_fg = &segment->pattern->foreground;
            break;

        case SRS_HIGHLIGHT_SAME:

            segment->cache_bg.red = 32768;
            segment->cache_bg.green = 32768;
            segment->cache_bg.blue = 32768;

            segment->used_fg = &segment->alt_fg;

            break;

    }

}


/******************************************************************************
*                                                                             *
*  Paramètres  : segment = fragment de texte à manipuler.                     *
*                cairo   = contexte graphique à utiliser pour les pinceaux.   *
*                x       = abscisse du point d'impression (à maj). [OUT]      *
*                y       = ordonnée du point d'impression.                    *
*                                                                             *
*  Description : Imprime le fragment de texte représenté.                     *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_buffer_segment_draw(GBufferSegment *segment, cairo_t *cairo, gint *x, gint y)
{

    cairo_font_extents_t extents;



    /* Fond du texte */
    if (segment->style != SRS_CLASSIC)
    {
        cairo_set_source_rgb(cairo,
                             segment->cache_bg.red / 65535.0,
                             segment->cache_bg.green / 65535.0,
                             segment->cache_bg.blue / 65535.0);

        cairo_rectangle(cairo, *x, y, segment->extents.x_advance, 17);

        cairo_set_operator(cairo, CAIRO_OPERATOR_DIFFERENCE);
        cairo_fill(cairo);
        cairo_set_operator(cairo, CAIRO_OPERATOR_OVER);

    }

    /* Couleur d'impression */

    if (segment->used_fg->pixel == COLOR_SET)
        cairo_set_source_rgb(cairo,
                             segment->used_fg->red / 65535.0,
                             segment->used_fg->green / 65535.0,
                             segment->used_fg->blue / 65535.0);

    /* Impression du texte */

    cairo_select_font_face(cairo, "mono", segment->pattern->slant, segment->pattern->weight);
    cairo_set_font_size(cairo, 13);




    cairo_move_to(cairo, *x, y + 17 - 3);




    cairo_font_extents(cairo, &extents);

    if (extents.descent != 3)
    printf("FONT : %g, %g\n", extents.ascent, extents.descent);

    cairo_show_text(cairo, segment->text);

    //printf(">> %s >> %f %f\n", segment->text, segment->extents.width, segment->extents.x_advance);

    *x += segment->extents.x_advance;

}