Changeset 1431 for libcaca


Ignore:
Timestamp:
Nov 27, 2006, 2:56:37 AM (14 years ago)
Author:
Sam Hocevar
Message:
  • Improved vt220 import by adding a persistent context to canvases.
Location:
libcaca/trunk/cucul
Files:
4 edited

Legend:

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

    r1390 r1431  
    7777    cv->frames[0].curattr = 0;
    7878    cv->frames[0].name = strdup("frame#00000000");
     79    cv->frames[0].import = NULL;
    7980
    8081    _cucul_load_frame_info(cv);
     
    190191        free(cv->frames[f].attrs);
    191192        free(cv->frames[f].name);
     193        if(cv->frames[f].import)
     194            free(cv->frames[f].import);
    192195    }
    193196
  • libcaca/trunk/cucul/cucul_internals.h

    r1390 r1431  
    3535    /* Frame name */
    3636    char *name;
     37
     38    /* Private information */
     39    void *import;
    3740};
    3841
  • libcaca/trunk/cucul/frame.c

    r1397 r1431  
    169169
    170170    cv->frames[id].name = strdup("frame#--------");
    171     sprintf(cv->frames[id].name + 6, "%.08x", cv->autoinc++);
     171    sprintf(cv->frames[id].name + 6, "%.08x", ++cv->autoinc);
     172
     173    cv->frames[id].import = NULL;
    172174
    173175    return 0;
     
    180182 *  The frame index indicates the frame to delete. Valid values range from
    181183 *  0 to the current canvas frame count minus 1. If the frame index is
    182  *  greater the or equals the current canvas frame count, the last frame
     184 *  greater than or equals the current canvas frame count, the last frame
    183185 *  is deleted.
    184186 *
     
    214216    free(cv->frames[id].attrs);
    215217    free(cv->frames[id].name);
     218    if(cv->frames[id].import)
     219        free(cv->frames[id].import);
    216220
    217221    for(f = id + 1; f < cv->framecount; f++)
  • libcaca/trunk/cucul/import.c

    r1426 r1431  
    4242}
    4343
    44 /* ANSI Graphic Rendition Combination Mode */
    45 struct ansi_grcm
    46 {
     44struct import
     45{
     46    uint32_t clearattr;
     47
     48    /* ANSI Graphic Rendition Combination Mode */
    4749    uint8_t fg, bg;   /* ANSI-context fg/bg */
    48     uint8_t efg, ebg; /* Effective (libcucul) fg/bg */
    4950    uint8_t dfg, dbg; /* Default fg/bg */
    5051    uint8_t bold, blink, italics, negative, concealed, underline;
     52    uint8_t faint, strike, proportional; /* unsupported */
    5153};
    5254
     
    5557static long int import_ansi(cucul_canvas_t *, void const *, unsigned int, int);
    5658
    57 static void ansi_parse_grcm(cucul_canvas_t *, struct ansi_grcm *,
     59static void ansi_parse_grcm(cucul_canvas_t *, struct import *,
    5860                            unsigned int, unsigned int const *);
    5961
     
    347349                            void const *data, unsigned int size, int utf8)
    348350{
    349     struct ansi_grcm grcm;
     351    struct import *im;
    350352    unsigned char const *buffer = (unsigned char const*)data;
    351     unsigned int i, j, skip, growx = 0, growy = 0, dummy = 0;
     353    unsigned int i, j, init, skip, growx = 0, growy = 0, dummy = 0;
    352354    unsigned int width, height;
    353     uint32_t savedattr, clearattr;
     355    uint32_t savedattr;
    354356    int x = 0, y = 0, save_x = 0, save_y = 0;
     357
     358    init = !!cv->frames[cv->frame].import;
     359
     360    if(!init)
     361    {
     362        cv->frames[cv->frame].import = malloc(sizeof(struct import));
     363        memset(cv->frames[cv->frame].import, 0, sizeof(struct import));
     364    }
     365
     366    im = (struct import *)cv->frames[cv->frame].import;
    355367
    356368    if(utf8)
     
    362374        x = cv->frames[cv->frame].x;
    363375        y = cv->frames[cv->frame].y;
    364         grcm.dfg = CUCUL_DEFAULT;
    365         grcm.dbg = CUCUL_TRANSPARENT;
    366376    }
    367377    else
     
    370380        growx = 0;
    371381        growy = 1;
    372         grcm.dfg = CUCUL_LIGHTGRAY;
    373         grcm.dbg = CUCUL_BLACK;
    374     }
    375 
    376     savedattr = cucul_get_attr(cv, -1, -1);
    377     cucul_set_color_ansi(cv, grcm.dfg, grcm.dbg);
    378     clearattr = cucul_get_attr(cv, -1, -1);
    379 
    380     if(utf8)
    381         cucul_set_attr(cv, savedattr);
    382 
    383     /* FIXME: this is not right, we should store the grcm information as a
    384      * persistent structure within the canvas. */
    385     ansi_parse_grcm(cv, &grcm, 1, &dummy);
     382    }
     383
     384    if(!init)
     385    {
     386        if(utf8)
     387        {
     388            im->dfg = CUCUL_DEFAULT;
     389            im->dbg = CUCUL_TRANSPARENT;
     390        }
     391        else
     392        {
     393            im->dfg = CUCUL_LIGHTGRAY;
     394            im->dbg = CUCUL_BLACK;
     395        }
     396
     397        cucul_set_color_ansi(cv, im->dfg, im->dbg);
     398        im->clearattr = cucul_get_attr(cv, -1, -1);
     399
     400        ansi_parse_grcm(cv, im, 1, &dummy);
     401    }
    386402
    387403    for(i = 0; i < size; i += skip)
     
    416432            if(x > 0)
    417433                x--;
    418         }
    419 
    420         else if(buffer[i] == '\x1b' && buffer[i + 1] == ']'
    421                  && buffer[i + 2] == '0' && buffer[i + 3] == ';')
    422         {
    423             for(j = i + 4; j < size; j++)
    424                 if(buffer[j] == '\x07' || buffer[j] == '\x1b'
    425                    || buffer[j] == '\r' || buffer[j] == '\n')
    426                     break;
    427 
    428             if(j < size && buffer[j] == '\x07')
    429             {
    430                 char *title = malloc(j - i - 4 + 1);
    431                 memcpy(title, buffer + i + 4, j - i - 4);
    432                 title[j - i - 4] = '\0';
    433                 debug("ansi import: got display title '%s'", title);
    434                 skip += j - i;
    435                 free(title);
    436             }
    437434        }
    438435
     
    539536            case 'J': /* ED (0x4a) - Erase In Page */
    540537                savedattr = cucul_get_attr(cv, -1, -1);
    541                 cucul_set_attr(cv, clearattr);
     538                cucul_set_attr(cv, im->clearattr);
    542539                if(!argc || argv[0] == 0)
    543540                {
     
    577574#if 0
    578575                savedattr = cucul_get_attr(cv, -1, -1);
    579                 cucul_set_attr(cv, clearattr);
     576                cucul_set_attr(cv, im->clearattr);
    580577                for( ; (unsigned int)j < width; j++)
    581578                    cucul_put_char(cv, j, y, ' ');
     
    586583                {
    587584                    savedattr = cucul_get_attr(cv, -1, -1);
    588                     cucul_set_attr(cv, clearattr);
     585                    cucul_set_attr(cv, im->clearattr);
    589586                    cucul_draw_line(cv, x, y, x + argv[0] - 1, y, ' ');
    590587                    cucul_set_attr(cv, savedattr);
     
    604601                break;
    605602            case 'm': /* SGR (0x6d) - Select Graphic Rendition */
    606                 ansi_parse_grcm(cv, &grcm, argc, argv);
     603                if(argc)
     604                    ansi_parse_grcm(cv, im, argc, argv);
     605                else
     606                    ansi_parse_grcm(cv, im, 1, &dummy);
    607607                break;
    608608            case 's': /* Private (save cursor position) */
     
    619619                break;
    620620            }
     621        }
     622
     623        /* Parse OSC stuff. */
     624        else if(buffer[i] == '\x1b' && buffer[i + 1] == ']')
     625        {
     626            char *string;
     627            unsigned int command = 0;
     628            unsigned int mode = 2, semicolon, final;
     629
     630            for(semicolon = mode; i + semicolon < size; semicolon++)
     631            {
     632                if(buffer[i + semicolon] < '0' || buffer[i + semicolon] > '9')
     633                    break;
     634                command = 10 * command + (buffer[i + semicolon] - '0');
     635            }
     636
     637            if(i + semicolon >= size || buffer[i + semicolon] != ';')
     638                break; /* Invalid Mode */
     639
     640            for(final = semicolon + 1; i + final < size; final++)
     641                if(buffer[i + final] < 0x20)
     642                    break;
     643
     644            if(i + final >= size || buffer[i + final] != '\a')
     645                break; /* Not enough data or no bell found */
     646                /* FIXME: XTerm also reacts to <ESC><backslash> and <ST> */
     647                /* FIXME: differenciate between not enough data (try again)
     648                 *        and invalid data (print shit) */
     649
     650            skip += final;
     651
     652            string = malloc(final - (semicolon + 1) + 1);
     653            memcpy(string, buffer + (semicolon + 1), final - (semicolon + 1));
     654            string[final - (semicolon + 1)] = '\0';
     655            debug("ansi import: got OSC command %i string '%s'", command,
     656                  string);
     657            free(string);
    621658        }
    622659
     
    658695            {
    659696                savedattr = cucul_get_attr(cv, -1, -1);
    660                 cucul_set_attr(cv, clearattr);
     697                cucul_set_attr(cv, im->clearattr);
    661698                cucul_set_canvas_size(cv, width = x + wch, height);
    662699                cucul_set_attr(cv, savedattr);
     
    673710        {
    674711            savedattr = cucul_get_attr(cv, -1, -1);
    675             cucul_set_attr(cv, clearattr);
     712            cucul_set_attr(cv, im->clearattr);
    676713            if(growy)
    677714            {
     
    707744    {
    708745        savedattr = cucul_get_attr(cv, -1, -1);
    709         cucul_set_attr(cv, clearattr);
     746        cucul_set_attr(cv, im->clearattr);
    710747        cucul_set_canvas_size(cv, width, height = y);
    711748        cucul_set_attr(cv, savedattr);
     
    715752    cv->frames[cv->frame].y = y;
    716753
    717     if(utf8)
    718         cucul_set_attr(cv, savedattr);
     754//    if(utf8)
     755//        cucul_set_attr(cv, savedattr);
    719756
    720757    return i;
     
    723760/* XXX : ANSI loader helper */
    724761
    725 static void ansi_parse_grcm(cucul_canvas_t *cv, struct ansi_grcm *g,
     762static void ansi_parse_grcm(cucul_canvas_t *cv, struct import *im,
    726763                            unsigned int argc, unsigned int const *argv)
    727764{
     
    733770
    734771    unsigned int j;
     772    uint8_t efg, ebg; /* Effective (libcucul) fg/bg */
    735773
    736774    for(j = 0; j < argc; j++)
     
    738776        /* Defined in ECMA-48 8.3.117: SGR - SELECT GRAPHIC RENDITION */
    739777        if(argv[j] >= 30 && argv[j] <= 37)
    740             g->fg = ansi2cucul[argv[j] - 30];
     778            im->fg = ansi2cucul[argv[j] - 30];
    741779        else if(argv[j] >= 40 && argv[j] <= 47)
    742             g->bg = ansi2cucul[argv[j] - 40];
     780            im->bg = ansi2cucul[argv[j] - 40];
    743781        else if(argv[j] >= 90 && argv[j] <= 97)
    744             g->fg = ansi2cucul[argv[j] - 90] + 8;
     782            im->fg = ansi2cucul[argv[j] - 90] + 8;
    745783        else if(argv[j] >= 100 && argv[j] <= 107)
    746             g->bg = ansi2cucul[argv[j] - 100] + 8;
     784            im->bg = ansi2cucul[argv[j] - 100] + 8;
    747785        else switch(argv[j])
    748786        {
    749787        case 0: /* default rendition */
    750             g->fg = g->dfg;
    751             g->bg = g->dbg;
    752             g->bold = g->blink = g->italics = 0;
    753             g->negative = g->concealed = g->underline = 0;
     788            im->fg = im->dfg;
     789            im->bg = im->dbg;
     790            im->bold = im->blink = im->italics = im->negative
     791             = im->concealed = im->underline = im->faint = im->strike
     792             = im->proportional = 0;
    754793            break;
    755794        case 1: /* bold or increased intensity */
    756             g->bold = 1;
     795            im->bold = 1;
    757796            break;
    758797        case 2: /* faint, decreased intensity or second colour */
     798            im->faint = 1;
    759799            break;
    760800        case 3: /* italicized */
    761             g->italics = 1;
     801            im->italics = 1;
    762802            break;
    763803        case 4: /* singly underlined */
    764             g->underline = 1;
     804            im->underline = 1;
    765805            break;
    766806        case 5: /* slowly blinking (less then 150 per minute) */
    767807        case 6: /* rapidly blinking (150 per minute or more) */
    768             g->blink = 1;
     808            im->blink = 1;
    769809            break;
    770810        case 7: /* negative image */
    771             g->negative = 1;
     811            im->negative = 1;
    772812            break;
    773813        case 8: /* concealed characters */
    774             g->concealed = 1;
     814            im->concealed = 1;
    775815            break;
    776816        case 9: /* crossed-out (characters still legible but marked as to be
    777817                 * deleted */
     818            im->strike = 1;
    778819            break;
    779820        case 21: /* doubly underlined */
    780             g->underline = 1;
     821            im->underline = 1;
    781822            break;
    782823        case 22: /* normal colour or normal intensity (neither bold nor
    783824                  * faint) */
    784             g->bold = 0;
     825            im->bold = im->faint = 0;
    785826            break;
    786827        case 23: /* not italicized, not fraktur */
    787             g->italics = 0;
     828            im->italics = 0;
    788829            break;
    789830        case 24: /* not underlined (neither singly nor doubly) */
    790             g->underline = 0;
     831            im->underline = 0;
    791832            break;
    792833        case 25: /* steady (not blinking) */
    793             g->blink = 0;
     834            im->blink = 0;
    794835            break;
    795836        case 26: /* (reserved for proportional spacing as specified in CCITT
    796837                  * Recommendation T.61) */
     838            im->proportional = 1;
    797839            break;
    798840        case 27: /* positive image */
    799             g->negative = 0;
     841            im->negative = 0;
    800842            break;
    801843        case 28: /* revealed characters */
    802             g->concealed = 0;
     844            im->concealed = 0;
    803845            break;
    804846        case 29: /* not crossed out */
     847            im->strike = 0;
    805848            break;
    806849        case 38: /* (reserved for future standardization, intended for setting
     
    809852            break;
    810853        case 39: /* default display colour (implementation-defined) */
    811             g->fg = g->dfg;
     854            im->fg = im->dfg;
    812855            break;
    813856        case 48: /* (reserved for future standardization, intended for setting
     
    816859            break;
    817860        case 49: /* default background colour (implementation-defined) */
    818             g->bg = g->dbg;
     861            im->bg = im->dbg;
    819862            break;
    820863        case 50: /* (reserved for cancelling the effect of the rendering
    821864                  * aspect established by parameter value 26) */
     865            im->proportional = 0;
    822866            break;
    823867        default:
     
    827871    }
    828872
    829     if(g->concealed)
    830     {
    831         g->efg = g->ebg = CUCUL_TRANSPARENT;
     873    if(im->concealed)
     874    {
     875        efg = ebg = CUCUL_TRANSPARENT;
    832876    }
    833877    else
    834878    {
    835         g->efg = g->negative ? g->bg : g->fg;
    836         g->ebg = g->negative ? g->fg : g->bg;
    837 
    838         if(g->bold)
    839         {
    840             if(g->efg < 8)
    841                 g->efg += 8;
    842             else if(g->efg == CUCUL_DEFAULT)
    843                 g->efg = CUCUL_WHITE;
    844         }
    845     }
    846 
    847     cucul_set_color_ansi(cv, g->efg, g->ebg);
     879        efg = im->negative ? im->bg : im->fg;
     880        ebg = im->negative ? im->fg : im->bg;
     881
     882        if(im->bold)
     883        {
     884            if(efg < 8)
     885                efg += 8;
     886            else if(efg == CUCUL_DEFAULT)
     887                efg = CUCUL_WHITE;
     888        }
     889    }
     890
     891    cucul_set_color_ansi(cv, efg, ebg);
    848892}
    849893
Note: See TracChangeset for help on using the changeset viewer.