Ignore:
Timestamp:
Sep 27, 2008, 3:12:46 PM (12 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/cxx
Files:
6 edited

Legend:

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

    r2424 r2821  
    11# $Id: Makefile.am 552 2006-04-13 16:10:16Z jylam $
    22
    3 AM_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/cucul -I../cucul \
    4               -I$(top_srcdir)/caca
     3AM_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/caca -I../caca
    54
    65if USE_CXX
    7 pkgconfig_DATA = cucul++.pc caca++.pc
     6pkgconfig_DATA = caca++.pc
    87pkgconfigdir = $(libdir)/pkgconfig
    98
    10 include_HEADERS = cucul++.h caca++.h
    11 lib_LTLIBRARIES = libcucul++.la libcaca++.la
     9include_HEADERS = caca++.h
     10lib_LTLIBRARIES = libcaca++.la
    1211endif
    1312
    14 libcucul___la_SOURCES = cucul++.cpp cucul++.h
    15 libcucul___la_LDFLAGS = -no-undefined -version-number @LT_VERSION@
    16 libcucul___la_LIBADD = ../cucul/libcucul.la
    17 
    18 libcaca___la_SOURCES = caca++.cpp caca++.h
     13libcaca___la_SOURCES = caca++.cpp cucul++.cpp caca++.h
    1914libcaca___la_LDFLAGS = -no-undefined -version-number @LT_VERSION@
    20 libcaca___la_LIBADD = libcucul++.la ../caca/libcaca.la
     15libcaca___la_LIBADD = ../caca/libcaca.la
    2116
    2217if USE_CXX
     
    2520
    2621cxxtest_SOURCES = cxxtest.cpp
    27 cxxtest_LDADD = libcaca++.la libcucul++.la ../caca/libcaca.la ../cucul/libcucul.la
     22cxxtest_LDADD = libcaca++.la ../caca/libcaca.la
    2823
  • libcaca/trunk/cxx/caca++.cpp

    r2191 r2821  
    2525#include "caca++.h"
    2626
    27 Caca::Caca(Cucul *cv)
     27Caca::Caca(Canvas *cv)
    2828{
    29     dp = caca_create_display(cv->get_cucul_canvas_t());
     29    dp = caca_create_display(cv->get_caca_canvas_t());
    3030    if(!dp)
    3131        throw -1;
     
    3737}
    3838
    39 void Caca::Attach(Cucul *cv)
     39void Caca::Attach(Canvas *cv)
    4040{
    41     dp = caca_create_display(cv->get_cucul_canvas_t());
     41    dp = caca_create_display(cv->get_caca_canvas_t());
    4242    if(!dp)
    4343        throw -1;
  • libcaca/trunk/cxx/caca++.h

    r2074 r2821  
    2424#define _CACA_PP_H
    2525
    26 #include <cucul.h>
    2726#include <caca.h>
    28 
     27#include <caca++.h>
    2928#include <cucul++.h>
    3029
     
    6261 public:
    6362    Caca();
    64     Caca(Cucul *cv);
     63    Caca(Canvas *cv);
    6564    ~Caca();
    6665
    67     void Attach(Cucul *cv);
     66    void Attach(Canvas *cv);
    6867    void Detach();
    6968    void setDisplayTime(unsigned int);
  • libcaca/trunk/cxx/cucul++.cpp

    r2321 r2821  
    11/*
    2  *  libcucul++    C++ bindings for libcucul
     2 *  libcaca++    C++ bindings for libcaca
    33 *  Copyright (c) 2006 Jean-Yves Lamoureux <jylam@lnxscene.org>
    44 *                All Rights Reserved
     
    1414
    1515/*
    16  *  This file contains the main functions used by \e libcucul++ applications
     16 *  This file contains the main functions used by \e libcaca++ applications
    1717 *  to initialise a drawing context.
    1818 */
     
    2323#include <stdarg.h> // va_*
    2424
    25 #include "cucul++.h"
     25#include "caca++.h"
    2626
    2727
    2828uint32_t Charset::utf8ToUtf32(char const *s, size_t *read)
    2929{
    30     return cucul_utf8_to_utf32(s, read);
     30    return caca_utf8_to_utf32(s, read);
    3131}
    3232size_t Charset::utf32ToUtf8(char *buf, uint32_t ch)
    3333{
    34     return cucul_utf32_to_utf8(buf, ch);
     34    return caca_utf32_to_utf8(buf, ch);
    3535}
    3636uint8_t Charset::utf32ToCp437(uint32_t ch)
    3737{
    38     return cucul_utf32_to_cp437(ch);
     38    return caca_utf32_to_cp437(ch);
    3939}
    4040uint32_t Charset::cp437ToUtf32(uint8_t ch)
    4141{
    42     return cucul_cp437_to_utf32(ch);
    43 }
    44 
    45 
    46 Cucul::Cucul()
    47 {
    48     cv = cucul_create_canvas(0, 0);
     42    return caca_cp437_to_utf32(ch);
     43}
     44
     45
     46Canvas::Canvas()
     47{
     48    cv = caca_create_canvas(0, 0);
    4949    if(!cv)
    5050        throw -1;
    5151}
    5252
    53 Cucul::Cucul(int width, int height)
    54 {
    55     cv = cucul_create_canvas(width, height);
     53Canvas::Canvas(int width, int height)
     54{
     55    cv = caca_create_canvas(width, height);
    5656    if(!cv) throw -1;
    5757}
    5858
    59 Cucul::~Cucul()
     59Canvas::~Canvas()
    6060{
    6161    if(cv)
    62         cucul_free_canvas(cv);
    63 }
    64 
    65 cucul_canvas_t *Cucul::get_cucul_canvas_t()
     62        caca_free_canvas(cv);
     63}
     64
     65caca_canvas_t *Canvas::get_caca_canvas_t()
    6666{
    6767    return cv;
    6868}
    6969
    70 void Cucul::setSize(unsigned int width, unsigned int height)
    71 {
    72     cucul_set_canvas_size(cv, width, height);
    73 }
    74 
    75 unsigned int Cucul::getWidth(void)
    76 {
    77     return cucul_get_canvas_width(cv);
    78 }
    79 
    80 unsigned int Cucul::getHeight(void)
    81 {
    82     return cucul_get_canvas_height(cv);
    83 }
    84 
    85 int Cucul::setColorANSI(uint8_t f, uint8_t b)
    86 {
    87     return cucul_set_color_ansi(cv, f, b);
    88 }
    89 
    90 int  Cucul::setColorARGB(unsigned int f, unsigned int b)
    91 {
    92     return cucul_set_color_argb(cv, f, b);
    93 }
    94 
    95 void Cucul::putChar(int x, int y, uint32_t ch)
    96 {
    97     cucul_put_char(cv, x, y, ch);
    98 }
    99 
    100 uint32_t Cucul::getChar(int x, int y)
    101 {
    102     return cucul_get_char(cv, x, y);
    103 }
    104 
    105 void Cucul::putStr(int x, int y, char *str)
    106 {
    107     cucul_put_str(cv, x, y, str);
    108 }
    109 
    110 void Cucul::Printf(int x, int y, char const * format, ...)
     70void Canvas::setSize(unsigned int width, unsigned int height)
     71{
     72    caca_set_canvas_size(cv, width, height);
     73}
     74
     75unsigned int Canvas::getWidth(void)
     76{
     77    return caca_get_canvas_width(cv);
     78}
     79
     80unsigned int Canvas::getHeight(void)
     81{
     82    return caca_get_canvas_height(cv);
     83}
     84
     85int Canvas::setColorANSI(uint8_t f, uint8_t b)
     86{
     87    return caca_set_color_ansi(cv, f, b);
     88}
     89
     90int  Canvas::setColorARGB(unsigned int f, unsigned int b)
     91{
     92    return caca_set_color_argb(cv, f, b);
     93}
     94
     95void Canvas::putChar(int x, int y, uint32_t ch)
     96{
     97    caca_put_char(cv, x, y, ch);
     98}
     99
     100uint32_t Canvas::getChar(int x, int y)
     101{
     102    return caca_get_char(cv, x, y);
     103}
     104
     105void Canvas::putStr(int x, int y, char *str)
     106{
     107    caca_put_str(cv, x, y, str);
     108}
     109
     110void Canvas::Printf(int x, int y, char const * format, ...)
    111111{
    112112    char tmp[BUFSIZ];
     
    126126}
    127127
    128 void Cucul::Clear(void)
    129 {
    130     cucul_clear_canvas(cv);
    131 }
    132 
    133 void Cucul::Blit(int x, int y, Cucul* c1, Cucul* c2)
    134 {
    135     cucul_blit(cv, x, y, c1->get_cucul_canvas_t(),
    136                          c2 ? c2->get_cucul_canvas_t() : NULL);
    137 }
    138 
    139 void Cucul::Invert()
    140 {
    141     cucul_invert(cv);
    142 }
    143 
    144 void Cucul::Flip()
    145 {
    146     cucul_flip(cv);
    147 }
    148 
    149 void Cucul::Flop()
    150 {
    151     cucul_flop(cv);
    152 }
    153 
    154 void Cucul::Rotate180()
    155 {
    156     cucul_rotate_180(cv);
    157 }
    158 
    159 void Cucul::RotateLeft()
    160 {
    161     cucul_rotate_left(cv);
    162 }
    163 
    164 void Cucul::RotateRight()
    165 {
    166     cucul_rotate_right(cv);
    167 }
    168 
    169 void Cucul::drawLine(int x1, int y1, int x2, int y2, uint32_t ch)
    170 {
    171     cucul_draw_line(cv, x1, y1, x2, y2, ch);
    172 }
    173 
    174 void Cucul::drawPolyline(int const x[], int const y[], int f, uint32_t ch)
    175 {
    176     cucul_draw_polyline(cv, x, y, f, ch);
    177 }
    178 
    179 void Cucul::drawThinLine(int x1, int y1, int x2, int y2)
    180 {
    181     cucul_draw_thin_line(cv, x1, y1, x2, y2);
    182 }
    183 
    184 void Cucul::drawThinPolyline(int const x[], int const y[], int f)
    185 {
    186     cucul_draw_thin_polyline(cv, x, y, f);
    187 }
    188 
    189 void Cucul::drawCircle(int x, int y, int d, uint32_t ch)
    190 {
    191     cucul_draw_circle(cv, x, y, d, ch);
    192 }
    193 
    194 void Cucul::drawEllipse(int x, int y, int d1, int d2, uint32_t ch)
    195 {
    196     cucul_draw_ellipse(cv, x, y, d1, d2, ch);
    197 }
    198 
    199 void Cucul::drawThinEllipse(int x, int y, int d1, int d2)
    200 {
    201     cucul_draw_thin_ellipse(cv, x, y, d1, d2);
    202 }
    203 
    204 void Cucul::fillEllipse(int x, int y, int d1, int d2, uint32_t ch)
    205 {
    206     cucul_fill_ellipse(cv, x, y, d1, d2, ch);
    207 }
    208 
    209 void Cucul::drawBox(int x, int y, int w, int h, uint32_t ch)
    210 {
    211     cucul_draw_box(cv, x, y, w, h, ch);
    212 }
    213 
    214 void Cucul::drawThinBox(int x, int y, int w, int h)
    215 {
    216     cucul_draw_thin_box(cv, x, y, w, h);
    217 }
    218 
    219 void Cucul::drawCP437Box(int x, int y, int w, int h)
    220 {
    221     cucul_draw_cp437_box(cv, x, y, w, h);
    222 }
    223 
    224 void Cucul::fillBox(int x, int y, int w, int h, uint32_t ch)
    225 {
    226     cucul_fill_box(cv, x, y, w, h, ch);
    227 }
    228 
    229 void Cucul::drawTriangle(int x1, int y1, int x2, int y2, int x3, int y3, uint32_t ch)
    230 {
    231     cucul_draw_triangle(cv, x1, y1, x2, y2, x3, y3, ch);
    232 }
    233 
    234 void Cucul::drawThinTriangle(int x1, int y1, int x2, int y2, int x3, int y3)
    235 {
    236     cucul_draw_thin_triangle(cv, x1, y1, x2, y2, x3, y3);
    237 }
    238 
    239 void Cucul::fillTriangle(int x1, int y1, int x2, int y2, int x3, int y3, uint32_t ch)
    240 {
    241     cucul_fill_triangle(cv, x1, y1, x2, y2, x3, y3, ch);
    242 }
    243 
    244 int Cucul::Rand(int min, int max)
    245 {
    246     return cucul_rand(min, max);
    247 }
    248 
    249 const char * Cucul::getVersion()
    250 {
    251     return cucul_get_version();
    252 }
    253 
    254 int Cucul::setAttr(uint32_t attr)
    255 {
    256     return cucul_set_attr(cv, attr);
    257 }
    258 
    259 uint32_t Cucul::getAttr(int x, int y)
    260 {
    261     return cucul_get_attr(cv, x, y);
    262 }
    263 
    264 int Cucul::setBoundaries(cucul_canvas_t *, int x, int y,
     128void Canvas::Clear(void)
     129{
     130    caca_clear_canvas(cv);
     131}
     132
     133void Canvas::Blit(int x, int y, Canvas* c1, Canvas* c2)
     134{
     135    caca_blit(cv, x, y, c1->get_caca_canvas_t(),
     136                         c2 ? c2->get_caca_canvas_t() : NULL);
     137}
     138
     139void Canvas::Invert()
     140{
     141    caca_invert(cv);
     142}
     143
     144void Canvas::Flip()
     145{
     146    caca_flip(cv);
     147}
     148
     149void Canvas::Flop()
     150{
     151    caca_flop(cv);
     152}
     153
     154void Canvas::Rotate180()
     155{
     156    caca_rotate_180(cv);
     157}
     158
     159void Canvas::RotateLeft()
     160{
     161    caca_rotate_left(cv);
     162}
     163
     164void Canvas::RotateRight()
     165{
     166    caca_rotate_right(cv);
     167}
     168
     169void Canvas::drawLine(int x1, int y1, int x2, int y2, uint32_t ch)
     170{
     171    caca_draw_line(cv, x1, y1, x2, y2, ch);
     172}
     173
     174void Canvas::drawPolyline(int const x[], int const y[], int f, uint32_t ch)
     175{
     176    caca_draw_polyline(cv, x, y, f, ch);
     177}
     178
     179void Canvas::drawThinLine(int x1, int y1, int x2, int y2)
     180{
     181    caca_draw_thin_line(cv, x1, y1, x2, y2);
     182}
     183
     184void Canvas::drawThinPolyline(int const x[], int const y[], int f)
     185{
     186    caca_draw_thin_polyline(cv, x, y, f);
     187}
     188
     189void Canvas::drawCircle(int x, int y, int d, uint32_t ch)
     190{
     191    caca_draw_circle(cv, x, y, d, ch);
     192}
     193
     194void Canvas::drawEllipse(int x, int y, int d1, int d2, uint32_t ch)
     195{
     196    caca_draw_ellipse(cv, x, y, d1, d2, ch);
     197}
     198
     199void Canvas::drawThinEllipse(int x, int y, int d1, int d2)
     200{
     201    caca_draw_thin_ellipse(cv, x, y, d1, d2);
     202}
     203
     204void Canvas::fillEllipse(int x, int y, int d1, int d2, uint32_t ch)
     205{
     206    caca_fill_ellipse(cv, x, y, d1, d2, ch);
     207}
     208
     209void Canvas::drawBox(int x, int y, int w, int h, uint32_t ch)
     210{
     211    caca_draw_box(cv, x, y, w, h, ch);
     212}
     213
     214void Canvas::drawThinBox(int x, int y, int w, int h)
     215{
     216    caca_draw_thin_box(cv, x, y, w, h);
     217}
     218
     219void Canvas::drawCP437Box(int x, int y, int w, int h)
     220{
     221    caca_draw_cp437_box(cv, x, y, w, h);
     222}
     223
     224void Canvas::fillBox(int x, int y, int w, int h, uint32_t ch)
     225{
     226    caca_fill_box(cv, x, y, w, h, ch);
     227}
     228
     229void Canvas::drawTriangle(int x1, int y1, int x2, int y2, int x3, int y3, uint32_t ch)
     230{
     231    caca_draw_triangle(cv, x1, y1, x2, y2, x3, y3, ch);
     232}
     233
     234void Canvas::drawThinTriangle(int x1, int y1, int x2, int y2, int x3, int y3)
     235{
     236    caca_draw_thin_triangle(cv, x1, y1, x2, y2, x3, y3);
     237}
     238
     239void Canvas::fillTriangle(int x1, int y1, int x2, int y2, int x3, int y3, uint32_t ch)
     240{
     241    caca_fill_triangle(cv, x1, y1, x2, y2, x3, y3, ch);
     242}
     243
     244int Canvas::Rand(int min, int max)
     245{
     246    return caca_rand(min, max);
     247}
     248
     249const char * Canvas::getVersion()
     250{
     251    return caca_get_version();
     252}
     253
     254int Canvas::setAttr(uint32_t attr)
     255{
     256    return caca_set_attr(cv, attr);
     257}
     258
     259uint32_t Canvas::getAttr(int x, int y)
     260{
     261    return caca_get_attr(cv, x, y);
     262}
     263
     264int Canvas::setBoundaries(caca_canvas_t *, int x, int y,
    265265                         unsigned int w, unsigned int h)
    266266{
    267     return cucul_set_canvas_boundaries(cv, x, y, h, w);
    268 }
    269 
    270 unsigned int Cucul::getFrameCount()
    271 {
    272     return cucul_get_frame_count(cv);
    273 }
    274 int Cucul::setFrame(unsigned int f)
    275 {
    276     return cucul_set_frame(cv, f);
    277 }
    278 int Cucul::createFrame(unsigned int f)
    279 {
    280     return cucul_create_frame(cv, f);
    281 }
    282 int Cucul::freeFrame(unsigned int f)
    283 {
    284     return cucul_create_frame(cv, f);
    285 }
    286 
    287 char const *const * Cucul::getImportList(void)
    288 {
    289     return cucul_get_import_list();
    290 }
    291 
    292 long int Cucul::importMemory(void const *buf, size_t len, char const *fmt)
    293 {
    294     return cucul_import_memory(cv, buf, len, fmt);
    295 }
    296 
    297 long int Cucul::importFile(char const *file, char const *fmt)
    298 {
    299     return cucul_import_file(cv, file, fmt);
    300 }
    301 
    302 char const *const * Cucul::getExportList(void)
    303 {
    304     return cucul_get_export_list();
    305 }
    306 
    307 void *Cucul::exportMemory(char const *fmt, size_t *len)
    308 {
    309     return cucul_export_memory(cv, fmt, len);
     267    return caca_set_canvas_boundaries(cv, x, y, h, w);
     268}
     269
     270unsigned int Canvas::getFrameCount()
     271{
     272    return caca_get_frame_count(cv);
     273}
     274int Canvas::setFrame(unsigned int f)
     275{
     276    return caca_set_frame(cv, f);
     277}
     278int Canvas::createFrame(unsigned int f)
     279{
     280    return caca_create_frame(cv, f);
     281}
     282int Canvas::freeFrame(unsigned int f)
     283{
     284    return caca_create_frame(cv, f);
     285}
     286
     287char const *const * Canvas::getImportList(void)
     288{
     289    return caca_get_import_list();
     290}
     291
     292long int Canvas::importMemory(void const *buf, size_t len, char const *fmt)
     293{
     294    return caca_import_memory(cv, buf, len, fmt);
     295}
     296
     297long int Canvas::importFile(char const *file, char const *fmt)
     298{
     299    return caca_import_file(cv, file, fmt);
     300}
     301
     302char const *const * Canvas::getExportList(void)
     303{
     304    return caca_get_export_list();
     305}
     306
     307void *Canvas::exportMemory(char const *fmt, size_t *len)
     308{
     309    return caca_export_memory(cv, fmt, len);
    310310}
    311311
    312312Dither::Dither(unsigned int v1, unsigned int v2, unsigned int v3, unsigned int v4, unsigned int v5, unsigned int v6, unsigned int v7, unsigned int v8)
    313313{
    314     dither = cucul_create_dither(v1, v2, v3, v4, v5, v6, v7, v8);
     314    dither = caca_create_dither(v1, v2, v3, v4, v5, v6, v7, v8);
    315315}
    316316Dither::~Dither()
    317317{
    318     cucul_free_dither(dither);
     318    caca_free_dither(dither);
    319319}
    320320
    321321void Dither::setPalette(uint32_t r[], uint32_t g[], uint32_t b[], uint32_t a[])
    322322{
    323     cucul_set_dither_palette(dither, r, g, b, a);
     323    caca_set_dither_palette(dither, r, g, b, a);
    324324}
    325325
    326326void Dither::setBrightness(float f)
    327327{
    328     cucul_set_dither_brightness(dither, f);
     328    caca_set_dither_brightness(dither, f);
    329329}
    330330
    331331void Dither::setGamma(float f)
    332332{
    333     cucul_set_dither_gamma(dither, f);
     333    caca_set_dither_gamma(dither, f);
    334334}
    335335
    336336void Dither::setContrast(float f)
    337337{
    338     cucul_set_dither_contrast(dither, f);
     338    caca_set_dither_contrast(dither, f);
    339339}
    340340
    341341void Dither::setAntialias(char const *cv)
    342342{
    343     cucul_set_dither_antialias(dither, cv);
     343    caca_set_dither_antialias(dither, cv);
    344344}
    345345
    346346char const *const * Dither::getAntialiasList()
    347347{
    348     return cucul_get_dither_antialias_list(dither);
     348    return caca_get_dither_antialias_list(dither);
    349349}
    350350
    351351void Dither::setColor(char const *cv)
    352352{
    353     cucul_set_dither_color(dither, cv);
     353    caca_set_dither_color(dither, cv);
    354354}
    355355
    356356char const *const * Dither::getColorList()
    357357{
    358     return cucul_get_dither_color_list(dither);
     358    return caca_get_dither_color_list(dither);
    359359}
    360360
    361361void Dither::setCharset(char const *cv)
    362362{
    363     cucul_set_dither_charset(dither, cv);
     363    caca_set_dither_charset(dither, cv);
    364364}
    365365
    366366char const *const * Dither::getCharsetList()
    367367{
    368     return cucul_get_dither_charset_list(dither);
     368    return caca_get_dither_charset_list(dither);
    369369}
    370370
    371371void Dither::setMode(char const *cv)
    372372{
    373     cucul_set_dither_algorithm(dither, cv);
     373    caca_set_dither_algorithm(dither, cv);
    374374}
    375375
    376376char const *const * Dither::getModeList(void)
    377377{
    378     return cucul_get_dither_algorithm_list(dither);
    379 }
    380 
    381 void Dither::Bitmap(Cucul *cv, int x, int y, int w, int h, void *v)
    382 {
    383     cucul_dither_bitmap(cv->get_cucul_canvas_t(), x, y, w, h, dither, v);
     378    return caca_get_dither_algorithm_list(dither);
     379}
     380
     381void Dither::Bitmap(Canvas *cv, int x, int y, int w, int h, void *v)
     382{
     383    caca_dither_bitmap(cv->get_caca_canvas_t(), x, y, w, h, dither, v);
    384384}
    385385
    386386Font::Font(void const *s, unsigned int v)
    387387{
    388     font = cucul_load_font(s, v);
     388    font = caca_load_font(s, v);
    389389    if(!font) throw -1;
    390390}
     
    392392char const *const * Font::getList(void)
    393393{
    394     return cucul_get_font_list();
     394    return caca_get_font_list();
    395395}
    396396
    397397unsigned int Font::getWidth()
    398398{
    399     return cucul_get_font_width(font);
     399    return caca_get_font_width(font);
    400400}
    401401
    402402unsigned int Font::getHeight()
    403403{
    404     return cucul_get_font_height(font);
    405 }
    406 
    407 void Font::renderCanvas(Cucul *cv, uint8_t *buf, unsigned int x, unsigned int y, unsigned int w)
    408 {
    409     cucul_render_canvas(cv->get_cucul_canvas_t(), font, buf, x, y, w);
     404    return caca_get_font_height(font);
     405}
     406
     407void Font::renderCanvas(Canvas *cv, uint8_t *buf, unsigned int x, unsigned int y, unsigned int w)
     408{
     409    caca_render_canvas(cv->get_caca_canvas_t(), font, buf, x, y, w);
    410410}
    411411
    412412uint32_t const *Font::getBlocks()
    413413{
    414     return cucul_get_font_blocks(font);
     414    return caca_get_font_blocks(font);
    415415}
    416416
    417417Font::~Font()
    418418{
    419     cucul_free_font(font);
    420 }
    421 
     419    caca_free_font(font);
     420}
     421
  • libcaca/trunk/cxx/cucul++.h

    r2321 r2821  
    11/*
    2  *  libcucul++    C++ bindings for libcucul
     2 *  libcaca++    C++ bindings for libcaca
    33 *  Copyright (c) 2006 Jean-Yves Lamoureux <jylam@lnxscene.org>
    44 *                All Rights Reserved
     
    1313 */
    1414
    15 /** \file cucul++.h
     15/** \file caca++.h
    1616 *  \version \$Id$
    1717 *  \author Jean-Yves Lamoureux <jylam@lnxscene.org>
    18  *  \brief The \e libcucul++ public header.
     18 *  \brief The \e libcaca++ public header.
    1919 *
    2020 *  This header contains the public types and functions that applications
    21  *  using \e libcucul++ may use.
     21 *  using \e libcaca++ may use.
    2222 */
    2323
     
    2525#define _CUCUL_PP_H
    2626
    27 #include <cucul.h>
     27#include <caca.h>
    2828
    2929#undef __class
    30 #if defined(_WIN32) && defined(__LIBCUCUL_PP__)
     30#if defined(_WIN32) && defined(__LIBCACA_PP__)
    3131#   define __class class __declspec(dllexport)
    3232#else
     
    3434#endif
    3535
    36 class Cucul;
     36class Canvas;
    3737
    3838__class Charset
     
    5454    unsigned int getWidth();
    5555    unsigned int getHeight();
    56     void renderCanvas(Cucul *, uint8_t *, unsigned int,
     56    void renderCanvas(Canvas *, uint8_t *, unsigned int,
    5757                               unsigned int, unsigned int);
    5858    uint32_t const *getBlocks();
    5959
    6060 private:
    61     cucul_font *font;
     61    caca_font *font;
    6262};
    6363
     
    8282    void setMode(char const *);
    8383    char const *const * getModeList();
    84     void Bitmap(Cucul *, int, int, int, int, void *);
     84    void Bitmap(Canvas *, int, int, int, int, void *);
    8585
    8686 private:
    87     cucul_dither *dither;
     87    caca_dither *dither;
    8888};
    8989
    90 __class Cucul
     90__class Canvas
    9191{
    9292    friend class Caca;
     
    9494    friend class Font;
    9595 public:
    96     Cucul();
    97     Cucul(int width, int height);
    98     ~Cucul();
     96    Canvas();
     97    Canvas(int width, int height);
     98    ~Canvas();
    9999
    100100    void setSize(unsigned int w, unsigned int h);
     
    110110    void putStr(int x, int y, char *str);
    111111    void Clear(void);
    112     void Blit(int, int, Cucul* c1, Cucul* c2);
     112    void Blit(int, int, Canvas* c1, Canvas* c2);
    113113    void Invert();
    114114    void Flip();
     
    132132    void drawThinTriangle(int, int, int, int, int, int);
    133133    void fillTriangle(int, int, int, int, int, int, uint32_t);
    134     int setBoundaries(cucul_canvas_t *, int, int, unsigned int, unsigned int);
     134    int setBoundaries(caca_canvas_t *, int, int, unsigned int, unsigned int);
    135135    unsigned int getFrameCount();
    136136    int setFrame(unsigned int);
     
    148148
    149149 protected:
    150     cucul_canvas_t *get_cucul_canvas_t();
     150    caca_canvas_t *get_caca_canvas_t();
    151151
    152152 private:
    153     cucul_canvas_t *cv;
     153    caca_canvas_t *cv;
    154154};
    155155
  • libcaca/trunk/cxx/cxxtest.cpp

    r2136 r2821  
    4141int main(int argc, char *argv[])
    4242{
    43     Cucul *cv, *pig;
     43    Canvas *cv, *pig;
    4444    Caca  *dp;
    4545
     
    4747
    4848    try {
    49         cv = new Cucul();
     49        cv = new Canvas();
    5050    }
    5151    catch (int e) {
     
    6464    try {
    6565        // Import buffer into a canvas
    66         pig = new Cucul();
    67         pig->setColorANSI(CUCUL_LIGHTMAGENTA, CUCUL_TRANSPARENT);
     66        pig = new Canvas();
     67        pig->setColorANSI(CACA_LIGHTMAGENTA, CACA_TRANSPARENT);
    6868        pig->importMemory(pigstring, strlen(pigstring), "text");
    6969    }
     
    9090
    9191        /* printf works */
    92         cv->setColorANSI(CUCUL_LIGHTBLUE, CUCUL_BLACK);
     92        cv->setColorANSI(CACA_LIGHTBLUE, CACA_BLACK);
    9393        cv->Printf(cv->getWidth() / 2 - 10, cv->getHeight() / 2,
    9494                   "Powered by libcaca %s", dp->getVersion());
Note: See TracChangeset for help on using the changeset viewer.