source: libcaca/trunk/cxx/cucul++.cpp @ 2821

Last change on this file since 2821 was 2821, checked in by Sam Hocevar, 11 years ago

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.

  • Property svn:keywords set to Id
File size: 8.1 KB
Line 
1/*
2 *  libcaca++    C++ bindings for libcaca
3 *  Copyright (c) 2006 Jean-Yves Lamoureux <jylam@lnxscene.org>
4 *                All Rights Reserved
5 *
6 *  $Id: cucul++.cpp 2821 2008-09-27 13:12:46Z sam $
7 *
8 *  This library is free software. It comes without any warranty, to
9 *  the extent permitted by applicable law. You can redistribute it
10 *  and/or modify it under the terms of the Do What The Fuck You Want
11 *  To Public License, Version 2, as published by Sam Hocevar. See
12 *  http://sam.zoy.org/wtfpl/COPYING for more details.
13 */
14
15/*
16 *  This file contains the main functions used by \e libcaca++ applications
17 *  to initialise a drawing context.
18 */
19
20#include "config.h"
21
22#include <stdio.h> // BUFSIZ
23#include <stdarg.h> // va_*
24
25#include "caca++.h"
26
27
28uint32_t Charset::utf8ToUtf32(char const *s, size_t *read)
29{
30    return caca_utf8_to_utf32(s, read);
31}
32size_t Charset::utf32ToUtf8(char *buf, uint32_t ch)
33{
34    return caca_utf32_to_utf8(buf, ch);
35}
36uint8_t Charset::utf32ToCp437(uint32_t ch)
37{
38    return caca_utf32_to_cp437(ch);
39}
40uint32_t Charset::cp437ToUtf32(uint8_t ch)
41{
42    return caca_cp437_to_utf32(ch);
43}
44
45
46Canvas::Canvas()
47{
48    cv = caca_create_canvas(0, 0);
49    if(!cv)
50        throw -1;
51}
52
53Canvas::Canvas(int width, int height)
54{
55    cv = caca_create_canvas(width, height);
56    if(!cv) throw -1;
57}
58
59Canvas::~Canvas()
60{
61    if(cv)
62        caca_free_canvas(cv);
63}
64
65caca_canvas_t *Canvas::get_caca_canvas_t()
66{
67    return cv;
68}
69
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, ...)
111{
112    char tmp[BUFSIZ];
113    char *buf = tmp;
114    va_list args;
115
116    va_start(args, format);
117#if defined(HAVE_VSNPRINTF)
118    vsnprintf(buf, getWidth() - x + 1, format, args);
119#else
120    vsprintf(buf, format, args);
121#endif
122    buf[getWidth() - x] = '\0';
123    va_end(args);
124
125    putStr(x, y, buf);
126}
127
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,
265                         unsigned int w, unsigned int h)
266{
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);
310}
311
312Dither::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)
313{
314    dither = caca_create_dither(v1, v2, v3, v4, v5, v6, v7, v8);
315}
316Dither::~Dither()
317{
318    caca_free_dither(dither);
319}
320
321void Dither::setPalette(uint32_t r[], uint32_t g[], uint32_t b[], uint32_t a[])
322{
323    caca_set_dither_palette(dither, r, g, b, a);
324}
325
326void Dither::setBrightness(float f)
327{
328    caca_set_dither_brightness(dither, f);
329}
330
331void Dither::setGamma(float f)
332{
333    caca_set_dither_gamma(dither, f);
334}
335
336void Dither::setContrast(float f)
337{
338    caca_set_dither_contrast(dither, f);
339}
340
341void Dither::setAntialias(char const *cv)
342{
343    caca_set_dither_antialias(dither, cv);
344}
345
346char const *const * Dither::getAntialiasList()
347{
348    return caca_get_dither_antialias_list(dither);
349}
350
351void Dither::setColor(char const *cv)
352{
353    caca_set_dither_color(dither, cv);
354}
355
356char const *const * Dither::getColorList()
357{
358    return caca_get_dither_color_list(dither);
359}
360
361void Dither::setCharset(char const *cv)
362{
363    caca_set_dither_charset(dither, cv);
364}
365
366char const *const * Dither::getCharsetList()
367{
368    return caca_get_dither_charset_list(dither);
369}
370
371void Dither::setMode(char const *cv)
372{
373    caca_set_dither_algorithm(dither, cv);
374}
375
376char const *const * Dither::getModeList(void)
377{
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);
384}
385
386Font::Font(void const *s, unsigned int v)
387{
388    font = caca_load_font(s, v);
389    if(!font) throw -1;
390}
391
392char const *const * Font::getList(void)
393{
394    return caca_get_font_list();
395}
396
397unsigned int Font::getWidth()
398{
399    return caca_get_font_width(font);
400}
401
402unsigned int Font::getHeight()
403{
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);
410}
411
412uint32_t const *Font::getBlocks()
413{
414    return caca_get_font_blocks(font);
415}
416
417Font::~Font()
418{
419    caca_free_font(font);
420}
421
Note: See TracBrowser for help on using the repository browser.