Changeset 810


Ignore:
Timestamp:
Apr 18, 2006, 2:59:07 PM (14 years ago)
Author:
Sam Hocevar
Message:
  • Renamed cucul_t into cucul_canvas_t. Eh ouais mon con.
Location:
libcaca/trunk
Files:
50 edited

Legend:

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

    r773 r810  
    3232static int caca_init_driver(caca_t *kk);
    3333
    34 /** \brief Attach a caca graphical context to a cucul backend context.
     34/** \brief Attach a caca graphical context to a cucul canvas.
    3535 *
    3636 *  Create a graphical context using device-dependent features (ncurses for
     
    3939 *  then be displayed by the libcaca driver.
    4040 *
    41  *  \param qq The cucul backend context.
     41 *  \param c The cucul cavas.
    4242 *  \return The caca graphical context or NULL if an error occurred.
    4343 */
    44 caca_t * caca_attach(cucul_t * qq)
     44caca_t * caca_attach(cucul_canvas_t * c)
    4545{
    4646    caca_t *kk = malloc(sizeof(caca_t));
    4747
    48     kk->qq = qq;
     48    kk->c = c;
    4949
    5050    if(caca_init_driver(kk))
     
    6161
    6262    /* Attached! */
    63     kk->qq->refcount++;
     63    kk->c->refcount++;
    6464
    6565    /* Graphics stuff */
     
    8484
    8585    /* Mouse position */
    86     kk->mouse.x = kk->qq->width / 2;
    87     kk->mouse.y = kk->qq->height / 2;
     86    kk->mouse.x = kk->c->width / 2;
     87    kk->mouse.y = kk->c->height / 2;
    8888
    8989    /* Resize events */
     
    104104{
    105105    kk->drv.end_graphics(kk);
    106     kk->qq->refcount--;
     106    kk->c->refcount--;
    107107    free(kk);
    108108}
  • libcaca/trunk/caca/caca.h

    r799 r810  
    101101 *  \li \b CACA_EVENT_NONE: no other field is valid.
    102102 *
    103  *  \li \b CACA_EVENT_KEY_PRESS, \b CACA_EVENT_KEY_RELEASE: the \e data.key.c
     103 *  \li \b CACA_EVENT_KEY_PRESS, \b CACA_EVENT_KEY_RELEASE: the \e data.key.ch
    104104 *      field is valid and contains either the ASCII value for the key, or
    105105 *      an \e enum \e caca_key value. If the value is a printable ASCII
     
    147147        struct { unsigned int x, y, button; } mouse;
    148148        struct { unsigned int w, h; } resize;
    149         struct { unsigned int c; unsigned long int ucs4; char utf8[8]; } key;
     149        struct { unsigned int ch; unsigned long int ucs4; char utf8[8]; } key;
    150150    } data;
    151151};
     
    204204 *
    205205 *  @{ */
    206 caca_t * caca_attach(cucul_t *qq);
    207 void caca_detach(caca_t *kk);
    208 void caca_set_delay(caca_t *kk, unsigned int);
    209 void caca_display(caca_t *kk);
    210 unsigned int caca_get_rendertime(caca_t *kk);
    211 unsigned int caca_get_window_width(caca_t *kk);
    212 unsigned int caca_get_window_height(caca_t *kk);
    213 int caca_set_window_title(caca_t *kk, char const *);
     206caca_t * caca_attach(cucul_canvas_t *);
     207void caca_detach(caca_t *);
     208void caca_set_delay(caca_t *, unsigned int);
     209void caca_display(caca_t *);
     210unsigned int caca_get_rendertime(caca_t *);
     211unsigned int caca_get_window_width(caca_t *);
     212unsigned int caca_get_window_height(caca_t *);
     213int caca_set_window_title(caca_t *, char const *);
    214214/*  @} */
    215215
     
    220220 *
    221221 *  @{ */
    222 int caca_get_event(caca_t *kk, unsigned int, caca_event_t *, int);
    223 unsigned int caca_get_mouse_x(caca_t *kk);
    224 unsigned int caca_get_mouse_y(caca_t *kk);
    225 void caca_set_mouse(caca_t *kk, int);
     222int caca_get_event(caca_t *, unsigned int, caca_event_t *, int);
     223unsigned int caca_get_mouse_x(caca_t *);
     224unsigned int caca_get_mouse_y(caca_t *);
     225void caca_set_mouse(caca_t *, int);
    226226/*  @} */
    227227
  • libcaca/trunk/caca/caca_internals.h

    r777 r810  
    9494{
    9595    /* A link to our cucul canvas */
    96     cucul_t *qq;
     96    cucul_canvas_t *c;
    9797
    9898    /* Device-specific functions */
  • libcaca/trunk/caca/driver_conio.c

    r777 r810  
    5757    /* FIXME */
    5858#   endif
    59     _cucul_set_size(kk->qq, kk->drv.p->ti.screenwidth,
    60                             kk->drv.p->ti.screenheight);
     59    _cucul_set_size(kk->c, kk->drv.p->ti.screenwidth,
     60                           kk->drv.p->ti.screenheight);
    6161    return 0;
    6262}
     
    6767    textcolor((enum COLORS)WHITE);
    6868    textbackground((enum COLORS)BLACK);
    69     gotoxy(kk->qq->width, kk->qq->height);
     69    gotoxy(kk->c->width, kk->c->height);
    7070    cputs("\r\n");
    7171    _setcursortype(_NORMALCURSOR);
     
    8585{
    8686    /* Fallback to a 6x10 font */
    87     return kk->qq->width * 6;
     87    return kk->c->width * 6;
    8888}
    8989
     
    9191{
    9292    /* Fallback to a 6x10 font */
    93     return kk->qq->height * 10;
     93    return kk->c->height * 10;
    9494}
    9595
     
    9797{
    9898    char *screen = kk->drv.p->screen;
    99     uint32_t *attr = kk->qq->attr;
    100     uint32_t *chars = kk->qq->chars;
     99    uint32_t *attr = kk->c->attr;
     100    uint32_t *chars = kk->c->chars;
    101101    int n;
    102102
    103     for(n = kk->qq->height * kk->qq->width; n--; )
     103    for(n = kk->c->height * kk->c->width; n--; )
    104104    {
    105105        *screen++ = _cucul_utf32_to_cp437(*chars++);
     
    116116{
    117117    /* We know nothing about our window */
    118     kk->resize.w = kk->qq->width;
    119     kk->resize.h = kk->qq->height;
     118    kk->resize.w = kk->c->width;
     119    kk->resize.h = kk->c->height;
    120120}
    121121
     
    134134
    135135    ev->type = CACA_EVENT_KEY_PRESS;
    136     ev->data.key.c = ch;
     136    ev->data.key.ch = ch;
    137137    ev->data.key.ucs4 = (uint32_t)ch;
    138138    ev->data.key.utf8[0] = ch;
  • libcaca/trunk/caca/driver_gl.c

    r799 r810  
    9797
    9898    if(width && height)
    99         _cucul_set_size(kk->qq, width, height);
     99        _cucul_set_size(kk->c, width, height);
    100100
    101101    kk->drv.p->font_width = 9;
    102102    kk->drv.p->font_height = 15;
    103103
    104     kk->drv.p->width = kk->qq->width * kk->drv.p->font_width;
    105     kk->drv.p->height = kk->qq->height * kk->drv.p->font_height;
     104    kk->drv.p->width = kk->c->width * kk->drv.p->font_width;
     105    kk->drv.p->height = kk->c->height * kk->drv.p->font_height;
    106106
    107107#ifdef HAVE_GLUTCLOSEFUNC
     
    228228    for(y = 0; y < kk->drv.p->height; y += kk->drv.p->font_height)
    229229    {
    230         uint32_t *attr = kk->qq->attr + line * kk->qq->width;
     230        uint32_t *attr = kk->c->attr + line * kk->c->width;
    231231
    232232        for(x = 0; x < kk->drv.p->width; x += kk->drv.p->font_width)
     
    257257    for(y = 0; y < kk->drv.p->height; y += kk->drv.p->font_height)
    258258    {
    259         uint32_t *attr = kk->qq->attr + line * kk->qq->width;
    260         uint32_t *chars = kk->qq->chars + line * kk->qq->width;
     259        uint32_t *attr = kk->c->attr + line * kk->c->width;
     260        uint32_t *chars = kk->c->chars + line * kk->c->width;
    261261
    262262        for(x = 0; x < kk->drv.p->width; x += kk->drv.p->font_width)
     
    334334    {
    335335        ev->type = CACA_EVENT_RESIZE;
    336         ev->data.resize.w = kk->qq->width;
    337         ev->data.resize.h = kk->qq->height;
     336        ev->data.resize.w = kk->c->width;
     337        ev->data.resize.h = kk->c->height;
    338338        return 1;
    339339    }
     
    360360    {
    361361        ev->type = CACA_EVENT_KEY_PRESS;
    362         ev->data.key.c = kk->drv.p->key;
     362        ev->data.key.ch = kk->drv.p->key;
    363363        ev->data.key.ucs4 = (uint32_t)kk->drv.p->key;
    364364        ev->data.key.utf8[0] = kk->drv.p->key;
     
    372372        switch(kk->drv.p->special_key)
    373373        {
    374             case GLUT_KEY_F1 : ev->data.key.c = CACA_KEY_F1; break;
    375             case GLUT_KEY_F2 : ev->data.key.c = CACA_KEY_F2; break;
    376             case GLUT_KEY_F3 : ev->data.key.c = CACA_KEY_F3; break;
    377             case GLUT_KEY_F4 : ev->data.key.c = CACA_KEY_F4; break;
    378             case GLUT_KEY_F5 : ev->data.key.c = CACA_KEY_F5; break;
    379             case GLUT_KEY_F6 : ev->data.key.c = CACA_KEY_F6; break;
    380             case GLUT_KEY_F7 : ev->data.key.c = CACA_KEY_F7; break;
    381             case GLUT_KEY_F8 : ev->data.key.c = CACA_KEY_F8; break;
    382             case GLUT_KEY_F9 : ev->data.key.c = CACA_KEY_F9; break;
    383             case GLUT_KEY_F10: ev->data.key.c = CACA_KEY_F10; break;
    384             case GLUT_KEY_F11: ev->data.key.c = CACA_KEY_F11; break;
    385             case GLUT_KEY_F12: ev->data.key.c = CACA_KEY_F12; break;
    386             case GLUT_KEY_LEFT : ev->data.key.c = CACA_KEY_LEFT; break;
    387             case GLUT_KEY_RIGHT: ev->data.key.c = CACA_KEY_RIGHT; break;
    388             case GLUT_KEY_UP   : ev->data.key.c = CACA_KEY_UP; break;
    389             case GLUT_KEY_DOWN : ev->data.key.c = CACA_KEY_DOWN; break;
     374            case GLUT_KEY_F1 : ev->data.key.ch = CACA_KEY_F1; break;
     375            case GLUT_KEY_F2 : ev->data.key.ch = CACA_KEY_F2; break;
     376            case GLUT_KEY_F3 : ev->data.key.ch = CACA_KEY_F3; break;
     377            case GLUT_KEY_F4 : ev->data.key.ch = CACA_KEY_F4; break;
     378            case GLUT_KEY_F5 : ev->data.key.ch = CACA_KEY_F5; break;
     379            case GLUT_KEY_F6 : ev->data.key.ch = CACA_KEY_F6; break;
     380            case GLUT_KEY_F7 : ev->data.key.ch = CACA_KEY_F7; break;
     381            case GLUT_KEY_F8 : ev->data.key.ch = CACA_KEY_F8; break;
     382            case GLUT_KEY_F9 : ev->data.key.ch = CACA_KEY_F9; break;
     383            case GLUT_KEY_F10: ev->data.key.ch = CACA_KEY_F10; break;
     384            case GLUT_KEY_F11: ev->data.key.ch = CACA_KEY_F11; break;
     385            case GLUT_KEY_F12: ev->data.key.ch = CACA_KEY_F12; break;
     386            case GLUT_KEY_LEFT : ev->data.key.ch = CACA_KEY_LEFT; break;
     387            case GLUT_KEY_RIGHT: ev->data.key.ch = CACA_KEY_RIGHT; break;
     388            case GLUT_KEY_UP   : ev->data.key.ch = CACA_KEY_UP; break;
     389            case GLUT_KEY_DOWN : ev->data.key.ch = CACA_KEY_DOWN; break;
    390390            default: ev->type = CACA_EVENT_NONE; return 0;
    391391        }
  • libcaca/trunk/caca/driver_ncurses.c

    r777 r810  
    152152        }
    153153
    154     _cucul_set_size(kk->qq, COLS, LINES);
     154    _cucul_set_size(kk->c, COLS, LINES);
    155155
    156156    return 0;
     
    177177{
    178178    /* Fallback to a 6x10 font */
    179     return kk->qq->width * 6;
     179    return kk->c->width * 6;
    180180}
    181181
     
    183183{
    184184    /* Fallback to a 6x10 font */
    185     return kk->qq->height * 10;
     185    return kk->c->height * 10;
    186186}
    187187
     
    189189{
    190190    int x, y;
    191     uint32_t *attr = kk->qq->attr;
    192     uint32_t *chars = kk->qq->chars;
    193     for(y = 0; y < (int)kk->qq->height; y++)
     191    uint32_t *attr = kk->c->attr;
     192    uint32_t *chars = kk->c->chars;
     193    for(y = 0; y < (int)kk->c->height; y++)
    194194    {
    195195        move(y, 0);
    196         for(x = kk->qq->width; x--; )
     196        for(x = kk->c->width; x--; )
    197197        {
    198198            attrset(kk->drv.p->attr[_cucul_argb32_to_ansi8(*attr++)]);
     
    221221
    222222    /* Fallback */
    223     kk->resize.w = kk->qq->width;
    224     kk->resize.h = kk->qq->height;
     223    kk->resize.w = kk->c->width;
     224    kk->resize.h = kk->c->height;
    225225}
    226226
     
    239239    {
    240240        ev->type = CACA_EVENT_KEY_PRESS;
    241         ev->data.key.c = intkey;
     241        ev->data.key.ch = intkey;
    242242        return 1;
    243243    }
     
    397397    switch(intkey)
    398398    {
    399         case KEY_UP: ev->data.key.c = CACA_KEY_UP; break;
    400         case KEY_DOWN: ev->data.key.c = CACA_KEY_DOWN; break;
    401         case KEY_LEFT: ev->data.key.c = CACA_KEY_LEFT; break;
    402         case KEY_RIGHT: ev->data.key.c = CACA_KEY_RIGHT; break;
    403 
    404         case KEY_IC: ev->data.key.c = CACA_KEY_INSERT; break;
    405         case KEY_DC: ev->data.key.c = CACA_KEY_DELETE; break;
    406         case KEY_HOME: ev->data.key.c = CACA_KEY_HOME; break;
    407         case KEY_END: ev->data.key.c = CACA_KEY_END; break;
    408         case KEY_PPAGE: ev->data.key.c = CACA_KEY_PAGEUP; break;
    409         case KEY_NPAGE: ev->data.key.c = CACA_KEY_PAGEDOWN; break;
    410 
    411         case KEY_F(1): ev->data.key.c = CACA_KEY_F1; break;
    412         case KEY_F(2): ev->data.key.c = CACA_KEY_F2; break;
    413         case KEY_F(3): ev->data.key.c = CACA_KEY_F3; break;
    414         case KEY_F(4): ev->data.key.c = CACA_KEY_F4; break;
    415         case KEY_F(5): ev->data.key.c = CACA_KEY_F5; break;
    416         case KEY_F(6): ev->data.key.c = CACA_KEY_F6; break;
    417         case KEY_F(7): ev->data.key.c = CACA_KEY_F7; break;
    418         case KEY_F(8): ev->data.key.c = CACA_KEY_F8; break;
    419         case KEY_F(9): ev->data.key.c = CACA_KEY_F9; break;
    420         case KEY_F(10): ev->data.key.c = CACA_KEY_F10; break;
    421         case KEY_F(11): ev->data.key.c = CACA_KEY_F11; break;
    422         case KEY_F(12): ev->data.key.c = CACA_KEY_F12; break;
     399        case KEY_UP: ev->data.key.ch = CACA_KEY_UP; break;
     400        case KEY_DOWN: ev->data.key.ch = CACA_KEY_DOWN; break;
     401        case KEY_LEFT: ev->data.key.ch = CACA_KEY_LEFT; break;
     402        case KEY_RIGHT: ev->data.key.ch = CACA_KEY_RIGHT; break;
     403
     404        case KEY_IC: ev->data.key.ch = CACA_KEY_INSERT; break;
     405        case KEY_DC: ev->data.key.ch = CACA_KEY_DELETE; break;
     406        case KEY_HOME: ev->data.key.ch = CACA_KEY_HOME; break;
     407        case KEY_END: ev->data.key.ch = CACA_KEY_END; break;
     408        case KEY_PPAGE: ev->data.key.ch = CACA_KEY_PAGEUP; break;
     409        case KEY_NPAGE: ev->data.key.ch = CACA_KEY_PAGEDOWN; break;
     410
     411        case KEY_F(1): ev->data.key.ch = CACA_KEY_F1; break;
     412        case KEY_F(2): ev->data.key.ch = CACA_KEY_F2; break;
     413        case KEY_F(3): ev->data.key.ch = CACA_KEY_F3; break;
     414        case KEY_F(4): ev->data.key.ch = CACA_KEY_F4; break;
     415        case KEY_F(5): ev->data.key.ch = CACA_KEY_F5; break;
     416        case KEY_F(6): ev->data.key.ch = CACA_KEY_F6; break;
     417        case KEY_F(7): ev->data.key.ch = CACA_KEY_F7; break;
     418        case KEY_F(8): ev->data.key.ch = CACA_KEY_F8; break;
     419        case KEY_F(9): ev->data.key.ch = CACA_KEY_F9; break;
     420        case KEY_F(10): ev->data.key.ch = CACA_KEY_F10; break;
     421        case KEY_F(11): ev->data.key.ch = CACA_KEY_F11; break;
     422        case KEY_F(12): ev->data.key.ch = CACA_KEY_F12; break;
    423423
    424424        default: ev->type = CACA_EVENT_NONE; return 0;
  • libcaca/trunk/caca/driver_raw.c

    r777 r810  
    5454static void raw_display(caca_t *kk)
    5555{
    56     uint32_t *attr = kk->qq->attr;
    57     uint32_t *chars = kk->qq->chars;
     56    uint32_t *attr = kk->c->attr;
     57    uint32_t *chars = kk->c->chars;
    5858    uint32_t w, h;
    5959    unsigned int n;
    6060
    61     w = kk->qq->width;
    62     h = kk->qq->height;
     61    w = kk->c->width;
     62    h = kk->c->height;
    6363
    6464    fprintf(stdout, "CACA%c%c%c%c%c%c%c%c",
     
    6666                    (h >> 24), (h >> 16) & 0xff, (h >> 8) & 0xff, h & 0xff);
    6767
    68     for(n = kk->qq->height * kk->qq->width; n--; )
     68    for(n = kk->c->height * kk->c->width; n--; )
    6969    {
    7070        uint32_t c = *chars++;
  • libcaca/trunk/caca/driver_slang.c

    r777 r810  
    165165#endif
    166166
    167     _cucul_set_size(kk->qq, SLtt_Screen_Cols, SLtt_Screen_Rows);
     167    _cucul_set_size(kk->c, SLtt_Screen_Cols, SLtt_Screen_Rows);
    168168
    169169    return 0;
     
    189189{
    190190    /* Fallback to a 6x10 font */
    191     return kk->qq->width * 6;
     191    return kk->c->width * 6;
    192192}
    193193
     
    195195{
    196196    /* Fallback to a 6x10 font */
    197     return kk->qq->height * 10;
     197    return kk->c->height * 10;
    198198}
    199199
     
    201201{
    202202    int x, y;
    203     uint32_t *attr = kk->qq->attr;
    204     uint32_t *chars = kk->qq->chars;
    205     for(y = 0; y < (int)kk->qq->height; y++)
     203    uint32_t *attr = kk->c->attr;
     204    uint32_t *chars = kk->c->chars;
     205    for(y = 0; y < (int)kk->c->height; y++)
    206206    {
    207207        SLsmg_gotorc(y, 0);
    208         for(x = kk->qq->width; x--; )
     208        for(x = kk->c->width; x--; )
    209209        {
    210210            uint32_t c = *chars++;
     
    249249    kk->resize.h = SLtt_Screen_Rows;
    250250
    251     if(kk->resize.w != kk->qq->width || kk->resize.h != kk->qq->height)
     251    if(kk->resize.w != kk->c->width || kk->resize.h != kk->c->height)
    252252        SLsmg_reinit_smg();
    253253}
     
    278278    {
    279279        ev->type = CACA_EVENT_KEY_PRESS;
    280         ev->data.key.c = intkey;
     280        ev->data.key.ch = intkey;
    281281        return 1;
    282282    }
     
    308308    switch(intkey)
    309309    {
    310         case SL_KEY_UP: ev->data.key.c = CACA_KEY_UP; break;
    311         case SL_KEY_DOWN: ev->data.key.c = CACA_KEY_DOWN; break;
    312         case SL_KEY_LEFT: ev->data.key.c = CACA_KEY_LEFT; break;
    313         case SL_KEY_RIGHT: ev->data.key.c = CACA_KEY_RIGHT; break;
    314 
    315         case SL_KEY_IC: ev->data.key.c = CACA_KEY_INSERT; break;
    316         case SL_KEY_DELETE: ev->data.key.c = CACA_KEY_DELETE; break;
    317         case SL_KEY_HOME: ev->data.key.c = CACA_KEY_HOME; break;
    318         case SL_KEY_END: ev->data.key.c = CACA_KEY_END; break;
    319         case SL_KEY_PPAGE: ev->data.key.c = CACA_KEY_PAGEUP; break;
    320         case SL_KEY_NPAGE: ev->data.key.c = CACA_KEY_PAGEDOWN; break;
    321 
    322         case SL_KEY_F(1): ev->data.key.c = CACA_KEY_F1; break;
    323         case SL_KEY_F(2): ev->data.key.c = CACA_KEY_F2; break;
    324         case SL_KEY_F(3): ev->data.key.c = CACA_KEY_F3; break;
    325         case SL_KEY_F(4): ev->data.key.c = CACA_KEY_F4; break;
    326         case SL_KEY_F(5): ev->data.key.c = CACA_KEY_F5; break;
    327         case SL_KEY_F(6): ev->data.key.c = CACA_KEY_F6; break;
    328         case SL_KEY_F(7): ev->data.key.c = CACA_KEY_F7; break;
    329         case SL_KEY_F(8): ev->data.key.c = CACA_KEY_F8; break;
    330         case SL_KEY_F(9): ev->data.key.c = CACA_KEY_F9; break;
    331         case SL_KEY_F(10): ev->data.key.c = CACA_KEY_F10; break;
    332         case SL_KEY_F(11): ev->data.key.c = CACA_KEY_F11; break;
    333         case SL_KEY_F(12): ev->data.key.c = CACA_KEY_F12; break;
     310        case SL_KEY_UP: ev->data.key.ch = CACA_KEY_UP; break;
     311        case SL_KEY_DOWN: ev->data.key.ch = CACA_KEY_DOWN; break;
     312        case SL_KEY_LEFT: ev->data.key.ch = CACA_KEY_LEFT; break;
     313        case SL_KEY_RIGHT: ev->data.key.ch = CACA_KEY_RIGHT; break;
     314
     315        case SL_KEY_IC: ev->data.key.ch = CACA_KEY_INSERT; break;
     316        case SL_KEY_DELETE: ev->data.key.ch = CACA_KEY_DELETE; break;
     317        case SL_KEY_HOME: ev->data.key.ch = CACA_KEY_HOME; break;
     318        case SL_KEY_END: ev->data.key.ch = CACA_KEY_END; break;
     319        case SL_KEY_PPAGE: ev->data.key.ch = CACA_KEY_PAGEUP; break;
     320        case SL_KEY_NPAGE: ev->data.key.ch = CACA_KEY_PAGEDOWN; break;
     321
     322        case SL_KEY_F(1): ev->data.key.ch = CACA_KEY_F1; break;
     323        case SL_KEY_F(2): ev->data.key.ch = CACA_KEY_F2; break;
     324        case SL_KEY_F(3): ev->data.key.ch = CACA_KEY_F3; break;
     325        case SL_KEY_F(4): ev->data.key.ch = CACA_KEY_F4; break;
     326        case SL_KEY_F(5): ev->data.key.ch = CACA_KEY_F5; break;
     327        case SL_KEY_F(6): ev->data.key.ch = CACA_KEY_F6; break;
     328        case SL_KEY_F(7): ev->data.key.ch = CACA_KEY_F7; break;
     329        case SL_KEY_F(8): ev->data.key.ch = CACA_KEY_F8; break;
     330        case SL_KEY_F(9): ev->data.key.ch = CACA_KEY_F9; break;
     331        case SL_KEY_F(10): ev->data.key.ch = CACA_KEY_F10; break;
     332        case SL_KEY_F(11): ev->data.key.ch = CACA_KEY_F11; break;
     333        case SL_KEY_F(12): ev->data.key.ch = CACA_KEY_F12; break;
    334334
    335335        default: ev->type = CACA_EVENT_NONE; return 0;
  • libcaca/trunk/caca/driver_vga.c

    r777 r810  
    7575
    7676    /* We don't have much choice */
    77     _cucul_set_size(kk->qq, 80, 25);
     77    _cucul_set_size(kk->c, 80, 25);
    7878
    7979    return 0;
     
    115115{
    116116    char *screen = (char *)(intptr_t)0x000b8000;
    117     uint32_t *attr = kk->qq->attr;
    118     uint32_t *chars = kk->qq->chars;
     117    uint32_t *attr = kk->c->attr;
     118    uint32_t *chars = kk->c->chars;
    119119    int n;
    120120
    121     for(n = kk->qq->height * kk->qq->width; n--; )
     121    for(n = kk->c->height * kk->c->width; n--; )
    122122    {
    123123        *screen++ = _cucul_utf32_to_cp437(*chars++);
     
    129129{
    130130    /* We know nothing about our window */
    131     kk->resize.w = kk->qq->width;
    132     kk->resize.h = kk->qq->height;
     131    kk->resize.w = kk->c->width;
     132    kk->resize.h = kk->c->height;
    133133}
    134134
  • libcaca/trunk/caca/driver_win32.c

    r777 r810  
    112112
    113113    /* Set the new console size */
    114     size.X = kk->qq->width;
    115     size.Y = kk->qq->height;
     114    size.X = kk->c->width;
     115    size.Y = kk->c->height;
    116116    SetConsoleScreenBufferSize(kk->drv.p->screen, size);
    117117
    118118    rect.Left = rect.Top = 0;
    119     rect.Right = kk->qq->width - 1;
    120     rect.Bottom = kk->qq->height - 1;
     119    rect.Right = kk->c->width - 1;
     120    rect.Bottom = kk->c->height - 1;
    121121    SetConsoleWindowInfo(kk->drv.p->screen, TRUE, &rect);
    122122
     
    125125        return -1;
    126126
    127     _cucul_set_size(kk->qq, csbi.srWindow.Right - csbi.srWindow.Left + 1,
    128                             csbi.srWindow.Bottom - csbi.srWindow.Top + 1);
     127    _cucul_set_size(kk->c, csbi.srWindow.Right - csbi.srWindow.Left + 1,
     128                           csbi.srWindow.Bottom - csbi.srWindow.Top + 1);
    129129
    130130    SetConsoleMode(kk->drv.p->screen, 0);
     
    137137    SetConsoleActiveScreenBuffer(kk->drv.p->screen);
    138138
    139     kk->drv.p->buffer = malloc(kk->qq->width * kk->qq->height
     139    kk->drv.p->buffer = malloc(kk->c->width * kk->c->height
    140140                               * sizeof(CHAR_INFO));
    141141    if(kk->drv.p->buffer == NULL)
     
    174174
    175175    /* Fallback to a 6x10 font */
    176     return kk->qq->width * 6;
     176    return kk->c->width * 6;
    177177}
    178178
     
    182182
    183183    /* Fallback to a 6x10 font */
    184     return kk->qq->height * 10;
     184    return kk->c->height * 10;
    185185}
    186186
     
    192192
    193193    /* Render everything to our screen buffer */
    194     for(i = 0; i < kk->qq->width * kk->qq->height; i++)
     194    for(i = 0; i < kk->c->width * kk->c->height; i++)
    195195    {
    196         uint32_t c = kk->qq->chars[i];
     196        uint32_t c = kk->c->chars[i];
    197197
    198198#if 0
     
    209209
    210210        kk->drv.p->buffer[i].Attributes =
    211                 win32_fg_palette[_cucul_argb32_to_ansi4fg(kk->qq->attr[i])]
    212                  | win32_bg_palette[_cucul_argb32_to_ansi4bg(kk->qq->attr[i])];
     211                win32_fg_palette[_cucul_argb32_to_ansi4fg(kk->c->attr[i])]
     212                 | win32_bg_palette[_cucul_argb32_to_ansi4bg(kk->c->attr[i])];
    213213    }
    214214
    215215    /* Blit the screen buffer */
    216     size.X = kk->qq->width;
    217     size.Y = kk->qq->height;
     216    size.X = kk->c->width;
     217    size.Y = kk->c->height;
    218218    pos.X = pos.Y = 0;
    219219    rect.Left = rect.Top = 0;
    220     rect.Right = kk->qq->width - 1;
    221     rect.Bottom = kk->qq->height - 1;
     220    rect.Right = kk->c->width - 1;
     221    rect.Bottom = kk->c->height - 1;
    222222#if 0
    223223    WriteConsoleOutput(kk->drv.p->screen, kk->drv.p->buffer, size, pos, &rect);
     
    230230{
    231231    /* FIXME: I don't know what to do here. */
    232     kk->resize.w = kk->qq->width;
    233     kk->resize.h = kk->qq->height;
     232    kk->resize.w = kk->c->width;
     233    kk->resize.h = kk->c->height;
    234234}
    235235
     
    257257            if(rec.Event.KeyEvent.uChar.AsciiChar)
    258258            {
    259                 ev->data.key.c = rec.Event.KeyEvent.uChar.AsciiChar;
    260                 ev->data.key.ucs4 = (uint32_t)ev->data.key.c;
    261                 ev->data.key.utf8[0] = ev->data.key.c;
     259                ev->data.key.ch = rec.Event.KeyEvent.uChar.AsciiChar;
     260                ev->data.key.ucs4 = (uint32_t)ev->data.key.ch;
     261                ev->data.key.utf8[0] = ev->data.key.ch;
    262262                ev->data.key.utf8[1] = '\0';
    263263
  • libcaca/trunk/caca/driver_x11.c

    r800 r810  
    7979
    8080    if(width && height)
    81         _cucul_set_size(kk->qq, width, height);
     81        _cucul_set_size(kk->c, width, height);
    8282
    8383    kk->drv.p->dpy = XOpenDisplay(NULL);
     
    145145    kk->drv.p->window =
    146146        XCreateWindow(kk->drv.p->dpy, DefaultRootWindow(kk->drv.p->dpy), 0, 0,
    147                       kk->qq->width * kk->drv.p->font_width,
    148                       kk->qq->height * kk->drv.p->font_height,
     147                      kk->c->width * kk->drv.p->font_width,
     148                      kk->c->height * kk->drv.p->font_height,
    149149                      0, 0, InputOutput, 0,
    150150                      CWBackingStore | CWBackPixel | CWEventMask,
     
    193193
    194194    kk->drv.p->pixmap = XCreatePixmap(kk->drv.p->dpy, kk->drv.p->window,
    195                                    kk->qq->width * kk->drv.p->font_width,
    196                                    kk->qq->height * kk->drv.p->font_height,
     195                                   kk->c->width * kk->drv.p->font_width,
     196                                   kk->c->height * kk->drv.p->font_height,
    197197                                   DefaultDepth(kk->drv.p->dpy,
    198198                                            DefaultScreen(kk->drv.p->dpy)));
     
    229229static unsigned int x11_get_window_width(caca_t *kk)
    230230{
    231     return kk->qq->width * kk->drv.p->font_width;
     231    return kk->c->width * kk->drv.p->font_width;
    232232}
    233233
    234234static unsigned int x11_get_window_height(caca_t *kk)
    235235{
    236     return kk->qq->height * kk->drv.p->font_height;
     236    return kk->c->height * kk->drv.p->font_height;
    237237}
    238238
     
    243243    /* First draw the background colours. Splitting the process in two
    244244     * loops like this is actually slightly faster. */
    245     for(y = 0; y < kk->qq->height; y++)
    246     {
    247         for(x = 0; x < kk->qq->width; x += len)
    248         {
    249             uint32_t *attr = kk->qq->attr + x + y * kk->qq->width;
     245    for(y = 0; y < kk->c->height; y++)
     246    {
     247        for(x = 0; x < kk->c->width; x += len)
     248        {
     249            uint32_t *attr = kk->c->attr + x + y * kk->c->width;
    250250            uint16_t bg = _cucul_argb32_to_rgb12bg(*attr);
    251251
    252252            len = 1;
    253             while(x + len < kk->qq->width
     253            while(x + len < kk->c->width
    254254                   && _cucul_argb32_to_rgb12bg(attr[len]) == bg)
    255255                len++;
     
    264264
    265265    /* Then print the foreground characters */
    266     for(y = 0; y < kk->qq->height; y++)
     266    for(y = 0; y < kk->c->height; y++)
    267267    {
    268268        unsigned int yoff = (y + 1) * kk->drv.p->font_height
    269269                                    - kk->drv.p->font_offset;
    270         uint32_t *chars = kk->qq->chars + y * kk->qq->width;
    271 
    272         for(x = 0; x < kk->qq->width; x++, chars++)
    273         {
    274             uint32_t *attr = kk->qq->attr + x + y * kk->qq->width;
     270        uint32_t *chars = kk->c->chars + y * kk->c->width;
     271
     272        for(x = 0; x < kk->c->width; x++, chars++)
     273        {
     274            uint32_t *attr = kk->c->attr + x + y * kk->c->width;
    275275
    276276            /* Skip spaces */
     
    371371    XCopyArea(kk->drv.p->dpy, kk->drv.p->pixmap, kk->drv.p->window,
    372372              kk->drv.p->gc, 0, 0,
    373               kk->qq->width * kk->drv.p->font_width,
    374               kk->qq->height * kk->drv.p->font_height,
     373              kk->c->width * kk->drv.p->font_width,
     374              kk->c->height * kk->drv.p->font_height,
    375375              0, 0);
    376376    XFlush(kk->drv.p->dpy);
     
    409409            XCopyArea(kk->drv.p->dpy, kk->drv.p->pixmap,
    410410                      kk->drv.p->window, kk->drv.p->gc, 0, 0,
    411                       kk->qq->width * kk->drv.p->font_width,
    412                       kk->qq->height * kk->drv.p->font_height, 0, 0);
     411                      kk->c->width * kk->drv.p->font_width,
     412                      kk->c->height * kk->drv.p->font_height, 0, 0);
    413413            continue;
    414414        }
     
    424424                  / kk->drv.p->font_height;
    425425
    426             if(!w || !h || (w == kk->qq->width && h == kk->qq->height))
     426            if(!w || !h || (w == kk->c->width && h == kk->c->height))
    427427                continue;
    428428
     
    440440            unsigned int newy = xevent.xmotion.y / kk->drv.p->font_height;
    441441
    442             if(newx >= kk->qq->width)
    443                 newx = kk->qq->width - 1;
    444             if(newy >= kk->qq->height)
    445                 newy = kk->qq->height - 1;
     442            if(newx >= kk->c->width)
     443                newx = kk->c->width - 1;
     444            if(newy >= kk->c->height)
     445                newy = kk->c->height - 1;
    446446
    447447            if(kk->mouse.x == newx && kk->mouse.y == newy)
     
    482482        if(XLookupString(&xevent.xkey, &key, 1, NULL, NULL))
    483483        {
    484             ev->data.key.c = key;
     484            ev->data.key.ch = key;
    485485            ev->data.key.ucs4 = key;
    486486            ev->data.key.utf8[0] = key;
     
    492492        switch(keysym)
    493493        {
    494             case XK_F1:    ev->data.key.c = CACA_KEY_F1;    break;
    495             case XK_F2:    ev->data.key.c = CACA_KEY_F2;    break;
    496             case XK_F3:    ev->data.key.c = CACA_KEY_F3;    break;
    497             case XK_F4:    ev->data.key.c = CACA_KEY_F4;    break;
    498             case XK_F5:    ev->data.key.c = CACA_KEY_F5;    break;
    499             case XK_F6:    ev->data.key.c = CACA_KEY_F6;    break;
    500             case XK_F7:    ev->data.key.c = CACA_KEY_F7;    break;
    501             case XK_F8:    ev->data.key.c = CACA_KEY_F8;    break;
    502             case XK_F9:    ev->data.key.c = CACA_KEY_F9;    break;
    503             case XK_F10:   ev->data.key.c = CACA_KEY_F10;   break;
    504             case XK_F11:   ev->data.key.c = CACA_KEY_F11;   break;
    505             case XK_F12:   ev->data.key.c = CACA_KEY_F12;   break;
    506             case XK_F13:   ev->data.key.c = CACA_KEY_F13;   break;
    507             case XK_F14:   ev->data.key.c = CACA_KEY_F14;   break;
    508             case XK_F15:   ev->data.key.c = CACA_KEY_F15;   break;
    509             case XK_Left:  ev->data.key.c = CACA_KEY_LEFT;  break;
    510             case XK_Right: ev->data.key.c = CACA_KEY_RIGHT; break;
    511             case XK_Up:    ev->data.key.c = CACA_KEY_UP;    break;
    512             case XK_Down:  ev->data.key.c = CACA_KEY_DOWN;  break;
     494            case XK_F1:    ev->data.key.ch = CACA_KEY_F1;    break;
     495            case XK_F2:    ev->data.key.ch = CACA_KEY_F2;    break;
     496            case XK_F3:    ev->data.key.ch = CACA_KEY_F3;    break;
     497            case XK_F4:    ev->data.key.ch = CACA_KEY_F4;    break;
     498            case XK_F5:    ev->data.key.ch = CACA_KEY_F5;    break;
     499            case XK_F6:    ev->data.key.ch = CACA_KEY_F6;    break;
     500            case XK_F7:    ev->data.key.ch = CACA_KEY_F7;    break;
     501            case XK_F8:    ev->data.key.ch = CACA_KEY_F8;    break;
     502            case XK_F9:    ev->data.key.ch = CACA_KEY_F9;    break;
     503            case XK_F10:   ev->data.key.ch = CACA_KEY_F10;   break;
     504            case XK_F11:   ev->data.key.ch = CACA_KEY_F11;   break;
     505            case XK_F12:   ev->data.key.ch = CACA_KEY_F12;   break;
     506            case XK_F13:   ev->data.key.ch = CACA_KEY_F13;   break;
     507            case XK_F14:   ev->data.key.ch = CACA_KEY_F14;   break;
     508            case XK_F15:   ev->data.key.ch = CACA_KEY_F15;   break;
     509            case XK_Left:  ev->data.key.ch = CACA_KEY_LEFT;  break;
     510            case XK_Right: ev->data.key.ch = CACA_KEY_RIGHT; break;
     511            case XK_Up:    ev->data.key.ch = CACA_KEY_UP;    break;
     512            case XK_Down:  ev->data.key.ch = CACA_KEY_DOWN;  break;
    513513
    514514            default: ev->type = CACA_EVENT_NONE; return 0;
  • libcaca/trunk/caca/event.c

    r777 r810  
    114114unsigned int caca_get_mouse_x(caca_t *kk)
    115115{
    116     if(kk->mouse.x >= kk->qq->width)
    117         kk->mouse.x = kk->qq->width - 1;
     116    if(kk->mouse.x >= kk->c->width)
     117        kk->mouse.x = kk->c->width - 1;
    118118
    119119    return kk->mouse.x;
     
    132132unsigned int caca_get_mouse_y(caca_t *kk)
    133133{
    134     if(kk->mouse.y >= kk->qq->height)
    135         kk->mouse.y = kk->qq->height - 1;
     134    if(kk->mouse.y >= kk->c->height)
     135        kk->mouse.y = kk->c->height - 1;
    136136
    137137    return kk->mouse.y;
     
    155155        _caca_handle_resize(kk);
    156156        ev->type = CACA_EVENT_RESIZE;
    157         ev->data.resize.w = kk->qq->width;
    158         ev->data.resize.h = kk->qq->height;
     157        ev->data.resize.w = kk->c->width;
     158        ev->data.resize.h = kk->c->height;
    159159        return 1;
    160160    }
     
    192192    if(ev->type == CACA_EVENT_KEY_PRESS
    193193        && kk->events.last_key_event.type
    194         && ev->data.key.c == kk->events.last_key_event.data.key.c
     194        && ev->data.key.ch == kk->events.last_key_event.data.key.ch
    195195        && ev->data.key.ucs4 == kk->events.last_key_event.data.key.ucs4)
    196196    {
  • libcaca/trunk/caca/graphics.c

    r773 r810  
    173173
    174174    /* Tell libcucul we changed size */
    175     if(kk->resize.w != kk->qq->width || kk->resize.h != kk->qq->height)
    176         _cucul_set_size(kk->qq, kk->resize.w, kk->resize.h);
     175    if(kk->resize.w != kk->c->width || kk->resize.h != kk->c->height)
     176        _cucul_set_size(kk->c, kk->resize.w, kk->resize.h);
    177177}
    178178
  • libcaca/trunk/cpp/caca++.cpp

    r796 r810  
    2626
    2727}
    28 Caca::Caca(Cucul *qq)
     28Caca::Caca(Cucul *c)
    2929{
    30     kk = caca_attach(qq->get_cucul_t());
     30    kk = caca_attach(c->get_cucul_canvas_t());
    3131    if(!kk) throw -1;
    3232}
     
    3535    caca_detach(kk);
    3636}
    37 void Caca::attach(Cucul *qq)
     37void Caca::attach(Cucul *c)
    3838{
    39     kk = caca_attach(qq->get_cucul_t());
     39    kk = caca_attach(c->get_cucul_canvas_t());
    4040    if(!kk) throw -1;
    4141}
  • libcaca/trunk/cpp/cucul++.cpp

    r795 r810  
    2121Cucul::Cucul()
    2222{
    23     qq = cucul_create(0,0);
    24     if(!qq) throw -1;
     23    c = cucul_create(0,0);
     24    if(!c) throw -1;
    2525}
    2626Cucul::Cucul(int width, int height)
    2727{
    28     qq = cucul_create(width, height);
    29     if(!qq) throw -1;
     28    c = cucul_create(width, height);
     29    if(!c) throw -1;
    3030}
    3131Cucul::~Cucul()
    3232{
    33     if(qq) {
    34         cucul_free(qq);
     33    if(c) {
     34        cucul_free(c);
    3535    }
    3636}
    3737
    38 cucul_t *Cucul::get_cucul_t()
    39 {
    40     return qq;
     38cucul_canvas_t *Cucul::get_cucul_canvas_t()
     39{
     40    return c;
    4141}
    4242
     
    4545void Cucul::set_size(unsigned int width, unsigned int height)
    4646{
    47     cucul_set_size (qq, width, height);
     47    cucul_set_size (c, width, height);
    4848}
    4949unsigned int Cucul::get_width(void)
    5050{
    51     return cucul_get_width (qq);
     51    return cucul_get_width (c);
    5252}
    5353unsigned int Cucul::get_height(void)
    5454{
    55     return cucul_get_height (qq);
     55    return cucul_get_height (c);
    5656}
    5757void Cucul::set_color(unsigned int f, unsigned int b)
    5858{
    59     cucul_set_color (qq, f, b);
     59    cucul_set_color (c, f, b);
    6060}
    6161char const * Cucul::get_color_name (unsigned int color)
     
    6363    return cucul_get_color_name (color);
    6464}
    65 void Cucul::putchar (int x, int y, char c)
    66 {
    67     cucul_putchar (qq, x, y, c);
     65void Cucul::putchar (int x, int y, char ch)
     66{
     67    cucul_putchar (c, x, y, ch);
    6868}
    6969void Cucul::putstr (int x, int y, char *str)
    7070{
    71     cucul_putstr(qq, x, y, str);
     71    cucul_putstr(c, x, y, str);
    7272}
    7373void    Cucul::printf ( int x , int y , char const * format,...)
     
    9292void    Cucul::clear ()
    9393{
    94     cucul_clear(qq);
     94    cucul_clear(c);
    9595}
    9696
    9797void    Cucul::blit ( int x, int y, Cucul* c1, Cucul* c2)
    9898{
    99     cucul_blit(qq, x, y, c1->get_cucul_t(), c2->get_cucul_t());
     99    cucul_blit(c, x, y, c1->get_cucul_canvas_t(), c2->get_cucul_canvas_t());
    100100}
    101101
    102102void    Cucul::invert ()
    103103{
    104     cucul_invert(qq);
     104    cucul_invert(c);
    105105}
    106106
    107107void    Cucul::flip ()
    108108{
    109     cucul_flip(qq);
     109    cucul_flip(c);
    110110}
    111111
    112112void    Cucul::flop ()
    113113{
    114     cucul_flop(qq);
     114    cucul_flop(c);
    115115}
    116116
    117117void    Cucul::rotate ()
    118118{
    119     cucul_rotate(qq);
    120 }
    121 
    122 void    Cucul::draw_line (int x1 , int y1, int x2, int y2, char const *c)
    123 {
    124     cucul_draw_line(qq, x1,y1,x2,y2, c);
    125 }
    126  
    127 void    Cucul::draw_polyline (int const x[], int const y[], int f, char const *c)
    128 {
    129     cucul_draw_polyline(qq, x, y, f, c);
     119    cucul_rotate(c);
     120}
     121
     122void    Cucul::draw_line (int x1 , int y1, int x2, int y2, char const *ch)
     123{
     124    cucul_draw_line(c, x1,y1,x2,y2, ch);
     125}
     126 
     127void    Cucul::draw_polyline (int const x[], int const y[], int f, char const *ch)
     128{
     129    cucul_draw_polyline(c, x, y, f, ch);
    130130}
    131131 
    132132void    Cucul::draw_thin_line (int x1 , int y1, int x2, int y2)
    133133{
    134     cucul_draw_thin_line(qq, x1, y1, x2, y2);
     134    cucul_draw_thin_line(c, x1, y1, x2, y2);
    135135}
    136136
    137137void    Cucul::draw_thin_polyline ( int const x[], int const y[], int f)
    138138{
    139     cucul_draw_thin_polyline(qq, x, y, f);
    140 }
    141  
    142 void    Cucul::draw_circle ( int x, int y, int d, char const *c)
    143 {
    144     cucul_draw_circle(qq, x, y, d, c);
    145 }
    146 
    147 void    Cucul::draw_ellipse ( int x, int y, int d1, int d2, char const *c)
    148 {
    149     cucul_draw_ellipse(qq, x, y, d1, d2, c);
     139    cucul_draw_thin_polyline(c, x, y, f);
     140}
     141 
     142void    Cucul::draw_circle ( int x, int y, int d, char const *ch)
     143{
     144    cucul_draw_circle(c, x, y, d, ch);
     145}
     146
     147void    Cucul::draw_ellipse ( int x, int y, int d1, int d2, char const *ch)
     148{
     149    cucul_draw_ellipse(c, x, y, d1, d2, ch);
    150150}
    151151
    152152void    Cucul::draw_thin_ellipse ( int x, int y, int d1, int d2)
    153153{
    154     cucul_draw_thin_ellipse(qq, x, y, d1, d2);
    155 }
    156 
    157 void    Cucul::fill_ellipse ( int x, int y, int d1, int d2, char const *c)
    158 {
    159     cucul_fill_ellipse(qq, x, y, d1, d2, c);
    160 }
    161 
    162 void    Cucul::draw_box ( int x, int y, int w, int h, char const *c)
    163 {
    164     cucul_draw_box(qq, x, y, w, h, c);
     154    cucul_draw_thin_ellipse(c, x, y, d1, d2);
     155}
     156
     157void    Cucul::fill_ellipse ( int x, int y, int d1, int d2, char const *ch)
     158{
     159    cucul_fill_ellipse(c, x, y, d1, d2, ch);
     160}
     161
     162void    Cucul::draw_box ( int x, int y, int w, int h, char const *ch)
     163{
     164    cucul_draw_box(c, x, y, w, h, ch);
    165165}
    166166 
    167167void    Cucul::draw_thin_box ( int x, int y, int w, int h)
    168168{
    169     cucul_draw_thin_box(qq, x, y, w, h);
    170 }
    171 
    172 void    Cucul::fill_box ( int x, int y, int w, int h, char const *c)
    173 {
    174     cucul_fill_box(qq, x, y, w, h, c);
    175 }
    176 
    177 void    Cucul::draw_triangle ( int x1, int y1, int x2, int y2, int x3, int y3, char const *c)
    178 {
    179     cucul_draw_triangle(qq, x1, y1, x2, y2, x3, y3, c);
     169    cucul_draw_thin_box(c, x, y, w, h);
     170}
     171
     172void    Cucul::fill_box ( int x, int y, int w, int h, char const *ch)
     173{
     174    cucul_fill_box(c, x, y, w, h, ch);
     175}
     176
     177void    Cucul::draw_triangle ( int x1, int y1, int x2, int y2, int x3, int y3, char const *ch)
     178{
     179    cucul_draw_triangle(c, x1, y1, x2, y2, x3, y3, ch);
    180180}
    181181
    182182void    Cucul::draw_thin_triangle ( int x1, int y1, int x2, int y2, int x3, int y3)
    183183{
    184     cucul_draw_thin_triangle(qq, x1, y1, x2, y2, x3, y3);
    185 }
    186 
    187 void    Cucul::fill_triangle ( int x1, int y1, int x2, int y2, int x3, int y3, const char *c)
    188 {
    189     cucul_fill_triangle(qq, x1, y1, x2, y2, x3, y3, c);
     184    cucul_draw_thin_triangle(c, x1, y1, x2, y2, x3, y3);
     185}
     186
     187void    Cucul::fill_triangle ( int x1, int y1, int x2, int y2, int x3, int y3, const char *ch)
     188{
     189    cucul_fill_triangle(c, x1, y1, x2, y2, x3, y3, ch);
    190190}
    191191
     
    229229void    Cucul::draw_sprite ( int x, int y, Cucul::Sprite const *s, int v)
    230230{
    231     cucul_draw_sprite(qq, x, y, s->sprite, v);
     231    cucul_draw_sprite(c, x, y, s->sprite, v);
    232232}
    233233
     
    311311void    Cucul::dither_bitmap ( int x, int y, int w, int h,  Cucul::Dither const *d, void *v)
    312312{
    313     cucul_dither_bitmap(qq, x, y, w, h, d->dither, v);
     313    cucul_dither_bitmap(c, x, y, w, h, d->dither, v);
    314314}
    315315
     
    341341}
    342342
    343 void    Cucul::render_canvas (Cucul::Font *f, unsigned char *c, unsigned int x, unsigned int y, unsigned int w)
    344 {
    345     cucul_render_canvas(qq, f->font, c, x,y,w);
     343void    Cucul::render_canvas (Cucul::Font *f, unsigned char *buf, unsigned int x, unsigned int y, unsigned int w)
     344{
     345    cucul_render_canvas(c, f->font, buf, x,y,w);
    346346}
    347347
     
    351351}
    352352
    353 Cucul::Buffer *         Cucul::create_export (char const *c)
     353Cucul::Buffer *         Cucul::create_export (char const *buf)
    354354{
    355355    Cucul::Buffer *b = new Cucul::Buffer();
    356     b->buffer = cucul_create_export(qq, c);
     356    b->buffer = cucul_create_export(c, buf);
    357357    return b;
    358358}
  • libcaca/trunk/cpp/cucul++.h

    r795 r810  
    124124
    125125 protected:
    126     cucul_t *get_cucul_t();
     126    cucul_canvas_t *get_cucul_canvas_t();
    127127
    128128 private:
    129     cucul_t *qq;
     129    cucul_canvas_t *c;
    130130
    131131
  • libcaca/trunk/cucul/box.c

    r773 r810  
    2727/** \brief Draw a box on the canvas using the given character.
    2828 *
    29  *  \param qq The handle to the libcucul canvas.
     29 *  \param c The handle to the libcucul canvas.
    3030 *  \param x1 X coordinate of the upper-left corner of the box.
    3131 *  \param y1 Y coordinate of the upper-left corner of the box.
     
    3535 *  \return void
    3636 */
    37 void cucul_draw_box(cucul_t *qq, int x1, int y1, int x2, int y2,
     37void cucul_draw_box(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
    3838                    char const *str)
    3939{
    40     cucul_draw_line(qq, x1, y1, x1, y2, str);
    41     cucul_draw_line(qq, x1, y2, x2, y2, str);
    42     cucul_draw_line(qq, x2, y2, x2, y1, str);
    43     cucul_draw_line(qq, x2, y1, x1, y1, str);
     40    cucul_draw_line(c, x1, y1, x1, y2, str);
     41    cucul_draw_line(c, x1, y2, x2, y2, str);
     42    cucul_draw_line(c, x2, y2, x2, y1, str);
     43    cucul_draw_line(c, x2, y1, x1, y1, str);
    4444}
    4545
    4646/** \brief Draw a thin box on the canvas.
    4747 *
    48  *  \param qq The handle to the libcucul canvas.
     48 *  \param c The handle to the libcucul canvas.
    4949 *  \param x1 X coordinate of the upper-left corner of the box.
    5050 *  \param y1 Y coordinate of the upper-left corner of the box.
     
    5353 *  \return void
    5454 */
    55 void cucul_draw_thin_box(cucul_t *qq, int x1, int y1, int x2, int y2)
     55void cucul_draw_thin_box(cucul_canvas_t *c, int x1, int y1, int x2, int y2)
    5656{
    5757    int x, y, xmax, ymax;
     
    6969    }
    7070
    71     xmax = qq->width - 1;
    72     ymax = qq->height - 1;
     71    xmax = c->width - 1;
     72    ymax = c->height - 1;
    7373
    7474    if(x2 < 0 || y2 < 0 || x1 > xmax || y1 > ymax)
     
    7878    if(y1 >= 0)
    7979        for(x = x1 < 0 ? 1 : x1 + 1; x < x2 && x < xmax; x++)
    80             _cucul_putchar32(qq, x, y1, (uint32_t)'-');
     80            _cucul_putchar32(c, x, y1, (uint32_t)'-');
    8181
    8282    if(y2 <= ymax)
    8383        for(x = x1 < 0 ? 1 : x1 + 1; x < x2 && x < xmax; x++)
    84             _cucul_putchar32(qq, x, y2, (uint32_t)'-');
     84            _cucul_putchar32(c, x, y2, (uint32_t)'-');
    8585
    8686    if(x1 >= 0)
    8787        for(y = y1 < 0 ? 1 : y1 + 1; y < y2 && y < ymax; y++)
    88             _cucul_putchar32(qq, x1, y, (uint32_t)'|');
     88            _cucul_putchar32(c, x1, y, (uint32_t)'|');
    8989
    9090    if(x2 <= xmax)
    9191        for(y = y1 < 0 ? 1 : y1 + 1; y < y2 && y < ymax; y++)
    92             _cucul_putchar32(qq, x2, y, (uint32_t)'|');
     92            _cucul_putchar32(c, x2, y, (uint32_t)'|');
    9393
    9494    /* Draw corners */
    9595    if(x1 >= 0 && y1 >= 0)
    96         _cucul_putchar32(qq, x1, y1, (uint32_t)',');
     96        _cucul_putchar32(c, x1, y1, (uint32_t)',');
    9797
    9898    if(x1 >= 0 && y2 <= ymax)
    99         _cucul_putchar32(qq, x1, y2, (uint32_t)'`');
     99        _cucul_putchar32(c, x1, y2, (uint32_t)'`');
    100100
    101101    if(x2 <= xmax && y1 >= 0)
    102         _cucul_putchar32(qq, x2, y1, (uint32_t)'.');
     102        _cucul_putchar32(c, x2, y1, (uint32_t)'.');
    103103
    104104    if(x2 <= xmax && y2 <= ymax)
    105         _cucul_putchar32(qq, x2, y2, (uint32_t)'\'');
     105        _cucul_putchar32(c, x2, y2, (uint32_t)'\'');
    106106}
    107107
    108108/** \brief Fill a box on the canvas using the given character.
    109109 *
    110  *  \param qq The handle to the libcucul canvas.
     110 *  \param c The handle to the libcucul canvas.
    111111 *  \param x1 X coordinate of the upper-left corner of the box.
    112112 *  \param y1 Y coordinate of the upper-left corner of the box.
     
    116116 *  \return void
    117117 */
    118 void cucul_fill_box(cucul_t *qq, int x1, int y1, int x2, int y2,
     118void cucul_fill_box(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
    119119                    char const *str)
    120120{
    121121    int x, y, xmax, ymax;
    122     uint32_t c;
     122    uint32_t ch;
    123123
    124124    if(x1 > x2)
     
    134134    }
    135135
    136     xmax = qq->width - 1;
    137     ymax = qq->height - 1;
     136    xmax = c->width - 1;
     137    ymax = c->height - 1;
    138138
    139139    if(x2 < 0 || y2 < 0 || x1 > xmax || y1 > ymax)
     
    145145    if(y2 > ymax) y2 = ymax;
    146146
    147     c = _cucul_utf8_to_utf32(str);
     147    ch = _cucul_utf8_to_utf32(str);
    148148
    149149    for(y = y1; y <= y2; y++)
    150150        for(x = x1; x <= x2; x++)
    151             _cucul_putchar32(qq, x, y, c);
     151            _cucul_putchar32(c, x, y, ch);
    152152}
    153153
  • libcaca/trunk/cucul/canvas.c

    r778 r810  
    4747 *  character, use cucul_putstr() instead.
    4848 *
    49  *  \param qq A handle to the libcucul canvas.
    50  *  \param x X coordinate.
    51  *  \param y Y coordinate.
    52  *  \param c The character to print.
    53  */
    54 void cucul_putchar(cucul_t *qq, int x, int y, char c)
    55 {
    56     if(x < 0 || x >= (int)qq->width ||
    57        y < 0 || y >= (int)qq->height)
    58         return;
    59 
    60     if((unsigned char)c < 0x20 || (unsigned char)c > 0x7f)
    61         c = 0x20;
    62 
    63     qq->chars[x + y * qq->width] = c;
    64     qq->attr[x + y * qq->width] = (qq->bgcolor << 16) | qq->fgcolor;
     49 *  \param c A handle to the libcucul canvas.
     50 *  \param x X coordinate.
     51 *  \param y Y coordinate.
     52 *  \param ch The character to print.
     53 */
     54void cucul_putchar(cucul_canvas_t *c, int x, int y, char ch)
     55{
     56    if(x < 0 || x >= (int)c->width ||
     57       y < 0 || y >= (int)c->height)
     58        return;
     59
     60    if((unsigned char)ch < 0x20 || (unsigned char)ch > 0x7f)
     61        ch = 0x20;
     62
     63    c->chars[x + y * c->width] = ch;
     64    c->attr[x + y * c->width] = (c->bgcolor << 16) | c->fgcolor;
    6565}
    6666
     
    7272 *  be cropped accordingly if it is too long.
    7373 *
    74  *  \param qq A handle to the libcucul canvas.
     74 *  \param c A handle to the libcucul canvas.
    7575 *  \param x X coordinate.
    7676 *  \param y Y coordinate.
    7777 *  \param s The string to print.
    7878 */
    79 void cucul_putstr(cucul_t *qq, int x, int y, char const *s)
     79void cucul_putstr(cucul_canvas_t *c, int x, int y, char const *s)
    8080{
    8181    uint32_t *chars, *attr;
    8282    unsigned int len;
    8383
    84     if(y < 0 || y >= (int)qq->height || x >= (int)qq->width)
     84    if(y < 0 || y >= (int)c->height || x >= (int)c->width)
    8585        return;
    8686
     
    9696    }
    9797
    98     chars = qq->chars + x + y * qq->width;
    99     attr = qq->attr + x + y * qq->width;
    100 
    101     if(x + len >= qq->width)
    102         len = qq->width - x;
     98    chars = c->chars + x + y * c->width;
     99    attr = c->attr + x + y * c->width;
     100
     101    if(x + len >= c->width)
     102        len = c->width - x;
    103103
    104104    while(len)
    105105    {
    106106        *chars++ = _cucul_utf8_to_utf32(s);
    107         *attr++ = (qq->bgcolor << 16) | qq->fgcolor;
     107        *attr++ = (c->bgcolor << 16) | c->fgcolor;
    108108
    109109        s = _cucul_skip_utf8(s, 1);
     
    120120 *  string is the same as for the C printf() function.
    121121 *
    122  *  \param qq A handle to the libcucul canvas.
     122 *  \param c A handle to the libcucul canvas.
    123123 *  \param x X coordinate.
    124124 *  \param y Y coordinate.
     
    126126 *  \param ... Arguments to the format string.
    127127 */
    128 void cucul_printf(cucul_t *qq, int x, int y, char const *format, ...)
     128void cucul_printf(cucul_canvas_t *c, int x, int y, char const *format, ...)
    129129{
    130130    char tmp[BUFSIZ];
     
    132132    va_list args;
    133133
    134     if(y < 0 || y >= (int)qq->height || x >= (int)qq->width)
    135         return;
    136 
    137     if(qq->width - x + 1 > BUFSIZ)
    138         buf = malloc(qq->width - x + 1);
     134    if(y < 0 || y >= (int)c->height || x >= (int)c->width)
     135        return;
     136
     137    if(c->width - x + 1 > BUFSIZ)
     138        buf = malloc(c->width - x + 1);
    139139
    140140    va_start(args, format);
    141141#if defined(HAVE_VSNPRINTF)
    142     vsnprintf(buf, qq->width - x + 1, format, args);
     142    vsnprintf(buf, c->width - x + 1, format, args);
    143143#else
    144144    vsprintf(buf, format, args);
    145145#endif
    146     buf[qq->width - x] = '\0';
     146    buf[c->width - x] = '\0';
    147147    va_end(args);
    148148
    149     cucul_putstr(qq, x, y, buf);
     149    cucul_putstr(c, x, y, buf);
    150150
    151151    if(buf != tmp)
     
    157157 *  This function clears the canvas using a black background.
    158158 */
    159 void cucul_clear(cucul_t *qq)
    160 {
    161     uint16_t oldfg = qq->fgcolor;
    162     uint16_t oldbg = qq->bgcolor;
    163     int y = qq->height;
    164 
    165     cucul_set_color(qq, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
     159void cucul_clear(cucul_canvas_t *c)
     160{
     161    uint16_t oldfg = c->fgcolor;
     162    uint16_t oldbg = c->bgcolor;
     163    int y = c->height;
     164
     165    cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
    166166
    167167    /* We could use SLsmg_cls() etc., but drawing empty lines is much faster */
    168168    while(y--)
    169         cucul_putstr(qq, 0, y, qq->empty_line);
    170 
    171     qq->fgcolor = oldfg;
    172     qq->bgcolor = oldbg;
     169        cucul_putstr(c, 0, y, c->empty_line);
     170
     171    c->fgcolor = oldfg;
     172    c->bgcolor = oldbg;
    173173}
    174174
     
    184184 *  \param mask The mask canvas.
    185185 */
    186 void cucul_blit(cucul_t *dst, int x, int y,
    187                 cucul_t const *src, cucul_t const *mask)
     186void cucul_blit(cucul_canvas_t *dst, int x, int y,
     187                cucul_canvas_t const *src, cucul_canvas_t const *mask)
    188188{
    189189    int i, j, starti, startj, endi, endj;
     
    231231 */
    232232
    233 void _cucul_putchar32(cucul_t *qq, int x, int y, uint32_t c)
    234 {
    235     if(x < 0 || x >= (int)qq->width ||
    236        y < 0 || y >= (int)qq->height)
    237         return;
    238 
    239     qq->chars[x + y * qq->width] = c;
    240     qq->attr[x + y * qq->width] = (qq->bgcolor << 16) | qq->fgcolor;
    241 }
    242 
     233void _cucul_putchar32(cucul_canvas_t *c, int x, int y, uint32_t ch)
     234{
     235    if(x < 0 || x >= (int)c->width ||
     236       y < 0 || y >= (int)c->height)
     237        return;
     238
     239    c->chars[x + y * c->width] = ch;
     240    c->attr[x + y * c->width] = (c->bgcolor << 16) | c->fgcolor;
     241}
     242
  • libcaca/trunk/cucul/colour.c

    r807 r810  
    3737 *  or CUCUL_COLOR_TRANSPARENT.
    3838 *
    39  *  \param qq A handle to the libcucul canvas.
     39 *  \param c A handle to the libcucul canvas.
    4040 *  \param fg The requested foreground colour.
    4141 *  \param bg The requested background colour.
    4242 */
    43 void cucul_set_color(cucul_t *qq, unsigned char fg, unsigned char bg)
     43void cucul_set_color(cucul_canvas_t *c, unsigned char fg, unsigned char bg)
    4444{
    4545    if(fg > 0x20 || bg > 0x20)
    4646        return;
    4747
    48     qq->fgcolor = fg;
    49     qq->bgcolor = bg;
     48    c->fgcolor = fg;
     49    c->bgcolor = bg;
    5050}
    5151
     
    6060 *  white with 50% alpha (A=8 R=15 G=15 B=15).
    6161 *
    62  *  \param qq A handle to the libcucul canvas.
     62 *  \param c A handle to the libcucul canvas.
    6363 *  \param fg The requested foreground colour.
    6464 *  \param bg The requested background colour.
    6565 */
    66 void cucul_set_truecolor(cucul_t *qq, unsigned int fg, unsigned int bg)
     66void cucul_set_truecolor(cucul_canvas_t *c, unsigned int fg, unsigned int bg)
    6767{
    6868    if(fg > 0xffff || bg > 0xffff)
     
    7575        bg += 0x100;
    7676
    77     qq->fgcolor = fg;
    78     qq->bgcolor = bg;
     77    c->fgcolor = fg;
     78    c->bgcolor = bg;
    7979}
    8080
     
    125125}
    126126
    127 uint8_t _cucul_argb32_to_ansi8(uint32_t c)
    128 {
    129     uint16_t fg = c & 0xffff;
    130     uint16_t bg = c >> 16;
     127uint8_t _cucul_argb32_to_ansi8(uint32_t ch)
     128{
     129    uint16_t fg = ch & 0xffff;
     130    uint16_t bg = ch >> 16;
    131131
    132132    return nearest_ansi(fg, CUCUL_COLOR_LIGHTGRAY)
     
    134134}
    135135
    136 uint8_t _cucul_argb32_to_ansi4fg(uint32_t c)
    137 {
    138     return nearest_ansi(c & 0xffff, CUCUL_COLOR_LIGHTGRAY);
    139 }
    140 
    141 uint8_t _cucul_argb32_to_ansi4bg(uint32_t c)
    142 {
    143     return nearest_ansi(c >> 16, CUCUL_COLOR_BLACK);
    144 }
    145 
    146 uint16_t _cucul_argb32_to_rgb12fg(uint32_t c)
    147 {
    148     uint16_t fg = c & 0xffff;
     136uint8_t _cucul_argb32_to_ansi4fg(uint32_t ch)
     137{
     138    return nearest_ansi(ch & 0xffff, CUCUL_COLOR_LIGHTGRAY);
     139}
     140
     141uint8_t _cucul_argb32_to_ansi4bg(uint32_t ch)
     142{
     143    return nearest_ansi(ch >> 16, CUCUL_COLOR_BLACK);
     144}
     145
     146uint16_t _cucul_argb32_to_rgb12fg(uint32_t ch)
     147{
     148    uint16_t fg = ch & 0xffff;
    149149
    150150    if(fg < CUCUL_COLOR_DEFAULT)
     
    160160}
    161161
    162 uint16_t _cucul_argb32_to_rgb12bg(uint32_t c)
    163 {
    164     uint16_t bg = c >> 16;
     162uint16_t _cucul_argb32_to_rgb12bg(uint32_t ch)
     163{
     164    uint16_t bg = ch >> 16;
    165165
    166166    if(bg < CUCUL_COLOR_DEFAULT)
     
    181181  | ((uint32_t)(i & 0x00f) * 0x000011))
    182182
    183 uint32_t _cucul_argb32_to_rgb24fg(uint32_t c)
    184 {
    185     return RGB12TO24(_cucul_argb32_to_rgb12fg(c));
    186 }
    187 
    188 uint32_t _cucul_argb32_to_rgb24bg(uint32_t c)
    189 {
    190     return RGB12TO24(_cucul_argb32_to_rgb12bg(c));
    191 }
    192 
    193 void _cucul_argb32_to_argb4(uint32_t c, uint8_t argb[8])
    194 {
    195     uint16_t fg = c & 0xffff;
    196     uint16_t bg = c >> 16;
     183uint32_t _cucul_argb32_to_rgb24fg(uint32_t ch)
     184{
     185    return RGB12TO24(_cucul_argb32_to_rgb12fg(ch));
     186}
     187
     188uint32_t _cucul_argb32_to_rgb24bg(uint32_t ch)
     189{
     190    return RGB12TO24(_cucul_argb32_to_rgb12bg(ch));
     191}
     192
     193void _cucul_argb32_to_argb4(uint32_t ch, uint8_t argb[8])
     194{
     195    uint16_t fg = ch & 0xffff;
     196    uint16_t bg = ch >> 16;
    197197
    198198    if(fg < CUCUL_COLOR_DEFAULT)
  • libcaca/trunk/cucul/conic.c

    r773 r810  
    2626#include "cucul_internals.h"
    2727
    28 static void ellipsepoints(cucul_t *, int, int, int, int, uint32_t);
     28static void ellipsepoints(cucul_canvas_t *, int, int, int, int, uint32_t);
    2929
    3030/** \brief Draw a circle on the canvas using the given character.
    3131 *
    32  *  \param qq The handle to the libcucul canvas.
     32 *  \param c The handle to the libcucul canvas.
    3333 *  \param x Center X coordinate.
    3434 *  \param y Center Y coordinate.
     
    3838 *  \return void
    3939 */
    40 void cucul_draw_circle(cucul_t *qq, int x, int y, int r, char const *str)
     40void cucul_draw_circle(cucul_canvas_t *c, int x, int y, int r, char const *str)
    4141{
    4242    int test, dx, dy;
    43     uint32_t c = _cucul_utf8_to_utf32(str);
     43    uint32_t ch = _cucul_utf8_to_utf32(str);
    4444
    4545    /* Optimized Bresenham. Kick ass. */
    4646    for(test = 0, dx = 0, dy = r ; dx <= dy ; dx++)
    4747    {
    48         ellipsepoints(qq, x, y, dx, dy, c);
    49         ellipsepoints(qq, x, y, dy, dx, c);
     48        ellipsepoints(c, x, y, dx, dy, ch);
     49        ellipsepoints(c, x, y, dy, dx, ch);
    5050
    5151        test += test > 0 ? dx - dy-- : dx;
     
    5555/** \brief Fill an ellipse on the canvas using the given character.
    5656 *
    57  *  \param qq The handle to the libcucul canvas.
     57 *  \param c The handle to the libcucul canvas.
    5858 *  \param xo Center X coordinate.
    5959 *  \param yo Center Y coordinate.
     
    6464 *  \return void
    6565 */
    66 void cucul_fill_ellipse(cucul_t *qq, int xo, int yo, int a, int b,
     66void cucul_fill_ellipse(cucul_canvas_t *c, int xo, int yo, int a, int b,
    6767                        char const *str)
    6868{
     
    8181        {
    8282            d1 += b*b*(2*x*1) + a*a*(-2*y+2);
    83             cucul_draw_line(qq, xo - x, yo - y, xo + x, yo - y, str);
    84             cucul_draw_line(qq, xo - x, yo + y, xo + x, yo + y, str);
     83            cucul_draw_line(c, xo - x, yo - y, xo + x, yo - y, str);
     84            cucul_draw_line(c, xo - x, yo + y, xo + x, yo + y, str);
    8585            y--;
    8686        }
     
    8888    }
    8989
    90     cucul_draw_line(qq, xo - x, yo - y, xo + x, yo - y, str);
    91     cucul_draw_line(qq, xo - x, yo + y, xo + x, yo + y, str);
     90    cucul_draw_line(c, xo - x, yo - y, xo + x, yo - y, str);
     91    cucul_draw_line(c, xo - x, yo + y, xo + x, yo + y, str);
    9292
    9393    d2 = b*b*(x+0.5)*(x+0.5) + a*a*(y-1)*(y-1) - a*a*b*b;
     
    105105
    106106        y--;
    107         cucul_draw_line(qq, xo - x, yo - y, xo + x, yo - y, str);
    108         cucul_draw_line(qq, xo - x, yo + y, xo + x, yo + y, str);
     107        cucul_draw_line(c, xo - x, yo - y, xo + x, yo - y, str);
     108        cucul_draw_line(c, xo - x, yo + y, xo + x, yo + y, str);
    109109    }
    110110}
     
    112112/** \brief Draw an ellipse on the canvas using the given character.
    113113 *
    114  *  \param qq The handle to the libcucul canvas.
     114 *  \param c The handle to the libcucul canvas.
    115115 *  \param xo Center X coordinate.
    116116 *  \param yo Center Y coordinate.
     
    121121 *  \return void
    122122 */
    123 void cucul_draw_ellipse(cucul_t *qq, int xo, int yo, int a, int b,
     123void cucul_draw_ellipse(cucul_canvas_t *c, int xo, int yo, int a, int b,
    124124                        char const *str)
    125125{
     
    128128    int y = b;
    129129    int d1 = b*b - (a*a*b) + (a*a/4);
    130     uint32_t c = _cucul_utf8_to_utf32(str);
    131 
    132     ellipsepoints(qq, xo, yo, x, y, c);
     130    uint32_t ch = _cucul_utf8_to_utf32(str);
     131
     132    ellipsepoints(c, xo, yo, x, y, ch);
    133133
    134134    while(a*a*y - a*a/2 > b*b*(x+1))
     
    144144        }
    145145        x++;
    146         ellipsepoints(qq, xo, yo, x, y, c);
     146        ellipsepoints(c, xo, yo, x, y, ch);
    147147    }
    148148
     
    161161
    162162        y--;
    163         ellipsepoints(qq, xo, yo, x, y, c);
     163        ellipsepoints(c, xo, yo, x, y, ch);
    164164    }
    165165}
     
    167167/** \brief Draw a thin ellipse on the canvas.
    168168 *
    169  *  \param qq The handle to the libcucul canvas.
     169 *  \param c The handle to the libcucul canvas.
    170170 *  \param xo Center X coordinate.
    171171 *  \param yo Center Y coordinate.
     
    174174 *  \return void
    175175 */
    176 void cucul_draw_thin_ellipse(cucul_t *qq, int xo, int yo, int a, int b)
     176void cucul_draw_thin_ellipse(cucul_canvas_t *c, int xo, int yo, int a, int b)
    177177{
    178178    /* FIXME: this is not correct */
     
    182182    int d1 = b*b - (a*a*b) + (a*a/4);
    183183
    184     ellipsepoints(qq, xo, yo, x, y, '-');
     184    ellipsepoints(c, xo, yo, x, y, '-');
    185185
    186186    while(a*a*y - a*a/2 > b*b*(x+1))
     
    196196        }
    197197        x++;
    198         ellipsepoints(qq, xo, yo, x, y, '-');
     198        ellipsepoints(c, xo, yo, x, y, '-');
    199199    }
    200200
     
    213213
    214214        y--;
    215         ellipsepoints(qq, xo, yo, x, y, '|');
    216     }
    217 }
    218 
    219 static void ellipsepoints(cucul_t *qq, int xo, int yo, int x, int y, uint32_t c)
     215        ellipsepoints(c, xo, yo, x, y, '|');
     216    }
     217}
     218
     219static void ellipsepoints(cucul_canvas_t *c, int xo, int yo, int x, int y,
     220                          uint32_t ch)
    220221{
    221222    uint8_t b = 0;
    222223
    223     if(xo + x >= 0 && xo + x < (int)qq->width)
     224    if(xo + x >= 0 && xo + x < (int)c->width)
    224225        b |= 0x1;
    225     if(xo - x >= 0 && xo - x < (int)qq->width)
     226    if(xo - x >= 0 && xo - x < (int)c->width)
    226227        b |= 0x2;
    227     if(yo + y >= 0 && yo + y < (int)qq->height)
     228    if(yo + y >= 0 && yo + y < (int)c->height)
    228229        b |= 0x4;
    229     if(yo - y >= 0 && yo - y < (int)qq->height)
     230    if(yo - y >= 0 && yo - y < (int)c->height)
    230231        b |= 0x8;
    231232
    232233    if((b & (0x1|0x4)) == (0x1|0x4))
    233         _cucul_putchar32(qq, xo + x, yo + y, c);
     234        _cucul_putchar32(c, xo + x, yo + y, ch);
    234235
    235236    if((b & (0x2|0x4)) == (0x2|0x4))
    236         _cucul_putchar32(qq, xo - x, yo + y, c);
     237        _cucul_putchar32(c, xo - x, yo + y, ch);
    237238
    238239    if((b & (0x1|0x8)) == (0x1|0x8))
    239         _cucul_putchar32(qq, xo + x, yo - y, c);
     240        _cucul_putchar32(c, xo + x, yo - y, ch);
    240241
    241242    if((b & (0x2|0x8)) == (0x2|0x8))
    242         _cucul_putchar32(qq, xo - x, yo - y, c);
    243 }
    244 
     243        _cucul_putchar32(c, xo - x, yo - y, ch);
     244}
     245
  • libcaca/trunk/cucul/cucul.c

    r804 r810  
    4242 *  \return A libcucul canvas handle upon success, NULL if an error occurred.
    4343 */
    44 cucul_t * cucul_create(unsigned int width, unsigned int height)
    45 {
    46     cucul_t *qq = malloc(sizeof(cucul_t));
    47 
    48     qq->refcount = 0;
    49 
    50     qq->fgcolor = CUCUL_COLOR_LIGHTGRAY;
    51     qq->bgcolor = CUCUL_COLOR_BLACK;
    52 
    53     qq->width = qq->height = 0;
    54     qq->chars = NULL;
    55     qq->attr = NULL;
    56     qq->empty_line = qq->scratch_line = NULL;
     44cucul_canvas_t * cucul_create(unsigned int width, unsigned int height)
     45{
     46    cucul_canvas_t *c = malloc(sizeof(cucul_canvas_t));
     47
     48    c->refcount = 0;
     49
     50    c->fgcolor = CUCUL_COLOR_LIGHTGRAY;
     51    c->bgcolor = CUCUL_COLOR_BLACK;
     52
     53    c->width = c->height = 0;
     54    c->chars = NULL;
     55    c->attr = NULL;
     56    c->empty_line = c->scratch_line = NULL;
    5757
    5858    /* Initialise to a default size. 80x32 is arbitrary but matches AAlib's
     
    6060     * a different size. */
    6161    if(width && height)
    62         _cucul_set_size(qq, width, height);
     62        _cucul_set_size(c, width, height);
    6363    else
    64         _cucul_set_size(qq, 80, 32);
     64        _cucul_set_size(c, 80, 32);
    6565
    6666    if(_cucul_init_dither())
    6767    {
    68         free(qq);
    69         return NULL;
    70     }
    71 
    72     return qq;
     68        free(c);
     69        return NULL;
     70    }
     71
     72    return c;
    7373}
    7474
     
    8282 *  \return A libcucul canvas, or NULL in case of error.
    8383 */
    84 cucul_t *cucul_load(void *data, unsigned int size)
    85 {
    86     cucul_t *qq;
     84cucul_canvas_t *cucul_load(void *data, unsigned int size)
     85{
     86    cucul_canvas_t *c;
    8787    uint8_t *buf = (uint8_t *)data;
    8888    unsigned int width, height, n;
     
    109109        return NULL;
    110110
    111     qq = cucul_create(width, height);
    112 
    113     if(!qq)
     111    c = cucul_create(width, height);
     112
     113    if(!c)
    114114        return NULL;
    115115
    116116    for(n = height * width; n--; )
    117117    {
    118         qq->chars[n] = ((uint32_t)buf[12 + 8 * n] << 24)
     118        c->chars[n] = ((uint32_t)buf[12 + 8 * n] << 24)
    119119                     | ((uint32_t)buf[13 + 8 * n] << 16)
    120120                     | ((uint32_t)buf[14 + 8 * n] << 8)
    121121                     | (uint32_t)buf[15 + 8 * n];
    122         qq->attr[n] = ((uint32_t)buf[16 + 8 * n] << 24)
     122        c->attr[n] = ((uint32_t)buf[16 + 8 * n] << 24)
    123123                    | ((uint32_t)buf[17 + 8 * n] << 16)
    124124                    | ((uint32_t)buf[18 + 8 * n] << 8)
     
    126126    }
    127127
    128     return qq;
     128    return c;
    129129}
    130130
     
    144144 *  for more about this.
    145145 *
    146  *  \param qq A libcucul canvas
     146 *  \param c A libcucul canvas
    147147 *  \param width The desired canvas width
    148148 *  \param height The desired canvas height
    149149 */
    150 void cucul_set_size(cucul_t *qq, unsigned int width, unsigned int height)
    151 {
    152     if(qq->refcount)
     150void cucul_set_size(cucul_canvas_t *c, unsigned int width, unsigned int height)
     151{
     152    if(c->refcount)
    153153        return;
    154154
    155     _cucul_set_size(qq, width, height);
     155    _cucul_set_size(c, width, height);
    156156}
    157157
     
    160160 *  This function returns the current canvas width, in character cells.
    161161 *
    162  *  \param qq A libcucul canvas
     162 *  \param c A libcucul canvas
    163163 *  \return The canvas width.
    164164 */
    165 unsigned int cucul_get_width(cucul_t *qq)
    166 {
    167     return qq->width;
     165unsigned int cucul_get_width(cucul_canvas_t *c)
     166{
     167    return c->width;
    168168}
    169169
     
    172172 *  This function returns the current canvas height, in character cells.
    173173 *
    174  *  \param qq A libcucul canvas
     174 *  \param c A libcucul canvas
    175175 *  \return The canvas height.
    176176 */
    177 unsigned int cucul_get_height(cucul_t *qq)
    178 {
    179     return qq->height;
     177unsigned int cucul_get_height(cucul_canvas_t *c)
     178{
     179    return c->height;
    180180}
    181181
     
    222222 *  unless a new call to cucul_create() is done.
    223223 *
    224  *  \param qq A libcucul canvas
    225  */
    226 void cucul_free(cucul_t *qq)
     224 *  \param c A libcucul canvas
     225 */
     226void cucul_free(cucul_canvas_t *c)
    227227{
    228228    _cucul_end_dither();
    229229
    230     free(qq->empty_line);
    231     free(qq->scratch_line);
    232 
    233     free(qq->chars);
    234     free(qq->attr);
    235 
    236     free(qq);
     230    free(c->empty_line);
     231    free(c->scratch_line);
     232
     233    free(c->chars);
     234    free(c->attr);
     235
     236    free(c);
    237237}
    238238
     
    291291 */
    292292
    293 void _cucul_set_size(cucul_t *qq, unsigned int width, unsigned int height)
     293void _cucul_set_size(cucul_canvas_t *c, unsigned int width, unsigned int height)
    294294{
    295295    unsigned int x, y, old_width, old_height, new_size, old_size;
    296296
    297     old_width = qq->width;
    298     old_height = qq->height;
     297    old_width = c->width;
     298    old_height = c->height;
    299299    old_size = old_width * old_height;
    300300
    301     qq->width = width;
    302     qq->height = height;
     301    c->width = width;
     302    c->height = height;
    303303    new_size = width * height;
    304304
     
    306306    if(new_size > old_size)
    307307    {
    308         qq->chars = realloc(qq->chars, new_size * sizeof(uint32_t));
    309         qq->attr = realloc(qq->attr, new_size * sizeof(uint32_t));
     308        c->chars = realloc(c->chars, new_size * sizeof(uint32_t));
     309        c->attr = realloc(c->attr, new_size * sizeof(uint32_t));
    310310    }
    311311
     
    325325            for(x = old_width; x--; )
    326326            {
    327                 qq->chars[y * width + x] = qq->chars[y * old_width + x];
    328                 qq->attr[y * width + x] = qq->attr[y * old_width + x];
     327                c->chars[y * width + x] = c->chars[y * old_width + x];
     328                c->attr[y * width + x] = c->attr[y * old_width + x];
    329329            }
    330330
    331331            /* Zero the end of the line */
    332332            for(x = width - old_width; x--; )
    333                 qq->chars[y * width + old_width + x] = (uint32_t)' ';
    334             memset(qq->attr + y * width + old_width, 0,
     333                c->chars[y * width + old_width + x] = (uint32_t)' ';
     334            memset(c->attr + y * width + old_width, 0,
    335335                   (width - old_width) * 4);
    336336        }
     
    346346            for(x = 0; x < width; x++)
    347347            {
    348                 qq->chars[y * width + x] = qq->chars[y * old_width + x];
    349                 qq->attr[y * width + x] = qq->attr[y * old_width + x];
     348                c->chars[y * width + x] = c->chars[y * old_width + x];
     349                c->attr[y * width + x] = c->attr[y * old_width + x];
    350350            }
    351351        }
     
    357357        /* Zero the bottom of the screen */
    358358        for(x = (height - old_height) * width; x--; )
    359             qq->chars[old_height * width + x] = (uint32_t)' ';
    360         memset(qq->attr + old_height * width, 0,
     359            c->chars[old_height * width + x] = (uint32_t)' ';
     360        memset(c->attr + old_height * width, 0,
    361361               (height - old_height) * width * 4);
    362362    }
     
    365365    if(new_size <= old_size)
    366366    {
    367         qq->chars = realloc(qq->chars, new_size * sizeof(uint32_t));
    368         qq->attr = realloc(qq->attr, new_size * sizeof(uint32_t));
     367        c->chars = realloc(c->chars, new_size * sizeof(uint32_t));
     368        c->attr = realloc(c->attr, new_size * sizeof(uint32_t));
    369369    }
    370370
     
    372372    if(width != old_width)
    373373    {
    374         qq->empty_line = realloc(qq->empty_line, width + 1);
    375         memset(qq->empty_line, ' ', width);
    376         qq->empty_line[width] = '\0';
    377 
    378         qq->scratch_line = realloc(qq->scratch_line, width + 1);
    379     }
    380 }
    381 
     374        c->empty_line = realloc(c->empty_line, width + 1);
     375        memset(c->empty_line, ' ', width);
     376        c->empty_line[width] = '\0';
     377
     378        c->scratch_line = realloc(c->scratch_line, width + 1);
     379    }
     380}
     381
  • libcaca/trunk/cucul/cucul.h

    r803 r810  
    3333
    3434/** \e libcucul context */
    35 typedef struct cucul cucul_t;
     35typedef struct cucul_canvas cucul_canvas_t;
    3636/** sprite structure */
    3737typedef struct cucul_sprite cucul_sprite_t;
     
    7474 *
    7575 *  @{ */
    76 cucul_t * cucul_create(unsigned int, unsigned int);
    77 cucul_t * cucul_load(void *, unsigned int);
    78 void cucul_set_size(cucul_t *, unsigned int, unsigned int);
    79 unsigned int cucul_get_width(cucul_t *);
    80 unsigned int cucul_get_height(cucul_t *);
    81 void cucul_free(cucul_t *);
     76cucul_canvas_t * cucul_create(unsigned int, unsigned int);
     77cucul_canvas_t * cucul_load(void *, unsigned int);
     78void cucul_set_size(cucul_canvas_t *, unsigned int, unsigned int);
     79unsigned int cucul_get_width(cucul_canvas_t *);
     80unsigned int cucul_get_height(cucul_canvas_t *);
     81void cucul_free(cucul_canvas_t *);
    8282int cucul_rand(int, int);
    8383/*  @} */
     
    9999 *
    100100 *  @{ */
    101 void cucul_set_color(cucul_t *, unsigned char, unsigned char);
    102 void cucul_set_truecolor(cucul_t *, unsigned int, unsigned int);
     101void cucul_set_color(cucul_canvas_t *, unsigned char, unsigned char);
     102void cucul_set_truecolor(cucul_canvas_t *, unsigned int, unsigned int);
    103103char const *cucul_get_color_name(unsigned int);
    104 void cucul_putchar(cucul_t *, int, int, char);
    105 void cucul_putstr(cucul_t *, int, int, char const *);
    106 void cucul_printf(cucul_t *, int, int, char const *, ...);
    107 void cucul_clear(cucul_t *);
    108 void cucul_blit(cucul_t *, int, int, cucul_t const *, cucul_t const *);
     104void cucul_putchar(cucul_canvas_t *, int, int, char);
     105void cucul_putstr(cucul_canvas_t *, int, int, char const *);
     106void cucul_printf(cucul_canvas_t *, int, int, char const *, ...);
     107void cucul_clear(cucul_canvas_t *);
     108void cucul_blit(cucul_canvas_t *, int, int, cucul_canvas_t const *, cucul_canvas_t const *);
    109109/*  @} */
    110110
     
    114114 *
    115115 *  @{ */
    116 void cucul_invert(cucul_t *);
    117 void cucul_flip(cucul_t *);
    118 void cucul_flop(cucul_t *);
    119 void cucul_rotate(cucul_t *);
     116void cucul_invert(cucul_canvas_t *);
     117void cucul_flip(cucul_canvas_t *);
     118void cucul_flop(cucul_canvas_t *);
     119void cucul_rotate(cucul_canvas_t *);
    120120/*  @} */
    121121
     
    126126 *
    127127 *  @{ */
    128 void cucul_draw_line(cucul_t *, int, int, int, int, char const *);
    129 void cucul_draw_polyline(cucul_t *, int const x[], int const y[], int, char const *);
    130 void cucul_draw_thin_line(cucul_t *, int, int, int, int);
    131 void cucul_draw_thin_polyline(cucul_t *, int const x[], int const y[], int);
    132 
    133 void cucul_draw_circle(cucul_t *, int, int, int, char const *);
    134 void cucul_draw_ellipse(cucul_t *, int, int, int, int, char const *);
    135 void cucul_draw_thin_ellipse(cucul_t *, int, int, int, int);
    136 void cucul_fill_ellipse(cucul_t *, int, int, int, int, char const *);
    137 
    138 void cucul_draw_box(cucul_t *, int, int, int, int, char const *);
    139 void cucul_draw_thin_box(cucul_t *, int, int, int, int);
    140 void cucul_fill_box(cucul_t *, int, int, int, int, char const *);
    141 
    142 void cucul_draw_triangle(cucul_t *, int, int, int, int, int, int, char const *);
    143 void cucul_draw_thin_triangle(cucul_t *, int, int, int, int, int, int);
    144 void cucul_fill_triangle(cucul_t *, int, int, int, int, int, int, char const *);
     128void cucul_draw_line(cucul_canvas_t *, int, int, int, int, char const *);
     129void cucul_draw_polyline(cucul_canvas_t *, int const x[], int const y[], int, char const *);
     130void cucul_draw_thin_line(cucul_canvas_t *, int, int, int, int);
     131void cucul_draw_thin_polyline(cucul_canvas_t *, int const x[], int const y[], int);
     132
     133void cucul_draw_circle(cucul_canvas_t *, int, int, int, char const *);
     134void cucul_draw_ellipse(cucul_canvas_t *, int, int, int, int, char const *);
     135void cucul_draw_thin_ellipse(cucul_canvas_t *, int, int, int, int);
     136void cucul_fill_ellipse(cucul_canvas_t *, int, int, int, int, char const *);
     137
     138void cucul_draw_box(cucul_canvas_t *, int, int, int, int, char const *);
     139void cucul_draw_thin_box(cucul_canvas_t *, int, int, int, int);
     140void cucul_fill_box(cucul_canvas_t *, int, int, int, int, char const *);
     141
     142void cucul_draw_triangle(cucul_canvas_t *, int, int, int, int, int, int, char const *);
     143void cucul_draw_thin_triangle(cucul_canvas_t *, int, int, int, int, int, int);
     144void cucul_fill_triangle(cucul_canvas_t *, int, int, int, int, int, int, char const *);
    145145/*  @} */
    146146
     
    157157int cucul_get_sprite_dx(cucul_sprite_t const *, int);
    158158int cucul_get_sprite_dy(cucul_sprite_t const *, int);
    159 void cucul_draw_sprite(cucul_t *, int, int, cucul_sprite_t const *, int);
     159void cucul_draw_sprite(cucul_canvas_t *, int, int, cucul_sprite_t const *, int);
    160160void cucul_free_sprite(cucul_sprite_t *);
    161161/*  @} */
     
    186186void cucul_set_dither_mode(cucul_dither_t *, char const *);
    187187char const * const * cucul_get_dither_mode_list(cucul_dither_t const *);
    188 void cucul_dither_bitmap(cucul_t *, int, int, int, int,
     188void cucul_dither_bitmap(cucul_canvas_t *, int, int, int, int,
    189189                         cucul_dither_t const *, void *);
    190190void cucul_free_dither(cucul_dither_t *);
     
    201201unsigned int cucul_get_font_width(cucul_font_t *);
    202202unsigned int cucul_get_font_height(cucul_font_t *);
    203 void cucul_render_canvas(cucul_t *, cucul_font_t *, void *,
     203void cucul_render_canvas(cucul_canvas_t *, cucul_font_t *, void *,
    204204                         unsigned int, unsigned int, unsigned int);
    205205void cucul_free_font(cucul_font_t *);
     
    212212 *
    213213 *  @{ */
    214 cucul_buffer_t * cucul_create_export(cucul_t *, char const *);
     214cucul_buffer_t * cucul_create_export(cucul_canvas_t *, char const *);
    215215char const * const * cucul_get_export_list(void);
    216216/*  @} */
  • libcaca/trunk/cucul/cucul_internals.h

    r804 r810  
    2626#endif
    2727
    28 struct cucul
     28struct cucul_canvas
    2929{
    3030    /* Context size */
     
    5252
    5353/* Canvas functions */
    54 extern void _cucul_set_size(cucul_t *, unsigned int, unsigned int);
    55 extern void _cucul_putchar32(cucul_t *qq, int x, int y, uint32_t c);
     54extern void _cucul_set_size(cucul_canvas_t *, unsigned int, unsigned int);
     55extern void _cucul_putchar32(cucul_canvas_t *, int, int, uint32_t);
    5656
    5757/* Charset functions */
  • libcaca/trunk/cucul/dither.c

    r777 r810  
    689689}
    690690
    691 /** \brief Draw a dither on the screen.
    692  *
    693  *  Draw a dither at the given coordinates. The dither can be of any size and
    694  *  will be stretched to the text area.
    695  *
    696  *  \param qq A handle to the libcucul canvas.
     691/** \brief Dither a bitmap on the canvas.
     692 *
     693 *  Dither a bitmap at the given coordinates. The dither can be of any size
     694 *  and will be stretched to the text area.
     695 *
     696 *  \param c A handle to the libcucul canvas.
    697697 *  \param x1 X coordinate of the upper-left corner of the drawing area.
    698698 *  \param y1 Y coordinate of the upper-left corner of the drawing area.
     
    702702 *  \param pixels Bitmap's pixels.
    703703 */
    704 void cucul_dither_bitmap(cucul_t *qq, int x1, int y1, int x2, int y2,
     704void cucul_dither_bitmap(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
    705705                         cucul_dither_t const *d, void *pixels)
    706706{
     
    731731    dchmax = d->glyph_count;
    732732
    733     fs_length = ((int)qq->width <= x2 ? (int)qq->width : x2) + 1;
     733    fs_length = ((int)c->width <= x2 ? (int)c->width : x2) + 1;
    734734    floyd_steinberg = malloc(3 * (fs_length + 2) * sizeof(int));
    735735    memset(floyd_steinberg, 0, 3 * (fs_length + 2) * sizeof(int));
     
    738738    fs_b = fs_g + fs_length + 2;
    739739
    740     for(y = y1 > 0 ? y1 : 0; y <= y2 && y <= (int)qq->height; y++)
     740    for(y = y1 > 0 ? y1 : 0; y <= y2 && y <= (int)c->height; y++)
    741741    {
    742742        int remain_r = 0, remain_g = 0, remain_b = 0;
    743743
    744744        for(x = x1 > 0 ? x1 : 0, d->init_dither(y);
    745             x <= x2 && x <= (int)qq->width;
     745            x <= x2 && x <= (int)c->width;
    746746            x++)
    747747    {
     
    792792            toy = (y - y1 + 1) * h / deltay;
    793793
    794             /* tox and toy can overflow the screen, but they cannot overflow
     794            /* tox and toy can overflow the canvas, but they cannot overflow
    795795             * when averaged with fromx and fromy because these are guaranteed
    796796             * to be within the pixel boundaries. */
     
    937937
    938938        /* Now output the character */
    939         cucul_set_color(qq, outfg, outbg);
    940         cucul_putstr(qq, x, y, outch);
     939        cucul_set_color(c, outfg, outbg);
     940        cucul_putstr(c, x, y, outch);
    941941
    942942       d->increment_dither();
  • libcaca/trunk/cucul/export.c

    r808 r810  
    2828#include "cucul_internals.h"
    2929
    30 static void export_ansi(cucul_t *, cucul_buffer_t *);
    31 static void export_html(cucul_t *, cucul_buffer_t *);
    32 static void export_html3(cucul_t *, cucul_buffer_t *);
    33 static void export_irc(cucul_t *, cucul_buffer_t *);
    34 static void export_ps(cucul_t *, cucul_buffer_t *);
    35 static void export_svg(cucul_t *, cucul_buffer_t *);
    36 static void export_tga(cucul_t *, cucul_buffer_t *);
     30static void export_ansi(cucul_canvas_t *, cucul_buffer_t *);
     31static void export_html(cucul_canvas_t *, cucul_buffer_t *);
     32static void export_html3(cucul_canvas_t *, cucul_buffer_t *);
     33static void export_irc(cucul_canvas_t *, cucul_buffer_t *);
     34static void export_ps(cucul_canvas_t *, cucul_buffer_t *);
     35static void export_svg(cucul_canvas_t *, cucul_buffer_t *);
     36static void export_tga(cucul_canvas_t *, cucul_buffer_t *);
    3737
    3838/** \brief Export a canvas into a foreign format.
     
    6060 *  \li \e "tga": export a TGA image.
    6161 *
    62  *  \param qq A libcucul canvas
     62 *  \param c A libcucul canvas
    6363 *  \param format A string describing the requested output format.
    6464 */
    65 cucul_buffer_t * cucul_create_export(cucul_t *qq, char const *format)
     65cucul_buffer_t * cucul_create_export(cucul_canvas_t *c, char const *format)
    6666{
    6767    cucul_buffer_t *ex;
     
    7272
    7373    if(!strcasecmp("ansi", format))
    74         export_ansi(qq, ex);
     74        export_ansi(c, ex);
    7575    else if(!strcasecmp("html", format))
    76         export_html(qq, ex);
     76        export_html(c, ex);
    7777    else if(!strcasecmp("html3", format))
    78         export_html3(qq, ex);
     78        export_html3(c, ex);
    7979    else if(!strcasecmp("irc", format))
    80         export_irc(qq, ex);
     80        export_irc(c, ex);
    8181    else if(!strcasecmp("ps", format))
    82         export_ps(qq, ex);
     82        export_ps(c, ex);
    8383    else if(!strcasecmp("svg", format))
    84         export_svg(qq, ex);
     84        export_svg(c, ex);
    8585    else if(!strcasecmp("tga", format))
    86         export_tga(qq, ex);
     86        export_tga(c, ex);
    8787
    8888    if(ex->size == 0)
     
    126126
    127127/* Generate ANSI representation of current canvas. */
    128 static void export_ansi(cucul_t *qq, cucul_buffer_t *ex)
     128static void export_ansi(cucul_canvas_t *c, cucul_buffer_t *ex)
    129129{
    130130    static uint8_t const palette[] =
     
    140140     * 4 max bytes for a UTF-8 character).
    141141     * Add height*9 to that (zeroes color at the end and jump to next line) */
    142     ex->size = (qq->height * 9) + (qq->width * qq->height * 23);
     142    ex->size = (c->height * 9) + (c->width * c->height * 23);
    143143    ex->data = malloc(ex->size);
    144144
    145145    cur = ex->data;
    146146
    147     for(y = 0; y < qq->height; y++)
    148     {
    149         uint32_t *lineattr = qq->attr + y * qq->width;
    150         uint32_t *linechar = qq->chars + y * qq->width;
     147    for(y = 0; y < c->height; y++)
     148    {
     149        uint32_t *lineattr = c->attr + y * c->width;
     150        uint32_t *linechar = c->chars + y * c->width;
    151151
    152152        uint8_t prevfg = -1;
    153153        uint8_t prevbg = -1;
    154154
    155         for(x = 0; x < qq->width; x++)
     155        for(x = 0; x < c->width; x++)
    156156        {
    157157            uint8_t fg = palette[_cucul_argb32_to_ansi4fg(lineattr[x])];
    158158            uint8_t bg = palette[_cucul_argb32_to_ansi4bg(lineattr[x])];
    159             uint32_t c = linechar[x];
     159            uint32_t ch = linechar[x];
    160160
    161161            if(fg != prevfg || bg != prevbg)
     
    178178            }
    179179
    180             *cur++ = c & 0x7f;
     180            *cur++ = ch & 0x7f;
    181181
    182182            prevfg = fg;
     
    193193
    194194/* Generate HTML representation of current canvas. */
    195 static void export_html(cucul_t *qq, cucul_buffer_t *ex)
     195static void export_html(cucul_canvas_t *c, cucul_buffer_t *ex)
    196196{
    197197    char *cur;
     
    203203     *          up to 9 chars for "&#xxxxxx;", far less for pure ASCII
    204204     *          7 chars for "</span>" */
    205     ex->size = 1000 + qq->height * (7 + qq->width * (47 + 9 + 7));
     205    ex->size = 1000 + c->height * (7 + c->width * (47 + 9 + 7));
    206206    ex->data = malloc(ex->size);
    207207
     
    216216                        "font-family: monospace, fixed; font-weight: bold;");
    217217
    218     for(y = 0; y < qq->height; y++)
    219     {
    220         uint32_t *lineattr = qq->attr + y * qq->width;
    221         uint32_t *linechar = qq->chars + y * qq->width;
    222 
    223         for(x = 0; x < qq->width; x += len)
     218    for(y = 0; y < c->height; y++)
     219    {
     220        uint32_t *lineattr = c->attr + y * c->width;
     221        uint32_t *linechar = c->chars + y * c->width;
     222
     223        for(x = 0; x < c->width; x += len)
    224224        {
    225225            cur += sprintf(cur, "<span style=\"color:#%.03x;"
     
    229229
    230230            for(len = 0;
    231                 x + len < qq->width && lineattr[x + len] == lineattr[x];
     231                x + len < c->width && lineattr[x + len] == lineattr[x];
    232232                len++)
    233233            {
     
    256256 * will not work under gecko (mozilla rendering engine) unless you set a
    257257 * correct header. */
    258 static void export_html3(cucul_t *qq, cucul_buffer_t *ex)
     258static void export_html3(cucul_canvas_t *c, cucul_buffer_t *ex)
    259259{
    260260    char *cur;
     
    266266     *          up to 9 chars for "&#xxxxxx;", far less for pure ASCII
    267267     *          12 chars for "</font></td>" */
    268     ex->size = 1000 + qq->height * (10 + qq->width * (40 + 9 + 12));
     268    ex->size = 1000 + c->height * (10 + c->width * (40 + 9 + 12));
    269269    ex->data = malloc(ex->size);
    270270
     
    273273    /* Table */
    274274    cur += sprintf(cur, "<table cols='%d' cellpadding='0' cellspacing='0'>\n",
    275                         qq->height);
    276 
    277     for(y = 0; y < qq->height; y++)
    278     {
    279         uint32_t *lineattr = qq->attr + y * qq->width;
    280         uint32_t *linechar = qq->chars + y * qq->width;
     275                        c->height);
     276
     277    for(y = 0; y < c->height; y++)
     278    {
     279        uint32_t *lineattr = c->attr + y * c->width;
     280        uint32_t *linechar = c->chars + y * c->width;
    281281
    282282        cur += sprintf(cur, "<tr>");
    283283
    284         for(x = 0; x < qq->width; x += len)
     284        for(x = 0; x < c->width; x += len)
    285285        {
    286286            unsigned int i;
     
    289289             * (see below) */
    290290            len = 1;
    291             while(x + len < qq->width && lineattr[x + len] == lineattr[x])
     291            while(x + len < c->width && lineattr[x + len] == lineattr[x])
    292292                len++;
    293293
     
    325325
    326326/* Export a text file with IRC colours */
    327 static void export_irc(cucul_t *qq, cucul_buffer_t *ex)
     327static void export_irc(cucul_canvas_t *c, cucul_buffer_t *ex)
    328328{
    329329    static uint8_t const palette[] =
     
    344344     */
    345345
    346     ex->size = 2 + (qq->width * qq->height * 11);
     346    ex->size = 2 + (c->width * c->height * 11);
    347347    ex->data = malloc(ex->size);
    348348
    349349    cur = ex->data;
    350350
    351     for(y = 0; y < qq->height; y++)
    352     {
    353         uint32_t *lineattr = qq->attr + y * qq->width;
    354         uint32_t *linechar = qq->chars + y * qq->width;
     351    for(y = 0; y < c->height; y++)
     352    {
     353        uint32_t *lineattr = c->attr + y * c->width;
     354        uint32_t *linechar = c->chars + y * c->width;
    355355
    356356        uint8_t prevfg = -1;
    357357        uint8_t prevbg = -1;
    358358
    359         for(x = 0; x < qq->width; x++)
     359        for(x = 0; x < c->width; x++)
    360360        {
    361361            uint8_t fg = palette[_cucul_argb32_to_ansi4fg(lineattr[x])];
    362362            uint8_t bg = palette[_cucul_argb32_to_ansi4bg(lineattr[x])];
    363             uint32_t c = linechar[x];
     363            uint32_t ch = linechar[x];
    364364
    365365            if(bg == prevbg)
     
    367367                if(fg == prevfg)
    368368                    ; /* Same fg/bg, do nothing */
    369                 else if(c == (uint32_t)' ')
     369                else if(ch == (uint32_t)' ')
    370370                    fg = prevfg; /* Hackety hack */
    371371                else
    372372                {
    373373                    cur += sprintf(cur, "\x03%d", fg);
    374                     if(c >= (uint32_t)'0' && c <= (uint32_t)'9')
     374                    if(ch >= (uint32_t)'0' && ch <= (uint32_t)'9')
    375375                        cur += sprintf(cur, "\x02\x02");
    376376                }
     
    383383                    cur += sprintf(cur, "\x03%d,%d", fg, bg);
    384384
    385                 if(c >= (uint32_t)'0' && c <= (uint32_t)'9')
     385                if(ch >= (uint32_t)'0' && ch <= (uint32_t)'9')
    386386                    cur += sprintf(cur, "\x02\x02");
    387387            }
    388             *cur++ = c & 0x7f;
     388            *cur++ = ch & 0x7f;
    389389            prevfg = fg;
    390390            prevbg = bg;
     
    400400
    401401/* Export a PostScript document. */
    402 static void export_ps(cucul_t *qq, cucul_buffer_t *ex)
     402static void export_ps(cucul_canvas_t *c, cucul_buffer_t *ex)
    403403{
    404404    static char const *ps_header =
     
    431431
    432432    /* 200 is arbitrary but should be ok */
    433     ex->size = strlen(ps_header) + (qq->width * qq->height * 200);
     433    ex->size = strlen(ps_header) + (c->width * c->height * 200);
    434434    ex->data = malloc(ex->size);
    435435
     
    440440
    441441    /* Background, drawn using csquare macro defined in header */
    442     for(y = qq->height; y--; )
    443     {
    444         uint32_t *lineattr = qq->attr + y * qq->width;
    445 
    446         for(x = 0; x < qq->width; x++)
     442    for(y = c->height; y--; )
     443    {
     444        uint32_t *lineattr = c->attr + y * c->width;
     445
     446        for(x = 0; x < c->width; x++)
    447447        {
    448448            uint8_t argb[8];
     
    455455
    456456        /* Return to beginning of the line, and jump to the next one */
    457         cur += sprintf(cur, "-%d 1 translate\n", qq->width);
     457        cur += sprintf(cur, "-%d 1 translate\n", c->width);
    458458    }
    459459
    460460    cur += sprintf(cur, "grestore\n"); /* Restore transformation matrix */
    461461
    462     for(y = qq->height; y--; )
    463     {
    464         uint32_t *lineattr = qq->attr + (qq->height - y - 1) * qq->width;
    465         uint32_t *linechar = qq->chars + (qq->height - y - 1) * qq->width;
    466 
    467         for(x = 0; x < qq->width; x++)
     462    for(y = c->height; y--; )
     463    {
     464        uint32_t *lineattr = c->attr + (c->height - y - 1) * c->width;
     465        uint32_t *linechar = c->chars + (c->height - y - 1) * c->width;
     466
     467        for(x = 0; x < c->width; x++)
    468468        {
    469469            uint8_t argb[8];
    470             uint32_t c = *linechar++;
     470            uint32_t ch = *linechar++;
    471471
    472472            _cucul_argb32_to_argb4(*lineattr++, argb);
     
    479479                           (float)argb[7] * (1.0 / 0xf));
    480480
    481             if(c < 0x00000020)
     481            if(ch < 0x00000020)
    482482                cur += sprintf(cur, "(?) show\n");
    483             else if(c >= 0x00000080)
     483            else if(ch >= 0x00000080)
    484484                cur += sprintf(cur, "(?) show\n");
    485             else switch((uint8_t)(c & 0x7f))
     485            else switch((uint8_t)(ch & 0x7f))
    486486            {
    487487                case '\\':
    488488                case '(':
    489489                case ')':
    490                     cur += sprintf(cur, "(\\%c) show\n", c);
     490                    cur += sprintf(cur, "(\\%c) show\n", ch);
    491491                    break;
    492492                default:
    493                     cur += sprintf(cur, "(%c) show\n", c);
     493                    cur += sprintf(cur, "(%c) show\n", ch);
    494494                    break;
    495495            }
     
    505505
    506506/* Export an SVG vector image */
    507 static void export_svg(cucul_t *qq, cucul_buffer_t *ex)
     507static void export_svg(cucul_canvas_t *c, cucul_buffer_t *ex)
    508508{
    509509    static char const svg_header[] =
     
    518518
    519519    /* 200 is arbitrary but should be ok */
    520     ex->size = strlen(svg_header) + (qq->width * qq->height * 200);
     520    ex->size = strlen(svg_header) + (c->width * c->height * 200);
    521521    ex->data = malloc(ex->size);
    522522
     
    524524
    525525    /* Header */
    526     cur += sprintf(cur, svg_header, qq->width * 6, qq->height * 10,
    527                                     qq->width * 6, qq->height * 10);
     526    cur += sprintf(cur, svg_header, c->width * 6, c->height * 10,
     527                                    c->width * 6, c->height * 10);
    528528
    529529    cur += sprintf(cur, " <g id=\"mainlayer\" font-size=\"12\">\n");
    530530
    531531    /* Background */
    532     for(y = 0; y < qq->height; y++)
    533     {
    534         uint32_t *lineattr = qq->attr + y * qq->width;
    535 
    536         for(x = 0; x < qq->width; x++)
     532    for(y = 0; y < c->height; y++)
     533    {
     534        uint32_t *lineattr = c->attr + y * c->width;
     535
     536        for(x = 0; x < c->width; x++)
    537537        {
    538538            cur += sprintf(cur, "<rect style=\"fill:#%.03x\" x=\"%d\" y=\"%d\""
     
    544544
    545545    /* Text */
    546     for(y = 0; y < qq->height; y++)
    547     {
    548         uint32_t *lineattr = qq->attr + y * qq->width;
    549         uint32_t *linechar = qq->chars + y * qq->width;
    550 
    551         for(x = 0; x < qq->width; x++)
    552         {
    553             uint32_t c = *linechar++;
     546    for(y = 0; y < c->height; y++)
     547    {
     548        uint32_t *lineattr = c->attr + y * c->width;
     549        uint32_t *linechar = c->chars + y * c->width;
     550
     551        for(x = 0; x < c->width; x++)
     552        {
     553            uint32_t ch = *linechar++;
    554554
    555555            cur += sprintf(cur, "<text style=\"fill:#%.03x\" "
     
    557557                                _cucul_argb32_to_rgb12fg(*lineattr++),
    558558                                x * 6, (y * 10) + 10);
    559             if(c < 0x00000020)
     559            if(ch < 0x00000020)
    560560                cur += sprintf(cur, "?");
    561             else if(c > 0x0000007f)
     561            else if(ch > 0x0000007f)
    562562            {
    563563                static const uint8_t mark[7] =
     
    567567
    568568                char buf[10], *parser;
    569                 int bytes = (c < 0x800) ? 2 : (c < 0x10000) ? 3 : 4;
     569                int bytes = (ch < 0x800) ? 2 : (ch < 0x10000) ? 3 : 4;
    570570
    571571                buf[bytes] = '\0';
     
    574574                switch(bytes)
    575575                {
    576                     case 4: *--parser = (c | 0x80) & 0xbf; c >>= 6;
    577                     case 3: *--parser = (c | 0x80) & 0xbf; c >>= 6;
    578                     case 2: *--parser = (c | 0x80) & 0xbf; c >>= 6;
     576                    case 4: *--parser = (ch | 0x80) & 0xbf; ch >>= 6;
     577                    case 3: *--parser = (ch | 0x80) & 0xbf; ch >>= 6;
     578                    case 2: *--parser = (ch | 0x80) & 0xbf; ch >>= 6;
    579579                }
    580                 *--parser = c | mark[bytes];
     580                *--parser = ch | mark[bytes];
    581581
    582582                cur += sprintf(cur, "%s", buf);
    583583            }
    584             else switch((uint8_t)c)
     584            else switch((uint8_t)ch)
    585585            {
    586586                case '>': cur += sprintf(cur, "&gt;"); break;
    587587                case '<': cur += sprintf(cur, "&lt;"); break;
    588588                case '&': cur += sprintf(cur, "&amp;"); break;
    589                 default: cur += sprintf(cur, "%c", c); break;
     589                default: cur += sprintf(cur, "%c", ch); break;
    590590            }
    591591            cur += sprintf(cur, "</text>\n");
     
    602602
    603603/* Export a TGA image */
    604 static void export_tga(cucul_t *qq, cucul_buffer_t *ex)
     604static void export_tga(cucul_canvas_t *c, cucul_buffer_t *ex)
    605605{
    606606    char const * const * fontlist;
     
    615615    f = cucul_load_font(fontlist[0], 0);
    616616
    617     w = cucul_get_width(qq) * cucul_get_font_width(f);
    618     h = cucul_get_height(qq) * cucul_get_font_height(f);
     617    w = cucul_get_width(c) * cucul_get_font_width(f);
     618    h = cucul_get_height(c) * cucul_get_font_height(f);
    619619
    620620    ex->size = w * h * 4 + 18; /* 32 bpp + 18 bytes for the header */
     
    644644
    645645    /* Image Data */
    646     cucul_render_canvas(qq, f, cur, w, h, 4 * w);
     646    cucul_render_canvas(c, f, cur, w, h, 4 * w);
    647647
    648648    /* Swap bytes. What a waste of time. */
  • libcaca/trunk/cucul/font.c

    r803 r810  
    260260 *  font. The pixel format is fixed (32-bit ARGB, 8 bits for each component).
    261261 *
    262  *  The required image width can be computed using \e cucul_get_width(qq) and
     262 *  The required image width can be computed using \e cucul_get_width(c) and
    263263 *  \e cucul_get_font_width(f). The required height can be computed using
    264  *  \e cucul_get_height(qq) and \e cucul_get_font_height(f).
     264 *  \e cucul_get_height(c) and \e cucul_get_font_height(f).
    265265 *
    266266 *  Glyphs that do not fit in the image buffer are currently not rendered at
    267267 *  all. They may be cropped instead in future versions.
    268268 *
    269  *  \param qq The canvas to render
     269 *  \param c The canvas to render
    270270 *  \param f The font, as returned by \e cucul_load_font()
    271271 *  \param buf The image buffer
     
    274274 *  \param pitch The pitch (in bytes) of an image buffer line.
    275275 */
    276 void cucul_render_canvas(cucul_t *qq, cucul_font_t *f,
     276void cucul_render_canvas(cucul_canvas_t *c, cucul_font_t *f,
    277277                         void *buf, unsigned int width,
    278278                         unsigned int height, unsigned int pitch)
     
    284284        glyph = malloc(f->header.width * f->header.height);
    285285
    286     if(width < qq->width * f->header.width)
     286    if(width < c->width * f->header.width)
    287287        xmax = width / f->header.width;
    288288    else
    289         xmax = qq->width;
    290 
    291     if(height < qq->height * f->header.height)
     289        xmax = c->width;
     290
     291    if(height < c->height * f->header.height)
    292292        ymax = height / f->header.height;
    293293    else
    294         ymax = qq->height;
     294        ymax = c->height;
    295295
    296296    for(y = 0; y < ymax; y++)
     
    301301            unsigned int starty = y * f->header.height;
    302302            unsigned int startx = x * f->header.width;
    303             uint32_t ch = qq->chars[y * qq->width + x];
    304             uint32_t attr = qq->attr[y * qq->width + x];
     303            uint32_t ch = c->chars[y * c->width + x];
     304            uint32_t attr = c->attr[y * c->width + x];
    305305            unsigned int b, i, j;
    306306            struct glyph_info *g;
  • libcaca/trunk/cucul/line.c

    r773 r810  
    3131    int x1, y1;
    3232    int x2, y2;
    33     uint32_t c;
    34     void (*draw) (cucul_t *, struct line*);
     33    uint32_t ch;
     34    void (*draw) (cucul_canvas_t *, struct line*);
    3535};
    3636#endif
    3737
    38 static void clip_line(cucul_t*, struct line*);
    39 static uint8_t clip_bits(cucul_t*, int, int);
    40 static void draw_solid_line(cucul_t*, struct line*);
    41 static void draw_thin_line(cucul_t*, struct line*);
     38static void clip_line(cucul_canvas_t*, struct line*);
     39static uint8_t clip_bits(cucul_canvas_t*, int, int);
     40static void draw_solid_line(cucul_canvas_t*, struct line*);
     41static void draw_thin_line(cucul_canvas_t*, struct line*);
    4242
    4343/** \brief Draw a line on the canvas using the given character.
    4444 *
    45  *  \param qq The handle to the libcucul canvas.
     45 *  \param c The handle to the libcucul canvas.
    4646 *  \param x1 X coordinate of the first point.
    4747 *  \param y1 Y coordinate of the first point.
     
    5151 *  \return void
    5252 */
    53 void cucul_draw_line(cucul_t *qq, int x1, int y1, int x2, int y2,
     53void cucul_draw_line(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
    5454                     char const *str)
    5555{
     
    5959    s.x2 = x2;
    6060    s.y2 = y2;
    61     s.c = _cucul_utf8_to_utf32(str);
     61    s.ch = _cucul_utf8_to_utf32(str);
    6262    s.draw = draw_solid_line;
    63     clip_line(qq, &s);
     63    clip_line(c, &s);
    6464}
    6565
     
    7171 *  list as well.
    7272 *
    73  *  \param qq The handle to the libcucul canvas.
     73 *  \param c The handle to the libcucul canvas.
    7474 *  \param x Array of X coordinates. Must have \p n + 1 elements.
    7575 *  \param y Array of Y coordinates. Must have \p n + 1 elements.
     
    7878 *  \return void
    7979 */
    80 void cucul_draw_polyline(cucul_t *qq, int const x[], int const y[], int n,
     80void cucul_draw_polyline(cucul_canvas_t *c, int const x[], int const y[], int n,
    8181                         char const *str)
    8282{
    8383    int i;
    8484    struct line s;
    85     s.c = _cucul_utf8_to_utf32(str);
     85    s.ch = _cucul_utf8_to_utf32(str);
    8686    s.draw = draw_solid_line;
    8787
     
    9292        s.x2 = x[i+1];
    9393        s.y2 = y[i+1];
    94         clip_line(qq, &s);
     94        clip_line(c, &s);
    9595    }
    9696}
     
    9898/** \brief Draw a thin line on the canvas, using ASCII art.
    9999 *
    100  *  \param qq The handle to the libcucul canvas.
     100 *  \param c The handle to the libcucul canvas.
    101101 *  \param x1 X coordinate of the first point.
    102102 *  \param y1 Y coordinate of the first point.
     
    105105 *  \return void
    106106 */
    107 void cucul_draw_thin_line(cucul_t *qq, int x1, int y1, int x2, int y2)
     107void cucul_draw_thin_line(cucul_canvas_t *c, int x1, int y1, int x2, int y2)
    108108{
    109109    struct line s;
     
    113113    s.y2 = y2;
    114114    s.draw = draw_thin_line;
    115     clip_line(qq, &s);
     115    clip_line(c, &s);
    116116}
    117117
     
    123123 *  the list as well.
    124124 *
    125  *  \param qq The handle to the libcucul canvas.
     125 *  \param c The handle to the libcucul canvas.
    126126 *  \param x Array of X coordinates. Must have \p n + 1 elements.
    127127 *  \param y Array of Y coordinates. Must have \p n + 1 elements.
     
    129129 *  \return void
    130130 */
    131 void cucul_draw_thin_polyline(cucul_t *qq, int const x[], int const y[], int n)
     131void cucul_draw_thin_polyline(cucul_canvas_t *c, int const x[], int const y[], int n)
    132132{
    133133    int i;
     
    141141        s.x2 = x[i+1];
    142142        s.y2 = y[i+1];
    143         clip_line(qq, &s);
     143        clip_line(c, &s);
    144144    }
    145145}
     
    150150
    151151/* Generic Cohen-Sutherland line clipping function. */
    152 static void clip_line(cucul_t *qq, struct line* s)
     152static void clip_line(cucul_canvas_t *c, struct line* s)
    153153{
    154154    uint8_t bits1, bits2;
    155155
    156     bits1 = clip_bits(qq, s->x1, s->y1);
    157     bits2 = clip_bits(qq, s->x2, s->y2);
     156    bits1 = clip_bits(c, s->x1, s->y1);
     157    bits2 = clip_bits(c, s->x2, s->y2);
    158158
    159159    if(bits1 & bits2)
     
    163163    {
    164164        if(bits2 == 0)
    165             s->draw(qq, s);
     165            s->draw(c, s);
    166166        else
    167167        {
     
    169169            tmp = s->x1; s->x1 = s->x2; s->x2 = tmp;
    170170            tmp = s->y1; s->y1 = s->y2; s->y2 = tmp;
    171             clip_line(qq, s);
     171            clip_line(c, s);
    172172        }
    173173
     
    182182    else if(bits1 & (1<<1))
    183183    {
    184         int xmax = qq->width - 1;
     184        int xmax = c->width - 1;
    185185        s->y1 = s->y2 - (s->x2 - xmax) * (s->y2 - s->y1) / (s->x2 - s->x1);
    186186        s->x1 = xmax;
     
    193193    else if(bits1 & (1<<3))
    194194    {
    195         int ymax = qq->height - 1;
     195        int ymax = c->height - 1;
    196196        s->x1 = s->x2 - (s->y2 - ymax) * (s->x2 - s->x1) / (s->y2 - s->y1);
    197197        s->y1 = ymax;
    198198    }
    199199
    200     clip_line(qq, s);
     200    clip_line(c, s);
    201201}
    202202
    203203/* Helper function for clip_line(). */
    204 static uint8_t clip_bits(cucul_t *qq, int x, int y)
     204static uint8_t clip_bits(cucul_canvas_t *c, int x, int y)
    205205{
    206206    uint8_t b = 0;
     
    208208    if(x < 0)
    209209        b |= (1<<0);
    210     else if(x >= (int)qq->width)
     210    else if(x >= (int)c->width)
    211211        b |= (1<<1);
    212212
    213213    if(y < 0)
    214214        b |= (1<<2);
    215     else if(y >= (int)qq->height)
     215    else if(y >= (int)c->height)
    216216        b |= (1<<3);
    217217
     
    221221/* Solid line drawing function, using Bresenham's mid-point line
    222222 * scan-conversion algorithm. */
    223 static void draw_solid_line(cucul_t *qq, struct line* s)
     223static void draw_solid_line(cucul_canvas_t *c, struct line* s)
    224224{
    225225    int x1, y1, x2, y2;
     
    243243        for(; dx>=0; dx--)
    244244        {
    245             _cucul_putchar32(qq, x1, y1, s->c);
     245            _cucul_putchar32(c, x1, y1, s->ch);
    246246            if(delta > 0)
    247247            {
     
    265265        for(; dy >= 0; dy--)
    266266        {
    267             _cucul_putchar32(qq, x1, y1, s->c);
     267            _cucul_putchar32(c, x1, y1, s->ch);
    268268            if(delta > 0)
    269269            {
     
    283283/* Thin line drawing function, using Bresenham's mid-point line
    284284 * scan-conversion algorithm and ASCII art graphics. */
    285 static void draw_thin_line(cucul_t *qq, struct line* s)
     285static void draw_thin_line(cucul_canvas_t *c, struct line* s)
    286286{
    287287    uint32_t charmapx[2], charmapy[2];
     
    330330            if(delta > 0)
    331331            {
    332                 _cucul_putchar32(qq, x1, y1, charmapy[1]);
     332                _cucul_putchar32(c, x1, y1, charmapy[1]);
    333333                x1++;
    334334                y1 += yinc;
     
    339339            {
    340340                if(prev)
    341                     _cucul_putchar32(qq, x1, y1, charmapy[0]);
     341                    _cucul_putchar32(c, x1, y1, charmapy[0]);
    342342                else
    343                     _cucul_putchar32(qq, x1, y1, (uint32_t)'-');
     343                    _cucul_putchar32(c, x1, y1, (uint32_t)'-');
    344344                x1++;
    345345                delta += dpr;
     
    358358            if(delta > 0)
    359359            {
    360                 _cucul_putchar32(qq, x1, y1, charmapx[0]);
    361                 _cucul_putchar32(qq, x1 + 1, y1, charmapx[1]);
     360                _cucul_putchar32(c, x1, y1, charmapx[0]);
     361                _cucul_putchar32(c, x1 + 1, y1, charmapx[1]);
    362362                x1++;
    363363                y1 += yinc;
     
    366366            else
    367367            {
    368                 _cucul_putchar32(qq, x1, y1, (uint32_t)'|');
     368                _cucul_putchar32(c, x1, y1, (uint32_t)'|');
    369369                y1 += yinc;
    370370                delta += dpr;
  • libcaca/trunk/cucul/sprite.c

    r777 r810  
    247247 *         frame does not exist, nothing is displayed.
    248248 *
    249  *  \param qq A libcucul canvas
     249 *  \param c A libcucul canvas
    250250 *  \param x The X coordinate.
    251251 *  \param y The Y coordinate.
     
    254254 *  \return void
    255255 */
    256 void cucul_draw_sprite(cucul_t *qq, int x, int y, cucul_sprite_t const *sprite, int f)
     256void cucul_draw_sprite(cucul_canvas_t *c, int x, int y, cucul_sprite_t const *sprite, int f)
    257257{
    258258    int i, j;
     
    268268    frame = &sprite->frames[f];
    269269
    270     oldfg = qq->fgcolor;
    271     oldbg = qq->bgcolor;
     270    oldfg = c->fgcolor;
     271    oldbg = c->bgcolor;
    272272
    273273    for(j = 0; j < frame->h; j++)
     
    278278            if(col >= 0)
    279279            {
    280                 cucul_set_color(qq, col, CUCUL_COLOR_BLACK);
    281                 cucul_putchar(qq, x + i - frame->dx, y + j - frame->dy,
     280                cucul_set_color(c, col, CUCUL_COLOR_BLACK);
     281                cucul_putchar(c, x + i - frame->dx, y + j - frame->dy,
    282282                              frame->chars[frame->w * j + i]);
    283283            }
     
    285285    }
    286286
    287     cucul_set_color(qq, oldfg, oldbg);
     287    cucul_set_color(c, oldfg, oldbg);
    288288}
    289289
  • libcaca/trunk/cucul/transform.c

    r769 r810  
    3333 *  becomes cyan, etc.) without changing the characters in it.
    3434 *
    35  *  \param qq The canvas to invert.
    36  */
    37 void cucul_invert(cucul_t *qq)
    38 {
    39     uint32_t *attr = qq->attr;
     35 *  \param c The canvas to invert.
     36 */
     37void cucul_invert(cucul_canvas_t *c)
     38{
     39    uint32_t *attr = c->attr;
    4040    unsigned int i;
    4141
    42     for(i = qq->height * qq->width; i--; )
     42    for(i = c->height * c->width; i--; )
    4343    {
    4444        *attr = *attr ^ 0x000f000f;
     
    5252 *  look like the mirrored version wherever possible.
    5353 *
    54  *  \param qq The canvas to flip.
    55  */
    56 void cucul_flip(cucul_t *qq)
     54 *  \param c The canvas to flip.
     55 */
     56void cucul_flip(cucul_canvas_t *c)
    5757{
    5858    unsigned int y;
    5959
    60     for(y = 0; y < qq->height; y++)
    61     {
    62         uint32_t *cleft = qq->chars + y * qq->width;
    63         uint32_t *cright = cleft + qq->width - 1;
    64         uint32_t *aleft = qq->attr + y * qq->width;
    65         uint32_t *aright = aleft + qq->width - 1;
     60    for(y = 0; y < c->height; y++)
     61    {
     62        uint32_t *cleft = c->chars + y * c->width;
     63        uint32_t *cright = cleft + c->width - 1;
     64        uint32_t *aleft = c->attr + y * c->width;
     65        uint32_t *aright = aleft + c->width - 1;
    6666
    6767        while(cleft < cright)
     
    8989 *  look like the mirrored version wherever possible.
    9090 *
    91  *  \param qq The canvas to flop.
    92  */
    93 void cucul_flop(cucul_t *qq)
     91 *  \param c The canvas to flop.
     92 */
     93void cucul_flop(cucul_canvas_t *c)
    9494{
    9595    unsigned int x;
    9696
    97     for(x = 0; x < qq->width; x++)
    98     {
    99         uint32_t *ctop = qq->chars + x;
    100         uint32_t *cbottom = ctop + qq->width * (qq->height - 1);
    101         uint32_t *atop = qq->attr + x;
    102         uint32_t *abottom = atop + qq->width * (qq->height - 1);
     97    for(x = 0; x < c->width; x++)
     98    {
     99        uint32_t *ctop = c->chars + x;
     100        uint32_t *cbottom = ctop + c->width * (c->height - 1);
     101        uint32_t *atop = c->attr + x;
     102        uint32_t *abottom = atop + c->width * (c->height - 1);
    103103
    104104        while(ctop < cbottom)
     
    113113            ch = *cbottom; *cbottom = flopchar(*ctop); *ctop = flopchar(ch);
    114114
    115             ctop += qq->width; cbottom -= qq->width;
    116             atop += qq->width; abottom -= qq->width;
     115            ctop += c->width; cbottom -= c->width;
     116            atop += c->width; abottom -= c->width;
    117117        }
    118118
     
    128128 *  possible.
    129129 *
    130  *  \param qq The canvas to rotate.
    131  */
    132 void cucul_rotate(cucul_t *qq)
    133 {
    134     uint32_t *cbegin = qq->chars;
    135     uint32_t *cend = cbegin + qq->width * qq->height - 1;
    136     uint32_t *abegin = qq->attr;
    137     uint32_t *aend = abegin + qq->width * qq->height - 1;
     130 *  \param c The canvas to rotate.
     131 */
     132void cucul_rotate(cucul_canvas_t *c)
     133{
     134    uint32_t *cbegin = c->chars;
     135    uint32_t *cend = cbegin + c->width * c->height - 1;
     136    uint32_t *abegin = c->attr;
     137    uint32_t *aend = abegin + c->width * c->height - 1;
    138138
    139139    while(cbegin < cend)
  • libcaca/trunk/cucul/triangle.c

    r773 r810  
    2727/** \brief Draw a triangle on the canvas using the given character.
    2828 *
    29  *  \param qq The handle to the libcucul canvas.
     29 *  \param c The handle to the libcucul canvas.
    3030 *  \param x1 X coordinate of the first point.
    3131 *  \param y1 Y coordinate of the first point.
     
    3838 *  \return void
    3939 */
    40 void cucul_draw_triangle(cucul_t *qq, int x1, int y1, int x2, int y2,
     40void cucul_draw_triangle(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
    4141                         int x3, int y3, char const *str)
    4242{
    43     cucul_draw_line(qq, x1, y1, x2, y2, str);
    44     cucul_draw_line(qq, x2, y2, x3, y3, str);
    45     cucul_draw_line(qq, x3, y3, x1, y1, str);
     43    cucul_draw_line(c, x1, y1, x2, y2, str);
     44    cucul_draw_line(c, x2, y2, x3, y3, str);
     45    cucul_draw_line(c, x3, y3, x1, y1, str);
    4646}
    4747
    4848/** \brief Draw a thin triangle on the canvas.
    4949 *
    50  *  \param qq The handle to the libcucul canvas.
     50 *  \param c The handle to the libcucul canvas.
    5151 *  \param x1 X coordinate of the first point.
    5252 *  \param y1 Y coordinate of the first point.
     
    5757 *  \return void
    5858 */
    59 void cucul_draw_thin_triangle(cucul_t *qq, int x1, int y1, int x2, int y2,
     59void cucul_draw_thin_triangle(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
    6060                              int x3, int y3)
    6161{
    62     cucul_draw_thin_line(qq, x1, y1, x2, y2);
    63     cucul_draw_thin_line(qq, x2, y2, x3, y3);
    64     cucul_draw_thin_line(qq, x3, y3, x1, y1);
     62    cucul_draw_thin_line(c, x1, y1, x2, y2);
     63    cucul_draw_thin_line(c, x2, y2, x3, y3);
     64    cucul_draw_thin_line(c, x3, y3, x1, y1);
    6565}
    6666
    6767/** \brief Fill a triangle on the canvas using the given character.
    6868 *
    69  *  \param qq The handle to the libcucul canvas.
     69 *  \param c The handle to the libcucul canvas.
    7070 *  \param x1 X coordinate of the first point.
    7171 *  \param y1 Y coordinate of the first point.
     
    7878 *  \return void
    7979 */
    80 void cucul_fill_triangle(cucul_t *qq, int x1, int y1, int x2, int y2,
     80void cucul_fill_triangle(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
    8181                         int x3, int y3, char const *str)
    8282{
    8383    int x, y, xa, xb, xmax, ymax;
    84     uint32_t c;
     84    uint32_t ch;
    8585
    8686    /* Bubble-sort y1 <= y2 <= y3 */
    8787    if(y1 > y2)
    8888    {
    89         cucul_fill_triangle(qq, x2, y2, x1, y1, x3, y3, str);
     89        cucul_fill_triangle(c, x2, y2, x1, y1, x3, y3, str);
    9090        return;
    9191    }
     
    9393    if(y2 > y3)
    9494    {
    95         cucul_fill_triangle(qq, x1, y1, x3, y3, x2, y2, str);
     95        cucul_fill_triangle(c, x1, y1, x3, y3, x2, y2, str);
    9696        return;
    9797    }
     
    102102    x3 *= 4;
    103103
    104     xmax = qq->width - 1;
    105     ymax = qq->height - 1;
     104    xmax = c->width - 1;
     105    ymax = c->height - 1;
    106106
    107     c = _cucul_utf8_to_utf32(str);
     107    ch = _cucul_utf8_to_utf32(str);
    108108
    109109    /* Rasterize our triangle */
     
    137137
    138138        for(x = xa; x <= xb; x++)
    139             _cucul_putchar32(qq, x, y, c);
     139            _cucul_putchar32(c, x, y, ch);
    140140    }
    141141}
  • libcaca/trunk/src/aafire.c

    r777 r810  
    4040#define MAXTABLE (256*5)
    4141#ifdef LIBCACA
    42 static cucul_t *qq;
     42static cucul_canvas_t *c;
    4343static caca_t *kk;
    4444static int XSIZ, YSIZ;
     
    101101
    102102#ifdef LIBCACA
    103   qq = cucul_create(80, 32);
    104   if (!qq)
     103  c = cucul_create(80, 32);
     104  if (!c)
    105105    {
    106106      printf ("Failed to initialize libcucul\n");
    107107      exit (1);
    108108    }
    109   kk = caca_attach(qq);
     109  kk = caca_attach(c);
    110110  if (!kk)
    111111    {
     
    114114    }
    115115  caca_set_delay(kk, 10000);
    116   XSIZ = cucul_get_width(qq) * 2;
    117   YSIZ = cucul_get_height(qq) * 2 - 4;
     116  XSIZ = cucul_get_width(c) * 2;
     117  YSIZ = cucul_get_height(c) * 2 - 4;
    118118#else
    119119  context = aa_autoinit (&aa_defparams);
     
    143143  cucul_dither = cucul_create_dither(8, XSIZ, YSIZ - 2, XSIZ, 0, 0, 0, 0);
    144144  cucul_set_dither_palette(cucul_dither, r, g, b, a);
    145   bitmap = malloc(4 * cucul_get_width(qq) * cucul_get_height(qq) * sizeof(char));
    146   memset(bitmap, 0, 4 * cucul_get_width(qq) * cucul_get_height(qq));
     145  bitmap = malloc(4 * cucul_get_width(c) * cucul_get_height(c) * sizeof(char));
     146  memset(bitmap, 0, 4 * cucul_get_width(c) * cucul_get_height(c));
    147147#else
    148148  aa_hidecursor (context);
     
    154154#ifdef LIBCACA
    155155  caca_detach(kk);
    156   cucul_free(qq);
     156  cucul_free(c);
    157157#else
    158158  aa_close (context);
     
    236236#ifdef LIBCACA
    237237paused:
    238   cucul_dither_bitmap(qq, 0, 0,
    239                       cucul_get_width(qq) - 1, cucul_get_height(qq) - 1,
     238  cucul_dither_bitmap(c, 0, 0,
     239                      cucul_get_width(c) - 1, cucul_get_height(c) - 1,
    240240                      cucul_dither, bitmap);
    241   cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    242   cucul_putstr(qq, cucul_get_width(qq) - 30, cucul_get_height(qq) - 2,
     241  cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
     242  cucul_putstr(c, cucul_get_width(c) - 30, cucul_get_height(c) - 2,
    243243               " -=[ Powered by libcaca ]=- ");
    244244 
     
    269269      if(caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, 0))
    270270        {
    271           switch(ev.data.key.c)
     271          switch(ev.data.key.ch)
    272272            {
    273273                case CACA_KEY_ESCAPE: return;
  • libcaca/trunk/src/cacaball.c

    r777 r810  
    4343int main(int argc, char **argv)
    4444{
    45     cucul_t *qq; caca_t *kk;
     45    cucul_canvas_t *c; caca_t *kk;
    4646    unsigned int r[256], g[256], b[256], a[256];
    4747    float d[METABALLS], di[METABALLS], dj[METABALLS], dk[METABALLS];
     
    5454    double frameOffset80[360];
    5555
    56     qq = cucul_create(0, 0);
    57     if(!qq)
     56    c = cucul_create(0, 0);
     57    if(!c)
    5858        return 1;
    59     kk = caca_attach(qq);
     59    kk = caca_attach(c);
    6060    if(!kk)
    6161        return 1;
     
    9696        if(caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, 0))
    9797        {
    98             switch(ev.data.key.c)
     98            switch(ev.data.key.ch)
    9999            {
    100100                case CACA_KEY_ESCAPE: goto end;
     
    154154paused:
    155155        /* Draw our virtual buffer to screen, letting libcucul resize it */
    156         cucul_dither_bitmap(qq, 0, 0,
    157                           cucul_get_width(qq) - 1, cucul_get_height(qq) - 1,
     156        cucul_dither_bitmap(c, 0, 0,
     157                          cucul_get_width(c) - 1, cucul_get_height(c) - 1,
    158158                          cucul_dither, pixels + (METASIZE / 2) * (1 + XSIZ));
    159         cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    160         cucul_putstr(qq, cucul_get_width(qq) - 30, cucul_get_height(qq) - 2,
     159        cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
     160        cucul_putstr(c, cucul_get_width(c) - 30, cucul_get_height(c) - 2,
    161161                     " -=[ Powered by libcaca ]=- ");
    162162
     
    168168    cucul_free_dither(cucul_dither);
    169169    caca_detach(kk);
    170     cucul_free(qq);
     170    cucul_free(c);
    171171
    172172    return 0;
  • libcaca/trunk/src/cacamoir.c

    r777 r810  
    3838int main (int argc, char **argv)
    3939{
    40     cucul_t *qq; caca_t *kk;
     40    cucul_canvas_t *c; caca_t *kk;
    4141    unsigned int red[256], green[256], blue[256], alpha[256];
    4242    cucul_dither_t *dither;
    4343    int i, x, y, frame = 0, pause = 0;
    4444
    45     qq = cucul_create(0, 0);
    46     if(!qq)
     45    c = cucul_create(0, 0);
     46    if(!c)
    4747        return 1;
    48     kk = caca_attach(qq);
     48    kk = caca_attach(c);
    4949    if(!kk)
    5050        return 1;
     
    7272        if(caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, 0))
    7373        {
    74             switch(ev.data.key.c)
     74            switch(ev.data.key.ch)
    7575            {
    7676                case CACA_KEY_ESCAPE: goto end;
     
    107107
    108108paused:
    109         cucul_dither_bitmap(qq, 0, 0,
    110                             cucul_get_width(qq) - 1, cucul_get_height(qq) - 1,
     109        cucul_dither_bitmap(c, 0, 0,
     110                            cucul_get_width(c) - 1, cucul_get_height(c) - 1,
    111111                            dither, screen);
    112         cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    113         cucul_putstr(qq, cucul_get_width(qq) - 30, cucul_get_height(qq) - 2,
     112        cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
     113        cucul_putstr(c, cucul_get_width(c) - 30, cucul_get_height(c) - 2,
    114114                     " -=[ Powered by libcaca ]=- ");
    115115        caca_display(kk);
     
    119119    cucul_free_dither(dither);
    120120    caca_detach(kk);
    121     cucul_free(qq);
     121    cucul_free(c);
    122122
    123123    return 0;
  • libcaca/trunk/src/cacaplas.c

    r777 r810  
    4141int main (int argc, char **argv)
    4242{
    43     cucul_t *qq, *qq2, *mask; caca_t *kk;
     43    cucul_canvas_t *c, *c2, *mask; caca_t *kk;
    4444    unsigned int red[256], green[256], blue[256], alpha[256];
    4545    double r[3], R[6];
     
    4747    int i, x, y, frame = 0, pause = 0;
    4848
    49     qq = cucul_create(0, 0);
    50     if(!qq)
     49    c = cucul_create(0, 0);
     50    if(!c)
    5151        return 1;
    52     kk = caca_attach(qq);
     52    kk = caca_attach(c);
    5353    if(!kk)
    5454        return 1;
     
    5656    caca_set_delay(kk, 20000);
    5757
    58     qq2 = cucul_create(cucul_get_width(qq), cucul_get_height(qq));
    59     mask = cucul_create(cucul_get_width(qq), cucul_get_height(qq));
     58    c2 = cucul_create(cucul_get_width(c), cucul_get_height(c));
     59    mask = cucul_create(cucul_get_width(c), cucul_get_height(c));
    6060
    6161    /* Fill various tables */
     
    8888        if(caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, 0))
    8989        {
    90             switch(ev.data.key.c)
     90            switch(ev.data.key.ch)
    9191            {
    9292                case CACA_KEY_ESCAPE: goto end;
     
    120120
    121121paused:
    122         cucul_dither_bitmap(qq, 0, 0,
    123                             cucul_get_width(qq) - 1, cucul_get_height(qq) - 1,
     122        cucul_dither_bitmap(c, 0, 0,
     123                            cucul_get_width(c) - 1, cucul_get_height(c) - 1,
    124124                            dither, screen);
    125125
    126         cucul_blit(qq2, 0, 0, qq, NULL);
    127         cucul_invert(qq2);
     126        cucul_blit(c2, 0, 0, c, NULL);
     127        cucul_invert(c2);
    128128
    129129
    130         cucul_blit(qq, 0, 0, qq2, mask);
     130        cucul_blit(c, 0, 0, c2, mask);
    131131
    132         cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    133         cucul_putstr(qq, cucul_get_width(qq) - 30, cucul_get_height(qq) - 2,
     132        cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
     133        cucul_putstr(c, cucul_get_width(c) - 30, cucul_get_height(c) - 2,
    134134                     " -=[ Powered by libcaca ]=- ");
    135135        caca_display(kk);
     
    139139    cucul_free_dither(dither);
    140140    caca_detach(kk);
    141     cucul_free(qq);
     141    cucul_free(c);
    142142
    143143    return 0;
  • libcaca/trunk/src/cacaplay.c

    r777 r810  
    2828    struct stat statbuf;
    2929    caca_event_t ev;
    30     cucul_t *qq;
     30    cucul_canvas_t *c;
    3131    caca_t *kk;
    3232    void *buffer;
     
    5454    buffer = malloc(statbuf.st_size);
    5555    read(fd, buffer, statbuf.st_size);
    56     qq = cucul_load(buffer, statbuf.st_size);
     56    c = cucul_load(buffer, statbuf.st_size);
    5757    free(buffer);
    5858
    59     if(!qq)
     59    if(!c)
    6060    {
    6161        fprintf(stderr, "%s: invalid caca file %s.\n", argv[0], argv[1]);
     
    6363    }
    6464
    65     kk = caca_attach(qq);
     65    kk = caca_attach(c);
    6666
    6767    caca_display(kk);
     
    6969    while(caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, -1))
    7070    {
    71         if(ev.data.key.c == CACA_KEY_ESCAPE)
     71        if(ev.data.key.ch == CACA_KEY_ESCAPE)
    7272            break;
    7373    }
     
    7575    /* Clean up */
    7676    caca_detach(kk);
    77     cucul_free(qq);
     77    cucul_free(c);
    7878
    7979    return 0;
  • libcaca/trunk/src/cacaserver.c

    r777 r810  
    105105    char prefix[sizeof(INIT_PREFIX)];
    106106
    107     cucul_t *qq;
     107    cucul_canvas_t *canvas;
    108108    cucul_buffer_t *buffer;
    109109    unsigned long int buflen;
     
    185185    }
    186186
    187     server->qq = NULL;
     187    server->canvas = NULL;
    188188    server->buffer = NULL;
    189189
     
    224224
    225225        /* Free the previous canvas, if any */
    226         if(server->qq)
    227             cucul_free(server->qq);
    228 
    229         server->qq = cucul_load(buf, size);
    230 
    231         if(!server->qq)
     226        if(server->canvas)
     227            cucul_free(server->canvas);
     228
     229        server->canvas = cucul_load(buf, size);
     230
     231        if(!server->canvas)
    232232            continue; /* Load error */
    233233
     
    241241        /* Get ANSI representation of the image and skip the end-of buffer
    242242         * linefeed ("\r\n\0", 3 bytes) */
    243         server->buffer = cucul_create_export(server->qq, "ansi");
     243        server->buffer = cucul_create_export(server->canvas, "ansi");
    244244        server->buflen -= 3;
    245245
  • libcaca/trunk/src/cacaview.c

    r777 r810  
    4242
    4343/* libcucul/libcaca contexts */
    44 cucul_t *qq; caca_t *kk;
     44cucul_canvas_t *c; caca_t *kk;
    4545
    4646/* Local functions */
     
    6969
    7070    /* Initialise libcucul */
    71     qq = cucul_create(0, 0);
    72     if(!qq)
     71    c = cucul_create(0, 0);
     72    if(!c)
    7373    {
    7474        fprintf(stderr, "%s: unable to initialise libcucul\n", argv[0]);
     
    7676    }
    7777
    78     kk = caca_attach(qq);
     78    kk = caca_attach(c);
    7979    if(!kk)
    8080    {
     
    8686    caca_set_window_title(kk, "cacaview");
    8787
    88     ww = cucul_get_width(qq);
    89     wh = cucul_get_height(qq);
     88    ww = cucul_get_width(c);
     89    wh = cucul_get_height(c);
    9090
    9191    /* Fill the zoom table */
     
    151151                }
    152152            }
    153             else if(ev.type & CACA_EVENT_KEY_PRESS) switch(ev.data.key.c)
     153            else if(ev.type & CACA_EVENT_KEY_PRESS) switch(ev.data.key.ch)
    154154            {
    155155            case 'n':
     
    171171#if 0 /* FIXME */
    172172            case 'b':
    173                 i = 1 + cucul_get_feature(qq, CUCUL_BACKGROUND);
     173                i = 1 + cucul_get_feature(c, CUCUL_BACKGROUND);
    174174                if(i > CUCUL_BACKGROUND_MAX) i = CUCUL_BACKGROUND_MIN;
    175                 cucul_set_feature(qq, i);
     175                cucul_set_feature(c, i);
    176176                new_status = STATUS_BACKGROUND;
    177177                update = 1;
    178178                break;
    179179            case 'B':
    180                 i = -1 + cucul_get_feature(qq, CUCUL_BACKGROUND);
     180                i = -1 + cucul_get_feature(c, CUCUL_BACKGROUND);
    181181                if(i < CUCUL_BACKGROUND_MIN) i = CUCUL_BACKGROUND_MAX;
    182                 cucul_set_feature(qq, i);
     182                cucul_set_feature(c, i);
    183183                new_status = STATUS_BACKGROUND;
    184184                update = 1;
    185185                break;
    186186            case 'a':
    187                 i = 1 + cucul_get_feature(qq, CUCUL_ANTIALIASING);
     187                i = 1 + cucul_get_feature(c, CUCUL_ANTIALIASING);
    188188                if(i > CUCUL_ANTIALIASING_MAX) i = CUCUL_ANTIALIASING_MIN;
    189                 cucul_set_feature(qq, i);
     189                cucul_set_feature(c, i);
    190190                new_status = STATUS_ANTIALIASING;
    191191                update = 1;
    192192                break;
    193193            case 'A':
    194                 i = -1 + cucul_get_feature(qq, CUCUL_ANTIALIASING);
     194                i = -1 + cucul_get_feature(c, CUCUL_ANTIALIASING);
    195195                if(i < CUCUL_ANTIALIASING_MIN) i = CUCUL_ANTIALIASING_MAX;
    196                 cucul_set_feature(qq, i);
     196                cucul_set_feature(c, i);
    197197                new_status = STATUS_ANTIALIASING;
    198198                update = 1;
    199199                break;
    200200            case 'd':
    201                 i = 1 + cucul_get_feature(qq, CUCUL_DITHERING);
     201                i = 1 + cucul_get_feature(c, CUCUL_DITHERING);
    202202                if(i > CUCUL_DITHERING_MAX) i = CUCUL_DITHERING_MIN;
    203                 cucul_set_feature(qq, i);
     203                cucul_set_feature(c, i);
    204204                new_status = STATUS_DITHERING;
    205205                update = 1;
    206206                break;
    207207            case 'D':
    208                 i = -1 + cucul_get_feature(qq, CUCUL_DITHERING);
     208                i = -1 + cucul_get_feature(c, CUCUL_DITHERING);
    209209                if(i < CUCUL_DITHERING_MIN) i = CUCUL_DITHERING_MAX;
    210                 cucul_set_feature(qq, i);
     210                cucul_set_feature(c, i);
    211211                new_status = STATUS_DITHERING;
    212212                update = 1;
     
    302302            sprintf(buffer, " Loading `%s'... ", list[current]);
    303303            buffer[ww] = '\0';
    304             cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    305             cucul_putstr(qq, (ww - strlen(buffer)) / 2, wh / 2, buffer);
     304            cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
     305            cucul_putstr(c, (ww - strlen(buffer)) / 2, wh / 2, buffer);
    306306            caca_display(kk);
    307             ww = cucul_get_width(qq);
    308             wh = cucul_get_height(qq);
     307            ww = cucul_get_width(c);
     308            wh = cucul_get_height(c);
    309309
    310310            if(im)
     
    322322        }
    323323
    324         cucul_clear(qq);
     324        cucul_clear(c);
    325325
    326326        if(!items)
    327327        {
    328             cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    329             cucul_printf(qq, ww / 2 - 5, wh / 2, " No image. ");
     328            cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
     329            cucul_printf(c, ww / 2 - 5, wh / 2, " No image. ");
    330330        }
    331331        else if(!im)
     
    346346            sprintf(buffer, ERROR_STRING, list[current]);
    347347            buffer[ww] = '\0';
    348             cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    349             cucul_putstr(qq, (ww - strlen(buffer)) / 2, wh / 2, buffer);
     348            cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
     349            cucul_putstr(c, (ww - strlen(buffer)) / 2, wh / 2, buffer);
    350350            free(buffer);
    351351        }
     
    366366                          y + height * (1.0 + yfactor) / 2);
    367367
    368             cucul_dither_bitmap(qq, ww * (1.0 - xfactor) * xdelta,
     368            cucul_dither_bitmap(c, ww * (1.0 - xfactor) * xdelta,
    369369                              y + height * (1.0 - yfactor) * ydelta,
    370370                              ww * (xdelta + (1.0 - xdelta) * xfactor),
     
    378378
    379379#if 0 /* FIXME */
    380             cucul_set_color(qq, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
     380            cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
    381381            switch(status)
    382382            {
    383383                case STATUS_ANTIALIASING:
    384                     cucul_printf(qq, 0, wh - 1, "Antialiasing: %s",
    385                   cucul_get_feature_name(cucul_get_feature(qq, CUCUL_ANTIALIASING)));
     384                    cucul_printf(c, 0, wh - 1, "Antialiasing: %s",
     385                  cucul_get_feature_name(cucul_get_feature(c, CUCUL_ANTIALIASING)));
    386386                    break;
    387387                case STATUS_DITHERING:
    388                     cucul_printf(qq, 0, wh - 1, "Dithering: %s",
    389                   cucul_get_feature_name(cucul_get_feature(qq, CUCUL_DITHERING)));
     388                    cucul_printf(c, 0, wh - 1, "Dithering: %s",
     389                  cucul_get_feature_name(cucul_get_feature(c, CUCUL_DITHERING)));
    390390                    break;
    391391                case STATUS_BACKGROUND:
    392                     cucul_printf(qq, 0, wh - 1, "Background: %s",
    393                   cucul_get_feature_name(cucul_get_feature(qq, CUCUL_BACKGROUND)));
     392                    cucul_printf(c, 0, wh - 1, "Background: %s",
     393                  cucul_get_feature_name(cucul_get_feature(c, CUCUL_BACKGROUND)));
    394394                    break;
    395395            }
     
    410410        unload_image(im);
    411411    caca_detach(kk);
    412     cucul_free(qq);
     412    cucul_free(c);
    413413
    414414    return 0;
     
    417417static void print_status(void)
    418418{
    419     cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    420     cucul_draw_line(qq, 0, 0, ww - 1, 0, " ");
    421     cucul_draw_line(qq, 0, wh - 2, ww - 1, wh - 2, "-");
    422     cucul_putstr(qq, 0, 0, "q:Quit  np:Next/Prev  +-x:Zoom  gG:Gamma  "
     419    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
     420    cucul_draw_line(c, 0, 0, ww - 1, 0, " ");
     421    cucul_draw_line(c, 0, wh - 2, ww - 1, wh - 2, "-");
     422    cucul_putstr(c, 0, 0, "q:Quit  np:Next/Prev  +-x:Zoom  gG:Gamma  "
    423423                           "hjkl:Move  d:Dither  a:Antialias");
    424     cucul_putstr(qq, ww - strlen("?:Help"), 0, "?:Help");
    425     cucul_printf(qq, 3, wh - 2, "cacaview %s", VERSION);
    426     cucul_printf(qq, ww - 30, wh - 2, "(gamma: %#.3g)", GAMMA(g));
    427     cucul_printf(qq, ww - 14, wh - 2, "(zoom: %s%i)", zoom > 0 ? "+" : "", zoom);
    428 
    429     cucul_set_color(qq, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
    430     cucul_draw_line(qq, 0, wh - 1, ww - 1, wh - 1, " ");
     424    cucul_putstr(c, ww - strlen("?:Help"), 0, "?:Help");
     425    cucul_printf(c, 3, wh - 2, "cacaview %s", VERSION);
     426    cucul_printf(c, ww - 30, wh - 2, "(gamma: %#.3g)", GAMMA(g));
     427    cucul_printf(c, ww - 14, wh - 2, "(zoom: %s%i)", zoom > 0 ? "+" : "", zoom);
     428
     429    cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
     430    cucul_draw_line(c, 0, wh - 1, ww - 1, wh - 1, " ");
    431431}
    432432
     
    455455    int i;
    456456
    457     cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
     457    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    458458
    459459    for(i = 0; help[i]; i++)
    460         cucul_putstr(qq, x, y + i, help[i]);
     460        cucul_putstr(c, x, y + i, help[i]);
    461461}
    462462
     
    473473    if(zoom < -ZOOM_MAX) zoom = -ZOOM_MAX;
    474474
    475     ww = cucul_get_width(qq);
     475    ww = cucul_get_width(c);
    476476    height = fullscreen ? wh : wh - 3;
    477477
    478478    xfactor = (zoom < 0) ? 1.0 / zoomtab[-zoom] : zoomtab[zoom];
    479479    yfactor = xfactor * ww / height * im->h / im->w
    480                * cucul_get_height(qq) / cucul_get_width(qq)
     480               * cucul_get_height(c) / cucul_get_width(c)
    481481               * caca_get_window_width(kk) / caca_get_window_height(kk);
    482482
     
    507507    int xn, yn;
    508508
    509     if(x2 + 1 > (int)cucul_get_width(qq)) x2 = cucul_get_width(qq) - 1;
    510     if(y2 + 1 > (int)cucul_get_height(qq)) y2 = cucul_get_height(qq) - 1;
     509    if(x2 + 1 > (int)cucul_get_width(c)) x2 = cucul_get_width(c) - 1;
     510    if(y2 + 1 > (int)cucul_get_height(c)) y2 = cucul_get_height(c) - 1;
    511511
    512512    for(yn = y1 > 0 ? y1 : 0; yn <= y2; yn++)
     
    514514    {
    515515        if((((xn - x1) / 5) ^ ((yn - y1) / 3)) & 1)
    516             cucul_set_color(qq, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_DARKGRAY);
     516            cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_DARKGRAY);
    517517        else
    518             cucul_set_color(qq, CUCUL_COLOR_DARKGRAY, CUCUL_COLOR_LIGHTGRAY);
    519         cucul_putchar(qq, xn, yn, ' ');
     518            cucul_set_color(c, CUCUL_COLOR_DARKGRAY, CUCUL_COLOR_LIGHTGRAY);
     519        cucul_putchar(c, xn, yn, ' ');
    520520    }
    521521}
  • libcaca/trunk/src/img2irc.c

    r777 r810  
    2424{
    2525    /* libcucul context */
    26     cucul_t *qq;
     26    cucul_canvas_t *c;
    2727    cucul_buffer_t *export;
    2828    struct image *i;
     
    3535    }
    3636
    37     qq = cucul_create(0, 0);
    38     if(!qq)
     37    c = cucul_create(0, 0);
     38    if(!c)
    3939    {
    4040        fprintf(stderr, "%s: unable to initialise libcucul\n", argv[0]);
     
    4646    {
    4747        fprintf(stderr, "%s: unable to load %s\n", argv[0], argv[1]);
    48         cucul_free(qq);
     48        cucul_free(c);
    4949        return 1;
    5050    }
     
    5353    lines = cols * i->h * 6 / i->w / 10;
    5454
    55     cucul_set_size(qq, cols, lines);
    56     cucul_clear(qq);
    57     cucul_dither_bitmap(qq, 0, 0, cols - 1, lines - 1, i->dither, i->pixels);
     55    cucul_set_size(c, cols, lines);
     56    cucul_clear(c);
     57    cucul_dither_bitmap(c, 0, 0, cols - 1, lines - 1, i->dither, i->pixels);
    5858
    5959    unload_image(i);
    6060
    61     export = cucul_create_export(qq, "irc");
     61    export = cucul_create_export(c, "irc");
    6262    fwrite(cucul_get_buffer_data(export),
    6363           cucul_get_buffer_size(export), 1, stdout);
    6464    cucul_free_buffer(export);
    6565
    66     cucul_free(qq);
     66    cucul_free(c);
    6767
    6868    return 0;
  • libcaca/trunk/test/colors.c

    r777 r810  
    2323int main(int argc, char **argv)
    2424{
    25     cucul_t *qq;
     25    cucul_canvas_t *c;
    2626    caca_t *kk;
    2727    caca_event_t ev;
    2828    int i, j;
    2929
    30     qq = cucul_create(0, 0);
    31     if(!qq)
     30    c = cucul_create(0, 0);
     31    if(!c)
    3232        return 1;
    3333
    34     kk = caca_attach(qq);
     34    kk = caca_attach(c);
    3535    if(!kk)
    3636        return 1;
    3737
    38     cucul_clear(qq);
     38    cucul_clear(c);
    3939    for(i = 0; i < 16; i++)
    4040    {
    41         cucul_set_color(qq, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
    42         cucul_printf(qq, 4, i + (i >= 8 ? 4 : 3), "'%c': %i (%s)",
     41        cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
     42        cucul_printf(c, 4, i + (i >= 8 ? 4 : 3), "'%c': %i (%s)",
    4343                     'a' + i, i, cucul_get_color_name(i));
    4444        for(j = 0; j < 16; j++)
    4545        {
    46             cucul_set_color(qq, i, j);
    47             cucul_putstr(qq, (j >= 8 ? 41 : 40) + j * 2, i + (i >= 8 ? 4 : 3),
     46            cucul_set_color(c, i, j);
     47            cucul_putstr(c, (j >= 8 ? 41 : 40) + j * 2, i + (i >= 8 ? 4 : 3),
    4848                         "# ");
    4949        }
     
    5454
    5555    caca_detach(kk);
    56     cucul_free(qq);
     56    cucul_free(c);
    5757
    5858    return 0;
  • libcaca/trunk/test/demo.c

    r777 r810  
    3838cucul_sprite_t *sprite = NULL;
    3939
    40 cucul_t *qq;
     40cucul_canvas_t *c;
    4141caca_t *kk;
    4242
     
    4646    int quit = 0;
    4747
    48     qq = cucul_create(0, 0);
    49     if(!qq)
     48    c = cucul_create(0, 0);
     49    if(!c)
    5050        return 1;
    51     kk = caca_attach(qq);
     51    kk = caca_attach(c);
    5252    if(!kk)
    5353        return 1;
     
    8484            else if(ev.type & CACA_EVENT_KEY_PRESS)
    8585            {
    86                 switch(ev.data.key.c)
     86                switch(ev.data.key.ch)
    8787                {
    8888                case 'q':
     
    105105                case 'D':
    106106                    dithering = (dithering + 1) % 5;
    107                     cucul_set_feature(qq, dithering);
     107                    cucul_set_feature(c, dithering);
    108108                    display_menu();
    109109                    break;
     
    143143
    144144                if(demo)
    145                     cucul_clear(qq);
     145                    cucul_clear(c);
    146146            }
    147147            else if(ev.type & CACA_EVENT_MOUSE_MOTION)
     
    162162            if(mouse && !demo)
    163163            {
    164                 cucul_set_color(qq, CUCUL_COLOR_RED, CUCUL_COLOR_BLACK);
    165                 cucul_putstr(qq, xmouse, ymouse,     ".");
    166                 cucul_putstr(qq, xmouse, ymouse + 1, "|\\");
     164                cucul_set_color(c, CUCUL_COLOR_RED, CUCUL_COLOR_BLACK);
     165                cucul_putstr(c, xmouse, ymouse,     ".");
     166                cucul_putstr(c, xmouse, ymouse + 1, "|\\");
    167167            }
    168168            caca_display(kk);
     
    174174            demo();
    175175
    176             cucul_set_color(qq, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
    177             cucul_draw_thin_box(qq, 1, 1, cucul_get_width(qq) - 2, cucul_get_height(qq) - 2);
    178             cucul_printf(qq, 4, 1, "[%i.%i fps]----",
     176            cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
     177            cucul_draw_thin_box(c, 1, 1, cucul_get_width(c) - 2, cucul_get_height(c) - 2);
     178            cucul_printf(c, 4, 1, "[%i.%i fps]----",
    179179                         1000000 / caca_get_rendertime(kk),
    180180                         (10000000 / caca_get_rendertime(kk)) % 10);
     
    186186    cucul_free_sprite(sprite);
    187187    caca_detach(kk);
    188     cucul_free(qq);
     188    cucul_free(c);
    189189
    190190    return 0;
     
    193193static void display_menu(void)
    194194{
    195     int xo = cucul_get_width(qq) - 2;
    196     int yo = cucul_get_height(qq) - 2;
    197 
    198     cucul_clear(qq);
    199     cucul_set_color(qq, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
    200     cucul_draw_thin_box(qq, 1, 1, xo, yo);
    201 
    202     cucul_putstr(qq, (xo - strlen("libcaca demo")) / 2, 3, "libcaca demo");
    203     cucul_putstr(qq, (xo - strlen("==============")) / 2, 4, "==============");
    204 
    205     cucul_putstr(qq, 4, 6, "demos:");
    206     cucul_putstr(qq, 4, 7, "'f': full");
    207     cucul_putstr(qq, 4, 8, "'1': dots");
    208     cucul_putstr(qq, 4, 9, "'2': lines");
    209     cucul_putstr(qq, 4, 10, "'3': boxes");
    210     cucul_putstr(qq, 4, 11, "'4': triangles");
    211     cucul_putstr(qq, 4, 12, "'5': ellipses");
    212     cucul_putstr(qq, 4, 13, "'c': colour");
    213     cucul_putstr(qq, 4, 14, "'r': render");
     195    int xo = cucul_get_width(c) - 2;
     196    int yo = cucul_get_height(c) - 2;
     197
     198    cucul_clear(c);
     199    cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
     200    cucul_draw_thin_box(c, 1, 1, xo, yo);
     201
     202    cucul_putstr(c, (xo - strlen("libcaca demo")) / 2, 3, "libcaca demo");
     203    cucul_putstr(c, (xo - strlen("==============")) / 2, 4, "==============");
     204
     205    cucul_putstr(c, 4, 6, "demos:");
     206    cucul_putstr(c, 4, 7, "'f': full");
     207    cucul_putstr(c, 4, 8, "'1': dots");
     208    cucul_putstr(c, 4, 9, "'2': lines");
     209    cucul_putstr(c, 4, 10, "'3': boxes");
     210    cucul_putstr(c, 4, 11, "'4': triangles");
     211    cucul_putstr(c, 4, 12, "'5': ellipses");
     212    cucul_putstr(c, 4, 13, "'c': colour");
     213    cucul_putstr(c, 4, 14, "'r': render");
    214214    if(sprite)
    215         cucul_putstr(qq, 4, 15, "'s': sprites");
    216 
    217     cucul_putstr(qq, 4, 16, "settings:");
    218     cucul_printf(qq, 4, 17, "'o': outline: %s",
     215        cucul_putstr(c, 4, 15, "'s': sprites");
     216
     217    cucul_putstr(c, 4, 16, "settings:");
     218    cucul_printf(c, 4, 17, "'o': outline: %s",
    219219                 outline == 0 ? "none" : outline == 1 ? "solid" : "thin");
    220     cucul_printf(qq, 4, 18, "'b': drawing boundaries: %s",
     220    cucul_printf(c, 4, 18, "'b': drawing boundaries: %s",
    221221                 bounds == 0 ? "screen" : "infinite");
    222     //cucul_printf(qq, 4, 19, "'d': dithering (%s)",
     222    //cucul_printf(c, 4, 19, "'d': dithering (%s)",
    223223    //             cucul_get_feature_name(dithering));
    224224
    225     cucul_putstr(qq, 4, yo - 2, "'q': quit");
     225    cucul_putstr(c, 4, yo - 2, "'q': quit");
    226226
    227227    caca_display(kk);
     
    236236    i++;
    237237
    238     cucul_clear(qq);
     238    cucul_clear(c);
    239239
    240240    /* Draw the sun */
    241     cucul_set_color(qq, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
    242     xo = cucul_get_width(qq) / 4;
    243     yo = cucul_get_height(qq) / 4 + 5 * sin(0.03*i);
     241    cucul_set_color(c, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
     242    xo = cucul_get_width(c) / 4;
     243    yo = cucul_get_height(c) / 4 + 5 * sin(0.03*i);
    244244
    245245    for(j = 0; j < 16; j++)
     
    247247        xa = xo - (30 + sin(0.03*i) * 8) * sin(0.03*i + M_PI*j/8);
    248248        ya = yo + (15 + sin(0.03*i) * 4) * cos(0.03*i + M_PI*j/8);
    249         cucul_draw_thin_line(qq, xo, yo, xa, ya);
     249        cucul_draw_thin_line(c, xo, yo, xa, ya);
    250250    }
    251251
    252252    j = 15 + sin(0.03*i) * 8;
    253     cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLACK);
    254     cucul_fill_ellipse(qq, xo, yo, j, j / 2, "#");
    255     cucul_set_color(qq, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
    256     cucul_draw_ellipse(qq, xo, yo, j, j / 2, "#");
     253    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLACK);
     254    cucul_fill_ellipse(c, xo, yo, j, j / 2, "#");
     255    cucul_set_color(c, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
     256    cucul_draw_ellipse(c, xo, yo, j, j / 2, "#");
    257257
    258258    /* Draw the pyramid */
    259     xo = cucul_get_width(qq) * 5 / 8;
     259    xo = cucul_get_width(c) * 5 / 8;
    260260    yo = 2;
    261261
    262     xa = cucul_get_width(qq) / 8 + sin(0.03*i) * 5;
    263     ya = cucul_get_height(qq) / 2 + cos(0.03*i) * 5;
    264 
    265     xb = cucul_get_width(qq) - 10 - cos(0.02*i) * 10;
    266     yb = cucul_get_height(qq) * 3 / 4 - 5 + sin(0.02*i) * 5;
    267 
    268     xc = cucul_get_width(qq) / 4 - sin(0.02*i) * 5;
    269     yc = cucul_get_height(qq) * 3 / 4 + cos(0.02*i) * 5;
    270 
    271     cucul_set_color(qq, CUCUL_COLOR_GREEN, CUCUL_COLOR_BLACK);
    272     cucul_fill_triangle(qq, xo, yo, xb, yb, xa, ya, "%");
    273     cucul_set_color(qq, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
    274     cucul_draw_thin_triangle(qq, xo, yo, xb, yb, xa, ya);
    275 
    276     cucul_set_color(qq, CUCUL_COLOR_RED, CUCUL_COLOR_BLACK);
    277     cucul_fill_triangle(qq, xa, ya, xb, yb, xc, yc, "#");
    278     cucul_set_color(qq, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
    279     cucul_draw_thin_triangle(qq, xa, ya, xb, yb, xc, yc);
    280 
    281     cucul_set_color(qq, CUCUL_COLOR_BLUE, CUCUL_COLOR_BLACK);
    282     cucul_fill_triangle(qq, xo, yo, xb, yb, xc, yc, "%");
    283     cucul_set_color(qq, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
    284     cucul_draw_thin_triangle(qq, xo, yo, xb, yb, xc, yc);
     262    xa = cucul_get_width(c) / 8 + sin(0.03*i) * 5;
     263    ya = cucul_get_height(c) / 2 + cos(0.03*i) * 5;
     264
     265    xb = cucul_get_width(c) - 10 - cos(0.02*i) * 10;
     266    yb = cucul_get_height(c) * 3 / 4 - 5 + sin(0.02*i) * 5;
     267
     268    xc = cucul_get_width(c) / 4 - sin(0.02*i) * 5;
     269    yc = cucul_get_height(c) * 3 / 4 + cos(0.02*i) * 5;
     270
     271    cucul_set_color(c, CUCUL_COLOR_GREEN, CUCUL_COLOR_BLACK);
     272    cucul_fill_triangle(c, xo, yo, xb, yb, xa, ya, "%");
     273    cucul_set_color(c, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
     274    cucul_draw_thin_triangle(c, xo, yo, xb, yb, xa, ya);
     275
     276    cucul_set_color(c, CUCUL_COLOR_RED, CUCUL_COLOR_BLACK);
     277    cucul_fill_triangle(c, xa, ya, xb, yb, xc, yc, "#");
     278    cucul_set_color(c, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
     279    cucul_draw_thin_triangle(c, xa, ya, xb, yb, xc, yc);
     280
     281    cucul_set_color(c, CUCUL_COLOR_BLUE, CUCUL_COLOR_BLACK);
     282    cucul_fill_triangle(c, xo, yo, xb, yb, xc, yc, "%");
     283    cucul_set_color(c, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
     284    cucul_draw_thin_triangle(c, xo, yo, xb, yb, xc, yc);
    285285
    286286    /* Draw a background triangle */
     
    288288    ya = 2;
    289289
    290     xb = cucul_get_width(qq) - 3;
    291     yb = cucul_get_height(qq) / 2;
    292 
    293     xc = cucul_get_width(qq) / 3;
    294     yc = cucul_get_height(qq) - 3;
    295 
    296     cucul_set_color(qq, CUCUL_COLOR_CYAN, CUCUL_COLOR_BLACK);
    297     cucul_draw_thin_triangle(qq, xa, ya, xb, yb, xc, yc);
    298 
    299     xo = cucul_get_width(qq) / 2 + cos(0.027*i) * cucul_get_width(qq) / 3;
    300     yo = cucul_get_height(qq) / 2 - sin(0.027*i) * cucul_get_height(qq) / 2;
    301 
    302     cucul_draw_thin_line(qq, xa, ya, xo, yo);
    303     cucul_draw_thin_line(qq, xb, yb, xo, yo);
    304     cucul_draw_thin_line(qq, xc, yc, xo, yo);
     290    xb = cucul_get_width(c) - 3;
     291    yb = cucul_get_height(c) / 2;
     292
     293    xc = cucul_get_width(c) / 3;
     294    yc = cucul_get_height(c) - 3;
     295
     296    cucul_set_color(c, CUCUL_COLOR_CYAN, CUCUL_COLOR_BLACK);
     297    cucul_draw_thin_triangle(c, xa, ya, xb, yb, xc, yc);
     298
     299    xo = cucul_get_width(c) / 2 + cos(0.027*i) * cucul_get_width(c) / 3;
     300    yo = cucul_get_height(c) / 2 - sin(0.027*i) * cucul_get_height(c) / 2;
     301
     302    cucul_draw_thin_line(c, xa, ya, xo, yo);
     303    cucul_draw_thin_line(c, xb, yb, xo, yo);
     304    cucul_draw_thin_line(c, xc, yc, xo, yo);
    305305
    306306    /* Draw a sprite on the pyramid */
    307     cucul_draw_sprite(qq, xo, yo, sprite, 0);
     307    cucul_draw_sprite(c, xo, yo, sprite, 0);
    308308
    309309    /* Draw a trail behind the foreground sprite */
     
    311311    {
    312312        int delta = cucul_rand(-5, 5);
    313         cucul_set_color(qq, cucul_rand(0, 15), cucul_rand(0, 15));
    314         cucul_putchar(qq, cucul_get_width(qq) / 2
    315                     + cos(0.02*j) * (delta + cucul_get_width(qq) / 4),
    316                    cucul_get_height(qq) / 2
    317                     + sin(0.02*j) * (delta + cucul_get_height(qq) / 3),
     313        cucul_set_color(c, cucul_rand(0, 15), cucul_rand(0, 15));
     314        cucul_putchar(c, cucul_get_width(c) / 2
     315                    + cos(0.02*j) * (delta + cucul_get_width(c) / 4),
     316                   cucul_get_height(c) / 2
     317                    + sin(0.02*j) * (delta + cucul_get_height(c) / 3),
    318318                   '#');
    319319    }
    320320
    321321    /* Draw foreground sprite */
    322     cucul_draw_sprite(qq, cucul_get_width(qq) / 2 + cos(0.02*i) * cucul_get_width(qq) / 4,
    323                    cucul_get_height(qq) / 2 + sin(0.02*i) * cucul_get_height(qq) / 3,
     322    cucul_draw_sprite(c, cucul_get_width(c) / 2 + cos(0.02*i) * cucul_get_width(c) / 4,
     323                   cucul_get_height(c) / 2 + sin(0.02*i) * cucul_get_height(c) / 3,
    324324                   sprite, 0);
    325325}
     
    327327static void demo_dots(void)
    328328{
    329     int xmax = cucul_get_width(qq) - 1;
    330     int ymax = cucul_get_height(qq) - 1;
     329    int xmax = cucul_get_width(c) - 1;
     330    int ymax = cucul_get_height(c) - 1;
    331331    int i;
    332332    static char chars[10] =
     
    338338    {
    339339        /* Putpixel */
    340         cucul_set_color(qq, cucul_rand(0, 15), cucul_rand(0, 15));
    341         cucul_putchar(qq, cucul_rand(0, xmax), cucul_rand(0, ymax),
     340        cucul_set_color(c, cucul_rand(0, 15), cucul_rand(0, 15));
     341        cucul_putchar(c, cucul_rand(0, xmax), cucul_rand(0, ymax),
    342342                      chars[cucul_rand(0, 9)]);
    343343    }
     
    349349    char buf[BUFSIZ];
    350350
    351     cucul_clear(qq);
     351    cucul_clear(c);
    352352    for(i = 0; i < 16; i++)
    353353    {
    354354        sprintf(buf, "'%c': %i (%s)", 'a' + i, i, cucul_get_color_name(i));
    355         cucul_set_color(qq, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
    356         cucul_putstr(qq, 4, i + (i >= 8 ? 4 : 3), buf);
     355        cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
     356        cucul_putstr(c, 4, i + (i >= 8 ? 4 : 3), buf);
    357357        for(j = 0; j < 16; j++)
    358358        {
    359             cucul_set_color(qq, i, j);
    360             cucul_putstr(qq, (j >= 8 ? 41 : 40) + j * 2, i + (i >= 8 ? 4 : 3), "# ");
     359            cucul_set_color(c, i, j);
     360            cucul_putstr(c, (j >= 8 ? 41 : 40) + j * 2, i + (i >= 8 ? 4 : 3), "# ");
    361361        }
    362362    }
     
    365365static void demo_lines(void)
    366366{
    367     int w = cucul_get_width(qq);
    368     int h = cucul_get_height(qq);
     367    int w = cucul_get_width(c);
     368    int h = cucul_get_height(c);
    369369    int xa, ya, xb, yb;
    370370
     
    380380    }
    381381
    382     cucul_set_color(qq, cucul_rand(0, 15), CUCUL_COLOR_BLACK);
     382    cucul_set_color(c, cucul_rand(0, 15), CUCUL_COLOR_BLACK);
    383383    if(outline > 1)
    384         cucul_draw_thin_line(qq, xa, ya, xb, yb);
     384        cucul_draw_thin_line(c, xa, ya, xb, yb);
    385385    else
    386         cucul_draw_line(qq, xa, ya, xb, yb, "#");
     386        cucul_draw_line(c, xa, ya, xb, yb, "#");
    387387}
    388388
    389389static void demo_boxes(void)
    390390{
    391     int w = cucul_get_width(qq);
    392     int h = cucul_get_height(qq);
     391    int w = cucul_get_width(c);
     392    int h = cucul_get_height(c);
    393393    int xa, ya, xb, yb;
    394394
     
    404404    }
    405405
    406     cucul_set_color(qq, cucul_rand(0, 15), cucul_rand(0, 15));
    407     cucul_fill_box(qq, xa, ya, xb, yb, "#");
    408 
    409     cucul_set_color(qq, cucul_rand(0, 15), CUCUL_COLOR_BLACK);
     406    cucul_set_color(c, cucul_rand(0, 15), cucul_rand(0, 15));
     407    cucul_fill_box(c, xa, ya, xb, yb, "#");
     408
     409    cucul_set_color(c, cucul_rand(0, 15), CUCUL_COLOR_BLACK);
    410410    if(outline == 2)
    411         cucul_draw_thin_box(qq, xa, ya, xb, yb);
     411        cucul_draw_thin_box(c, xa, ya, xb, yb);
    412412    else if(outline == 1)
    413         cucul_draw_box(qq, xa, ya, xb, yb, "#");
     413        cucul_draw_box(c, xa, ya, xb, yb, "#");
    414414}
    415415
    416416static void demo_ellipses(void)
    417417{
    418     int w = cucul_get_width(qq);
    419     int h = cucul_get_height(qq);
     418    int w = cucul_get_width(c);
     419    int h = cucul_get_height(c);
    420420    int x, y, a, b;
    421421
     
    435435    }
    436436
    437     cucul_set_color(qq, cucul_rand(0, 15), cucul_rand(0, 15));
    438     cucul_fill_ellipse(qq, x, y, a, b, "#");
    439 
    440     cucul_set_color(qq, cucul_rand(0, 15), CUCUL_COLOR_BLACK);
     437    cucul_set_color(c, cucul_rand(0, 15), cucul_rand(0, 15));
     438    cucul_fill_ellipse(c, x, y, a, b, "#");
     439
     440    cucul_set_color(c, cucul_rand(0, 15), CUCUL_COLOR_BLACK);
    441441    if(outline == 2)
    442         cucul_draw_thin_ellipse(qq, x, y, a, b);
     442        cucul_draw_thin_ellipse(c, x, y, a, b);
    443443    else if(outline == 1)
    444         cucul_draw_ellipse(qq, x, y, a, b, "#");
     444        cucul_draw_ellipse(c, x, y, a, b, "#");
    445445}
    446446
    447447static void demo_triangles(void)
    448448{
    449     int w = cucul_get_width(qq);
    450     int h = cucul_get_height(qq);
     449    int w = cucul_get_width(c);
     450    int h = cucul_get_height(c);
    451451    int xa, ya, xb, yb, xc, yc;
    452452
     
    465465    }
    466466
    467     cucul_set_color(qq, cucul_rand(0, 15), cucul_rand(0, 15));
    468     cucul_fill_triangle(qq, xa, ya, xb, yb, xc, yc, "#");
    469 
    470     cucul_set_color(qq, cucul_rand(0, 15), CUCUL_COLOR_BLACK);
     467    cucul_set_color(c, cucul_rand(0, 15), cucul_rand(0, 15));
     468    cucul_fill_triangle(c, xa, ya, xb, yb, xc, yc, "#");
     469
     470    cucul_set_color(c, cucul_rand(0, 15), CUCUL_COLOR_BLACK);
    471471    if(outline == 2)
    472         cucul_draw_thin_triangle(qq, xa, ya, xb, yb, xc, yc);
     472        cucul_draw_thin_triangle(c, xa, ya, xb, yb, xc, yc);
    473473    else if(outline == 1)
    474         cucul_draw_triangle(qq, xa, ya, xb, yb, xc, yc, "#");
     474        cucul_draw_triangle(c, xa, ya, xb, yb, xc, yc, "#");
    475475}
    476476
    477477static void demo_sprites(void)
    478478{
    479     cucul_draw_sprite(qq, cucul_rand(0, cucul_get_width(qq) - 1),
    480                    cucul_rand(0, cucul_get_height(qq) - 1), sprite, 0);
     479    cucul_draw_sprite(c, cucul_rand(0, cucul_get_width(c) - 1),
     480                   cucul_rand(0, cucul_get_height(c) - 1), sprite, 0);
    481481}
    482482
     
    504504    //dither = cucul_create_dither(16, 256, 256, 2 * 256, 0xf800, 0x07e0, 0x001f, 0x0000);
    505505    dither = cucul_create_dither(32, 256, 256, 4 * 256, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
    506     cucul_dither_bitmap(qq, 0, 0, cucul_get_width(qq) - 1, cucul_get_height(qq) - 1,
     506    cucul_dither_bitmap(c, 0, 0, cucul_get_width(c) - 1, cucul_get_height(c) - 1,
    507507                     dither, buffer);
    508508    cucul_free_dither(dither);
     
    549549    dither = cucul_create_dither(32, 256, 256, 4 * 256, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
    550550 cucul_set_dither_invert(dither, 1);
    551     cucul_dither_bitmap(qq, 0, 0, cucul_get_width(qq) - 1, cucul_get_height(qq) - 1, dither, (char *)buffer);
     551    cucul_dither_bitmap(c, 0, 0, cucul_get_width(c) - 1, cucul_get_height(c) - 1, dither, (char *)buffer);
    552552    cucul_free_dither(dither);
    553553}
  • libcaca/trunk/test/dithering.c

    r792 r810  
    3636{
    3737    caca_event_t ev;
    38     cucul_t *qq;
     38    cucul_canvas_t *c;
    3939    caca_t *kk;
    4040    int neara, dista, nearb, distb, dist;
    4141    int x, y;
    4242
    43     qq = cucul_create(0, 0);
    44     kk = caca_attach(qq);
     43    c = cucul_create(0, 0);
     44    kk = caca_attach(c);
    4545
    4646    for(x = 0; x < 100; x++)
     
    117117        else
    118118            ch = density[dista * 2 * 13 / (dista + distb)];
    119         cucul_set_color(qq, points[nearb], points[neara]);
     119        cucul_set_color(c, points[nearb], points[neara]);
    120120
    121         cucul_putchar(qq, x * cucul_get_width(qq) / 100,
    122                           (100 - y) * cucul_get_height(qq) / 100, ch);
     121        cucul_putchar(c, x * cucul_get_width(c) / 100,
     122                          (100 - y) * cucul_get_height(c) / 100, ch);
    123123    }
    124124
     
    128128
    129129    caca_detach(kk);
    130     cucul_free(qq);
     130    cucul_free(c);
    131131
    132132    return 0;
  • libcaca/trunk/test/event.c

    r802 r810  
    2121#include "caca.h"
    2222
    23 static cucul_t *qq;
     23static cucul_canvas_t *c;
    2424static caca_t *kk;
    2525
     
    3131    int i, h, quit;
    3232
    33     qq = cucul_create(0, 0);
    34     if(!qq)
     33    c = cucul_create(0, 0);
     34    if(!c)
    3535        return 1;
    36     kk = caca_attach(qq);
     36    kk = caca_attach(c);
    3737    if(!kk)
    3838        return 1;
    3939
    40     h = cucul_get_height(qq) - 1;
     40    h = cucul_get_height(c) - 1;
    4141
    42     cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    43     cucul_draw_line(qq, 0, 0, cucul_get_width(qq) - 1, 0, " ");
     42    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
     43    cucul_draw_line(c, 0, 0, cucul_get_width(c) - 1, 0, " ");
    4444
    45     cucul_draw_line(qq, 0, h, cucul_get_width(qq) - 1, h, " ");
    46     cucul_putstr(qq, 0, h, "type \"quit\" to exit");
     45    cucul_draw_line(c, 0, h, cucul_get_width(c) - 1, h, " ");
     46    cucul_putstr(c, 0, h, "type \"quit\" to exit");
    4747
    4848    caca_display(kk);
     
    6565            if(ev.type & CACA_EVENT_KEY_PRESS)
    6666            {
    67                 int key = ev.data.key.c;
     67                int key = ev.data.key.ch;
    6868                if((key == 'q' && quit == 0) || (key == 'u' && quit == 1)
    6969                    || (key == 'i' && quit == 2) || (key == 't' && quit == 3))
     
    8282        while(ret);
    8383
    84         cucul_clear(qq);
     84        cucul_clear(c);
    8585
    8686        /* Print current event */
    87         cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    88         cucul_draw_line(qq, 0, 0, cucul_get_width(qq) - 1, 0, " ");
     87        cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
     88        cucul_draw_line(c, 0, 0, cucul_get_width(c) - 1, 0, " ");
    8989        print_event(0, 0, events);
    9090
    91         cucul_draw_line(qq, 0, h, cucul_get_width(qq) - 1, h, " ");
    92         cucul_printf(qq, 0, h, "type \"quit\" to exit: %s", quit_string[quit]);
     91        cucul_draw_line(c, 0, h, cucul_get_width(c) - 1, h, " ");
     92        cucul_printf(c, 0, h, "type \"quit\" to exit: %s", quit_string[quit]);
    9393
    9494        /* Print previous events */
    95         cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLACK);
     95        cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLACK);
    9696        for(i = 1; i < h && events[i].type; i++)
    9797            print_event(0, i, events + i);
     
    102102    /* Clean up */
    103103    caca_detach(kk);
    104     cucul_free(qq);
     104    cucul_free(c);
    105105
    106106    return 0;
     
    114114    {
    115115    case CACA_EVENT_NONE:
    116         cucul_printf(qq, x, y, "CACA_EVENT_NONE");
     116        cucul_printf(c, x, y, "CACA_EVENT_NONE");
    117117        break;
    118118    case CACA_EVENT_KEY_PRESS:
    119         character = ev->data.key.c;
    120         cucul_printf(qq, x, y, "CACA_EVENT_KEY_PRESS 0x%02x (%c)", character,
     119        character = ev->data.key.ch;
     120        cucul_printf(c, x, y, "CACA_EVENT_KEY_PRESS 0x%02x (%c)", character,
    121121                     (character > 0x1f && character < 0x80) ? character : '?');
    122122        break;
    123123    case CACA_EVENT_KEY_RELEASE:
    124         character = ev->data.key.c;
    125         cucul_printf(qq, x, y, "CACA_EVENT_KEY_RELEASE 0x%02x (%c)", character,
     124        character = ev->data.key.ch;
     125        cucul_printf(c, x, y, "CACA_EVENT_KEY_RELEASE 0x%02x (%c)", character,
    126126                     (character > 0x1f && character < 0x80) ? character : '?');
    127127        break;
    128128    case CACA_EVENT_MOUSE_MOTION:
    129         cucul_printf(qq, x, y, "CACA_EVENT_MOUSE_MOTION %u %u",
     129        cucul_printf(c, x, y, "CACA_EVENT_MOUSE_MOTION %u %u",
    130130                     ev->data.mouse.x, ev->data.mouse.y);
    131131        break;
    132132    case CACA_EVENT_MOUSE_PRESS:
    133         cucul_printf(qq, x, y, "CACA_EVENT_MOUSE_PRESS %u",
     133        cucul_printf(c, x, y, "CACA_EVENT_MOUSE_PRESS %u",
    134134                     ev->data.mouse.button);
    135135        break;
    136136    case CACA_EVENT_MOUSE_RELEASE:
    137         cucul_printf(qq, x, y, "CACA_EVENT_MOUSE_RELEASE %u",
     137        cucul_printf(c, x, y, "CACA_EVENT_MOUSE_RELEASE %u",
    138138                     ev->data.mouse.button);
    139139        break;
    140140    case CACA_EVENT_RESIZE:
    141         cucul_printf(qq, x, y, "CACA_EVENT_RESIZE %u %u",
     141        cucul_printf(c, x, y, "CACA_EVENT_RESIZE %u %u",
    142142                     ev->data.resize.w, ev->data.resize.h);
    143143        break;
    144144    case CACA_EVENT_QUIT:
    145         cucul_printf(qq, x, y, "CACA_EVENT_QUIT");
     145        cucul_printf(c, x, y, "CACA_EVENT_QUIT");
    146146        break;
    147147    default:
    148         cucul_printf(qq, x, y, "CACA_EVENT_UNKNOWN");
     148        cucul_printf(c, x, y, "CACA_EVENT_UNKNOWN");
    149149    }
    150150}
  • libcaca/trunk/test/export.c

    r788 r810  
    3535int main(int argc, char *argv[])
    3636{
    37     cucul_t *qq;
     37    cucul_canvas_t *c;
    3838    cucul_dither_t *dither;
    3939    cucul_buffer_t *buffer;
     
    6666    }
    6767
    68     qq = cucul_create(WIDTH, HEIGHT);
     68    c = cucul_create(WIDTH, HEIGHT);
    6969
    7070    for(y = 0; y < 256; y++)
     
    8181    dither = cucul_create_dither(32, 256, 256, 4 * 256,
    8282                                 0x00ff0000, 0x0000ff00, 0x000000ff, 0x0);
    83     cucul_dither_bitmap(qq, 0, 0,
    84                         cucul_get_width(qq) - 1, cucul_get_height(qq) - 1,
     83    cucul_dither_bitmap(c, 0, 0,
     84                        cucul_get_width(c) - 1, cucul_get_height(c) - 1,
    8585                        dither, pixels);
    8686    cucul_free_dither(dither);
    8787
    88     cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLACK);
    89     cucul_draw_thin_box(qq, 0, 0, WIDTH - 1, HEIGHT - 1);
     88    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLACK);
     89    cucul_draw_thin_box(c, 0, 0, WIDTH - 1, HEIGHT - 1);
    9090
    91     cucul_set_color(qq, CUCUL_COLOR_BLACK, CUCUL_COLOR_WHITE);
    92     cucul_fill_ellipse(qq, WIDTH / 2, HEIGHT / 2, WIDTH / 4, HEIGHT / 4, " ");
    93     cucul_putstr(qq, WIDTH / 2 - 5, HEIGHT / 2 - 2, "(\") \\o/ <&>");
    94     cucul_putstr(qq, WIDTH / 2 - 7, HEIGHT / 2 + 2, "äβç ░▒▓█▓▒░ ΔЗҒ");
     91    cucul_set_color(c, CUCUL_COLOR_BLACK, CUCUL_COLOR_WHITE);
     92    cucul_fill_ellipse(c, WIDTH / 2, HEIGHT / 2, WIDTH / 4, HEIGHT / 4, " ");
     93    cucul_putstr(c, WIDTH / 2 - 5, HEIGHT / 2 - 2, "(\") \\o/ <&>");
     94    cucul_putstr(c, WIDTH / 2 - 7, HEIGHT / 2 + 2, "äβç ░▒▓█▓▒░ ΔЗҒ");
    9595
    96     cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_LIGHTBLUE);
    97     cucul_putstr(qq, WIDTH / 2 - 7, HEIGHT / 2, "    LIBCACA    ");
     96    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_LIGHTBLUE);
     97    cucul_putstr(c, WIDTH / 2 - 7, HEIGHT / 2, "    LIBCACA    ");
    9898
    9999    for(x = 0; x < 16; x++)
    100100    {
    101         cucul_set_truecolor(qq, 0xff00 | x, 0xf00f | (x << 4));
    102         cucul_putstr(qq, WIDTH / 2 - 7 + x, HEIGHT / 2 + 5, "#");
     101        cucul_set_truecolor(c, 0xff00 | x, 0xf00f | (x << 4));
     102        cucul_putstr(c, WIDTH / 2 - 7 + x, HEIGHT / 2 + 5, "#");
    103103    }
    104104
    105     buffer = cucul_create_export(qq, argv[1]);
     105    buffer = cucul_create_export(c, argv[1]);
    106106    fwrite(cucul_get_buffer_data(buffer),
    107107           cucul_get_buffer_size(buffer), 1, stdout);
    108108    cucul_free_buffer(buffer);
    109109
    110     cucul_free(qq);
     110    cucul_free(c);
    111111
    112112    return 0;
  • libcaca/trunk/test/font.c

    r777 r810  
    3535int main(int argc, char *argv[])
    3636{
    37     cucul_t *qq;
     37    cucul_canvas_t *c;
    3838    caca_t *kk;
    3939    cucul_font_t *f;
     
    4545
    4646    /* Create a canvas */
    47     qq = cucul_create(8, 2);
     47    c = cucul_create(8, 2);
    4848
    4949    /* Draw stuff on our canvas */
    50     cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLACK);
    51     cucul_putstr(qq, 0, 0, "ABcde");
    52     cucul_set_color(qq, CUCUL_COLOR_LIGHTRED, CUCUL_COLOR_BLACK);
    53     cucul_putstr(qq, 5, 0, "\\o/");
    54     cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    55     cucul_putstr(qq, 0, 1, "&$âøÿØ?!");
     50    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLACK);
     51    cucul_putstr(c, 0, 0, "ABcde");
     52    cucul_set_color(c, CUCUL_COLOR_LIGHTRED, CUCUL_COLOR_BLACK);
     53    cucul_putstr(c, 5, 0, "\\o/");
     54    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
     55    cucul_putstr(c, 0, 1, "&$âøÿØ?!");
    5656
    5757    /* Load a libcucul internal font */
     
    7070
    7171    /* Create our bitmap buffer (32-bit ARGB) */
    72     w = cucul_get_width(qq) * cucul_get_font_width(f);
    73     h = cucul_get_height(qq) * cucul_get_font_height(f);
     72    w = cucul_get_width(c) * cucul_get_font_width(f);
     73    h = cucul_get_height(c) * cucul_get_font_height(f);
    7474    buf = malloc(4 * w * h);
    7575
    7676    /* Render the canvas onto our image buffer */
    77     cucul_render_canvas(qq, f, buf, w, h, 4 * w);
     77    cucul_render_canvas(c, f, buf, w, h, 4 * w);
    7878
    7979    /* Just for fun, render the image using libcaca */
    80     cucul_set_size(qq, 80, 32);
    81     kk = caca_attach(qq);
     80    cucul_set_size(c, 80, 32);
     81    kk = caca_attach(c);
    8282
    8383#if defined(HAVE_ENDIAN_H)
     
    9494                                0x0000ff00, 0x00ff0000, 0xff000000, 0x000000ff);
    9595
    96     cucul_dither_bitmap(qq, 0, 0, cucul_get_width(qq) - 1,
    97                                   cucul_get_height(qq) - 1, d, buf);
     96    cucul_dither_bitmap(c, 0, 0, cucul_get_width(c) - 1,
     97                                  cucul_get_height(c) - 1, d, buf);
    9898    caca_display(kk);
    9999
     
    105105    cucul_free_dither(d);
    106106    cucul_free_font(f);
    107     cucul_free(qq);
     107    cucul_free(c);
    108108
    109109    return 0;
  • libcaca/trunk/test/gamma.c

    r777 r810  
    3535{
    3636    caca_event_t ev;
    37     cucul_t *qq, *gg, *mask;
     37    cucul_canvas_t *c, *gg, *mask;
    3838    caca_t *kk;
    3939    cucul_dither_t *left, *right;
     
    4141    int x;
    4242
    43     qq = cucul_create(0, 0);
    44     kk = caca_attach(qq);
     43    c = cucul_create(0, 0);
     44    kk = caca_attach(c);
    4545
    46     gg = cucul_create(cucul_get_width(qq), cucul_get_height(qq));
    47     mask = cucul_create(cucul_get_width(qq), cucul_get_height(qq));
     46    gg = cucul_create(cucul_get_width(c), cucul_get_height(c));
     47    mask = cucul_create(cucul_get_width(c), cucul_get_height(c));
    4848
    4949    for(x = 0; x < 256; x++)
     
    6767        if(ret)
    6868        {
    69             if(ev.data.key.c == CACA_KEY_LEFT)
     69            if(ev.data.key.ch == CACA_KEY_LEFT)
    7070                gam /= 1.03;
    71             else if(ev.data.key.c == CACA_KEY_RIGHT)
     71            else if(ev.data.key.ch == CACA_KEY_RIGHT)
    7272                gam *= 1.03;
    73             else if(ev.data.key.c == CACA_KEY_DOWN)
     73            else if(ev.data.key.ch == CACA_KEY_DOWN)
    7474                gam = 1.0;
    75             else if(ev.data.key.c == CACA_KEY_ESCAPE)
     75            else if(ev.data.key.ch == CACA_KEY_ESCAPE)
    7676                break;
    7777        }
    7878
    7979        /* Resize the spare canvas, just in case the main one changed */
    80         cucul_set_size(gg, cucul_get_width(qq), cucul_get_height(qq));
    81         cucul_set_size(mask, cucul_get_width(qq), cucul_get_height(qq));
     80        cucul_set_size(gg, cucul_get_width(c), cucul_get_height(c));
     81        cucul_set_size(mask, cucul_get_width(c), cucul_get_height(c));
    8282
    8383        /* Draw the regular dither on the main canvas */
    84         cucul_dither_bitmap(qq, 0, 0,
    85                             cucul_get_width(qq) - 1, cucul_get_height(qq) - 1,
     84        cucul_dither_bitmap(c, 0, 0,
     85                            cucul_get_width(c) - 1, cucul_get_height(c) - 1,
    8686                            left, buffer);
    8787
     
    103103
    104104        /* Blit the spare canvas onto the first one */
    105         cucul_blit(qq, 0, 0, gg, mask);
     105        cucul_blit(c, 0, 0, gg, mask);
    106106
    107         cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    108         cucul_printf(qq, 2, 1,
     107        cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
     108        cucul_printf(c, 2, 1,
    109109                     "gamma=%g - use arrows to change, Esc to quit", gam);
    110110
     
    116116
    117117    caca_detach(kk);
    118     cucul_free(qq);
     118    cucul_free(c);
    119119
    120120    return 0;
  • libcaca/trunk/test/hsv.c

    r777 r810  
    3030{
    3131    caca_event_t ev;
    32     cucul_t *qq;
     32    cucul_canvas_t *c;
    3333    caca_t *kk;
    3434
     
    3636    int x, y;
    3737
    38     qq = cucul_create(0, 0);
    39     kk = caca_attach(qq);
     38    c = cucul_create(0, 0);
     39    kk = caca_attach(c);
    4040
    4141    for(y = 0; y < 256; y++)
     
    4747    dither = cucul_create_dither(32, 256, 256, 4 * 256,
    4848                                 0x00ff0000, 0x0000ff00, 0x000000ff, 0x0);
    49     cucul_dither_bitmap(qq, 0, 0,
    50                         cucul_get_width(qq) - 1, cucul_get_height(qq) - 1,
     49    cucul_dither_bitmap(c, 0, 0,
     50                        cucul_get_width(c) - 1, cucul_get_height(c) - 1,
    5151                        dither, buffer);
    5252    cucul_free_dither(dither);
     
    5757
    5858    caca_detach(kk);
    59     cucul_free(qq);
     59    cucul_free(c);
    6060
    6161    return 0;
  • libcaca/trunk/test/spritedit.c

    r777 r810  
    2323int main(int argc, char **argv)
    2424{
    25     cucul_t *qq;
     25    cucul_canvas_t *c;
    2626    caca_t *kk;
    2727
     
    3838    }
    3939
    40     qq = cucul_create(0, 0);
    41     if(!qq)
     40    c = cucul_create(0, 0);
     41    if(!c)
    4242        return 1;
    43     kk = caca_attach(qq);
     43    kk = caca_attach(c);
    4444    if(!kk)
    4545        return 1;
     
    5050    {
    5151        caca_detach(kk);
    52         cucul_free(qq);
     52        cucul_free(c);
    5353        fprintf(stderr, "%s: could not open `%s'.\n", argv[0], argv[1]);
    5454        return 1;
     
    6464        while(caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, 0))
    6565        {
    66             switch(ev.data.key.c)
     66            switch(ev.data.key.ch)
    6767            {
    6868            case 0:
     
    101101
    102102
    103         cucul_clear(qq);
     103        cucul_clear(c);
    104104
    105         cucul_set_color(qq, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
    106         cucul_draw_thin_box(qq, 0, 0, cucul_get_width(qq) - 1, cucul_get_height(qq) - 1);
     105        cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
     106        cucul_draw_thin_box(c, 0, 0, cucul_get_width(c) - 1, cucul_get_height(c) - 1);
    107107
    108         cucul_putstr(qq, 3, 0, "[ Sprite editor for libcaca ]");
     108        cucul_putstr(c, 3, 0, "[ Sprite editor for libcaca ]");
    109109
    110110        sprintf(buf, "sprite `%s'", argv[1]);
    111         cucul_putstr(qq, 3, 2, buf);
     111        cucul_putstr(c, 3, 2, buf);
    112112        sprintf(buf, "frame %i/%i", frame, cucul_get_sprite_frames(sprite) - 1);
    113         cucul_putstr(qq, 3, 3, buf);
     113        cucul_putstr(c, 3, 3, buf);
    114114
    115115        /* Crosshair */
    116         cucul_draw_thin_line(qq, 57, 2, 57, 18);
    117         cucul_draw_thin_line(qq, 37, 10, 77, 10);
    118         cucul_putchar(qq, 57, 10, '+');
     116        cucul_draw_thin_line(c, 57, 2, 57, 18);
     117        cucul_draw_thin_line(c, 37, 10, 77, 10);
     118        cucul_putchar(c, 57, 10, '+');
    119119
    120120        /* Boxed sprite */
     
    123123        xb = xa + 1 + cucul_get_sprite_width(sprite, frame);
    124124        yb = ya + 1 + cucul_get_sprite_height(sprite, frame);
    125         cucul_set_color(qq, CUCUL_COLOR_BLACK, CUCUL_COLOR_BLACK);
    126         cucul_fill_box(qq, 57 + xa, 10 + ya, 57 + xb, 10 + yb, " ");
    127         cucul_set_color(qq, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
    128         cucul_draw_thin_box(qq, 57 + xa, 10 + ya, 57 + xb, 10 + yb);
    129         cucul_draw_sprite(qq, 57, 10, sprite, frame);
     125        cucul_set_color(c, CUCUL_COLOR_BLACK, CUCUL_COLOR_BLACK);
     126        cucul_fill_box(c, 57 + xa, 10 + ya, 57 + xb, 10 + yb, " ");
     127        cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
     128        cucul_draw_thin_box(c, 57 + xa, 10 + ya, 57 + xb, 10 + yb);
     129        cucul_draw_sprite(c, 57, 10, sprite, frame);
    130130
    131131        /* Free sprite */
    132         cucul_draw_sprite(qq, 20, 10, sprite, frame);
     132        cucul_draw_sprite(c, 20, 10, sprite, frame);
    133133
    134134        caca_display(kk);
     
    137137    /* Clean up */
    138138    caca_detach(kk);
    139     cucul_free(qq);
     139    cucul_free(c);
    140140
    141141    return 0;
  • libcaca/trunk/test/transform.c

    r777 r810  
    5151{
    5252    caca_event_t ev;
    53     cucul_t *qq, *normal, *flip, *flop, *rotate;
     53    cucul_canvas_t *c, *normal, *flip, *flop, *rotate;
    5454    caca_t *kk;
    5555    int i;
    5656
    57     qq = cucul_create(0, 0);
    58     kk = caca_attach(qq);
     57    c = cucul_create(0, 0);
     58    kk = caca_attach(c);
    5959
    6060    normal = cucul_create(70, 6);
     
    9797
    9898    /* Blit the transformed canvas onto the main canvas */
    99     cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    100     cucul_putstr(qq, 0, 0, "normal");
    101     cucul_blit(qq, 10, 0, normal, NULL);
    102     cucul_putstr(qq, 0, 6, "flip");
    103     cucul_blit(qq, 10, 6, flip, NULL);
    104     cucul_putstr(qq, 0, 12, "flop");
    105     cucul_blit(qq, 10, 12, flop, NULL);
    106     cucul_putstr(qq, 0, 18, "rotate");
    107     cucul_blit(qq, 10, 18, rotate, NULL);
     99    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
     100    cucul_putstr(c, 0, 0, "normal");
     101    cucul_blit(c, 10, 0, normal, NULL);
     102    cucul_putstr(c, 0, 6, "flip");
     103    cucul_blit(c, 10, 6, flip, NULL);
     104    cucul_putstr(c, 0, 12, "flop");
     105    cucul_blit(c, 10, 12, flop, NULL);
     106    cucul_putstr(c, 0, 18, "rotate");
     107    cucul_blit(c, 10, 18, rotate, NULL);
    108108
    109109    caca_display(kk);
     
    116116    cucul_free(flip);
    117117    cucul_free(normal);
    118     cucul_free(qq);
     118    cucul_free(c);
    119119
    120120    return 0;
  • libcaca/trunk/test/truecolor.c

    r792 r810  
    2828{
    2929    caca_event_t ev;
    30     cucul_t *qq;
     30    cucul_canvas_t *c;
    3131    caca_t *kk;
    3232
    3333    int x, y;
    3434
    35     qq = cucul_create(32, 16);
    36     kk = caca_attach(qq);
     35    c = cucul_create(32, 16);
     36    kk = caca_attach(c);
    3737
    3838    for(y = 0; y < 16; y++)
     
    4242        uint16_t fgcolor = 0xf000 | ((15 - y) << 4) | ((15 - x) << 8);
    4343
    44         cucul_set_truecolor(qq, fgcolor, bgcolor);
    45         cucul_putstr(qq, x * 2, y, "CA");
     44        cucul_set_truecolor(c, fgcolor, bgcolor);
     45        cucul_putstr(c, x * 2, y, "CA");
    4646    }
    4747
    48     cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_LIGHTBLUE);
    49     cucul_putstr(qq, 2, 1, " truecolor libcaca ");
     48    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_LIGHTBLUE);
     49    cucul_putstr(c, 2, 1, " truecolor libcaca ");
    5050
    5151    caca_display(kk);
     
    5454
    5555    caca_detach(kk);
    56     cucul_free(qq);
     56    cucul_free(c);
    5757
    5858    return 0;
  • libcaca/trunk/test/unicode.c

    r777 r810  
    2828{
    2929    caca_event_t ev;
    30     cucul_t *qq;
     30    cucul_canvas_t *c;
    3131    caca_t *kk;
    3232
    33     qq = cucul_create(0, 0);
    34     kk = caca_attach(qq);
     33    c = cucul_create(0, 0);
     34    kk = caca_attach(c);
    3535
    36     cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    37     cucul_putstr(qq, 1, 1, "Basic Unicode support");
     36    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
     37    cucul_putstr(c, 1, 1, "Basic Unicode support");
    3838
    39     cucul_set_color(qq, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
    40     cucul_putstr(qq, 1, 2, "This is ASCII:    | abc DEF 123 !@# |");
    41     cucul_putstr(qq, 1, 3, "This is Unicode:  | äßç δεφ ☺♥♀ ╞╬╗ |");
    42     cucul_putstr(qq, 1, 4, "And this is, too: | ἀβϛ ΔЗҒ ᚴᛒᛯ ♩♔✈ |");
     39    cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
     40    cucul_putstr(c, 1, 2, "This is ASCII:    | abc DEF 123 !@# |");
     41    cucul_putstr(c, 1, 3, "This is Unicode:  | äßç δεφ ☺♥♀ ╞╬╗ |");
     42    cucul_putstr(c, 1, 4, "And this is, too: | ἀβϛ ΔЗҒ ᚴᛒᛯ ♩♔✈ |");
    4343
    44     cucul_putstr(qq, 1, 5, "If the three lines do not have the same length, there is a bug somewhere.");
     44    cucul_putstr(c, 1, 5, "If the three lines do not have the same length, there is a bug somewhere.");
    4545
    46     cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    47     cucul_putstr(qq, 1, 7, "Gradient glyphs");
     46    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
     47    cucul_putstr(c, 1, 7, "Gradient glyphs");
    4848
    49     cucul_set_color(qq, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
    50     cucul_putstr(qq, 31,  8, "  0%");
    51     cucul_putstr(qq, 31,  9, " 25%");
    52     cucul_putstr(qq, 31, 10, " 50%");
    53     cucul_putstr(qq, 31, 11, " 75%");
    54     cucul_putstr(qq, 31, 12, "100%");
     49    cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
     50    cucul_putstr(c, 31,  8, "  0%");
     51    cucul_putstr(c, 31,  9, " 25%");
     52    cucul_putstr(c, 31, 10, " 50%");
     53    cucul_putstr(c, 31, 11, " 75%");
     54    cucul_putstr(c, 31, 12, "100%");
    5555
    56     cucul_set_color(qq, CUCUL_COLOR_LIGHTRED, CUCUL_COLOR_LIGHTGREEN);
    57     cucul_putstr(qq, 1,  8, "                             ");
    58     cucul_putstr(qq, 1,  9, "░░░░░░░░░░░░░░░░░░░░░░░░░░░░░");
    59     cucul_putstr(qq, 1, 10, "▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒");
    60     cucul_putstr(qq, 1, 11, "▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓");
    61     cucul_putstr(qq, 1, 12, "█████████████████████████████");
     56    cucul_set_color(c, CUCUL_COLOR_LIGHTRED, CUCUL_COLOR_LIGHTGREEN);
     57    cucul_putstr(c, 1,  8, "                             ");
     58    cucul_putstr(c, 1,  9, "░░░░░░░░░░░░░░░░░░░░░░░░░░░░░");
     59    cucul_putstr(c, 1, 10, "▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒");
     60    cucul_putstr(c, 1, 11, "▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓");
     61    cucul_putstr(c, 1, 12, "█████████████████████████████");
    6262
    63     cucul_set_color(qq, CUCUL_COLOR_LIGHTGREEN, CUCUL_COLOR_LIGHTRED);
    64     cucul_putstr(qq, 36,  8, "█████████████████████████████");
    65     cucul_putstr(qq, 36,  9, "▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓");
    66     cucul_putstr(qq, 36, 10, "▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒");
    67     cucul_putstr(qq, 36, 11, "░░░░░░░░░░░░░░░░░░░░░░░░░░░░░");
    68     cucul_putstr(qq, 36, 12, "                             ");
     63    cucul_set_color(c, CUCUL_COLOR_LIGHTGREEN, CUCUL_COLOR_LIGHTRED);
     64    cucul_putstr(c, 36,  8, "█████████████████████████████");
     65    cucul_putstr(c, 36,  9, "▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓");
     66    cucul_putstr(c, 36, 10, "▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒");
     67    cucul_putstr(c, 36, 11, "░░░░░░░░░░░░░░░░░░░░░░░░░░░░░");
     68    cucul_putstr(c, 36, 12, "                             ");
    6969
    70     cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    71     cucul_putstr(qq, 1, 14, "Double width characters");
     70    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
     71    cucul_putstr(c, 1, 14, "Double width characters");
    7272
    73     cucul_set_color(qq, CUCUL_COLOR_LIGHTRED, CUCUL_COLOR_BLACK);
    74     cucul_putstr(qq, 1, 15, "| ドラゴン ボーレ |");
    75     cucul_set_color(qq, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
    76     cucul_putstr(qq, 1, 16, "| ()()()() ()()() |");
    77     cucul_set_color(qq, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
    78     cucul_putstr(qq, 1, 17, "| ドラゴン");
    79     cucul_putstr(qq, 10, 17, "ボーレ |");