cacalabs
/
libcaca
miroir de https://github.com/cacalabs/libcaca.git
1
0
Bifurcation 0
Code Tickets 0 Versions 7 Wiki Activité
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
555 Révisions
1 Branche
84 MiB
Aborescence: 99aa400f26
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de '99aa400f26'
${ noResults }
libcaca/cucul/cucul.h

cucul.h 8.1 KiB
Brut Vue normale Historique

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.
il y a 19 ans
* Slightly changed header comments.
il y a 18 ans
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.
il y a 19 ans
​
​
* Removed \file directives from all files except caca.h and cucul.h, to remove redundencies in the Doxygen documentation.
il y a 18 ans
​
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.
il y a 19 ans
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
* Renamed cucul_buffer to cucul_export. Vanilla rum rules.
il y a 18 ans
​
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.
il y a 19 ans
​
​
​
​
* Replaced enum cucul_color with unsigned int. The size of an enum is not really portable, and Visual Studio complains when they are not explicitely cast.
il y a 18 ans
​
* Renamed cucul_export into cucul_buffer. We'll use it for other things.
il y a 18 ans
​
​
​
​
​
* Replaced enum cucul_color with unsigned int. The size of an enum is not really portable, and Visual Studio complains when they are not explicitely cast.
il y a 18 ans
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.
il y a 19 ans
* 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.
il y a 18 ans
* Replaced enum cucul_color with unsigned int. The size of an enum is not really portable, and Visual Studio complains when they are not explicitely cast.
il y a 18 ans
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
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.
il y a 19 ans
​
​
​
​
​
​
* Renamed cucul_init()/cucul_end() into cucul_create()/cucul_free().
il y a 18 ans
* 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.
il y a 18 ans
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.
il y a 19 ans
​
​
* Renamed cucul_init()/cucul_end() into cucul_create()/cucul_free().
il y a 18 ans
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.
il y a 19 ans
​
* Added the cucul_blit() function. It lets us blit various canvas one onto the other with an optional mask.
il y a 18 ans
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.
il y a 19 ans
* Added the cucul_blit() function. It lets us blit various canvas one onto the other with an optional mask.
il y a 18 ans
​
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.
il y a 19 ans
​
* Replaced enum cucul_color with unsigned int. The size of an enum is not really portable, and Visual Studio complains when they are not explicitely cast.
il y a 18 ans
​
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.
il y a 19 ans
​
​
​
* Added the cucul_blit() function. It lets us blit various canvas one onto the other with an optional mask.
il y a 18 ans
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.
il y a 19 ans
​
* Added cucul_flip(), cucul_flop() and cucul_transform() to perform operations on canvases.
il y a 18 ans
​
​
​
​
* Implemented cucul_invert() to invert a canvas' colours.
il y a 18 ans
* Added cucul_flip(), cucul_flop() and cucul_transform() to perform operations on canvases.
il y a 18 ans
​
​
​
​
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.
il y a 19 ans
​
​
​
​
​
* 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.
il y a 18 ans
​
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.
il y a 19 ans
​
​
* 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.
il y a 18 ans
​
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.
il y a 19 ans
* 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.
il y a 18 ans
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.
il y a 19 ans
* 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.
il y a 18 ans
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.
il y a 19 ans
* 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.
il y a 18 ans
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.
il y a 19 ans
* 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.
il y a 18 ans
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.
il y a 19 ans
* 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.
il y a 18 ans
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.
il y a 19 ans
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
* Got rid of useless parameters in cucul_*_bitmap and cucul_*_sprite.
il y a 18 ans
​
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.
il y a 19 ans
​
* Renamed *bitmap to *dither. Ben ouais connard, je fais ce que je veux.
il y a 18 ans
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.
il y a 19 ans
* Renamed *bitmap to *dither. Ben ouais connard, je fais ce que je veux.
il y a 18 ans
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.
il y a 19 ans
​
​
* Renamed *bitmap to *dither. Ben ouais connard, je fais ce que je veux.
il y a 18 ans
​
* Removed the cucul_t * argument from cucul_create_bitmap(). It's not needed.
il y a 18 ans
​
​
* Renamed *bitmap to *dither. Ben ouais connard, je fais ce que je veux.
il y a 18 ans
* Got rid of useless parameters in cucul_*_bitmap and cucul_*_sprite.
il y a 18 ans
​
* Renamed *bitmap to *dither. Ben ouais connard, je fais ce que je veux.
il y a 18 ans
​
​
​
​
​
​
​
​
​
​
​
​
​
​
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.
il y a 19 ans
​
* Slightly updated the font format and wrote a font loader. Also added a skeleton for the renderer that will not last very long.
il y a 18 ans
​
​
​
​
​
​
* Internal font support through cucul_load_font(). Documented that. * Removed ugly hooks from test/font.c.
il y a 18 ans
* Implemented cucul_get_font_list() to retrieve the list of builtin fonts. * Fixed font selection through cucul_font_load(). * Added a bigger 10x19 bold font.
il y a 18 ans
* Implemented cucul_get_font_width() and cucul_get_font_height(). * Documented most font functions. * Cleaned up cucul_render_canvas() and made it actually usable by external programs. Removed ugly printf() debug calls.
il y a 18 ans
​
​
​
* Slightly updated the font format and wrote a font loader. Also added a skeleton for the renderer that will not last very long.
il y a 18 ans
​
​
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.
il y a 19 ans
​
* 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.
il y a 18 ans
* Renamed cucul_buffer to cucul_export. Vanilla rum rules.
il y a 18 ans
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.
il y a 19 ans
​
* Renamed cucul_export into cucul_buffer. We'll use it for other things.
il y a 18 ans
* Added cucul_get_export_list(). Returns a list of known export formats.
il y a 18 ans
* Renamed cucul_export into cucul_buffer. We'll use it for other things.
il y a 18 ans
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.
il y a 19 ans
​
​
​
​
​
​
 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219 
  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.  *  $Id$

  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. /** \file cucul.h

  15.  *  \version \$Id$

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

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

  18.  *

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

  20.  *  using \e libcucul may use.

  21.  */

  22. 

  23. #ifndef __CUCUL_H__

  24. #define __CUCUL_H__

  25. 

  26. #define CUCUL_API_VERSION_1

  27. 

  28. #ifdef __cplusplus

  29. extern "C"

  30. {

  31. #endif

  32. 

  33. typedef struct cucul_context cucul_t;

  34. 

  35. struct cucul_buffer

  36. {

  37.     unsigned int size;

  38.     char *data;

  39. };

  40. 

  41. /** \defgroup colour Colour definitions

  42.  *

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

  44.  *

  45.  *  @{ */

  46. #define CUCUL_COLOR_BLACK 0x00 /**< The colour index for black. */

  47. #define CUCUL_COLOR_BLUE 0x01 /**< The colour index for blue. */

  48. #define CUCUL_COLOR_GREEN 0x02 /**< The colour index for green. */

  49. #define CUCUL_COLOR_CYAN 0x03 /**< The colour index for cyan. */

  50. #define CUCUL_COLOR_RED 0x04 /**< The colour index for red. */

  51. #define CUCUL_COLOR_MAGENTA 0x05 /**< The colour index for magenta. */

  52. #define CUCUL_COLOR_BROWN 0x06 /**< The colour index for brown. */

  53. #define CUCUL_COLOR_LIGHTGRAY 0x07 /**< The colour index for light gray. */

  54. #define CUCUL_COLOR_DARKGRAY 0x08 /**< The colour index for dark gray. */

  55. #define CUCUL_COLOR_LIGHTBLUE 0x09 /**< The colour index for blue. */

  56. #define CUCUL_COLOR_LIGHTGREEN 0x0a /**< The colour index for light green. */

  57. #define CUCUL_COLOR_LIGHTCYAN 0x0b /**< The colour index for light cyan. */

  58. #define CUCUL_COLOR_LIGHTRED 0x0c /**< The colour index for light red. */

  59. #define CUCUL_COLOR_LIGHTMAGENTA 0x0d /**< The colour index for light magenta. */

  60. #define CUCUL_COLOR_YELLOW 0x0e /**< The colour index for yellow. */

  61. #define CUCUL_COLOR_WHITE 0x0f /**< The colour index for white. */

  62. #define CUCUL_COLOR_DEFAULT 0x10 /**< The output driver's default colour. */

  63. #define CUCUL_COLOR_TRANSPARENT 0x20 /**< The transparent colour. */

  64. /*  @} */

  65. 

  66. /** \defgroup basic Basic functions

  67.  *

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

  69.  *  initialisation, system information retrieval and configuration.

  70.  *

  71.  *  @{ */

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

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

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

  75. unsigned int cucul_get_width(cucul_t *);

  76. unsigned int cucul_get_height(cucul_t *);

  77. void cucul_free(cucul_t *);

  78. /*  @} */

  79. 

  80. /** \defgroup canvas Canvas drawing

  81.  *

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

  83.  *  higher level graphics functions.

  84.  *

  85.  *  @{ */

  86. void cucul_set_color(cucul_t *, unsigned int, unsigned int);

  87. char const *cucul_get_color_name(unsigned int);

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

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

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

  91. void cucul_clear(cucul_t *);

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

  93. /*  @} */

  94. 

  95. /** \defgroup transform Canvas transformation

  96.  *

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

  98.  *

  99.  *  @{ */

  100. void cucul_invert(cucul_t *);

  101. void cucul_flip(cucul_t *);

  102. void cucul_flop(cucul_t *);

  103. void cucul_rotate(cucul_t *);

  104. /*  @} */

  105. 

  106. /** \defgroup prim Primitives drawing

  107.  *

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

  109.  *  boxes, triangles and ellipses.

  110.  *

  111.  *  @{ */

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

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

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

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

  116. 

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

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

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

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

  121. 

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

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

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

  125. 

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

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

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

  129. /*  @} */

  130. 

  131. /** \defgroup math Mathematical functions

  132.  *

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

  134.  *

  135.  *  @{ */

  136. int cucul_rand(int, int);

  137. unsigned int cucul_sqrt(unsigned int);

  138. /*  @} */

  139. 

  140. /** \defgroup sprite Sprite handling

  141.  *

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

  143.  *  and rendering.

  144.  *

  145.  *  @{ */

  146. struct cucul_sprite;

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

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

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

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

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

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

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

  154. void cucul_free_sprite(struct cucul_sprite *);

  155. /*  @} */

  156. 

  157. /** \defgroup dither Bitmap dithering

  158.  *

  159.  *  These functions provide high level routines for dither allocation and

  160.  *  rendering.

  161.  *

  162.  *  @{ */

  163. struct cucul_dither;

  164. struct cucul_dither *cucul_create_dither(unsigned int, unsigned int,

  165.                                          unsigned int, unsigned int,

  166.                                          unsigned int, unsigned int,

  167.                                          unsigned int, unsigned int);

  168. void cucul_set_dither_palette(struct cucul_dither *,

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

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

  171. void cucul_set_dither_brightness(struct cucul_dither *, float);

  172. void cucul_set_dither_gamma(struct cucul_dither *, float);

  173. void cucul_set_dither_contrast(struct cucul_dither *, float);

  174. void cucul_set_dither_invert(struct cucul_dither *, int);

  175. void cucul_set_dither_antialias(struct cucul_dither *, char const *);

  176. char const * const * cucul_get_dither_antialias_list(struct cucul_dither const *);

  177. void cucul_set_dither_color(struct cucul_dither *, char const *);

  178. char const * const * cucul_get_dither_color_list(struct cucul_dither const *);

  179. void cucul_set_dither_charset(struct cucul_dither *, char const *);

  180. char const * const * cucul_get_dither_charset_list(struct cucul_dither const *);

  181. void cucul_set_dither_mode(struct cucul_dither *, char const *);

  182. char const * const * cucul_get_dither_mode_list(struct cucul_dither const *);

  183. void cucul_dither_bitmap(cucul_t *, int, int, int, int,

  184.                          struct cucul_dither const *, void *);

  185. void cucul_free_dither(struct cucul_dither *);

  186. /*  @} */

  187. 

  188. /** \defgroup font Font handling

  189.  *

  190.  *  These functions provide font handling routines and high quality

  191.  *  canvas to bitmap rendering.

  192.  *

  193.  *  @{ */

  194. struct cucul_font;

  195. struct cucul_font *cucul_load_font(void const *, unsigned int);

  196. char const * const * cucul_get_font_list(void);

  197. unsigned int cucul_get_font_width(struct cucul_font *);

  198. unsigned int cucul_get_font_height(struct cucul_font *);

  199. void cucul_render_canvas(cucul_t *, struct cucul_font *, unsigned char *,

  200.                          unsigned int, unsigned int, unsigned int);

  201. void cucul_free_font(struct cucul_font *);

  202. /*  @} */

  203. 

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

  205.  *

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

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

  208.  *

  209.  *  @{ */

  210. struct cucul_buffer * cucul_create_export(cucul_t *, char const *);

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

  212. void cucul_free_export(struct cucul_buffer *);

  213. /*  @} */

  214. 

  215. #ifdef __cplusplus

  216. }

  217. #endif

  218. 

  219. #endif /* __CUCUL_H__ */