cairo_face::cairo_face(boost::shared_ptr<freetype_engine> const& engine, face_ptr const& face)
: face_(face)
{
static cairo_user_data_key_t key;
c_face_ = cairo_ft_font_face_create_for_ft_face(face->get_face(), FT_LOAD_NO_HINTING);
cairo_font_face_set_user_data(c_face_, &key, new handle(engine, face), destroy);
}
static cairo_font_face_t *
font_face_create(gchar *fontfile){
FT_Error error;
FT_Library library;
FT_Face face;
GFile *file;
gchar *font_file;
error = FT_Init_FreeType (&library);
if (error) {
g_printerr("Could not initialise freetype\n");
exit(1);
}
file = g_file_new_for_commandline_arg (fontfile);
font_file = g_file_get_uri (file);
g_object_unref (file);
if (!font_file) {
g_printerr("Could not parse argument into a URI\n");
exit(1);
}
error = FT_New_Face_From_URI (library, font_file, 0, &face);
if (error) {
g_printerr("Could not load face '%s'\n", font_file);
exit(1);
}
return cairo_ft_font_face_create_for_ft_face (face, 0);
}
static void
draw (GtkWidget *drawing_area,
cairo_t *cr,
FT_Face face)
{
cairo_font_extents_t font_extents;
gint *sizes = NULL, n_sizes, alpha_size, pos_y, i;
const gchar *text;
cairo_font_face_t *font;
text = get_sample_string (face);
sizes = build_sizes_table (face, &n_sizes, &alpha_size);
font = cairo_ft_font_face_create_for_ft_face (face, 0);
cairo_set_font_face (cr, font);
cairo_font_extents (cr, &font_extents);
cairo_font_face_destroy (font);
/* draw text */
pos_y = MAX (font_extents.height, 32) + 4;
cairo_set_font_size (cr, alpha_size);
draw_string (cr, lowercase_text, &pos_y);
draw_string (cr, uppercase_text, &pos_y);
draw_string (cr, punctuation_text, &pos_y);
pos_y += 8;
for (i = 0; i < n_sizes; i++) {
cairo_set_font_size (cr, sizes[i]);
draw_string (cr, text, &pos_y);
}
g_free (sizes);
}
faceCacheObj *getFontFace(cairoCacheData *cache, const char *font)
{
faceCacheObj *newface = NULL;
faceCacheObj *cur=cache->facecache;
while(cur) {
if(!strcmp(cur->path,font))
return cur;
cur = cur->next;
}
newface = malloc(sizeof(faceCacheObj));
if(FT_New_Face(cache->library, font, 0, &(newface->ftface))) {
msSetError(MS_RENDERERERR,"Freetype failed to open font %s","getFontFace()",font);
free(newface);
return NULL;
}
/* Try to select charmap */
if (!newface->ftface->charmap) {
if( FT_Select_Charmap(newface->ftface, FT_ENCODING_MS_SYMBOL) )
FT_Select_Charmap(newface->ftface, FT_ENCODING_APPLE_ROMAN );
}
newface->next = cache->facecache;
cache->facecache = newface;
newface->face = cairo_ft_font_face_create_for_ft_face(newface->ftface, 0);
cairo_font_face_set_user_data (newface->face, &newface->facekey,
&(newface->ftface), (cairo_destroy_func_t) NULL); // we call FT_Done_Face ourselves in freeFaceCache
newface->path = msStrdup(font);
return newface;
}
void load_font(caStack* stack)
{
caValue* filename = circa_input(stack, 0);
FontFace* font = new FontFace();
circa_read_file_with_stack(stack, circa_string(filename), &font->rawData);
if (circa_is_null(&font->rawData))
return circa_output_error(stack, "Failed to load file");
if (!g_ftLibraryInitialized) {
FT_Init_FreeType(&g_ftLibrary);
g_ftLibraryInitialized = true;
}
int error = FT_New_Memory_Face(g_ftLibrary,
(FT_Byte*) circa_blob(&font->rawData),
circa_blob_size(&font->rawData),
0,
&font->ftFace);
if (error)
return circa_output_error(stack, "FT_New_Memory_Face failed");
font->cairoFace = cairo_ft_font_face_create_for_ft_face(font->ftFace, 0);
caValue* out = circa_set_default_output(stack, 0);
circa_set_native_ptr(circa_index(out, 0), font, FontFaceRelease);
}
static VALUE
cr_freetype_font_face_initialize (VALUE self, VALUE path)
{
FT_Face freetype_face;
FT_Error error;
cairo_font_face_t *face;
cairo_status_t status;
error = FT_New_Face (cr_freetype_library,
StringValueCStr(path),
0,
&freetype_face);
cr_freetype_error_check (error, "failed to open FreeType font", path);
cr_freetype_n_faces++;
face = cairo_ft_font_face_create_for_ft_face (freetype_face, 0);
cr_font_face_check_status (face);
status =
cairo_font_face_set_user_data (face,
&cr_freetype_face_key,
freetype_face,
(cairo_destroy_func_t) cr_freetype_done_face);
if (status != CAIRO_STATUS_SUCCESS) {
cairo_font_face_destroy (face);
FT_Done_Face (freetype_face);
rb_cairo_check_status (status);
}
DATA_PTR (self) = face;
return Qnil;
}
faceCacheObj *getFontFace(cairoCacheData *cache, char *font) {
faceCacheObj *newface = NULL;
faceCacheObj *cur=cache->facecache;
while(cur) {
if(!strcmp(cur->path,font))
return cur;
cur = cur->next;
}
newface = malloc(sizeof(faceCacheObj));
if(FT_New_Face(cache->library, font, 0, &(newface->ftface))) {
msSetError(MS_RENDERERERR,"Freetype failed to open font %s","getFontFace()",font);
free(newface);
return NULL;
}
newface->next = cache->facecache;
cache->facecache = newface;
newface->face = cairo_ft_font_face_create_for_ft_face(newface->ftface, 0);
cairo_font_face_set_user_data (newface->face, &newface->facekey,
&(newface->ftface), (cairo_destroy_func_t) FT_Done_Face);
newface->path = msStrdup(font);
return newface;
}
cairo_face::cairo_face(std::shared_ptr<font_library> const& library, face_ptr const& face)
: face_(face)
{
static cairo_user_data_key_t key;
c_face_ = cairo_ft_font_face_create_for_ft_face(face->get_face(), FT_LOAD_NO_HINTING);
cairo_font_face_set_user_data(c_face_, &key, new handle(library, face), destroy);
}
void CairoRenderer::SetFontFace(InputStream *pStream)
{
FT_Face face;
static cairo_user_data_key_t key;
if (m_cairo_face)
{
cairo_set_font_face(m_pCairo, NULL);
cairo_font_face_destroy(m_cairo_face);
m_cairo_face = NULL;
}
if (pStream)
{
face = FreeType::OpenFace(pStream); // face will be destroyed by FT_Done_Face
if (face)
{
m_cairo_face = cairo_ft_font_face_create_for_ft_face(face, 0);
cairo_font_face_set_user_data(m_cairo_face, &key, face, (cairo_destroy_func_t)FT_Done_Face);
}
}
else
m_cairo_face = cairo_toy_font_face_create("unifont", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
if (m_cairo_face)
cairo_set_font_face(m_pCairo, m_cairo_face);
}
FontCustomPlatformData* createFontCustomPlatformData(SharedBuffer* buffer)
{
ASSERT_ARG(buffer, buffer);
int error;
static FT_Library library = 0;
if (!library) {
error = FT_Init_FreeType(&library);
if (error) {
library = 0;
return 0;
}
}
FT_Face face;
error = FT_New_Memory_Face(library, reinterpret_cast<const FT_Byte*>(buffer->data()), buffer->size(), 0, &face);
if (error)
return 0;
buffer->ref();
cairo_font_face_t* fontFace = cairo_ft_font_face_create_for_ft_face(face, 0);
static cairo_user_data_key_t bufferKey;
cairo_font_face_set_user_data(fontFace, &bufferKey, buffer, releaseData);
return new FontCustomPlatformData(fontFace);
}
static int l_font_new(lua_State * L)
{
const char * family = luaL_checkstring(L, 1);
struct lfont_t * font = lua_newuserdata(L, sizeof(struct lfont_t));
if(FT_Init_FreeType(&font->library))
return 0;
if(FT_New_Xfs_Face(font->library, family, 0, &font->fface))
{
FT_Done_FreeType(font->library);
return 0;
}
font->face = cairo_ft_font_face_create_for_ft_face(font->fface, 0);
if(font->face->status != CAIRO_STATUS_SUCCESS)
{
FT_Done_Face(font->fface);
FT_Done_FreeType(font->library);
cairo_font_face_destroy(font->face);
return 0;
}
cairo_font_options_t * options = cairo_font_options_create();
cairo_matrix_t identity;
cairo_matrix_init_identity(&identity);
font->sfont = cairo_scaled_font_create(font->face, &identity, &identity, options);
cairo_font_options_destroy(options);
if(cairo_scaled_font_status(font->sfont) != CAIRO_STATUS_SUCCESS)
{
FT_Done_Face(font->fface);
FT_Done_FreeType(font->library);
cairo_font_face_destroy(font->face);
cairo_scaled_font_destroy(font->sfont);
return 0;
}
luaL_setmetatable(L, MT_FONT);
return 1;
}
unsigned int init_font(FontFace *font, char *path)
{
unsigned int result = FT_New_Face(library, path, 0, &font->ft_font);
if (0 == result) {
font->cairo_font = cairo_ft_font_face_create_for_ft_face(font->ft_font, 0);
}
return result;
}
double lime_cairo_ft_font_face_create (double face, int flags) {
#ifdef LIME_FREETYPE
Font *font = (Font*)(intptr_t)face;
return (intptr_t)cairo_ft_font_face_create_for_ft_face ((FT_Face)font->face, flags);
#else
return 0;
#endif
}
static void
realize_callback (GtkWidget *drawing_area,
FT_Face face)
{
gint i, pixmap_width, pixmap_height;
const gchar *text;
cairo_text_extents_t extents;
cairo_font_face_t *font;
gint *sizes = NULL, n_sizes, alpha_size;
cairo_t *cr;
cr = gdk_cairo_create (gtk_widget_get_window (drawing_area));
text = get_sample_string (face);
sizes = build_sizes_table (face, &n_sizes, &alpha_size);
/* calculate size of pixmap to use (with 4 pixels padding) ... */
pixmap_width = 8;
pixmap_height = 8;
font = cairo_ft_font_face_create_for_ft_face (face, 0);
cairo_set_font_face (cr, font);
cairo_set_font_size (cr, alpha_size);
cairo_font_face_destroy (font);
cairo_text_extents (cr, lowercase_text, &extents);
pixmap_height += extents.height + 4;
pixmap_width = MAX (pixmap_width, 8 + extents.width);
cairo_text_extents (cr, uppercase_text, &extents);
pixmap_height += extents.height + 4;
pixmap_width = MAX (pixmap_width, 8 + extents.width);
cairo_text_extents (cr, punctuation_text, &extents);
pixmap_height += extents.height + 4;
pixmap_width = MAX (pixmap_width, 8 + extents.width);
pixmap_height += 8;
for (i = 0; i < n_sizes; i++) {
cairo_set_font_size (cr, sizes[i]);
cairo_text_extents (cr, text, &extents);
pixmap_height += extents.height + 4;
pixmap_width = MAX (pixmap_width, 8 + extents.width);
}
gtk_widget_set_size_request (drawing_area, pixmap_width, pixmap_height);
cairo_destroy (cr);
g_free (sizes);
}
struct GUIConfig *guiConfig()
{
static struct GUIConfig *gconfig = 0;
FT_Face face;
FT_Library library;
if (!gconfig) {
gconfig = (struct GUIConfig*)malloc(sizeof(struct GUIConfig));
gconfig->borderSize = DEFAULT_BORDER_SIZE;
gconfig->titleHeight = DEFAULT_TITLE_HEIGHT;
FT_Init_FreeType(&library);
FT_New_Face(library, "C:/zenhei.ttc", 0, &face);
gconfig->fontFace = cairo_ft_font_face_create_for_ft_face(face,0);
}
return gconfig;
}
value lime_cairo_ft_font_face_create (value face, int flags) {
#ifdef LIME_FREETYPE
Font* font = (Font*)val_data (face);
cairo_font_face_t* cairoFont = cairo_ft_font_face_create_for_ft_face ((FT_Face)font->face, flags);
AutoGCRoot* fontReference = new AutoGCRoot (face);
cairo_font_face_set_user_data (cairoFont, &userData, fontReference, gc_user_data);
return CFFIPointer (cairoFont, gc_cairo_font_face);
#else
return 0;
#endif
}
static cairoFaceCache* getCairoFontFace(cairoCacheData *cache, FT_Face ftface) {
cairoFaceCache *cur = cache->cairofacecache;
while(cur) {
if(cur->ftface == ftface) return cur;
cur = cur->next;
}
cur = msSmallMalloc(sizeof(cairoFaceCache));
cur->next = cache->cairofacecache;
cache->cairofacecache = cur;
cur->ftface = ftface;
cur->face = cairo_ft_font_face_create_for_ft_face(ftface, 0);
cur->options = cairo_font_options_create();
cairo_font_options_set_hint_style(cur->options,CAIRO_HINT_STYLE_NONE);
return cur;
}
cairo_font_face_t *Rcairo_set_font_face(int i, const char *file){
cairo_font_face_t *c_face;
cairo_status_t status;
FT_Face face;
FT_Error er;
FT_CharMap found = 0;
FT_CharMap charmap;
int n;
/* Ensure that freetype library is ready */
if (!Rcairo_ft_library){
if (FT_Init_FreeType(&Rcairo_ft_library)){
error("Failed to initialize freetype library in Rcairo_set_font_face!\n");
return FALSE;
}
}
er = FT_New_Face(Rcairo_ft_library, file, 0, &face);
if ( er == FT_Err_Unknown_File_Format ) {
error("Unsupported font file format\n");
return NULL;
} else if ( er ) {
error("Unknown font problem\n");
return NULL;
}
for ( n = 0; n < face->num_charmaps; n++ ) {
charmap = face->charmaps[n];
if ( charmap->platform_id == TT_PLATFORM_MACINTOSH) {
found = charmap;
break;
}
}
/* Only do this for symbol font */
if (found && i == 4){
er = FT_Set_Charmap( face, found );
}
c_face = cairo_ft_font_face_create_for_ft_face(face,FT_LOAD_DEFAULT);
status = cairo_font_face_set_user_data (c_face, &key,
face, (cairo_destroy_func_t) FT_Done_Face);
if (status) {
cairo_font_face_destroy (c_face);
FT_Done_Face (face);
return NULL;
}
return c_face;
}
cairo_font_face_t *load_font_face() {
FT_Library lib;
FT_Face face;
FT_Error error;
cairo_font_face_t *cr_face;
char *path = "/Users/sseefried/code/games/epidemic-game/GoodDog.otf";
error = FT_Init_FreeType(&lib);
exitOnError(error);
error = FT_New_Face(lib, path, 0, &face);
exitOnError(error);
cr_face = cairo_ft_font_face_create_for_ft_face(face, 0);
return cr_face;
}
FontCustomPlatformData::FontCustomPlatformData(FT_Face freeTypeFace, SharedBuffer& buffer)
: m_freeTypeFace(freeTypeFace)
, m_fontFace(cairo_ft_font_face_create_for_ft_face(freeTypeFace, 0))
{
// FIXME Should we be setting some hinting options here?
buffer.ref(); // This is balanced by the buffer->deref() in releaseCustomFontData.
static cairo_user_data_key_t bufferKey;
cairo_font_face_set_user_data(m_fontFace, &bufferKey, &buffer,
static_cast<cairo_destroy_func_t>(releaseCustomFontData));
// Cairo doesn't do FreeType reference counting, so we need to ensure that when
// this cairo_font_face_t is destroyed, it cleans up the FreeType face as well.
static cairo_user_data_key_t freeTypeFaceKey;
cairo_font_face_set_user_data(m_fontFace, &freeTypeFaceKey, freeTypeFace,
reinterpret_cast<cairo_destroy_func_t>(FT_Done_Face));
}
ilA_img *ilG_gui_textlayout_render(ilG_gui_textlayout *self, float col[4], enum ilG_gui_textoptions opts)
{
(void)opts;
unsigned w = 0, h = 0;
unsigned x = 0, y = 0;
int bx = 0, by = 0;
int scale = 64;
unsigned i;
self->cairo_ft_face = cairo_ft_font_face_create_for_ft_face(self->ft_face, 0);
self->hb_ft_face = hb_ft_face_create(self->ft_face, NULL);
x *= scale;
y *= scale;
self->cairo_glyphs = calloc(self->glyph_count, sizeof(cairo_glyph_t));
for (i = 0; i < self->glyph_count; i++) {
self->cairo_glyphs[i].index = self->glyph_info[i].codepoint;
self->cairo_glyphs[i].x = (x + self->glyph_pos[i].x_offset)/scale;
self->cairo_glyphs[i].y = (y + self->glyph_pos[i].y_offset)/scale;
x += self->glyph_pos[i].x_advance;
y += self->glyph_pos[i].y_advance;
}
ilG_gui_textlayout_getExtents(self, &w, &h, &bx, &by, NULL, NULL);
self->surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, w, h);
self->cr = cairo_create(self->surface);
cairo_translate(self->cr, -bx, 1-by);
cairo_set_source_rgba(self->cr, col[0], col[1], col[2], col[3]);
cairo_set_font_face(self->cr, self->cairo_ft_face);
cairo_set_font_size(self->cr, self->pt);
cairo_show_glyphs(self->cr, self->cairo_glyphs, self->glyph_count);
cairo_surface_flush(self->surface);
ilA_img *preswizzle = ilA_img_fromdata(cairo_image_surface_get_data(self->surface), w, h, 8, ILA_IMG_RGBA);
/* R G B A | 0x
* B 0 0 1 0 | 2
* G 0 1 0 0 | 4
* R 1 0 0 0 | 8
* A 0 0 0 1 | 1
*/
ilA_img *img = ilA_img_bgra_to_rgba(preswizzle);//ilA_img_swizzle(preswizzle, 0x2481);
ilA_img_free(preswizzle);
return img;
}
static int cairo_font_face_create_l( lua_State* L )
{
const char* filename = luaL_checkstring( L, 1 );
lua_cairo_font_face_t* lcff = (lua_cairo_font_face_t*)lua_newuserdata( L, sizeof( lua_cairo_font_face_t ) );
memset( lcff, 0, sizeof( lua_cairo_font_face_t ) );
luaL_getmetatable( L, "lua_cairo_font_face_t" );
lua_setmetatable( L, -2 );
if ( FT_New_Face( m_ftlibrary, filename, 0, &lcff->ftface ) ) {
luaL_error( L, "Failed to load font from file %s", filename );
}
if ( !( lcff->crface = cairo_ft_font_face_create_for_ft_face( lcff->ftface, 0 ) ) ) {
luaL_error( L, "cairo_ft_font_face_create_for_ft_face() failed for font %s", filename );
}
return( 1 );
}
int addfont(char * filepath, char * key)
{
fontface * face;
int error;
// we'll only accept font keys of a certain size
if ( (key != NULL) && (strlen(key) > MAX_FONT_NAME_LEN) ) return;
if ( strlen(strrchr(filepath, '/')+1) > MAX_FONT_NAME_LEN ) return;
face = malloc(sizeof(fontface));
if ( face == NULL ) { return ENOMEM; }
face->ftface = malloc(sizeof(FT_Face));
if ( face->ftface == NULL ) { return ENOMEM; }
error = FT_New_Face(library, filepath, 0, face->ftface);
if ( error )
{
free(face->ftface);
free(face);
printf("cannot load font %s : Error code %d\n", filepath, error);
return error;
}
// why does this generate a warning?
face->cface = cairo_ft_font_face_create_for_ft_face(*(face->ftface), FT_LOAD_FORCE_AUTOHINT);
// Add to error logging when that's ready
// printf("Added \t%s\t%s\t%s\n", strrchr(filepath, '/')+1, (*(face->ftface))->family_name, (*(face->ftface))->style_name);
if ( key != NULL )
hash_set(faces, key, face);
else
hash_set(faces, strrchr(filepath, '/')+1, face);
return 0;
}
gboolean draw_overview_glyph (cairo_t* context, const char* font_file, gdouble width, gdouble height, gunichar character) {
FT_Face face;
int error;
gdouble units_per_em;
gdouble units;
gdouble advance;
int gid;
// private use area
if (0xe000 <= character && character <= 0xf8ff) {
return FALSE;
}
// control characters
if (character <= 0x001f || (0x007f <= character && character <= 0x008d)) {
return FALSE;
}
if (font_file == NULL) {
g_warning("font_file is null");
return FALSE;
}
gchar text[7];
int length = g_unichar_to_utf8 (character, text);
text[length] = '\0';
if (freetype_library == NULL) {
error = FT_Init_FreeType (&freetype_library);
if (error) {
g_warning ("Freetype init error %d.\n", error);
return FALSE;
}
}
error = FT_New_Face (freetype_library, font_file, 0, &face);
if (error) {
g_warning ("Freetype font face error %d\n", error);
return FALSE;
}
units_per_em = face->units_per_EM;
units = (height * 0.5) / units_per_em;
error = FT_Select_Charmap (face , FT_ENCODING_UNICODE);
if (error) {
g_warning ("Freetype can not use Unicode, error: %d\n", error);
FT_Done_Face (face);
return FALSE;
}
error = FT_Set_Char_Size (face, 0, 64, (int) height, (int) height);
if (error) {
g_warning ("FT_Set_Char_Size, error: %d.\n", error);
FT_Done_Face (face);
return FALSE;
}
error = FT_Set_Pixel_Sizes (face, 0, (int) (height * 0.5));
if (error) {
g_warning ("FT_Set_Pixel_Sizes, error: %d.\n", error);
FT_Done_Face (face);
return FALSE;
}
gid = FT_Get_Char_Index (face, character);
advance = 0;
if (gid != 0) {
FT_Load_Glyph(face, gid, FT_LOAD_DEFAULT | FT_LOAD_NO_BITMAP | FT_LOAD_NO_SCALE);
advance = face->glyph->metrics.horiAdvance;
advance *= units;
} else {
FT_Done_Face (face);
return FALSE;
}
static const cairo_user_data_key_t key;
cairo_save (context);
cairo_font_face_t* cairo_face = cairo_ft_font_face_create_for_ft_face (face, 0);
if (cairo_face == NULL) {
g_warning("cairo font face is null");
FT_Done_Face (face);
return FALSE;
}
int status = cairo_font_face_set_user_data (cairo_face, &key, face, (cairo_destroy_func_t) FT_Done_Face);
if (status != CAIRO_STATUS_SUCCESS) {
cairo_font_face_destroy (cairo_face);
FT_Done_Face (face);
return FALSE;
}
cairo_set_font_face (context, cairo_face);
cairo_set_font_size (context, height * 0.5);
gdouble x = (width - advance) / 2;
if (x < 0) {
x = 0;
}
cairo_move_to (context, x, height - 30);
cairo_show_text (context, text);
cairo_font_face_destroy (cairo_face);
cairo_restore (context);
// cairo closes the font face and the library must be kept open
return TRUE;
}
/**
* Initialize a new console
*/
Console* new_Console(cairo_t* context, double font_size)
{
//printf("Console::Console(cairo_t@%p)\n", context);
Console* self;
self = malloc(sizeof(Console));
self->head = null;
self->tail = null;
self->cursor = null;
self->width = default_width;
self->height = default_height;
self->pad = 4;
self->font_filename = "./Monaco_Linux.ttf"; /* TODO */
self->font_size = font_size;
self->transparency = 1.0;
self->antialias_text = false;
self->antialias_graphics = true;
/* initialize lithp, cairo - and define callbacks */
self->lithp = new_LithpInterpreter();
char* cairo_init [] = {
//"(set 'libcairo (xl:dlopen \"libcairo.dylib\"))",
//"(set 'libcairo (xl:dlopen \"libcairo.so.2\"))",
//"(set 'libcairo (xl:dlopen \"/Users/antoine/Projects/phlo/install/lib/libcairo.dylib\"))",
#if defined(__linux__)
"(set 'libcairo (xl:dlopen \"libcairo.so.2\"))",
#elif defined(__APPLE__) && defined(__MACH__)
"(set 'libcairo (xl:dlopen \"libcairo.dylib\"))",
#endif
"(set 'cairo:set-source-rgb (xl:dlsym libcairo \"cairo_set_source_rgb\"))",
"(set 'cairo:rectangle (xl:dlsym libcairo \"cairo_rectangle\"))",
"(set 'cairo:fill (xl:dlsym libcairo \"cairo_fill\"))",
"(set 'cairo:translate (xl:dlsym libcairo \"cairo_translate\"))",
"(set 'cairo:rotate (xl:dlsym libcairo \"cairo_rotate\"))",
"(set 'cairo:move-to (xl:dlsym libcairo \"cairo_move_to\"))",
"(set 'cairo:set-source-rgba (xl:dlsym libcairo \"cairo_set_source_rgba\"))",
"(set 'console:width 492)",
"(set 'console:height 344)",
"(set 'pi 3.141592)",
"(set 'pretty '(lambda (cr arc theta) "
" (cond ((lte arc 0.0) 0.0) "
" ('t (progn "
" (cairo:rotate cr theta) "
" (cairo:rectangle cr 20.0 20.0 140.0 20.0) "
" (cairo:fill cr) "
" (pretty cr (sub arc theta) theta)))))) ",
"(set 'console:expose-event '(lambda (context) "
" (cairo:set-source-rgb context 0.5 0.5 1.0) "
" (cairo:translate context (div console:width 2.0) (div console:height 2.0))"
" (pretty context (mul pi 2.0) (div pi 4.0))))",
//"(set 'console:expose-event '(lambda (context) ()))",
null
};
for (size_t t = 0; cairo_init[t] != null; t++) {
Expression* callback = Expression_parse_utf8(cairo_init[t], null, &self->lithp->symbol_list);
_gc_protect(callback);
Expression_eval(callback, self->lithp->environment);
_gc_unprotect(callback);
}
/* initialize and configure console font */
FT_Library library;
int error = FT_Init_FreeType(&library);
if (error) { perror("Could not open FreeType library"); exit(EXIT_FAILURE); }
self->font_face = malloc(sizeof(FT_Face*));
error = FT_New_Face(library, self->font_filename, 0, self->font_face);
if (error) { perror("Could not open font"); exit(EXIT_FAILURE); }
cairo_set_font_face(context, cairo_ft_font_face_create_for_ft_face(*self->font_face, 0));
cairo_set_font_size(context, self->font_size);
cairo_font_options_t* font_options = cairo_font_options_create();
cairo_get_font_options(context, font_options);
if (self->antialias_text) {
cairo_font_options_set_antialias(font_options, CAIRO_ANTIALIAS_NONE);
}
cairo_set_font_options(context, font_options);
self->font_extents = malloc(sizeof(cairo_font_extents_t));
cairo_font_extents(context, self->font_extents);
/* some sample text */
//wchar_t* test_text = L"ABCDEFGHIJKLM\nNOPQRSTUVWXYZ\nabcdefghijklm\nnopqrstuvwxyz\n1234567890\0";
wchar_t* test_text = L" \n ";
unsigned int n;
for (n = 0; n < wcslen(test_text); n++) {
// Console_append(self, test_text[n]);
Console_insert(self, test_text[n]);
}
self->cursor = self->head;
return self;
}
/**
* Handle console expose events
*/
void Console_expose(Console* self, cairo_t* context)
{
/* a pretty background */
cairo_save(context);
cairo_set_source_rgb(context, 1.0, 1.0, 1.0);
cairo_translate(context, self->width / 2, self->height / 2);
double t = pi / 4;
for (double n = 0; n < pi * 2; n += t) {
cairo_rectangle(context, 20, 20, 140, 40);
cairo_fill(context);
cairo_rotate(context, t);
}
cairo_restore(context);
/* set console:width and console:height */
char buf[256];
sprintf(buf, "(set 'console:width %d)", (int)self->width);
Expression* e = Expression_parse_utf8(buf, null, &self->lithp->symbol_list);
_gc_protect(e); Expression_eval(e, self->lithp->environment); _gc_unprotect(e);
sprintf(buf, "(set 'console:height %d)", (int)self->height);
e = Expression_parse_utf8(buf, null, &self->lithp->symbol_list);
_gc_protect(e); Expression_eval(e, self->lithp->environment); _gc_unprotect(e);
/* invoke callbacks inside lithp */
cairo_save(context);
Expression* fn = Expression_intern("console:expose-event", &self->lithp->symbol_list);
Expression* arg = _new_Expression(pointer);
arg->car = (void*)context;
_gc_protect(fn); _gc_protect(arg);
Expression* callback = Expression_cons(fn, (Expression_cons(arg, nil_)));
_gc_protect(callback);
Expression_eval(callback, self->lithp->environment);
_gc_unprotect(callback);
_gc_unprotect(arg); _gc_unprotect(fn);
cairo_restore(context);
/* force lithp to garbage collect - TODO fix */
self->lithp->gc->free_list = _gc_collect();
/* select font */
cairo_set_font_face(context, cairo_ft_font_face_create_for_ft_face(*self->font_face, 0));
cairo_set_font_size(context, self->font_size);
/* layout text */
Console_layout(self);
/* render text */
cairo_set_source_rgb(context, 0, 0, 0);
glyph_list* current = self->head;
while (current) {
cairo_show_glyphs(context, current->glyph, 1);
current = current->next;
}
/* render cursor */
cairo_set_source_rgba(context, 0, 0, 1, 0.5);
double x = 0;
double y = 0;
if (self->cursor) {
x = self->cursor->glyph->x; // + self->font_extents->max_x_advance;
y = self->cursor->glyph->y - self->font_extents->ascent;
}
cairo_rectangle(context, x, y, self->font_extents->max_x_advance, self->font_extents->height);
cairo_fill(context);
}
static gboolean
sushi_font_widget_draw (GtkWidget *drawing_area,
cairo_t *cr)
{
SushiFontWidget *self = SUSHI_FONT_WIDGET (drawing_area);
SushiFontWidgetPrivate *priv = self->priv;
gint *sizes = NULL, n_sizes, alpha_size, title_size, pos_y = 0, i;
cairo_font_face_t *font;
FT_Face face = priv->face;
GtkStyleContext *context;
GdkRGBA color;
GtkBorder padding;
GtkStateFlags state;
gint allocated_width, allocated_height;
if (face == NULL)
goto end;
context = gtk_widget_get_style_context (drawing_area);
state = gtk_style_context_get_state (context);
allocated_width = gtk_widget_get_allocated_width (drawing_area);
allocated_height = gtk_widget_get_allocated_height (drawing_area);
gtk_render_background (context, cr,
0, 0, allocated_width, allocated_height);
gtk_style_context_get_color (context, state, &color);
gtk_style_context_get_padding (context, state, &padding);
gdk_cairo_set_source_rgba (cr, &color);
sizes = build_sizes_table (face, &n_sizes, &alpha_size, &title_size);
font = cairo_ft_font_face_create_for_ft_face (face, 0);
cairo_set_font_face (cr, font);
cairo_font_face_destroy (font);
/* draw text */
if (self->priv->font_name != NULL) {
cairo_set_font_size (cr, title_size);
draw_string (self, cr, padding, self->priv->font_name, &pos_y);
}
if (pos_y > allocated_height)
goto end;
pos_y += SECTION_SPACING / 2;
cairo_set_font_size (cr, alpha_size);
if (self->priv->lowercase_text != NULL)
draw_string (self, cr, padding, self->priv->lowercase_text, &pos_y);
if (pos_y > allocated_height)
goto end;
if (self->priv->uppercase_text != NULL)
draw_string (self, cr, padding, self->priv->uppercase_text, &pos_y);
if (pos_y > allocated_height)
goto end;
if (self->priv->punctuation_text != NULL)
draw_string (self, cr, padding, self->priv->punctuation_text, &pos_y);
if (pos_y > allocated_height)
goto end;
pos_y += SECTION_SPACING;
for (i = 0; i < n_sizes; i++) {
cairo_set_font_size (cr, sizes[i]);
if (self->priv->sample_string != NULL)
draw_string (self, cr, padding, self->priv->sample_string, &pos_y);
if (pos_y > allocated_height)
break;
}
end:
g_free (sizes);
return FALSE;
}
static void
sushi_font_widget_size_request (GtkWidget *drawing_area,
gint *width,
gint *height,
gint *min_height)
{
SushiFontWidget *self = SUSHI_FONT_WIDGET (drawing_area);
SushiFontWidgetPrivate *priv = self->priv;
gint i, pixmap_width, pixmap_height;
cairo_text_extents_t extents;
cairo_font_extents_t font_extents;
cairo_font_face_t *font;
gint *sizes = NULL, n_sizes, alpha_size, title_size;
cairo_t *cr;
cairo_surface_t *surface;
FT_Face face = priv->face;
GtkStyleContext *context;
GtkStateFlags state;
GtkBorder padding;
if (face == NULL) {
if (width != NULL)
*width = 1;
if (height != NULL)
*height = 1;
if (min_height != NULL)
*min_height = 1;
return;
}
if (min_height != NULL)
*min_height = -1;
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
SURFACE_SIZE, SURFACE_SIZE);
cr = cairo_create (surface);
context = gtk_widget_get_style_context (drawing_area);
state = gtk_style_context_get_state (context);
gtk_style_context_get_padding (context, state, &padding);
sizes = build_sizes_table (face, &n_sizes, &alpha_size, &title_size);
/* calculate size of pixmap to use */
pixmap_width = padding.left + padding.right;
pixmap_height = padding.top + padding.bottom;
font = cairo_ft_font_face_create_for_ft_face (face, 0);
cairo_set_font_face (cr, font);
cairo_font_face_destroy (font);
if (self->priv->font_name != NULL) {
cairo_set_font_size (cr, title_size);
cairo_font_extents (cr, &font_extents);
text_extents (cr, self->priv->font_name, &extents);
pixmap_height += font_extents.ascent + font_extents.descent +
extents.y_advance + LINE_SPACING;
pixmap_width = MAX (pixmap_width, extents.width + padding.left + padding.right);
}
pixmap_height += SECTION_SPACING / 2;
cairo_set_font_size (cr, alpha_size);
cairo_font_extents (cr, &font_extents);
if (self->priv->lowercase_text != NULL) {
text_extents (cr, self->priv->lowercase_text, &extents);
pixmap_height += font_extents.ascent + font_extents.descent +
extents.y_advance + LINE_SPACING;
pixmap_width = MAX (pixmap_width, extents.width + padding.left + padding.right);
}
if (self->priv->uppercase_text != NULL) {
text_extents (cr, self->priv->uppercase_text, &extents);
pixmap_height += font_extents.ascent + font_extents.descent +
extents.y_advance + LINE_SPACING;
pixmap_width = MAX (pixmap_width, extents.width + padding.left + padding.right);
}
if (self->priv->punctuation_text != NULL) {
text_extents (cr, self->priv->punctuation_text, &extents);
pixmap_height += font_extents.ascent + font_extents.descent +
extents.y_advance + LINE_SPACING;
pixmap_width = MAX (pixmap_width, extents.width + padding.left + padding.right);
}
if (self->priv->sample_string != NULL) {
pixmap_height += SECTION_SPACING;
for (i = 0; i < n_sizes; i++) {
cairo_set_font_size (cr, sizes[i]);
cairo_font_extents (cr, &font_extents);
text_extents (cr, self->priv->sample_string, &extents);
pixmap_height += font_extents.ascent + font_extents.descent +
extents.y_advance + LINE_SPACING;
pixmap_width = MAX (pixmap_width, extents.width + padding.left + padding.right);
if ((i == 7) && (min_height != NULL))
*min_height = pixmap_height;
}
}
pixmap_height += padding.bottom + SECTION_SPACING;
if (min_height != NULL && *min_height == -1)
*min_height = pixmap_height;
if (width != NULL)
*width = pixmap_width;
if (height != NULL)
*height = pixmap_height;
cairo_destroy (cr);
cairo_surface_destroy (surface);
g_free (sizes);
}
static zend_bool php_cairo_create_ft_font_face(pecl_ft_container *ft_container, cairo_ft_font_face_object *font_face_object, php_stream *stream, zend_bool owned_stream, int load_flags, zend_bool throw_exceptions TSRMLS_DC) {
FT_Stream ft_stream;
stream_closure *closure;
php_stream_statbuf ssbuf;
FT_Open_Args open_args;
int error;
if (php_stream_stat(stream,&ssbuf) < 0) {
return 1;
}
ft_container->ft_face = NULL;
ft_container->ft_stream = NULL;
font_face_object->closure = NULL;
closure = ecalloc(1, sizeof(stream_closure));
closure->stream = stream;
closure->owned_stream = owned_stream;
#ifdef ZTS
closure->TSRMLS_C = TSRMLS_C;
#endif
ft_stream = pecalloc(1, sizeof(*ft_stream), TRUE);
ft_stream->descriptor.pointer = (void *)closure;
ft_stream->pos = php_stream_tell(stream);
ft_stream->size = ssbuf.sb.st_size;
ft_stream->read = php_cairo_ft_read_func;
open_args.flags = FT_OPEN_STREAM;
open_args.stream = ft_stream;
error = FT_Open_Face(ft_container->ft_lib, &open_args, 0, &ft_container->ft_face);
if (error) {
if (owned_stream) {
php_stream_close(stream);
}
efree(closure);
pefree(ft_stream, TRUE);
return error;
}
font_face_object->closure = closure;
ft_container->ft_stream = ft_stream;
font_face_object->font_face = (cairo_font_face_t *)cairo_ft_font_face_create_for_ft_face(ft_container->ft_face, (int)load_flags);
/* Set Cairo to automatically destroy the FT_Face when the cairo_font_face_t is destroyed */
error = cairo_font_face_set_user_data (
font_face_object->font_face,
&font_face_object->key,
ft_container,
(cairo_destroy_func_t) cairo_user_data_callback_ft_free);
if (error) {
cairo_font_face_destroy (font_face_object->font_face);
FT_Done_Face(ft_container->ft_face);
pefree(ft_stream, TRUE);
return error;
}
return 0;
}
void Drawer::DrawText(std::string& aTexte)
{
Point Point1 (100,100);
FacesMap::iterator IterFont;
cairo_text_extents_t te;
cairo_font_face_t* Cairo_font_face = NULL;
for (IterFont = mFacesMap.begin(); IterFont != mFacesMap.end(); ++IterFont)
{
cairo_user_data_key_t Key;
FT_Face FaceFind = IterFont->second;
if (FaceFind)
{
Cairo_font_face = cairo_ft_font_face_create_for_ft_face (FaceFind,0);
cairo_font_face_set_user_data (Cairo_font_face, &Key, FaceFind, NULL);
cairo_set_font_size (mCairoDC, 75);
cairo_set_source_rgb (mCairoDC, 0.0, 0.0, 0.0);
MoveTo(Point1);
std::string StrTmp = IterFont->first;
StrTmp += "||";
cairo_ft_font_face_set_synthesize (Cairo_font_face, CAIRO_FT_SYNTHESIZE_BOLD);
cairo_ft_font_face_set_synthesize (Cairo_font_face, CAIRO_FT_SYNTHESIZE_OBLIQUE);
cairo_set_font_face(mCairoDC, Cairo_font_face);
cairo_text_path (mCairoDC, StrTmp.c_str());
cairo_fill(mCairoDC);
cairo_text_extents(mCairoDC,StrTmp.c_str(),&te);
Point1.X += (te.width + 10);
MoveTo(Point1);
cairo_text_path (mCairoDC, IterFont->first.c_str());
cairo_fill(mCairoDC);
Point1.X -= (te.width + 10);
Point1.Y += 100;
cairo_font_face_set_user_data (Cairo_font_face, &Key, NULL, NULL);
cairo_font_face_destroy(Cairo_font_face);
}
}
cairo_user_data_key_t KeyFontSystem;
if (mFontSystem)
{
Cairo_font_face = cairo_ft_font_face_create_for_ft_face (mFontSystem,0);
cairo_font_face_set_user_data (Cairo_font_face, &KeyFontSystem, mFontSystem, NULL);
cairo_set_font_size (mCairoDC, 75);
cairo_set_source_rgb (mCairoDC, 0.0, 0.0, 0.0);
MoveTo(Point1);
cairo_set_font_face(mCairoDC, Cairo_font_face);
cairo_text_path (mCairoDC, "FontSystem");
cairo_fill(mCairoDC);
cairo_font_face_set_user_data (Cairo_font_face, &KeyFontSystem, NULL, NULL);
cairo_font_face_destroy(Cairo_font_face);
}
Point1.X -= (100);
Point1.Y += 100;
cairo_user_data_key_t KeyFontTest;
if (mFontTest)
{
Cairo_font_face = cairo_ft_font_face_create_for_ft_face (mFontTest,0);
cairo_font_face_set_user_data (Cairo_font_face, &KeyFontTest, mFontTest, NULL);
cairo_set_font_size (mCairoDC, 75);
cairo_set_source_rgb (mCairoDC, 0.0, 0.0, 0.0);
MoveTo(Point1);
cairo_set_font_face(mCairoDC, Cairo_font_face);
cairo_text_path (mCairoDC, "FontTest");
cairo_fill(mCairoDC);
cairo_font_face_set_user_data (Cairo_font_face, &KeyFontTest, NULL, NULL);
cairo_font_face_destroy(Cairo_font_face);
}
}
