Ignore:
Timestamp:
Sep 27, 2008, 3:12:46 PM (11 years ago)
Author:
Sam Hocevar
Message:

Starting refactoring to get rid of libcucul. The initial reason for the
split is rendered moot by the plugin system: when enabled, binaries do
not link directly with libX11 or libGL. I hope this is a step towards
more consisteny and clarity.

File:
1 copied

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/caca/figfont.c

    r2819 r2821  
    11/*
    2  *  libcucul      Canvas for ultrafast compositing of Unicode letters
     2 *  libcaca       Colour ASCII-Art library
    33 *  Copyright (c) 2006-2007 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
     
    2929#endif
    3030
    31 #include "cucul.h"
    32 #include "cucul_internals.h"
    33 
    34 struct cucul_figfont
     31#include "caca.h"
     32#include "caca_internals.h"
     33
     34struct caca_figfont
    3535{
    3636    int term_width;
     
    4444    int print_direction, full_layout, codetag_count;
    4545    int glyphs;
    46     cucul_canvas_t *fontcv, *charcv;
     46    caca_canvas_t *fontcv, *charcv;
    4747    int *left, *right; /* Unused yet */
    4848    uint32_t *lookup;
     
    5050
    5151static uint32_t hsmush(uint32_t ch1, uint32_t ch2, int rule);
    52 static cucul_figfont_t * open_figfont(char const *);
    53 static int free_figfont(cucul_figfont_t *);
    54 
    55 int cucul_canvas_set_figfont(cucul_canvas_t *cv, char const *path)
    56 {
    57     cucul_figfont_t *ff = NULL;
     52static caca_figfont_t * open_figfont(char const *);
     53static int free_figfont(caca_figfont_t *);
     54
     55int caca_canvas_set_figfont(caca_canvas_t *cv, char const *path)
     56{
     57    caca_figfont_t *ff = NULL;
    5858
    5959    if(path)
     
    6666    if(cv->ff)
    6767    {
    68         cucul_free_canvas(cv->ff->charcv);
     68        caca_free_canvas(cv->ff->charcv);
    6969        free(cv->ff->left);
    7070        free(cv->ff->right);
     
    8585    ff->w = ff->h = 0;
    8686    ff->lines = 0;
    87     cucul_set_canvas_size(cv, 0, 0); /* XXX */
     87    caca_set_canvas_size(cv, 0, 0); /* XXX */
    8888
    8989    /* from TOIlet’s figlet.c */
     
    118118    }
    119119
    120     ff->charcv = cucul_create_canvas(ff->max_length - 2, ff->height);
     120    ff->charcv = caca_create_canvas(ff->max_length - 2, ff->height);
    121121
    122122    ff->left = malloc(ff->height * sizeof(int));
     
    128128}
    129129
    130 int cucul_put_figchar(cucul_canvas_t *cv, uint32_t ch)
    131 {
    132     cucul_figfont_t *ff = cv->ff;
     130int caca_put_figchar(caca_canvas_t *cv, uint32_t ch)
     131{
     132    caca_figfont_t *ff = cv->ff;
    133133    int c, w, h, x, y, overlap, extra, xleft, xright;
    134134
     
    155155    h = ff->height;
    156156
    157     cucul_set_canvas_handle(ff->fontcv, 0, c * ff->height);
    158     cucul_blit(ff->charcv, 0, 0, ff->fontcv, NULL);
     157    caca_set_canvas_handle(ff->fontcv, 0, c * ff->height);
     158    caca_blit(ff->charcv, 0, 0, ff->fontcv, NULL);
    159159
    160160    /* Check whether we reached the end of the screen */
     
    177177            /* Compute how much spaces we can eat from the new glyph */
    178178            for(xright = 0; xright < overlap; xright++)
    179                 if(cucul_get_char(ff->charcv, xright, y) != ' ')
     179                if(caca_get_char(ff->charcv, xright, y) != ' ')
    180180                    break;
    181181
    182182            /* Compute how much spaces we can eat from the previous glyph */
    183183            for(xleft = 0; xright + xleft < overlap && xleft < ff->x; xleft++)
    184                 if(cucul_get_char(cv, ff->x - 1 - xleft, ff->y + y) != ' ')
     184                if(caca_get_char(cv, ff->x - 1 - xleft, ff->y + y) != ' ')
    185185                    break;
    186186
     
    193193            {
    194194                if(xleft < ff->x &&
    195                     hsmush(cucul_get_char(cv, ff->x - 1 - xleft, ff->y + y),
    196                           cucul_get_char(ff->charcv, xright, y),
     195                    hsmush(caca_get_char(cv, ff->x - 1 - xleft, ff->y + y),
     196                          caca_get_char(ff->charcv, xright, y),
    197197                          ff->hsmushrule))
    198198                    xleft++;
     
    220220#if 0 /* deactivated for libcaca insertion */
    221221    if(attr)
    222         cucul_set_attr(cv, attr);
     222        caca_set_attr(cv, attr);
    223223#endif
    224     cucul_set_canvas_size(cv, ff->w, ff->h);
    225 
    226     /* Render our char (FIXME: create a rect-aware cucul_blit_canvas?) */
     224    caca_set_canvas_size(cv, ff->w, ff->h);
     225
     226    /* Render our char (FIXME: create a rect-aware caca_blit_canvas?) */
    227227    for(y = 0; y < h; y++)
    228228        for(x = 0; x < w; x++)
    229229    {
    230230        uint32_t ch1, ch2;
    231         //uint32_t tmpat = cucul_get_attr(ff->fontcv, x, y + c * ff->height);
    232         ch2 = cucul_get_char(ff->charcv, x, y);
     231        //uint32_t tmpat = caca_get_attr(ff->fontcv, x, y + c * ff->height);
     232        ch2 = caca_get_char(ff->charcv, x, y);
    233233        if(ch2 == ' ')
    234234            continue;
    235         ch1 = cucul_get_char(cv, ff->x + x - overlap, ff->y + y);
    236         /* FIXME: this could be changed to cucul_put_attr() when the
    237          * function is fixed in libcucul */
    238         //cucul_set_attr(cv, tmpat);
     235        ch1 = caca_get_char(cv, ff->x + x - overlap, ff->y + y);
     236        /* FIXME: this could be changed to caca_put_attr() when the
     237         * function is fixed in libcaca */
     238        //caca_set_attr(cv, tmpat);
    239239        if(ch1 == ' ' || ff->hmode != H_SMUSH)
    240             cucul_put_char(cv, ff->x + x - overlap, ff->y + y, ch2);
     240            caca_put_char(cv, ff->x + x - overlap, ff->y + y, ch2);
    241241        else
    242             cucul_put_char(cv, ff->x + x - overlap, ff->y + y,
     242            caca_put_char(cv, ff->x + x - overlap, ff->y + y,
    243243                           hsmush(ch1, ch2, ff->hsmushrule));
    244         //cucul_put_attr(cv, ff->x + x, ff->y + y, tmpat);
     244        //caca_put_attr(cv, ff->x + x, ff->y + y, tmpat);
    245245    }
    246246
     
    251251}
    252252
    253 int cucul_flush_figlet(cucul_canvas_t *cv)
    254 {
    255     cucul_figfont_t *ff = cv->ff;
     253int caca_flush_figlet(caca_canvas_t *cv)
     254{
     255    caca_figfont_t *ff = cv->ff;
    256256    int x, y;
    257257
    258258    //ff->torender = cv;
    259     //cucul_set_canvas_size(ff->torender, ff->w, ff->h);
    260     cucul_set_canvas_size(cv, ff->w, ff->h);
     259    //caca_set_canvas_size(ff->torender, ff->w, ff->h);
     260    caca_set_canvas_size(cv, ff->w, ff->h);
    261261
    262262    /* FIXME: do this somewhere else, or record hardblank positions */
    263263    for(y = 0; y < ff->h; y++)
    264264        for(x = 0; x < ff->w; x++)
    265             if(cucul_get_char(cv, x, y) == 0xa0)
    266             {
    267                 uint32_t attr = cucul_get_attr(cv, x, y);
    268                 cucul_put_char(cv, x, y, ' ');
    269                 cucul_put_attr(cv, x, y, attr);
     265            if(caca_get_char(cv, x, y) == 0xa0)
     266            {
     267                uint32_t attr = caca_get_attr(cv, x, y);
     268                caca_put_char(cv, x, y, ' ');
     269                caca_put_attr(cv, x, y, attr);
    270270            }
    271271
     
    273273    ff->w = ff->h = 0;
    274274
    275     //cv = cucul_create_canvas(1, 1); /* XXX */
     275    //cv = caca_create_canvas(1, 1); /* XXX */
    276276
    277277    /* from render.c */
    278     ff->lines += cucul_get_canvas_height(cv);
     278    ff->lines += caca_get_canvas_height(cv);
    279279
    280280    return 0;
     
    284284#define EXT_GLYPHS (STD_GLYPHS + 7)
    285285
    286 static cucul_figfont_t * open_figfont(char const *path)
     286static caca_figfont_t * open_figfont(char const *path)
    287287{
    288288    char altpath[2048];
    289289    char buf[2048];
    290290    char hardblank[10];
    291     cucul_figfont_t *ff;
     291    caca_figfont_t *ff;
    292292    char *data = NULL;
    293     cucul_file_t *f;
     293    caca_file_t *f;
    294294    int i, j, size, comment_lines;
    295295
    296     ff = malloc(sizeof(cucul_figfont_t));
     296    ff = malloc(sizeof(caca_figfont_t));
    297297    if(!ff)
    298298    {
     
    302302
    303303    /* Open font: if not found, try .tlf, then .flf */
    304     f = cucul_file_open(path, "r");
     304    f = caca_file_open(path, "r");
    305305#if !defined __KERNEL__ && defined HAVE_SNPRINTF
    306306
     
    313313        snprintf(altpath, 2047, "%s.tlf", path);
    314314        altpath[2047] = '\0';
    315         f = cucul_file_open(altpath, "r");
     315        f = caca_file_open(altpath, "r");
    316316    }
    317317    if(!f)
     
    319319        snprintf(altpath, 2047, "%s.flf", path);
    320320        altpath[2047] = '\0';
    321         f = cucul_file_open(altpath, "r");
     321        f = caca_file_open(altpath, "r");
    322322    }
    323323#endif
     
    333333    ff->full_layout = 0;
    334334    ff->codetag_count = 0;
    335     cucul_file_gets(f, buf, 2048);
     335    caca_file_gets(f, buf, 2048);
    336336    if(sscanf(buf, "%*[ft]lf2a%6s %u %u %u %i %u %u %u %u\n", hardblank,
    337337              &ff->height, &ff->baseline, &ff->max_length,
     
    340340    {
    341341        debug("figfont error: `%s' has invalid header: %s", path, buf);
    342         cucul_file_close(f);
     342        caca_file_close(f);
    343343        free(ff);
    344344        seterrno(EINVAL);
     
    352352        debug("figfont error: `%s' has invalid layout %i/%u",
    353353                path, ff->old_layout, ff->full_layout);
    354         cucul_file_close(f);
     354        caca_file_close(f);
    355355        free(ff);
    356356        seterrno(EINVAL);
     
    358358    }
    359359
    360     ff->hardblank = cucul_utf8_to_utf32(hardblank, NULL);
     360    ff->hardblank = caca_utf8_to_utf32(hardblank, NULL);
    361361
    362362    /* Skip comment lines */
    363363    for(i = 0; i < comment_lines; i++)
    364         cucul_file_gets(f, buf, 2048);
     364        caca_file_gets(f, buf, 2048);
    365365
    366366    /* Read mandatory characters (32-127, 196, 214, 220, 228, 246, 252, 223)
     
    369369    ff->lookup = NULL;
    370370
    371     for(i = 0, size = 0; !cucul_file_eof(f); ff->glyphs++)
     371    for(i = 0, size = 0; !caca_file_eof(f); ff->glyphs++)
    372372    {
    373373        if((ff->glyphs % 2048) == 0)
     
    386386        else
    387387        {
    388             if(cucul_file_gets(f, buf, 2048) == NULL)
     388            if(caca_file_gets(f, buf, 2048) == NULL)
    389389                break;
    390390
     
    397397            {
    398398                for(j = 0; j < ff->height; j++)
    399                     cucul_file_gets(f, buf, 2048);
     399                    caca_file_gets(f, buf, 2048);
    400400                continue;
    401401            }
     
    424424                data = realloc(data, size += 2048);
    425425
    426             cucul_file_gets(f, data + i, 2048);
     426            caca_file_gets(f, data + i, 2048);
    427427            i = (uintptr_t)strchr(data + i, 0) - (uintptr_t)data;
    428428        }
    429429    }
    430430
    431     cucul_file_close(f);
     431    caca_file_close(f);
    432432
    433433    if(ff->glyphs < EXT_GLYPHS)
     
    443443
    444444    /* Import buffer into canvas */
    445     ff->fontcv = cucul_create_canvas(0, 0);
    446     cucul_import_memory(ff->fontcv, data, i, "utf8");
     445    ff->fontcv = caca_create_canvas(0, 0);
     446    caca_import_memory(ff->fontcv, data, i, "utf8");
    447447    free(data);
    448448
     
    455455        for(i = ff->max_length; i--;)
    456456        {
    457             ch = cucul_get_char(ff->fontcv, i, j);
     457            ch = caca_get_char(ff->fontcv, i, j);
    458458
    459459            /* Replace hardblanks with U+00A0 NO-BREAK SPACE */
    460460            if(ch == ff->hardblank)
    461                 cucul_put_char(ff->fontcv, i, j, ch = 0xa0);
     461                caca_put_char(ff->fontcv, i, j, ch = 0xa0);
    462462
    463463            if(oldch && ch != oldch)
     
    467467            }
    468468            else if(oldch && ch == oldch)
    469                 cucul_put_char(ff->fontcv, i, j, ' ');
     469                caca_put_char(ff->fontcv, i, j, ' ');
    470470            else if(ch != ' ')
    471471            {
    472472                oldch = ch;
    473                 cucul_put_char(ff->fontcv, i, j, ' ');
     473                caca_put_char(ff->fontcv, i, j, ' ');
    474474            }
    475475        }
     
    479479}
    480480
    481 int free_figfont(cucul_figfont_t *ff)
    482 {
    483     cucul_free_canvas(ff->fontcv);
     481int free_figfont(caca_figfont_t *ff)
     482{
     483    caca_free_canvas(ff->fontcv);
    484484    free(ff->lookup);
    485485    free(ff);
Note: See TracChangeset for help on using the changeset viewer.