/* Chrysalide - Outil d'analyse de fichiers binaires
* bufferline.c - représentation de fragments de texte en ligne
*
* Copyright (C) 2010-2019 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 .
*/
#include "bufferline.h"
#include "bufferline-int.h"
#if 0
#include
#include
#include
#include "chrysamarshal.h"
//#include "linecolumn.h"
#include "../common/extstr.h"
#include "../core/paths.h"
#endif
/* ---------------------------- GESTION DE LINE COMPLETE ---------------------------- */
/* Procède à l'initialisation d'une classe de représentation. */
static void g_buffer_line_class_init(GBufferLineClass *);
/* Procède à l'initialisation d'une représentation de fragments. */
static void g_buffer_line_init(GBufferLine *);
/* Supprime toutes les références externes. */
static void g_buffer_line_dispose(GBufferLine *);
/* Procède à la libération totale de la mémoire. */
static void g_buffer_line_finalize(GBufferLine *);
/* ---------------------------------------------------------------------------------- */
/* GESTION DE LINE COMPLETE */
/* ---------------------------------------------------------------------------------- */
/* Détermine le type de la représentation de fragments de texte en ligne. */
G_DEFINE_TYPE(GBufferLine, g_buffer_line, G_TYPE_OBJECT);
/******************************************************************************
* *
* Paramètres : class = classe de composant GTK à initialiser. *
* *
* Description : Procède à l'initialisation d'une classe de représentation. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_buffer_line_class_init(GBufferLineClass *class)
{
GObjectClass *object; /* Autre version de la classe */
#ifdef INCLUDE_GTK_SUPPORT
gchar *filename; /* Chemin d'accès à utiliser */
#endif
object = G_OBJECT_CLASS(class);
object->dispose = (GObjectFinalizeFunc/* ! */)g_buffer_line_dispose;
object->finalize = (GObjectFinalizeFunc)g_buffer_line_finalize;
#if 0
#ifdef INCLUDE_GTK_SUPPORT
filename = find_pixmap_file("entrypoint.png");
assert(filename != NULL);
class->entrypoint_img = cairo_image_surface_create_from_png(filename);
g_free(filename);
filename = find_pixmap_file("bookmark.png");
assert(filename != NULL);
class->bookmark_img = cairo_image_surface_create_from_png(filename);
g_free(filename);
#endif
g_signal_new("content-changed",
G_TYPE_BUFFER_LINE,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(GBufferLineClass, content_changed),
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1, G_TYPE_OBJECT);
g_signal_new("flip-flag",
G_TYPE_BUFFER_LINE,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(GBufferLineClass, flip_flag),
NULL, NULL,
g_cclosure_user_marshal_VOID__ENUM_ENUM,
G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_UINT);
#endif
}
/******************************************************************************
* *
* Paramètres : line = composant GLib à initialiser. *
* *
* Description : Procède à l'initialisation d'une représentation de fragments.*
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_buffer_line_init(GBufferLine *line)
{
line->columns = NULL;
line->col_count = 0;
line->merge_start = -1;
}
/******************************************************************************
* *
* Paramètres : line = instance d'objet GLib à traiter. *
* *
* Description : Supprime toutes les références externes. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_buffer_line_dispose(GBufferLine *line)
{
#if 0
size_t i; /* Boucle de parcours */
for (i = 0; i < line->ocount; i++)
g_object_unref(G_OBJECT(line->origins[i].creator));
#endif
G_OBJECT_CLASS(g_buffer_line_parent_class)->dispose(G_OBJECT(line));
}
/******************************************************************************
* *
* Paramètres : line = instance d'objet GLib à traiter. *
* *
* Description : Procède à la libération totale de la mémoire. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_buffer_line_finalize(GBufferLine *line)
{
size_t i; /* Boucle de parcours */
for (i = 0; i < line->col_count; i++)
reset_line_column(&line->columns[i]);
if (line->columns != NULL)
free(line->columns);
#if 0
if (line->origins != NULL)
free(line->origins);
#endif
G_OBJECT_CLASS(g_buffer_line_parent_class)->finalize(G_OBJECT(line));
}
/******************************************************************************
* *
* Paramètres : col_count = quantité de colonnes à considérer. *
* *
* Description : Crée une nouvelle représentation de fragments de texte. *
* *
* Retour : Composant GTK créé. *
* *
* Remarques : - *
* *
******************************************************************************/
GBufferLine *g_buffer_line_new(size_t col_count)
{
GBufferLine *result; /* Composant à retourner */
result = g_object_new(G_TYPE_BUFFER_LINE, NULL);
if (!g_buffer_line_create(result, col_count))
g_clear_object(&result);
return result;
}
/******************************************************************************
* *
* Paramètres : line = ligne de représentation à initialiser. *
* col_count = quantité de colonnes à considérer. *
* *
* Description : Met en place une nouvelle représentation de bribes de texte. *
* *
* Retour : Bilan de l'opération. *
* *
* Remarques : - *
* *
******************************************************************************/
bool g_buffer_line_create(GBufferLine *line, size_t col_count)
{
bool result; /* Bilen à retourner */
size_t i; /* Boucle de parcours */
result = true;
line->columns = malloc(col_count * sizeof(line_column_t));
for (i = 0; i < col_count; i++)
init_line_column(&line->columns[i]);
line->col_count = col_count;
return result;
}
/******************************************************************************
* *
* Paramètres : line = ligne à venir compléter. *
* column = colonne de la ligne visée par l'insertion. *
* tag = type de décorateur à utiliser. *
* text = texte à insérer dans l'existant. *
* length = taille du texte à traiter. *
* style = gestionnaire de paramètres de rendu à consulter. *
* creator = instance GLib quelconque à associer. *
* *
* Description : Ajoute du texte à formater dans une ligne donnée. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_buffer_line_append_text(GBufferLine *line, size_t column, TokenRenderingTag tag, const char *text, size_t length, const GTokenStyle *style, GObject *creator)
{
size_t index; /* Indice d'insertion */
//content_origin *origin; /* Définition d'une origine */
assert(column < line->col_count);
assert(length > 0);
index = append_text_to_line_column(&line->columns[column], tag, text, length, style);
/*
if (creator != NULL)
{
line->origins = realloc(line->origins, ++line->ocount * sizeof(content_origin));
origin = &line->origins[line->ocount - 1];
origin->coord.column = column;
origin->coord.index = index;
origin->creator = creator;
g_object_ref(G_OBJECT(creator));
}
*/
}
/******************************************************************************
* *
* Paramètres : line = ligne de texte à manipuler. *
* cr = contexte graphique dédié à la procédure. *
* column = (première) colonne à traiter. *
* y = ordonnée du point d'impression. *
* style = style de rendu pour les bribes de texte. *
* *
* Description : Imprime la ligne de texte représentée. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_buffer_line_draw(const GBufferLine *line, cairo_t *cr, size_t column, int y, const GTokenStyle *style)
{
#if 0
GBufferLineClass *class; /* Stockage de briques de base */
bool has_src_surface; /* Note une présence définie */
#endif
size_t max_column; /* Borne de fin des colonnes */
int x; /* Point de départ d'impression*/
size_t i; /* Boucle de parcours */
/*
if (line->flags != BLF_NONE)
{
class = G_BUFFER_LINE_GET_CLASS(line);
if (line->flags & BLF_ENTRYPOINT)
{
cairo_set_source_surface(cairo, class->entrypoint_img, 5, y);
has_src_surface = true;
}
else if (line->flags & BLF_BOOKMARK)
{
cairo_set_source_surface(cairo, class->bookmark_img, 5, y);
has_src_surface = true;
}
else
has_src_surface = false;
if (has_src_surface)
cairo_paint(cairo);
}
*/
/* Détermination de l'éventail des colonnes à traiter */
if (column == line->merge_start)
max_column = line->col_count;
else if (column > line->merge_start)
max_column = 0;
else
max_column = column + 1;
/* Dessin du contenu de ces colonnes */
x = 0;
for (i = column; i < max_column; i++)
draw_line_column(&line->columns[i], cr, &x, y, style);
}
#if 0
/******************************************************************************
* *
* Paramètres : line = ligne à venir compléter. *
* col = indice de la colonne à constituer. *
* size = taille souhaitée de l'impression des positions. *
* addr = localisation physique à venir représenter. *
* *
* Description : Construit le tronc commun d'une ligne autour de sa position. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_buffer_line_fill_phys(GBufferLine *line, size_t col, MemoryDataSize size, const vmpa2t *addr)
{
VMPA_BUFFER(position); /* Emplacement au format texte */
size_t len; /* Taille de l'élément inséré */
size_t i; /* Boucle de parcours #1 */
vmpa2_phys_to_string(addr, size, position, &len);
for (i = 2; i < len; i++)
if (position[i] != '0') break;
if (i == len)
i = len - 1;
if (i > 0)
g_buffer_line_append_text(line, col, position, i, RTT_PHYS_ADDR_PAD, NULL);
g_buffer_line_append_text(line, col, &position[i], len - i, RTT_PHYS_ADDR, NULL);
}
/******************************************************************************
* *
* Paramètres : line = ligne à venir compléter. *
* col = indice de la colonne à constituer. *
* size = taille souhaitée de l'impression des positions. *
* addr = localisation virtuelle à venir représenter. *
* *
* Description : Construit le tronc commun d'une ligne autour de sa position. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_buffer_line_fill_virt(GBufferLine *line, size_t col, MemoryDataSize size, const vmpa2t *addr)
{
VMPA_BUFFER(position); /* Emplacement au format texte */
size_t len; /* Taille de l'élément inséré */
size_t i; /* Boucle de parcours #1 */
vmpa2_virt_to_string(addr, size, position, &len);
if (has_virt_addr(addr))
{
for (i = 2; i < len; i++)
if (position[i] != '0') break;
if (i == len)
i = len - 1;
if (i > 0)
g_buffer_line_append_text(line, col, position, i, RTT_VIRT_ADDR_PAD, NULL);
g_buffer_line_append_text(line, col, &position[i], len - i, RTT_VIRT_ADDR, NULL);
}
else
g_buffer_line_append_text(line, col, position, len, RTT_VIRT_ADDR_PAD, NULL);
}
/******************************************************************************
* *
* Paramètres : line = ligne à venir compléter. *
* col = indice de la colonne à constituer. *
* content = contenu binaire global à venir lire. *
* range = localisation des données à venir lire et présenter.*
* max = taille maximale de la portion binaire en octets. *
* *
* Description : Construit le tronc commun d'une ligne autour de son contenu. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_buffer_line_fill_content(GBufferLine *line, size_t col, const GBinContent *content, const mrange_t *range, phys_t max)
{
phys_t length; /* Taille de la couverture */
bool truncated; /* Indique si le code est coupé*/
size_t required; /* Taille de traitement requise*/
char static_buffer[64]; /* Petit tampon local rapide */
char *bin_code; /* Tampon utilisé pour le code */
vmpa2t pos; /* Boucle de parcours #1 */
phys_t i; /* Boucle de parcours #2 */
char *iter; /* Boucle de parcours #3 */
int ret; /* Progression dans l'écriture */
uint8_t byte; /* Octet à représenter */
static const char *charset = "0123456789abcdef";
/* Détermination du réceptacle */
length = get_mrange_length(range);
truncated = (max != VMPA_NO_PHYSICAL && length > max);
if (truncated)
{
length = max;
required = length * 3 + 4 /* "..." */ + 1;
}
else
required = length * 3 + 1;
if (required <= sizeof(static_buffer))
bin_code = static_buffer;
else
bin_code = (char *)calloc(required, sizeof(char));
/* Code brut */
copy_vmpa(&pos, get_mrange_addr(range));
for (i = 0, iter = bin_code; i < length; i++, iter += ret)
{
if (i == 0)
ret = 0;
else
{
iter[0] = ' ';
ret = 1;
}
if (!g_binary_content_read_u8(content, &pos, &byte))
{
iter[ret + 0] = '?';
iter[ret + 1] = '?';
}
else
{
iter[ret + 0] = charset[byte >> 4];
iter[ret + 1] = charset[byte & 0x0f];
}
ret += 2;
}
if (truncated)
{
strcpy(iter, "...");
iter += 3;
}
else
*iter = '\0';
/* Conclusion */
g_buffer_line_append_text(line, col, bin_code, iter - bin_code, RTT_RAW_CODE, NULL);
if (bin_code != static_buffer)
free(bin_code);
}
/******************************************************************************
* *
* Paramètres : line = ligne à venir consulter. *
* column = indice de la colonne visée par les recherches. *
* *
* Description : Recherche le premier créateur enregistré dans des segments. *
* *
* Retour : Créateur trouvé à déréférencer par la suite ou NULL si échec.*
* *
* Remarques : - *
* *
******************************************************************************/
GObject *g_buffer_line_find_first_segment_creator(const GBufferLine *line, size_t column)
{
GObject *result; /* Trouvaille à retourner */
size_t i; /* Boucle de parcours */
assert(column < line->col_count);
result = NULL;
for (i = 0; i < line->ocount && result == NULL; i++)
{
if (line->origins[i].coord.column == column)
result = line->origins[i].creator;
}
if (result != NULL)
g_object_ref(G_OBJECT(result));
return result;
}
/******************************************************************************
* *
* Paramètres : line = ligne à venir compléter. *
* column = colonne de la ligne visée par l'insertion. *
* text = texte à insérer dans l'existant. *
* length = taille du texte à traiter. *
* type = type de décorateur à utiliser. *
* creator = instance GLib quelconque à associer. *
* *
* Description : Ajoute du texte à formater dans une ligne donnée. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_buffer_line_append_text(GBufferLine *line, size_t column, const char *text, size_t length, RenderingTagType type, GObject *creator)
{
size_t index; /* Indice d'insertion */
content_origin *origin; /* Définition d'une origine */
assert(column < line->col_count);
assert(length > 0);
index = append_text_to_line_column(&line->columns[column], text, length, type);
if (creator != NULL)
{
line->origins = realloc(line->origins, ++line->ocount * sizeof(content_origin));
origin = &line->origins[line->ocount - 1];
origin->coord.column = column;
origin->coord.index = index;
origin->creator = creator;
g_object_ref(G_OBJECT(creator));
}
}
/******************************************************************************
* *
* Paramètres : line = ligne à venir compléter. *
* creator = instance GLib quelconque identifiant un segment. *
* text = texte à insérer dans l'existant. *
* length = taille du texte à traiter. *
* *
* Description : Remplace du texte dans une ligne donnée. *
* *
* Retour : Bilan de l'opération. *
* *
* Remarques : - *
* *
******************************************************************************/
bool g_buffer_line_replace_text(GBufferLine *line, const GObject *creator, const char *text, size_t length)
{
bool result; /* Bilan à retourner */
size_t i; /* Boucle de parcours */
const col_coord_t *coord; /* Emplacement du contenu visé */
result = false;
for (i = 0; i < line->ocount && !result; i++)
{
if (line->origins[i].creator == creator)
{
coord = &line->origins[i].coord;
replace_text_in_line_column(&line->columns[coord->column], coord->index, text, length);
g_signal_emit_by_name(line, "content-changed", NULL);
result = true;
}
}
return result;
}
/******************************************************************************
* *
* Paramètres : line = ligne à venir consulter. *
* first = première colonne à parcourir. *
* end = colonne de fin de parcours. *
* *
* Description : Indique si du texte est présent dans une ligne de tampon. *
* *
* Retour : true pour indiquer la présence de texte, false pour du vide. *
* *
* Remarques : - *
* *
******************************************************************************/
bool g_buffer_line_has_text(const GBufferLine *line, size_t first, size_t end)
{
bool result; /* Bilan à retourner */
size_t i; /* Boucle de parcours */
result = false;
assert(first < end);
for (i = first; i < end && !result; i++)
result = (line->columns[i].count > 0);
return result;
}
/******************************************************************************
* *
* Paramètres : line = ligne à venir consulter. *
* first = première colonne à parcourir. *
* end = colonne de fin de parcours. *
* markup = indique si le texte doit être décoré ou non. *
* *
* Description : Donne le texte représenté par une ligne de tampon. *
* *
* Retour : Texte à libérer de la mémoire après usage. *
* *
* Remarques : - *
* *
******************************************************************************/
char *g_buffer_line_get_text(const GBufferLine *line, size_t first, size_t end, bool markup)
{
char *result; /* Construction à retourner */
size_t i; /* Boucle de parcours */
char *extra; /* Contenu à intégrer au texte */
result = NULL;
assert(first < end);
for (i = first; i < end; i++)
{
if (i > first && result != NULL)
result = stradd(result, " ");
extra = get_line_column_text(&line->columns[i], markup);
/* Si la colonne était vide, suivante ! */
if (extra == NULL) continue;
if (result == NULL)
result = extra;
else
{
result = stradd(result, extra);
free(extra);
}
}
return result;
}
/******************************************************************************
* *
* Paramètres : line = ligne à venir modifier. *
* first = première colonne à parcourir. *
* end = colonne de fin de parcours. *
* *
* Description : Supprime du texte représenté par une ligne de tampon. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_buffer_line_delete_text(GBufferLine *line, size_t first, size_t end)
{
size_t i; /* Boucle de parcours */
assert(first < end);
for (i = first; i < end; i++)
reset_line_column(&line->columns[i]);
}
/******************************************************************************
* *
* Paramètres : line = ligne à venir consulter. *
* *
* Description : Fournit la colonne à partir de laquelle une fusion opère. *
* *
* Retour : Début de la première (et unique) zone globale. *
* *
* Remarques : - *
* *
******************************************************************************/
size_t g_buffer_line_get_merge_start(const GBufferLine *line)
{
return line->merge_start;
}
/******************************************************************************
* *
* Paramètres : line = ligne à venir compléter. *
* start = début de la première (et unique) zone globale. *
* *
* Description : Définit la colonne à partir de laquelle la fusion opère. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_buffer_line_start_merge_at(GBufferLine *line, size_t start)
{
line->merge_start = start;
}
/******************************************************************************
* *
* Paramètres : line = ligne à venir compléter. *
* flag = propriété à intégrer. *
* *
* Description : Ajoute une propriété particulière à une ligne donnée. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_buffer_line_add_flag(GBufferLine *line, BufferLineFlags flag)
{
if ((line->flags & flag) == 0)
{
g_signal_emit_by_name(line, "flip-flag", line->flags, flag);
line->flags |= flag;
}
}
/******************************************************************************
* *
* Paramètres : line = ligne à venir consulter. *
* *
* Description : Renseigne sur les propriétés particulières liées à une ligne.*
* *
* Retour : Propriétés intégrées. *
* *
* Remarques : - *
* *
******************************************************************************/
BufferLineFlags g_buffer_line_get_flags(const GBufferLine *line)
{
return line->flags;
}
/******************************************************************************
* *
* Paramètres : line = ligne à venir compléter. *
* flag = propriété à supprimer. *
* *
* Description : Retire une propriété particulière à une ligne donnée. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_buffer_line_remove_flag(GBufferLine *line, BufferLineFlags flag)
{
if ((line->flags & flag) != 0)
{
g_signal_emit_by_name(line, "flip-flag", line->flags, flag);
line->flags &= ~flag;
}
}
/******************************************************************************
* *
* Paramètres : line = ligne de texte à manipuler. *
* ctx = éléments à disposition pour l'exportation. *
* type = type d'exportation attendue. *
* col_count = quantité de colonnes existantes au total. *
* options = règles d'affichage des colonnes modulables. *
* *
* Description : Exporte la ligne de texte représentée. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_buffer_line_export(GBufferLine *line, buffer_export_context *ctx, BufferExportType type, const GDisplayOptions *options)
{
size_t opt_count; /* Qté de colonnes en option */
size_t i; /* Boucle de parcours */
int col_span; /* Fusion de colonnes ? */
switch (type)
{
case BET_HTML:
dprintf(ctx->fd, "\t\n");
break;
default:
break;
}
opt_count = g_display_options_count(options);
assert(opt_count < line->col_count);
for (i = 0; i < line->col_count; i++)
{
if (i < opt_count)
{
if (!g_display_options_get(options, i))
continue;
}
switch (type)
{
case BET_TEXT:
if (i > 0) dprintf(ctx->fd, "%s", ctx->sep);
break;
default:
break;
}
/**
* Pour la signification des différentes valeurs assignées,
* se référer au code de export_line_column_segments().
*
* En gros :
* - 1 = rien de spécial.
* - >1 = il s'agit de la première cellule fusionnée de la ligne.
* - 0 = fusion déjà faite, on ne peut que rajouter du contenu dedans.
* - <1 = il s'agit de la dernière cellule fusionnée de la ligne.
*
* On considère qu'une fusion ne peut pas se réaliser sur la dernière
* cellule uniquement (ce qui a du sens : c'est inutile).
*/
if (i < line->merge_start)
col_span = 1;
else if (i == line->merge_start)
col_span = line->col_count - i;
else
col_span = ((i + 1) == line->col_count ? -1 : 0);
export_line_column_segments(&line->columns[i], ctx, type, col_span);
}
switch (type)
{
case BET_TEXT:
dprintf(ctx->fd, "\n");
break;
case BET_HTML:
dprintf(ctx->fd, "
\n");
break;
default:
break;
}
}
/*----------------------------------------------------------------------------------- */
/* MANIPULATION DES LARGEURS REQUISES */
/* ---------------------------------------------------------------------------------- */
#ifdef INCLUDE_GTK_SUPPORT
/******************************************************************************
* *
* Paramètres : line = ligne à venir consulter. *
* col_count = quantité de colonnes à considérer. *
* opt_count = quantité de colonnes optionnelles. *
* widths = largeur mesurée pour chacune des colonnes. [OUT] *
* merged = largeur cumulée en cas de fusion. [OUT] *
* *
* Description : Fait remonter les largeurs requises par une ligne donnée. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_buffer_line_collect_widths(const GBufferLine *line, size_t col_count, size_t opt_count, gint *widths, gint *merged)
{
size_t i; /* Boucle de parcours */
gint width; /* Largeur d'une colonne */
assert(col_count == line->col_count);
*merged = 0;
for (i = 0; i < col_count; i++)
{
width = get_column_width(&line->columns[i]);
widths[i] = (i < line->merge_start ? width : 0);
if (line->merge_start != -1 && i >= opt_count)
{
*merged += width;
if (i < line->merge_start && (i + 1) < col_count)
*merged += COL_MARGIN;
}
}
}
/******************************************************************************
* *
* Paramètres : line = ligne à venir consulter. *
* coord = coordonnées interne du segment à retrouver. *
* *
* Description : Fournit le segment présent à une position donnée. *
* *
* Retour : Segment trouvé ou NULL si hors borne. *
* *
* Remarques : - *
* *
******************************************************************************/
line_segment *g_buffer_line_get_segment_from_coord(const GBufferLine *line, const col_coord_t *coord)
{
line_segment *result; /* Trouvaille à retourner */
if (coord->column < line->col_count)
result = get_line_column_content_from_index(&line->columns[coord->column], coord->index);
else
result = NULL;
return result;
}
/******************************************************************************
* *
* Paramètres : line = ligne à venir consulter. *
* index = indice de ligne associé. *
* tracker = gestionnaire de largeur à consulter au besoin. *
* options = règles d'affichage des colonnes modulables. *
* offsets = décalages supplémentaires à appliquer. *
* base = position jusqu'au segment trouvé. [OUT] *
* offset = position à la colonne visée. [OUT] *
* dir = direction d'un éventuel déplacement en cours. *
* force = accepte les segments en bordure au pire. *
* coord = cordonnées à usage interne à renseigner. [OUT] *
* *
* Description : Fournit les coordonnées correspondant à une abscisse donnée. *
* *
* Retour : true si des coordonnées valides ont été renseignées. *
* *
* Remarques : - *
* *
******************************************************************************/
bool g_buffer_line_get_coord_at(const GBufferLine *line, size_t index, GWidthTracker *tracker, const GDisplayOptions *options, gint *base, gint *offset, GdkScrollDirection dir, bool force, col_coord_t *coord)
{
bool result; /* Bilan à retourner */
size_t last; /* Dernière colonne remplie */
gint last_base; /* Dernière abscisse associée */
size_t col_count; /* Qté de colonnes présentes */
size_t opt_count; /* Qté de colonnes en option */
size_t i; /* Boucle de parcours */
gint width; /* Largeur d'une colonne donnée*/
gint limit; /* Limite d'appartenance */
gint consumed; /* Distance vers le segment */
gint old_base; /* Somme de toutes les largeurs*/
result = false;
*base = 0;
last = line->col_count;
last_base = 0;
/* On cible déjà la colonne idéale */
col_count = g_width_tracker_count_columns(tracker);
opt_count = g_display_options_count(options);
for (i = 0; i < col_count; i++)
{
if (i < opt_count)
{
if (!g_display_options_get(options, i))
continue;
}
/* Mémorisation de la dernière colonne contenant quelque chose... */
if (get_column_width(&line->columns[i]) > 0)
{
last = i;
last_base = *base;
}
if (i < line->merge_start)
{
width = g_width_tracker_get_local_column_width(tracker, index, i, opt_count);
/* Si la colonne n'est absolument pas visible, on ne s'arrête pas dessus ! */
if (width == 0) continue;
if ((i + 1) < col_count) limit = width + COL_MARGIN / 2;
else limit = width;
if (*offset <= limit) break;
else
{
*offset -= width + COL_MARGIN;
*base += width + COL_MARGIN;
}
}
else
{
width = get_column_width(&line->columns[i]);
if (*offset <= width) break;
else
{
*offset -= width;
*base += width;
}
}
}
/* Si l'abscisse fournie tombe encore dans une colonne... */
if (i < col_count)
{
/* Il y a bien du contenu dans cette colonne */
if (get_column_width(&line->columns[i]) > 0)
{
/**
* Si la position était au milieu d'une marge, la sélection a pu pousser
* jusqu'à la colonne suivante, plus proche.
* Relativment à la base de cette dernière, la position est donc devenue négative.
*/
if (*offset < 0) *offset = 0;
result = get_line_column_content_index_at(&line->columns[i], offset, dir, &consumed, &coord->index);
if (result)
{
coord->column = i;
*base += consumed;
}
}
/* La position fournie tombe dans une colonne vide ! */
else
{
if (force || get_column_width(&line->columns[i]) == 0)
{
result = false;
*offset = 0;
old_base = *base;
for (i++; i < col_count && !result; i++)
{
if ((i - 1) < line->merge_start)
{
width = g_width_tracker_get_local_column_width(tracker, index, i - 1, opt_count);
if (width > 0)
*base += (width + COL_MARGIN);
}
else
*base += get_column_width(&line->columns[i - 1]);
result = get_line_column_first_content_index(&line->columns[i], &coord->index);
if (result)
coord->column = i;
}
if (!result)
{
*base = old_base;
goto use_right_border;
}
}
}
}
else /* if (i == col_count) */
{
if (force)
{
use_right_border:
if (last != col_count)
{
result = get_line_column_last_content_index(&line->columns[last], &coord->index);
if (result)
{
coord->column = last;
*base = last_base;
*offset = get_column_width(&line->columns[last]);
}
}
/* Il n'y a rien sur la ligne ! */
else
{
result = true;
*base = 0;
*offset = 0;
coord->column = col_count;
coord->index = -1;
}
}
else
result = false;
}
return result;
}
/******************************************************************************
* *
* Paramètres : line = ligne à venir consulter. *
* index = indice de ligne associé. *
* tracker = gestionnaire de largeur à consulter au besoin. *
* options = règles d'affichage des colonnes modulables. *
* base = position jusqu'au segment trouvé. [OUT] *
* offset = position à la colonne visée. [OUT] *
* dir = direction d'un éventuel déplacement en cours. *
* force = accepte les segments en bordure au pire. *
* *
* Description : Donne le segment présent à une abscisse donnée. *
* *
* Retour : Segment trouvé ou NULL si hors borne. *
* *
* Remarques : - *
* *
******************************************************************************/
line_segment *g_buffer_line_get_segment_at(const GBufferLine *line, size_t index, GWidthTracker *tracker, const GDisplayOptions *options, gint *base, gint *offset, GdkScrollDirection dir, bool force)
{
line_segment *result; /* Trouvaille à retourner */
col_coord_t coord; /* Emplacement du contenu visé */
bool status; /* Bilan de la localisation */
status = g_buffer_line_get_coord_at(line, index, tracker, options, base, offset, dir, force, &coord);
if (status)
result = g_buffer_line_get_segment_from_coord(line, &coord);
else
result = NULL;
return result;
}
/******************************************************************************
* *
* Paramètres : line = ligne à venir consulter. *
* index = indice de ligne associé. *
* tracker = gestionnaire de largeur à consulter au besoin. *
* options = règles d'affichage des colonnes modulables. *
* base = position jusqu'au segment trouvé. [OUT] *
* offset = position à la colonne visée. [OUT] *
* dir = direction d'un éventuel déplacement en cours. *
* force = accepte les segments en bordure au pire. *
* *
* Description : Donne le créateur présent à une abscisse donnée. *
* *
* Retour : Créateur trouvé ou NULL si hors borne. *
* *
* Remarques : - *
* *
******************************************************************************/
GObject *g_buffer_line_get_creator_at(const GBufferLine *line, size_t index, GWidthTracker *tracker, const GDisplayOptions *options, gint *base, gint *offset, GdkScrollDirection dir, bool force)
{
GObject *result; /* Trouvaille à retourner */
col_coord_t target; /* Emplacement du contenu visé */
bool status; /* Bilan de la localisation */
size_t i; /* Boucle de parcours */
const col_coord_t *coord; /* Emplacement du contenu visé */
result = NULL;
status = g_buffer_line_get_coord_at(line, index, tracker, options, base, offset, dir, force, &target);
if (status)
{
for (i = 0; i < line->ocount && result == NULL; i++)
{
coord = &line->origins[i].coord;
if (coord->column == target.column && coord->index == target.index)
result = line->origins[i].creator;
}
if (result != NULL)
g_object_ref(G_OBJECT(result));
}
return result;
}
/******************************************************************************
* *
* Paramètres : line = ligne à venir consulter. *
* index = indice de ligne associé. *
* coord = cordonnées à consulter puis renseigner. [OUT] *
* tracker = gestionnaire de largeur à consulter au besoin. *
* options = règles d'affichage des colonnes modulables. *
* dir = orientation des recherches. *
* offset = décalage pour amener à l'extrémité nouvelle. [OUT] *
* *
* Description : Fournit des coordonnées voisines selon une direction donnée. *
* *
* Retour : true si des coordonnées valides ont été renseignées. *
* *
* Remarques : - *
* *
******************************************************************************/
bool g_buffer_line_find_near_coord(const GBufferLine *line, size_t index, col_coord_t *coord, GWidthTracker *tracker, const GDisplayOptions *options, GdkScrollDirection dir, gint *offset)
{
bool result; /* Bilan à retourner */
size_t col_count; /* Qté de colonnes présentes */
size_t i; /* Boucle de parcours #1 */
size_t opt_count; /* Qté de colonnes en option */
bool displayed; /* Confort de lecture */
size_t k; /* Boucle de parcours #2 */
gint width; /* Largeur d'une colonne donnée*/
result = false;
col_count = g_width_tracker_count_columns(tracker);
/* Recherche dans la colonne de départ */
i = coord->column;
if (i == col_count) return false;
result = find_near_segment(&line->columns[i], &coord->index, dir);
/* Recherche dans la direction des colonnes voisines */
opt_count = g_display_options_count(options);
if (!result)
switch (dir)
{
case GDK_SCROLL_LEFT:
/* Si on a atteint la première colonne sans trouver... */
if (i == 0) break;
/* On s'assure que la colonne précédente est visible et peuplée */
for (; i > 0 && !result; i--)
{
displayed = (i <= opt_count ? g_display_options_get(options, i - 1) : true);
if (displayed)
{
result = get_line_column_first_content_index(&line->columns[i - 1], &coord->index);
if (result)
coord->column = i - 1;
}
}
break;
case GDK_SCROLL_RIGHT:
/* On s'assure que la colonne suivante est visible et peuplée */
for (; (i + 1) < col_count && !result; i++)
{
displayed = ((i + 1) < opt_count ? g_display_options_get(options, i + 1) : true);
if (displayed)
{
result = get_line_column_first_content_index(&line->columns[i + 1], &coord->index);
if (result)
coord->column = i + 1;
}
}
break;
default:
break;
}
/* Calcul de la position finale */
if (result)
{
*offset = 0;
for (k = 0; k < i; k++)
{
displayed = (k < opt_count ? g_display_options_get(options, k) : true);
if (displayed)
{
if (k >= line->merge_start)
width = get_column_width(&line->columns[index]);
else
width = g_width_tracker_get_local_column_width(tracker, index, k, opt_count);
if (width > 0)
{
*offset += width;
if (k < line->merge_start) *offset += COL_MARGIN;
}
}
}
switch (dir)
{
case GDK_SCROLL_LEFT:
*offset += get_column_width(&line->columns[i]);
break;
case GDK_SCROLL_RIGHT:
/**offset += 0;*/
break;
default:
break;
}
}
return result;
}
/******************************************************************************
* *
* Paramètres : line = ligne de texte à manipuler. *
* index = indice de ligne associé. *
* cairo = contexte graphique à utiliser pour les pinceaux. *
* x_init = abscisse du point d'impression de départ. *
* y = ordonnée du point d'impression. *
* tracker = gestionnaire de largeur à consulter au besoin. *
* options = règles d'affichage des colonnes modulables. *
* list = liste de contenus à mettre en évidence. *
* *
* Description : Imprime la ligne de texte représentée. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_buffer_line_draw(GBufferLine *line, size_t index, cairo_t *cairo, gint x_init, gint y, GWidthTracker *tracker, const GDisplayOptions *options, const segcnt_list *list)
{
GBufferLineClass *class; /* Stockage de briques de base */
bool has_src_surface; /* Note une présence définie */
gint x; /* Point de départ d'impression*/
size_t col_count; /* Qté de colonnes présentes */
size_t opt_count; /* Qté de colonnes en option */
size_t i; /* Boucle de parcours */
gint max_width; /* Largeur maximale de colonne */
if (line->flags != BLF_NONE)
{
class = G_BUFFER_LINE_GET_CLASS(line);
if (line->flags & BLF_ENTRYPOINT)
{
cairo_set_source_surface(cairo, class->entrypoint_img, 5, y);
has_src_surface = true;
}
else if (line->flags & BLF_BOOKMARK)
{
cairo_set_source_surface(cairo, class->bookmark_img, 5, y);
has_src_surface = true;
}
else
has_src_surface = false;
if (has_src_surface)
cairo_paint(cairo);
}
x = x_init;
col_count = g_width_tracker_count_columns(tracker);
opt_count = g_display_options_count(options);
for (i = 0; i < col_count; i++)
{
if (i < opt_count)
{
if (!g_display_options_get(options, i))
continue;
}
draw_line_column_segments(&line->columns[i], cairo, x, y, list);
if (i < line->merge_start)
{
max_width = g_width_tracker_get_local_column_width(tracker, index, i, opt_count);
if (max_width > 0)
x += max_width + COL_MARGIN;
}
}
}
#endif
#endif