cacalabs
/
libcaca
mirror of https://github.com/cacalabs/libcaca.git
1
0
Fork 0
Code Issues 0 Releases 7 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
515 Commits
1 Branch
4.9 MiB
Tree: f4933461d4
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f4933461d4'
${ noResults }
libcaca/cucul/cucul.h

cucul.h 7.6 KiB
Raw Normal View History

A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
* Slightly changed header comments.
18 years ago
A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
* Renamed cucul_buffer to cucul_export. Vanilla rum rules.
19 years ago
​
A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
​
​
​
​
​
​
* Replaced all cucul_get_* exporters with a generic cucul_export() function. * Got rid of static buffers; we now use cucul_free() to free exported buffers. * Fixed light background in the ANSI exporter by adding escape sequences for most terminal emulators.
19 years ago
A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
​
​
* Removed CUCUL_BACKGROUND, CUCUL_ANTIALIASING and CUCUL_DITHERING environment variables handling. Replaced that with three per-bitmap functions: cucul_set_bitmap_antialias(), cucul_set_bitmap_color() and cucul_set_bitmap_dithering(). * Added cucul_set_bitmap_brightness() and cucul_set_bitmap_contrast() prototypes (but did not implement them yet). * Added cucul_set_bitmap_charset() to choose what characters are going to be used for the bitmap rendering. * Removed the now useless cucul_get_feature(), cucul_set_feature() etc.
18 years ago
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
​
​
​
​
​
​
​
​
​
* Renamed cucul_init()/cucul_end() into cucul_create()/cucul_free().
18 years ago
* Implemented cucul_load() to reload a file that was saved with the raw driver. I know it is inconsistent to have the loader in libcucul and the exporter in libcaca but I'll find a way to harmonise that.
18 years ago
A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
​
​
* Renamed cucul_init()/cucul_end() into cucul_create()/cucul_free().
18 years ago
A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
​
* Added the cucul_blit() function. It lets us blit various canvas one onto the other with an optional mask.
18 years ago
A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
* Added the cucul_blit() function. It lets us blit various canvas one onto the other with an optional mask.
18 years ago
​
A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
​
​
​
​
​
​
​
* Added the cucul_blit() function. It lets us blit various canvas one onto the other with an optional mask.
18 years ago
A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
​
* Added cucul_flip(), cucul_flop() and cucul_transform() to perform operations on canvases.
18 years ago
​
​
​
​
* Implemented cucul_invert() to invert a canvas' colours.
18 years ago
* Added cucul_flip(), cucul_flop() and cucul_transform() to perform operations on canvases.
18 years ago
​
​
​
​
A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
​
​
​
​
​
* Made cucul_putchar32() an internal-only function. * Changed the line, box, ellipsis etc. prototypes so that they use an UTF-8 string instead of a single character as their last argument.
18 years ago
​
A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
​
​
* Made cucul_putchar32() an internal-only function. * Changed the line, box, ellipsis etc. prototypes so that they use an UTF-8 string instead of a single character as their last argument.
18 years ago
​
A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
* Made cucul_putchar32() an internal-only function. * Changed the line, box, ellipsis etc. prototypes so that they use an UTF-8 string instead of a single character as their last argument.
18 years ago
A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
* Made cucul_putchar32() an internal-only function. * Changed the line, box, ellipsis etc. prototypes so that they use an UTF-8 string instead of a single character as their last argument.
18 years ago
A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
* Made cucul_putchar32() an internal-only function. * Changed the line, box, ellipsis etc. prototypes so that they use an UTF-8 string instead of a single character as their last argument.
18 years ago
A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
* Made cucul_putchar32() an internal-only function. * Changed the line, box, ellipsis etc. prototypes so that they use an UTF-8 string instead of a single character as their last argument.
18 years ago
A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
* Made cucul_putchar32() an internal-only function. * Changed the line, box, ellipsis etc. prototypes so that they use an UTF-8 string instead of a single character as their last argument.
18 years ago
A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
* Got rid of useless parameters in cucul_*_bitmap and cucul_*_sprite.
19 years ago
​
A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
​
​
​
​
​
​
​
​
* Removed the cucul_t * argument from cucul_create_bitmap(). It's not needed.
18 years ago
​
​
​
* Got rid of useless parameters in cucul_*_bitmap and cucul_*_sprite.
19 years ago
​
​
* Removed CUCUL_BACKGROUND, CUCUL_ANTIALIASING and CUCUL_DITHERING environment variables handling. Replaced that with three per-bitmap functions: cucul_set_bitmap_antialias(), cucul_set_bitmap_color() and cucul_set_bitmap_dithering(). * Added cucul_set_bitmap_brightness() and cucul_set_bitmap_contrast() prototypes (but did not implement them yet). * Added cucul_set_bitmap_charset() to choose what characters are going to be used for the bitmap rendering. * Removed the now useless cucul_get_feature(), cucul_set_feature() etc.
18 years ago
* Got rid of useless parameters in cucul_*_bitmap and cucul_*_sprite.
19 years ago
* Removed CUCUL_BACKGROUND, CUCUL_ANTIALIASING and CUCUL_DITHERING environment variables handling. Replaced that with three per-bitmap functions: cucul_set_bitmap_antialias(), cucul_set_bitmap_color() and cucul_set_bitmap_dithering(). * Added cucul_set_bitmap_brightness() and cucul_set_bitmap_contrast() prototypes (but did not implement them yet). * Added cucul_set_bitmap_charset() to choose what characters are going to be used for the bitmap rendering. * Removed the now useless cucul_get_feature(), cucul_set_feature() etc.
18 years ago
​
* Changed the cucul_set_bitmap_antialias() argument to a string.
18 years ago
​
* Removed CUCUL_BACKGROUND, CUCUL_ANTIALIASING and CUCUL_DITHERING environment variables handling. Replaced that with three per-bitmap functions: cucul_set_bitmap_antialias(), cucul_set_bitmap_color() and cucul_set_bitmap_dithering(). * Added cucul_set_bitmap_brightness() and cucul_set_bitmap_contrast() prototypes (but did not implement them yet). * Added cucul_set_bitmap_charset() to choose what characters are going to be used for the bitmap rendering. * Removed the now useless cucul_get_feature(), cucul_set_feature() etc.
18 years ago
​
​
​
​
​
​
​
​
​
* Got rid of useless parameters in cucul_*_bitmap and cucul_*_sprite.
19 years ago
A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
​
​
​
* Replaced all cucul_get_* exporters with a generic cucul_export() function. * Got rid of static buffers; we now use cucul_free() to free exported buffers. * Fixed light background in the ANSI exporter by adding escape sequences for most terminal emulators.
19 years ago
* Renamed cucul_buffer to cucul_export. Vanilla rum rules.
19 years ago
A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
​
* Renamed cucul_buffer to cucul_export. Vanilla rum rules.
19 years ago
* Replaced all cucul_get_* exporters with a generic cucul_export() function. * Got rid of static buffers; we now use cucul_free() to free exported buffers. * Fixed light background in the ANSI exporter by adding escape sequences for most terminal emulators.
19 years ago
​
​
​
​
* Changed the 2nd argument of cucul_create_export to a string. This way we can add new exporters without changing the API.
18 years ago
* Added cucul_get_export_list(). Returns a list of known export formats.
18 years ago
* Renamed cucul_buffer to cucul_export. Vanilla rum rules.
19 years ago
* Added preliminary Postscript (tm) (r) (c) exporter.
19 years ago
A new low-level text management library (canvas for ultrafast compositing of unicode letters) is now separated from the higher level rendering and I/O (that is, libcaca). This commit totally breaks the API, but once everything is polished I will think about source-level backward compatibility. Most drivers are broken, but X11 still sorta works. The new design is much more object-oriented and allows having several active renderers at the same time, changing renderers on the fly, and more important, having no renderer at all (useful for converters, or when you want to do your own renderer). And in case you are still wondering, the libcucul acronym has "Unicode" because I want to support at least a subset of Unicode. There are awesome glyphs in it, including the ones inherited from Codepage 437 such as "gray 25%" that are used in DOS and Win32 ANSI art.
19 years ago
​
​
​
​
​
​
 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206 
  1. /*

  2.  *  libcucul      Canvas for ultrafast compositing of Unicode letters

  3.  *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>

  4.  *                All Rights Reserved

  5.  *

  6.  *  This library is free software; you can redistribute it and/or

  7.  *  modify it under the terms of the Do What The Fuck You Want To

  8.  *  Public License, Version 2, as published by Sam Hocevar. See

  9.  *  http://sam.zoy.org/wtfpl/COPYING for more details.

  10.  */

  11. 

  12. /** \file cucul.h

  13.  *  \version \$Id$

  14.  *  \author Sam Hocevar <sam@zoy.org>

  15.  *  \brief The \e libcucul public header.

  16.  *

  17.  *  This header contains the public types and functions that applications

  18.  *  using \e libcucul may use.

  19.  */

  20. 

  21. #ifndef __CUCUL_H__

  22. #define __CUCUL_H__

  23. 

  24. #define CUCUL_API_VERSION_1

  25. 

  26. #ifdef __cplusplus

  27. extern "C"

  28. {

  29. #endif

  30. 

  31. /** \brief Colour definitions.

  32.  *

  33.  *  Colours that can be used with cucul_set_color().

  34.  */

  35. enum cucul_color

  36. {

  37.     CUCUL_COLOR_BLACK = 0x0, /**< The colour index for black. */

  38.     CUCUL_COLOR_BLUE = 0x1, /**< The colour index for blue. */

  39.     CUCUL_COLOR_GREEN = 0x2, /**< The colour index for green. */

  40.     CUCUL_COLOR_CYAN = 0x3, /**< The colour index for cyan. */

  41.     CUCUL_COLOR_RED = 0x4, /**< The colour index for red. */

  42.     CUCUL_COLOR_MAGENTA = 0x5, /**< The colour index for magenta. */

  43.     CUCUL_COLOR_BROWN = 0x6, /**< The colour index for brown. */

  44.     CUCUL_COLOR_LIGHTGRAY = 0x7, /**< The colour index for light gray. */

  45.     CUCUL_COLOR_DARKGRAY = 0x8, /**< The colour index for dark gray. */

  46.     CUCUL_COLOR_LIGHTBLUE = 0x9, /**< The colour index for blue. */

  47.     CUCUL_COLOR_LIGHTGREEN = 0xa, /**< The colour index for light green. */

  48.     CUCUL_COLOR_LIGHTCYAN = 0xb, /**< The colour index for light cyan. */

  49.     CUCUL_COLOR_LIGHTRED = 0xc, /**< The colour index for light red. */

  50.     CUCUL_COLOR_LIGHTMAGENTA = 0xd, /**< The colour index for light magenta. */

  51.     CUCUL_COLOR_YELLOW = 0xe, /**< The colour index for yellow. */

  52.     CUCUL_COLOR_WHITE = 0xf, /**< The colour index for white. */

  53. 

  54.     CUCUL_COLOR_TRANSPARENT = 0xfe, /**< The transparent colour. */

  55.     CUCUL_COLOR_DEFAULT = 0xff, /**< The output driver's default colour. */

  56. };

  57. 

  58. typedef struct cucul_context cucul_t;

  59. 

  60. /** \defgroup basic Basic functions

  61.  *

  62.  *  These functions provide the basic \e libcaca routines for library

  63.  *  initialisation, system information retrieval and configuration.

  64.  *

  65.  *  @{ */

  66. cucul_t * cucul_create(unsigned int, unsigned int);

  67. cucul_t * cucul_load(void *, unsigned int);

  68. void cucul_set_size(cucul_t *, unsigned int, unsigned int);

  69. unsigned int cucul_get_width(cucul_t *);

  70. unsigned int cucul_get_height(cucul_t *);

  71. void cucul_free(cucul_t *);

  72. /*  @} */

  73. 

  74. /** \defgroup canvas Canvas drawing

  75.  *

  76.  *  These functions provide low-level character printing routines and

  77.  *  higher level graphics functions.

  78.  *

  79.  *  @{ */

  80. void cucul_set_color(cucul_t *, enum cucul_color, enum cucul_color);

  81. char const *cucul_get_color_name(enum cucul_color);

  82. void cucul_putchar(cucul_t *, int, int, char);

  83. void cucul_putstr(cucul_t *, int, int, char const *);

  84. void cucul_printf(cucul_t *, int, int, char const *, ...);

  85. void cucul_clear(cucul_t *);

  86. void cucul_blit(cucul_t *, int, int, cucul_t const *, cucul_t const *);

  87. /*  @} */

  88. 

  89. /** \defgroup transform Canvas transformation

  90.  *

  91.  *  These functions perform horizontal and vertical canvas flipping.

  92.  *

  93.  *  @{ */

  94. void cucul_invert(cucul_t *);

  95. void cucul_flip(cucul_t *);

  96. void cucul_flop(cucul_t *);

  97. void cucul_rotate(cucul_t *);

  98. /*  @} */

  99. 

  100. /** \defgroup prim Primitives drawing

  101.  *

  102.  *  These functions provide routines for primitive drawing, such as lines,

  103.  *  boxes, triangles and ellipses.

  104.  *

  105.  *  @{ */

  106. void cucul_draw_line(cucul_t *, int, int, int, int, char const *);

  107. void cucul_draw_polyline(cucul_t *, int const x[], int const y[], int, char const *);

  108. void cucul_draw_thin_line(cucul_t *, int, int, int, int);

  109. void cucul_draw_thin_polyline(cucul_t *, int const x[], int const y[], int);

  110. 

  111. void cucul_draw_circle(cucul_t *, int, int, int, char const *);

  112. void cucul_draw_ellipse(cucul_t *, int, int, int, int, char const *);

  113. void cucul_draw_thin_ellipse(cucul_t *, int, int, int, int);

  114. void cucul_fill_ellipse(cucul_t *, int, int, int, int, char const *);

  115. 

  116. void cucul_draw_box(cucul_t *, int, int, int, int, char const *);

  117. void cucul_draw_thin_box(cucul_t *, int, int, int, int);

  118. void cucul_fill_box(cucul_t *, int, int, int, int, char const *);

  119. 

  120. void cucul_draw_triangle(cucul_t *, int, int, int, int, int, int, char const *);

  121. void cucul_draw_thin_triangle(cucul_t *, int, int, int, int, int, int);

  122. void cucul_fill_triangle(cucul_t *, int, int, int, int, int, int, char const *);

  123. /*  @} */

  124. 

  125. /** \defgroup math Mathematical functions

  126.  *

  127.  *  These functions provide a few useful math-related routines.

  128.  *

  129.  *  @{ */

  130. int cucul_rand(int, int);

  131. unsigned int cucul_sqrt(unsigned int);

  132. /*  @} */

  133. 

  134. /** \defgroup sprite Sprite handling

  135.  *

  136.  *  These functions provide high level routines for sprite loading, animation

  137.  *  and rendering.

  138.  *

  139.  *  @{ */

  140. struct cucul_sprite;

  141. struct cucul_sprite * cucul_load_sprite(cucul_t *, char const *);

  142. int cucul_get_sprite_frames(cucul_t *, struct cucul_sprite const *);

  143. int cucul_get_sprite_width(cucul_t *, struct cucul_sprite const *, int);

  144. int cucul_get_sprite_height(cucul_t *, struct cucul_sprite const *, int);

  145. int cucul_get_sprite_dx(cucul_t *, struct cucul_sprite const *, int);

  146. int cucul_get_sprite_dy(cucul_t *, struct cucul_sprite const *, int);

  147. void cucul_draw_sprite(cucul_t *, int, int, struct cucul_sprite const *, int);

  148. void cucul_free_sprite(struct cucul_sprite *);

  149. /*  @} */

  150. 

  151. /** \defgroup bitmap Bitmap handling

  152.  *

  153.  *  These functions provide high level routines for bitmap allocation and

  154.  *  rendering.

  155.  *

  156.  *  @{ */

  157. struct cucul_bitmap;

  158. struct cucul_bitmap *cucul_create_bitmap(unsigned int, unsigned int,

  159.                                          unsigned int, unsigned int,

  160.                                          unsigned int, unsigned int,

  161.                                          unsigned int, unsigned int);

  162. void cucul_set_bitmap_palette(struct cucul_bitmap *,

  163.                               unsigned int r[], unsigned int g[],

  164.                               unsigned int b[], unsigned int a[]);

  165. void cucul_set_bitmap_brightness(struct cucul_bitmap *, float);

  166. void cucul_set_bitmap_gamma(struct cucul_bitmap *, float);

  167. void cucul_set_bitmap_contrast(struct cucul_bitmap *, float);

  168. void cucul_set_bitmap_invert(struct cucul_bitmap *, int);

  169. void cucul_set_bitmap_antialias(struct cucul_bitmap *, char const *);

  170. char const * const * cucul_get_bitmap_antialias_list(struct cucul_bitmap const *);

  171. void cucul_set_bitmap_color(struct cucul_bitmap *, char const *);

  172. char const * const * cucul_get_bitmap_color_list(struct cucul_bitmap const *);

  173. void cucul_set_bitmap_charset(struct cucul_bitmap *, char const *);

  174. char const * const * cucul_get_bitmap_charset_list(struct cucul_bitmap

  175.                                                    const *);

  176. void cucul_set_bitmap_dithering(struct cucul_bitmap *, char const *);

  177. char const * const * cucul_get_bitmap_dithering_list(struct cucul_bitmap

  178.                                                      const *);

  179. void cucul_draw_bitmap(cucul_t *, int, int, int, int,

  180.                        struct cucul_bitmap const *, void *);

  181. void cucul_free_bitmap(struct cucul_bitmap *);

  182. /*  @} */

  183. 

  184. /** \defgroup exporter Exporters to various formats

  185.  *

  186.  *  These functions export the current canvas to various text formats. It

  187.  *  is necessary to call cucul_free_export() to dispose of the data.

  188.  *

  189.  *  @{ */

  190. struct cucul_export

  191. {

  192.     unsigned int size;

  193.     char *buffer;

  194. };

  195. 

  196. struct cucul_export * cucul_create_export(cucul_t *, char const *);

  197. char const * const * cucul_get_export_list(void);

  198. void cucul_free_export(struct cucul_export *);

  199. 

  200. /*  @} */

  201. 

  202. #ifdef __cplusplus

  203. }

  204. #endif

  205. 

  206. #endif /* __CUCUL_H__ */