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/import.c

    r2819 r2821  
    11/*
    2  *  libcucul      Canvas for ultrafast compositing of Unicode letters
     2 *  libcaca       Colour ASCII-Art library
    33 *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
     
    2424#endif
    2525
    26 #include "cucul.h"
    27 #include "cucul_internals.h"
     26#include "caca.h"
     27#include "caca_internals.h"
    2828
    2929static inline uint32_t sscanu32(void const *s)
     
    5252};
    5353
    54 static ssize_t import_caca(cucul_canvas_t *, void const *, size_t);
    55 static ssize_t import_text(cucul_canvas_t *, void const *, size_t);
    56 static ssize_t import_ansi(cucul_canvas_t *, void const *, size_t, int);
    57 
    58 static void ansi_parse_grcm(cucul_canvas_t *, struct import *,
     54static ssize_t import_caca(caca_canvas_t *, void const *, size_t);
     55static ssize_t import_text(caca_canvas_t *, void const *, size_t);
     56static ssize_t import_ansi(caca_canvas_t *, void const *, size_t, int);
     57
     58static void ansi_parse_grcm(caca_canvas_t *, struct import *,
    5959                            unsigned int, unsigned int const *);
    6060
    6161/** \brief Import a memory buffer into a canvas
    6262 *
    63  *  Import a memory buffer into the given libcucul canvas's current
     63 *  Import a memory buffer into the given libcaca canvas's current
    6464 *  frame. The current frame is resized accordingly and its contents are
    6565 *  replaced with the imported data.
     
    7979 *  - \c EINVAL Invalid format requested.
    8080 *
    81  *  \param cv A libcucul canvas in which to import the file.
     81 *  \param cv A libcaca canvas in which to import the file.
    8282 *  \param data A memory area containing the data to be loaded into the canvas.
    8383 *  \param len The size in bytes of the memory area.
     
    8686 *  or -1 if an error occurred.
    8787 */
    88 ssize_t cucul_import_memory(cucul_canvas_t *cv, void const *data,
     88ssize_t caca_import_memory(caca_canvas_t *cv, void const *data,
    8989                            size_t len, char const *format)
    9090{
     
    124124/** \brief Import a file into a canvas
    125125 *
    126  *  Import a file into the given libcucul canvas's current frame. The
     126 *  Import a file into the given libcaca canvas's current frame. The
    127127 *  current frame is resized accordingly and its contents are replaced
    128128 *  with the imported data.
     
    142142 *  - \c ENOMEM Not enough memory to allocate canvas.
    143143 *  - \c EINVAL Invalid format requested.
    144  *  cucul_import_file() may also fail and set \b errno for any of the
     144 *  caca_import_file() may also fail and set \b errno for any of the
    145145 *  errors specified for the routine fopen().
    146146 *
    147  *  \param cv A libcucul canvas in which to import the file.
     147 *  \param cv A libcaca canvas in which to import the file.
    148148 *  \param filename The name of the file to load.
    149149 *  \param format A string describing the input format.
     
    151151 *  or -1 if an error occurred.
    152152 */
    153 ssize_t cucul_import_file(cucul_canvas_t *cv, char const *filename,
     153ssize_t caca_import_file(caca_canvas_t *cv, char const *filename,
    154154                          char const *format)
    155155{
     
    158158    return -1;
    159159#else
    160     cucul_file_t *f;
     160    caca_file_t *f;
    161161    char *data = NULL;
    162162    ssize_t size = 0;
    163163    int ret;
    164164
    165     f = cucul_file_open(filename, "rb");
     165    f = caca_file_open(filename, "rb");
    166166    if(!f)
    167167        return -1; /* fopen already set errno */
    168168
    169     while(!cucul_file_eof(f))
     169    while(!caca_file_eof(f))
    170170    {
    171171        data = realloc(data, size + 1024);
    172172        if(!data)
    173173        {
    174             cucul_file_close(f);
     174            caca_file_close(f);
    175175            seterrno(ENOMEM);
    176176            return -1;
    177177        }
    178178
    179         ret = cucul_file_read(f, data + size, 1024);
     179        ret = caca_file_read(f, data + size, 1024);
    180180        if(ret >= 0)
    181181            size += ret;
    182182    }
    183     cucul_file_close(f);
    184 
    185     ret = cucul_import_memory(cv, data, size, format);
     183    caca_file_close(f);
     184
     185    ret = caca_import_memory(cv, data, size, format);
    186186    free(data);
    187187
     
    194194 *  Return a list of available import formats. The list is a NULL-terminated
    195195 *  array of strings, interleaving a string containing the internal value for
    196  *  the import format, to be used with cucul_import_canvas(), and a string
     196 *  the import format, to be used with caca_import_canvas(), and a string
    197197 *  containing the natural language description for that import format.
    198198 *
     
    201201 *  \return An array of strings.
    202202 */
    203 char const * const * cucul_get_import_list(void)
     203char const * const * caca_get_import_list(void)
    204204{
    205205    static char const * const list[] =
     
    220220 */
    221221
    222 static ssize_t import_caca(cucul_canvas_t *cv, void const *data, size_t size)
     222static ssize_t import_caca(caca_canvas_t *cv, void const *data, size_t size)
    223223{
    224224    uint8_t const *buf = (uint8_t const *)data;
     
    285285    }
    286286
    287     cucul_set_canvas_size(cv, 0, 0);
    288     cucul_set_canvas_size(cv, xmax - xmin, ymax - ymin);
    289 
    290     for (f = cucul_get_frame_count(cv); f--; )
    291     {
    292         cucul_free_frame(cv, f);
     287    caca_set_canvas_size(cv, 0, 0);
     288    caca_set_canvas_size(cv, xmax - xmin, ymax - ymin);
     289
     290    for (f = caca_get_frame_count(cv); f--; )
     291    {
     292        caca_free_frame(cv, f);
    293293    }
    294294
     
    299299        width = sscanu32(buf + 4 + 16 + f * 32);
    300300        height = sscanu32(buf + 4 + 16 + f * 32 + 4);
    301         cucul_create_frame(cv, f);
    302         cucul_set_frame(cv, f);
     301        caca_create_frame(cv, f);
     302        caca_set_frame(cv, f);
    303303
    304304        cv->curattr = sscanu32(buf + 4 + 16 + f * 32 + 12);
     
    315315            int y = (n / width) - cv->frames[f].handley - ymin;
    316316
    317             cucul_put_char(cv, x, y, sscanu32(buf + 4 + control_size
     317            caca_put_char(cv, x, y, sscanu32(buf + 4 + control_size
    318318                                               + offset + 8 * n));
    319             cucul_put_attr(cv, x, y, sscanu32(buf + 4 + control_size
     319            caca_put_attr(cv, x, y, sscanu32(buf + 4 + control_size
    320320                                               + offset + 8 * n + 4));
    321321        }
     
    328328    }
    329329
    330     cucul_set_frame(cv, 0);
     330    caca_set_frame(cv, 0);
    331331
    332332    return 4 + control_size + data_size;
     
    337337}
    338338
    339 static ssize_t import_text(cucul_canvas_t *cv, void const *data, size_t size)
     339static ssize_t import_text(caca_canvas_t *cv, void const *data, size_t size)
    340340{
    341341    char const *text = (char const *)data;
    342342    unsigned int width = 0, height = 0, x = 0, y = 0, i;
    343343
    344     cucul_set_canvas_size(cv, width, height);
     344    caca_set_canvas_size(cv, width, height);
    345345
    346346    for(i = 0; i < size; i++)
     
    366366                height = y + 1;
    367367
    368             cucul_set_canvas_size(cv, width, height);
    369         }
    370 
    371         cucul_put_char(cv, x, y, ch);
     368            caca_set_canvas_size(cv, width, height);
     369        }
     370
     371        caca_put_char(cv, x, y, ch);
    372372        x++;
    373373    }
    374374
    375375    if(y > height)
    376         cucul_set_canvas_size(cv, width, height = y);
     376        caca_set_canvas_size(cv, width, height = y);
    377377
    378378    return size;
    379379}
    380380
    381 static ssize_t import_ansi(cucul_canvas_t *cv, void const *data,
     381static ssize_t import_ansi(caca_canvas_t *cv, void const *data,
    382382                           size_t size, int utf8)
    383383{
     
    400400    else
    401401    {
    402         cucul_set_canvas_size(cv, width = 80, height = 0);
     402        caca_set_canvas_size(cv, width = 80, height = 0);
    403403        growx = 0;
    404404        growy = 1;
     
    407407    if(utf8)
    408408    {
    409         im.dfg = CUCUL_DEFAULT;
    410         im.dbg = CUCUL_TRANSPARENT;
     409        im.dfg = CACA_DEFAULT;
     410        im.dbg = CACA_TRANSPARENT;
    411411    }
    412412    else
    413413    {
    414         im.dfg = CUCUL_LIGHTGRAY;
    415         im.dbg = CUCUL_BLACK;
    416     }
    417 
    418     cucul_set_color_ansi(cv, im.dfg, im.dbg);
    419     im.clearattr = cucul_get_attr(cv, -1, -1);
     414        im.dfg = CACA_LIGHTGRAY;
     415        im.dbg = CACA_BLACK;
     416    }
     417
     418    caca_set_color_ansi(cv, im.dfg, im.dbg);
     419    im.clearattr = caca_get_attr(cv, -1, -1);
    420420
    421421    ansi_parse_grcm(cv, &im, 1, &dummy);
     
    555555                break;
    556556            case 'J': /* ED (0x4a) - Erase In Page */
    557                 savedattr = cucul_get_attr(cv, -1, -1);
    558                 cucul_set_attr(cv, im.clearattr);
     557                savedattr = caca_get_attr(cv, -1, -1);
     558                caca_set_attr(cv, im.clearattr);
    559559                if(!argc || argv[0] == 0)
    560560                {
    561                     cucul_draw_line(cv, x, y, width, y, ' ');
    562                     cucul_fill_box(cv, 0, y + 1, width - 1, height - 1, ' ');
     561                    caca_draw_line(cv, x, y, width, y, ' ');
     562                    caca_fill_box(cv, 0, y + 1, width - 1, height - 1, ' ');
    563563                }
    564564                else if(argv[0] == 1)
    565565                {
    566                     cucul_fill_box(cv, 0, 0, width - 1, y - 1, ' ');
    567                     cucul_draw_line(cv, 0, y, x, y, ' ');
     566                    caca_fill_box(cv, 0, 0, width - 1, y - 1, ' ');
     567                    caca_draw_line(cv, 0, y, x, y, ' ');
    568568                }
    569569                else if(argv[0] == 2)
    570570                    //x = y = 0;
    571                     cucul_fill_box(cv, 0, 0, width - 1, height - 1, ' ');
    572                 cucul_set_attr(cv, savedattr);
     571                    caca_fill_box(cv, 0, 0, width - 1, height - 1, ' ');
     572                caca_set_attr(cv, savedattr);
    573573                break;
    574574            case 'K': /* EL (0x4b) - Erase In Line */
    575575                if(!argc || argv[0] == 0)
    576                     cucul_draw_line(cv, x, y, width, y, ' ');
     576                    caca_draw_line(cv, x, y, width, y, ' ');
    577577                else if(argv[0] == 1)
    578                     cucul_draw_line(cv, 0, y, x, y, ' ');
     578                    caca_draw_line(cv, 0, y, x, y, ' ');
    579579                else if(argv[0] == 2)
    580580                    if((unsigned int)x < width)
    581                         cucul_draw_line(cv, x, y, width - 1, y, ' ');
     581                        caca_draw_line(cv, x, y, width - 1, y, ' ');
    582582                //x = width;
    583583                break;
     
    587587                for(j = 0; (unsigned int)(j + argv[0]) < width; j++)
    588588                {
    589                     cucul_put_char(cv, j, y,
    590                                    cucul_get_char(cv, j + argv[0], y));
    591                     cucul_put_attr(cv, j, y,
    592                                    cucul_get_attr(cv, j + argv[0], y));
     589                    caca_put_char(cv, j, y,
     590                                   caca_get_char(cv, j + argv[0], y));
     591                    caca_put_attr(cv, j, y,
     592                                   caca_get_attr(cv, j + argv[0], y));
    593593                }
    594594#if 0
    595                 savedattr = cucul_get_attr(cv, -1, -1);
    596                 cucul_set_attr(cv, im.clearattr);
     595                savedattr = caca_get_attr(cv, -1, -1);
     596                caca_set_attr(cv, im.clearattr);
    597597                for( ; (unsigned int)j < width; j++)
    598                     cucul_put_char(cv, j, y, ' ');
    599                 cucul_set_attr(cv, savedattr);
     598                    caca_put_char(cv, j, y, ' ');
     599                caca_set_attr(cv, savedattr);
    600600#endif
    601601            case 'X': /* ECH (0x58) - Erase Character */
    602602                if(argc && argv[0])
    603603                {
    604                     savedattr = cucul_get_attr(cv, -1, -1);
    605                     cucul_set_attr(cv, im.clearattr);
    606                     cucul_draw_line(cv, x, y, x + argv[0] - 1, y, ' ');
    607                     cucul_set_attr(cv, savedattr);
     604                    savedattr = caca_get_attr(cv, -1, -1);
     605                    caca_set_attr(cv, im.clearattr);
     606                    caca_draw_line(cv, x, y, x + argv[0] - 1, y, ' ');
     607                    caca_set_attr(cv, savedattr);
    608608                }
    609609            case 'd': /* VPA (0x64) - Line Position Absolute */
     
    684684
    685685            if(i + 6 < size)
    686                 ch = cucul_utf8_to_utf32((char const *)(buffer + i), &bytes);
     686                ch = caca_utf8_to_utf32((char const *)(buffer + i), &bytes);
    687687            else
    688688            {
     
    691691                memcpy(tmp, buffer + i, size - i);
    692692                tmp[size - i] = '\0';
    693                 ch = cucul_utf8_to_utf32(tmp, &bytes);
     693                ch = caca_utf8_to_utf32(tmp, &bytes);
    694694            }
    695695
     
    700700                bytes = 1;
    701701            }
    702             wch = cucul_utf32_is_fullwidth(ch) ? 2 : 1;
     702            wch = caca_utf32_is_fullwidth(ch) ? 2 : 1;
    703703            skip += bytes - 1;
    704704        }
    705705        else
    706706        {
    707             ch = cucul_cp437_to_utf32(buffer[i]);
     707            ch = caca_cp437_to_utf32(buffer[i]);
    708708            wch = 1;
    709709        }
     
    714714            if(growx)
    715715            {
    716                 savedattr = cucul_get_attr(cv, -1, -1);
    717                 cucul_set_attr(cv, im.clearattr);
    718                 cucul_set_canvas_size(cv, width = x + wch, height);
    719                 cucul_set_attr(cv, savedattr);
     716                savedattr = caca_get_attr(cv, -1, -1);
     717                caca_set_attr(cv, im.clearattr);
     718                caca_set_canvas_size(cv, width = x + wch, height);
     719                caca_set_attr(cv, savedattr);
    720720            }
    721721            else
     
    729729        if((unsigned int)y >= height)
    730730        {
    731             savedattr = cucul_get_attr(cv, -1, -1);
    732             cucul_set_attr(cv, im.clearattr);
     731            savedattr = caca_get_attr(cv, -1, -1);
     732            caca_set_attr(cv, im.clearattr);
    733733            if(growy)
    734734            {
    735                 cucul_set_canvas_size(cv, width, height = y + 1);
     735                caca_set_canvas_size(cv, width, height = y + 1);
    736736            }
    737737            else
     
    746746                           cv->chars + (j + lines) * cv->width, cv->width * 4);
    747747                }
    748                 cucul_fill_box(cv, 0, height - lines,
     748                caca_fill_box(cv, 0, height - lines,
    749749                                   cv->width - 1, height - 1, ' ');
    750750                y -= lines;
    751751            }
    752             cucul_set_attr(cv, savedattr);
     752            caca_set_attr(cv, savedattr);
    753753        }
    754754
     
    756756        if(wch)
    757757        {
    758             cucul_put_char(cv, x, y, ch);
     758            caca_put_char(cv, x, y, ch);
    759759            x += wch;
    760760        }
     
    763763    if(growy && (unsigned int)y > height)
    764764    {
    765         savedattr = cucul_get_attr(cv, -1, -1);
    766         cucul_set_attr(cv, im.clearattr);
    767         cucul_set_canvas_size(cv, width, height = y);
    768         cucul_set_attr(cv, savedattr);
     765        savedattr = caca_get_attr(cv, -1, -1);
     766        caca_set_attr(cv, im.clearattr);
     767        caca_set_canvas_size(cv, width, height = y);
     768        caca_set_attr(cv, savedattr);
    769769    }
    770770
     
    773773
    774774//    if(utf8)
    775 //        cucul_set_attr(cv, savedattr);
     775//        caca_set_attr(cv, savedattr);
    776776
    777777    return i;
     
    780780/* XXX : ANSI loader helper */
    781781
    782 static void ansi_parse_grcm(cucul_canvas_t *cv, struct import *im,
     782static void ansi_parse_grcm(caca_canvas_t *cv, struct import *im,
    783783                            unsigned int argc, unsigned int const *argv)
    784784{
    785     static uint8_t const ansi2cucul[] =
    786     {
    787         CUCUL_BLACK, CUCUL_RED, CUCUL_GREEN, CUCUL_BROWN,
    788         CUCUL_BLUE, CUCUL_MAGENTA, CUCUL_CYAN, CUCUL_LIGHTGRAY
     785    static uint8_t const ansi2caca[] =
     786    {
     787        CACA_BLACK, CACA_RED, CACA_GREEN, CACA_BROWN,
     788        CACA_BLUE, CACA_MAGENTA, CACA_CYAN, CACA_LIGHTGRAY
    789789    };
    790790
    791791    unsigned int j;
    792     uint8_t efg, ebg; /* Effective (libcucul) fg/bg */
     792    uint8_t efg, ebg; /* Effective (libcaca) fg/bg */
    793793
    794794    for(j = 0; j < argc; j++)
     
    796796        /* Defined in ECMA-48 8.3.117: SGR - SELECT GRAPHIC RENDITION */
    797797        if(argv[j] >= 30 && argv[j] <= 37)
    798             im->fg = ansi2cucul[argv[j] - 30];
     798            im->fg = ansi2caca[argv[j] - 30];
    799799        else if(argv[j] >= 40 && argv[j] <= 47)
    800             im->bg = ansi2cucul[argv[j] - 40];
     800            im->bg = ansi2caca[argv[j] - 40];
    801801        else if(argv[j] >= 90 && argv[j] <= 97)
    802             im->fg = ansi2cucul[argv[j] - 90] + 8;
     802            im->fg = ansi2caca[argv[j] - 90] + 8;
    803803        else if(argv[j] >= 100 && argv[j] <= 107)
    804             im->bg = ansi2cucul[argv[j] - 100] + 8;
     804            im->bg = ansi2caca[argv[j] - 100] + 8;
    805805        else switch(argv[j])
    806806        {
     
    893893    if(im->concealed)
    894894    {
    895         efg = ebg = CUCUL_TRANSPARENT;
     895        efg = ebg = CACA_TRANSPARENT;
    896896    }
    897897    else
     
    904904            if(efg < 8)
    905905                efg += 8;
    906             else if(efg == CUCUL_DEFAULT)
    907                 efg = CUCUL_WHITE;
    908         }
    909     }
    910 
    911     cucul_set_color_ansi(cv, efg, ebg);
     906            else if(efg == CACA_DEFAULT)
     907                efg = CACA_WHITE;
     908        }
     909    }
     910
     911    caca_set_color_ansi(cv, efg, ebg);
    912912}
    913913
Note: See TracChangeset for help on using the changeset viewer.