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

Last change on this file since 1276 was 1276, checked in by Sam Hocevar, 14 years ago
  • Don't crash if Blit()'s second canvas argument is NULL (which is valid).
  • Property svn:keywords set to Id
File size: 8.2 KB
Line 
1/*
2 *  libcucul++    C++ bindings for libcucul
3 *  Copyright (c) 2006 Jean-Yves Lamoureux <jylam@lnxscene.org>
4 *                All Rights Reserved
5 *
6 *  $Id: cucul++.cpp 1276 2006-11-05 18:00:53Z sam $
7 *
8 *  This library is free software; you can redistribute it and/or
9 *  modify it under the terms of the Do What The Fuck You Want To
10 *  Public License, Version 2, as published by Sam Hocevar. See
11 *  http://sam.zoy.org/wtfpl/COPYING for more details.
12 */
13
14/*
15 *  This file contains the main functions used by \e libcucul++ applications
16 *  to initialise a drawing context.
17 */
18
19#include "config.h"
20
21#include <stdio.h> // BUFSIZ
22#include <stdarg.h> // va_*
23
24#include "cucul++.h"
25
26
27unsigned long int Charset::utf8ToUtf32(char const *s, unsigned int *read)
28{
29    return cucul_utf8_to_utf32(s, read);
30}
31unsigned int Charset::utf32ToUtf8(char *buf, unsigned long int ch)
32{
33    return cucul_utf32_to_utf8(buf, ch);
34}
35unsigned char Charset::utf32ToCp437(unsigned long int ch)
36{
37    return cucul_utf32_to_cp437(ch);
38}
39unsigned long int Charset::cp437ToUtf32(unsigned char ch)
40{
41    return cucul_cp437_to_utf32(ch);
42}
43
44
45Cucul::Cucul()
46{
47    cv = cucul_create_canvas(0, 0);
48    if(!cv)
49        throw -1;
50}
51
52Cucul::Cucul(int width, int height)
53{
54    cv = cucul_create_canvas(width, height);
55    if(!cv) throw -1;
56}
57
58Cucul::Cucul(Buffer *b, char const *format)
59{
60    cv = cucul_import_canvas(b->getBuffer(), format);
61    if(!cv) throw -1;
62}
63
64Cucul::~Cucul()
65{
66    if(cv)
67        cucul_free_canvas(cv);
68}
69
70cucul_canvas_t *Cucul::get_cucul_canvas_t()
71{
72    return cv;
73}
74
75void Cucul::setSize(unsigned int width, unsigned int height)
76{
77    cucul_set_canvas_size(cv, width, height);
78}
79
80unsigned int Cucul::getWidth(void)
81{
82    return cucul_get_canvas_width(cv);
83}
84
85unsigned int Cucul::getHeight(void)
86{
87    return cucul_get_canvas_height(cv);
88}
89
90int Cucul::setColorANSI(unsigned char f, unsigned char b)
91{
92    return cucul_set_color_ansi(cv, f, b);
93}
94
95int  Cucul::setColorARGB(unsigned int f, unsigned int b)
96{
97    return cucul_set_color_argb(cv, f, b);
98}
99
100void Cucul::putChar(int x, int y, char ch)
101{
102    cucul_putchar(cv, x, y, ch);
103}
104
105void Cucul::putStr(int x, int y, char *str)
106{
107    cucul_putstr(cv, x, y, str);
108}
109
110void Cucul::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 Cucul::Clear(void)
129{
130    cucul_clear_canvas(cv);
131}
132
133void 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
139void Cucul::Invert()
140{
141    cucul_invert(cv);
142}
143
144void Cucul::Flip()
145{
146    cucul_flip(cv);
147}
148
149void Cucul::Flop()
150{
151    cucul_flop(cv);
152}
153
154void Cucul::Rotate()
155{
156    cucul_rotate(cv);
157}
158
159void Cucul::drawLine(int x1, int y1, int x2, int y2, char const *ch)
160{
161    cucul_draw_line(cv, x1, y1, x2, y2, ch);
162}
163
164void Cucul::drawPolyline(int const x[], int const y[], int f, char const *ch)
165{
166    cucul_draw_polyline(cv, x, y, f, ch);
167}
168
169void Cucul::drawThinLine(int x1, int y1, int x2, int y2)
170{
171    cucul_draw_thin_line(cv, x1, y1, x2, y2);
172}
173
174void Cucul::drawThinPolyline(int const x[], int const y[], int f)
175{
176    cucul_draw_thin_polyline(cv, x, y, f);
177}
178
179void Cucul::drawCircle(int x, int y, int d, char const *ch)
180{
181    cucul_draw_circle(cv, x, y, d, ch);
182}
183
184void Cucul::drawEllipse(int x, int y, int d1, int d2, char const *ch)
185{
186    cucul_draw_ellipse(cv, x, y, d1, d2, ch);
187}
188
189void Cucul::drawThinEllipse(int x, int y, int d1, int d2)
190{
191    cucul_draw_thin_ellipse(cv, x, y, d1, d2);
192}
193
194void Cucul::fillEllipse(int x, int y, int d1, int d2, char const *ch)
195{
196    cucul_fill_ellipse(cv, x, y, d1, d2, ch);
197}
198
199void Cucul::drawBox(int x, int y, int w, int h, char const *ch)
200{
201    cucul_draw_box(cv, x, y, w, h, ch);
202}
203
204void Cucul::drawThinBox(int x, int y, int w, int h)
205{
206    cucul_draw_thin_box(cv, x, y, w, h);
207}
208
209void Cucul::fillBox(int x, int y, int w, int h, char const *ch)
210{
211    cucul_fill_box(cv, x, y, w, h, ch);
212}
213
214void Cucul::drawTriangle(int x1, int y1, int x2, int y2, int x3, int y3, char const *ch)
215{
216    cucul_draw_triangle(cv, x1, y1, x2, y2, x3, y3, ch);
217}
218
219void Cucul::drawThinTriangle(int x1, int y1, int x2, int y2, int x3, int y3)
220{
221    cucul_draw_thin_triangle(cv, x1, y1, x2, y2, x3, y3);
222}
223
224void Cucul::fillTriangle(int x1, int y1, int x2, int y2, int x3, int y3, const char *ch)
225{
226    cucul_fill_triangle(cv, x1, y1, x2, y2, x3, y3, ch);
227}
228
229int Cucul::Rand(int min, int max)
230{
231    return cucul_rand(min, max);
232}
233
234int Cucul::setAttr(unsigned long int attr)
235{
236    return cucul_set_attr(cv, attr);
237}
238
239unsigned long int Cucul::getAttr(int x, int y)
240{
241    return cucul_get_attr(cv, x, y);
242}
243
244int Cucul::setBoundaries(cucul_canvas_t *, int x, int y,
245                         unsigned int w, unsigned int h)
246{
247    return cucul_set_canvas_boundaries(cv, x, y, h, w);
248}
249
250unsigned int Cucul::getFrameCount()
251{
252    return cucul_get_canvas_frame_count(cv);
253}
254int Cucul::setFrame(unsigned int f)
255{
256    return cucul_set_canvas_frame(cv, f);
257}
258int Cucul::createFrame(unsigned int f)
259{
260    return cucul_create_canvas_frame(cv, f);
261}
262int Cucul::freeFrame(unsigned int f)
263{
264    return cucul_create_canvas_frame(cv, f);
265}
266
267Dither::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)
268{
269    dither = cucul_create_dither(v1, v2, v3, v4, v5, v6, v7, v8);
270}
271Dither::~Dither()
272{
273    cucul_free_dither(dither);
274}
275
276void Dither::setPalette(unsigned int r[], unsigned int g[], unsigned int b[], unsigned int a[])
277{
278    cucul_set_dither_palette(dither, r, g, b, a);
279}
280
281void Dither::setBrightness(float f)
282{
283    cucul_set_dither_brightness(dither, f);
284}
285
286void Dither::setGamma(float f)
287{
288    cucul_set_dither_gamma(dither, f);
289}
290
291void Dither::setContrast(float f)
292{
293    cucul_set_dither_contrast(dither, f);
294}
295
296void Dither::setInvert(int i)
297{
298    cucul_set_dither_invert(dither, i);
299}
300
301void Dither::setAntialias(char const *cv)
302{
303    cucul_set_dither_antialias(dither, cv);
304}
305
306char const *const * Dither::getAntialiasList()
307{
308    return cucul_get_dither_antialias_list(dither);
309}
310
311void Dither::setColor(char const *cv)
312{
313    cucul_set_dither_color(dither, cv);
314}
315
316char const *const * Dither::getColorList()
317{
318    return cucul_get_dither_color_list(dither);
319}
320
321void Dither::setCharset(char const *cv)
322{
323    cucul_set_dither_charset(dither, cv);
324}
325
326char const *const * Dither::getCharsetList()
327{
328    return cucul_get_dither_charset_list(dither);
329}
330
331void Dither::setMode(char const *cv)
332{
333    cucul_set_dither_mode(dither, cv);
334}
335
336char const *const * Dither::getModeList(void)
337{
338    return cucul_get_dither_mode_list(dither);
339}
340
341void Dither::Bitmap(Cucul *cv, int x, int y, int w, int h, void *v)
342{
343    cucul_dither_bitmap(cv->get_cucul_canvas_t(), x, y, w, h, dither, v);
344}
345
346Font::Font(void const *s, unsigned int v)
347{
348    font = cucul_load_font(s, v);
349    if(!font) throw -1;
350}
351
352char const *const * Font::getList(void)
353{
354    return cucul_get_font_list();
355}
356
357unsigned int Font::getWidth()
358{
359    return cucul_get_font_width(font);
360}
361
362unsigned int Font::getHeight()
363{
364    return cucul_get_font_height(font);
365}
366
367void Font::renderCanvas(Cucul *cv, unsigned char *buf, unsigned int x, unsigned int y, unsigned int w)
368{
369    cucul_render_canvas(cv->get_cucul_canvas_t(), font, buf, x, y, w);
370}
371
372unsigned long int const *Font::getBlocks()
373{
374    return cucul_get_font_blocks(font);
375}
376
377Font::~Font()
378{
379    cucul_free_font(font);
380}
381
382Buffer::Buffer()
383{
384    buffer_ = NULL;
385}
386
387Buffer::~Buffer()
388{
389    if(buffer_)
390        cucul_free_buffer(buffer_);
391}
392
393char const *const * Buffer::getExportList(void)
394{
395    return cucul_get_export_list();
396}
397
398void *Buffer::getData(void)
399{
400    return cucul_get_buffer_data(buffer_);
401}
402
403void Buffer::loadMemory(void *buf, unsigned long int size)
404{
405    buffer_ = cucul_load_memory(buf, size);
406    if(buffer_ == NULL)
407        throw -1;
408}
409
410void Buffer::loadFile(char const *filename)
411{
412    buffer_ = cucul_load_file(filename);
413    if(buffer_ == NULL)
414        throw -1;
415}
416
417unsigned long int Buffer::getSize()
418{
419    return cucul_get_buffer_size(buffer_);
420}
421
422cucul_buffer *Buffer::getBuffer()
423{
424    return buffer_;
425}
Note: See TracBrowser for help on using the repository browser.