cacalabs
/
libcaca
zrcadlo https://github.com/cacalabs/libcaca.git
1
0
Rozštěpit 0
Zdrojový kód Úkoly 0 Vydání 7 Wiki Aktivita
Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.
910 Revize
1 Větev
98 MiB
Strom: 7255c6b034
Větve Značky
${ item.name }
Vytvořit větev ${ searchTerm }
z „7255c6b034“
${ noResults }
libcaca/cucul/cucul.h

cucul.h 9.4 KiB
Surový Normální zobrazení Historie

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.
před 19 roky
* Slightly changed header comments.
před 18 roky
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.
před 19 roky
​
​
* Removed \file directives from all files except caca.h and cucul.h, to remove redundencies in the Doxygen documentation.
před 18 roky
​
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.
před 19 roky
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
* Improved documentation in many places.
před 18 roky
* Renamed cucul_buffer to cucul_export. Vanilla rum rules.
před 18 roky
​
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.
před 19 roky
​
​
​
​
* Added basis for an errno-like mechanism.
před 18 roky
* Renamed cucul_t into cucul_canvas_t. Eh ouais mon con.
před 18 roky
* Replaced "struct cucul_*" and "struct caca_*" types with opaque typedefs such as cucul_dither_t instead of struct cucul_dither. * Made cucul_buffer_t an opaque structure and implemented the two getters cucul_get_buffer_data() and cucul_get_buffer_size(). * Documented all missing functions and function parameters.
před 18 roky
​
​
​
​
​
* Renamed cucul_export into cucul_buffer. We'll use it for other things.
před 18 roky
* Documentation improvements. Wrote a small migration guide and added the skeleton of a tutorial for Jylam.
před 18 roky
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.
před 19 roky
* 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.
před 18 roky
* 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.
před 18 roky
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
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.
před 19 roky
* Documentation improvements. Wrote a small migration guide and added the skeleton of a tutorial for Jylam.
před 18 roky
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.
před 19 roky
​
​
​
​
* Renamed main canvas-related functions so that they have "canvas" in their name, eg. cucul_create() -> cucul_create_canvas() etc. * Moved buffer-related functions to cucul/buffer.c.
před 18 roky
* More error checking in libcucul.
před 18 roky
* Renamed main canvas-related functions so that they have "canvas" in their name, eg. cucul_create() -> cucul_create_canvas() etc. * Moved buffer-related functions to cucul/buffer.c.
před 18 roky
​
* More error checking in libcucul.
před 18 roky
* Removed math.c from cucul, it's beyond uselessness. Kept cucul_rand in cucul.c just in case.
před 18 roky
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.
před 19 roky
​
* Documentation improvements. Wrote a small migration guide and added the skeleton of a tutorial for Jylam.
před 18 roky
* Replaced "struct cucul_*" and "struct caca_*" types with opaque typedefs such as cucul_dither_t instead of struct cucul_dither. * Made cucul_buffer_t an opaque structure and implemented the two getters cucul_get_buffer_data() and cucul_get_buffer_size(). * Documented all missing functions and function parameters.
před 18 roky
​
​
​
* Implemented cucul_load_file() and cucul_load_memory() to load respectively a file and a memory area into a libcucul buffer. * Changed the cucul_import_canvas() prototype so that it uses libcucul buffers instead of simple memory areas.
před 18 roky
​
* Replaced "struct cucul_*" and "struct caca_*" types with opaque typedefs such as cucul_dither_t instead of struct cucul_dither. * Made cucul_buffer_t an opaque structure and implemented the two getters cucul_get_buffer_data() and cucul_get_buffer_size(). * Documented all missing functions and function parameters.
před 18 roky
​
* Check for <errno.h>. * Started changing function prototypes so that they return an integer instead of void, just in case they might fail.
před 18 roky
* Replaced "struct cucul_*" and "struct caca_*" types with opaque typedefs such as cucul_dither_t instead of struct cucul_dither. * Made cucul_buffer_t an opaque structure and implemented the two getters cucul_get_buffer_data() and cucul_get_buffer_size(). * Documented all missing functions and function parameters.
před 18 roky
​
* Documentation improvements. Wrote a small migration guide and added the skeleton of a tutorial for Jylam.
před 18 roky
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.
před 19 roky
* Added the cucul_blit() function. It lets us blit various canvas one onto the other with an optional mask.
před 18 roky
​
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.
před 19 roky
​
* Support for fullwidth glyphs in the libcaca output drivers.
před 18 roky
* More error checking in libcucul.
před 18 roky
​
* Implemented cucul_get_color().
před 18 roky
* 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.
před 18 roky
* Changed cucul_putchar's prototype so that it accepts a 32-bit unsigned int which shall be used as an UTF-32 character. We do not have any casting problems due to the signedness of chars because all characters were ASCII (ie. <= 0x7f) beforehands.
před 18 roky
* Implemented cucul_getchar(). Useful because you don’t necessarily know what you are importing.
před 18 roky
* More error checking in libcucul.
před 18 roky
​
​
* Implement cucul_set_canvas_boundaries() for cropping and expanding.
před 18 roky
​
​
​
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.
před 19 roky
​
* Documentation improvements. Wrote a small migration guide and added the skeleton of a tutorial for Jylam.
před 18 roky
* Added cucul_flip(), cucul_flop() and cucul_transform() to perform operations on canvases.
před 18 roky
​
​
​
* Completed return value and errno handling in libcucul API.
před 18 roky
​
​
​
* Added cucul_flip(), cucul_flop() and cucul_transform() to perform operations on canvases.
před 18 roky
​
* Export the UTF-8 / UTF-32 / CP437 character conversions to applications.
před 18 roky
​
​
​
​
* Have cucul_utf8_to_utf32 write how many bytes it read. * Use that in the SLang driver so that it supports UTF-8 input.
před 18 roky
* Export the UTF-8 / UTF-32 / CP437 character conversions to applications.
před 18 roky
​
​
* Implemented cucul_utf32_is_fullwidth().
před 18 roky
* Export the UTF-8 / UTF-32 / CP437 character conversions to applications.
před 18 roky
​
* Documentation improvements. Wrote a small migration guide and added the skeleton of a tutorial for Jylam.
před 18 roky
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.
před 19 roky
​
​
​
​
* Check for <errno.h>. * Started changing function prototypes so that they return an integer instead of void, just in case they might fail.
před 18 roky
​
​
​
* Renamed cucul_t into cucul_canvas_t. Eh ouais mon con.
před 18 roky
* Check for <errno.h>. * Started changing function prototypes so that they return an integer instead of void, just in case they might fail.
před 18 roky
​
​
​
* Renamed cucul_t into cucul_canvas_t. Eh ouais mon con.
před 18 roky
* Check for <errno.h>. * Started changing function prototypes so that they return an integer instead of void, just in case they might fail.
před 18 roky
​
​
* Renamed cucul_t into cucul_canvas_t. Eh ouais mon con.
před 18 roky
* Check for <errno.h>. * Started changing function prototypes so that they return an integer instead of void, just in case they might fail.
před 18 roky
​
​
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.
před 19 roky
​
* Support for multiple frames in canvases.
před 18 roky
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.
před 19 roky
* Support for multiple frames in canvases.
před 18 roky
​
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.
před 19 roky
​
* Support for multiple frames in canvases.
před 18 roky
* Completed return value and errno handling in libcucul API.
před 18 roky
​
​
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.
před 19 roky
​
* Documentation improvements. Wrote a small migration guide and added the skeleton of a tutorial for Jylam.
před 18 roky
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.
před 19 roky
* Renamed *bitmap to *dither. Ben ouais connard, je fais ce que je veux.
před 18 roky
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.
před 19 roky
​
​
* Replaced "struct cucul_*" and "struct caca_*" types with opaque typedefs such as cucul_dither_t instead of struct cucul_dither. * Made cucul_buffer_t an opaque structure and implemented the two getters cucul_get_buffer_data() and cucul_get_buffer_size(). * Documented all missing functions and function parameters.
před 18 roky
* Support for multiple frames in canvases.
před 18 roky
* Changed the cucul_create_dither() prototype to make sure the mask arguments are at least 32 bits.
před 18 roky
​
* Completed return value and errno handling in libcucul API.
před 18 roky
​
​
​
​
​
​
​
* Replaced "struct cucul_*" and "struct caca_*" types with opaque typedefs such as cucul_dither_t instead of struct cucul_dither. * Made cucul_buffer_t an opaque structure and implemented the two getters cucul_get_buffer_data() and cucul_get_buffer_size(). * Documented all missing functions and function parameters.
před 18 roky
* Completed return value and errno handling in libcucul API.
před 18 roky
* Replaced "struct cucul_*" and "struct caca_*" types with opaque typedefs such as cucul_dither_t instead of struct cucul_dither. * Made cucul_buffer_t an opaque structure and implemented the two getters cucul_get_buffer_data() and cucul_get_buffer_size(). * Documented all missing functions and function parameters.
před 18 roky
* Completed return value and errno handling in libcucul API.
před 18 roky
* Replaced "struct cucul_*" and "struct caca_*" types with opaque typedefs such as cucul_dither_t instead of struct cucul_dither. * Made cucul_buffer_t an opaque structure and implemented the two getters cucul_get_buffer_data() and cucul_get_buffer_size(). * Documented all missing functions and function parameters.
před 18 roky
* Completed return value and errno handling in libcucul API.
před 18 roky
* Replaced "struct cucul_*" and "struct caca_*" types with opaque typedefs such as cucul_dither_t instead of struct cucul_dither. * Made cucul_buffer_t an opaque structure and implemented the two getters cucul_get_buffer_data() and cucul_get_buffer_size(). * Documented all missing functions and function parameters.
před 18 roky
* Completed return value and errno handling in libcucul API.
před 18 roky
* Replaced "struct cucul_*" and "struct caca_*" types with opaque typedefs such as cucul_dither_t instead of struct cucul_dither. * Made cucul_buffer_t an opaque structure and implemented the two getters cucul_get_buffer_data() and cucul_get_buffer_size(). * Documented all missing functions and function parameters.
před 18 roky
* Completed return value and errno handling in libcucul API.
před 18 roky
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.
před 19 roky
​
* Documentation improvements. Wrote a small migration guide and added the skeleton of a tutorial for Jylam.
před 18 roky
* Slightly updated the font format and wrote a font loader. Also added a skeleton for the renderer that will not last very long.
před 18 roky
​
​
​
​
* Replaced "struct cucul_*" and "struct caca_*" types with opaque typedefs such as cucul_dither_t instead of struct cucul_dither. * Made cucul_buffer_t an opaque structure and implemented the two getters cucul_get_buffer_data() and cucul_get_buffer_size(). * Documented all missing functions and function parameters.
před 18 roky
* 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.
před 18 roky
* Replaced "struct cucul_*" and "struct caca_*" types with opaque typedefs such as cucul_dither_t instead of struct cucul_dither. * Made cucul_buffer_t an opaque structure and implemented the two getters cucul_get_buffer_data() and cucul_get_buffer_size(). * Documented all missing functions and function parameters.
před 18 roky
​
* Implemented cucul_get_font_blocks() to export the list of available glyphs.
před 18 roky
* Completed return value and errno handling in libcucul API.
před 18 roky
* 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.
před 18 roky
* Completed return value and errno handling in libcucul API.
před 18 roky
* Slightly updated the font format and wrote a font loader. Also added a skeleton for the renderer that will not last very long.
před 18 roky
​
* Moved cucul_load_canvas() into cucul/import.c and renamed it into cucul_import_canvas(). * Renamed cucul_create_export() into cucul_export_canvas() for consistency.
před 18 roky
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.
před 19 roky
* Moved cucul_load_canvas() into cucul/import.c and renamed it into cucul_import_canvas(). * Renamed cucul_create_export() into cucul_export_canvas() for consistency.
před 18 roky
​
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.
před 19 roky
​
* Moved cucul_load_canvas() into cucul/import.c and renamed it into cucul_import_canvas(). * Renamed cucul_create_export() into cucul_export_canvas() for consistency.
před 18 roky
* Added cucul_get_export_list(). Returns a list of known export formats.
před 18 roky
* Implemented cucul_load_file() and cucul_load_memory() to load respectively a file and a memory area into a libcucul buffer. * Changed the cucul_import_canvas() prototype so that it uses libcucul buffers instead of simple memory areas.
před 18 roky
* Moved cucul_load_canvas() into cucul/import.c and renamed it into cucul_import_canvas(). * Renamed cucul_create_export() into cucul_export_canvas() for consistency.
před 18 roky
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.
před 19 roky
​
​
​
​
​
​
 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238 
  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. /** libcucul API version */

  27. #define CUCUL_API_VERSION_1

  28. 

  29. #ifdef __cplusplus

  30. extern "C"

  31. {

  32. #endif

  33. 

  34. /** \e libcucul canvas */

  35. typedef struct cucul_canvas cucul_canvas_t;

  36. /** dither structure */

  37. typedef struct cucul_dither cucul_dither_t;

  38. /** data buffer structure */

  39. typedef struct cucul_buffer cucul_buffer_t;

  40. /** font structure */

  41. typedef struct cucul_font cucul_font_t;

  42. 

  43. /** \defgroup colour libcucul colour definitions

  44.  *

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

  46.  *

  47.  *  @{ */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  66. /*  @} */

  67. 

  68. /** \defgroup cucul libcucul basic functions

  69.  *

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

  71.  *  initialisation, system information retrieval and configuration.

  72.  *

  73.  *  @{ */

  74. cucul_canvas_t * cucul_create_canvas(unsigned int, unsigned int);

  75. int cucul_set_canvas_size(cucul_canvas_t *, unsigned int, unsigned int);

  76. unsigned int cucul_get_canvas_width(cucul_canvas_t *);

  77. unsigned int cucul_get_canvas_height(cucul_canvas_t *);

  78. int cucul_free_canvas(cucul_canvas_t *);

  79. int cucul_rand(int, int);

  80. /*  @} */

  81. 

  82. /** \defgroup buffer libcucul buffer handling

  83.  *

  84.  *  These functions provide methods to handle libcucul buffers.

  85.  *

  86.  *  @{ */

  87. cucul_buffer_t *cucul_load_memory(void *, unsigned long int);

  88. cucul_buffer_t *cucul_load_file(char const *);

  89. unsigned long int cucul_get_buffer_size(cucul_buffer_t *);

  90. void * cucul_get_buffer_data(cucul_buffer_t *);

  91. int cucul_free_buffer(cucul_buffer_t *);

  92. /*  @} */

  93. 

  94. /** \defgroup canvas libcucul canvas drawing

  95.  *

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

  97.  *  higher level graphics functions.

  98.  *

  99.  *  @{ */

  100. #define CUCUL_MAGIC_FULLWIDTH 0x000ffffe /**< Used to indicate that the previous character was a fullwidth glyph. */

  101. int cucul_set_color(cucul_canvas_t *, unsigned char, unsigned char);

  102. int cucul_set_truecolor(cucul_canvas_t *, unsigned int, unsigned int);

  103. unsigned long int cucul_get_color(cucul_canvas_t *, int, int);

  104. char const *cucul_get_color_name(unsigned int);

  105. int cucul_putchar(cucul_canvas_t *, int, int, unsigned long int);

  106. unsigned long int cucul_getchar(cucul_canvas_t *, int, int);

  107. int cucul_putstr(cucul_canvas_t *, int, int, char const *);

  108. int cucul_printf(cucul_canvas_t *, int, int, char const *, ...);

  109. int cucul_clear_canvas(cucul_canvas_t *);

  110. int cucul_blit(cucul_canvas_t *, int, int, cucul_canvas_t const *,

  111.                cucul_canvas_t const *);

  112. int cucul_set_canvas_boundaries(cucul_canvas_t *, int, int,

  113.                                 unsigned int, unsigned int);

  114. /*  @} */

  115. 

  116. /** \defgroup transform libcucul canvas transformation

  117.  *

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

  119.  *

  120.  *  @{ */

  121. int cucul_invert(cucul_canvas_t *);

  122. int cucul_flip(cucul_canvas_t *);

  123. int cucul_flop(cucul_canvas_t *);

  124. int cucul_rotate(cucul_canvas_t *);

  125. /*  @} */

  126. 

  127. /** \defgroup charset libcucul character set conversions

  128.  *

  129.  *  These functions perform conversions between usual character sets.

  130.  *

  131.  *  @{ */

  132. extern unsigned long int cucul_utf8_to_utf32(char const *, unsigned int *);

  133. extern unsigned int cucul_utf32_to_utf8(char *, unsigned long int);

  134. extern unsigned char cucul_utf32_to_cp437(unsigned long int);

  135. extern unsigned long int cucul_cp437_to_utf32(unsigned char);

  136. extern int cucul_utf32_is_fullwidth(unsigned long int);

  137. /*  @} */

  138. 

  139. /** \defgroup prim libcucul primitives drawing

  140.  *

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

  142.  *  boxes, triangles and ellipses.

  143.  *

  144.  *  @{ */

  145. int cucul_draw_line(cucul_canvas_t *, int, int, int, int, char const *);

  146. int cucul_draw_polyline(cucul_canvas_t *, int const x[], int const y[], int, char const *);

  147. int cucul_draw_thin_line(cucul_canvas_t *, int, int, int, int);

  148. int cucul_draw_thin_polyline(cucul_canvas_t *, int const x[], int const y[], int);

  149. 

  150. int cucul_draw_circle(cucul_canvas_t *, int, int, int, char const *);

  151. int cucul_draw_ellipse(cucul_canvas_t *, int, int, int, int, char const *);

  152. int cucul_draw_thin_ellipse(cucul_canvas_t *, int, int, int, int);

  153. int cucul_fill_ellipse(cucul_canvas_t *, int, int, int, int, char const *);

  154. 

  155. int cucul_draw_box(cucul_canvas_t *, int, int, int, int, char const *);

  156. int cucul_draw_thin_box(cucul_canvas_t *, int, int, int, int);

  157. int cucul_fill_box(cucul_canvas_t *, int, int, int, int, char const *);

  158. 

  159. int cucul_draw_triangle(cucul_canvas_t *, int, int, int, int, int, int, char const *);

  160. int cucul_draw_thin_triangle(cucul_canvas_t *, int, int, int, int, int, int);

  161. int cucul_fill_triangle(cucul_canvas_t *, int, int, int, int, int, int, char const *);

  162. /*  @} */

  163. 

  164. /** \defgroup frame libcucul canvas frame handling

  165.  *

  166.  *  These functions provide high level routines for canvas frame insertion,

  167.  *  removal, copying etc.

  168.  *

  169.  *  @{ */

  170. unsigned int cucul_get_canvas_frame_count(cucul_canvas_t *);

  171. int cucul_set_canvas_frame(cucul_canvas_t *, unsigned int);

  172. int cucul_create_canvas_frame(cucul_canvas_t *, unsigned int);

  173. int cucul_free_canvas_frame(cucul_canvas_t *, unsigned int);

  174. /*  @} */

  175. 

  176. /** \defgroup dither libcucul bitmap dithering

  177.  *

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

  179.  *  rendering.

  180.  *

  181.  *  @{ */

  182. cucul_dither_t *cucul_create_dither(unsigned int, unsigned int,

  183.                                     unsigned int, unsigned int,

  184.                                     unsigned long int, unsigned long int,

  185.                                     unsigned long int, unsigned long int);

  186. int cucul_set_dither_palette(cucul_dither_t *,

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

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

  189. int cucul_set_dither_brightness(cucul_dither_t *, float);

  190. int cucul_set_dither_gamma(cucul_dither_t *, float);

  191. int cucul_set_dither_contrast(cucul_dither_t *, float);

  192. int cucul_set_dither_invert(cucul_dither_t *, int);

  193. int cucul_set_dither_antialias(cucul_dither_t *, char const *);

  194. char const * const * cucul_get_dither_antialias_list(cucul_dither_t const *);

  195. int cucul_set_dither_color(cucul_dither_t *, char const *);

  196. char const * const * cucul_get_dither_color_list(cucul_dither_t const *);

  197. int cucul_set_dither_charset(cucul_dither_t *, char const *);

  198. char const * const * cucul_get_dither_charset_list(cucul_dither_t const *);

  199. int cucul_set_dither_mode(cucul_dither_t *, char const *);

  200. char const * const * cucul_get_dither_mode_list(cucul_dither_t const *);

  201. int cucul_dither_bitmap(cucul_canvas_t *, int, int, int, int,

  202.                          cucul_dither_t const *, void *);

  203. int cucul_free_dither(cucul_dither_t *);

  204. /*  @} */

  205. 

  206. /** \defgroup font libcucul font handling

  207.  *

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

  209.  *  canvas to bitmap rendering.

  210.  *

  211.  *  @{ */

  212. cucul_font_t *cucul_load_font(void const *, unsigned int);

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

  214. unsigned int cucul_get_font_width(cucul_font_t *);

  215. unsigned int cucul_get_font_height(cucul_font_t *);

  216. unsigned long int const *cucul_get_font_blocks(cucul_font_t *);

  217. int cucul_render_canvas(cucul_canvas_t *, cucul_font_t *, void *,

  218.                          unsigned int, unsigned int, unsigned int);

  219. int cucul_free_font(cucul_font_t *);

  220. /*  @} */

  221. 

  222. /** \defgroup importexport libcucul importers/exporters from/to various formats

  223.  *

  224.  *  These functions import various file formats into a new canvas, or export

  225.  *  the current canvas to various text formats.

  226.  *

  227.  *  @{ */

  228. cucul_buffer_t * cucul_export_canvas(cucul_canvas_t *, char const *);

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

  230. cucul_canvas_t * cucul_import_canvas(cucul_buffer_t *, char const *);

  231. char const * const * cucul_get_import_list(void);

  232. /*  @} */

  233. 

  234. #ifdef __cplusplus

  235. }

  236. #endif

  237. 

  238. #endif /* __CUCUL_H__ */