Ignore:
Timestamp:
Apr 18, 2006, 5:11:25 PM (14 years ago)
Author:
Sam Hocevar
Message:
  • Renamed caca_t into caca_display_t.
  • Renamed canvas handle variables from "c" to "cv". Eh ouais mon gros.
File:
1 edited

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/cucul/export.c

    r810 r811  
    6060 *  \li \e "tga": export a TGA image.
    6161 *
    62  *  \param c A libcucul canvas
     62 *  \param cv A libcucul canvas
    6363 *  \param format A string describing the requested output format.
    6464 */
    65 cucul_buffer_t * cucul_create_export(cucul_canvas_t *c, char const *format)
     65cucul_buffer_t * cucul_create_export(cucul_canvas_t *cv, char const *format)
    6666{
    6767    cucul_buffer_t *ex;
     
    7272
    7373    if(!strcasecmp("ansi", format))
    74         export_ansi(c, ex);
     74        export_ansi(cv, ex);
    7575    else if(!strcasecmp("html", format))
    76         export_html(c, ex);
     76        export_html(cv, ex);
    7777    else if(!strcasecmp("html3", format))
    78         export_html3(c, ex);
     78        export_html3(cv, ex);
    7979    else if(!strcasecmp("irc", format))
    80         export_irc(c, ex);
     80        export_irc(cv, ex);
    8181    else if(!strcasecmp("ps", format))
    82         export_ps(c, ex);
     82        export_ps(cv, ex);
    8383    else if(!strcasecmp("svg", format))
    84         export_svg(c, ex);
     84        export_svg(cv, ex);
    8585    else if(!strcasecmp("tga", format))
    86         export_tga(c, ex);
     86        export_tga(cv, ex);
    8787
    8888    if(ex->size == 0)
     
    126126
    127127/* Generate ANSI representation of current canvas. */
    128 static void export_ansi(cucul_canvas_t *c, cucul_buffer_t *ex)
     128static void export_ansi(cucul_canvas_t *cv, cucul_buffer_t *ex)
    129129{
    130130    static uint8_t const palette[] =
     
    140140     * 4 max bytes for a UTF-8 character).
    141141     * Add height*9 to that (zeroes color at the end and jump to next line) */
    142     ex->size = (c->height * 9) + (c->width * c->height * 23);
     142    ex->size = (cv->height * 9) + (cv->width * cv->height * 23);
    143143    ex->data = malloc(ex->size);
    144144
    145145    cur = ex->data;
    146146
    147     for(y = 0; y < c->height; y++)
    148     {
    149         uint32_t *lineattr = c->attr + y * c->width;
    150         uint32_t *linechar = c->chars + y * c->width;
     147    for(y = 0; y < cv->height; y++)
     148    {
     149        uint32_t *lineattr = cv->attr + y * cv->width;
     150        uint32_t *linechar = cv->chars + y * cv->width;
    151151
    152152        uint8_t prevfg = -1;
    153153        uint8_t prevbg = -1;
    154154
    155         for(x = 0; x < c->width; x++)
     155        for(x = 0; x < cv->width; x++)
    156156        {
    157157            uint8_t fg = palette[_cucul_argb32_to_ansi4fg(lineattr[x])];
     
    193193
    194194/* Generate HTML representation of current canvas. */
    195 static void export_html(cucul_canvas_t *c, cucul_buffer_t *ex)
     195static void export_html(cucul_canvas_t *cv, cucul_buffer_t *ex)
    196196{
    197197    char *cur;
     
    203203     *          up to 9 chars for "&#xxxxxx;", far less for pure ASCII
    204204     *          7 chars for "</span>" */
    205     ex->size = 1000 + c->height * (7 + c->width * (47 + 9 + 7));
     205    ex->size = 1000 + cv->height * (7 + cv->width * (47 + 9 + 7));
    206206    ex->data = malloc(ex->size);
    207207
     
    216216                        "font-family: monospace, fixed; font-weight: bold;");
    217217
    218     for(y = 0; y < c->height; y++)
    219     {
    220         uint32_t *lineattr = c->attr + y * c->width;
    221         uint32_t *linechar = c->chars + y * c->width;
    222 
    223         for(x = 0; x < c->width; x += len)
     218    for(y = 0; y < cv->height; y++)
     219    {
     220        uint32_t *lineattr = cv->attr + y * cv->width;
     221        uint32_t *linechar = cv->chars + y * cv->width;
     222
     223        for(x = 0; x < cv->width; x += len)
    224224        {
    225225            cur += sprintf(cur, "<span style=\"color:#%.03x;"
     
    229229
    230230            for(len = 0;
    231                 x + len < c->width && lineattr[x + len] == lineattr[x];
     231                x + len < cv->width && lineattr[x + len] == lineattr[x];
    232232                len++)
    233233            {
     
    256256 * will not work under gecko (mozilla rendering engine) unless you set a
    257257 * correct header. */
    258 static void export_html3(cucul_canvas_t *c, cucul_buffer_t *ex)
     258static void export_html3(cucul_canvas_t *cv, cucul_buffer_t *ex)
    259259{
    260260    char *cur;
     
    266266     *          up to 9 chars for "&#xxxxxx;", far less for pure ASCII
    267267     *          12 chars for "</font></td>" */
    268     ex->size = 1000 + c->height * (10 + c->width * (40 + 9 + 12));
     268    ex->size = 1000 + cv->height * (10 + cv->width * (40 + 9 + 12));
    269269    ex->data = malloc(ex->size);
    270270
     
    273273    /* Table */
    274274    cur += sprintf(cur, "<table cols='%d' cellpadding='0' cellspacing='0'>\n",
    275                         c->height);
    276 
    277     for(y = 0; y < c->height; y++)
    278     {
    279         uint32_t *lineattr = c->attr + y * c->width;
    280         uint32_t *linechar = c->chars + y * c->width;
     275                        cv->height);
     276
     277    for(y = 0; y < cv->height; y++)
     278    {
     279        uint32_t *lineattr = cv->attr + y * cv->width;
     280        uint32_t *linechar = cv->chars + y * cv->width;
    281281
    282282        cur += sprintf(cur, "<tr>");
    283283
    284         for(x = 0; x < c->width; x += len)
     284        for(x = 0; x < cv->width; x += len)
    285285        {
    286286            unsigned int i;
     
    289289             * (see below) */
    290290            len = 1;
    291             while(x + len < c->width && lineattr[x + len] == lineattr[x])
     291            while(x + len < cv->width && lineattr[x + len] == lineattr[x])
    292292                len++;
    293293
     
    325325
    326326/* Export a text file with IRC colours */
    327 static void export_irc(cucul_canvas_t *c, cucul_buffer_t *ex)
     327static void export_irc(cucul_canvas_t *cv, cucul_buffer_t *ex)
    328328{
    329329    static uint8_t const palette[] =
     
    339339     * ^Cxx,yy   6 bytes
    340340     * ^B^B      2 bytes
    341      * c         1 byte
     341     * ch        1 byte
    342342     * \r\n      2 bytes
    343343     * In real life, the average bytes per pixel value will be around 5.
    344344     */
    345345
    346     ex->size = 2 + (c->width * c->height * 11);
     346    ex->size = 2 + (cv->width * cv->height * 11);
    347347    ex->data = malloc(ex->size);
    348348
    349349    cur = ex->data;
    350350
    351     for(y = 0; y < c->height; y++)
    352     {
    353         uint32_t *lineattr = c->attr + y * c->width;
    354         uint32_t *linechar = c->chars + y * c->width;
     351    for(y = 0; y < cv->height; y++)
     352    {
     353        uint32_t *lineattr = cv->attr + y * cv->width;
     354        uint32_t *linechar = cv->chars + y * cv->width;
    355355
    356356        uint8_t prevfg = -1;
    357357        uint8_t prevbg = -1;
    358358
    359         for(x = 0; x < c->width; x++)
     359        for(x = 0; x < cv->width; x++)
    360360        {
    361361            uint8_t fg = palette[_cucul_argb32_to_ansi4fg(lineattr[x])];
     
    400400
    401401/* Export a PostScript document. */
    402 static void export_ps(cucul_canvas_t *c, cucul_buffer_t *ex)
     402static void export_ps(cucul_canvas_t *cv, cucul_buffer_t *ex)
    403403{
    404404    static char const *ps_header =
     
    431431
    432432    /* 200 is arbitrary but should be ok */
    433     ex->size = strlen(ps_header) + (c->width * c->height * 200);
     433    ex->size = strlen(ps_header) + (cv->width * cv->height * 200);
    434434    ex->data = malloc(ex->size);
    435435
     
    440440
    441441    /* Background, drawn using csquare macro defined in header */
    442     for(y = c->height; y--; )
    443     {
    444         uint32_t *lineattr = c->attr + y * c->width;
    445 
    446         for(x = 0; x < c->width; x++)
     442    for(y = cv->height; y--; )
     443    {
     444        uint32_t *lineattr = cv->attr + y * cv->width;
     445
     446        for(x = 0; x < cv->width; x++)
    447447        {
    448448            uint8_t argb[8];
     
    455455
    456456        /* Return to beginning of the line, and jump to the next one */
    457         cur += sprintf(cur, "-%d 1 translate\n", c->width);
     457        cur += sprintf(cur, "-%d 1 translate\n", cv->width);
    458458    }
    459459
    460460    cur += sprintf(cur, "grestore\n"); /* Restore transformation matrix */
    461461
    462     for(y = c->height; y--; )
    463     {
    464         uint32_t *lineattr = c->attr + (c->height - y - 1) * c->width;
    465         uint32_t *linechar = c->chars + (c->height - y - 1) * c->width;
    466 
    467         for(x = 0; x < c->width; x++)
     462    for(y = cv->height; y--; )
     463    {
     464        uint32_t *lineattr = cv->attr + (cv->height - y - 1) * cv->width;
     465        uint32_t *linechar = cv->chars + (cv->height - y - 1) * cv->width;
     466
     467        for(x = 0; x < cv->width; x++)
    468468        {
    469469            uint8_t argb[8];
     
    505505
    506506/* Export an SVG vector image */
    507 static void export_svg(cucul_canvas_t *c, cucul_buffer_t *ex)
     507static void export_svg(cucul_canvas_t *cv, cucul_buffer_t *ex)
    508508{
    509509    static char const svg_header[] =
     
    518518
    519519    /* 200 is arbitrary but should be ok */
    520     ex->size = strlen(svg_header) + (c->width * c->height * 200);
     520    ex->size = strlen(svg_header) + (cv->width * cv->height * 200);
    521521    ex->data = malloc(ex->size);
    522522
     
    524524
    525525    /* Header */
    526     cur += sprintf(cur, svg_header, c->width * 6, c->height * 10,
    527                                     c->width * 6, c->height * 10);
     526    cur += sprintf(cur, svg_header, cv->width * 6, cv->height * 10,
     527                                    cv->width * 6, cv->height * 10);
    528528
    529529    cur += sprintf(cur, " <g id=\"mainlayer\" font-size=\"12\">\n");
    530530
    531531    /* Background */
    532     for(y = 0; y < c->height; y++)
    533     {
    534         uint32_t *lineattr = c->attr + y * c->width;
    535 
    536         for(x = 0; x < c->width; x++)
     532    for(y = 0; y < cv->height; y++)
     533    {
     534        uint32_t *lineattr = cv->attr + y * cv->width;
     535
     536        for(x = 0; x < cv->width; x++)
    537537        {
    538538            cur += sprintf(cur, "<rect style=\"fill:#%.03x\" x=\"%d\" y=\"%d\""
     
    544544
    545545    /* Text */
    546     for(y = 0; y < c->height; y++)
    547     {
    548         uint32_t *lineattr = c->attr + y * c->width;
    549         uint32_t *linechar = c->chars + y * c->width;
    550 
    551         for(x = 0; x < c->width; x++)
     546    for(y = 0; y < cv->height; y++)
     547    {
     548        uint32_t *lineattr = cv->attr + y * cv->width;
     549        uint32_t *linechar = cv->chars + y * cv->width;
     550
     551        for(x = 0; x < cv->width; x++)
    552552        {
    553553            uint32_t ch = *linechar++;
     
    602602
    603603/* Export a TGA image */
    604 static void export_tga(cucul_canvas_t *c, cucul_buffer_t *ex)
     604static void export_tga(cucul_canvas_t *cv, cucul_buffer_t *ex)
    605605{
    606606    char const * const * fontlist;
     
    615615    f = cucul_load_font(fontlist[0], 0);
    616616
    617     w = cucul_get_width(c) * cucul_get_font_width(f);
    618     h = cucul_get_height(c) * cucul_get_font_height(f);
     617    w = cucul_get_width(cv) * cucul_get_font_width(f);
     618    h = cucul_get_height(cv) * cucul_get_font_height(f);
    619619
    620620    ex->size = w * h * 4 + 18; /* 32 bpp + 18 bytes for the header */
     
    644644
    645645    /* Image Data */
    646     cucul_render_canvas(c, f, cur, w, h, 4 * w);
     646    cucul_render_canvas(cv, f, cur, w, h, 4 * w);
    647647
    648648    /* Swap bytes. What a waste of time. */
Note: See TracChangeset for help on using the changeset viewer.