Changeset 1254


Ignore:
Timestamp:
Oct 29, 2006, 1:53:46 AM (13 years ago)
Author:
Sam Hocevar
Message:
  • Use the LSB of alpha and blue components to encode additional flags such as bold or underline. No higher level support for these yet, but at least everything is consistent.
  • Created cucul_set_attr_ansi() and cucul_set_attr_argb() which are bound to replace cucul_set_color() and cucul_set_truecolor().
Location:
libcaca/trunk
Files:
18 edited

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/caca/caca0.h

    r1015 r1254  
    131131
    132132#define caca_set_color(x, y) \
    133     (__caca0_fg = (x), __caca0_bg = (y), cucul_set_color(__caca0_cv, x, y))
     133    (__caca0_fg = (x), __caca0_bg = (y), \
     134     cucul_set_attr_ansi(__caca0_cv, x, y, 0))
    134135#define caca_get_fg_color() __caca0_fg
    135136#define caca_get_bg_color() __caca0_bg
  • libcaca/trunk/caca/driver_conio.c

    r1218 r1254  
    9898{
    9999    char *screen = dp->drv.p->screen;
    100     uint32_t *attr = dp->cv->attr;
     100    uint32_t *attrs = dp->cv->attrs;
    101101    uint32_t *chars = dp->cv->chars;
    102102    unsigned int n;
     
    108108        {
    109109            *screen++ = '[';
    110             *screen++ = _cucul_argb32_to_ansi8(*attr++);
     110            *screen++ = _cucul_attr_to_ansi8(*attrs++);
    111111            ch = ']';
    112112            chars++;
     
    114114        }
    115115        *screen++ = ch;
    116         *screen++ = _cucul_argb32_to_ansi8(*attr++);
     116        *screen++ = _cucul_attr_to_ansi8(*attrs++);
    117117    }
    118118#   if defined(SCREENUPDATE_IN_PC_H)
  • libcaca/trunk/caca/driver_gl.c

    r1233 r1254  
    215215    for(y = 0; y < dp->drv.p->height; y += dp->drv.p->font_height)
    216216    {
    217         uint32_t *attr = dp->cv->attr + line * dp->cv->width;
     217        uint32_t *attrs = dp->cv->attrs + line * dp->cv->width;
    218218
    219219        /* FIXME: optimise using stride */
    220220        for(x = 0; x < dp->drv.p->width; x += dp->drv.p->font_width)
    221221        {
    222             uint16_t bg = _cucul_argb32_to_rgb12bg(*attr++);
     222            uint16_t bg = _cucul_attr_to_rgb12bg(*attrs++);
    223223
    224224            glColor4b(((bg & 0xf00) >> 8) * 8,
     
    245245    for(y = 0; y < dp->drv.p->height; y += dp->drv.p->font_height, line++)
    246246    {
    247         uint32_t *attr = dp->cv->attr + line * dp->cv->width;
     247        uint32_t *attrs = dp->cv->attrs + line * dp->cv->width;
    248248        uint32_t *chars = dp->cv->chars + line * dp->cv->width;
    249249
    250         for(x = 0; x < dp->drv.p->width; x += dp->drv.p->font_width, attr++)
     250        for(x = 0; x < dp->drv.p->width; x += dp->drv.p->font_width, attrs++)
    251251        {
    252252            uint32_t ch = *chars++;
     
    272272                                        - (uint32_t)dp->drv.p->blocks[i]]);
    273273
    274                 fg = _cucul_argb32_to_rgb12fg(*attr);
     274                fg = _cucul_attr_to_rgb12fg(*attrs);
    275275                glColor3b(((fg & 0xf00) >> 8) * 8,
    276276                          ((fg & 0x0f0) >> 4) * 8,
     
    292292            if(fullwidth)
    293293            {
    294                 chars++; attr++; x += dp->drv.p->font_width;
     294                chars++; attrs++; x += dp->drv.p->font_width;
    295295            }
    296296        }
  • libcaca/trunk/caca/driver_ncurses.c

    r1218 r1254  
    197197{
    198198    int x, y;
    199     uint32_t *attr = dp->cv->attr;
     199    uint32_t *attrs = dp->cv->attrs;
    200200    uint32_t *chars = dp->cv->chars;
    201201    for(y = 0; y < (int)dp->cv->height; y++)
     
    204204        for(x = dp->cv->width; x--; )
    205205        {
    206             attrset(dp->drv.p->attr[_cucul_argb32_to_ansi8(*attr++)]);
     206            attrset(dp->drv.p->attr[_cucul_attr_to_ansi8(*attrs++)]);
    207207            ncurses_write_utf32(*chars++);
    208208        }
  • libcaca/trunk/caca/driver_slang.c

    r1218 r1254  
    202202{
    203203    int x, y;
    204     uint32_t *attr = dp->cv->attr;
     204    uint32_t *attrs = dp->cv->attrs;
    205205    uint32_t *chars = dp->cv->chars;
    206206    for(y = 0; y < (int)dp->cv->height; y++)
     
    218218             * bright backgrounds, it's just fucked up. */
    219219#if 0
    220             uint8_t fgcolor = _cucul_argb32_to_ansi4fg(*attr);
    221             uint8_t bgcolor = _cucul_argb32_to_ansi4bg(*attr);
     220            uint8_t fgcolor = _cucul_attr_to_ansi4fg(*attrs);
     221            uint8_t bgcolor = _cucul_attr_to_ansi4bg(*attrs);
    222222
    223223            if(fgcolor == bgcolor)
     
    232232                SLsmg_set_color(slang_assoc[fgcolor + 16 * bgcolor]);
    233233                SLsmg_write_char(' ');
    234                 attr++;
     234                attrs++;
    235235            }
    236236            else
    237237#endif
    238238            {
    239                 SLsmg_set_color(slang_assoc[_cucul_argb32_to_ansi8(*attr++)]);
     239                SLsmg_set_color(slang_assoc[_cucul_attr_to_ansi8(*attrs++)]);
    240240                slang_write_utf32(ch);
    241241            }
    242242#else
    243             SLsmg_set_color(_cucul_argb32_to_ansi8(*attr++));
     243            SLsmg_set_color(_cucul_attr_to_ansi8(*attrs++));
    244244            slang_write_utf32(ch);
    245245#endif
  • libcaca/trunk/caca/driver_vga.c

    r1218 r1254  
    116116{
    117117    char *screen = (char *)(intptr_t)0x000b8000;
    118     uint32_t *attr = dp->cv->attr;
     118    uint32_t *attrs = dp->cv->attrs;
    119119    uint32_t *chars = dp->cv->chars;
    120120    int n;
     
    126126        {
    127127            *screen++ = '[';
    128             *screen++ = _cucul_argb32_to_ansi8(*attr++);
     128            *screen++ = _cucul_attr_to_ansi8(*attrs++);
    129129            ch = ']';
    130130            chars++;
     
    132132        }
    133133        *screen++ = ch;
    134         *screen++ = _cucul_argb32_to_ansi8(*attr++);
     134        *screen++ = _cucul_attr_to_ansi8(*attrs++);
    135135    }
    136136}
  • libcaca/trunk/caca/driver_win32.c

    r1233 r1254  
    191191    SMALL_RECT rect;
    192192    CHAR_INFO *buffer = dp->drv.p->buffer;
    193     uint32_t *attr = dp->cv->attr;
     193    uint32_t *attrs = dp->cv->attrs;
    194194    uint32_t *chars = dp->cv->chars;
    195195    unsigned int n;
     
    215215
    216216        buffer->Attributes =
    217                 win32_fg_palette[_cucul_argb32_to_ansi4fg(*attr)]
    218                  | win32_bg_palette[_cucul_argb32_to_ansi4bg(*attr)];
    219         attr++;
     217                win32_fg_palette[_cucul_attr_to_ansi4fg(*attrs)]
     218                 | win32_bg_palette[_cucul_attr_to_ansi4bg(*attrs)];
     219        attrs++;
    220220        buffer++;
    221221    }
  • libcaca/trunk/caca/driver_x11.c

    r1233 r1254  
    247247        for(x = 0; x < dp->cv->width; x += len)
    248248        {
    249             uint32_t *attr = dp->cv->attr + x + y * dp->cv->width;
    250             uint16_t bg = _cucul_argb32_to_rgb12bg(*attr);
     249            uint32_t *attrs = dp->cv->attrs + x + y * dp->cv->width;
     250            uint16_t bg = _cucul_attr_to_rgb12bg(*attrs);
    251251
    252252            len = 1;
    253253            while(x + len < dp->cv->width
    254                    && _cucul_argb32_to_rgb12bg(attr[len]) == bg)
     254                   && _cucul_attr_to_rgb12bg(attrs[len]) == bg)
    255255                len++;
    256256
     
    272272        for(x = 0; x < dp->cv->width; x++, chars++)
    273273        {
    274             uint32_t *attr = dp->cv->attr + x + y * dp->cv->width;
     274            uint32_t *attrs = dp->cv->attrs + x + y * dp->cv->width;
    275275
    276276            /* Skip spaces */
     
    282282
    283283            XSetForeground(dp->drv.p->dpy, dp->drv.p->gc,
    284                            dp->drv.p->colors[_cucul_argb32_to_rgb12fg(*attr)]);
     284                           dp->drv.p->colors[_cucul_attr_to_rgb12fg(*attrs)]);
    285285
    286286            /* Plain ASCII, no problem. */
  • libcaca/trunk/cucul/canvas.c

    r1231 r1254  
    8787
    8888    curchar = cv->chars + x + y * cv->width;
    89     curattr = cv->attr + x + y * cv->width;
    90     attr = (cv->bgcolor << 16) | cv->fgcolor;
     89    curattr = cv->attrs + x + y * cv->width;
     90    attr = cv->curattr;
    9191
    9292    /* When overwriting the right part of a fullwidth character,
     
    254254int cucul_clear_canvas(cucul_canvas_t *cv)
    255255{
    256     uint32_t color = (cv->bgcolor << 16) | cv->fgcolor;
     256    uint32_t attr = cv->curattr;
    257257    unsigned int n;
    258258
     
    260260    {
    261261        cv->chars[n] = (uint32_t)' ';
    262         cv->attr[n] = color;
     262        cv->attrs[n] = attr;
    263263    }
    264264
     
    326326
    327327                dst->chars[dstix + i] = src->chars[srcix + i];
    328                 dst->attr[dstix + i] = src->attr[srcix + i];
     328                dst->attrs[dstix + i] = src->attrs[srcix + i];
    329329            }
    330330        }
    331331        else
    332332        {
    333             memcpy(dst->chars + dstix, src->chars + srcix, (stride) * 4);
    334             memcpy(dst->attr + dstix, src->attr + srcix, (stride) * 4);
     333            memcpy(dst->chars + dstix, src->chars + srcix, stride * 4);
     334            memcpy(dst->attrs + dstix, src->attrs + srcix, stride * 4);
    335335        }
    336336
     
    393393
    394394        free(cv->allchars[f]);
    395         free(cv->allattr[f]);
     395        free(cv->allattrs[f]);
    396396    }
    397397    free(cv->allchars);
    398     free(cv->allattr);
     398    free(cv->allattrs);
    399399
    400400    memcpy(cv, new, sizeof(cucul_canvas_t));
  • libcaca/trunk/cucul/colour.c

    r1231 r1254  
    2929/* RGB colours for the ANSI palette. There is no real standard, so we
    3030 * use the same values as gnome-terminal. The 7th colour (brown) is a bit
    31  * special. */
     31 * special: 0xfa50 instead of 0xfaa0. */
    3232static const uint16_t ansitab[16] =
    3333{
     
    3636};
    3737
    38 /** \brief Set the default colour pair.
    39  *
    40  *  Set the default ANSI colour pair for drawing. String functions such as
     38/** \brief Set the default character attribute.
     39 *
     40 *  Set the default character attribute for drawing. Attributes define
     41 *  foreground and background colour, transparency, bold, italics and
     42 *  underline styles, as well as blink. String functions such as
    4143 *  caca_printf() and graphical primitive functions such as caca_draw_line()
    42  *  will use these colours.
    43  *
    44  *  Color values are those defined in cucul.h, such as CUCUL_COLOR_RED
    45  *  or CUCUL_COLOR_TRANSPARENT.
     44 *  will use this attribute.
     45 *
     46 *  The attribute value is a 32-bit integer as returned by cucul_get_attr().
     47 *  For more user-friendly versions of this function, see cucul_set_attr_ansi()
     48 *  and cucul_set_attr_argb().
    4649 *
    4750 *  If an error occurs, -1 is returned and \b errno is set accordingly:
    48  *  - \c EINVAL At least one of the colour values is invalid.
     51 *  - \c EINVAL The attribute value is out of the 32-bit range.
    4952 *
    5053 *  \param cv A handle to the libcucul canvas.
    51  *  \param fg The requested foreground colour.
    52  *  \param bg The requested background colour.
     54 *  \param attr The requested attribute value.
    5355 *  \return 0 in case of success, -1 if an error occurred.
    5456 */
    55 int cucul_set_color(cucul_canvas_t *cv, unsigned char fg, unsigned char bg)
    56 {
    57     if(fg > 0x20 || bg > 0x20)
     57int cucul_set_attr(cucul_canvas_t *cv, unsigned long int attr)
     58{
     59    if(sizeof(unsigned long int) > sizeof(uint32_t) && attr > 0xffffffff)
    5860    {
    5961#if defined(HAVE_ERRNO_H)
     
    6365    }
    6466
    65     cv->fgcolor = fg;
    66     cv->bgcolor = bg;
     67    cv->curattr = attr;
    6768
    6869    return 0;
    6970}
    7071
    71 /** \brief Set the default colour pair (truecolor version).
    72  *
    73  *  Set the default colour pair for drawing. String functions such as
    74  *  caca_printf() and graphical primitive functions such as caca_draw_line()
    75  *  will use these colours.
    76  *
    77  *  Colors are 16-bit ARGB values, each component being coded on 4 bits. For
    78  *  instance, 0xf088 is solid dark cyan (A=15 R=0 G=8 B=8), and 0x8fff is
    79  *  white with 50% alpha (A=8 R=15 G=15 B=15).
     72/** \brief Set the default colour pair and text style (ANSI version).
     73 *
     74 *  Set the default ANSI colour pair and text style for drawing. String
     75 *  functions such as caca_printf() and graphical primitive functions such as
     76 *  caca_draw_line() will use these attributes.
     77 *
     78 *  Color values are those defined in cucul.h, such as CUCUL_COLOR_RED
     79 *  or CUCUL_COLOR_TRANSPARENT.
     80 *
     81 *  Style values are those defined in cucul.h, such as CUCUL_STYLE_UNDERLINE
     82 *  or CUCUL_STYLE_BLINK. The values can be ORed to set several styles at
     83 *  the same time.
    8084 *
    8185 *  If an error occurs, -1 is returned and \b errno is set accordingly:
    82  *  - \c EINVAL At least one of the colour values is invalid.
     86 *  - \c EINVAL The colour values and/or the style mask are invalid.
    8387 *
    8488 *  \param cv A handle to the libcucul canvas.
    8589 *  \param fg The requested foreground colour.
    8690 *  \param bg The requested background colour.
     91 *  \param style The requested text styles.
    8792 *  \return 0 in case of success, -1 if an error occurred.
    8893 */
    89 int cucul_set_truecolor(cucul_canvas_t *cv, unsigned int fg, unsigned int bg)
    90 {
    91     if(fg > 0xffff || bg > 0xffff)
     94int cucul_set_attr_ansi(cucul_canvas_t *cv, unsigned char fg, unsigned char bg,
     95                        unsigned char style)
     96{
     97    uint32_t attr;
     98
     99    if(fg > 0x20 || bg > 0x20 || style > 0x0f)
    92100    {
    93101#if defined(HAVE_ERRNO_H)
     
    97105    }
    98106
     107    attr = ((uint32_t)bg << 20) | ((uint32_t)fg << 4);
     108
     109    if(style)
     110        attr |= (0x02004801 * style) & 0x10011001;
     111
     112    cv->curattr = attr;
     113
     114    return 0;
     115}
     116
     117/* Legacy function for old programs */
     118int cucul_set_color(cucul_canvas_t *cv, unsigned char fg, unsigned char bg)
     119{
     120    return cucul_set_attr_ansi(cv, fg, bg, 0);
     121}
     122
     123/** \brief Set the default colour pair and text style (truecolor version).
     124 *
     125 *  Set the default colour pair and text style for drawing. String
     126 *  functions such as caca_printf() and graphical primitive functions such as
     127 *  caca_draw_line() will use these attributes.
     128 *
     129 *  Colors are 16-bit ARGB values, each component being coded on 4 bits. For
     130 *  instance, 0xf088 is solid dark cyan (A=15 R=0 G=8 B=8), and 0x8fff is
     131 *  white with 50% alpha (A=8 R=15 G=15 B=15).
     132 *
     133 *  Style values are those defined in cucul.h, such as CUCUL_STYLE_UNDERLINE
     134 *  or CUCUL_STYLE_BLINK. The values can be ORed to set several styles at
     135 *  the same time.
     136 *
     137 *  If an error occurs, -1 is returned and \b errno is set accordingly:
     138 *  - \c EINVAL At least one of the colour values is invalid.
     139 *
     140 *  \param cv A handle to the libcucul canvas.
     141 *  \param fg The requested foreground colour.
     142 *  \param bg The requested background colour.
     143 *  \param style The requested text styles.
     144 *  \return 0 in case of success, -1 if an error occurred.
     145 */
     146int cucul_set_attr_argb(cucul_canvas_t *cv, unsigned int fg, unsigned int bg,
     147                        unsigned char style)
     148{
     149    uint32_t attr;
     150
     151    if(fg > 0xffff || bg > 0xffff || style > 0x0f)
     152    {
     153#if defined(HAVE_ERRNO_H)
     154        errno = EINVAL;
     155#endif
     156        return -1;
     157    }
     158
    99159    if(fg < 0x100)
    100160        fg += 0x100;
     
    103163        bg += 0x100;
    104164
    105     cv->fgcolor = fg;
    106     cv->bgcolor = bg;
     165    attr = (((uint32_t)bg << 16) | (uint32_t)fg) & 0xeffeeffe;
     166
     167    if(style)
     168        attr |= (0x02004801 * style) & 0x10011001;
     169
     170    cv->curattr = attr;
    107171
    108172    return 0;
    109173}
    110174
    111 /** \brief Get the colour pair at the given coordinates.
    112  *
    113  *  Get the internal \e libcucul colour pair value of the character at the
    114  *  given coordinates. The colour pair value has 32 significant bits: the
    115  *  lower 16 bits are for the foreground colour, the higher 16 bits are for
    116  *  the background.
    117  *
    118  *  If the coordinates are outside the canvas boundaries, the current colour
    119  *  pair is returned.
     175/* Legacy function for old programs */
     176int cucul_set_truecolor(cucul_canvas_t *cv, unsigned int fg, unsigned int bg)
     177{
     178    return cucul_set_attr_argb(cv, fg, bg, 0);
     179}
     180
     181/** \brief Get the text attribute at the given coordinates.
     182 *
     183 *  Get the internal \e libcucul attribute value of the character at the
     184 *  given coordinates. The attribute value has 32 significant bits,
     185 *  organised as follows from MSB to LSB:
     186 *  - 3 bits for the background alpha
     187 *  - 1 bit for the blink flag
     188 *  - 4 bits for the background red component
     189 *  - 4 bits for the background green component
     190 *  - 3 bits for the background blue component
     191 *  - 1 bit for the underline flag
     192 *  - 3 bits for the foreground alpha
     193 *  - 1 bit for the italics flag
     194 *  - 4 bits for the foreground red component
     195 *  - 4 bits for the foreground green component
     196 *  - 3 bits for the foreground blue component
     197 *  - 1 bit for the bold flag
     198 *
     199 *  If the coordinates are outside the canvas boundaries, the current
     200 *  attribute is returned.
    120201 *
    121202 *  This function never fails.
     
    124205 *  \param x X coordinate.
    125206 *  \param y Y coordinate.
    126  *  \param ch The requested colour pair value.
    127  *  \return The character always returns 0.
    128  */
    129 unsigned long int cucul_get_color(cucul_canvas_t *cv, int x, int y)
     207 *  \return The requested attribute.
     208 */
     209unsigned long int cucul_get_attr(cucul_canvas_t *cv, int x, int y)
    130210{
    131211    if(x < 0 || x >= (int)cv->width || y < 0 || y >= (int)cv->height)
    132         return ((uint32_t)cv->bgcolor << 16) | (uint32_t)cv->fgcolor;
    133 
    134     return (unsigned long int)cv->attr[x + y * cv->width];
    135 }
    136 
     212        return (unsigned long int)cv->curattr;
     213
     214    return (unsigned long int)cv->attrs[x + y * cv->width];
     215}
    137216
    138217/*
     
    144223    unsigned int i, best, dist;
    145224
    146     if(argb16 < CUCUL_COLOR_DEFAULT)
    147         return argb16;
    148 
    149     if(argb16 == CUCUL_COLOR_DEFAULT || argb16 == CUCUL_COLOR_TRANSPARENT)
     225    if(argb16 == (argb16 & 0x00f0))
     226        return argb16 >> 4;
     227
     228    if(argb16 == (CUCUL_COLOR_DEFAULT << 4)
     229       || argb16 == (CUCUL_COLOR_TRANSPARENT << 4))
    150230        return def;
    151231
    152     if(argb16 < 0x5fff) /* too transparent, return default colour */
     232    if(argb16 < 0x6fff) /* too transparent, return default colour */
    153233        return def;
    154234
     
    182262}
    183263
    184 uint8_t _cucul_argb32_to_ansi8(uint32_t ch)
    185 {
    186     uint16_t fg = ch & 0xffff;
    187     uint16_t bg = ch >> 16;
     264uint8_t _cucul_attr_to_ansi8(uint32_t attr)
     265{
     266    uint16_t fg = attr & 0xeffe;
     267    uint16_t bg = (attr >> 16) & 0xeffe;
    188268
    189269    return nearest_ansi(fg, CUCUL_COLOR_LIGHTGRAY)
     
    191271}
    192272
    193 uint8_t _cucul_argb32_to_ansi4fg(uint32_t ch)
    194 {
    195     return nearest_ansi(ch & 0xffff, CUCUL_COLOR_LIGHTGRAY);
    196 }
    197 
    198 uint8_t _cucul_argb32_to_ansi4bg(uint32_t ch)
    199 {
    200     return nearest_ansi(ch >> 16, CUCUL_COLOR_BLACK);
    201 }
    202 
    203 uint16_t _cucul_argb32_to_rgb12fg(uint32_t ch)
    204 {
    205     uint16_t fg = ch & 0xffff;
    206 
    207     if(fg < CUCUL_COLOR_DEFAULT)
    208         return ansitab[fg] & 0x0fff;
    209 
    210     if(fg == CUCUL_COLOR_DEFAULT)
     273uint8_t _cucul_attr_to_ansi4fg(uint32_t attr)
     274{
     275    return nearest_ansi(attr & 0xeffe, CUCUL_COLOR_LIGHTGRAY);
     276}
     277
     278uint8_t _cucul_attr_to_ansi4bg(uint32_t attr)
     279{
     280    return nearest_ansi((attr >> 16) & 0xeffe, CUCUL_COLOR_BLACK);
     281}
     282
     283uint16_t _cucul_attr_to_rgb12fg(uint32_t attr)
     284{
     285    uint16_t fg = attr & 0xeffe;
     286
     287    if(fg == (fg & 0x00f0))
     288        return ansitab[fg >> 4] & 0x0fff;
     289
     290    if(fg == (CUCUL_COLOR_DEFAULT << 4))
    211291        return ansitab[CUCUL_COLOR_LIGHTGRAY] & 0x0fff;
    212292
    213     if(fg == CUCUL_COLOR_TRANSPARENT)
     293    if(fg == (CUCUL_COLOR_TRANSPARENT << 4))
    214294        return ansitab[CUCUL_COLOR_LIGHTGRAY] & 0x0fff;
    215295
     
    217297}
    218298
    219 uint16_t _cucul_argb32_to_rgb12bg(uint32_t ch)
    220 {
    221     uint16_t bg = ch >> 16;
    222 
    223     if(bg < CUCUL_COLOR_DEFAULT)
    224         return ansitab[bg] & 0x0fff;
    225 
    226     if(bg == CUCUL_COLOR_DEFAULT)
     299uint16_t _cucul_attr_to_rgb12bg(uint32_t attr)
     300{
     301    uint16_t bg = (attr >> 16) & 0xeffe;
     302
     303    if(bg == (bg & 0x00f0))
     304        return ansitab[bg >> 4] & 0x0fff;
     305
     306    if(bg == (CUCUL_COLOR_DEFAULT << 4))
    227307        return ansitab[CUCUL_COLOR_BLACK] & 0x0fff;
    228308
    229     if(bg == CUCUL_COLOR_TRANSPARENT)
     309    if(bg == (CUCUL_COLOR_TRANSPARENT << 4))
    230310        return ansitab[CUCUL_COLOR_BLACK] & 0x0fff;
    231311
     
    238318  | ((uint32_t)(i & 0x00f) * 0x000011))
    239319
    240 uint32_t _cucul_argb32_to_rgb24fg(uint32_t ch)
    241 {
    242     return RGB12TO24(_cucul_argb32_to_rgb12fg(ch));
    243 }
    244 
    245 uint32_t _cucul_argb32_to_rgb24bg(uint32_t ch)
    246 {
    247     return RGB12TO24(_cucul_argb32_to_rgb12bg(ch));
    248 }
    249 
    250 void _cucul_argb32_to_argb4(uint32_t ch, uint8_t argb[8])
    251 {
    252     uint16_t fg = ch & 0xffff;
    253     uint16_t bg = ch >> 16;
    254 
    255     if(fg < CUCUL_COLOR_DEFAULT)
    256         fg = ansitab[fg];
    257     else if(fg == CUCUL_COLOR_DEFAULT)
     320uint32_t _cucul_attr_to_rgb24fg(uint32_t attr)
     321{
     322    return RGB12TO24(_cucul_attr_to_rgb12fg(attr));
     323}
     324
     325uint32_t _cucul_attr_to_rgb24bg(uint32_t attr)
     326{
     327    return RGB12TO24(_cucul_attr_to_rgb12bg(attr));
     328}
     329
     330void _cucul_attr_to_argb4(uint32_t attr, uint8_t argb[8])
     331{
     332    uint16_t fg = attr & 0xeffe;
     333    uint16_t bg = (attr >> 16) & 0xeffe;
     334
     335    if(fg == (fg & 0x00f0))
     336        fg = ansitab[fg >> 4];
     337    else if(fg == (CUCUL_COLOR_DEFAULT << 4))
    258338        fg = ansitab[CUCUL_COLOR_LIGHTGRAY];
    259     else if(fg == CUCUL_COLOR_TRANSPARENT)
     339    else if(fg == (CUCUL_COLOR_TRANSPARENT << 4))
    260340        fg = 0x0fff;
    261341
    262     if(bg < CUCUL_COLOR_DEFAULT)
    263         bg = ansitab[bg];
    264     else if(bg == CUCUL_COLOR_DEFAULT)
     342    if(bg == (bg & 0x00f0))
     343        bg = ansitab[bg >> 4];
     344    else if(bg == (CUCUL_COLOR_DEFAULT << 4))
    265345        bg = ansitab[CUCUL_COLOR_BLACK];
    266     else if(bg == CUCUL_COLOR_TRANSPARENT)
     346    else if(bg == (CUCUL_COLOR_TRANSPARENT << 4))
    267347        bg = 0x0fff;
    268348
  • libcaca/trunk/cucul/cucul.c

    r1233 r1254  
    6060    cv->refcount = 0;
    6161
    62     cv->fgcolor = CUCUL_COLOR_DEFAULT;
    63     cv->bgcolor = CUCUL_COLOR_TRANSPARENT;
     62    cv->curattr = (CUCUL_COLOR_DEFAULT << 20) | (CUCUL_COLOR_TRANSPARENT < 4);
    6463
    6564    cv->width = cv->height = 0;
    6665    cv->chars = NULL;
    67     cv->attr = NULL;
     66    cv->attrs = NULL;
    6867
    6968    cv->frame = 0;
     
    7574        goto nomem;
    7675    }
    77     cv->allattr = malloc(sizeof(uint32_t *));
    78     if(!cv->allattr)
     76    cv->allattrs = malloc(sizeof(uint32_t *));
     77    if(!cv->allattrs)
    7978    {
    8079        free(cv->allchars);
     
    8382    }
    8483    cv->allchars[0] = NULL;
    85     cv->allattr[0] = NULL;
     84    cv->allattrs[0] = NULL;
    8685
    8786    if(_cucul_set_canvas_size(cv, width, height) < 0)
     
    9089        int saved_errno = errno;
    9190#endif
    92         free(cv->allattr);
     91        free(cv->allattrs);
    9392        free(cv->allchars);
    9493        free(cv);
     
    247246    {
    248247        free(cv->allchars[f]);
    249         free(cv->allattr[f]);
     248        free(cv->allattrs[f]);
    250249    }
    251250
    252251    free(cv->allchars);
    253     free(cv->allattr);
     252    free(cv->allattrs);
    254253    free(cv);
    255254
     
    305304            cv->allchars[f] = realloc(cv->allchars[f],
    306305                                      new_size * sizeof(uint32_t));
    307             cv->allattr[f] = realloc(cv->allattr[f],
     306            cv->allattrs[f] = realloc(cv->allattrs[f],
    308307                                     new_size * sizeof(uint32_t));
    309             if(!cv->allchars[f] || !cv->allattr[f])
     308            if(!cv->allchars[f] || !cv->allattrs[f])
    310309            {
    311310#if defined(HAVE_ERRNO_H)
     
    331330        {
    332331            uint32_t *chars = cv->allchars[f];
    333             uint32_t *attr = cv->allattr[f];
     332            uint32_t *attrs = cv->allattrs[f];
    334333
    335334            for(y = height < old_height ? height : old_height; y--; )
    336335            {
    337                 uint32_t color = (cv->bgcolor << 16) | cv->fgcolor;
     336                uint32_t attr = cv->curattr;
    338337
    339338                for(x = old_width; x--; )
    340339                {
    341340                    chars[y * width + x] = chars[y * old_width + x];
    342                     attr[y * width + x] = attr[y * old_width + x];
     341                    attrs[y * width + x] = attrs[y * old_width + x];
    343342                }
    344343
     
    347346                {
    348347                    chars[y * width + old_width + x] = (uint32_t)' ';
    349                     attr[y * width + old_width + x] = color;
     348                    attrs[y * width + old_width + x] = attr;
    350349                }
    351350            }
     
    361360        {
    362361            uint32_t *chars = cv->allchars[f];
    363             uint32_t *attr = cv->allattr[f];
     362            uint32_t *attrs = cv->allattrs[f];
    364363
    365364            for(y = 1; y < lines; y++)
     
    368367                {
    369368                    chars[y * width + x] = chars[y * old_width + x];
    370                     attr[y * width + x] = attr[y * old_width + x];
     369                    attrs[y * width + x] = attrs[y * old_width + x];
    371370                }
    372371            }
     
    380379        {
    381380            uint32_t *chars = cv->allchars[f];
    382             uint32_t *attr = cv->allattr[f];
    383             uint32_t color = (cv->bgcolor << 16) | cv->fgcolor;
     381            uint32_t *attrs = cv->allattrs[f];
     382            uint32_t attr = cv->curattr;
    384383
    385384            /* Zero the bottom of the screen */
     
    387386            {
    388387                chars[old_height * width + x] = (uint32_t)' ';
    389                 attr[old_height * width + x] = color;
     388                attrs[old_height * width + x] = attr;
    390389            }
    391390        }
     
    399398            cv->allchars[f] = realloc(cv->allchars[f],
    400399                                      new_size * sizeof(uint32_t));
    401             cv->allattr[f] = realloc(cv->allattr[f],
     400            cv->allattrs[f] = realloc(cv->allattrs[f],
    402401                                     new_size * sizeof(uint32_t));
    403             if(!cv->allchars[f] || !cv->allattr[f])
     402            if(!cv->allchars[f] || !cv->allattrs[f])
    404403            {
    405404#if defined(HAVE_ERRNO_H)
     
    413412    /* Reset the current frame shortcut */
    414413    cv->chars = cv->allchars[cv->frame];
    415     cv->attr = cv->allattr[cv->frame];
     414    cv->attrs = cv->allattrs[cv->frame];
    416415
    417416    return 0;
  • libcaca/trunk/cucul/cucul.h

    r1218 r1254  
    4141typedef struct cucul_font cucul_font_t;
    4242
    43 /** \defgroup colour libcucul colour definitions
    44  *
    45  *  Colours that can be used with cucul_set_color().
     43/** \defgroup attributes libcucul attribute definitions
     44 *
     45 *  Colours and styles that can be used with cucul_set_attr_ansi() and
     46 *  cucul_set_attr_argb().
    4647 *
    4748 *  @{ */
     
    6465#define CUCUL_COLOR_DEFAULT 0x10 /**< The output driver's default colour. */
    6566#define CUCUL_COLOR_TRANSPARENT 0x20 /**< The transparent colour. */
     67
     68#define CUCUL_STYLE_BOLD 0x01 /**< The style mask for bold. */
     69#define CUCUL_STYLE_ITALICS 0x02 /**< The style mask for italics. */
     70#define CUCUL_STYLE_UNDERLINE 0x04 /**< The style mask for underline. */
     71#define CUCUL_STYLE_BLINK 0x08 /**< The style mask for blink. */
    6672/*  @} */
    6773
     
    99105 *  @{ */
    100106#define CUCUL_MAGIC_FULLWIDTH 0x000ffffe /**< Used to indicate that the previous character was a fullwidth glyph. */
    101 int cucul_set_color(cucul_canvas_t *, unsigned char, unsigned char);
    102 int cucul_set_truecolor(cucul_canvas_t *, unsigned int, unsigned int);
    103 unsigned long int cucul_get_color(cucul_canvas_t *, int, int);
     107int cucul_set_attr(cucul_canvas_t *, unsigned long int);
     108int cucul_set_attr_ansi(cucul_canvas_t *, unsigned char, unsigned char,
     109                        unsigned char);
     110int cucul_set_attr_argb(cucul_canvas_t *, unsigned int, unsigned int,
     111                        unsigned char);
     112unsigned long int cucul_get_attr(cucul_canvas_t *, int, int);
    104113char const *cucul_get_color_name(unsigned int);
    105114int cucul_putchar(cucul_canvas_t *, int, int, unsigned long int);
     
    112121int cucul_set_canvas_boundaries(cucul_canvas_t *, int, int,
    113122                                unsigned int, unsigned int);
     123/* Legacy stuff */
     124int cucul_set_color(cucul_canvas_t *, unsigned char, unsigned char);
     125int cucul_set_truecolor(cucul_canvas_t *, unsigned int, unsigned int);
    114126/*  @} */
    115127
  • libcaca/trunk/cucul/cucul_internals.h

    r1218 r1254  
    2626    /* Shortcut to the active frame */
    2727    uint32_t *chars;
    28     uint32_t *attr;
     28    uint32_t *attrs;
    2929
    3030    /* Frame information */
    3131    unsigned int frame, framecount;
    3232    uint32_t **allchars;
    33     uint32_t **allattr;
     33    uint32_t **allattrs;
    3434
    3535    /* Painting context */
    36     uint16_t fgcolor;
    37     uint16_t bgcolor;
     36    uint32_t curattr;
    3837
    3938    unsigned int refcount;
     
    5958
    6059/* Colour functions */
    61 uint8_t _cucul_argb32_to_ansi8(uint32_t);
    62 uint8_t _cucul_argb32_to_ansi4fg(uint32_t);
    63 uint8_t _cucul_argb32_to_ansi4bg(uint32_t);
    64 uint16_t _cucul_argb32_to_rgb12fg(uint32_t);
    65 uint16_t _cucul_argb32_to_rgb12bg(uint32_t);
    66 uint32_t _cucul_argb32_to_rgb24fg(uint32_t);
    67 uint32_t _cucul_argb32_to_rgb24bg(uint32_t);
    68 void _cucul_argb32_to_argb4(uint32_t, uint8_t[8]);
     60uint8_t _cucul_attr_to_ansi8(uint32_t);
     61uint8_t _cucul_attr_to_ansi4fg(uint32_t);
     62uint8_t _cucul_attr_to_ansi4bg(uint32_t);
     63uint16_t _cucul_attr_to_rgb12fg(uint32_t);
     64uint16_t _cucul_attr_to_rgb12bg(uint32_t);
     65uint32_t _cucul_attr_to_rgb24fg(uint32_t);
     66uint32_t _cucul_attr_to_rgb24bg(uint32_t);
     67void _cucul_attr_to_argb4(uint32_t, uint8_t[8]);
    6968
    7069#endif /* __CUCUL_INTERNALS_H__ */
  • libcaca/trunk/cucul/export.c

    r1239 r1254  
    154154static int export_caca(cucul_canvas_t *cv, cucul_buffer_t *ex)
    155155{
    156     uint32_t *attr = cv->attr;
     156    uint32_t *attrs = cv->attrs;
    157157    uint32_t *chars = cv->chars;
    158158    char *cur;
     
    178178    {
    179179        uint32_t ch = *chars++;
    180         uint32_t a = *attr++;
     180        uint32_t a = *attrs++;
    181181
    182182        *cur++ = ch >> 24;
     
    216216    for(y = 0; y < cv->height; y++)
    217217    {
    218         uint32_t *lineattr = cv->attr + y * cv->width;
     218        uint32_t *lineattr = cv->attrs + y * cv->width;
    219219        uint32_t *linechar = cv->chars + y * cv->width;
    220220
     
    231231                continue;
    232232
    233             fg = ((attr & 0xffff) == CUCUL_COLOR_DEFAULT) ?
    234                      0x10 : palette[_cucul_argb32_to_ansi4fg(attr)];
    235             bg = ((attr >> 16) == CUCUL_COLOR_TRANSPARENT) ?
    236                      0x10 : palette[_cucul_argb32_to_ansi4bg(attr)];
     233            fg = ((attr & 0xeffe) == (CUCUL_COLOR_DEFAULT << 4)) ?
     234                     0x10 : palette[_cucul_attr_to_ansi4fg(attr)];
     235            bg = (((attr >> 16) & 0xeffe) == (CUCUL_COLOR_TRANSPARENT << 4)) ?
     236                     0x10 : palette[_cucul_attr_to_ansi4bg(attr)];
    237237
    238238            /* TODO: the [0 could be omitted in some cases */
     
    298298    for(y = 0; y < cv->height; y++)
    299299    {
    300         uint32_t *lineattr = cv->attr + y * cv->width;
     300        uint32_t *lineattr = cv->attrs + y * cv->width;
    301301        uint32_t *linechar = cv->chars + y * cv->width;
    302302
    303303        for(x = 0; x < cv->width; x++)
    304304        {
    305             uint8_t fg = palette[_cucul_argb32_to_ansi4fg(lineattr[x])];
    306             uint8_t bg = palette[_cucul_argb32_to_ansi4bg(lineattr[x])];
     305            uint8_t fg = palette[_cucul_attr_to_ansi4fg(lineattr[x])];
     306            uint8_t bg = palette[_cucul_attr_to_ansi4bg(lineattr[x])];
    307307            uint32_t ch = linechar[x];
    308308
     
    377377    for(y = 0; y < cv->height; y++)
    378378    {
    379         uint32_t *lineattr = cv->attr + y * cv->width;
     379        uint32_t *lineattr = cv->attrs + y * cv->width;
    380380        uint32_t *linechar = cv->chars + y * cv->width;
    381381
     
    384384            cur += sprintf(cur, "<span style=\"color:#%.03x;"
    385385                                "background-color:#%.03x\">",
    386                                 _cucul_argb32_to_rgb12fg(lineattr[x]),
    387                                 _cucul_argb32_to_rgb12bg(lineattr[x]));
     386                                _cucul_attr_to_rgb12fg(lineattr[x]),
     387                                _cucul_attr_to_rgb12bg(lineattr[x]));
    388388
    389389            for(len = 0;
     
    442442    for(y = 0; y < cv->height; y++)
    443443    {
    444         uint32_t *lineattr = cv->attr + y * cv->width;
     444        uint32_t *lineattr = cv->attrs + y * cv->width;
    445445        uint32_t *linechar = cv->chars + y * cv->width;
    446446
     
    458458
    459459            cur += sprintf(cur, "<td bgcolor=#%.06lx", (unsigned long int)
    460                            _cucul_argb32_to_rgb24bg(lineattr[x]));
     460                           _cucul_attr_to_rgb24bg(lineattr[x]));
    461461
    462462            if(len > 1)
     
    464464
    465465            cur += sprintf(cur, "><font color=#%.06lx>", (unsigned long int)
    466                            _cucul_argb32_to_rgb24fg(lineattr[x]));
     466                           _cucul_attr_to_rgb24fg(lineattr[x]));
    467467
    468468            for(i = 0; i < len; i++)
     
    522522    for(y = 0; y < cv->height; y++)
    523523    {
    524         uint32_t *lineattr = cv->attr + y * cv->width;
     524        uint32_t *lineattr = cv->attrs + y * cv->width;
    525525        uint32_t *linechar = cv->chars + y * cv->width;
    526526
     
    531531        {
    532532            uint32_t attr = lineattr[x];
    533             uint8_t fg = palette[_cucul_argb32_to_ansi4fg(attr)];
    534             uint8_t bg = palette[_cucul_argb32_to_ansi4bg(attr)];
     533            uint8_t fg = palette[_cucul_attr_to_ansi4fg(attr)];
     534            uint8_t bg = palette[_cucul_attr_to_ansi4bg(attr)];
    535535            uint32_t ch = linechar[x];
    536536
     
    538538                continue;
    539539
    540             if((attr & 0xffff) == CUCUL_COLOR_DEFAULT)
     540            if((attr & 0xeffe) == (CUCUL_COLOR_DEFAULT << 4))
    541541                fg = 0x10;
    542542
    543             if((attr >> 16) == CUCUL_COLOR_TRANSPARENT)
     543            if(((attr >> 16) & 0xeffe) == (CUCUL_COLOR_TRANSPARENT << 4))
    544544                bg = 0x10;
    545545
     
    645645    for(y = cv->height; y--; )
    646646    {
    647         uint32_t *lineattr = cv->attr + y * cv->width;
     647        uint32_t *lineattr = cv->attrs + y * cv->width;
    648648
    649649        for(x = 0; x < cv->width; x++)
    650650        {
    651651            uint8_t argb[8];
    652             _cucul_argb32_to_argb4(*lineattr++, argb);
     652            _cucul_attr_to_argb4(*lineattr++, argb);
    653653            cur += sprintf(cur, "1 0 translate\n %f %f %f csquare\n",
    654654                           (float)argb[1] * (1.0 / 0xf),
     
    666666    for(y = cv->height; y--; )
    667667    {
    668         uint32_t *lineattr = cv->attr + (cv->height - y - 1) * cv->width;
     668        uint32_t *lineattr = cv->attrs + (cv->height - y - 1) * cv->width;
    669669        uint32_t *linechar = cv->chars + (cv->height - y - 1) * cv->width;
    670670
     
    674674            uint32_t ch = *linechar++;
    675675
    676             _cucul_argb32_to_argb4(*lineattr++, argb);
     676            _cucul_attr_to_argb4(*lineattr++, argb);
    677677
    678678            cur += sprintf(cur, "newpath\n");
     
    739739    for(y = 0; y < cv->height; y++)
    740740    {
    741         uint32_t *lineattr = cv->attr + y * cv->width;
     741        uint32_t *lineattr = cv->attrs + y * cv->width;
    742742
    743743        for(x = 0; x < cv->width; x++)
     
    745745            cur += sprintf(cur, "<rect style=\"fill:#%.03x\" x=\"%d\" y=\"%d\""
    746746                                " width=\"6\" height=\"10\"/>\n",
    747                                 _cucul_argb32_to_rgb12bg(*lineattr++),
     747                                _cucul_attr_to_rgb12bg(*lineattr++),
    748748                                x * 6, y * 10);
    749749        }
     
    753753    for(y = 0; y < cv->height; y++)
    754754    {
    755         uint32_t *lineattr = cv->attr + y * cv->width;
     755        uint32_t *lineattr = cv->attrs + y * cv->width;
    756756        uint32_t *linechar = cv->chars + y * cv->width;
    757757
     
    768768            cur += sprintf(cur, "<text style=\"fill:#%.03x\" "
    769769                                "x=\"%d\" y=\"%d\">",
    770                                 _cucul_argb32_to_rgb12fg(*lineattr++),
     770                                _cucul_attr_to_rgb12fg(*lineattr++),
    771771                                x * 6, (y * 10) + 8);
    772772
  • libcaca/trunk/cucul/font.c

    r1072 r1254  
    421421            unsigned int startx = x * f->header.width;
    422422            uint32_t ch = cv->chars[y * cv->width + x];
    423             uint32_t attr = cv->attr[y * cv->width + x];
     423            uint32_t attr = cv->attrs[y * cv->width + x];
    424424            unsigned int b, i, j;
    425425            struct glyph_info *g;
     
    445445                                + ch - f->block_list[b].start];
    446446
    447             _cucul_argb32_to_argb4(attr, argb);
     447            _cucul_attr_to_argb4(attr, argb);
    448448
    449449            /* Step 1: unpack glyph */
  • libcaca/trunk/cucul/import.c

    r1248 r1254  
    173173            | ((uint32_t)buf[16 + 2 + 8 * n] << 8)
    174174            | (uint32_t)buf[16 + 3 + 8 * n];
    175         cv->attr[n] = ((uint32_t)buf[16 + 4 + 8 * n] << 24)
     175        cv->attrs[n] = ((uint32_t)buf[16 + 4 + 8 * n] << 24)
    176176            | ((uint32_t)buf[16 + 5 + 8 * n] << 16)
    177177            | ((uint32_t)buf[16 + 6 + 8 * n] << 8)
  • libcaca/trunk/cucul/sprite.c

    r1231 r1254  
    7373
    7474    cv->chars = cv->allchars[cv->frame];
    75     cv->attr = cv->allattr[cv->frame];
     75    cv->attrs = cv->allattrs[cv->frame];
    7676
    7777    return 0;
     
    108108    cv->framecount++;
    109109    cv->allchars = realloc(cv->allchars, sizeof(uint32_t *) * cv->framecount);
    110     cv->allattr = realloc(cv->allattr, sizeof(uint32_t *) * cv->framecount);
     110    cv->allattrs = realloc(cv->allattrs, sizeof(uint32_t *) * cv->framecount);
    111111
    112112    for(f = cv->framecount - 1; f > frame; f--)
    113113    {
    114114        cv->allchars[f] = cv->allchars[f - 1];
    115         cv->allattr[f] = cv->allattr[f - 1];
     115        cv->allattrs[f] = cv->allattrs[f - 1];
    116116    }
    117117
    118118    cv->allchars[frame] = malloc(size);
    119119    memcpy(cv->allchars[frame], cv->chars, size);
    120     cv->allattr[frame] = malloc(size);
    121     memcpy(cv->allattr[frame], cv->attr, size);
     120    cv->allattrs[frame] = malloc(size);
     121    memcpy(cv->allattrs[frame], cv->attrs, size);
    122122
    123123    if(cv->frame >= frame)
     
    125125
    126126    cv->chars = cv->allchars[cv->frame];
    127     cv->attr = cv->allattr[cv->frame];
     127    cv->attrs = cv->allattrs[cv->frame];
    128128
    129129    return 0;
     
    172172
    173173    free(cv->allchars[frame]);
    174     free(cv->allattr[frame]);
     174    free(cv->allattrs[frame]);
    175175
    176176    for(f = frame + 1; f < cv->framecount; f++)
    177177    {
    178178        cv->allchars[f - 1] = cv->allchars[f];
    179         cv->allattr[f - 1] = cv->allattr[f];
     179        cv->allattrs[f - 1] = cv->allattrs[f];
    180180    }
    181181
    182182    cv->framecount--;
    183183    cv->allchars = realloc(cv->allchars, sizeof(uint32_t *) * cv->framecount);
    184     cv->allattr = realloc(cv->allattr, sizeof(uint32_t *) * cv->framecount);
     184    cv->allattrs = realloc(cv->allattrs, sizeof(uint32_t *) * cv->framecount);
    185185
    186186    if(cv->frame > frame)
     
    190190
    191191    cv->chars = cv->allchars[cv->frame];
    192     cv->attr = cv->allattr[cv->frame];
     192    cv->attrs = cv->allattrs[cv->frame];
    193193
    194194    return 0;
  • libcaca/trunk/cucul/transform.c

    r1231 r1254  
    4141int cucul_invert(cucul_canvas_t *cv)
    4242{
    43     uint32_t *attr = cv->attr;
     43    uint32_t *attrs = cv->attrs;
    4444    unsigned int i;
    4545
    4646    for(i = cv->height * cv->width; i--; )
    4747    {
    48         *attr = *attr ^ 0x000f000f;
    49         attr++;
     48        *attrs = *attrs ^ 0x000f000f;
     49        attrs++;
    5050    }
    5151
     
    7171        uint32_t *cleft = cv->chars + y * cv->width;
    7272        uint32_t *cright = cleft + cv->width - 1;
    73         uint32_t *aleft = cv->attr + y * cv->width;
     73        uint32_t *aleft = cv->attrs + y * cv->width;
    7474        uint32_t *aright = aleft + cv->width - 1;
    7575
     
    128128        uint32_t *ctop = cv->chars + x;
    129129        uint32_t *cbottom = ctop + cv->width * (cv->height - 1);
    130         uint32_t *atop = cv->attr + x;
     130        uint32_t *atop = cv->attrs + x;
    131131        uint32_t *abottom = atop + cv->width * (cv->height - 1);
    132132
     
    167167    uint32_t *cbegin = cv->chars;
    168168    uint32_t *cend = cbegin + cv->width * cv->height - 1;
    169     uint32_t *abegin = cv->attr;
     169    uint32_t *abegin = cv->attrs;
    170170    uint32_t *aend = abegin + cv->width * cv->height - 1;
    171171    unsigned int y;
Note: See TracChangeset for help on using the changeset viewer.