Ignore:
Timestamp:
Sep 27, 2008, 3:12:46 PM (11 years ago)
Author:
Sam Hocevar
Message:

Starting refactoring to get rid of libcucul. The initial reason for the
split is rendered moot by the plugin system: when enabled, binaries do
not link directly with libX11 or libGL. I hope this is a step towards
more consisteny and clarity.

Location:
libcaca/trunk/examples
Files:
23 edited
1 moved

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/examples/Makefile.am

    r2299 r2821  
    11# $Id$
    22
    3 AM_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/cucul -I../cucul \
    4               -I$(top_srcdir)/caca -DDATADIR=\"$(pkgdatadir)\"
     3AM_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/caca -DDATADIR=\"$(pkgdatadir)\"
    54
    6 noinst_PROGRAMS = blit colors cucul demo demo0 dithering driver event export figfont font font2tga frames fullwidth gamma hsv input spritedit swallow text transform truecolor unicode import
     5noinst_PROGRAMS = blit canvas colors demo demo0 dithering driver event export figfont font font2tga frames fullwidth gamma hsv input spritedit swallow text transform truecolor unicode import
    76
    87blit_SOURCES = blit.c
    9 blit_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     8blit_LDADD = ../caca/libcaca.la
     9
     10canvas_SOURCES = canvas.c
     11canvas_LDADD = ../caca/libcaca.la
    1012
    1113colors_SOURCES = colors.c
    12 colors_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
    13 
    14 cucul_SOURCES = cucul.c
    15 cucul_LDADD = ../cucul/libcucul.la
     14colors_LDADD = ../caca/libcaca.la
    1615
    1716demo_SOURCES = demo.c
    18 demo_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     17demo_LDADD = ../caca/libcaca.la
    1918demo_LDFLAGS = @MATH_LIBS@
    2019
    2120demo0_SOURCES = demo0.c
    22 demo0_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     21demo0_LDADD = ../caca/libcaca.la
    2322demo0_LDFLAGS = @MATH_LIBS@
    2423
    2524dithering_SOURCES = dithering.c
    26 dithering_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     25dithering_LDADD = ../caca/libcaca.la
    2726
    2827driver_SOURCES = driver.c
    29 driver_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     28driver_LDADD = ../caca/libcaca.la
    3029
    3130event_SOURCES = event.c
    32 event_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     31event_LDADD = ../caca/libcaca.la
    3332
    3433export_SOURCES = export.c
    35 export_LDADD = ../cucul/libcucul.la
     34export_LDADD = ../caca/libcaca.la
    3635
    3736figfont_SOURCES = figfont.c
    38 figfont_LDADD = ../cucul/libcucul.la
     37figfont_LDADD = ../caca/libcaca.la
    3938
    4039font_SOURCES = font.c
    41 font_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     40font_LDADD = ../caca/libcaca.la
    4241
    4342font2tga_SOURCES = font2tga.c
    44 font2tga_LDADD = ../cucul/libcucul.la
     43font2tga_LDADD = ../caca/libcaca.la
    4544
    4645frames_SOURCES = frames.c
    47 frames_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     46frames_LDADD = ../caca/libcaca.la
    4847
    4948fullwidth_SOURCES = fullwidth.c
    50 fullwidth_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     49fullwidth_LDADD = ../caca/libcaca.la
    5150
    5251gamma_SOURCES = gamma.c
    53 gamma_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     52gamma_LDADD = ../caca/libcaca.la
    5453gamma_LDFLAGS = @MATH_LIBS@
    5554
    5655hsv_SOURCES = hsv.c
    57 hsv_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     56hsv_LDADD = ../caca/libcaca.la
    5857
    5958input_SOURCES = input.c
    60 input_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     59input_LDADD = ../caca/libcaca.la
    6160
    6261spritedit_SOURCES = spritedit.c
    63 spritedit_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     62spritedit_LDADD = ../caca/libcaca.la
    6463
    6564swallow_SOURCES = swallow.c
    66 swallow_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     65swallow_LDADD = ../caca/libcaca.la
    6766
    6867text_SOURCES = text.c
    69 text_LDADD = ../cucul/libcucul.la
     68text_LDADD = ../caca/libcaca.la
    7069
    7170transform_SOURCES = transform.c
    72 transform_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     71transform_LDADD = ../caca/libcaca.la
    7372
    7473truecolor_SOURCES = truecolor.c
    75 truecolor_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     74truecolor_LDADD = ../caca/libcaca.la
    7675
    7776unicode_SOURCES = unicode.c
    78 unicode_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     77unicode_LDADD = ../caca/libcaca.la
    7978
    8079import_SOURCES = import.c
    81 import_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     80import_LDADD = ../caca/libcaca.la
    8281
  • libcaca/trunk/examples/blit.c

    r2299 r2821  
    2020#endif
    2121
    22 #include "cucul.h"
    2322#include "caca.h"
    2423
     
    4140int main(int argc, char *argv[])
    4241{
    43     cucul_canvas_t *cv, *sprite;
     42    caca_canvas_t *cv, *sprite;
    4443    caca_display_t *dp;
    4544
    46     cv = cucul_create_canvas(80, 24);
     45    cv = caca_create_canvas(80, 24);
    4746    if(cv == NULL)
    4847    {
     
    5857    }
    5958
    60     sprite = cucul_create_canvas(0, 0);
    61     cucul_set_color_ansi(sprite, CUCUL_LIGHTRED, CUCUL_BLACK);
    62     cucul_import_memory(sprite, pig, strlen(pig), "text");
    63     cucul_set_canvas_handle(sprite, cucul_get_canvas_width(sprite) / 2,
    64                                     cucul_get_canvas_height(sprite) / 2);
     59    sprite = caca_create_canvas(0, 0);
     60    caca_set_color_ansi(sprite, CACA_LIGHTRED, CACA_BLACK);
     61    caca_import_memory(sprite, pig, strlen(pig), "text");
     62    caca_set_canvas_handle(sprite, caca_get_canvas_width(sprite) / 2,
     63                                    caca_get_canvas_height(sprite) / 2);
    6564
    66     cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLUE);
    67     cucul_put_str(cv, 0, 0, "Centered sprite");
     65    caca_set_color_ansi(cv, CACA_WHITE, CACA_BLUE);
     66    caca_put_str(cv, 0, 0, "Centered sprite");
    6867
    69     cucul_blit(cv, cucul_get_canvas_width(cv) / 2,
    70                    cucul_get_canvas_height(cv) / 2, sprite, NULL);
     68    caca_blit(cv, caca_get_canvas_width(cv) / 2,
     69                   caca_get_canvas_height(cv) / 2, sprite, NULL);
    7170
    7271    caca_refresh_display(dp);
     
    7574
    7675    caca_free_display(dp);
    77     cucul_free_canvas(sprite);
    78     cucul_free_canvas(cv);
     76    caca_free_canvas(sprite);
     77    caca_free_canvas(cv);
    7978
    8079    return 0;
  • libcaca/trunk/examples/canvas.c

    r2820 r2821  
    2020#endif
    2121
    22 #include "cucul.h"
    2322#include "caca.h"
    2423
     
    2726int main(int argc, char *argv[])
    2827{
    29     cucul_canvas_t *cv;
     28    caca_canvas_t *cv;
    3029    unsigned int i, j, w, h;
    3130
    32     fprintf(stderr, "testing cucul_create_canvas()\n");
     31    fprintf(stderr, "testing caca_create_canvas()\n");
    3332    for(i = 0; i < ITER; i++)
    3433    {
    35         w = cucul_rand(1, 1000);
    36         h = cucul_rand(1, 1000);
    37         cv = cucul_create_canvas(w, h);
    38         cucul_put_char(cv, w - 1, h - 1, 'x');
    39         if(cucul_get_char(cv, w - 1, h - 1) != 'x')
     34        w = caca_rand(1, 1000);
     35        h = caca_rand(1, 1000);
     36        cv = caca_create_canvas(w, h);
     37        caca_put_char(cv, w - 1, h - 1, 'x');
     38        if(caca_get_char(cv, w - 1, h - 1) != 'x')
    4039            fprintf(stderr, "  failed (%ux%u)\n", w, h);
    41         cucul_free_canvas(cv);
     40        caca_free_canvas(cv);
    4241    }
    4342
    44     fprintf(stderr, "testing cucul_set_frame_name()\n");
    45     cv = cucul_create_canvas(1, 1);
     43    fprintf(stderr, "testing caca_set_frame_name()\n");
     44    cv = caca_create_canvas(1, 1);
    4645    if(cv == NULL)
    4746    {
     
    5251    for(i = 0; i < ITER; i++)
    5352    {
    54         cucul_create_frame(cv, 0);
     53        caca_create_frame(cv, 0);
    5554        for(j = 0; j < ITER; j++)
    5655        {
    5756            char buf[BUFSIZ];
    58             w = cucul_rand(1, 1000);
     57            w = caca_rand(1, 1000);
    5958            memset(buf, 'x', w);
    6059            buf[w] = '\0';
    61             cucul_set_frame_name(cv, buf);
     60            caca_set_frame_name(cv, buf);
    6261        }
    6362    }
    64     cucul_free_canvas(cv);
     63    caca_free_canvas(cv);
    6564
    6665    fprintf(stderr, "all tests passed\n");
  • libcaca/trunk/examples/colors.c

    r2299 r2821  
    1919#endif
    2020
    21 #include "cucul.h"
    2221#include "caca.h"
    2322
    2423int main(int argc, char **argv)
    2524{
    26     cucul_canvas_t *cv;
     25    caca_canvas_t *cv;
    2726    caca_display_t *dp;
    2827    int i, j;
    2928
    30     cv = cucul_create_canvas(80, 24);
     29    cv = caca_create_canvas(80, 24);
    3130    if(cv == NULL)
    3231    {
     
    4241    }
    4342
    44     cucul_set_color_ansi(cv, CUCUL_LIGHTGRAY, CUCUL_BLACK);
    45     cucul_clear_canvas(cv);
     43    caca_set_color_ansi(cv, CACA_LIGHTGRAY, CACA_BLACK);
     44    caca_clear_canvas(cv);
    4645    for(i = 0; i < 16; i++)
    4746    {
    48         cucul_set_color_ansi(cv, CUCUL_LIGHTGRAY, CUCUL_BLACK);
    49         cucul_printf(cv, 3, i + (i >= 8 ? 3 : 2), "ANSI %i", i);
     47        caca_set_color_ansi(cv, CACA_LIGHTGRAY, CACA_BLACK);
     48        caca_printf(cv, 3, i + (i >= 8 ? 3 : 2), "ANSI %i", i);
    5049        for(j = 0; j < 16; j++)
    5150        {
    52             cucul_set_color_ansi(cv, i, j);
    53             cucul_put_str(cv, (j >= 8 ? 13 : 12) + j * 4, i + (i >= 8 ? 3 : 2),
     51            caca_set_color_ansi(cv, i, j);
     52            caca_put_str(cv, (j >= 8 ? 13 : 12) + j * 4, i + (i >= 8 ? 3 : 2),
    5453                          "Aaホ");
    5554        }
    5655    }
    5756
    58     cucul_set_color_ansi(cv, CUCUL_LIGHTGRAY, CUCUL_BLACK);
    59     cucul_put_str(cv, 3, 20, "This is bold    This is blink    This is italics    This is underline");
    60     cucul_set_attr(cv, CUCUL_BOLD);
    61     cucul_put_str(cv, 3 + 8, 20, "bold");
    62     cucul_set_attr(cv, CUCUL_BLINK);
    63     cucul_put_str(cv, 3 + 24, 20, "blink");
    64     cucul_set_attr(cv, CUCUL_ITALICS);
    65     cucul_put_str(cv, 3 + 41, 20, "italics");
    66     cucul_set_attr(cv, CUCUL_UNDERLINE);
    67     cucul_put_str(cv, 3 + 60, 20, "underline");
     57    caca_set_color_ansi(cv, CACA_LIGHTGRAY, CACA_BLACK);
     58    caca_put_str(cv, 3, 20, "This is bold    This is blink    This is italics    This is underline");
     59    caca_set_attr(cv, CACA_BOLD);
     60    caca_put_str(cv, 3 + 8, 20, "bold");
     61    caca_set_attr(cv, CACA_BLINK);
     62    caca_put_str(cv, 3 + 24, 20, "blink");
     63    caca_set_attr(cv, CACA_ITALICS);
     64    caca_put_str(cv, 3 + 41, 20, "italics");
     65    caca_set_attr(cv, CACA_UNDERLINE);
     66    caca_put_str(cv, 3 + 60, 20, "underline");
    6867
    6968    caca_refresh_display(dp);
     
    7170
    7271    caca_free_display(dp);
    73     cucul_free_canvas(cv);
     72    caca_free_canvas(cv);
    7473
    7574    return 0;
  • libcaca/trunk/examples/demo.c

    r2299 r2821  
    2121#endif
    2222
    23 #include "cucul.h"
    2423#include "caca.h"
    2524
     
    4039int dithering = 0;
    4140#if 0
    42 cucul_sprite_t *sprite = NULL;
    43 #endif
    44 
    45 cucul_canvas_t *cv;
     41caca_sprite_t *sprite = NULL;
     42#endif
     43
     44caca_canvas_t *cv;
    4645caca_display_t *dp;
    4746
     
    5150    int quit = 0;
    5251
    53     cv = cucul_create_canvas(80, 24);
     52    cv = caca_create_canvas(80, 24);
    5453    if(cv == NULL)
    5554    {
     
    6968    /* Initialize data */
    7069#if 0
    71     sprite = cucul_load_sprite(DATADIR "/caca.txt");
     70    sprite = caca_load_sprite(DATADIR "/caca.txt");
    7271    if(!sprite)
    73         sprite = cucul_load_sprite("caca.txt");
     72        sprite = caca_load_sprite("caca.txt");
    7473    if(!sprite)
    75         sprite = cucul_load_sprite("examples/caca.txt");
     74        sprite = caca_load_sprite("examples/caca.txt");
    7675#endif
    7776
     
    120119                case 'D':
    121120                    dithering = (dithering + 1) % 5;
    122                     cucul_set_feature(cv, dithering);
     121                    caca_set_feature(cv, dithering);
    123122                    display_menu();
    124123                    break;
     
    158157                if(demo)
    159158                {
    160                     cucul_set_color_ansi(cv, CUCUL_LIGHTGRAY, CUCUL_BLACK);
    161                     cucul_clear_canvas(cv);
     159                    caca_set_color_ansi(cv, CACA_LIGHTGRAY, CACA_BLACK);
     160                    caca_clear_canvas(cv);
    162161                }
    163162            }
     
    179178            if(mouse && !demo)
    180179            {
    181                 cucul_set_color_ansi(cv, CUCUL_RED, CUCUL_BLACK);
    182                 cucul_put_str(cv, xmouse, ymouse,     ".");
    183                 cucul_put_str(cv, xmouse, ymouse + 1, "|\\");
     180                caca_set_color_ansi(cv, CACA_RED, CACA_BLACK);
     181                caca_put_str(cv, xmouse, ymouse,     ".");
     182                caca_put_str(cv, xmouse, ymouse + 1, "|\\");
    184183            }
    185184            caca_refresh_display(dp);
     
    191190            demo();
    192191
    193             cucul_set_color_ansi(cv, CUCUL_LIGHTGRAY, CUCUL_BLACK);
    194             cucul_draw_thin_box(cv, 1, 1, cucul_get_canvas_width(cv) - 2,
    195                                           cucul_get_canvas_height(cv) - 2);
    196             cucul_printf(cv, 4, 1, "[%i.%i fps]----",
     192            caca_set_color_ansi(cv, CACA_LIGHTGRAY, CACA_BLACK);
     193            caca_draw_thin_box(cv, 1, 1, caca_get_canvas_width(cv) - 2,
     194                                          caca_get_canvas_height(cv) - 2);
     195            caca_printf(cv, 4, 1, "[%i.%i fps]----",
    197196                         1000000 / caca_get_display_time(dp),
    198197                         (10000000 / caca_get_display_time(dp)) % 10);
     
    203202    /* Clean up */
    204203#if 0
    205     cucul_free_sprite(sprite);
     204    caca_free_sprite(sprite);
    206205#endif
    207206    caca_free_display(dp);
    208     cucul_free_canvas(cv);
     207    caca_free_canvas(cv);
    209208
    210209    return 0;
     
    213212static void display_menu(void)
    214213{
    215     int xo = cucul_get_canvas_width(cv) - 2;
    216     int yo = cucul_get_canvas_height(cv) - 2;
    217 
    218     cucul_set_color_ansi(cv, CUCUL_LIGHTGRAY, CUCUL_BLACK);
    219     cucul_clear_canvas(cv);
    220     cucul_draw_thin_box(cv, 1, 1, xo, yo);
    221 
    222     cucul_put_str(cv, (xo - strlen("libcaca demo")) / 2, 3, "libcaca demo");
    223     cucul_put_str(cv, (xo - strlen("==============")) / 2, 4, "==============");
    224 
    225     cucul_put_str(cv, 4, 6, "demos:");
    226     cucul_put_str(cv, 4, 7, "'f': full");
    227     cucul_put_str(cv, 4, 8, "'1': dots");
    228     cucul_put_str(cv, 4, 9, "'2': lines");
    229     cucul_put_str(cv, 4, 10, "'3': boxes");
    230     cucul_put_str(cv, 4, 11, "'4': triangles");
    231     cucul_put_str(cv, 4, 12, "'5': ellipses");
    232     cucul_put_str(cv, 4, 13, "'c': colour");
    233     cucul_put_str(cv, 4, 14, "'r': render");
     214    int xo = caca_get_canvas_width(cv) - 2;
     215    int yo = caca_get_canvas_height(cv) - 2;
     216
     217    caca_set_color_ansi(cv, CACA_LIGHTGRAY, CACA_BLACK);
     218    caca_clear_canvas(cv);
     219    caca_draw_thin_box(cv, 1, 1, xo, yo);
     220
     221    caca_put_str(cv, (xo - strlen("libcaca demo")) / 2, 3, "libcaca demo");
     222    caca_put_str(cv, (xo - strlen("==============")) / 2, 4, "==============");
     223
     224    caca_put_str(cv, 4, 6, "demos:");
     225    caca_put_str(cv, 4, 7, "'f': full");
     226    caca_put_str(cv, 4, 8, "'1': dots");
     227    caca_put_str(cv, 4, 9, "'2': lines");
     228    caca_put_str(cv, 4, 10, "'3': boxes");
     229    caca_put_str(cv, 4, 11, "'4': triangles");
     230    caca_put_str(cv, 4, 12, "'5': ellipses");
     231    caca_put_str(cv, 4, 13, "'c': colour");
     232    caca_put_str(cv, 4, 14, "'r': render");
    234233#if 0
    235234    if(sprite)
    236         cucul_put_str(cv, 4, 15, "'s': sprites");
    237 #endif
    238 
    239     cucul_put_str(cv, 4, 16, "settings:");
    240     cucul_printf(cv, 4, 17, "'o': outline: %s",
     235        caca_put_str(cv, 4, 15, "'s': sprites");
     236#endif
     237
     238    caca_put_str(cv, 4, 16, "settings:");
     239    caca_printf(cv, 4, 17, "'o': outline: %s",
    241240                 outline == 0 ? "none" : outline == 1 ? "solid" : "thin");
    242     cucul_printf(cv, 4, 18, "'b': drawing boundaries: %s",
     241    caca_printf(cv, 4, 18, "'b': drawing boundaries: %s",
    243242                 bounds == 0 ? "screen" : "infinite");
    244     //cucul_printf(cv, 4, 19, "'d': dithering (%s)",
    245     //             cucul_get_feature_name(dithering));
    246 
    247     cucul_put_str(cv, 4, yo - 2, "'q': quit");
     243    //caca_printf(cv, 4, 19, "'d': dithering (%s)",
     244    //             caca_get_feature_name(dithering));
     245
     246    caca_put_str(cv, 4, yo - 2, "'q': quit");
    248247
    249248    caca_refresh_display(dp);
     
    258257    i++;
    259258
    260     cucul_set_color_ansi(cv, CUCUL_LIGHTGRAY, CUCUL_BLACK);
    261     cucul_clear_canvas(cv);
     259    caca_set_color_ansi(cv, CACA_LIGHTGRAY, CACA_BLACK);
     260    caca_clear_canvas(cv);
    262261
    263262    /* Draw the sun */
    264     cucul_set_color_ansi(cv, CUCUL_YELLOW, CUCUL_BLACK);
    265     xo = cucul_get_canvas_width(cv) / 4;
    266     yo = cucul_get_canvas_height(cv) / 4 + 5 * sin(0.03*i);
     263    caca_set_color_ansi(cv, CACA_YELLOW, CACA_BLACK);
     264    xo = caca_get_canvas_width(cv) / 4;
     265    yo = caca_get_canvas_height(cv) / 4 + 5 * sin(0.03*i);
    267266
    268267    for(j = 0; j < 16; j++)
     
    270269        xa = xo - (30 + sin(0.03*i) * 8) * sin(0.03*i + M_PI*j/8);
    271270        ya = yo + (15 + sin(0.03*i) * 4) * cos(0.03*i + M_PI*j/8);
    272         cucul_draw_thin_line(cv, xo, yo, xa, ya);
     271        caca_draw_thin_line(cv, xo, yo, xa, ya);
    273272    }
    274273
    275274    j = 15 + sin(0.03*i) * 8;
    276     cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLACK);
    277     cucul_fill_ellipse(cv, xo, yo, j, j / 2, '#');
    278     cucul_set_color_ansi(cv, CUCUL_YELLOW, CUCUL_BLACK);
    279     cucul_draw_ellipse(cv, xo, yo, j, j / 2, '#');
     275    caca_set_color_ansi(cv, CACA_WHITE, CACA_BLACK);
     276    caca_fill_ellipse(cv, xo, yo, j, j / 2, '#');
     277    caca_set_color_ansi(cv, CACA_YELLOW, CACA_BLACK);
     278    caca_draw_ellipse(cv, xo, yo, j, j / 2, '#');
    280279
    281280    /* Draw the pyramid */
    282     xo = cucul_get_canvas_width(cv) * 5 / 8;
     281    xo = caca_get_canvas_width(cv) * 5 / 8;
    283282    yo = 2;
    284283
    285     xa = cucul_get_canvas_width(cv) / 8 + sin(0.03*i) * 5;
    286     ya = cucul_get_canvas_height(cv) / 2 + cos(0.03*i) * 5;
    287 
    288     xb = cucul_get_canvas_width(cv) - 10 - cos(0.02*i) * 10;
    289     yb = cucul_get_canvas_height(cv) * 3 / 4 - 5 + sin(0.02*i) * 5;
    290 
    291     xc = cucul_get_canvas_width(cv) / 4 - sin(0.02*i) * 5;
    292     yc = cucul_get_canvas_height(cv) * 3 / 4 + cos(0.02*i) * 5;
    293 
    294     cucul_set_color_ansi(cv, CUCUL_GREEN, CUCUL_BLACK);
    295     cucul_fill_triangle(cv, xo, yo, xb, yb, xa, ya, '%');
    296     cucul_set_color_ansi(cv, CUCUL_YELLOW, CUCUL_BLACK);
    297     cucul_draw_thin_triangle(cv, xo, yo, xb, yb, xa, ya);
    298 
    299     cucul_set_color_ansi(cv, CUCUL_RED, CUCUL_BLACK);
    300     cucul_fill_triangle(cv, xa, ya, xb, yb, xc, yc, '#');
    301     cucul_set_color_ansi(cv, CUCUL_YELLOW, CUCUL_BLACK);
    302     cucul_draw_thin_triangle(cv, xa, ya, xb, yb, xc, yc);
    303 
    304     cucul_set_color_ansi(cv, CUCUL_BLUE, CUCUL_BLACK);
    305     cucul_fill_triangle(cv, xo, yo, xb, yb, xc, yc, '%');
    306     cucul_set_color_ansi(cv, CUCUL_YELLOW, CUCUL_BLACK);
    307     cucul_draw_thin_triangle(cv, xo, yo, xb, yb, xc, yc);
     284    xa = caca_get_canvas_width(cv) / 8 + sin(0.03*i) * 5;
     285    ya = caca_get_canvas_height(cv) / 2 + cos(0.03*i) * 5;
     286
     287    xb = caca_get_canvas_width(cv) - 10 - cos(0.02*i) * 10;
     288    yb = caca_get_canvas_height(cv) * 3 / 4 - 5 + sin(0.02*i) * 5;
     289
     290    xc = caca_get_canvas_width(cv) / 4 - sin(0.02*i) * 5;
     291    yc = caca_get_canvas_height(cv) * 3 / 4 + cos(0.02*i) * 5;
     292
     293    caca_set_color_ansi(cv, CACA_GREEN, CACA_BLACK);
     294    caca_fill_triangle(cv, xo, yo, xb, yb, xa, ya, '%');
     295    caca_set_color_ansi(cv, CACA_YELLOW, CACA_BLACK);
     296    caca_draw_thin_triangle(cv, xo, yo, xb, yb, xa, ya);
     297
     298    caca_set_color_ansi(cv, CACA_RED, CACA_BLACK);
     299    caca_fill_triangle(cv, xa, ya, xb, yb, xc, yc, '#');
     300    caca_set_color_ansi(cv, CACA_YELLOW, CACA_BLACK);
     301    caca_draw_thin_triangle(cv, xa, ya, xb, yb, xc, yc);
     302
     303    caca_set_color_ansi(cv, CACA_BLUE, CACA_BLACK);
     304    caca_fill_triangle(cv, xo, yo, xb, yb, xc, yc, '%');
     305    caca_set_color_ansi(cv, CACA_YELLOW, CACA_BLACK);
     306    caca_draw_thin_triangle(cv, xo, yo, xb, yb, xc, yc);
    308307
    309308    /* Draw a background triangle */
     
    311310    ya = 2;
    312311
    313     xb = cucul_get_canvas_width(cv) - 3;
    314     yb = cucul_get_canvas_height(cv) / 2;
    315 
    316     xc = cucul_get_canvas_width(cv) / 3;
    317     yc = cucul_get_canvas_height(cv) - 3;
    318 
    319     cucul_set_color_ansi(cv, CUCUL_CYAN, CUCUL_BLACK);
    320     cucul_draw_thin_triangle(cv, xa, ya, xb, yb, xc, yc);
    321 
    322     xo = cucul_get_canvas_width(cv) / 2 + cos(0.027*i) * cucul_get_canvas_width(cv) / 3;
    323     yo = cucul_get_canvas_height(cv) / 2 - sin(0.027*i) * cucul_get_canvas_height(cv) / 2;
    324 
    325     cucul_draw_thin_line(cv, xa, ya, xo, yo);
    326     cucul_draw_thin_line(cv, xb, yb, xo, yo);
    327     cucul_draw_thin_line(cv, xc, yc, xo, yo);
     312    xb = caca_get_canvas_width(cv) - 3;
     313    yb = caca_get_canvas_height(cv) / 2;
     314
     315    xc = caca_get_canvas_width(cv) / 3;
     316    yc = caca_get_canvas_height(cv) - 3;
     317
     318    caca_set_color_ansi(cv, CACA_CYAN, CACA_BLACK);
     319    caca_draw_thin_triangle(cv, xa, ya, xb, yb, xc, yc);
     320
     321    xo = caca_get_canvas_width(cv) / 2 + cos(0.027*i) * caca_get_canvas_width(cv) / 3;
     322    yo = caca_get_canvas_height(cv) / 2 - sin(0.027*i) * caca_get_canvas_height(cv) / 2;
     323
     324    caca_draw_thin_line(cv, xa, ya, xo, yo);
     325    caca_draw_thin_line(cv, xb, yb, xo, yo);
     326    caca_draw_thin_line(cv, xc, yc, xo, yo);
    328327
    329328    /* Draw a sprite on the pyramid */
    330329#if 0
    331     cucul_draw_sprite(cv, xo, yo, sprite, 0);
     330    caca_draw_sprite(cv, xo, yo, sprite, 0);
    332331#endif
    333332
     
    335334    for(j = i - 60; j < i; j++)
    336335    {
    337         int delta = cucul_rand(-5, 6);
    338         cucul_set_color_ansi(cv, cucul_rand(0, 16), cucul_rand(0, 16));
    339         cucul_put_char(cv, cucul_get_canvas_width(cv) / 2
    340                     + cos(0.02*j) * (delta + cucul_get_canvas_width(cv) / 4),
    341                    cucul_get_canvas_height(cv) / 2
    342                     + sin(0.02*j) * (delta + cucul_get_canvas_height(cv) / 3),
     336        int delta = caca_rand(-5, 6);
     337        caca_set_color_ansi(cv, caca_rand(0, 16), caca_rand(0, 16));
     338        caca_put_char(cv, caca_get_canvas_width(cv) / 2
     339                    + cos(0.02*j) * (delta + caca_get_canvas_width(cv) / 4),
     340                   caca_get_canvas_height(cv) / 2
     341                    + sin(0.02*j) * (delta + caca_get_canvas_height(cv) / 3),
    343342                   '#');
    344343    }
     
    346345    /* Draw foreground sprite */
    347346#if 0
    348     cucul_draw_sprite(cv, cucul_get_canvas_width(cv) / 2 + cos(0.02*i) * cucul_get_canvas_width(cv) / 4,
    349                    cucul_get_canvas_height(cv) / 2 + sin(0.02*i) * cucul_get_canvas_height(cv) / 3,
     347    caca_draw_sprite(cv, caca_get_canvas_width(cv) / 2 + cos(0.02*i) * caca_get_canvas_width(cv) / 4,
     348                   caca_get_canvas_height(cv) / 2 + sin(0.02*i) * caca_get_canvas_height(cv) / 3,
    350349                   sprite, 0);
    351350#endif
     
    354353static void demo_dots(void)
    355354{
    356     int xmax = cucul_get_canvas_width(cv);
    357     int ymax = cucul_get_canvas_height(cv);
     355    int xmax = caca_get_canvas_width(cv);
     356    int ymax = caca_get_canvas_height(cv);
    358357    int i;
    359358    static char chars[10] =
     
    365364    {
    366365        /* Putpixel */
    367         cucul_set_color_ansi(cv, cucul_rand(0, 16), cucul_rand(0, 16));
    368         cucul_put_char(cv, cucul_rand(0, xmax), cucul_rand(0, ymax),
    369                       chars[cucul_rand(0, 9)]);
     366        caca_set_color_ansi(cv, caca_rand(0, 16), caca_rand(0, 16));
     367        caca_put_char(cv, caca_rand(0, xmax), caca_rand(0, ymax),
     368                      chars[caca_rand(0, 9)]);
    370369    }
    371370}
     
    373372static void demo_lines(void)
    374373{
    375     int w = cucul_get_canvas_width(cv);
    376     int h = cucul_get_canvas_height(cv);
     374    int w = caca_get_canvas_width(cv);
     375    int h = caca_get_canvas_height(cv);
    377376    int xa, ya, xb, yb;
    378377
    379378    if(bounds)
    380379    {
    381         xa = cucul_rand(- w, 2 * w); ya = cucul_rand(- h, 2 * h);
    382         xb = cucul_rand(- w, 2 * w); yb = cucul_rand(- h, 2 * h);
     380        xa = caca_rand(- w, 2 * w); ya = caca_rand(- h, 2 * h);
     381        xb = caca_rand(- w, 2 * w); yb = caca_rand(- h, 2 * h);
    383382    }
    384383    else
    385384    {
    386         xa = cucul_rand(0, w); ya = cucul_rand(0, h);
    387         xb = cucul_rand(0, w); yb = cucul_rand(0, h);
    388     }
    389 
    390     cucul_set_color_ansi(cv, cucul_rand(0, 16), CUCUL_BLACK);
     385        xa = caca_rand(0, w); ya = caca_rand(0, h);
     386        xb = caca_rand(0, w); yb = caca_rand(0, h);
     387    }
     388
     389    caca_set_color_ansi(cv, caca_rand(0, 16), CACA_BLACK);
    391390    if(outline > 1)
    392         cucul_draw_thin_line(cv, xa, ya, xb, yb);
     391        caca_draw_thin_line(cv, xa, ya, xb, yb);
    393392    else
    394         cucul_draw_line(cv, xa, ya, xb, yb, '#');
     393        caca_draw_line(cv, xa, ya, xb, yb, '#');
    395394}
    396395
    397396static void demo_boxes(void)
    398397{
    399     int w = cucul_get_canvas_width(cv);
    400     int h = cucul_get_canvas_height(cv);
     398    int w = caca_get_canvas_width(cv);
     399    int h = caca_get_canvas_height(cv);
    401400    int xa, ya, xb, yb;
    402401
    403402    if(bounds)
    404403    {
    405         xa = cucul_rand(- w, 2 * w); ya = cucul_rand(- h, 2 * h);
    406         xb = cucul_rand(- w, 2 * w); yb = cucul_rand(- h, 2 * h);
     404        xa = caca_rand(- w, 2 * w); ya = caca_rand(- h, 2 * h);
     405        xb = caca_rand(- w, 2 * w); yb = caca_rand(- h, 2 * h);
    407406    }
    408407    else
    409408    {
    410         xa = cucul_rand(0, w); ya = cucul_rand(0, h);
    411         xb = cucul_rand(0, w); yb = cucul_rand(0, h);
    412     }
    413 
    414     cucul_set_color_ansi(cv, cucul_rand(0, 16), cucul_rand(0, 16));
    415     cucul_fill_box(cv, xa, ya, xb, yb, '#');
    416 
    417     cucul_set_color_ansi(cv, cucul_rand(0, 16), CUCUL_BLACK);
     409        xa = caca_rand(0, w); ya = caca_rand(0, h);
     410        xb = caca_rand(0, w); yb = caca_rand(0, h);
     411    }
     412
     413    caca_set_color_ansi(cv, caca_rand(0, 16), caca_rand(0, 16));
     414    caca_fill_box(cv, xa, ya, xb, yb, '#');
     415
     416    caca_set_color_ansi(cv, caca_rand(0, 16), CACA_BLACK);
    418417    if(outline == 2)
    419         cucul_draw_thin_box(cv, xa, ya, xb, yb);
     418        caca_draw_thin_box(cv, xa, ya, xb, yb);
    420419    else if(outline == 1)
    421         cucul_draw_box(cv, xa, ya, xb, yb, '#');
     420        caca_draw_box(cv, xa, ya, xb, yb, '#');
    422421}
    423422
    424423static void demo_ellipses(void)
    425424{
    426     int w = cucul_get_canvas_width(cv);
    427     int h = cucul_get_canvas_height(cv);
     425    int w = caca_get_canvas_width(cv);
     426    int h = caca_get_canvas_height(cv);
    428427    int x, y, a, b;
    429428
    430429    if(bounds)
    431430    {
    432         x = cucul_rand(- w, 2 * w); y = cucul_rand(- h, 2 * h);
    433         a = cucul_rand(0, w); b = cucul_rand(0, h);
     431        x = caca_rand(- w, 2 * w); y = caca_rand(- h, 2 * h);
     432        a = caca_rand(0, w); b = caca_rand(0, h);
    434433    }
    435434    else
     
    437436        do
    438437        {
    439             x = cucul_rand(0, w); y = cucul_rand(0, h);
    440             a = cucul_rand(0, w); b = cucul_rand(0, h);
     438            x = caca_rand(0, w); y = caca_rand(0, h);
     439            a = caca_rand(0, w); b = caca_rand(0, h);
    441440
    442441        } while(x - a < 0 || x + a >= w || y - b < 0 || y + b >= h);
    443442    }
    444443
    445     cucul_set_color_ansi(cv, cucul_rand(0, 16), cucul_rand(0, 16));
    446     cucul_fill_ellipse(cv, x, y, a, b, '#');
    447 
    448     cucul_set_color_ansi(cv, cucul_rand(0, 16), CUCUL_BLACK);
     444    caca_set_color_ansi(cv, caca_rand(0, 16), caca_rand(0, 16));
     445    caca_fill_ellipse(cv, x, y, a, b, '#');
     446
     447    caca_set_color_ansi(cv, caca_rand(0, 16), CACA_BLACK);
    449448    if(outline == 2)
    450         cucul_draw_thin_ellipse(cv, x, y, a, b);
     449        caca_draw_thin_ellipse(cv, x, y, a, b);
    451450    else if(outline == 1)
    452         cucul_draw_ellipse(cv, x, y, a, b, '#');
     451        caca_draw_ellipse(cv, x, y, a, b, '#');
    453452}
    454453
    455454static void demo_triangles(void)
    456455{
    457     int w = cucul_get_canvas_width(cv);
    458     int h = cucul_get_canvas_height(cv);
     456    int w = caca_get_canvas_width(cv);
     457    int h = caca_get_canvas_height(cv);
    459458    int xa, ya, xb, yb, xc, yc;
    460459
    461460    if(bounds)
    462461    {
    463         xa = cucul_rand(- w, 2 * w); ya = cucul_rand(- h, 2 * h);
    464         xb = cucul_rand(- w, 2 * w); yb = cucul_rand(- h, 2 * h);
    465         xc = cucul_rand(- w, 2 * w); yc = cucul_rand(- h, 2 * h);
     462        xa = caca_rand(- w, 2 * w); ya = caca_rand(- h, 2 * h);
     463        xb = caca_rand(- w, 2 * w); yb = caca_rand(- h, 2 * h);
     464        xc = caca_rand(- w, 2 * w); yc = caca_rand(- h, 2 * h);
    466465    }
    467466    else
    468467    {
    469468
    470         xa = cucul_rand(0, w); ya = cucul_rand(0, h);
    471         xb = cucul_rand(0, w); yb = cucul_rand(0, h);
    472         xc = cucul_rand(0, w); yc = cucul_rand(0, h);
    473     }
    474 
    475     cucul_set_color_ansi(cv, cucul_rand(0, 16), cucul_rand(0, 16));
    476     cucul_fill_triangle(cv, xa, ya, xb, yb, xc, yc, '#');
    477 
    478     cucul_set_color_ansi(cv, cucul_rand(0, 16), CUCUL_BLACK);
     469        xa = caca_rand(0, w); ya = caca_rand(0, h);
     470        xb = caca_rand(0, w); yb = caca_rand(0, h);
     471        xc = caca_rand(0, w); yc = caca_rand(0, h);
     472    }
     473
     474    caca_set_color_ansi(cv, caca_rand(0, 16), caca_rand(0, 16));
     475    caca_fill_triangle(cv, xa, ya, xb, yb, xc, yc, '#');
     476
     477    caca_set_color_ansi(cv, caca_rand(0, 16), CACA_BLACK);
    479478    if(outline == 2)
    480         cucul_draw_thin_triangle(cv, xa, ya, xb, yb, xc, yc);
     479        caca_draw_thin_triangle(cv, xa, ya, xb, yb, xc, yc);
    481480    else if(outline == 1)
    482         cucul_draw_triangle(cv, xa, ya, xb, yb, xc, yc, '#');
     481        caca_draw_triangle(cv, xa, ya, xb, yb, xc, yc, '#');
    483482}
    484483#if 0
     
    486485{
    487486
    488     cucul_draw_sprite(cv, cucul_rand(0, cucul_get_canvas_width(cv)),
    489                       cucul_rand(0, cucul_get_canvas_height(cv)), sprite, 0);
     487    caca_draw_sprite(cv, caca_rand(0, caca_get_canvas_width(cv)),
     488                      caca_rand(0, caca_get_canvas_height(cv)), sprite, 0);
    490489
    491490}
     
    494493static void demo_render(void)
    495494{
    496     cucul_dither_t *dither;
     495    caca_dither_t *dither;
    497496    //short buffer[256*256];
    498497    //short *dest = buffer;
     
    511510        *dest++ = (x << 16) | (y << 8) | (z);
    512511    }
    513     cucul_set_dither_invert(dither, 1);
    514     //dither = cucul_create_dither(16, 256, 256, 2 * 256, 0xf800, 0x07e0, 0x001f, 0x0000);
    515     dither = cucul_create_dither(32, 256, 256, 4 * 256, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
    516     cucul_dither_bitmap(cv, 0, 0, cucul_get_canvas_width(cv), cucul_get_canvas_height(cv),
     512    caca_set_dither_invert(dither, 1);
     513    //dither = caca_create_dither(16, 256, 256, 2 * 256, 0xf800, 0x07e0, 0x001f, 0x0000);
     514    dither = caca_create_dither(32, 256, 256, 4 * 256, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
     515    caca_dither_bitmap(cv, 0, 0, caca_get_canvas_width(cv), caca_get_canvas_height(cv),
    517516                     dither, buffer);
    518     cucul_free_dither(dither);
     517    caca_free_dither(dither);
    519518}
    520519#endif
     
    524523static void demo_render(void)
    525524{
    526     cucul_dither_t *dither;
     525    caca_dither_t *dither;
    527526    int buffer[256*256];
    528527    int *dest;
     
    557556        draw_circle(buffer, xo, yo, z, 0x000000ff, 200);
    558557
    559     dither = cucul_create_dither(32, 256, 256, 4 * 256, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
    560     cucul_set_dither_gamma(dither, -1.0);
    561     cucul_dither_bitmap(cv, 0, 0, cucul_get_canvas_width(cv), cucul_get_canvas_height(cv), dither, (char *)buffer);
    562     cucul_free_dither(dither);
     558    dither = caca_create_dither(32, 256, 256, 4 * 256, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
     559    caca_set_dither_gamma(dither, -1.0);
     560    caca_dither_bitmap(cv, 0, 0, caca_get_canvas_width(cv), caca_get_canvas_height(cv), dither, (char *)buffer);
     561    caca_free_dither(dither);
    563562}
    564563
  • libcaca/trunk/examples/dithering.c

    r2299 r2821  
    1919#endif
    2020
    21 #include "cucul.h"
    2221#include "caca.h"
    2322
     
    2827unsigned int points[] =
    2928{
    30     CUCUL_BLACK, CUCUL_DARKGRAY, CUCUL_LIGHTGRAY,
    31     CUCUL_WHITE, CUCUL_RED, CUCUL_LIGHTRED
     29    CACA_BLACK, CACA_DARKGRAY, CACA_LIGHTGRAY,
     30    CACA_WHITE, CACA_RED, CACA_LIGHTRED
    3231};
    3332
     
    3635int main(int argc, char *argv[])
    3736{
    38     cucul_canvas_t *cv;
     37    caca_canvas_t *cv;
    3938    caca_display_t *dp;
    4039    int neara, dista, nearb, distb, dist;
    4140    int x, y;
    4241
    43     cv = cucul_create_canvas(80, 24);
     42    cv = caca_create_canvas(80, 24);
    4443    if(cv == NULL)
    4544    {
     
    6867        /* distance to 40% */
    6968        dist = XRATIO * (x - 40) * (x - 40) + YRATIO * y * y;
    70         if(cucul_rand(-FUZZY, FUZZY+1) + dist < dista)
     69        if(caca_rand(-FUZZY, FUZZY+1) + dist < dista)
    7170        {
    7271            nearb = neara; distb = dista; neara = 1; dista = dist;
     
    7978        /* check dist to 70% */
    8079        dist = XRATIO * (x - 70) * (x - 70) + YRATIO * y * y;
    81         if(cucul_rand(-FUZZY, FUZZY+1) + dist < dista)
     80        if(caca_rand(-FUZZY, FUZZY+1) + dist < dista)
    8281        {
    8382            nearb = neara; distb = dista; neara = 2; dista = dist;
    8483        }
    85         else if(cucul_rand(-FUZZY, FUZZY+1) + dist < distb)
     84        else if(caca_rand(-FUZZY, FUZZY+1) + dist < distb)
    8685        {
    8786            nearb = 2; distb = dist;
     
    9089        /* check dist to white */
    9190        dist = XRATIO * (x - 100) * (x - 100) + YRATIO * y * y;
    92         if(cucul_rand(-FUZZY, FUZZY+1) + dist < dista)
     91        if(caca_rand(-FUZZY, FUZZY+1) + dist < dista)
    9392        {
    9493            nearb = neara; distb = dista; neara = 3; dista = dist;
    9594        }
    96         else if(cucul_rand(-FUZZY, FUZZY+1) + dist < distb)
     95        else if(caca_rand(-FUZZY, FUZZY+1) + dist < distb)
    9796        {
    9897            nearb = 3; distb = dist;
     
    103102        dist = XRATIO * (x - 40) * (x - 40) + YRATIO * (y - 100) * (y - 100);
    104103        dist = dist * 12 / 16;
    105         if(cucul_rand(-FUZZY, FUZZY+1) + dist < dista)
     104        if(caca_rand(-FUZZY, FUZZY+1) + dist < dista)
    106105        {
    107106            nearb = neara; distb = dista; neara = 4; dista = dist;
    108107        }
    109         else if(cucul_rand(-FUZZY, FUZZY+1) + dist < distb)
     108        else if(caca_rand(-FUZZY, FUZZY+1) + dist < distb)
    110109        {
    111110            nearb = 4; distb = dist;
     
    115114        dist = XRATIO * (x - 100) * (x - 100) + YRATIO * (y - 100) * (y - 100);
    116115        dist = dist * 8 / 16;
    117         if(cucul_rand(-FUZZY, FUZZY+1) + dist < dista)
     116        if(caca_rand(-FUZZY, FUZZY+1) + dist < dista)
    118117        {
    119118            nearb = neara; distb = dista; neara = 5; dista = dist;
    120119        }
    121         else if(cucul_rand(-FUZZY, FUZZY+1) + dist < distb)
     120        else if(caca_rand(-FUZZY, FUZZY+1) + dist < distb)
    122121        {
    123122            nearb = 5; distb = dist;
     
    130129        else
    131130            ch = density[dista * 2 * 13 / (dista + distb)];
    132         cucul_set_color_ansi(cv, points[nearb], points[neara]);
     131        caca_set_color_ansi(cv, points[nearb], points[neara]);
    133132
    134         cucul_put_char(cv, x * cucul_get_canvas_width(cv) / 100,
    135                           (100 - y) * cucul_get_canvas_height(cv) / 100, ch);
     133        caca_put_char(cv, x * caca_get_canvas_width(cv) / 100,
     134                          (100 - y) * caca_get_canvas_height(cv) / 100, ch);
    136135    }
    137136
     
    141140
    142141    caca_free_display(dp);
    143     cucul_free_canvas(cv);
     142    caca_free_canvas(cv);
    144143
    145144    return 0;
  • libcaca/trunk/examples/driver.c

    r2299 r2821  
    2020#endif
    2121
    22 #include "cucul.h"
    2322#include "caca.h"
    2423
     
    2726    char const * const *list;
    2827    caca_display_t *dp;
    29     cucul_canvas_t *cv;
     28    caca_canvas_t *cv;
    3029
    3130    list = caca_get_display_driver_list();
     
    3938
    4039    cv = caca_get_canvas(dp);
    41     cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLACK);
     40    caca_set_color_ansi(cv, CACA_WHITE, CACA_BLACK);
    4241
    4342    while(1)
     
    4645        int i, cur = 0;
    4746
    48         cucul_put_str(cv, 1, 0, "Available drivers:");
     47        caca_put_str(cv, 1, 0, "Available drivers:");
    4948
    5049        driver = caca_get_display_driver(dp);
     
    5655            if(match)
    5756                cur = i;
    58             cucul_draw_line(cv, 0, i + 2, 9999, i + 2, ' ');
    59             cucul_printf(cv, 2, i + 2, "%c %s (%s)",
     57            caca_draw_line(cv, 0, i + 2, 9999, i + 2, ' ');
     58            caca_printf(cv, 2, i + 2, "%c %s (%s)",
    6059                         match ? '*' : ' ', list[i], list[i + 1]);
    6160        }
    6261
    63         cucul_put_str(cv, 1, i + 2, "Switching driver in 5 seconds");
     62        caca_put_str(cv, 1, i + 2, "Switching driver in 5 seconds");
    6463
    6564        caca_refresh_display(dp);
  • libcaca/trunk/examples/event.c

    r2299 r2821  
    2121#endif
    2222
    23 #include "cucul.h"
    2423#include "caca.h"
    2524
    26 static cucul_canvas_t *cv;
     25static caca_canvas_t *cv;
    2726static caca_display_t *dp;
    2827
     
    3433    int i, h, quit;
    3534
    36     cv = cucul_create_canvas(80, 24);
     35    cv = caca_create_canvas(80, 24);
    3736    if(cv == NULL)
    3837    {
     
    4847    }
    4948
    50     h = cucul_get_canvas_height(cv) - 1;
     49    h = caca_get_canvas_height(cv) - 1;
    5150
    52     cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLUE);
    53     cucul_draw_line(cv, 0, 0, cucul_get_canvas_width(cv) - 1, 0, ' ');
     51    caca_set_color_ansi(cv, CACA_WHITE, CACA_BLUE);
     52    caca_draw_line(cv, 0, 0, caca_get_canvas_width(cv) - 1, 0, ' ');
    5453
    55     cucul_draw_line(cv, 0, h, cucul_get_canvas_width(cv) - 1, h, ' ');
    56     cucul_put_str(cv, 0, h, "type \"quit\" to exit");
     54    caca_draw_line(cv, 0, h, caca_get_canvas_width(cv) - 1, h, ' ');
     55    caca_put_str(cv, 0, h, "type \"quit\" to exit");
    5756
    5857    caca_refresh_display(dp);
     
    9291        while(ret);
    9392
    94         cucul_set_color_ansi(cv, CUCUL_LIGHTGRAY, CUCUL_BLACK);
    95         cucul_clear_canvas(cv);
     93        caca_set_color_ansi(cv, CACA_LIGHTGRAY, CACA_BLACK);
     94        caca_clear_canvas(cv);
    9695
    9796        /* Print current event */
    98         cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLUE);
    99         cucul_draw_line(cv, 0, 0, cucul_get_canvas_width(cv) - 1, 0, ' ');
     97        caca_set_color_ansi(cv, CACA_WHITE, CACA_BLUE);
     98        caca_draw_line(cv, 0, 0, caca_get_canvas_width(cv) - 1, 0, ' ');
    10099        print_event(0, 0, events);
    101100
    102         cucul_draw_line(cv, 0, h, cucul_get_canvas_width(cv) - 1, h, ' ');
    103         cucul_printf(cv, 0, h, "type \"quit\" to exit: %s", quit_string[quit]);
     101        caca_draw_line(cv, 0, h, caca_get_canvas_width(cv) - 1, h, ' ');
     102        caca_printf(cv, 0, h, "type \"quit\" to exit: %s", quit_string[quit]);
    104103
    105104        /* Print previous events */
    106         cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLACK);
     105        caca_set_color_ansi(cv, CACA_WHITE, CACA_BLACK);
    107106        for(i = 1; i < h && caca_get_event_type(&events[i]); i++)
    108107            print_event(0, i, events + i);
     
    114113    free(events);
    115114    caca_free_display(dp);
    116     cucul_free_canvas(cv);
     115    caca_free_canvas(cv);
    117116
    118117    return 0;
     
    126125    {
    127126    case CACA_EVENT_NONE:
    128         cucul_printf(cv, x, y, "CACA_EVENT_NONE");
     127        caca_printf(cv, x, y, "CACA_EVENT_NONE");
    129128        break;
    130129    case CACA_EVENT_KEY_PRESS:
    131130        character = caca_get_event_key_ch(ev);
    132         cucul_printf(cv, x, y, "CACA_EVENT_KEY_PRESS 0x%02x (%c)", character,
     131        caca_printf(cv, x, y, "CACA_EVENT_KEY_PRESS 0x%02x (%c)", character,
    133132                     (character > 0x1f && character < 0x80) ? character : '?');
    134133        break;
    135134    case CACA_EVENT_KEY_RELEASE:
    136135        character = caca_get_event_key_ch(ev);
    137         cucul_printf(cv, x, y, "CACA_EVENT_KEY_RELEASE 0x%02x (%c)", character,
     136        caca_printf(cv, x, y, "CACA_EVENT_KEY_RELEASE 0x%02x (%c)", character,
    138137                     (character > 0x1f && character < 0x80) ? character : '?');
    139138        break;
    140139    case CACA_EVENT_MOUSE_MOTION:
    141         cucul_printf(cv, x, y, "CACA_EVENT_MOUSE_MOTION %u %u",
     140        caca_printf(cv, x, y, "CACA_EVENT_MOUSE_MOTION %u %u",
    142141                     caca_get_event_mouse_x(ev), caca_get_event_mouse_y(ev));
    143142        break;
    144143    case CACA_EVENT_MOUSE_PRESS:
    145         cucul_printf(cv, x, y, "CACA_EVENT_MOUSE_PRESS %u",
     144        caca_printf(cv, x, y, "CACA_EVENT_MOUSE_PRESS %u",
    146145                     caca_get_event_mouse_button(ev));
    147146        break;
    148147    case CACA_EVENT_MOUSE_RELEASE:
    149         cucul_printf(cv, x, y, "CACA_EVENT_MOUSE_RELEASE %u",
     148        caca_printf(cv, x, y, "CACA_EVENT_MOUSE_RELEASE %u",
    150149                     caca_get_event_mouse_button(ev));
    151150        break;
    152151    case CACA_EVENT_RESIZE:
    153         cucul_printf(cv, x, y, "CACA_EVENT_RESIZE %u %u",
     152        caca_printf(cv, x, y, "CACA_EVENT_RESIZE %u %u",
    154153                     caca_get_event_resize_width(ev),
    155154                     caca_get_event_resize_height(ev));
    156155        break;
    157156    case CACA_EVENT_QUIT:
    158         cucul_printf(cv, x, y, "CACA_EVENT_QUIT");
     157        caca_printf(cv, x, y, "CACA_EVENT_QUIT");
    159158        break;
    160159    default:
    161         cucul_printf(cv, x, y, "CACA_EVENT_UNKNOWN");
     160        caca_printf(cv, x, y, "CACA_EVENT_UNKNOWN");
    162161    }
    163162}
  • libcaca/trunk/examples/export.c

    r2313 r2821  
    11/*
    2  *  export        libcucul export test program
     2 *  export        libcaca export test program
    33 *  Copyright (c) 2006 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
     
    2121#endif
    2222
    23 #include "cucul.h"
     23#include "caca.h"
    2424
    2525#define WIDTH 80
     
    3030int main(int argc, char *argv[])
    3131{
    32     cucul_canvas_t *cv;
    33     cucul_dither_t *dither;
     32    caca_canvas_t *cv;
     33    caca_dither_t *dither;
    3434    void *buffer;
    3535    char *file, *format;
     
    3838    int x, y;
    3939
    40     exports = cucul_get_export_list();
     40    exports = caca_get_export_list();
    4141
    4242    if(argc < 2 || argc > 3)
     
    7676    if(file)
    7777    {
    78         cv = cucul_create_canvas(0, 0);
    79         if(cucul_import_file(cv, file, "") < 0)
     78        cv = caca_create_canvas(0, 0);
     79        if(caca_import_file(cv, file, "") < 0)
    8080        {
    8181            fprintf(stderr, "%s: `%s' has unknown format\n", argv[0], file);
     
    8585    else
    8686    {
    87         cv = cucul_create_canvas(WIDTH, HEIGHT);
     87        cv = caca_create_canvas(WIDTH, HEIGHT);
    8888
    8989        for(y = 0; y < 256; y++)
     
    9898        }
    9999
    100         dither = cucul_create_dither(32, 256, 256, 4 * 256,
     100        dither = caca_create_dither(32, 256, 256, 4 * 256,
    101101                                     0x00ff0000, 0x0000ff00, 0x000000ff, 0x0);
    102102        if(!strcmp(format, "ansi") || !strcmp(format, "utf8"))
    103             cucul_set_dither_charset(dither, "shades");
    104         cucul_dither_bitmap(cv, 0, 0, cucul_get_canvas_width(cv),
    105                             cucul_get_canvas_height(cv), dither, pixels);
    106         cucul_free_dither(dither);
     103            caca_set_dither_charset(dither, "shades");
     104        caca_dither_bitmap(cv, 0, 0, caca_get_canvas_width(cv),
     105                            caca_get_canvas_height(cv), dither, pixels);
     106        caca_free_dither(dither);
    107107
    108         cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLACK);
    109         cucul_draw_thin_box(cv, 0, 0, WIDTH - 1, HEIGHT - 1);
     108        caca_set_color_ansi(cv, CACA_WHITE, CACA_BLACK);
     109        caca_draw_thin_box(cv, 0, 0, WIDTH - 1, HEIGHT - 1);
    110110
    111         cucul_set_color_ansi(cv, CUCUL_BLACK, CUCUL_WHITE);
    112         cucul_fill_ellipse(cv, WIDTH / 2, HEIGHT / 2,
     111        caca_set_color_ansi(cv, CACA_BLACK, CACA_WHITE);
     112        caca_fill_ellipse(cv, WIDTH / 2, HEIGHT / 2,
    113113                               WIDTH / 4, HEIGHT / 4, ' ');
    114114
    115         cucul_set_color_ansi(cv, CUCUL_LIGHTGRAY, CUCUL_BLACK);
    116         cucul_put_str(cv, WIDTH / 2 - 12, HEIGHT / 2 - 6,
     115        caca_set_color_ansi(cv, CACA_LIGHTGRAY, CACA_BLACK);
     116        caca_put_str(cv, WIDTH / 2 - 12, HEIGHT / 2 - 6,
    117117                      "   lightgray on black   ");
    118         cucul_set_color_ansi(cv, CUCUL_DEFAULT, CUCUL_TRANSPARENT);
    119         cucul_put_str(cv, WIDTH / 2 - 12, HEIGHT / 2 - 5,
     118        caca_set_color_ansi(cv, CACA_DEFAULT, CACA_TRANSPARENT);
     119        caca_put_str(cv, WIDTH / 2 - 12, HEIGHT / 2 - 5,
    120120                      " default on transparent ");
    121         cucul_set_color_ansi(cv, CUCUL_BLACK, CUCUL_WHITE);
    122         cucul_put_str(cv, WIDTH / 2 - 12, HEIGHT / 2 - 4,
     121        caca_set_color_ansi(cv, CACA_BLACK, CACA_WHITE);
     122        caca_put_str(cv, WIDTH / 2 - 12, HEIGHT / 2 - 4,
    123123                      "     black on white     ");
    124124
    125         cucul_set_color_ansi(cv, CUCUL_BLACK, CUCUL_WHITE);
    126         cucul_put_str(cv, WIDTH / 2 - 8, HEIGHT / 2 - 3, "[<><><><> <>--<>]");
    127         cucul_put_str(cv, WIDTH / 2 - 8, HEIGHT / 2 - 2, "[ドラゴン ボーレ]");
    128         cucul_put_str(cv, WIDTH / 2 - 7, HEIGHT / 2 + 2, "äβç ░▒▓█▓▒░ ΔЗҒ");
    129         cucul_put_str(cv, WIDTH / 2 - 5, HEIGHT / 2 + 4, "(\") \\o/ <&>");
     125        caca_set_color_ansi(cv, CACA_BLACK, CACA_WHITE);
     126        caca_put_str(cv, WIDTH / 2 - 8, HEIGHT / 2 - 3, "[<><><><> <>--<>]");
     127        caca_put_str(cv, WIDTH / 2 - 8, HEIGHT / 2 - 2, "[ドラゴン ボーレ]");
     128        caca_put_str(cv, WIDTH / 2 - 7, HEIGHT / 2 + 2, "äβç ░▒▓█▓▒░ ΔЗҒ");
     129        caca_put_str(cv, WIDTH / 2 - 5, HEIGHT / 2 + 4, "(\") \\o/ <&>");
    130130
    131         cucul_set_attr(cv, CUCUL_BOLD);
    132         cucul_put_str(cv, WIDTH / 2 - 16, HEIGHT / 2 + 3, "Bold");
    133         cucul_set_attr(cv, CUCUL_BLINK);
    134         cucul_put_str(cv, WIDTH / 2 - 9, HEIGHT / 2 + 3, "Blink");
    135         cucul_set_attr(cv, CUCUL_ITALICS);
    136         cucul_put_str(cv, WIDTH / 2 - 1, HEIGHT / 2 + 3, "Italics");
    137         cucul_set_attr(cv, CUCUL_UNDERLINE);
    138         cucul_put_str(cv, WIDTH / 2 + 8, HEIGHT / 2 + 3, "Underline");
    139         cucul_set_attr(cv, 0);
     131        caca_set_attr(cv, CACA_BOLD);
     132        caca_put_str(cv, WIDTH / 2 - 16, HEIGHT / 2 + 3, "Bold");
     133        caca_set_attr(cv, CACA_BLINK);
     134        caca_put_str(cv, WIDTH / 2 - 9, HEIGHT / 2 + 3, "Blink");
     135        caca_set_attr(cv, CACA_ITALICS);
     136        caca_put_str(cv, WIDTH / 2 - 1, HEIGHT / 2 + 3, "Italics");
     137        caca_set_attr(cv, CACA_UNDERLINE);
     138        caca_put_str(cv, WIDTH / 2 + 8, HEIGHT / 2 + 3, "Underline");
     139        caca_set_attr(cv, 0);
    140140
    141         cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_LIGHTBLUE);
    142         cucul_put_str(cv, WIDTH / 2 - 7, HEIGHT / 2, "    LIBCACA    ");
     141        caca_set_color_ansi(cv, CACA_WHITE, CACA_LIGHTBLUE);
     142        caca_put_str(cv, WIDTH / 2 - 7, HEIGHT / 2, "    LIBCACA    ");
    143143
    144144        for(x = 0; x < 16; x++)
    145145        {
    146             cucul_set_color_argb(cv, 0xff00 | x, 0xf00f | (x << 4));
    147             cucul_put_char(cv, WIDTH / 2 - 7 + x, HEIGHT / 2 + 6, '#');
     146            caca_set_color_argb(cv, 0xff00 | x, 0xf00f | (x << 4));
     147            caca_put_char(cv, WIDTH / 2 - 7 + x, HEIGHT / 2 + 6, '#');
    148148        }
    149149    }
    150150
    151     buffer = cucul_export_memory(cv, format, &len);
     151    buffer = caca_export_memory(cv, format, &len);
    152152    fwrite(buffer, len, 1, stdout);
    153153    free(buffer);
    154154
    155     cucul_free_canvas(cv);
     155    caca_free_canvas(cv);
    156156
    157157    return 0;
  • libcaca/trunk/examples/figfont.c

    r2313 r2821  
    11/*
    2  *  figfont       libcucul FIGfont test program
     2 *  figfont       libcaca FIGfont test program
    33 *  Copyright (c) 2007 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
     
    2020#endif
    2121
    22 #include "cucul.h"
     22#include "caca.h"
    2323
    2424int main(int argc, char *argv[])
    2525{
    26     cucul_canvas_t *cv;
     26    caca_canvas_t *cv;
    2727    void *buffer;
    2828    size_t len;
     
    3535    }
    3636
    37     cv = cucul_create_canvas(0, 0);
    38     if(cucul_canvas_set_figfont(cv, argv[1]))
     37    cv = caca_create_canvas(0, 0);
     38    if(caca_canvas_set_figfont(cv, argv[1]))
    3939    {
    4040        fprintf(stderr, "Could not open font\n");
     
    4444    while(argv[2][0])
    4545    {
    46         cucul_set_color_ansi(cv, 1 + ((color += 4) % 15), CUCUL_TRANSPARENT);
    47         cucul_put_figchar(cv, argv[2]++[0]);
     46        caca_set_color_ansi(cv, 1 + ((color += 4) % 15), CACA_TRANSPARENT);
     47        caca_put_figchar(cv, argv[2]++[0]);
    4848    }
    4949
    50     buffer = cucul_export_memory(cv, "utf8", &len);
     50    buffer = caca_export_memory(cv, "utf8", &len);
    5151    fwrite(buffer, len, 1, stdout);
    5252    free(buffer);
    5353
    54     cucul_free_canvas(cv);
     54    caca_free_canvas(cv);
    5555
    5656    return 0;
  • libcaca/trunk/examples/font.c

    r2300 r2821  
    11/*
    2  *  font          libcucul font test program
     2 *  font          libcaca font test program
    33 *  Copyright (c) 2006 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
     
    2525#endif
    2626
    27 #include "cucul.h"
    2827#include "caca.h"
    2928
    3029int main(int argc, char *argv[])
    3130{
    32     cucul_canvas_t *cv;
     31    caca_canvas_t *cv;
    3332    caca_display_t *dp;
    34     cucul_font_t *f;
    35     cucul_dither_t *d;
     33    caca_font_t *f;
     34    caca_dither_t *d;
    3635    uint8_t *buf;
    3736    unsigned int w, h;
     
    3938
    4039    /* Create a canvas */
    41     cv = cucul_create_canvas(8, 2);
     40    cv = caca_create_canvas(8, 2);
    4241    if(cv == NULL)
    4342    {
     
    4847
    4948    /* Draw stuff on our canvas */
    50     cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLACK);
    51     cucul_put_str(cv, 0, 0, "ABcde");
    52     cucul_set_color_ansi(cv, CUCUL_LIGHTRED, CUCUL_BLACK);
    53     cucul_put_str(cv, 5, 0, "\\o/");
    54     cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLUE);
    55     cucul_put_str(cv, 0, 1, "&$âøÿØ?!");
     49    caca_set_color_ansi(cv, CACA_WHITE, CACA_BLACK);
     50    caca_put_str(cv, 0, 0, "ABcde");
     51    caca_set_color_ansi(cv, CACA_LIGHTRED, CACA_BLACK);
     52    caca_put_str(cv, 5, 0, "\\o/");
     53    caca_set_color_ansi(cv, CACA_WHITE, CACA_BLUE);
     54    caca_put_str(cv, 0, 1, "&$âøÿØ?!");
    5655
    57     /* Load a libcucul internal font */
    58     fonts = cucul_get_font_list();
     56    /* Load a libcaca internal font */
     57    fonts = caca_get_font_list();
    5958    if(fonts[0] == NULL)
    6059    {
    61         fprintf(stderr, "error: libcucul was compiled without any fonts\n");
     60        fprintf(stderr, "error: libcaca was compiled without any fonts\n");
    6261        return -1;
    6362    }
    64     f = cucul_load_font(fonts[0], 0);
     63    f = caca_load_font(fonts[0], 0);
    6564    if(f == NULL)
    6665    {
     
    7069
    7170    /* Create our bitmap buffer (32-bit ARGB) */
    72     w = cucul_get_canvas_width(cv) * cucul_get_font_width(f);
    73     h = cucul_get_canvas_height(cv) * cucul_get_font_height(f);
     71    w = caca_get_canvas_width(cv) * caca_get_font_width(f);
     72    h = caca_get_canvas_height(cv) * caca_get_font_height(f);
    7473    buf = malloc(4 * w * h);
    7574
    7675    /* Render the canvas onto our image buffer */
    77     cucul_render_canvas(cv, f, buf, w, h, 4 * w);
     76    caca_render_canvas(cv, f, buf, w, h, 4 * w);
    7877
    7978    /* Just for fun, render the image using libcaca */
    80     cucul_set_canvas_size(cv, 80, 32);
     79    caca_set_canvas_size(cv, 80, 32);
    8180    dp = caca_create_display(cv);
    8281
     
    8988        if(*(uint8_t const *)&tmp == 0x12)
    9089#endif
    91             d = cucul_create_dither(32, w, h, 4 * w,
     90            d = caca_create_dither(32, w, h, 4 * w,
    9291                                    0xff0000, 0xff00, 0xff, 0xff000000);
    9392        else
    94             d = cucul_create_dither(32, w, h, 4 * w,
     93            d = caca_create_dither(32, w, h, 4 * w,
    9594                                    0xff00, 0xff0000, 0xff000000, 0xff);
    9695    }
    9796
    98     cucul_dither_bitmap(cv, 0, 0, cucul_get_canvas_width(cv),
    99                                   cucul_get_canvas_height(cv), d, buf);
     97    caca_dither_bitmap(cv, 0, 0, caca_get_canvas_width(cv),
     98                                  caca_get_canvas_height(cv), d, buf);
    10099    caca_refresh_display(dp);
    101100
     
    105104    caca_free_display(dp);
    106105    free(buf);
    107     cucul_free_dither(d);
    108     cucul_free_font(f);
    109     cucul_free_canvas(cv);
     106    caca_free_dither(d);
     107    caca_free_font(f);
     108    caca_free_canvas(cv);
    110109
    111110    return 0;
  • libcaca/trunk/examples/font2tga.c

    r2304 r2821  
    11/*
    2  *  font2tga      libcucul font test program
     2 *  font2tga      libcaca font test program
    33 *  Copyright (c) 2006 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
     
    2020#endif
    2121
    22 #include "cucul.h"
     22#include "caca.h"
    2323
    2424int main(int argc, char *argv[])
    2525{
    2626    uint32_t const *blocks;
    27     cucul_font_t *f;
     27    caca_font_t *f;
    2828    char const * const * fonts;
    29     cucul_canvas_t *cv;
     29    caca_canvas_t *cv;
    3030    void *buffer;
    3131    size_t len;
    3232    unsigned int i, j, x, y, cells, width;
    3333
    34     fonts = cucul_get_font_list();
    35     f = cucul_load_font(fonts[0], 0);
    36     blocks = cucul_get_font_blocks(f);
     34    fonts = caca_get_font_list();
     35    f = caca_load_font(fonts[0], 0);
     36    blocks = caca_get_font_blocks(f);
    3737
    3838    for(i = 0, cells = 0; blocks[i + 1]; i += 2)
     
    4040        cells += blocks[i + 1] - blocks[i];
    4141        for(j = blocks[i]; j < blocks[i + 1]; j++)
    42             if(cucul_utf32_is_fullwidth(j))
     42            if(caca_utf32_is_fullwidth(j))
    4343                cells++;
    4444    }
     
    4848
    4949    /* Create a canvas */
    50     cv = cucul_create_canvas(width, (cells + width - 1) / (width - 1));
    51     cucul_set_color_ansi(cv, CUCUL_RED, CUCUL_RED);
    52     cucul_clear_canvas(cv);
    53     cucul_set_color_ansi(cv, CUCUL_BLACK, CUCUL_WHITE);
     50    cv = caca_create_canvas(width, (cells + width - 1) / (width - 1));
     51    caca_set_color_ansi(cv, CACA_RED, CACA_RED);
     52    caca_clear_canvas(cv);
     53    caca_set_color_ansi(cv, CACA_BLACK, CACA_WHITE);
    5454
    5555    /* Put all glyphs on the canvas */
     
    6060        for(j = blocks[i]; j < blocks[i + 1]; j++)
    6161        {
    62             cucul_put_char(cv, x, y, j);
     62            caca_put_char(cv, x, y, j);
    6363
    64             if(cucul_utf32_is_fullwidth(j))
     64            if(caca_utf32_is_fullwidth(j))
    6565                ++x;
    6666
     
    7373    }
    7474
    75     cucul_free_font(f);
     75    caca_free_font(f);
    7676
    77     buffer = cucul_export_memory(cv, "tga", &len);
     77    buffer = caca_export_memory(cv, "tga", &len);
    7878    fwrite(buffer, len, 1, stdout);
    7979    free(buffer);
    8080
    8181    /* Free everything */
    82     cucul_free_canvas(cv);
     82    caca_free_canvas(cv);
    8383
    8484    return 0;
  • libcaca/trunk/examples/frames.c

    r2299 r2821  
    1919#endif
    2020
    21 #include "cucul.h"
    2221#include "caca.h"
    2322
    2423int main(int argc, char *argv[])
    2524{
    26     cucul_canvas_t *cv;
     25    caca_canvas_t *cv;
    2726    caca_display_t *dp;
    2827
     
    3029
    3130    /* Create a canvas with 200 frames */
    32     cv = cucul_create_canvas(0, 0);
     31    cv = caca_create_canvas(0, 0);
    3332    if(cv == NULL)
    3433    {
     
    3837
    3938    for(frame = 1; frame < 200; frame++)
    40         cucul_create_frame(cv, frame);
     39        caca_create_frame(cv, frame);
    4140
    4241    fprintf(stderr, "canvas created, size is %ix%i\n",
    43             cucul_get_canvas_width(cv), cucul_get_canvas_height(cv));
     42            caca_get_canvas_width(cv), caca_get_canvas_height(cv));
    4443
    4544    /* Resize it to 150 x 80 (around 19MB) */
    46     cucul_set_canvas_size(cv, 150, 80);
     45    caca_set_canvas_size(cv, 150, 80);
    4746
    4847    fprintf(stderr, "canvas expanded, size is %ix%i\n",
    49             cucul_get_canvas_width(cv), cucul_get_canvas_height(cv));
     48            caca_get_canvas_width(cv), caca_get_canvas_height(cv));
    5049
    5150    /* Fill the first 16 frames with a different colour */
    5251    for(frame = 0; frame < 16; frame++)
    5352    {
    54         cucul_set_frame(cv, frame);
    55         cucul_set_color_ansi(cv, CUCUL_WHITE, frame);
    56         cucul_fill_box(cv, 0, 0, 40, 15, ':');
    57         cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLUE);
    58         cucul_put_str(cv, frame * 5 / 2, frame, "カカ");
    59         cucul_set_color_ansi(cv, CUCUL_DEFAULT, CUCUL_TRANSPARENT);
     53        caca_set_frame(cv, frame);
     54        caca_set_color_ansi(cv, CACA_WHITE, frame);
     55        caca_fill_box(cv, 0, 0, 40, 15, ':');
     56        caca_set_color_ansi(cv, CACA_WHITE, CACA_BLUE);
     57        caca_put_str(cv, frame * 5 / 2, frame, "カカ");
     58        caca_set_color_ansi(cv, CACA_DEFAULT, CACA_TRANSPARENT);
    6059    }
    6160
    6261    /* Resize it to a more decent size */
    63     cucul_set_canvas_size(cv, 41, 16);
     62    caca_set_canvas_size(cv, 41, 16);
    6463
    6564    fprintf(stderr, "canvas shrinked, size is %ix%i\n",
    66             cucul_get_canvas_width(cv), cucul_get_canvas_height(cv));
     65            caca_get_canvas_width(cv), caca_get_canvas_height(cv));
    6766
    6867    dp = caca_create_display(cv);
     
    7069
    7170    fprintf(stderr, "display attached, size is %ix%i\n",
    72             cucul_get_canvas_width(cv), cucul_get_canvas_height(cv));
     71            caca_get_canvas_width(cv), caca_get_canvas_height(cv));
    7372
    7473    n = 0;
    7574    while(!caca_get_event(dp, CACA_EVENT_KEY_PRESS, NULL, 0))
    7675    {
    77         cucul_set_frame(cv, n % 16);
     76        caca_set_frame(cv, n % 16);
    7877        caca_refresh_display(dp);
    7978        n++;
     
    8483    /* It is possible, though not necessary, to free all additional frames
    8584     * separately. */
    86     cucul_free_canvas(cv);
     85    caca_free_canvas(cv);
    8786
    8887    return 0;
  • libcaca/trunk/examples/fullwidth.c

    r2299 r2821  
    1919#endif
    2020
    21 #include "cucul.h"
    2221#include "caca.h"
    2322
     
    2625int main(int argc, char *argv[])
    2726{
    28     cucul_canvas_t *cv, *caca, *line;
     27    caca_canvas_t *cv, *caca, *line;
    2928    caca_display_t *dp;
    3029
    3130    unsigned int i;
    3231
    33     cv = cucul_create_canvas(0, 0);
     32    cv = caca_create_canvas(0, 0);
    3433    if(cv == NULL)
    3534    {
     
    4443    }
    4544
    46     caca = cucul_create_canvas(6, 10);
    47     line = cucul_create_canvas(2, 1);
     45    caca = caca_create_canvas(6, 10);
     46    line = caca_create_canvas(2, 1);
    4847
    4948    /* Line of x's */
    5049    for(i = 0; i < 10; i++)
    5150    {
    52         cucul_set_color_ansi(caca, CUCUL_WHITE, CUCUL_BLUE);
    53         cucul_put_str(caca, 0, i, CACA);
    54         cucul_set_color_ansi(caca, CUCUL_WHITE, CUCUL_RED);
    55         cucul_put_char(caca, i - 2, i, 'x');
     51        caca_set_color_ansi(caca, CACA_WHITE, CACA_BLUE);
     52        caca_put_str(caca, 0, i, CACA);
     53        caca_set_color_ansi(caca, CACA_WHITE, CACA_RED);
     54        caca_put_char(caca, i - 2, i, 'x');
    5655    }
    5756
    58     cucul_blit(cv, 1, 1, caca, NULL);
     57    caca_blit(cv, 1, 1, caca, NULL);
    5958
    6059    /* Line of ホ's */
    6160    for(i = 0; i < 10; i++)
    6261    {
    63         cucul_set_color_ansi(caca, CUCUL_WHITE, CUCUL_BLUE);
    64         cucul_put_str(caca, 0, i, CACA);
    65         cucul_set_color_ansi(caca, CUCUL_WHITE, CUCUL_GREEN);
    66         cucul_put_str(caca, i - 2, i, "ホ");
     62        caca_set_color_ansi(caca, CACA_WHITE, CACA_BLUE);
     63        caca_put_str(caca, 0, i, CACA);
     64        caca_set_color_ansi(caca, CACA_WHITE, CACA_GREEN);
     65        caca_put_str(caca, i - 2, i, "ホ");
    6766    }
    6867
    69     cucul_blit(cv, 15, 1, caca, NULL);
     68    caca_blit(cv, 15, 1, caca, NULL);
    7069
    7170    /* Line of canvas */
    72     cucul_set_color_ansi(line, CUCUL_WHITE, CUCUL_MAGENTA);
    73     cucul_put_str(line, 0, 0, "ほ");
     71    caca_set_color_ansi(line, CACA_WHITE, CACA_MAGENTA);
     72    caca_put_str(line, 0, 0, "ほ");
    7473    for(i = 0; i < 10; i++)
    7574    {
    76         cucul_set_color_ansi(caca, CUCUL_WHITE, CUCUL_BLUE);
    77         cucul_put_str(caca, 0, i, CACA);
    78         cucul_blit(caca, i - 2, i, line, NULL);
     75        caca_set_color_ansi(caca, CACA_WHITE, CACA_BLUE);
     76        caca_put_str(caca, 0, i, CACA);
     77        caca_blit(caca, i - 2, i, line, NULL);
    7978    }
    8079
    81     cucul_blit(cv, 29, 1, caca, NULL);
     80    caca_blit(cv, 29, 1, caca, NULL);
    8281
    8382    caca_refresh_display(dp);
     
    8786    caca_free_display(dp);
    8887
    89     cucul_free_canvas(line);
    90     cucul_free_canvas(caca);
    91     cucul_free_canvas(cv);
     88    caca_free_canvas(line);
     89    caca_free_canvas(caca);
     90    caca_free_canvas(cv);
    9291
    9392    return 0;
  • libcaca/trunk/examples/gamma.c

    r2299 r2821  
    11/*
    2  *  gamma         libcucul gamma test program
     2 *  gamma         libcaca gamma test program
    33 *  Copyright (c) 2006 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
     
    2020#endif
    2121
    22 #include "cucul.h"
    2322#include "caca.h"
    2423
     
    2827{
    2928    caca_event_t ev;
    30     cucul_canvas_t *cv, *cw, *mask;
     29    caca_canvas_t *cv, *cw, *mask;
    3130    caca_display_t *dp;
    32     cucul_dither_t *left, *right;
     31    caca_dither_t *left, *right;
    3332    float gam;
    3433    int x;
    3534
    36     cv = cucul_create_canvas(0, 0);
     35    cv = caca_create_canvas(0, 0);
    3736    if(cv == NULL)
    3837    {
     
    4746    }
    4847
    49     cw = cucul_create_canvas(cucul_get_canvas_width(cv), cucul_get_canvas_height(cv));
    50     mask = cucul_create_canvas(cucul_get_canvas_width(cv), cucul_get_canvas_height(cv));
     48    cw = caca_create_canvas(caca_get_canvas_width(cv), caca_get_canvas_height(cv));
     49    mask = caca_create_canvas(caca_get_canvas_width(cv), caca_get_canvas_height(cv));
    5150
    5251    for(x = 0; x < 256; x++)
     
    5857    }
    5958
    60     left = cucul_create_dither(32, 256, 4, 4 * 256,
     59    left = caca_create_dither(32, 256, 4, 4 * 256,
    6160                               0x00ff0000, 0x0000ff00, 0x000000ff, 0x0);
    62     right = cucul_create_dither(32, 256, 4, 4 * 256,
     61    right = caca_create_dither(32, 256, 4, 4 * 256,
    6362                                0x00ff0000, 0x0000ff00, 0x000000ff, 0x0);
    64     gam = cucul_get_dither_gamma(right);
     63    gam = caca_get_dither_gamma(right);
    6564    caca_set_display_time(dp, 20000);
    6665
     
    8281
    8382        /* Resize the spare canvas, just in case the main one changed */
    84         cucul_set_canvas_size(cw, cucul_get_canvas_width(cv), cucul_get_canvas_height(cv));
    85         cucul_set_canvas_size(mask, cucul_get_canvas_width(cv), cucul_get_canvas_height(cv));
     83        caca_set_canvas_size(cw, caca_get_canvas_width(cv), caca_get_canvas_height(cv));
     84        caca_set_canvas_size(mask, caca_get_canvas_width(cv), caca_get_canvas_height(cv));
    8685
    8786        /* Draw the regular dither on the main canvas */
    88         cucul_dither_bitmap(cv, 0, 0, cucul_get_canvas_width(cv),
    89                             cucul_get_canvas_height(cv), left, buffer);
     87        caca_dither_bitmap(cv, 0, 0, caca_get_canvas_width(cv),
     88                            caca_get_canvas_height(cv), left, buffer);
    9089
    9190        /* Draw the gamma-modified dither on the spare canvas */
    92         cucul_set_dither_gamma(right, gam);
    93         cucul_dither_bitmap(cw, 0, 0, cucul_get_canvas_width(cw),
    94                             cucul_get_canvas_height(cw), right, buffer);
     91        caca_set_dither_gamma(right, gam);
     92        caca_dither_bitmap(cw, 0, 0, caca_get_canvas_width(cw),
     93                            caca_get_canvas_height(cw), right, buffer);
    9594
    9695        /* Draw something on the mask */
    97         cucul_set_color_ansi(mask, CUCUL_LIGHTGRAY, CUCUL_BLACK);
    98         cucul_clear_canvas(mask);
    99         cucul_set_color_ansi(mask, CUCUL_WHITE, CUCUL_WHITE);
    100         cucul_fill_ellipse(mask, (1.0 + sin(0.05 * (float)x))
    101                                    * 0.5 * cucul_get_canvas_width(mask),
     96        caca_set_color_ansi(mask, CACA_LIGHTGRAY, CACA_BLACK);
     97        caca_clear_canvas(mask);
     98        caca_set_color_ansi(mask, CACA_WHITE, CACA_WHITE);
     99        caca_fill_ellipse(mask, (1.0 + sin(0.05 * (float)x))
     100                                   * 0.5 * caca_get_canvas_width(mask),
    102101                                 (1.0 + cos(0.05 * (float)x))
    103                                    * 0.5 * cucul_get_canvas_height(mask),
    104                                  cucul_get_canvas_width(mask) / 2,
    105                                  cucul_get_canvas_height(mask) / 2, '#');
     102                                   * 0.5 * caca_get_canvas_height(mask),
     103                                 caca_get_canvas_width(mask) / 2,
     104                                 caca_get_canvas_height(mask) / 2, '#');
    106105
    107106        /* Blit the spare canvas onto the first one */
    108         cucul_blit(cv, 0, 0, cw, mask);
     107        caca_blit(cv, 0, 0, cw, mask);
    109108
    110         cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLUE);
    111         cucul_printf(cv, 2, 1,
     109        caca_set_color_ansi(cv, CACA_WHITE, CACA_BLUE);
     110        caca_printf(cv, 2, 1,
    112111                     "gamma=%g - use arrows to change, Esc to quit", gam);
    113112
     
    115114    }
    116115
    117     cucul_free_dither(left);
    118     cucul_free_dither(right);
     116    caca_free_dither(left);
     117    caca_free_dither(right);
    119118
    120119    caca_free_display(dp);
    121     cucul_free_canvas(mask);
    122     cucul_free_canvas(cw);
    123     cucul_free_canvas(cv);
     120    caca_free_canvas(mask);
     121    caca_free_canvas(cw);
     122    caca_free_canvas(cv);
    124123
    125124    return 0;
  • libcaca/trunk/examples/hsv.c

    r2299 r2821  
    1919#endif
    2020
    21 #include "cucul.h"
    2221#include "caca.h"
    2322
     
    2726{
    2827    caca_display_t *dp;
    29     cucul_canvas_t *cv;
     28    caca_canvas_t *cv;
    3029
    31     cucul_dither_t *dither;
     30    caca_dither_t *dither;
    3231    int x, y;
    3332
     
    4746    }
    4847
    49     dither = cucul_create_dither(32, 256, 256, 4 * 256,
     48    dither = caca_create_dither(32, 256, 256, 4 * 256,
    5049                                 0x00ff0000, 0x0000ff00, 0x000000ff, 0x0);
    51     cucul_dither_bitmap(caca_get_canvas(dp), 0, 0, cucul_get_canvas_width(cv),
    52                         cucul_get_canvas_height(cv), dither, buffer);
    53     cucul_free_dither(dither);
     50    caca_dither_bitmap(caca_get_canvas(dp), 0, 0, caca_get_canvas_width(cv),
     51                        caca_get_canvas_height(cv), dither, buffer);
     52    caca_free_dither(dither);
    5453
    5554    caca_refresh_display(dp);
  • libcaca/trunk/examples/import.c

    r2299 r2821  
    2020#endif
    2121
    22 #include "cucul.h"
    2322#include "caca.h"
    2423
    2524int main(int argc, char *argv[])
    2625{
    27     cucul_canvas_t *cv;
     26    caca_canvas_t *cv;
    2827    caca_display_t *dp;
    2928
     
    3534    }
    3635
    37     cv = cucul_create_canvas(0, 0);
     36    cv = caca_create_canvas(0, 0);
    3837    if(cv == NULL)
    3938    {
     
    4241    }
    4342
    44     if(cucul_import_file(cv, argv[1], argc >= 3 ? argv[2] : "") < 0)
     43    if(caca_import_file(cv, argv[1], argc >= 3 ? argv[2] : "") < 0)
    4544    {
    4645        fprintf(stderr, "%s: could not open `%s'.\n", argv[0], argv[1]);
    47         cucul_free_canvas(cv);
     46        caca_free_canvas(cv);
    4847        return 1;
    4948    }
     
    6160
    6261    caca_free_display(dp);
    63     cucul_free_canvas(cv);
     62    caca_free_canvas(cv);
    6463
    6564    return 0;
  • libcaca/trunk/examples/input.c

    r2299 r2821  
    2020#endif
    2121
    22 #include "cucul.h"
    2322#include "caca.h"
    2423
     
    3534{
    3635    textentry entries[TEXT_ENTRIES];
    37     cucul_canvas_t *cv;
     36    caca_canvas_t *cv;
    3837    caca_display_t *dp;
    3938    unsigned int i, e = 0, running = 1;
    4039
    41     cv = cucul_create_canvas(0, 0);
     40    cv = caca_create_canvas(0, 0);
    4241    if(cv == NULL)
    4342    {
     
    5352    caca_set_cursor(dp, 1);
    5453
    55     cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLUE);
    56     cucul_put_str(cv, 1, 1, "Text entries - press tab to cycle");
     54    caca_set_color_ansi(cv, CACA_WHITE, CACA_BLUE);
     55    caca_put_str(cv, 1, 1, "Text entries - press tab to cycle");
    5756
    5857    for(i = 0; i < TEXT_ENTRIES; i++)
     
    7170            unsigned int j, start, size;
    7271
    73             cucul_set_color_ansi(cv, CUCUL_BLACK, CUCUL_LIGHTGRAY);
    74             cucul_fill_box(cv, 2, 3 * i + 4, 2 + BUFFER_SIZE, 3 * i + 4, ' ');
     72            caca_set_color_ansi(cv, CACA_BLACK, CACA_LIGHTGRAY);
     73            caca_fill_box(cv, 2, 3 * i + 4, 2 + BUFFER_SIZE, 3 * i + 4, ' ');
    7574
    7675            start = 0;
     
    7978            for(j = 0; j < size; j++)
    8079            {
    81                 cucul_put_char(cv, 2 + j, 3 * i + 4,
     80                caca_put_char(cv, 2 + j, 3 * i + 4,
    8281                              entries[i].buffer[start + j]);
    8382            }
     
    8584
    8685        /* Put the cursor on the active textentry */
    87         cucul_gotoxy(cv, 2 + entries[e].cursor, 3 * e + 4);
     86        caca_gotoxy(cv, 2 + entries[e].cursor, 3 * e + 4);
    8887
    8988        caca_refresh_display(dp);
     
    150149
    151150    caca_free_display(dp);
    152     cucul_free_canvas(cv);
     151    caca_free_canvas(cv);
    153152
    154153    return 0;
  • libcaca/trunk/examples/spritedit.c

    r2313 r2821  
    2121#endif
    2222
    23 #include "cucul.h"
    2423#include "caca.h"
    2524
     
    4948int main(int argc, char **argv)
    5049{
    51     cucul_canvas_t *sprite;
     50    caca_canvas_t *sprite;
    5251    size_t len;
    5352    void *buffer;
     
    5554
    5655    /* Create a canvas with 4 frames */
    57     sprite = cucul_create_canvas(0, 0);
     56    sprite = caca_create_canvas(0, 0);
    5857    for(i = 0; i < 3; i++)
    59         cucul_create_frame(sprite, 0);
     58        caca_create_frame(sprite, 0);
    6059
    6160    /* Load stuff in all 4 frames */
    6261    for(i = 0; i < 4; i++)
    6362    {
    64         cucul_set_frame(sprite, i);
    65         cucul_import_memory(sprite, guy[i], strlen(guy[i]), "utf8");
     63        caca_set_frame(sprite, i);
     64        caca_import_memory(sprite, guy[i], strlen(guy[i]), "utf8");
    6665    }
    6766
    6867    /* Export our sprite in a memory buffer. We could save this to
    6968     * disk afterwards. */
    70     buffer = cucul_export_memory(sprite, "caca", &len);
     69    buffer = caca_export_memory(sprite, "caca", &len);
    7170
    7271    /* Free our sprite and reload it from the memory buffer. We could
    7372     * load this from disk, too. */
    74     cucul_free_canvas(sprite);
    75     sprite = cucul_create_canvas(0, 0);
    76     cucul_import_memory(sprite, buffer, len, "caca");
     73    caca_free_canvas(sprite);
     74    sprite = caca_create_canvas(0, 0);
     75    caca_import_memory(sprite, buffer, len, "caca");
    7776    free(buffer);
    7877
     
    8079    for(i = 0; i < 4; i++)
    8180    {
    82         cucul_set_frame(sprite, i);
     81        caca_set_frame(sprite, i);
    8382        printf("Frame #%i\n", i);
    84         buffer = cucul_export_memory(sprite, "utf8", &len);
     83        buffer = caca_export_memory(sprite, "utf8", &len);
    8584        fwrite(buffer, len, 1, stdout);
    8685        free(buffer);
     
    8887
    8988    /* Free our sprite */
    90     cucul_free_canvas(sprite);
     89    caca_free_canvas(sprite);
    9190
    9291    return 0;
  • libcaca/trunk/examples/swallow.c

    r2300 r2821  
    2121#endif
    2222
    23 #include "cucul.h"
    2423#include "caca.h"
    2524
     
    2726{
    2827    char cmd[BUFSIZ];
    29     static cucul_canvas_t *cv, *app;
     28    static caca_canvas_t *cv, *app;
    3029    static caca_display_t *dp;
    3130    uint8_t *buf[4];
     
    4039    }
    4140
    42     cv = cucul_create_canvas(0, 0);
    43     app = cucul_create_canvas(0, 0);
     41    cv = caca_create_canvas(0, 0);
     42    app = caca_create_canvas(0, 0);
    4443    dp = caca_create_display(cv);
    4544
     
    5554    }
    5655
    57     w = (cucul_get_canvas_width(cv) - 4) / 2;
    58     h = (cucul_get_canvas_height(cv) - 6) / 2;
     56    w = (caca_get_canvas_width(cv) - 4) / 2;
     57    h = (caca_get_canvas_height(cv) - 6) / 2;
    5958
    6059    if(w < 0 || h < 0)
    6160        return 1;
    6261
    63     cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLUE);
    64     cucul_draw_line(cv, 0, 0, cucul_get_canvas_width(cv) - 1, 0, ' ');
    65     cucul_printf(cv, cucul_get_canvas_width(cv) / 2 - 10, 0,
     62    caca_set_color_ansi(cv, CACA_WHITE, CACA_BLUE);
     63    caca_draw_line(cv, 0, 0, caca_get_canvas_width(cv) - 1, 0, ' ');
     64    caca_printf(cv, caca_get_canvas_width(cv) / 2 - 10, 0,
    6665                 "libcaca multiplexer");
    6766
     
    7574        if(!f[i])
    7675            return 1;
    77         cucul_printf(cv, (w + 2) * (i / 2) + 1,
     76        caca_printf(cv, (w + 2) * (i / 2) + 1,
    7877                         (h + 2) * ((i % 2) + 1), "%s", argv[i + 1]);
    7978    }
     
    8988        for(i = 0; i < 4; i++)
    9089        {
    91             bytes[i] = cucul_import_memory(app, buf[i], total[i], "caca");
     90            bytes[i] = caca_import_memory(app, buf[i], total[i], "caca");
    9291
    9392            if(bytes[i] > 0)
     
    9695                memmove(buf[i], buf[i] + bytes[i], total[i]);
    9796
    98                 cucul_blit(cv, (w + 2) * (i / 2) + 1,
     97                caca_blit(cv, (w + 2) * (i / 2) + 1,
    9998                               (h + 2) * (i % 2) + 2, app, NULL);
    10099                caca_refresh_display(dp);
     
    116115    /* Clean up */
    117116    caca_free_display(dp);
    118     cucul_free_canvas(cv);
    119     cucul_free_canvas(app);
     117    caca_free_canvas(cv);
     118    caca_free_canvas(app);
    120119
    121120    return 0;
  • libcaca/trunk/examples/text.c

    r2305 r2821  
    2121#endif
    2222
    23 #include "cucul.h"
     23#include "caca.h"
    2424
    2525#define STRING \
     
    3636int main(int argc, char *argv[])
    3737{
    38     cucul_canvas_t *cv, *pig;
     38    caca_canvas_t *cv, *pig;
    3939    void *buffer;
    4040    size_t len;
    4141    int i, j;
    4242
    43     pig = cucul_create_canvas(0, 0);
    44     cucul_import_memory(pig, STRING, strlen(STRING), "text");
     43    pig = caca_create_canvas(0, 0);
     44    caca_import_memory(pig, STRING, strlen(STRING), "text");
    4545
    46     cv = cucul_create_canvas(cucul_get_canvas_width(pig) * 2,
    47                              cucul_get_canvas_height(pig) * 2);
     46    cv = caca_create_canvas(caca_get_canvas_width(pig) * 2,
     47                             caca_get_canvas_height(pig) * 2);
    4848
    4949    if(cv == NULL || pig == NULL)
     
    5353    }
    5454
    55     cucul_blit(cv, 0, 0, pig, NULL);
    56     cucul_flip(pig);
    57     cucul_blit(cv, cucul_get_canvas_width(pig), 0, pig, NULL);
    58     cucul_flip(pig);
    59     cucul_flop(pig);
    60     cucul_blit(cv, 0, cucul_get_canvas_height(pig), pig, NULL);
    61     cucul_flop(pig);
    62     cucul_rotate_180(pig);
    63     cucul_blit(cv, cucul_get_canvas_width(pig),
    64                    cucul_get_canvas_height(pig), pig, NULL);
     55    caca_blit(cv, 0, 0, pig, NULL);
     56    caca_flip(pig);
     57    caca_blit(cv, caca_get_canvas_width(pig), 0, pig, NULL);
     58    caca_flip(pig);
     59    caca_flop(pig);
     60    caca_blit(cv, 0, caca_get_canvas_height(pig), pig, NULL);
     61    caca_flop(pig);
     62    caca_rotate_180(pig);
     63    caca_blit(cv, caca_get_canvas_width(pig),
     64                   caca_get_canvas_height(pig), pig, NULL);
    6565
    66     for(j = 0; j < cucul_get_canvas_height(cv); j++)
     66    for(j = 0; j < caca_get_canvas_height(cv); j++)
    6767    {
    68         for(i = 0; i < cucul_get_canvas_width(cv); i += 2)
     68        for(i = 0; i < caca_get_canvas_width(cv); i += 2)
    6969        {
    7070            unsigned long int a;
    71             cucul_set_color_ansi(cv, CUCUL_LIGHTBLUE + (i + j) % 6,
    72                                  CUCUL_DEFAULT);
    73             a = cucul_get_attr(cv, -1, -1);
    74             cucul_put_attr(cv, i, j, a);
    75             cucul_put_attr(cv, i + 1, j, a);
     71            caca_set_color_ansi(cv, CACA_LIGHTBLUE + (i + j) % 6,
     72                                 CACA_DEFAULT);
     73            a = caca_get_attr(cv, -1, -1);
     74            caca_put_attr(cv, i, j, a);
     75            caca_put_attr(cv, i + 1, j, a);
    7676        }
    7777    }
    7878
    79     buffer = cucul_export_memory(cv, "utf8", &len);
     79    buffer = caca_export_memory(cv, "utf8", &len);
    8080    fwrite(buffer, len, 1, stdout);
    8181    free(buffer);
    8282
    83     cucul_rotate_left(cv);
    84     buffer = cucul_export_memory(cv, "utf8", &len);
     83    caca_rotate_left(cv);
     84    buffer = caca_export_memory(cv, "utf8", &len);
    8585    fwrite(buffer, len, 1, stdout);
    8686    free(buffer);
    8787
    88     cucul_free_canvas(pig);
    89     cucul_free_canvas(cv);
     88    caca_free_canvas(pig);
     89    caca_free_canvas(cv);
    9090
    9191    return 0;
  • libcaca/trunk/examples/transform.c

    r2299 r2821  
    2020#endif
    2121
    22 #include "cucul.h"
    2322#include "caca.h"
    2423
     
    4039int main(int argc, char *argv[])
    4140{
    42     cucul_canvas_t *cv, *image, *tmp, *sprite;
     41    caca_canvas_t *cv, *image, *tmp, *sprite;
    4342    caca_display_t *dp;
    4443
    45     cv = cucul_create_canvas(0, 0);
     44    cv = caca_create_canvas(0, 0);
    4645    if(cv == NULL)
    4746    {
     
    5655    }
    5756
    58     image = cucul_create_canvas(70, 6);
    59     tmp = cucul_create_canvas(70, 6);
    60     sprite = cucul_create_canvas(0, 0);
     57    image = caca_create_canvas(70, 6);
     58    tmp = caca_create_canvas(70, 6);
     59    sprite = caca_create_canvas(0, 0);
    6160
    62     cucul_set_color_ansi(sprite, CUCUL_LIGHTMAGENTA, CUCUL_BLACK);
    63     cucul_import_memory(sprite, pig, strlen(pig), "text");
    64     cucul_blit(image, 55, 0, sprite, NULL);
     61    caca_set_color_ansi(sprite, CACA_LIGHTMAGENTA, CACA_BLACK);
     62    caca_import_memory(sprite, pig, strlen(pig), "text");
     63    caca_blit(image, 55, 0, sprite, NULL);
    6564
    66     cucul_set_color_ansi(sprite, CUCUL_LIGHTGREEN, CUCUL_BLACK);
    67     cucul_import_memory(sprite, duck, strlen(duck), "text");
    68     cucul_blit(image, 30, 1, sprite, NULL);
     65    caca_set_color_ansi(sprite, CACA_LIGHTGREEN, CACA_BLACK);
     66    caca_import_memory(sprite, duck, strlen(duck), "text");
     67    caca_blit(image, 30, 1, sprite, NULL);
    6968
    70     cucul_set_color_ansi(image, CUCUL_LIGHTCYAN, CUCUL_BLACK);
    71     cucul_put_str(image, 1, 1, "hahaha mais vieux porc immonde !! [⽼ ⾗]");
    72     cucul_set_color_ansi(image, CUCUL_LIGHTRED, CUCUL_BLACK);
    73     cucul_put_char(image, 38, 1, '|');
     69    caca_set_color_ansi(image, CACA_LIGHTCYAN, CACA_BLACK);
     70    caca_put_str(image, 1, 1, "hahaha mais vieux porc immonde !! [⽼ ⾗]");
     71    caca_set_color_ansi(image, CACA_LIGHTRED, CACA_BLACK);
     72    caca_put_char(image, 38, 1, '|');
    7473
    75     cucul_set_color_ansi(image, CUCUL_YELLOW, CUCUL_BLACK);
    76     cucul_put_str(image, 4, 2, "\\o\\ \\o| _o/ \\o_ |o/ /o/");
     74    caca_set_color_ansi(image, CACA_YELLOW, CACA_BLACK);
     75    caca_put_str(image, 4, 2, "\\o\\ \\o| _o/ \\o_ |o/ /o/");
    7776
    78     cucul_set_color_ansi(image, CUCUL_WHITE, CUCUL_LIGHTRED);
    79     cucul_put_str(image, 7, 3, "▙▘▌▙▘▞▖▞▖▌ ▞▖▌ ▌▌");
    80     cucul_put_str(image, 7, 4, "▛▖▌▛▖▚▘▚▘▚▖▚▘▚▖▖▖");
    81     cucul_set_color_ansi(image, CUCUL_BLACK, CUCUL_LIGHTRED);
    82     cucul_put_str(image, 4, 3, "▓▒░");
    83     cucul_put_str(image, 4, 4, "▓▒░");
    84     cucul_put_str(image, 24, 3, "░▒▓");
    85     cucul_put_str(image, 24, 4, "░▒▓");
     77    caca_set_color_ansi(image, CACA_WHITE, CACA_LIGHTRED);
     78    caca_put_str(image, 7, 3, "▙▘▌▙▘▞▖▞▖▌ ▞▖▌ ▌▌");
     79    caca_put_str(image, 7, 4, "▛▖▌▛▖▚▘▚▘▚▖▚▘▚▖▖▖");
     80    caca_set_color_ansi(image, CACA_BLACK, CACA_LIGHTRED);
     81    caca_put_str(image, 4, 3, "▓▒░");
     82    caca_put_str(image, 4, 4, "▓▒░");
     83    caca_put_str(image, 24, 3, "░▒▓");
     84    caca_put_str(image, 24, 4, "░▒▓");
    8685
    8786    /* Blit the transformed canvas onto the main canvas */
    88     cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLUE);
    89     cucul_put_str(cv, 0, 0, "normal");
    90     cucul_blit(cv, 10, 0, image, NULL);
     87    caca_set_color_ansi(cv, CACA_WHITE, CACA_BLUE);
     88    caca_put_str(cv, 0, 0, "normal");
     89    caca_blit(cv, 10, 0, image, NULL);
    9190
    92     cucul_put_str(cv, 0, 6, "flip");
    93     cucul_blit(tmp, 0, 0, image, NULL);
    94     cucul_flip(tmp);
    95     cucul_blit(cv, 10, 6, tmp, NULL);
     91    caca_put_str(cv, 0, 6, "flip");
     92    caca_blit(tmp, 0, 0, image, NULL);
     93    caca_flip(tmp);
     94    caca_blit(cv, 10, 6, tmp, NULL);
    9695
    97     cucul_put_str(cv, 0, 12, "flop");
    98     cucul_blit(tmp, 0, 0, image, NULL);
    99     cucul_flop(tmp);
    100     cucul_blit(cv, 10, 12, tmp, NULL);
     96    caca_put_str(cv, 0, 12, "flop");
     97    caca_blit(tmp, 0, 0, image, NULL);
     98    caca_flop(tmp);
     99    caca_blit(cv, 10, 12, tmp, NULL);
    101100
    102     cucul_put_str(cv, 0, 18, "rotate");
    103     cucul_blit(tmp, 0, 0, image, NULL);
    104     cucul_rotate_180(tmp);
    105     cucul_blit(cv, 10, 18, tmp, NULL);
     101    caca_put_str(cv, 0, 18, "rotate");
     102    caca_blit(tmp, 0, 0, image, NULL);
     103    caca_rotate_180(tmp);
     104    caca_blit(cv, 10, 18, tmp, NULL);
    106105
    107106    caca_refresh_display(dp);
     
    110109
    111110    caca_free_display(dp);
    112     cucul_free_canvas(tmp);
    113     cucul_free_canvas(sprite);
    114     cucul_free_canvas(image);
    115     cucul_free_canvas(cv);
     111    caca_free_canvas(tmp);
     112    caca_free_canvas(sprite);
     113    caca_free_canvas(image);
     114    caca_free_canvas(cv);
    116115
    117116    return 0;
  • libcaca/trunk/examples/truecolor.c

    r2299 r2821  
    1919#endif
    2020
    21 #include "cucul.h"
    2221#include "caca.h"
    2322
    2423int main(int argc, char *argv[])
    2524{
    26     cucul_canvas_t *cv;
     25    caca_canvas_t *cv;
    2726    caca_display_t *dp;
    2827
    2928    int x, y;
    3029
    31     cv = cucul_create_canvas(32, 16);
     30    cv = caca_create_canvas(32, 16);
    3231    if(cv == NULL)
    3332    {
     
    4948        uint16_t fgcolor = 0xf000 | ((15 - y) << 4) | ((15 - x) << 8);
    5049
    51         cucul_set_color_argb(cv, fgcolor, bgcolor);
    52         cucul_put_str(cv, x * 2, y, "CA");
     50        caca_set_color_argb(cv, fgcolor, bgcolor);
     51        caca_put_str(cv, x * 2, y, "CA");
    5352    }
    5453
    55     cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_LIGHTBLUE);
    56     cucul_put_str(cv, 2, 1, " truecolor libcaca ");
     54    caca_set_color_ansi(cv, CACA_WHITE, CACA_LIGHTBLUE);
     55    caca_put_str(cv, 2, 1, " truecolor libcaca ");
    5756
    5857    caca_refresh_display(dp);
     
    6160
    6261    caca_free_display(dp);
    63     cucul_free_canvas(cv);
     62    caca_free_canvas(cv);
    6463
    6564    return 0;
  • libcaca/trunk/examples/unicode.c

    r2299 r2821  
    1919#endif
    2020
    21 #include "cucul.h"
    2221#include "caca.h"
    2322
    2423int main(int argc, char *argv[])
    2524{
    26     cucul_canvas_t *cv;
     25    caca_canvas_t *cv;
    2726    caca_display_t *dp;
    2827
    29     cv = cucul_create_canvas(0, 0);
     28    cv = caca_create_canvas(0, 0);
    3029    if(cv == NULL)
    3130    {
     
    3938        return -1;
    4039    }
    41     cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLUE);
    42     cucul_put_str(cv, 1, 1, "Basic Unicode support");
     40    caca_set_color_ansi(cv, CACA_WHITE, CACA_BLUE);
     41    caca_put_str(cv, 1, 1, "Basic Unicode support");
    4342
    44     cucul_set_color_ansi(cv, CUCUL_DEFAULT, CUCUL_TRANSPARENT);
    45     cucul_put_str(cv, 1, 2, "This is ASCII:    | abc DEF 123 !@# |");
    46     cucul_put_str(cv, 1, 3, "This is Unicode:  | äßç δεφ ☺♥♀ ╞╬╗ |");
    47     cucul_put_str(cv, 1, 4, "And this is, too: | ἀβϛ ΔЗҒ ᚴᛒᛯ ♩♔✈ |");
     43    caca_set_color_ansi(cv, CACA_DEFAULT, CACA_TRANSPARENT);
     44    caca_put_str(cv, 1, 2, "This is ASCII:    | abc DEF 123 !@# |");
     45    caca_put_str(cv, 1, 3, "This is Unicode:  | äßç δεφ ☺♥♀ ╞╬╗ |");
     46    caca_put_str(cv, 1, 4, "And this is, too: | ἀβϛ ΔЗҒ ᚴᛒᛯ ♩♔✈ |");
    4847
    49     cucul_put_str(cv, 1, 5, "If the three lines do not have the same length, there is a bug somewhere.");
     48    caca_put_str(cv, 1, 5, "If the three lines do not have the same length, there is a bug somewhere.");
    5049
    51     cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLUE);
    52     cucul_put_str(cv, 1, 7, "Gradient glyphs");
     50    caca_set_color_ansi(cv, CACA_WHITE, CACA_BLUE);
     51    caca_put_str(cv, 1, 7, "Gradient glyphs");
    5352
    54     cucul_set_color_ansi(cv, CUCUL_DEFAULT, CUCUL_TRANSPARENT);
    55     cucul_put_str(cv, 31,  8, "  0%");
    56     cucul_put_str(cv, 31,  9, " 25%");
    57     cucul_put_str(cv, 31, 10, " 50%");
    58     cucul_put_str(cv, 31, 11, " 75%");
    59     cucul_put_str(cv, 31, 12, "100%");
     53    caca_set_color_ansi(cv, CACA_DEFAULT, CACA_TRANSPARENT);
     54    caca_put_str(cv, 31,  8, "  0%");
     55    caca_put_str(cv, 31,  9, " 25%");
     56    caca_put_str(cv, 31, 10, " 50%");
     57    caca_put_str(cv, 31, 11, " 75%");
     58    caca_put_str(cv, 31, 12, "100%");
    6059
    61     cucul_set_color_ansi(cv, CUCUL_LIGHTRED, CUCUL_LIGHTGREEN);
    62     cucul_put_str(cv, 1,  8, "                             ");
    63     cucul_put_str(cv, 1,  9, "░░░░░░░░░░░░░░░░░░░░░░░░░░░░░");
    64     cucul_put_str(cv, 1, 10, "▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒");
    65     cucul_put_str(cv, 1, 11, "▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓");
    66     cucul_put_str(cv, 1, 12, "█████████████████████████████");
     60    caca_set_color_ansi(cv, CACA_LIGHTRED, CACA_LIGHTGREEN);
     61    caca_put_str(cv, 1,  8, "                             ");
     62    caca_put_str(cv, 1,  9, "░░░░░░░░░░░░░░░░░░░░░░░░░░░░░");
     63    caca_put_str(cv, 1, 10, "▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒");
     64    caca_put_str(cv, 1, 11, "▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓");
     65    caca_put_str(cv, 1, 12, "█████████████████████████████");
    6766
    68     cucul_set_color_ansi(cv, CUCUL_LIGHTGREEN, CUCUL_LIGHTRED);
    69     cucul_put_str(cv, 36,  8, "█████████████████████████████");
    70     cucul_put_str(cv, 36,  9, "▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓");
    71     cucul_put_str(cv, 36, 10, "▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒");
    72     cucul_put_str(cv, 36, 11, "░░░░░░░░░░░░░░░░░░░░░░░░░░░░░");
    73     cucul_put_str(cv, 36, 12, "                             ");
     67    caca_set_color_ansi(cv, CACA_LIGHTGREEN, CACA_LIGHTRED);
     68    caca_put_str(cv, 36,  8, "█████████████████████████████");
     69    caca_put_str(cv, 36,  9, "▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓");
     70    caca_put_str(cv, 36, 10, "▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒");
     71    caca_put_str(cv, 36, 11, "░░░░░░░░░░░░░░░░░░░░░░░░░░░░░");
     72    caca_put_str(cv, 36, 12, "                             ");
    7473
    75     cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLUE);
    76     cucul_put_str(cv, 1, 14, "Double width characters");
     74    caca_set_color_ansi(cv, CACA_WHITE, CACA_BLUE);
     75    caca_put_str(cv, 1, 14, "Double width characters");
    7776
    78     cucul_set_color_ansi(cv, CUCUL_LIGHTRED, CUCUL_TRANSPARENT);
    79     cucul_put_str(cv, 1, 15, "| ドラゴン ボーレ |");
    80     cucul_set_color_ansi(cv, CUCUL_DEFAULT, CUCUL_TRANSPARENT);
    81     cucul_put_str(cv, 1, 16, "| ()()()() ()()() |");
    82     cucul_set_color_ansi(cv, CUCUL_YELLOW, CUCUL_TRANSPARENT);
    83     cucul_put_str(cv, 1, 17, "| ドラゴン");
    84     cucul_put_str(cv, 12, 17, "ボーレ |");
     77    caca_set_color_ansi(cv, CACA_LIGHTRED, CACA_TRANSPARENT);
     78    caca_put_str(cv, 1, 15, "| ドラゴン ボーレ |");
     79    caca_set_color_ansi(cv, CACA_DEFAULT, CACA_TRANSPARENT);
     80    caca_put_str(cv, 1, 16, "| ()()()() ()()() |");
     81    caca_set_color_ansi(cv, CACA_YELLOW, CACA_TRANSPARENT);
     82    caca_put_str(cv, 1, 17, "| ドラゴン");
     83    caca_put_str(cv, 12, 17, "ボーレ |");
    8584
    86     cucul_set_color_ansi(cv, CUCUL_DEFAULT, CUCUL_TRANSPARENT);
    87     cucul_put_str(cv, 1, 18, "If the three lines do not have the same length, there is a bug somewhere.");
     85    caca_set_color_ansi(cv, CACA_DEFAULT, CACA_TRANSPARENT);
     86    caca_put_str(cv, 1, 18, "If the three lines do not have the same length, there is a bug somewhere.");
    8887
    89     cucul_put_str(cv, 1, 20, "CP437 glyphs: ☺ ☻ ♥ ♦ ♣ ♠ • ◘ ○ ◙ ♂ ♀ ♪ ♫ ☼ ► ◄ ↕ ‼ ¶ § ▬ ↨ ↑ ↓ → ← ∟ ↔ ▲ ▼");
    90     cucul_put_str(cv, 1, 21, "more CP437: α ß Γ π Σ σ µ τ Φ Θ Ω δ ∞ φ ε ∩ ≡ ± ≥ ≤ ⌠ ⌡ ÷ ≈ ° ∙ · √ ⁿ ² ■");
    91     cucul_put_str(cv, 1, 22, "drawing blocks: ███ ▓▓▓ ▒▒▒ ░░░ ▀ ▄ ▌ ▐ █ ▖ ▗ ▘ ▝ ▚ ▞ ▙ ▛ ▜ ▟ ─ │ ┌ ┐ └ ┘ ├ ┤");
    92     cucul_put_str(cv, 1, 23, "more drawing: ┬ ┴ ┼ ═ ║ ╒ ╓ ╔ ╕ ╖ ╗ ╘ ╙ ╚ ╛ ╜ ╝ ╞ ╟ ╠ ╡ ╢ ╣ ╤ ╥ ╦ ╧ ╨ ╩ ╪ ╫ ╬");
    93     cucul_put_str(cv, 1, 24, "misc Unicode: ● ☭ ☮ ☯ ♔ ♛ ♙ ♞ ⚒ ⚓ ⚠");
     88    caca_put_str(cv, 1, 20, "CP437 glyphs: ☺ ☻ ♥ ♦ ♣ ♠ • ◘ ○ ◙ ♂ ♀ ♪ ♫ ☼ ► ◄ ↕ ‼ ¶ § ▬ ↨ ↑ ↓ → ← ∟ ↔ ▲ ▼");
     89    caca_put_str(cv, 1, 21, "more CP437: α ß Γ π Σ σ µ τ Φ Θ Ω δ ∞ φ ε ∩ ≡ ± ≥ ≤ ⌠ ⌡ ÷ ≈ ° ∙ · √ ⁿ ² ■");
     90    caca_put_str(cv, 1, 22, "drawing blocks: ███ ▓▓▓ ▒▒▒ ░░░ ▀ ▄ ▌ ▐ █ ▖ ▗ ▘ ▝ ▚ ▞ ▙ ▛ ▜ ▟ ─ │ ┌ ┐ └ ┘ ├ ┤");
     91    caca_put_str(cv, 1, 23, "more drawing: ┬ ┴ ┼ ═ ║ ╒ ╓ ╔ ╕ ╖ ╗ ╘ ╙ ╚ ╛ ╜ ╝ ╞ ╟ ╠ ╡ ╢ ╣ ╤ ╥ ╦ ╧ ╨ ╩ ╪ ╫ ╬");
     92    caca_put_str(cv, 1, 24, "misc Unicode: ● ☭ ☮ ☯ ♔ ♛ ♙ ♞ ⚒ ⚓ ⚠");
    9493
    9594    caca_refresh_display(dp);
     
    9897
    9998    caca_free_display(dp);
    100     cucul_free_canvas(cv);
     99    caca_free_canvas(cv);
    101100
    102101    return 0;
Note: See TracChangeset for help on using the changeset viewer.