Changeset 1254Tweet

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:

• caca/caca0.h (modified) (1 diff)
• caca/driver_conio.c (modified) (3 diffs)
• caca/driver_gl.c (modified) (4 diffs)
• caca/driver_ncurses.c (modified) (2 diffs)
• caca/driver_slang.c (modified) (3 diffs)
• caca/driver_vga.c (modified) (3 diffs)
• caca/driver_win32.c (modified) (2 diffs)
• caca/driver_x11.c (modified) (3 diffs)
• cucul/canvas.c (modified) (5 diffs)
• cucul/colour.c (modified) (11 diffs)
• cucul/cucul.c (modified) (14 diffs)
• cucul/cucul.h (modified) (4 diffs)
• cucul/cucul_internals.h (modified) (2 diffs)
• cucul/export.c (modified) (20 diffs)
• cucul/font.c (modified) (2 diffs)
• cucul/import.c (modified) (1 diff)
• cucul/sprite.c (modified) (5 diffs)
• cucul/transform.c (modified) (4 diffs)

libcaca/trunk/caca/caca0.h

@@ -131 +131 @@
 
 #define caca_set_color(x, y) \
-    (__caca0_fg = (x), __caca0_bg = (y), cucul_set_color(__caca0_cv, x, y))
+    (__caca0_fg = (x), __caca0_bg = (y), \
+     cucul_set_attr_ansi(__caca0_cv, x, y, 0))
 #define caca_get_fg_color() __caca0_fg
 #define caca_get_bg_color() __caca0_bg

libcaca/trunk/caca/driver_conio.c

@@ -98 +98 @@
 {
     char *screen = dp->drv.p->screen;
-    uint32_t *attr = dp->cv->attr;
+    uint32_t *attrs = dp->cv->attrs;
     uint32_t *chars = dp->cv->chars;
     unsigned int n;
@@ -108 +108 @@
         {
             *screen++ = '[';
-            *screen++ = _cucul_argb32_to_ansi8(*attr++);
+            *screen++ = _cucul_attr_to_ansi8(*attrs++);
             ch = ']';
             chars++;
@@ -114 +114 @@
         }
         *screen++ = ch;
-        *screen++ = _cucul_argb32_to_ansi8(*attr++);
+        *screen++ = _cucul_attr_to_ansi8(*attrs++);
     }
 #   if defined(SCREENUPDATE_IN_PC_H)

libcaca/trunk/caca/driver_gl.c

@@ -215 +215 @@
     for(y = 0; y < dp->drv.p->height; y += dp->drv.p->font_height)
     {
-        uint32_t *attr = dp->cv->attr + line * dp->cv->width;
+        uint32_t *attrs = dp->cv->attrs + line * dp->cv->width;
 
         /* FIXME: optimise using stride */
         for(x = 0; x < dp->drv.p->width; x += dp->drv.p->font_width)
         {
-            uint16_t bg = _cucul_argb32_to_rgb12bg(*attr++);
+            uint16_t bg = _cucul_attr_to_rgb12bg(*attrs++);
 
             glColor4b(((bg & 0xf00) >> 8) * 8,
@@ -245 +245 @@
     for(y = 0; y < dp->drv.p->height; y += dp->drv.p->font_height, line++)
     {
-        uint32_t *attr = dp->cv->attr + line * dp->cv->width;
+        uint32_t *attrs = dp->cv->attrs + line * dp->cv->width;
         uint32_t *chars = dp->cv->chars + line * dp->cv->width;
 
-        for(x = 0; x < dp->drv.p->width; x += dp->drv.p->font_width, attr++)
+        for(x = 0; x < dp->drv.p->width; x += dp->drv.p->font_width, attrs++)
         {
             uint32_t ch = *chars++;
@@ -272 +272 @@
                                         - (uint32_t)dp->drv.p->blocks[i]]);
 
-                fg = _cucul_argb32_to_rgb12fg(*attr);
+                fg = _cucul_attr_to_rgb12fg(*attrs);
                 glColor3b(((fg & 0xf00) >> 8) * 8,
                           ((fg & 0x0f0) >> 4) * 8,
@@ -292 +292 @@
             if(fullwidth)
             {
-                chars++; attr++; x += dp->drv.p->font_width;
+                chars++; attrs++; x += dp->drv.p->font_width;
             }
         }

libcaca/trunk/caca/driver_ncurses.c

@@ -197 +197 @@
 {
     int x, y;
-    uint32_t *attr = dp->cv->attr;
+    uint32_t *attrs = dp->cv->attrs;
     uint32_t *chars = dp->cv->chars;
     for(y = 0; y < (int)dp->cv->height; y++)
@@ -204 +204 @@
         for(x = dp->cv->width; x--; )
         {
-            attrset(dp->drv.p->attr[_cucul_argb32_to_ansi8(*attr++)]);
+            attrset(dp->drv.p->attr[_cucul_attr_to_ansi8(*attrs++)]);
             ncurses_write_utf32(*chars++);
         }

libcaca/trunk/caca/driver_slang.c

@@ -202 +202 @@
 {
     int x, y;
-    uint32_t *attr = dp->cv->attr;
+    uint32_t *attrs = dp->cv->attrs;
     uint32_t *chars = dp->cv->chars;
     for(y = 0; y < (int)dp->cv->height; y++)
@@ -218 +218 @@
              * bright backgrounds, it's just fucked up. */
 #if 0
-            uint8_t fgcolor = _cucul_argb32_to_ansi4fg(*attr);
-            uint8_t bgcolor = _cucul_argb32_to_ansi4bg(*attr);
+            uint8_t fgcolor = _cucul_attr_to_ansi4fg(*attrs);
+            uint8_t bgcolor = _cucul_attr_to_ansi4bg(*attrs);
 
             if(fgcolor == bgcolor)
@@ -232 +232 @@
                 SLsmg_set_color(slang_assoc[fgcolor + 16 * bgcolor]);
                 SLsmg_write_char(' ');
-                attr++;
+                attrs++;
             }
             else
 #endif
             {
-                SLsmg_set_color(slang_assoc[_cucul_argb32_to_ansi8(*attr++)]);
+                SLsmg_set_color(slang_assoc[_cucul_attr_to_ansi8(*attrs++)]);
                 slang_write_utf32(ch);
             }
 #else
-            SLsmg_set_color(_cucul_argb32_to_ansi8(*attr++));
+            SLsmg_set_color(_cucul_attr_to_ansi8(*attrs++));
             slang_write_utf32(ch);
 #endif

libcaca/trunk/caca/driver_vga.c

@@ -116 +116 @@
 {
     char *screen = (char *)(intptr_t)0x000b8000;
-    uint32_t *attr = dp->cv->attr;
+    uint32_t *attrs = dp->cv->attrs;
     uint32_t *chars = dp->cv->chars;
     int n;
@@ -126 +126 @@
         {
             *screen++ = '[';
-            *screen++ = _cucul_argb32_to_ansi8(*attr++);
+            *screen++ = _cucul_attr_to_ansi8(*attrs++);
             ch = ']';
             chars++;
@@ -132 +132 @@
         }
         *screen++ = ch;
-        *screen++ = _cucul_argb32_to_ansi8(*attr++);
+        *screen++ = _cucul_attr_to_ansi8(*attrs++);
     }
 }

libcaca/trunk/caca/driver_win32.c

@@ -191 +191 @@
     SMALL_RECT rect;
     CHAR_INFO *buffer = dp->drv.p->buffer;
-    uint32_t *attr = dp->cv->attr;
+    uint32_t *attrs = dp->cv->attrs;
     uint32_t *chars = dp->cv->chars;
     unsigned int n;
@@ -215 +215 @@
 
         buffer->Attributes =
-                win32_fg_palette[_cucul_argb32_to_ansi4fg(*attr)]
-                 | win32_bg_palette[_cucul_argb32_to_ansi4bg(*attr)];
-        attr++;
+                win32_fg_palette[_cucul_attr_to_ansi4fg(*attrs)]
+                 | win32_bg_palette[_cucul_attr_to_ansi4bg(*attrs)];
+        attrs++;
         buffer++;
     }

libcaca/trunk/caca/driver_x11.c

@@ -247 +247 @@
         for(x = 0; x < dp->cv->width; x += len)
         {
-            uint32_t *attr = dp->cv->attr + x + y * dp->cv->width;
-            uint16_t bg = _cucul_argb32_to_rgb12bg(*attr);
+            uint32_t *attrs = dp->cv->attrs + x + y * dp->cv->width;
+            uint16_t bg = _cucul_attr_to_rgb12bg(*attrs);
 
             len = 1;
             while(x + len < dp->cv->width
-                   && _cucul_argb32_to_rgb12bg(attr[len]) == bg)
+                   && _cucul_attr_to_rgb12bg(attrs[len]) == bg)
                 len++;
 
@@ -272 +272 @@
         for(x = 0; x < dp->cv->width; x++, chars++)
         {
-            uint32_t *attr = dp->cv->attr + x + y * dp->cv->width;
+            uint32_t *attrs = dp->cv->attrs + x + y * dp->cv->width;
 
             /* Skip spaces */
@@ -282 +282 @@
 
             XSetForeground(dp->drv.p->dpy, dp->drv.p->gc,
-                           dp->drv.p->colors[_cucul_argb32_to_rgb12fg(*attr)]);
+                           dp->drv.p->colors[_cucul_attr_to_rgb12fg(*attrs)]);
 
             /* Plain ASCII, no problem. */

libcaca/trunk/cucul/canvas.c

@@ -87 +87 @@
 
     curchar = cv->chars + x + y * cv->width;
-    curattr = cv->attr + x + y * cv->width;
-    attr = (cv->bgcolor << 16) | cv->fgcolor;
+    curattr = cv->attrs + x + y * cv->width;
+    attr = cv->curattr;
 
     /* When overwriting the right part of a fullwidth character,
@@ -254 +254 @@
 int cucul_clear_canvas(cucul_canvas_t *cv)
 {
-    uint32_t color = (cv->bgcolor << 16) | cv->fgcolor;
+    uint32_t attr = cv->curattr;
     unsigned int n;
 
@@ -260 +260 @@
     {
         cv->chars[n] = (uint32_t)' ';
-        cv->attr[n] = color;
+        cv->attrs[n] = attr;
     }
 
@@ -326 +326 @@
 
                 dst->chars[dstix + i] = src->chars[srcix + i];
-                dst->attr[dstix + i] = src->attr[srcix + i];
+                dst->attrs[dstix + i] = src->attrs[srcix + i];
             }
         }
         else
         {
-            memcpy(dst->chars + dstix, src->chars + srcix, (stride) * 4);
-            memcpy(dst->attr + dstix, src->attr + srcix, (stride) * 4);
+            memcpy(dst->chars + dstix, src->chars + srcix, stride * 4);
+            memcpy(dst->attrs + dstix, src->attrs + srcix, stride * 4);
         }
 
@@ -393 +393 @@
 
         free(cv->allchars[f]);
-        free(cv->allattr[f]);
+        free(cv->allattrs[f]);
     }
     free(cv->allchars);
-    free(cv->allattr);
+    free(cv->allattrs);
 
     memcpy(cv, new, sizeof(cucul_canvas_t));

libcaca/trunk/cucul/colour.c

@@ -29 +29 @@
 /* RGB colours for the ANSI palette. There is no real standard, so we
  * use the same values as gnome-terminal. The 7th colour (brown) is a bit
- * special. */
+ * special: 0xfa50 instead of 0xfaa0. */
 static const uint16_t ansitab[16] =
 {
@@ -36 +36 @@
 };
 
-/** \brief Set the default colour pair.
- *
- *  Set the default ANSI colour pair for drawing. String functions such as
+/** \brief Set the default character attribute.
+ *
+ *  Set the default character attribute for drawing. Attributes define
+ *  foreground and background colour, transparency, bold, italics and
+ *  underline styles, as well as blink. String functions such as
  *  caca_printf() and graphical primitive functions such as caca_draw_line()
- *  will use these colours.
- *
- *  Color values are those defined in cucul.h, such as CUCUL_COLOR_RED
- *  or CUCUL_COLOR_TRANSPARENT.
+ *  will use this attribute.
+ *
+ *  The attribute value is a 32-bit integer as returned by cucul_get_attr().
+ *  For more user-friendly versions of this function, see cucul_set_attr_ansi()
+ *  and cucul_set_attr_argb().
  *
  *  If an error occurs, -1 is returned and \b errno is set accordingly:
- *  - \c EINVAL At least one of the colour values is invalid.
+ *  - \c EINVAL The attribute value is out of the 32-bit range.
  *
  *  \param cv A handle to the libcucul canvas.
- *  \param fg The requested foreground colour.
- *  \param bg The requested background colour.
+ *  \param attr The requested attribute value.
  *  \return 0 in case of success, -1 if an error occurred.
  */
-int cucul_set_color(cucul_canvas_t *cv, unsigned char fg, unsigned char bg)
-{
-    if(fg > 0x20 || bg > 0x20)
+int cucul_set_attr(cucul_canvas_t *cv, unsigned long int attr)
+{
+    if(sizeof(unsigned long int) > sizeof(uint32_t) && attr > 0xffffffff)
     {
 #if defined(HAVE_ERRNO_H)
@@ -63 +65 @@
     }
 
-    cv->fgcolor = fg;
-    cv->bgcolor = bg;
+    cv->curattr = attr;
 
     return 0;
 }
 
-/** \brief Set the default colour pair (truecolor version).
- *
- *  Set the default colour pair for drawing. String functions such as
- *  caca_printf() and graphical primitive functions such as caca_draw_line()
- *  will use these colours.
- *
- *  Colors are 16-bit ARGB values, each component being coded on 4 bits. For
- *  instance, 0xf088 is solid dark cyan (A=15 R=0 G=8 B=8), and 0x8fff is
- *  white with 50% alpha (A=8 R=15 G=15 B=15).
+/** \brief Set the default colour pair and text style (ANSI version).
+ *
+ *  Set the default ANSI colour pair and text style for drawing. String
+ *  functions such as caca_printf() and graphical primitive functions such as
+ *  caca_draw_line() will use these attributes.
+ *
+ *  Color values are those defined in cucul.h, such as CUCUL_COLOR_RED
+ *  or CUCUL_COLOR_TRANSPARENT.
+ *
+ *  Style values are those defined in cucul.h, such as CUCUL_STYLE_UNDERLINE
+ *  or CUCUL_STYLE_BLINK. The values can be ORed to set several styles at
+ *  the same time.
  *
  *  If an error occurs, -1 is returned and \b errno is set accordingly:
- *  - \c EINVAL At least one of the colour values is invalid.
+ *  - \c EINVAL The colour values and/or the style mask are invalid.
  *
  *  \param cv A handle to the libcucul canvas.
  *  \param fg The requested foreground colour.
  *  \param bg The requested background colour.
+ *  \param style The requested text styles.
  *  \return 0 in case of success, -1 if an error occurred.
  */
-int cucul_set_truecolor(cucul_canvas_t *cv, unsigned int fg, unsigned int bg)
-{
-    if(fg > 0xffff || bg > 0xffff)
+int cucul_set_attr_ansi(cucul_canvas_t *cv, unsigned char fg, unsigned char bg,
+                        unsigned char style)
+{
+    uint32_t attr;
+
+    if(fg > 0x20 || bg > 0x20 || style > 0x0f)
     {
 #if defined(HAVE_ERRNO_H)
@@ -97 +105 @@
     }
 
+    attr = ((uint32_t)bg << 20) | ((uint32_t)fg << 4);
+
+    if(style)
+        attr |= (0x02004801 * style) & 0x10011001;
+
+    cv->curattr = attr;
+
+    return 0;
+}
+
+/* Legacy function for old programs */
+int cucul_set_color(cucul_canvas_t *cv, unsigned char fg, unsigned char bg)
+{
+    return cucul_set_attr_ansi(cv, fg, bg, 0);
+}
+
+/** \brief Set the default colour pair and text style (truecolor version).
+ *
+ *  Set the default colour pair and text style for drawing. String
+ *  functions such as caca_printf() and graphical primitive functions such as
+ *  caca_draw_line() will use these attributes.
+ *
+ *  Colors are 16-bit ARGB values, each component being coded on 4 bits. For
+ *  instance, 0xf088 is solid dark cyan (A=15 R=0 G=8 B=8), and 0x8fff is
+ *  white with 50% alpha (A=8 R=15 G=15 B=15).
+ *
+ *  Style values are those defined in cucul.h, such as CUCUL_STYLE_UNDERLINE
+ *  or CUCUL_STYLE_BLINK. The values can be ORed to set several styles at
+ *  the same time.
+ *
+ *  If an error occurs, -1 is returned and \b errno is set accordingly:
+ *  - \c EINVAL At least one of the colour values is invalid.
+ *
+ *  \param cv A handle to the libcucul canvas.
+ *  \param fg The requested foreground colour.
+ *  \param bg The requested background colour.
+ *  \param style The requested text styles.
+ *  \return 0 in case of success, -1 if an error occurred.
+ */
+int cucul_set_attr_argb(cucul_canvas_t *cv, unsigned int fg, unsigned int bg,
+                        unsigned char style)
+{
+    uint32_t attr;
+
+    if(fg > 0xffff || bg > 0xffff || style > 0x0f)
+    {
+#if defined(HAVE_ERRNO_H)
+        errno = EINVAL;
+#endif
+        return -1;
+    }
+
     if(fg < 0x100)
         fg += 0x100;
@@ -103 +163 @@
         bg += 0x100;
 
-    cv->fgcolor = fg;
-    cv->bgcolor = bg;
+    attr = (((uint32_t)bg << 16) | (uint32_t)fg) & 0xeffeeffe;
+
+    if(style)
+        attr |= (0x02004801 * style) & 0x10011001;
+
+    cv->curattr = attr;
 
     return 0;
 }
 
-/** \brief Get the colour pair at the given coordinates.
- *
- *  Get the internal \e libcucul colour pair value of the character at the
- *  given coordinates. The colour pair value has 32 significant bits: the
- *  lower 16 bits are for the foreground colour, the higher 16 bits are for
- *  the background.
- *
- *  If the coordinates are outside the canvas boundaries, the current colour
- *  pair is returned.
+/* Legacy function for old programs */
+int cucul_set_truecolor(cucul_canvas_t *cv, unsigned int fg, unsigned int bg)
+{
+    return cucul_set_attr_argb(cv, fg, bg, 0);
+}
+
+/** \brief Get the text attribute at the given coordinates.
+ *
+ *  Get the internal \e libcucul attribute value of the character at the
+ *  given coordinates. The attribute value has 32 significant bits,
+ *  organised as follows from MSB to LSB:
+ *  - 3 bits for the background alpha
+ *  - 1 bit for the blink flag
+ *  - 4 bits for the background red component
+ *  - 4 bits for the background green component
+ *  - 3 bits for the background blue component
+ *  - 1 bit for the underline flag
+ *  - 3 bits for the foreground alpha
+ *  - 1 bit for the italics flag
+ *  - 4 bits for the foreground red component
+ *  - 4 bits for the foreground green component
+ *  - 3 bits for the foreground blue component
+ *  - 1 bit for the bold flag
+ *
+ *  If the coordinates are outside the canvas boundaries, the current
+ *  attribute is returned.
  *
  *  This function never fails.
@@ -124 +205 @@
  *  \param x X coordinate.
  *  \param y Y coordinate.
- *  \param ch The requested colour pair value.
- *  \return The character always returns 0.
- */
-unsigned long int cucul_get_color(cucul_canvas_t *cv, int x, int y)
+ *  \return The requested attribute.
+ */
+unsigned long int cucul_get_attr(cucul_canvas_t *cv, int x, int y)
 {
     if(x < 0 || x >= (int)cv->width || y < 0 || y >= (int)cv->height)
-        return ((uint32_t)cv->bgcolor << 16) | (uint32_t)cv->fgcolor;
-
-    return (unsigned long int)cv->attr[x + y * cv->width];
-}
-
+        return (unsigned long int)cv->curattr;
+
+    return (unsigned long int)cv->attrs[x + y * cv->width];
+}
 
 /*
@@ -144 +223 @@
     unsigned int i, best, dist;
 
-    if(argb16 < CUCUL_COLOR_DEFAULT)
-        return argb16;
-
-    if(argb16 == CUCUL_COLOR_DEFAULT || argb16 == CUCUL_COLOR_TRANSPARENT)
+    if(argb16 == (argb16 & 0x00f0))
+        return argb16 >> 4;
+
+    if(argb16 == (CUCUL_COLOR_DEFAULT << 4)
+       || argb16 == (CUCUL_COLOR_TRANSPARENT << 4))
         return def;
 
-    if(argb16 < 0x5fff) /* too transparent, return default colour */
+    if(argb16 < 0x6fff) /* too transparent, return default colour */
         return def;
 
@@ -182 +262 @@
 }
 
-uint8_t _cucul_argb32_to_ansi8(uint32_t ch)
-{
-    uint16_t fg = ch & 0xffff;
-    uint16_t bg = ch >> 16;
+uint8_t _cucul_attr_to_ansi8(uint32_t attr)
+{
+    uint16_t fg = attr & 0xeffe;
+    uint16_t bg = (attr >> 16) & 0xeffe;
 
     return nearest_ansi(fg, CUCUL_COLOR_LIGHTGRAY)
@@ -191 +271 @@
 }
 
-uint8_t _cucul_argb32_to_ansi4fg(uint32_t ch)
-{
-    return nearest_ansi(ch & 0xffff, CUCUL_COLOR_LIGHTGRAY);
-}
-
-uint8_t _cucul_argb32_to_ansi4bg(uint32_t ch)
-{
-    return nearest_ansi(ch >> 16, CUCUL_COLOR_BLACK);
-}
-
-uint16_t _cucul_argb32_to_rgb12fg(uint32_t ch)
-{
-    uint16_t fg = ch & 0xffff;
-
-    if(fg < CUCUL_COLOR_DEFAULT)
-        return ansitab[fg] & 0x0fff;
-
-    if(fg == CUCUL_COLOR_DEFAULT)
+uint8_t _cucul_attr_to_ansi4fg(uint32_t attr)
+{
+    return nearest_ansi(attr & 0xeffe, CUCUL_COLOR_LIGHTGRAY);
+}
+
+uint8_t _cucul_attr_to_ansi4bg(uint32_t attr)
+{
+    return nearest_ansi((attr >> 16) & 0xeffe, CUCUL_COLOR_BLACK);
+}
+
+uint16_t _cucul_attr_to_rgb12fg(uint32_t attr)
+{
+    uint16_t fg = attr & 0xeffe;
+
+    if(fg == (fg & 0x00f0))
+        return ansitab[fg >> 4] & 0x0fff;
+
+    if(fg == (CUCUL_COLOR_DEFAULT << 4))
         return ansitab[CUCUL_COLOR_LIGHTGRAY] & 0x0fff;
 
-    if(fg == CUCUL_COLOR_TRANSPARENT)
+    if(fg == (CUCUL_COLOR_TRANSPARENT << 4))
         return ansitab[CUCUL_COLOR_LIGHTGRAY] & 0x0fff;
 
@@ -217 +297 @@
 }
 
-uint16_t _cucul_argb32_to_rgb12bg(uint32_t ch)
-{
-    uint16_t bg = ch >> 16;
-
-    if(bg < CUCUL_COLOR_DEFAULT)
-        return ansitab[bg] & 0x0fff;
-
-    if(bg == CUCUL_COLOR_DEFAULT)
+uint16_t _cucul_attr_to_rgb12bg(uint32_t attr)
+{
+    uint16_t bg = (attr >> 16) & 0xeffe;
+
+    if(bg == (bg & 0x00f0))
+        return ansitab[bg >> 4] & 0x0fff;
+
+    if(bg == (CUCUL_COLOR_DEFAULT << 4))
         return ansitab[CUCUL_COLOR_BLACK] & 0x0fff;
 
-    if(bg == CUCUL_COLOR_TRANSPARENT)
+    if(bg == (CUCUL_COLOR_TRANSPARENT << 4))
         return ansitab[CUCUL_COLOR_BLACK] & 0x0fff;
 
@@ -238 +318 @@
   | ((uint32_t)(i & 0x00f) * 0x000011))
 
-uint32_t _cucul_argb32_to_rgb24fg(uint32_t ch)
-{
-    return RGB12TO24(_cucul_argb32_to_rgb12fg(ch));
-}
-
-uint32_t _cucul_argb32_to_rgb24bg(uint32_t ch)
-{
-    return RGB12TO24(_cucul_argb32_to_rgb12bg(ch));
-}
-
-void _cucul_argb32_to_argb4(uint32_t ch, uint8_t argb[8])
-{
-    uint16_t fg = ch & 0xffff;
-    uint16_t bg = ch >> 16;
-
-    if(fg < CUCUL_COLOR_DEFAULT)
-        fg = ansitab[fg];
-    else if(fg == CUCUL_COLOR_DEFAULT)
+uint32_t _cucul_attr_to_rgb24fg(uint32_t attr)
+{
+    return RGB12TO24(_cucul_attr_to_rgb12fg(attr));
+}
+
+uint32_t _cucul_attr_to_rgb24bg(uint32_t attr)
+{
+    return RGB12TO24(_cucul_attr_to_rgb12bg(attr));
+}
+
+void _cucul_attr_to_argb4(uint32_t attr, uint8_t argb[8])
+{
+    uint16_t fg = attr & 0xeffe;
+    uint16_t bg = (attr >> 16) & 0xeffe;
+
+    if(fg == (fg & 0x00f0))
+        fg = ansitab[fg >> 4];
+    else if(fg == (CUCUL_COLOR_DEFAULT << 4))
         fg = ansitab[CUCUL_COLOR_LIGHTGRAY];
-    else if(fg == CUCUL_COLOR_TRANSPARENT)
+    else if(fg == (CUCUL_COLOR_TRANSPARENT << 4))
         fg = 0x0fff;
 
-    if(bg < CUCUL_COLOR_DEFAULT)
-        bg = ansitab[bg];
-    else if(bg == CUCUL_COLOR_DEFAULT)
+    if(bg == (bg & 0x00f0))
+        bg = ansitab[bg >> 4];
+    else if(bg == (CUCUL_COLOR_DEFAULT << 4))
         bg = ansitab[CUCUL_COLOR_BLACK];
-    else if(bg == CUCUL_COLOR_TRANSPARENT)
+    else if(bg == (CUCUL_COLOR_TRANSPARENT << 4))
         bg = 0x0fff;
 

libcaca/trunk/cucul/cucul.c

@@ -60 +60 @@
     cv->refcount = 0;
 
-    cv->fgcolor = CUCUL_COLOR_DEFAULT;
-    cv->bgcolor = CUCUL_COLOR_TRANSPARENT;
+    cv->curattr = (CUCUL_COLOR_DEFAULT << 20) | (CUCUL_COLOR_TRANSPARENT < 4);
 
     cv->width = cv->height = 0;
     cv->chars = NULL;
-    cv->attr = NULL;
+    cv->attrs = NULL;
 
     cv->frame = 0;
@@ -75 +74 @@
         goto nomem;
     }
-    cv->allattr = malloc(sizeof(uint32_t *));
-    if(!cv->allattr)
+    cv->allattrs = malloc(sizeof(uint32_t *));
+    if(!cv->allattrs)
     {
         free(cv->allchars);
@@ -83 +82 @@
     }
     cv->allchars[0] = NULL;
-    cv->allattr[0] = NULL;
+    cv->allattrs[0] = NULL;
 
     if(_cucul_set_canvas_size(cv, width, height) < 0)
@@ -90 +89 @@
         int saved_errno = errno;
 #endif
-        free(cv->allattr);
+        free(cv->allattrs);
         free(cv->allchars);
         free(cv);
@@ -247 +246 @@
     {
         free(cv->allchars[f]);
-        free(cv->allattr[f]);
+        free(cv->allattrs[f]);
     }
 
     free(cv->allchars);
-    free(cv->allattr);
+    free(cv->allattrs);
     free(cv);
 
@@ -305 +304 @@
             cv->allchars[f] = realloc(cv->allchars[f],
                                       new_size * sizeof(uint32_t));
-            cv->allattr[f] = realloc(cv->allattr[f],
+            cv->allattrs[f] = realloc(cv->allattrs[f],
                                      new_size * sizeof(uint32_t));
-            if(!cv->allchars[f] || !cv->allattr[f])
+            if(!cv->allchars[f] || !cv->allattrs[f])
             {
 #if defined(HAVE_ERRNO_H)
@@ -331 +330 @@
         {
             uint32_t *chars = cv->allchars[f];
-            uint32_t *attr = cv->allattr[f];
+            uint32_t *attrs = cv->allattrs[f];
 
             for(y = height < old_height ? height : old_height; y--; )
             {
-                uint32_t color = (cv->bgcolor << 16) | cv->fgcolor;
+                uint32_t attr = cv->curattr;
 
                 for(x = old_width; x--; )
                 {
                     chars[y * width + x] = chars[y * old_width + x];
-                    attr[y * width + x] = attr[y * old_width + x];
+                    attrs[y * width + x] = attrs[y * old_width + x];
                 }
 
@@ -347 +346 @@
                 {
                     chars[y * width + old_width + x] = (uint32_t)' ';
-                    attr[y * width + old_width + x] = color;
+                    attrs[y * width + old_width + x] = attr;
                 }
             }
@@ -361 +360 @@
         {
             uint32_t *chars = cv->allchars[f];
-            uint32_t *attr = cv->allattr[f];
+            uint32_t *attrs = cv->allattrs[f];
 
             for(y = 1; y < lines; y++)
@@ -368 +367 @@
                 {
                     chars[y * width + x] = chars[y * old_width + x];
-                    attr[y * width + x] = attr[y * old_width + x];
+                    attrs[y * width + x] = attrs[y * old_width + x];
                 }
             }
@@ -380 +379 @@
         {
             uint32_t *chars = cv->allchars[f];
-            uint32_t *attr = cv->allattr[f];
-            uint32_t color = (cv->bgcolor << 16) | cv->fgcolor;
+            uint32_t *attrs = cv->allattrs[f];
+            uint32_t attr = cv->curattr;
 
             /* Zero the bottom of the screen */
@@ -387 +386 @@
             {
                 chars[old_height * width + x] = (uint32_t)' ';
-                attr[old_height * width + x] = color;
+                attrs[old_height * width + x] = attr;
             }
         }
@@ -399 +398 @@
             cv->allchars[f] = realloc(cv->allchars[f],
                                       new_size * sizeof(uint32_t));
-            cv->allattr[f] = realloc(cv->allattr[f],
+            cv->allattrs[f] = realloc(cv->allattrs[f],
                                      new_size * sizeof(uint32_t));
-            if(!cv->allchars[f] || !cv->allattr[f])
+            if(!cv->allchars[f] || !cv->allattrs[f])
             {
 #if defined(HAVE_ERRNO_H)
@@ -413 +412 @@
     /* Reset the current frame shortcut */
     cv->chars = cv->allchars[cv->frame];
-    cv->attr = cv->allattr[cv->frame];
+    cv->attrs = cv->allattrs[cv->frame];
 
     return 0;

libcaca/trunk/cucul/cucul.h

@@ -41 +41 @@
 typedef struct cucul_font cucul_font_t;
 
-/** \defgroup colour libcucul colour definitions
- *
- *  Colours that can be used with cucul_set_color().
+/** \defgroup attributes libcucul attribute definitions
+ *
+ *  Colours and styles that can be used with cucul_set_attr_ansi() and
+ *  cucul_set_attr_argb().
  *
  *  @{ */
@@ -64 +65 @@
 #define CUCUL_COLOR_DEFAULT 0x10 /**< The output driver's default colour. */
 #define CUCUL_COLOR_TRANSPARENT 0x20 /**< The transparent colour. */
+
+#define CUCUL_STYLE_BOLD 0x01 /**< The style mask for bold. */
+#define CUCUL_STYLE_ITALICS 0x02 /**< The style mask for italics. */
+#define CUCUL_STYLE_UNDERLINE 0x04 /**< The style mask for underline. */
+#define CUCUL_STYLE_BLINK 0x08 /**< The style mask for blink. */
 /*  @} */
 
@@ -99 +105 @@
  *  @{ */
 #define CUCUL_MAGIC_FULLWIDTH 0x000ffffe /**< Used to indicate that the previous character was a fullwidth glyph. */
-int cucul_set_color(cucul_canvas_t *, unsigned char, unsigned char);
-int cucul_set_truecolor(cucul_canvas_t *, unsigned int, unsigned int);
-unsigned long int cucul_get_color(cucul_canvas_t *, int, int);
+int cucul_set_attr(cucul_canvas_t *, unsigned long int);
+int cucul_set_attr_ansi(cucul_canvas_t *, unsigned char, unsigned char,
+                        unsigned char);
+int cucul_set_attr_argb(cucul_canvas_t *, unsigned int, unsigned int,
+                        unsigned char);
+unsigned long int cucul_get_attr(cucul_canvas_t *, int, int);
 char const *cucul_get_color_name(unsigned int);
 int cucul_putchar(cucul_canvas_t *, int, int, unsigned long int);
@@ -112 +121 @@
 int cucul_set_canvas_boundaries(cucul_canvas_t *, int, int,
                                 unsigned int, unsigned int);
+/* Legacy stuff */
+int cucul_set_color(cucul_canvas_t *, unsigned char, unsigned char);
+int cucul_set_truecolor(cucul_canvas_t *, unsigned int, unsigned int);
 /*  @} */
 

libcaca/trunk/cucul/cucul_internals.h

@@ -26 +26 @@
     /* Shortcut to the active frame */
     uint32_t *chars;
-    uint32_t *attr;
+    uint32_t *attrs;
 
     /* Frame information */
     unsigned int frame, framecount;
     uint32_t **allchars;
-    uint32_t **allattr;
+    uint32_t **allattrs;
 
     /* Painting context */
-    uint16_t fgcolor;
-    uint16_t bgcolor;
+    uint32_t curattr;
 
     unsigned int refcount;
@@ -59 +58 @@
 
 /* Colour functions */
-uint8_t _cucul_argb32_to_ansi8(uint32_t);
-uint8_t _cucul_argb32_to_ansi4fg(uint32_t);
-uint8_t _cucul_argb32_to_ansi4bg(uint32_t);
-uint16_t _cucul_argb32_to_rgb12fg(uint32_t);
-uint16_t _cucul_argb32_to_rgb12bg(uint32_t);
-uint32_t _cucul_argb32_to_rgb24fg(uint32_t);
-uint32_t _cucul_argb32_to_rgb24bg(uint32_t);
-void _cucul_argb32_to_argb4(uint32_t, uint8_t[8]);
+uint8_t _cucul_attr_to_ansi8(uint32_t);
+uint8_t _cucul_attr_to_ansi4fg(uint32_t);
+uint8_t _cucul_attr_to_ansi4bg(uint32_t);
+uint16_t _cucul_attr_to_rgb12fg(uint32_t);
+uint16_t _cucul_attr_to_rgb12bg(uint32_t);
+uint32_t _cucul_attr_to_rgb24fg(uint32_t);
+uint32_t _cucul_attr_to_rgb24bg(uint32_t);
+void _cucul_attr_to_argb4(uint32_t, uint8_t[8]);
 
 #endif /* __CUCUL_INTERNALS_H__ */

libcaca/trunk/cucul/export.c

@@ -154 +154 @@
 static int export_caca(cucul_canvas_t *cv, cucul_buffer_t *ex)
 {
-    uint32_t *attr = cv->attr;
+    uint32_t *attrs = cv->attrs;
     uint32_t *chars = cv->chars;
     char *cur;
@@ -178 +178 @@
     {
         uint32_t ch = *chars++;
-        uint32_t a = *attr++;
+        uint32_t a = *attrs++;
 
         *cur++ = ch >> 24;
@@ -216 +216 @@
     for(y = 0; y < cv->height; y++)
     {
-        uint32_t *lineattr = cv->attr + y * cv->width;
+        uint32_t *lineattr = cv->attrs + y * cv->width;
         uint32_t *linechar = cv->chars + y * cv->width;
 
@@ -231 +231 @@
                 continue;
 
-            fg = ((attr & 0xffff) == CUCUL_COLOR_DEFAULT) ?
-                     0x10 : palette[_cucul_argb32_to_ansi4fg(attr)];
-            bg = ((attr >> 16) == CUCUL_COLOR_TRANSPARENT) ?
-                     0x10 : palette[_cucul_argb32_to_ansi4bg(attr)];
+            fg = ((attr & 0xeffe) == (CUCUL_COLOR_DEFAULT << 4)) ?
+                     0x10 : palette[_cucul_attr_to_ansi4fg(attr)];
+            bg = (((attr >> 16) & 0xeffe) == (CUCUL_COLOR_TRANSPARENT << 4)) ?
+                     0x10 : palette[_cucul_attr_to_ansi4bg(attr)];
 
             /* TODO: the [0 could be omitted in some cases */
@@ -298 +298 @@
     for(y = 0; y < cv->height; y++)
     {
-        uint32_t *lineattr = cv->attr + y * cv->width;
+        uint32_t *lineattr = cv->attrs + y * cv->width;
         uint32_t *linechar = cv->chars + y * cv->width;
 
         for(x = 0; x < cv->width; x++)
         {
-            uint8_t fg = palette[_cucul_argb32_to_ansi4fg(lineattr[x])];
-            uint8_t bg = palette[_cucul_argb32_to_ansi4bg(lineattr[x])];
+            uint8_t fg = palette[_cucul_attr_to_ansi4fg(lineattr[x])];
+            uint8_t bg = palette[_cucul_attr_to_ansi4bg(lineattr[x])];
             uint32_t ch = linechar[x];
 
@@ -377 +377 @@
     for(y = 0; y < cv->height; y++)
     {
-        uint32_t *lineattr = cv->attr + y * cv->width;
+        uint32_t *lineattr = cv->attrs + y * cv->width;
         uint32_t *linechar = cv->chars + y * cv->width;
 
@@ -384 +384 @@
             cur += sprintf(cur, "<span style=\"color:#%.03x;"
                                 "background-color:#%.03x\">",
-                                _cucul_argb32_to_rgb12fg(lineattr[x]),
-                                _cucul_argb32_to_rgb12bg(lineattr[x]));
+                                _cucul_attr_to_rgb12fg(lineattr[x]),
+                                _cucul_attr_to_rgb12bg(lineattr[x]));
 
             for(len = 0;
@@ -442 +442 @@
     for(y = 0; y < cv->height; y++)
     {
-        uint32_t *lineattr = cv->attr + y * cv->width;
+        uint32_t *lineattr = cv->attrs + y * cv->width;
         uint32_t *linechar = cv->chars + y * cv->width;
 
@@ -458 +458 @@
 
             cur += sprintf(cur, "<td bgcolor=#%.06lx", (unsigned long int)
-                           _cucul_argb32_to_rgb24bg(lineattr[x]));
+                           _cucul_attr_to_rgb24bg(lineattr[x]));
 
             if(len > 1)
@@ -464 +464 @@
 
             cur += sprintf(cur, "><font color=#%.06lx>", (unsigned long int)
-                           _cucul_argb32_to_rgb24fg(lineattr[x]));
+                           _cucul_attr_to_rgb24fg(lineattr[x]));
 
             for(i = 0; i < len; i++)
@@ -522 +522 @@
     for(y = 0; y < cv->height; y++)
     {
-        uint32_t *lineattr = cv->attr + y * cv->width;
+        uint32_t *lineattr = cv->attrs + y * cv->width;
         uint32_t *linechar = cv->chars + y * cv->width;
 
@@ -531 +531 @@
         {
             uint32_t attr = lineattr[x];
-            uint8_t fg = palette[_cucul_argb32_to_ansi4fg(attr)];
-            uint8_t bg = palette[_cucul_argb32_to_ansi4bg(attr)];
+            uint8_t fg = palette[_cucul_attr_to_ansi4fg(attr)];
+            uint8_t bg = palette[_cucul_attr_to_ansi4bg(attr)];
             uint32_t ch = linechar[x];
 
@@ -538 +538 @@
                 continue;
 
-            if((attr & 0xffff) == CUCUL_COLOR_DEFAULT)
+            if((attr & 0xeffe) == (CUCUL_COLOR_DEFAULT << 4))
                 fg = 0x10;
 
-            if((attr >> 16) == CUCUL_COLOR_TRANSPARENT)
+            if(((attr >> 16) & 0xeffe) == (CUCUL_COLOR_TRANSPARENT << 4))
                 bg = 0x10;
 
@@ -645 +645 @@
     for(y = cv->height; y--; )
     {
-        uint32_t *lineattr = cv->attr + y * cv->width;
+        uint32_t *lineattr = cv->attrs + y * cv->width;
 
         for(x = 0; x < cv->width; x++)
         {
             uint8_t argb[8];
-            _cucul_argb32_to_argb4(*lineattr++, argb);
+            _cucul_attr_to_argb4(*lineattr++, argb);
             cur += sprintf(cur, "1 0 translate\n %f %f %f csquare\n",
                            (float)argb[1] * (1.0 / 0xf),
@@ -666 +666 @@
     for(y = cv->height; y--; )
     {
-        uint32_t *lineattr = cv->attr + (cv->height - y - 1) * cv->width;
+        uint32_t *lineattr = cv->attrs + (cv->height - y - 1) * cv->width;
         uint32_t *linechar = cv->chars + (cv->height - y - 1) * cv->width;
 
@@ -674 +674 @@
             uint32_t ch = *linechar++;
 
-            _cucul_argb32_to_argb4(*lineattr++, argb);
+            _cucul_attr_to_argb4(*lineattr++, argb);
 
             cur += sprintf(cur, "newpath\n");
@@ -739 +739 @@
     for(y = 0; y < cv->height; y++)
     {
-        uint32_t *lineattr = cv->attr + y * cv->width;
+        uint32_t *lineattr = cv->attrs + y * cv->width;
 
         for(x = 0; x < cv->width; x++)
@@ -745 +745 @@
             cur += sprintf(cur, "<rect style=\"fill:#%.03x\" x=\"%d\" y=\"%d\""
                                 " width=\"6\" height=\"10\"/>\n",
-                                _cucul_argb32_to_rgb12bg(*lineattr++),
+                                _cucul_attr_to_rgb12bg(*lineattr++),
                                 x * 6, y * 10);
         }
@@ -753 +753 @@
     for(y = 0; y < cv->height; y++)
     {
-        uint32_t *lineattr = cv->attr + y * cv->width;
+        uint32_t *lineattr = cv->attrs + y * cv->width;
         uint32_t *linechar = cv->chars + y * cv->width;
 
@@ -768 +768 @@
             cur += sprintf(cur, "<text style=\"fill:#%.03x\" "
                                 "x=\"%d\" y=\"%d\">",
-                                _cucul_argb32_to_rgb12fg(*lineattr++),
+                                _cucul_attr_to_rgb12fg(*lineattr++),
                                 x * 6, (y * 10) + 8);
 

libcaca/trunk/cucul/font.c

@@ -421 +421 @@
             unsigned int startx = x * f->header.width;
             uint32_t ch = cv->chars[y * cv->width + x];
-            uint32_t attr = cv->attr[y * cv->width + x];
+            uint32_t attr = cv->attrs[y * cv->width + x];
             unsigned int b, i, j;
             struct glyph_info *g;
@@ -445 +445 @@
                                 + ch - f->block_list[b].start];
 
-            _cucul_argb32_to_argb4(attr, argb);
+            _cucul_attr_to_argb4(attr, argb);
 
             /* Step 1: unpack glyph */

libcaca/trunk/cucul/import.c

@@ -173 +173 @@
             | ((uint32_t)buf[16 + 2 + 8 * n] << 8)
             | (uint32_t)buf[16 + 3 + 8 * n];
-        cv->attr[n] = ((uint32_t)buf[16 + 4 + 8 * n] << 24)
+        cv->attrs[n] = ((uint32_t)buf[16 + 4 + 8 * n] << 24)
             | ((uint32_t)buf[16 + 5 + 8 * n] << 16)
             | ((uint32_t)buf[16 + 6 + 8 * n] << 8)

libcaca/trunk/cucul/sprite.c

@@ -73 +73 @@
 
     cv->chars = cv->allchars[cv->frame];
-    cv->attr = cv->allattr[cv->frame];
+    cv->attrs = cv->allattrs[cv->frame];
 
     return 0;
@@ -108 +108 @@
     cv->framecount++;
     cv->allchars = realloc(cv->allchars, sizeof(uint32_t *) * cv->framecount);
-    cv->allattr = realloc(cv->allattr, sizeof(uint32_t *) * cv->framecount);
+    cv->allattrs = realloc(cv->allattrs, sizeof(uint32_t *) * cv->framecount);
 
     for(f = cv->framecount - 1; f > frame; f--)
     {
         cv->allchars[f] = cv->allchars[f - 1];
-        cv->allattr[f] = cv->allattr[f - 1];
+        cv->allattrs[f] = cv->allattrs[f - 1];
     }
 
     cv->allchars[frame] = malloc(size);
     memcpy(cv->allchars[frame], cv->chars, size);
-    cv->allattr[frame] = malloc(size);
-    memcpy(cv->allattr[frame], cv->attr, size);
+    cv->allattrs[frame] = malloc(size);
+    memcpy(cv->allattrs[frame], cv->attrs, size);
 
     if(cv->frame >= frame)
@@ -125 +125 @@
 
     cv->chars = cv->allchars[cv->frame];
-    cv->attr = cv->allattr[cv->frame];
+    cv->attrs = cv->allattrs[cv->frame];
 
     return 0;
@@ -172 +172 @@
 
     free(cv->allchars[frame]);
-    free(cv->allattr[frame]);
+    free(cv->allattrs[frame]);
 
     for(f = frame + 1; f < cv->framecount; f++)
     {
         cv->allchars[f - 1] = cv->allchars[f];
-        cv->allattr[f - 1] = cv->allattr[f];
+        cv->allattrs[f - 1] = cv->allattrs[f];
     }
 
     cv->framecount--;
     cv->allchars = realloc(cv->allchars, sizeof(uint32_t *) * cv->framecount);
-    cv->allattr = realloc(cv->allattr, sizeof(uint32_t *) * cv->framecount);
+    cv->allattrs = realloc(cv->allattrs, sizeof(uint32_t *) * cv->framecount);
 
     if(cv->frame > frame)
@@ -190 +190 @@
 
     cv->chars = cv->allchars[cv->frame];
-    cv->attr = cv->allattr[cv->frame];
+    cv->attrs = cv->allattrs[cv->frame];
 
     return 0;

libcaca/trunk/cucul/transform.c

@@ -41 +41 @@
 int cucul_invert(cucul_canvas_t *cv)
 {
-    uint32_t *attr = cv->attr;
+    uint32_t *attrs = cv->attrs;
     unsigned int i;
 
     for(i = cv->height * cv->width; i--; )
     {
-        *attr = *attr ^ 0x000f000f;
-        attr++;
+        *attrs = *attrs ^ 0x000f000f;
+        attrs++;
     }
 
@@ -71 +71 @@
         uint32_t *cleft = cv->chars + y * cv->width;
         uint32_t *cright = cleft + cv->width - 1;
-        uint32_t *aleft = cv->attr + y * cv->width;
+        uint32_t *aleft = cv->attrs + y * cv->width;
         uint32_t *aright = aleft + cv->width - 1;
 
@@ -128 +128 @@
         uint32_t *ctop = cv->chars + x;
         uint32_t *cbottom = ctop + cv->width * (cv->height - 1);
-        uint32_t *atop = cv->attr + x;
+        uint32_t *atop = cv->attrs + x;
         uint32_t *abottom = atop + cv->width * (cv->height - 1);
 
@@ -167 +167 @@
     uint32_t *cbegin = cv->chars;
     uint32_t *cend = cbegin + cv->width * cv->height - 1;
-    uint32_t *abegin = cv->attr;
+    uint32_t *abegin = cv->attrs;
     uint32_t *aend = abegin + cv->width * cv->height - 1;
     unsigned int y;