2002-11-08 00:02:15 -08:00
|
|
|
#include "evas_common.h"
|
2006-04-08 19:36:03 -07:00
|
|
|
#include "evas_private.h"
|
2002-11-08 00:02:15 -08:00
|
|
|
|
2009-06-15 08:07:13 -07:00
|
|
|
#include <assert.h>
|
|
|
|
|
2010-05-21 00:10:45 -07:00
|
|
|
#include "evas_font_private.h" /* for Frame-Queuing support */
|
2011-01-30 02:37:52 -08:00
|
|
|
#include "evas_font_ot.h"
|
2010-05-21 00:10:45 -07:00
|
|
|
|
2012-06-22 13:31:31 -07:00
|
|
|
#ifdef EVAS_CSERVE2
|
|
|
|
# include "../../cserve2/evas_cs2_private.h"
|
|
|
|
#endif
|
|
|
|
|
2011-10-17 07:24:49 -07:00
|
|
|
#ifdef USE_HARFBUZZ
|
|
|
|
# include <hb.h>
|
|
|
|
# include <hb-ft.h>
|
|
|
|
#endif
|
|
|
|
|
2004-01-15 06:58:03 -08:00
|
|
|
extern FT_Library evas_ft_lib;
|
2002-11-08 00:02:15 -08:00
|
|
|
|
|
|
|
static int font_cache_usage = 0;
|
|
|
|
static int font_cache = 0;
|
2010-01-07 23:10:53 -08:00
|
|
|
static int font_dpi = 75;
|
2009-06-15 08:07:13 -07:00
|
|
|
|
2010-10-29 05:55:42 -07:00
|
|
|
static Eina_Hash *fonts_src = NULL;
|
|
|
|
static Eina_Hash *fonts = NULL;
|
|
|
|
static Eina_List *fonts_lru = NULL;
|
|
|
|
static Eina_Inlist *fonts_use_lru = NULL;
|
|
|
|
static int fonts_use_usage = 0;
|
2002-11-08 00:02:15 -08:00
|
|
|
|
2010-04-12 01:23:53 -07:00
|
|
|
static void _evas_common_font_int_clear(RGBA_Font_Int *fi);
|
2002-11-08 00:02:15 -08:00
|
|
|
|
2009-06-15 08:07:13 -07:00
|
|
|
static int
|
2009-10-22 15:22:10 -07:00
|
|
|
_evas_font_cache_int_cmp(const RGBA_Font_Int *k1, int k1_length __UNUSED__,
|
|
|
|
const RGBA_Font_Int *k2, int k2_length __UNUSED__)
|
2009-06-15 08:07:13 -07:00
|
|
|
{
|
|
|
|
/* RGBA_Font_Source->name is a stringshare */
|
|
|
|
if (k1->src->name == k2->src->name)
|
2011-04-12 02:05:47 -07:00
|
|
|
{
|
|
|
|
if (k1->size == k2->size)
|
|
|
|
return k1->wanted_rend - k2->wanted_rend;
|
|
|
|
else
|
|
|
|
return k1->size - k2->size;
|
|
|
|
}
|
2011-10-26 07:33:51 -07:00
|
|
|
return strcmp(k1->src->name, k2->src->name);
|
2009-06-15 08:07:13 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2009-10-22 15:22:10 -07:00
|
|
|
_evas_font_cache_int_hash(const RGBA_Font_Int *key, int key_length __UNUSED__)
|
2009-06-15 08:07:13 -07:00
|
|
|
{
|
|
|
|
int hash;
|
2011-04-12 02:05:47 -07:00
|
|
|
unsigned int wanted_rend = key->wanted_rend;
|
2009-06-15 08:07:13 -07:00
|
|
|
hash = eina_hash_djb2(key->src->name, eina_stringshare_strlen(key->src->name) + 1);
|
|
|
|
hash ^= eina_hash_int32(&key->size, sizeof (int));
|
2011-04-12 02:05:47 -07:00
|
|
|
hash ^= eina_hash_int32(&wanted_rend, sizeof (int));
|
2009-06-15 08:07:13 -07:00
|
|
|
return hash;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_evas_common_font_source_free(RGBA_Font_Source *fs)
|
|
|
|
{
|
2010-05-21 00:10:45 -07:00
|
|
|
FTLOCK();
|
2009-06-15 08:07:13 -07:00
|
|
|
FT_Done_Face(fs->ft.face);
|
2010-05-21 00:10:45 -07:00
|
|
|
FTUNLOCK();
|
2009-06-15 08:07:13 -07:00
|
|
|
if (fs->name) eina_stringshare_del(fs->name);
|
2011-02-23 03:53:29 -08:00
|
|
|
if (fs->file) eina_stringshare_del(fs->file);
|
2009-06-15 08:07:13 -07:00
|
|
|
free(fs);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_evas_common_font_int_free(RGBA_Font_Int *fi)
|
|
|
|
{
|
|
|
|
FT_Done_Size(fi->ft.size);
|
|
|
|
|
|
|
|
evas_common_font_int_modify_cache_by(fi, -1);
|
2010-04-12 01:23:53 -07:00
|
|
|
_evas_common_font_int_clear(fi);
|
|
|
|
eina_hash_free(fi->kerning);
|
2009-06-15 08:07:13 -07:00
|
|
|
|
2012-03-18 23:18:44 -07:00
|
|
|
LKD(fi->ft_mutex);
|
2011-10-18 02:58:49 -07:00
|
|
|
#ifdef USE_HARFBUZZ
|
|
|
|
hb_font_destroy(fi->ft.hb_font);
|
2009-06-15 08:07:13 -07:00
|
|
|
#endif
|
|
|
|
evas_common_font_source_free(fi->src);
|
2012-06-28 03:13:05 -07:00
|
|
|
if (fi->references <= 0) fonts_lru = eina_list_remove(fonts_lru, fi);
|
2010-02-03 03:18:00 -08:00
|
|
|
if (fi->fash) fi->fash->freeme(fi->fash);
|
2010-10-29 05:55:42 -07:00
|
|
|
if (fi->inuse)
|
|
|
|
{
|
|
|
|
fonts_use_lru = eina_inlist_remove(fonts_use_lru, EINA_INLIST_GET(fi));
|
|
|
|
fi->inuse = 0;
|
|
|
|
fonts_use_usage -= fi->usage;
|
|
|
|
fi->usage = 0;
|
|
|
|
}
|
2012-06-22 13:31:31 -07:00
|
|
|
#ifdef EVAS_CSERVE2
|
|
|
|
evas_cserve2_font_free(fi->cs2_handler);
|
|
|
|
#endif
|
2009-06-15 08:07:13 -07:00
|
|
|
free(fi);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
evas_common_font_load_init(void)
|
|
|
|
{
|
|
|
|
fonts_src = eina_hash_string_small_new(EINA_FREE_CB(_evas_common_font_source_free));
|
2009-06-18 05:14:29 -07:00
|
|
|
fonts = eina_hash_new(NULL,
|
2009-06-15 08:07:13 -07:00
|
|
|
EINA_KEY_CMP(_evas_font_cache_int_cmp),
|
|
|
|
EINA_KEY_HASH(_evas_font_cache_int_hash),
|
|
|
|
EINA_FREE_CB(_evas_common_font_int_free),
|
|
|
|
5);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
evas_common_font_load_shutdown(void)
|
|
|
|
{
|
|
|
|
eina_hash_free(fonts);
|
|
|
|
fonts = NULL;
|
|
|
|
eina_hash_free(fonts_src);
|
|
|
|
fonts_src = NULL;
|
|
|
|
}
|
|
|
|
|
2010-01-07 23:10:53 -08:00
|
|
|
EAPI void
|
|
|
|
evas_common_font_dpi_set(int dpi)
|
|
|
|
{
|
|
|
|
font_dpi = dpi;
|
|
|
|
}
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI RGBA_Font_Source *
|
2004-01-22 18:14:45 -08:00
|
|
|
evas_common_font_source_memory_load(const char *name, const void *data, int data_size)
|
|
|
|
{
|
2010-10-29 05:55:42 -07:00
|
|
|
int error;
|
2004-01-22 18:14:45 -08:00
|
|
|
RGBA_Font_Source *fs;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2010-08-25 18:34:13 -07:00
|
|
|
assert(name != NULL);
|
2005-11-30 00:45:20 -08:00
|
|
|
fs = calloc(1, sizeof(RGBA_Font_Source) + data_size);
|
2004-01-22 18:14:45 -08:00
|
|
|
if (!fs) return NULL;
|
2005-11-30 00:45:20 -08:00
|
|
|
fs->data = ((unsigned char *)fs) + sizeof(RGBA_Font_Source);
|
2005-12-01 19:15:08 -08:00
|
|
|
fs->data_size = data_size;
|
2004-01-22 21:58:34 -08:00
|
|
|
fs->current_size = 0;
|
2004-01-22 18:14:45 -08:00
|
|
|
memcpy(fs->data, data, data_size);
|
2010-05-21 00:10:45 -07:00
|
|
|
FTLOCK();
|
2004-01-22 18:14:45 -08:00
|
|
|
error = FT_New_Memory_Face(evas_ft_lib, fs->data, fs->data_size, 0, &(fs->ft.face));
|
2010-05-21 00:10:45 -07:00
|
|
|
FTUNLOCK();
|
2004-01-22 18:14:45 -08:00
|
|
|
if (error)
|
|
|
|
{
|
|
|
|
free(fs);
|
|
|
|
return NULL;
|
|
|
|
}
|
2008-10-15 07:38:34 -07:00
|
|
|
fs->name = eina_stringshare_add(name);
|
2005-12-01 19:15:08 -08:00
|
|
|
fs->file = NULL;
|
2010-05-21 00:10:45 -07:00
|
|
|
FTLOCK();
|
2004-01-26 00:21:00 -08:00
|
|
|
error = FT_Select_Charmap(fs->ft.face, ft_encoding_unicode);
|
2010-10-29 05:55:42 -07:00
|
|
|
if (error)
|
|
|
|
{
|
|
|
|
FT_Done_Face(fs->ft.face);
|
|
|
|
fs->ft.face = NULL;
|
|
|
|
free(fs);
|
|
|
|
return NULL;
|
|
|
|
}
|
2010-05-21 00:10:45 -07:00
|
|
|
FTUNLOCK();
|
2004-01-26 00:21:00 -08:00
|
|
|
fs->ft.orig_upem = fs->ft.face->units_per_EM;
|
2004-01-22 18:14:45 -08:00
|
|
|
fs->references = 1;
|
2009-06-15 08:07:13 -07:00
|
|
|
eina_hash_direct_add(fonts_src, fs->name, fs);
|
2004-01-22 18:14:45 -08:00
|
|
|
return fs;
|
|
|
|
}
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI RGBA_Font_Source *
|
2004-01-22 18:14:45 -08:00
|
|
|
evas_common_font_source_load(const char *name)
|
|
|
|
{
|
|
|
|
RGBA_Font_Source *fs;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2010-08-25 18:34:13 -07:00
|
|
|
assert(name != NULL);
|
2005-11-30 00:45:20 -08:00
|
|
|
fs = calloc(1, sizeof(RGBA_Font_Source));
|
2004-01-22 18:14:45 -08:00
|
|
|
if (!fs) return NULL;
|
2004-01-22 21:58:34 -08:00
|
|
|
fs->data = NULL;
|
|
|
|
fs->data_size = 0;
|
|
|
|
fs->current_size = 0;
|
2006-04-08 17:02:47 -07:00
|
|
|
fs->ft.face = NULL;
|
2008-10-15 07:38:34 -07:00
|
|
|
fs->name = eina_stringshare_add(name);
|
2011-02-23 03:50:09 -08:00
|
|
|
fs->file = eina_stringshare_ref(fs->name);
|
2006-04-08 17:02:47 -07:00
|
|
|
fs->ft.orig_upem = 0;
|
2004-01-22 18:14:45 -08:00
|
|
|
fs->references = 1;
|
2009-06-15 08:07:13 -07:00
|
|
|
eina_hash_direct_add(fonts_src, fs->name, fs);
|
2004-01-22 18:14:45 -08:00
|
|
|
return fs;
|
|
|
|
}
|
|
|
|
|
2010-10-29 05:55:42 -07:00
|
|
|
void
|
|
|
|
evas_common_font_source_unload(RGBA_Font_Source *fs)
|
|
|
|
{
|
|
|
|
FTLOCK();
|
|
|
|
FT_Done_Face(fs->ft.face);
|
|
|
|
fs->ft.face = NULL;
|
|
|
|
FTUNLOCK();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
evas_common_font_source_reload(RGBA_Font_Source *fs)
|
|
|
|
{
|
|
|
|
if (fs->ft.face) return;
|
|
|
|
if (fs->data)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
FTLOCK();
|
|
|
|
error = FT_New_Memory_Face(evas_ft_lib, fs->data, fs->data_size, 0, &(fs->ft.face));
|
|
|
|
FTUNLOCK();
|
|
|
|
if (error) return;
|
|
|
|
FTLOCK();
|
|
|
|
error = FT_Select_Charmap(fs->ft.face, ft_encoding_unicode);
|
|
|
|
if (error)
|
|
|
|
{
|
|
|
|
FT_Done_Face(fs->ft.face);
|
|
|
|
fs->ft.face = NULL;
|
|
|
|
}
|
|
|
|
FTUNLOCK();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
evas_common_font_source_load_complete(fs);
|
|
|
|
}
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI int
|
2006-04-08 17:02:47 -07:00
|
|
|
evas_common_font_source_load_complete(RGBA_Font_Source *fs)
|
|
|
|
{
|
|
|
|
int error;
|
2008-07-10 11:12:45 -07:00
|
|
|
|
2010-05-21 00:10:45 -07:00
|
|
|
FTLOCK();
|
2008-07-10 11:12:45 -07:00
|
|
|
error = FT_New_Face(evas_ft_lib, fs->file, 0, &(fs->ft.face));
|
|
|
|
if (error)
|
2007-05-05 03:30:11 -07:00
|
|
|
{
|
2010-05-21 00:10:45 -07:00
|
|
|
FTUNLOCK();
|
2007-05-05 03:30:11 -07:00
|
|
|
fs->ft.face = NULL;
|
|
|
|
return error;
|
|
|
|
}
|
2006-04-08 17:02:47 -07:00
|
|
|
error = FT_Select_Charmap(fs->ft.face, ft_encoding_unicode);
|
2008-07-10 11:12:45 -07:00
|
|
|
if (error)
|
2007-05-05 03:30:11 -07:00
|
|
|
{
|
|
|
|
FT_Done_Face(fs->ft.face);
|
2010-10-29 05:55:42 -07:00
|
|
|
FTUNLOCK();
|
2007-05-05 03:30:11 -07:00
|
|
|
fs->ft.face = NULL;
|
|
|
|
return error;
|
|
|
|
}
|
2010-05-21 00:10:45 -07:00
|
|
|
FTUNLOCK();
|
2006-04-08 17:02:47 -07:00
|
|
|
fs->ft.orig_upem = fs->ft.face->units_per_EM;
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI RGBA_Font_Source *
|
2004-01-22 18:14:45 -08:00
|
|
|
evas_common_font_source_find(const char *name)
|
|
|
|
{
|
2008-10-20 05:36:48 -07:00
|
|
|
RGBA_Font_Source *fs;
|
2004-01-23 03:03:07 -08:00
|
|
|
|
2004-01-22 18:14:45 -08:00
|
|
|
if (!name) return NULL;
|
2009-06-15 08:07:13 -07:00
|
|
|
fs = eina_hash_find(fonts_src, name);
|
|
|
|
if (fs)
|
2004-01-22 18:14:45 -08:00
|
|
|
{
|
2009-06-15 08:07:13 -07:00
|
|
|
fs->references++;
|
|
|
|
return fs;
|
2004-01-22 18:14:45 -08:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI void
|
2004-01-22 18:14:45 -08:00
|
|
|
evas_common_font_source_free(RGBA_Font_Source *fs)
|
|
|
|
{
|
|
|
|
fs->references--;
|
|
|
|
if (fs->references > 0) return;
|
2009-06-15 08:07:13 -07:00
|
|
|
eina_hash_del(fonts_src, fs->name, fs);
|
2004-01-22 18:14:45 -08:00
|
|
|
}
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI void
|
2004-01-22 18:14:45 -08:00
|
|
|
evas_common_font_size_use(RGBA_Font *fn)
|
|
|
|
{
|
2009-06-15 08:07:13 -07:00
|
|
|
RGBA_Font_Int *fi;
|
2008-10-21 09:31:05 -07:00
|
|
|
Eina_List *l;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2009-06-15 08:07:13 -07:00
|
|
|
EINA_LIST_FOREACH(fn->fonts, l, fi)
|
2005-03-20 07:57:55 -08:00
|
|
|
{
|
2005-03-20 09:14:41 -08:00
|
|
|
if (fi->src->current_size != fi->size)
|
|
|
|
{
|
2010-10-29 05:55:42 -07:00
|
|
|
evas_common_font_source_reload(fi->src);
|
|
|
|
FTLOCK();
|
2005-03-20 09:14:41 -08:00
|
|
|
FT_Activate_Size(fi->ft.size);
|
2010-10-29 05:55:42 -07:00
|
|
|
FTUNLOCK();
|
2005-03-20 09:14:41 -08:00
|
|
|
fi->src->current_size = fi->size;
|
|
|
|
}
|
2005-03-20 07:57:55 -08:00
|
|
|
}
|
2004-01-22 18:14:45 -08:00
|
|
|
}
|
|
|
|
|
2009-02-10 07:53:17 -08:00
|
|
|
static int
|
|
|
|
_evas_common_font_double_int_cmp(const int *key1, __UNUSED__ int key1_length,
|
|
|
|
const int *key2, __UNUSED__ int key2_length)
|
|
|
|
{
|
2010-10-29 05:55:42 -07:00
|
|
|
if (key1[0] - key2[0] == 0) return key1[1] - key2[1];
|
2009-02-10 07:53:17 -08:00
|
|
|
return key1[0] - key2[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2009-03-19 12:29:05 -07:00
|
|
|
_evas_common_font_double_int_hash(const unsigned int key[2], int key_length)
|
2009-02-10 07:53:17 -08:00
|
|
|
{
|
2010-10-29 05:55:42 -07:00
|
|
|
return
|
|
|
|
eina_hash_int32(&key[0], key_length) ^
|
|
|
|
eina_hash_int32(&key[1], key_length);
|
2009-02-10 07:53:17 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-06-15 08:07:13 -07:00
|
|
|
_evas_common_font_int_cache_init(RGBA_Font_Int *fi)
|
2009-02-10 07:53:17 -08:00
|
|
|
{
|
|
|
|
/* Add some font kerning cache. */
|
2010-02-23 05:31:10 -08:00
|
|
|
fi->kerning = eina_hash_new(NULL,
|
|
|
|
EINA_KEY_CMP(_evas_common_font_double_int_cmp),
|
|
|
|
EINA_KEY_HASH(_evas_common_font_double_int_hash),
|
|
|
|
free, 3);
|
2012-03-18 23:18:44 -07:00
|
|
|
LKI(fi->ft_mutex);
|
2009-02-10 07:53:17 -08:00
|
|
|
}
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI RGBA_Font_Int *
|
2012-06-22 13:31:31 -07:00
|
|
|
evas_common_font_int_memory_load(const char *source, const char *name, int size, const void *data, int data_size, Font_Rend_Flags wanted_rend)
|
2004-01-22 18:14:45 -08:00
|
|
|
{
|
2005-03-20 07:57:55 -08:00
|
|
|
RGBA_Font_Int *fi;
|
2012-06-22 13:31:31 -07:00
|
|
|
char *fake_name;
|
2004-01-22 18:14:45 -08:00
|
|
|
|
2012-06-22 13:31:31 -07:00
|
|
|
fake_name = evas_file_path_join(source, name);
|
|
|
|
fi = evas_common_font_int_find(fake_name, size, wanted_rend);
|
|
|
|
if (fi)
|
|
|
|
{
|
|
|
|
free(fake_name);
|
|
|
|
return fi;
|
|
|
|
}
|
2005-05-21 19:49:50 -07:00
|
|
|
fi = calloc(1, sizeof(RGBA_Font_Int));
|
2012-06-22 13:31:31 -07:00
|
|
|
if (!fi)
|
|
|
|
{
|
|
|
|
free(fake_name);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
fi->src = evas_common_font_source_find(fake_name);
|
2010-11-01 21:56:57 -07:00
|
|
|
if (!fi->src)
|
2012-06-22 13:31:31 -07:00
|
|
|
fi->src = evas_common_font_source_memory_load(fake_name, data, data_size);
|
2005-03-20 07:57:55 -08:00
|
|
|
if (!fi->src)
|
2004-01-22 18:14:45 -08:00
|
|
|
{
|
2005-03-20 07:57:55 -08:00
|
|
|
free(fi);
|
2012-06-22 13:31:31 -07:00
|
|
|
free(fake_name);
|
2004-01-22 18:14:45 -08:00
|
|
|
return NULL;
|
|
|
|
}
|
2005-03-20 07:57:55 -08:00
|
|
|
fi->size = size;
|
2009-06-15 08:07:13 -07:00
|
|
|
_evas_common_font_int_cache_init(fi);
|
2006-04-08 19:36:03 -07:00
|
|
|
fi = evas_common_font_int_load_init(fi);
|
|
|
|
evas_common_font_int_load_complete(fi);
|
2012-06-22 13:31:31 -07:00
|
|
|
#ifdef EVAS_CSERVE2
|
|
|
|
if (evas_cserve2_use_get())
|
|
|
|
fi->cs2_handler = evas_cserve2_font_load(source, name, size, font_dpi,
|
|
|
|
wanted_rend);
|
|
|
|
#endif
|
|
|
|
free(fake_name);
|
2006-04-08 19:36:03 -07:00
|
|
|
return fi;
|
2004-01-22 18:14:45 -08:00
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI RGBA_Font_Int *
|
2011-04-12 02:05:47 -07:00
|
|
|
evas_common_font_int_load(const char *name, int size,
|
|
|
|
Font_Rend_Flags wanted_rend)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2005-03-20 07:57:55 -08:00
|
|
|
RGBA_Font_Int *fi;
|
2002-11-08 00:02:15 -08:00
|
|
|
|
2011-04-12 02:05:47 -07:00
|
|
|
fi = evas_common_font_int_find(name, size, wanted_rend);
|
2005-03-20 07:57:55 -08:00
|
|
|
if (fi) return fi;
|
2005-05-21 19:49:50 -07:00
|
|
|
fi = calloc(1, sizeof(RGBA_Font_Int));
|
2005-03-20 07:57:55 -08:00
|
|
|
if (!fi) return NULL;
|
|
|
|
fi->src = evas_common_font_source_find(name);
|
2006-04-08 19:36:03 -07:00
|
|
|
if (!fi->src && evas_file_path_is_file(name))
|
2005-11-25 21:24:25 -08:00
|
|
|
fi->src = evas_common_font_source_load(name);
|
2011-04-12 02:05:47 -07:00
|
|
|
|
2005-03-20 07:57:55 -08:00
|
|
|
if (!fi->src)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2005-03-20 07:57:55 -08:00
|
|
|
free(fi);
|
2002-11-08 00:02:15 -08:00
|
|
|
return NULL;
|
|
|
|
}
|
2005-03-20 07:57:55 -08:00
|
|
|
fi->size = size;
|
2011-04-12 02:05:47 -07:00
|
|
|
fi->wanted_rend = wanted_rend;
|
2009-06-15 08:07:13 -07:00
|
|
|
_evas_common_font_int_cache_init(fi);
|
2010-11-01 21:56:57 -07:00
|
|
|
fi = evas_common_font_int_load_init(fi);
|
2012-06-22 13:31:31 -07:00
|
|
|
#ifdef EVAS_CSERVE2
|
|
|
|
if (evas_cserve2_use_get())
|
|
|
|
fi->cs2_handler = evas_cserve2_font_load(NULL, name, size, font_dpi,
|
|
|
|
wanted_rend);
|
|
|
|
#endif
|
2010-11-01 21:56:57 -07:00
|
|
|
// evas_common_font_int_load_complete(fi);
|
|
|
|
return fi;
|
2004-01-22 18:14:45 -08:00
|
|
|
}
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI RGBA_Font_Int *
|
2005-03-20 07:57:55 -08:00
|
|
|
evas_common_font_int_load_init(RGBA_Font_Int *fi)
|
2006-04-08 17:02:47 -07:00
|
|
|
{
|
2006-04-08 19:36:03 -07:00
|
|
|
fi->ft.size = NULL;
|
2006-04-08 17:02:47 -07:00
|
|
|
fi->references = 1;
|
2009-06-15 08:07:13 -07:00
|
|
|
eina_hash_direct_add(fonts, fi, fi);
|
2006-04-08 17:02:47 -07:00
|
|
|
return fi;
|
|
|
|
}
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI RGBA_Font_Int *
|
2006-04-08 17:02:47 -07:00
|
|
|
evas_common_font_int_load_complete(RGBA_Font_Int *fi)
|
2004-01-22 18:14:45 -08:00
|
|
|
{
|
2009-10-09 05:10:27 -07:00
|
|
|
int val, dv;
|
|
|
|
int ret;
|
2004-01-22 18:14:45 -08:00
|
|
|
int error;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2010-05-21 00:10:45 -07:00
|
|
|
FTLOCK();
|
2005-03-20 07:57:55 -08:00
|
|
|
error = FT_New_Size(fi->src->ft.face, &(fi->ft.size));
|
2004-01-26 00:21:00 -08:00
|
|
|
if (!error)
|
2004-01-25 19:31:40 -08:00
|
|
|
{
|
2005-03-20 07:57:55 -08:00
|
|
|
FT_Activate_Size(fi->ft.size);
|
2004-01-25 19:31:40 -08:00
|
|
|
}
|
2005-03-20 07:57:55 -08:00
|
|
|
fi->real_size = fi->size * 64;
|
2010-01-07 23:10:53 -08:00
|
|
|
error = FT_Set_Char_Size(fi->src->ft.face, 0, fi->real_size, font_dpi, font_dpi);
|
2002-11-08 00:02:15 -08:00
|
|
|
if (error)
|
2012-06-12 17:54:27 -07:00
|
|
|
error = FT_Set_Pixel_Sizes(fi->src->ft.face, 0, fi->real_size);
|
2010-05-21 00:10:45 -07:00
|
|
|
FTUNLOCK();
|
2002-11-08 00:02:15 -08:00
|
|
|
if (error)
|
|
|
|
{
|
2012-06-12 17:54:27 -07:00
|
|
|
int i, maxd = 0x7fffffff;
|
2002-11-08 00:02:15 -08:00
|
|
|
int chosen_size = 0;
|
2012-06-12 17:54:27 -07:00
|
|
|
int chosen_size2 = 0;
|
2002-11-08 00:02:15 -08:00
|
|
|
|
2005-03-20 07:57:55 -08:00
|
|
|
for (i = 0; i < fi->src->ft.face->num_fixed_sizes; i++)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2012-06-12 17:54:27 -07:00
|
|
|
int s, cd;
|
|
|
|
|
|
|
|
s = fi->src->ft.face->available_sizes[i].size;
|
|
|
|
cd = chosen_size - fi->real_size;
|
2002-11-08 00:02:15 -08:00
|
|
|
if (cd < 0) cd = -cd;
|
2012-06-12 17:54:27 -07:00
|
|
|
if (cd < maxd)
|
|
|
|
{
|
|
|
|
maxd = cd;
|
2002-11-08 00:02:15 -08:00
|
|
|
chosen_size = s;
|
2012-06-12 17:54:27 -07:00
|
|
|
chosen_size2 = fi->src->ft.face->available_sizes[i].y_ppem;
|
|
|
|
if (maxd == 0) break;
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
}
|
2005-03-20 07:57:55 -08:00
|
|
|
fi->real_size = chosen_size;
|
2010-10-29 05:55:42 -07:00
|
|
|
FTLOCK();
|
2012-06-12 17:54:27 -07:00
|
|
|
error = FT_Set_Pixel_Sizes(fi->src->ft.face, 0, fi->real_size);
|
2010-10-29 05:55:42 -07:00
|
|
|
FTUNLOCK();
|
2002-11-08 00:02:15 -08:00
|
|
|
if (error)
|
|
|
|
{
|
2012-06-12 17:54:27 -07:00
|
|
|
error = FT_Set_Char_Size(fi->src->ft.face, 0, fi->real_size, font_dpi, font_dpi);
|
|
|
|
if (error)
|
|
|
|
{
|
|
|
|
/* hack around broken fonts */
|
|
|
|
fi->real_size = (chosen_size2 / 64) * 60;
|
|
|
|
error = FT_Set_Char_Size(fi->src->ft.face, 0, fi->real_size, font_dpi, font_dpi);
|
|
|
|
if (error)
|
|
|
|
{
|
|
|
|
/* couldn't choose the size anyway... what now? */
|
|
|
|
}
|
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
}
|
2010-02-03 03:18:00 -08:00
|
|
|
fi->src->current_size = 0;
|
2009-10-09 05:10:27 -07:00
|
|
|
fi->max_h = 0;
|
|
|
|
val = (int)fi->src->ft.face->bbox.yMax;
|
|
|
|
if (fi->src->ft.face->units_per_EM != 0)
|
|
|
|
{
|
|
|
|
dv = (fi->src->ft.orig_upem * 2048) / fi->src->ft.face->units_per_EM;
|
2012-10-10 00:00:07 -07:00
|
|
|
ret = FONT_METRIC_CONV(val, dv, fi->src->ft.face->size->metrics.y_scale);
|
2009-10-09 05:10:27 -07:00
|
|
|
}
|
2012-06-09 20:23:57 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if ((fi->src->ft.face->bbox.yMax == 0) &&
|
|
|
|
(fi->src->ft.face->bbox.yMin == 0))
|
2012-10-09 23:07:38 -07:00
|
|
|
ret = FONT_METRIC_ROUNDUP((int)fi->ft.size->metrics.ascender);
|
2012-06-09 20:23:57 -07:00
|
|
|
else
|
|
|
|
ret = val;
|
|
|
|
}
|
2009-10-09 05:10:27 -07:00
|
|
|
fi->max_h += ret;
|
|
|
|
val = -(int)fi->src->ft.face->bbox.yMin;
|
|
|
|
if (fi->src->ft.face->units_per_EM != 0)
|
|
|
|
{
|
|
|
|
dv = (fi->src->ft.orig_upem * 2048) / fi->src->ft.face->units_per_EM;
|
2012-10-10 00:00:07 -07:00
|
|
|
ret = FONT_METRIC_CONV(val, dv, fi->src->ft.face->size->metrics.y_scale);
|
2009-10-09 05:10:27 -07:00
|
|
|
}
|
2012-06-09 20:23:57 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if ((fi->src->ft.face->bbox.yMax == 0) &&
|
|
|
|
(fi->src->ft.face->bbox.yMin == 0))
|
2012-10-09 23:07:38 -07:00
|
|
|
ret = FONT_METRIC_ROUNDUP(-(int)fi->ft.size->metrics.descender);
|
2012-06-09 20:23:57 -07:00
|
|
|
else
|
|
|
|
ret = val;
|
|
|
|
}
|
2009-10-09 05:10:27 -07:00
|
|
|
fi->max_h += ret;
|
2011-04-12 02:05:47 -07:00
|
|
|
|
|
|
|
/* If the loaded font doesn't match with wanted_rend value requested by
|
2011-08-01 02:11:42 -07:00
|
|
|
* textobject and textblock, Set the runtime_rend value as FONT_REND_SLANT
|
|
|
|
* or FONT_REND_WEIGHT for software rendering. */
|
2011-04-12 02:05:47 -07:00
|
|
|
fi->runtime_rend = FONT_REND_REGULAR;
|
2011-08-01 02:11:42 -07:00
|
|
|
if ((fi->wanted_rend & FONT_REND_SLANT) &&
|
2011-04-12 02:05:47 -07:00
|
|
|
!(fi->src->ft.face->style_flags & FT_STYLE_FLAG_ITALIC))
|
2011-08-01 02:11:42 -07:00
|
|
|
fi->runtime_rend |= FONT_REND_SLANT;
|
2011-04-12 02:05:47 -07:00
|
|
|
|
2011-08-01 02:11:42 -07:00
|
|
|
if ((fi->wanted_rend & FONT_REND_WEIGHT) &&
|
2011-04-12 02:05:47 -07:00
|
|
|
!(fi->src->ft.face->style_flags & FT_STYLE_FLAG_BOLD))
|
2011-08-01 02:11:42 -07:00
|
|
|
fi->runtime_rend |= FONT_REND_WEIGHT;
|
2011-04-12 02:05:47 -07:00
|
|
|
|
2005-03-20 07:57:55 -08:00
|
|
|
return fi;
|
|
|
|
}
|
2008-07-16 13:46:47 -07:00
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI RGBA_Font *
|
2012-06-22 13:31:31 -07:00
|
|
|
evas_common_font_memory_load(const char *source, const char *name, int size, const void *data, int data_size, Font_Rend_Flags wanted_rend)
|
2005-03-20 07:57:55 -08:00
|
|
|
{
|
|
|
|
RGBA_Font *fn;
|
|
|
|
RGBA_Font_Int *fi;
|
2008-07-10 11:12:45 -07:00
|
|
|
|
2012-06-22 13:31:31 -07:00
|
|
|
fi = evas_common_font_int_memory_load(source, name, size, data, data_size,
|
2011-04-12 02:05:47 -07:00
|
|
|
wanted_rend);
|
2005-03-20 07:57:55 -08:00
|
|
|
if (!fi) return NULL;
|
|
|
|
fn = calloc(1, sizeof(RGBA_Font));
|
2005-08-26 01:00:49 -07:00
|
|
|
if (!fn)
|
2006-02-27 06:03:27 -08:00
|
|
|
{
|
2012-06-28 03:13:05 -07:00
|
|
|
evas_common_font_int_unref(fi);
|
2006-02-27 06:03:27 -08:00
|
|
|
return NULL;
|
|
|
|
}
|
2008-10-21 09:31:05 -07:00
|
|
|
fn->fonts = eina_list_append(fn->fonts, fi);
|
2006-02-27 06:03:27 -08:00
|
|
|
fn->hinting = FONT_BYTECODE_HINT;
|
|
|
|
fi->hinting = fn->hinting;
|
2006-11-13 15:23:44 -08:00
|
|
|
fn->references = 1;
|
|
|
|
LKI(fn->lock);
|
2010-10-29 05:55:42 -07:00
|
|
|
if (fi->inuse) evas_common_font_int_promote(fi);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
fi->inuse = 1;
|
|
|
|
fonts_use_lru = eina_inlist_prepend(fonts_use_lru, EINA_INLIST_GET(fi));
|
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
return fn;
|
|
|
|
}
|
|
|
|
|
2010-10-29 05:55:42 -07:00
|
|
|
|
|
|
|
//ZZZ: font struct looks like:
|
|
|
|
// fn->(fi, fi, fi, ...)
|
|
|
|
// fi->fs
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI RGBA_Font *
|
2011-04-12 02:05:47 -07:00
|
|
|
evas_common_font_load(const char *name, int size, Font_Rend_Flags wanted_rend)
|
2005-03-20 07:57:55 -08:00
|
|
|
{
|
|
|
|
RGBA_Font *fn;
|
|
|
|
RGBA_Font_Int *fi;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2011-04-12 02:05:47 -07:00
|
|
|
fi = evas_common_font_int_load(name, size, wanted_rend);
|
2005-03-20 07:57:55 -08:00
|
|
|
if (!fi) return NULL;
|
2008-07-10 11:12:45 -07:00
|
|
|
/* First font, complete load */
|
2006-04-08 17:02:47 -07:00
|
|
|
if (!fi->ft.size)
|
|
|
|
{
|
|
|
|
if (!fi->src->ft.face)
|
|
|
|
{
|
|
|
|
if (evas_common_font_source_load_complete(fi->src))
|
|
|
|
{
|
2012-06-28 03:13:05 -07:00
|
|
|
evas_common_font_int_unref(fi);
|
2006-04-08 17:02:47 -07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
evas_common_font_int_load_complete(fi);
|
|
|
|
}
|
2005-03-20 07:57:55 -08:00
|
|
|
fn = calloc(1, sizeof(RGBA_Font));
|
2005-08-26 01:00:49 -07:00
|
|
|
if (!fn)
|
2006-02-27 06:03:27 -08:00
|
|
|
{
|
2012-06-28 03:13:05 -07:00
|
|
|
evas_common_font_int_unref(fi);
|
2006-02-27 06:03:27 -08:00
|
|
|
return NULL;
|
|
|
|
}
|
2011-04-12 02:05:47 -07:00
|
|
|
|
2008-10-21 09:31:05 -07:00
|
|
|
fn->fonts = eina_list_append(fn->fonts, fi);
|
2006-02-27 06:03:27 -08:00
|
|
|
fn->hinting = FONT_BYTECODE_HINT;
|
|
|
|
fi->hinting = fn->hinting;
|
2006-11-13 15:23:44 -08:00
|
|
|
fn->references = 1;
|
|
|
|
LKI(fn->lock);
|
2010-10-29 05:55:42 -07:00
|
|
|
if (fi->inuse) evas_common_font_int_promote(fi);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
fi->inuse = 1;
|
|
|
|
fonts_use_lru = eina_inlist_prepend(fonts_use_lru, EINA_INLIST_GET(fi));
|
|
|
|
}
|
2005-03-20 07:57:55 -08:00
|
|
|
return fn;
|
|
|
|
}
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI RGBA_Font *
|
2011-04-12 02:05:47 -07:00
|
|
|
evas_common_font_add(RGBA_Font *fn, const char *name, int size, Font_Rend_Flags wanted_rend)
|
2005-03-20 07:57:55 -08:00
|
|
|
{
|
|
|
|
RGBA_Font_Int *fi;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2010-10-29 05:55:42 -07:00
|
|
|
if (!fn) return NULL;
|
2011-04-12 02:05:47 -07:00
|
|
|
fi = evas_common_font_int_load(name, size, wanted_rend);
|
2005-03-20 07:57:55 -08:00
|
|
|
if (fi)
|
|
|
|
{
|
2008-10-21 09:31:05 -07:00
|
|
|
fn->fonts = eina_list_append(fn->fonts, fi);
|
2006-02-27 07:40:46 -08:00
|
|
|
fi->hinting = fn->hinting;
|
2010-10-29 05:55:42 -07:00
|
|
|
if (fi->inuse) evas_common_font_int_promote(fi);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
fi->inuse = 1;
|
|
|
|
fonts_use_lru = eina_inlist_prepend(fonts_use_lru, EINA_INLIST_GET(fi));
|
|
|
|
}
|
2005-03-20 08:41:49 -08:00
|
|
|
return fn;
|
2005-03-20 07:57:55 -08:00
|
|
|
}
|
2005-03-20 08:41:49 -08:00
|
|
|
return NULL;
|
2005-03-20 07:57:55 -08:00
|
|
|
}
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI RGBA_Font *
|
2012-06-22 13:31:31 -07:00
|
|
|
evas_common_font_memory_add(RGBA_Font *fn, const char *source, const char *name, int size, const void *data, int data_size, Font_Rend_Flags wanted_rend)
|
2005-03-20 07:57:55 -08:00
|
|
|
{
|
|
|
|
RGBA_Font_Int *fi;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2005-08-26 01:00:49 -07:00
|
|
|
if (!fn)
|
|
|
|
return NULL;
|
2012-06-22 13:31:31 -07:00
|
|
|
fi = evas_common_font_int_memory_load(source, name, size, data, data_size, wanted_rend);
|
2005-03-20 07:57:55 -08:00
|
|
|
if (fi)
|
|
|
|
{
|
2008-10-21 09:31:05 -07:00
|
|
|
fn->fonts = eina_list_append(fn->fonts, fi);
|
2006-02-27 07:40:46 -08:00
|
|
|
fi->hinting = fn->hinting;
|
2010-10-29 05:55:42 -07:00
|
|
|
if (fi->inuse) evas_common_font_int_promote(fi);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
fi->inuse = 1;
|
|
|
|
fonts_use_lru = eina_inlist_prepend(fonts_use_lru, EINA_INLIST_GET(fi));
|
|
|
|
}
|
2005-03-20 08:41:49 -08:00
|
|
|
return fn;
|
2005-03-20 07:57:55 -08:00
|
|
|
}
|
2005-03-20 08:41:49 -08:00
|
|
|
return NULL;
|
2005-03-20 07:57:55 -08:00
|
|
|
}
|
|
|
|
|
2012-06-28 03:13:05 -07:00
|
|
|
EAPI void
|
|
|
|
evas_common_font_int_unref(RGBA_Font_Int *fi)
|
|
|
|
{
|
|
|
|
fi->references--;
|
|
|
|
if (fi->references == 0)
|
|
|
|
{
|
|
|
|
fonts_lru = eina_list_append(fonts_lru, fi);
|
|
|
|
evas_common_font_int_modify_cache_by(fi, 1);
|
|
|
|
evas_common_font_flush();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI void
|
2002-11-13 21:38:10 -08:00
|
|
|
evas_common_font_free(RGBA_Font *fn)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2008-10-21 09:31:05 -07:00
|
|
|
Eina_List *l;
|
2008-12-09 09:56:31 -08:00
|
|
|
RGBA_Font_Int *fi;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2010-02-03 03:18:00 -08:00
|
|
|
if (!fn) return;
|
2006-11-13 15:23:44 -08:00
|
|
|
fn->references--;
|
|
|
|
if (fn->references > 0) return;
|
2008-12-09 09:56:31 -08:00
|
|
|
EINA_LIST_FOREACH(fn->fonts, l, fi)
|
2012-06-28 03:13:05 -07:00
|
|
|
evas_common_font_int_unref(fi);
|
2009-06-15 08:07:13 -07:00
|
|
|
evas_common_font_flush();
|
2008-10-21 09:31:05 -07:00
|
|
|
eina_list_free(fn->fonts);
|
2010-02-03 03:18:00 -08:00
|
|
|
if (fn->fash) fn->fash->freeme(fn->fash);
|
2006-11-13 15:23:44 -08:00
|
|
|
LKD(fn->lock);
|
2005-03-20 07:57:55 -08:00
|
|
|
free(fn);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI void
|
2006-02-27 06:03:27 -08:00
|
|
|
evas_common_font_hinting_set(RGBA_Font *fn, Font_Hint_Flags hinting)
|
|
|
|
{
|
2008-10-21 09:31:05 -07:00
|
|
|
Eina_List *l;
|
2008-12-09 09:56:31 -08:00
|
|
|
RGBA_Font_Int *fi;
|
2008-07-10 11:12:45 -07:00
|
|
|
|
2010-10-29 05:55:42 -07:00
|
|
|
if (!fn) return;
|
2006-02-27 06:03:27 -08:00
|
|
|
fn->hinting = hinting;
|
2008-12-09 09:56:31 -08:00
|
|
|
EINA_LIST_FOREACH(fn->fonts, l, fi)
|
2010-10-29 05:55:42 -07:00
|
|
|
{
|
|
|
|
fi->hinting = fn->hinting;
|
|
|
|
}
|
2006-02-27 06:03:27 -08:00
|
|
|
}
|
|
|
|
|
2009-06-17 03:01:52 -07:00
|
|
|
EAPI Eina_Bool
|
2006-02-27 06:03:27 -08:00
|
|
|
evas_common_hinting_available(Font_Hint_Flags hinting)
|
|
|
|
{
|
2006-10-08 06:00:26 -07:00
|
|
|
switch (hinting)
|
2006-02-27 06:03:27 -08:00
|
|
|
{
|
2006-10-08 06:00:26 -07:00
|
|
|
case FONT_NO_HINT:
|
|
|
|
case FONT_AUTO_HINT:
|
|
|
|
/* these two hinting modes are always available */
|
2009-06-17 03:01:52 -07:00
|
|
|
return EINA_TRUE;
|
2006-10-08 06:00:26 -07:00
|
|
|
case FONT_BYTECODE_HINT:
|
|
|
|
/* Only use the bytecode interpreter if support for the _patented_
|
|
|
|
* algorithms is available because the free bytecode
|
|
|
|
* interpreter's results are too crappy.
|
|
|
|
*
|
|
|
|
* On freetyp 2.2+, we can ask the library about support for
|
|
|
|
* the patented interpreter. On older versions, we need to use
|
|
|
|
* macros to check for it.
|
|
|
|
*/
|
|
|
|
#if FREETYPE_MINOR >= 2
|
|
|
|
return FT_Get_TrueType_Engine_Type(evas_ft_lib) >=
|
|
|
|
FT_TRUETYPE_ENGINE_TYPE_PATENTED;
|
2006-02-27 06:03:27 -08:00
|
|
|
#else
|
2006-10-08 06:58:58 -07:00
|
|
|
/* we may not rely on TT_CONFIG_OPTION_BYTECODE_INTERPRETER
|
|
|
|
* here to find out whether it's supported.
|
|
|
|
*
|
|
|
|
* so, assume it is. o_O
|
|
|
|
*/
|
2009-06-17 03:01:52 -07:00
|
|
|
return EINA_TRUE;
|
2006-02-27 06:03:27 -08:00
|
|
|
#endif
|
|
|
|
}
|
2006-10-08 06:00:26 -07:00
|
|
|
/* shouldn't get here - need to add another case statement */
|
2009-06-17 03:01:52 -07:00
|
|
|
return EINA_FALSE;
|
2006-02-27 06:03:27 -08:00
|
|
|
}
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI RGBA_Font *
|
2012-06-22 13:31:31 -07:00
|
|
|
evas_common_font_memory_hinting_load(const char *source, const char *name, int size, const void *data, int data_size, Font_Hint_Flags hinting, Font_Rend_Flags wanted_rend)
|
2006-02-27 07:40:46 -08:00
|
|
|
{
|
|
|
|
RGBA_Font *fn;
|
|
|
|
|
2012-06-22 13:31:31 -07:00
|
|
|
fn = evas_common_font_memory_load(source, name, size, data, data_size, wanted_rend);
|
2006-02-27 07:40:46 -08:00
|
|
|
if (fn) evas_common_font_hinting_set(fn, hinting);
|
|
|
|
return fn;
|
|
|
|
}
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI RGBA_Font *
|
2011-04-12 02:05:47 -07:00
|
|
|
evas_common_font_hinting_load(const char *name, int size, Font_Hint_Flags hinting, Font_Rend_Flags wanted_rend)
|
2006-02-27 07:40:46 -08:00
|
|
|
{
|
|
|
|
RGBA_Font *fn;
|
|
|
|
|
2011-04-12 02:05:47 -07:00
|
|
|
fn = evas_common_font_load(name, size, wanted_rend);
|
2006-02-27 07:40:46 -08:00
|
|
|
if (fn) evas_common_font_hinting_set(fn, hinting);
|
|
|
|
return fn;
|
|
|
|
}
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI RGBA_Font *
|
2011-04-12 02:05:47 -07:00
|
|
|
evas_common_font_hinting_add(RGBA_Font *fn, const char *name, int size, Font_Hint_Flags hinting, Font_Rend_Flags wanted_rend)
|
2006-02-27 07:40:46 -08:00
|
|
|
{
|
2011-04-12 02:05:47 -07:00
|
|
|
fn = evas_common_font_add(fn, name, size, wanted_rend);
|
2006-02-27 07:40:46 -08:00
|
|
|
if (fn) evas_common_font_hinting_set(fn, hinting);
|
|
|
|
return fn;
|
|
|
|
}
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI RGBA_Font *
|
2012-06-22 13:31:31 -07:00
|
|
|
evas_common_font_memory_hinting_add(RGBA_Font *fn, const char *source, const char *name, int size, const void *data, int data_size, Font_Hint_Flags hinting, Font_Rend_Flags wanted_rend)
|
2006-02-27 07:40:46 -08:00
|
|
|
{
|
2012-06-22 13:31:31 -07:00
|
|
|
fn = evas_common_font_memory_add(fn, source, name, size, data, data_size,
|
2011-04-12 02:05:47 -07:00
|
|
|
wanted_rend);
|
2006-02-27 07:40:46 -08:00
|
|
|
if (fn) evas_common_font_hinting_set(fn, hinting);
|
|
|
|
return fn;
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:23:53 -07:00
|
|
|
static void
|
|
|
|
_evas_common_font_int_clear(RGBA_Font_Int *fi)
|
|
|
|
{
|
|
|
|
LKL(fi->ft_mutex);
|
|
|
|
if (!fi->fash)
|
|
|
|
{
|
|
|
|
LKU(fi->ft_mutex);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
evas_common_font_int_modify_cache_by(fi, -1);
|
2012-06-28 03:13:05 -07:00
|
|
|
if (fi->references <= 1)
|
|
|
|
{
|
|
|
|
if (fi->fash)
|
|
|
|
{
|
|
|
|
fi->fash->freeme(fi->fash);
|
|
|
|
fi->fash = NULL;
|
|
|
|
}
|
2010-04-12 01:23:53 -07:00
|
|
|
}
|
2010-10-29 05:55:42 -07:00
|
|
|
if (fi->inuse) fonts_use_usage -= fi->usage;
|
|
|
|
fi->usage = 0;
|
2012-05-10 18:50:40 -07:00
|
|
|
fi->generation++;
|
2010-04-12 01:23:53 -07:00
|
|
|
LKU(fi->ft_mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
cleanup: fix some "unused" errors from -Wextra.
As we're heading for a release we better remove as much errors as
possible and as the first step I'm removing warnings due unused
parameters, variables and functions. These tend to pollute real errors
spotted by -Wall and clang/llvm.
This does not fixes all, just the clear that could be set to
__UNUSED__, particularly to do (and I'd like some help from the
authors):
* src/lib/engines/common/evas_font_{draw,query}.c (tasn):
intl_props is just used while doing BIDI, but also used in other
#ifdef blocks :-/
* evas_map_* (raster):
huge amount of warnings, code is quite confusing and thus I'm not
touching it. I have no idea whenever the commented blocks or extra
parameters are intended to be used or no.
* src/modules/engines/fbevas_fb_main.c (raster?):
is fb_setvt() to be used? If not do you mind removing it?
* src/modules/engines/gl_{common,x11} (raster):
huge amount of warnings, code is quite nested and full of #ifdefs
that does not help to give a clear picture of what's going on.
* src/bin/evas_cserve_main.c (raster):
I could have ignored most of the errors, but is the code correct? I
mean, there is no unload of images being applied. If you confirm
none of those warnings are harmful I can flag them as unused.
* src/lib/engines/common_8 (dottedmag):
lots of unused functions that were acquired from common_16, they
are unused and if they will not, then they should be removed.
SVN revision: 52421
2010-09-18 12:17:41 -07:00
|
|
|
_evas_common_font_all_clear_cb(const Eina_Hash *hash __UNUSED__, const void *key __UNUSED__, void *data, void *fdata __UNUSED__)
|
2010-04-12 01:23:53 -07:00
|
|
|
{
|
|
|
|
RGBA_Font_Int *fi = data;
|
|
|
|
_evas_common_font_int_clear(fi);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
evas_common_font_all_clear(void)
|
|
|
|
{
|
|
|
|
eina_hash_foreach(fonts, _evas_common_font_all_clear_cb, NULL);
|
|
|
|
}
|
|
|
|
|
2010-10-29 05:55:42 -07:00
|
|
|
void
|
|
|
|
evas_common_font_int_promote(RGBA_Font_Int *fi)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2010-10-29 05:55:42 -07:00
|
|
|
return;
|
|
|
|
if (fonts_use_lru == (Eina_Inlist *)fi) return;
|
|
|
|
if (!fi->inuse) return;
|
|
|
|
fonts_use_lru = eina_inlist_remove(fonts_use_lru, EINA_INLIST_GET(fi));
|
|
|
|
fonts_use_lru = eina_inlist_prepend(fonts_use_lru, EINA_INLIST_GET(fi));
|
|
|
|
}
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2010-10-29 05:55:42 -07:00
|
|
|
void
|
|
|
|
evas_common_font_int_use_increase(int size)
|
|
|
|
{
|
|
|
|
fonts_use_usage += size;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
evas_common_font_int_use_trim(void)
|
|
|
|
{
|
|
|
|
Eina_Inlist *l;
|
|
|
|
|
|
|
|
return;
|
|
|
|
if (fonts_use_usage <= (font_cache << 1)) return;
|
|
|
|
if (!fonts_use_lru) return;
|
|
|
|
l = fonts_use_lru->last;
|
|
|
|
while (l)
|
|
|
|
{
|
|
|
|
RGBA_Font_Int *fi = (RGBA_Font_Int *)l;
|
|
|
|
if (fonts_use_usage <= (font_cache << 1)) break;
|
|
|
|
// FIXME: del fi->kerning content
|
|
|
|
_evas_common_font_int_clear(fi);
|
|
|
|
evas_common_font_int_unload(fi);
|
|
|
|
evas_common_font_int_promote(fi);
|
|
|
|
l = l->prev;
|
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
2010-10-29 05:55:42 -07:00
|
|
|
|
|
|
|
void
|
|
|
|
evas_common_font_int_unload(RGBA_Font_Int *fi)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
if (!fi->src->ft.face) return;
|
|
|
|
_evas_common_font_int_clear(fi);
|
|
|
|
FT_Done_Size(fi->ft.size);
|
|
|
|
fi->ft.size = NULL;
|
|
|
|
evas_common_font_source_unload(fi->src);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
evas_common_font_int_reload(RGBA_Font_Int *fi)
|
|
|
|
{
|
|
|
|
if (fi->src->ft.face) return;
|
2010-11-01 21:56:57 -07:00
|
|
|
evas_common_font_source_load_complete(fi->src);
|
|
|
|
return;
|
2010-10-29 05:55:42 -07:00
|
|
|
evas_common_font_source_reload(fi->src);
|
|
|
|
evas_common_font_int_load_complete(fi);
|
|
|
|
}
|
|
|
|
|
2007-05-05 03:30:11 -07:00
|
|
|
/* when the fi->references == 0 we increase this instead of really deleting
|
2008-07-10 11:12:45 -07:00
|
|
|
* we then check if the cache_useage size is larger than allowed
|
|
|
|
* !If the cache is NOT too large we dont delete font_int
|
2007-05-05 03:30:11 -07:00
|
|
|
* !If the cache is too large we really delete font_int */
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI void
|
2005-03-20 07:57:55 -08:00
|
|
|
evas_common_font_int_modify_cache_by(RGBA_Font_Int *fi, int dir)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2010-10-29 05:55:42 -07:00
|
|
|
font_cache_usage += dir * (sizeof(RGBA_Font) + fi->usage +
|
|
|
|
sizeof(FT_FaceRec) + 16384); /* fudge values */
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI int
|
2002-11-13 21:38:10 -08:00
|
|
|
evas_common_font_cache_get(void)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
return font_cache;
|
|
|
|
}
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI void
|
2002-11-13 21:38:10 -08:00
|
|
|
evas_common_font_cache_set(int size)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
font_cache = size;
|
2002-11-13 21:38:10 -08:00
|
|
|
evas_common_font_flush();
|
2010-10-29 05:55:42 -07:00
|
|
|
evas_common_font_int_use_trim();
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI void
|
2002-11-13 21:38:10 -08:00
|
|
|
evas_common_font_flush(void)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
|
|
|
if (font_cache_usage < font_cache) return;
|
2010-05-17 21:22:33 -07:00
|
|
|
while (font_cache_usage > font_cache)
|
|
|
|
{
|
|
|
|
int pfont_cache_usage;
|
|
|
|
|
|
|
|
pfont_cache_usage = font_cache_usage;
|
|
|
|
evas_common_font_flush_last();
|
|
|
|
if (pfont_cache_usage == font_cache_usage) break;
|
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2007-05-05 03:30:11 -07:00
|
|
|
/* We run this when the cache gets larger than allowed size
|
|
|
|
* We check cache size each time a fi->references goes to 0
|
|
|
|
* PERFORMS: Find font_int(s) with references == 0 and delete them */
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI void
|
2002-11-13 21:38:10 -08:00
|
|
|
evas_common_font_flush_last(void)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2005-03-20 07:57:55 -08:00
|
|
|
RGBA_Font_Int *fi = NULL;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2009-06-15 08:07:13 -07:00
|
|
|
if (!fonts_lru) return ;
|
|
|
|
fi = eina_list_data_get(fonts_lru);
|
|
|
|
fonts_lru = eina_list_remove_list(fonts_lru, fonts_lru);
|
|
|
|
eina_hash_del(fonts, fi, fi);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2006-09-06 00:33:40 -07:00
|
|
|
EAPI RGBA_Font_Int *
|
2011-04-12 02:05:47 -07:00
|
|
|
evas_common_font_int_find(const char *name, int size,
|
|
|
|
Font_Rend_Flags wanted_rend)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2009-06-15 08:07:13 -07:00
|
|
|
RGBA_Font_Int tmp_fi;
|
|
|
|
RGBA_Font_Source tmp_fn;
|
2008-10-20 05:36:48 -07:00
|
|
|
RGBA_Font_Int *fi;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2009-06-15 08:07:13 -07:00
|
|
|
tmp_fn.name = (char*) eina_stringshare_add(name);
|
|
|
|
tmp_fi.src = &tmp_fn;
|
|
|
|
tmp_fi.size = size;
|
2011-04-12 02:05:47 -07:00
|
|
|
tmp_fi.wanted_rend = wanted_rend;
|
2009-06-15 08:07:13 -07:00
|
|
|
fi = eina_hash_find(fonts, &tmp_fi);
|
|
|
|
if (fi)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2009-06-15 08:07:13 -07:00
|
|
|
if (fi->references == 0)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2009-06-15 08:07:13 -07:00
|
|
|
evas_common_font_int_modify_cache_by(fi, -1);
|
|
|
|
fonts_lru = eina_list_remove(fonts_lru, fi);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
2009-06-15 08:07:13 -07:00
|
|
|
fi->references++;
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
2009-06-15 08:07:13 -07:00
|
|
|
eina_stringshare_del(tmp_fn.name);
|
|
|
|
return fi;
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|