gboolean
FcAddAppFontDir(const gchar * dir)
{
g_assert(FcInit());
gboolean result = FcConfigAppFontAddDir(NULL, (FcChar8 *) dir);
return result;
}
static PyObject*
Py_Config_add_dir(Py_Config *self, PyObject *args, PyObject *kwds)
{
PyObject *pydir;
PyObject *pydir_bytes;
unsigned char *dir;
static char *kwlist[] = {"dir", NULL};
if (!PyArg_ParseTupleAndKeywords(
args, kwds, "O:add_dir", kwlist,
&pydir)) {
return NULL;
}
pydir_bytes = PyUnicode_EncodeFSDefault(pydir);
if (pydir_bytes == NULL) {
return NULL;
}
dir = (unsigned char *)PyBytes_AsString(pydir_bytes);
if (dir == NULL) {
Py_DECREF(pydir_bytes);
return NULL;
}
if (!FcConfigAppFontAddDir(self->x, dir)) {
PyErr_SetString(PyExc_ValueError, "Could not add directory");
return NULL;
}
Py_DECREF(pydir_bytes);
Py_RETURN_NONE;
}
void manager::init() const
{
LOG_FT << "Cairo version: " << cairo_version_string() << std::endl;
LOG_FT << "Pango version: " << pango_version_string() << std::endl;
#ifdef CAIRO_HAS_FT_FONT
if (!FcConfigAppFontAddDir(FcConfigGetCurrent(),
reinterpret_cast<const FcChar8 *>((game_config::path + "/fonts").c_str())))
{
ERR_FT << "Could not load the true type fonts" << std::endl;
throw error();
}
#endif
#if CAIRO_HAS_WIN32_FONT
BOOST_FOREACH(const std::string& path, filesystem::get_binary_paths("fonts")) {
std::vector<std::string> files;
if(filesystem::is_directory(path))
filesystem::get_files_in_dir(path, &files, NULL, filesystem::ENTIRE_FILE_PATH);
BOOST_FOREACH(const std::string& file, files) {
if(file.substr(file.length() - 4) == ".ttf" || file.substr(file.length() - 4) == ".ttc")
{
utf16::string ufile = unicode_cast<utf16::string>(file);
std::wstring wfile(ufile.begin(), ufile.end());
AddFontResourceW(wfile.c_str());
}
}
}
#endif
}
static bool addFontDirectory(const CString& fontDirectory, FcConfig* config)
{
const char* path = fontDirectory.data();
if (!FcConfigAppFontAddDir(config, reinterpret_cast<const FcChar8*>(path))) {
fprintf(stderr, "Could not add font directory %s!\n", path);
return false;
}
return true;
}
void FontConfig_BuildCache( filter_t *p_filter )
{
/* */
msg_Dbg( p_filter, "Building font databases.");
mtime_t t1, t2;
t1 = mdate();
#ifdef __OS2__
FcInit();
#endif
#if defined( _WIN32 ) || defined( __APPLE__ )
dialog_progress_bar_t *p_dialog = NULL;
FcConfig *fcConfig = FcInitLoadConfig();
p_dialog = dialog_ProgressCreate( p_filter,
_("Building font cache"),
_("Please wait while your font cache is rebuilt.\n"
"This should take less than a few minutes."), NULL );
/* if( p_dialog )
dialog_ProgressSet( p_dialog, NULL, 0.5 ); */
FcConfigBuildFonts( fcConfig );
#if defined( __APPLE__ )
// By default, scan only the directory /System/Library/Fonts.
// So build the set of available fonts under another directories,
// and add the set to the current configuration.
FcConfigAppFontAddDir( NULL, "~/Library/Fonts" );
FcConfigAppFontAddDir( NULL, "/Library/Fonts" );
FcConfigAppFontAddDir( NULL, "/Network/Library/Fonts" );
//FcConfigAppFontAddDir( NULL, "/System/Library/Fonts" );
#endif
if( p_dialog )
{
// dialog_ProgressSet( p_dialog, NULL, 1.0 );
dialog_ProgressDestroy( p_dialog );
p_dialog = NULL;
}
#endif
t2 = mdate();
msg_Dbg( p_filter, "Took %ld microseconds", (long)((t2 - t1)) );
}
/**
* \brief Init fontconfig.
* \param library libass library object
* \param ftlibrary freetype library object
* \param family default font family
* \param path default font path
* \param fc whether fontconfig should be used
* \param config path to a fontconfig configuration file, or NULL
* \param update whether the fontconfig cache should be built/updated
* \return pointer to fontconfig private data
*/
FCInstance *fontconfig_init(ASS_Library *library,
FT_Library ftlibrary, const char *family,
const char *path, int fc, const char *config,
int update)
{
int rc;
FCInstance *priv = calloc(1, sizeof(FCInstance));
const char *dir = library->fonts_dir;
int i;
if (!fc) {
ass_msg(library, MSGL_WARN,
"Fontconfig disabled, only default font will be used.");
goto exit;
}
priv->config = FcConfigCreate();
rc = FcConfigParseAndLoad(priv->config, (unsigned char *) config, FcTrue);
if (!rc) {
ass_msg(library, MSGL_WARN, "No usable fontconfig configuration "
"file found, using fallback.");
FcConfigDestroy(priv->config);
priv->config = FcInitLoadConfig();
rc++;
}
if (rc && update) {
FcConfigBuildFonts(priv->config);
}
if (!rc || !priv->config) {
ass_msg(library, MSGL_FATAL,
"No valid fontconfig configuration found!");
FcConfigDestroy(priv->config);
goto exit;
}
for (i = 0; i < library->num_fontdata; ++i)
process_fontdata(priv, library, ftlibrary, i);
if (dir) {
ass_msg(library, MSGL_V, "Updating font cache");
rc = FcConfigAppFontAddDir(priv->config, (const FcChar8 *) dir);
if (!rc) {
ass_msg(library, MSGL_WARN, "%s failed", "FcConfigAppFontAddDir");
}
}
priv->family_default = family ? strdup(family) : NULL;
exit:
priv->path_default = path ? strdup(path) : NULL;
priv->index_default = 0;
return priv;
}
static void
gimp_fonts_add_directories (FcConfig *config,
const gchar *path_str)
{
GList *path;
GList *list;
g_return_if_fail (config != NULL);
g_return_if_fail (path_str != NULL);
path = gimp_path_parse (path_str, 256, TRUE, NULL);
for (list = path; list; list = list->next)
FcConfigAppFontAddDir (config, (const guchar *) list->data);
gimp_path_free (path);
}
manager::manager()
{
#ifdef CAIRO_HAS_FT_FONT
std::string font_path = game_config::path + "/fonts";
if (!FcConfigAppFontAddDir(FcConfigGetCurrent(),
reinterpret_cast<const FcChar8 *>(font_path.c_str())))
{
ERR_FT << "Could not load the true type fonts" << std::endl;
throw font::error("font config lib failed to add the font path: '" + font_path + "'");
}
std::string font_file = font_path + "/fonts.conf";
if(!FcConfigParseAndLoad(FcConfigGetCurrent(),
reinterpret_cast<const FcChar8*>(font_file.c_str()),
FcFalse))
{
ERR_FT << "Could not load local font configuration\n";
throw font::error("font config lib failed to find font.conf: '" + font_file + "'");
}
else
{
LOG_FT << "Local font configuration loaded\n";
}
#endif
#if CAIRO_HAS_WIN32_FONT
for(const std::string& path : filesystem::get_binary_paths("fonts")) {
std::vector<std::string> files;
if(filesystem::is_directory(path)) {
filesystem::get_files_in_dir(path, &files, nullptr, filesystem::ENTIRE_FILE_PATH);
}
for(const std::string& file : files) {
if(file.substr(file.length() - 4) == ".ttf" || file.substr(file.length() - 4) == ".ttc")
{
const std::wstring wfile = unicode_cast<std::wstring>(file);
AddFontResourceExW(wfile.c_str(), FR_PRIVATE, nullptr);
}
}
}
#endif
}
void manager::init() const
{
#ifdef CAIRO_HAS_FT_FONT
if (!FcConfigAppFontAddDir(FcConfigGetCurrent(),
reinterpret_cast<const FcChar8 *>((game_config::path + "/fonts").c_str())))
{
ERR_FT << "Could not load the true type fonts\n";
throw error();
}
#endif
#if CAIRO_HAS_WIN32_FONT
foreach(const std::string& path, get_binary_paths("fonts")) {
std::vector<std::string> files;
get_files_in_dir(path, &files, NULL, ENTIRE_FILE_PATH);
foreach(const std::string& file, files)
if(file.substr(file.length() - 4) == ".ttf" || file.substr(file.length() - 4) == ".ttc")
AddFontResource(file.c_str());
}
#endif
}
void QtTestSupport::initializeTestFonts()
{
QFontDatabase::removeAllApplicationFonts();
#if HAVE(FONTCONFIG)
static int numFonts = -1;
FcInit();
// Some test cases may add or remove application fonts (via @font-face).
// Make sure to re-initialize the font set if necessary.
FcFontSet* appFontSet = FcConfigGetFonts(0, FcSetApplication);
if (appFontSet && numFonts >= 0 && appFontSet->nfont == numFonts)
return;
QByteArray fontDir = getenv("WEBKIT_TESTFONTS");
if (fontDir.isEmpty() || !QDir(QString::fromLatin1(fontDir)).exists()) {
qFatal("\n\n"
"----------------------------------------------------------------------\n"
"WEBKIT_TESTFONTS environment variable is not set correctly.\n"
"This variable has to point to the directory containing the fonts\n"
"you can clone from git://gitorious.org/qtwebkit/testfonts.git\n"
"----------------------------------------------------------------------\n"
);
}
QByteArray configFile = fontDir + "/fonts.conf";
FcConfig* config = FcConfigCreate();
if (!FcConfigParseAndLoad(config, reinterpret_cast<const FcChar8*>(configFile.constData()), FcTrue))
qFatal("Couldn't load font configuration file");
if (!FcConfigAppFontAddDir(config, reinterpret_cast<const FcChar8*>(fontDir.data())))
qFatal("Couldn't add font dir!");
FcConfigSetCurrent(config);
appFontSet = FcConfigGetFonts(config, FcSetApplication);
numFonts = appFontSet->nfont;
WebCore::fontCache()->invalidate();
#endif
}
void activateFonts()
{
#if defined(Q_WS_X11)
static int numFonts = -1;
// Some test cases may add or remove application fonts (via @font-face).
// Make sure to re-initialize the font set if necessary.
FcFontSet* appFontSet = FcConfigGetFonts(0, FcSetApplication);
if (appFontSet && numFonts >= 0 && appFontSet->nfont == numFonts)
return;
QByteArray fontDir = getenv("WEBKIT_TESTFONTS");
if (fontDir.isEmpty() || !QDir(fontDir).exists()) {
fprintf(stderr,
"\n\n"
"----------------------------------------------------------------------\n"
"WEBKIT_TESTFONTS environment variable is not set correctly.\n"
"This variable has to point to the directory containing the fonts\n"
"you can clone from git://gitorious.org/qtwebkit/testfonts.git\n"
"----------------------------------------------------------------------\n"
);
exit(1);
}
char currentPath[PATH_MAX+1];
if (!getcwd(currentPath, PATH_MAX))
qFatal("Couldn't get current working directory");
QByteArray configFile = currentPath;
FcConfig* config = FcConfigCreate();
configFile += "/WebKitTools/DumpRenderTree/qt/fonts.conf";
if (!FcConfigParseAndLoad (config, (FcChar8*) configFile.data(), true))
qFatal("Couldn't load font configuration file");
if (!FcConfigAppFontAddDir (config, (FcChar8*) fontDir.data()))
qFatal("Couldn't add font dir!");
FcConfigSetCurrent(config);
appFontSet = FcConfigGetFonts(config, FcSetApplication);
numFonts = appFontSet->nfont;
#endif
}
static void
gimp_fonts_add_directories (FcConfig *config,
GList *path)
{
GList *list;
g_return_if_fail (config != NULL);
for (list = path; list; list = list->next)
{
gchar *dir = g_file_get_path (list->data);
#ifdef G_OS_WIN32
gchar *tmp = g_win32_locale_filename_from_utf8 (dir);
g_free (dir);
dir = tmp;
#endif
FcConfigAppFontAddDir (config, (const FcChar8 *) dir);
g_free (dir);
}
}
int BC_Resources::init_fontconfig(const char *search_path)
{
if( fontlist ) return 0;
fontlist = new ArrayList<BC_FontEntry*>;
#define get_str(str,sep,ptr,cond) do { char *out = str; \
while( *ptr && !strchr(sep,*ptr) && (cond) ) *out++ = *ptr++; \
*out = 0; \
} while(0)
#define skip_str(sep, ptr) do { \
while( *ptr && strchr(sep,*ptr) ) ++ptr; \
} while(0)
char find_command[BCTEXTLEN];
sprintf(find_command,
"find %s -name 'fonts.dir' -print -exec cat {} \\;",
search_path);
FILE *in = popen(find_command, "r");
FT_Library freetype_library = 0;
// FT_Face freetype_face = 0;
// FT_Init_FreeType(&freetype_library);
char line[BCTEXTLEN], current_dir[BCTEXTLEN];
current_dir[0] = 0;
while( !feof(in) && fgets(line, BCTEXTLEN, in) ) {
if(!strlen(line)) break;
char *in_ptr = line;
// Get current directory
if(line[0] == '/') {
get_str(current_dir, "\n", in_ptr,1);
for( int i=strlen(current_dir); --i>=0 && current_dir[i]!='/'; )
current_dir[i] = 0;
continue;
}
//printf("TitleMain::build_fonts %s\n", line);
BC_FontEntry *entry = new BC_FontEntry;
char string[BCTEXTLEN];
// Path
get_str(string, "\n", in_ptr, in_ptr[0]!=' ' || in_ptr[1]!='-');
entry->path = cstrcat(2, current_dir, string);
// Foundary
skip_str(" -", in_ptr);
get_str(string, " -\n", in_ptr, 1);
if( !string[0] ) { delete entry; continue; }
entry->foundry = cstrdup(string);
if(*in_ptr == '-') in_ptr++;
// Family
get_str(string, "-\n", in_ptr, 1);
if( !string[0] ) { delete entry; continue; }
entry->family = cstrdup(string);
if(*in_ptr == '-') in_ptr++;
// Weight
get_str(string, "-\n", in_ptr, 1);
entry->weight = cstrdup(string);
if(*in_ptr == '-') in_ptr++;
// Slant
get_str(string, "-\n", in_ptr, 1);
entry->slant = cstrdup(string);
if(*in_ptr == '-') in_ptr++;
// SWidth
get_str(string, "-\n", in_ptr, 1);
entry->swidth = cstrdup(string);
if(*in_ptr == '-') in_ptr++;
// Adstyle
get_str(string, "-\n", in_ptr, 1);
entry->adstyle = cstrdup(string);
if(*in_ptr == '-') in_ptr++;
// pixelsize
get_str(string, "-\n", in_ptr, 1);
entry->pixelsize = atol(string);
if(*in_ptr == '-') in_ptr++;
// pointsize
get_str(string, "-\n", in_ptr, 1);
entry->pointsize = atol(string);
if(*in_ptr == '-') in_ptr++;
// xres
get_str(string, "-\n", in_ptr, 1);
entry->xres = atol(string);
if(*in_ptr == '-') in_ptr++;
// yres
get_str(string, "-\n", in_ptr, 1);
entry->yres = atol(string);
if(*in_ptr == '-') in_ptr++;
// spacing
get_str(string, "-\n", in_ptr, 1);
entry->spacing = cstrdup(string);
if(*in_ptr == '-') in_ptr++;
// avg_width
get_str(string, "-\n", in_ptr, 1);
entry->avg_width = atol(string);
if(*in_ptr == '-') in_ptr++;
// registry
get_str(string, "-\n", in_ptr, 1);
entry->registry = cstrdup(string);
if(*in_ptr == '-') in_ptr++;
// encoding
get_str(string, "-\n", in_ptr, 1);
entry->encoding = cstrdup(string);
if(*in_ptr == '-') in_ptr++;
// Add to list
//printf("TitleMain::build_fonts 1 %s\n", entry->path);
// This takes a real long time to do. Instead just take all fonts
// if(!load_freetype_face(freetype_library,
// freetype_face, entry->path) )
// Fix parameters
sprintf(line, "%s (%s)", entry->family, entry->foundry);
entry->displayname = cstrdup(line);
if(!strcasecmp(entry->weight, "demibold")) {
entry->fixed_style |= BC_FONT_BOLD;
entry->style |= FL_WEIGHT_DEMIBOLD;
}
else if(!strcasecmp(entry->weight, "bold")) {
entry->fixed_style |= BC_FONT_BOLD;
entry->style |= FL_WEIGHT_BOLD;
}
else {
entry->style |= FL_WEIGHT_NORMAL;
}
if(!strcasecmp(entry->slant, "r")) {
entry->style |= FL_SLANT_ROMAN;
}
else if(!strcasecmp(entry->slant, "i")) {
entry->style |= FL_SLANT_ITALIC;
entry->fixed_style |= BC_FONT_ITALIC;
}
else if(!strcasecmp(entry->slant, "o")) {
entry->style |= FL_SLANT_OBLIQUE;
entry->fixed_style |= BC_FONT_ITALIC;
}
if(!strcasecmp(entry->swidth, "normal"))
entry->style = FL_WIDTH_NORMAL;
else if(!strcasecmp(entry->swidth, "ultracondensed"))
entry->style = FL_WIDTH_ULTRACONDENSED;
else if(!strcasecmp(entry->swidth, "extracondensed"))
entry->style = FL_WIDTH_EXTRACONDENSED;
else if(!strcasecmp(entry->swidth, "condensed"))
entry->style = FL_WIDTH_CONDENSED;
else if(!strcasecmp(entry->swidth, "semicondensed"))
entry->style = FL_WIDTH_SEMICONDENSED;
else if(!strcasecmp(entry->swidth, "semiexpanded"))
entry->style = FL_WIDTH_SEMIEXPANDED;
else if(!strcasecmp(entry->swidth, "expanded"))
entry->style = FL_WIDTH_EXPANDED;
else if(!strcasecmp(entry->swidth, "extraexpanded"))
entry->style = FL_WIDTH_EXTRAEXPANDED;
else if(!strcasecmp(entry->swidth, "ultraexpanded"))
entry->style = FL_WIDTH_ULTRAEXPANDED;
else
entry->style = FL_WIDTH_NORMAL;
fontlist->append(entry);
// printf("TitleMain::build_fonts %s: success\n", entry->path);
//printf("TitleMain::build_fonts 2\n");
}
pclose(in);
// Load all the fonts from fontconfig
FcPattern *pat;
FcFontSet *fs;
FcObjectSet *os;
FcChar8 *family, *file, *foundry, *style, *format;
int slant, spacing, width, weight;
int force_style = 0;
// if you want limit search to TrueType put 1
int limit_to_trutype = 1;
FcConfig *config;
int i;
char tmpstring[BCTEXTLEN];
if(!FcInit())
return 1;
config = FcConfigGetCurrent();
FcConfigSetRescanInterval(config, 0);
pat = FcPatternCreate();
os = FcObjectSetBuild ( FC_FAMILY, FC_FILE, FC_FOUNDRY, FC_WEIGHT,
FC_WIDTH, FC_SLANT, FC_FONTFORMAT, FC_SPACING, FC_STYLE, (char *) 0);
FcPatternAddBool(pat, FC_SCALABLE, true);
if(language[0]) {
char langstr[LEN_LANG * 3];
strcpy(langstr, language);
if(region[0]) {
strcat(langstr, "-");
strcat(langstr, region);
}
FcLangSet *ls = FcLangSetCreate();
if(FcLangSetAdd(ls, (const FcChar8*)langstr))
if(FcPatternAddLangSet(pat, FC_LANG, ls))
FcLangSetDestroy(ls);
}
fs = FcFontList(config, pat, os);
FcPatternDestroy(pat);
FcObjectSetDestroy(os);
for (i = 0; fs && i < fs->nfont; i++) {
FcPattern *font = fs->fonts[i];
force_style = 0;
FcPatternGetString(font, FC_FONTFORMAT, 0, &format);
//on this point you can limit font search
if(limit_to_trutype && strcmp((char *)format, "TrueType"))
continue;
sprintf(tmpstring, "%s", format);
BC_FontEntry *entry = new BC_FontEntry;
if(FcPatternGetString(font, FC_FILE, 0, &file) == FcResultMatch) {
entry->path = cstrdup((char*)file);
}
if(FcPatternGetString(font, FC_FOUNDRY, 0, &foundry) == FcResultMatch) {
entry->foundry = cstrdup((char*)foundry);
}
if(FcPatternGetInteger(font, FC_WEIGHT, 0, &weight) == FcResultMatch) {
switch(weight) {
case FC_WEIGHT_THIN:
case FC_WEIGHT_EXTRALIGHT:
case FC_WEIGHT_LIGHT:
case FC_WEIGHT_BOOK:
force_style = 1;
entry->weight = cstrdup("medium");
break;
case FC_WEIGHT_NORMAL:
case FC_WEIGHT_MEDIUM:
default:
entry->weight = cstrdup("medium");
break;
case FC_WEIGHT_BLACK:
case FC_WEIGHT_SEMIBOLD:
case FC_WEIGHT_BOLD:
entry->weight = cstrdup("bold");
entry->fixed_style |= BC_FONT_BOLD;
break;
case FC_WEIGHT_EXTRABOLD:
case FC_WEIGHT_EXTRABLACK:
force_style = 1;
entry->weight = cstrdup("bold");
entry->fixed_style |= BC_FONT_BOLD;
break;
}
}
if(FcPatternGetString(font, FC_FAMILY, 0, &family) == FcResultMatch)
entry->family = cstrdup((char*)family);
if(FcPatternGetInteger(font, FC_SLANT, 0, &slant) == FcResultMatch) {
switch(slant) {
case FC_SLANT_ROMAN:
default:
entry->slant = cstrdup("r");
entry->style |= FL_SLANT_ROMAN;
break;
case FC_SLANT_ITALIC:
entry->slant = cstrdup("i");
entry->style |= FL_SLANT_ITALIC;
entry->fixed_style |= BC_FONT_ITALIC;
break;
case FC_SLANT_OBLIQUE:
entry->slant = cstrdup("o");
entry->style |= FL_SLANT_OBLIQUE;
entry->fixed_style |= BC_FONT_ITALIC;
break;
}
}
if(FcPatternGetInteger(font, FC_WIDTH, 0, &width) == FcResultMatch) {
switch(width) {
case FC_WIDTH_ULTRACONDENSED:
entry->swidth = cstrdup("ultracondensed");
break;
case FC_WIDTH_EXTRACONDENSED:
entry->swidth = cstrdup("extracondensed");
break;
case FC_WIDTH_CONDENSED:
entry->swidth = cstrdup("condensed");
break;
case FC_WIDTH_SEMICONDENSED:
entry->swidth = cstrdup("semicondensed");
break;
case FC_WIDTH_NORMAL:
default:
entry->swidth = cstrdup("normal");
break;
case FC_WIDTH_SEMIEXPANDED:
entry->swidth = cstrdup("semiexpanded");
break;
case FC_WIDTH_EXPANDED:
entry->swidth = cstrdup("expanded");
break;
case FC_WIDTH_EXTRAEXPANDED:
entry->swidth = cstrdup("extraexpanded");
break;
case FC_WIDTH_ULTRAEXPANDED:
entry->swidth = cstrdup("ultraexpanded");
break;
}
}
if(FcPatternGetInteger(font, FC_SPACING, 0, &spacing) == FcResultMatch) {
switch(spacing) {
case 0:
default:
entry->spacing = cstrdup("p");
break;
case 90:
entry->spacing = cstrdup("d");
break;
case 100:
entry->spacing = cstrdup("m");
break;
case 110:
entry->spacing = cstrdup("c");
break;
}
}
// Add fake stuff for compatibility
entry->adstyle = cstrdup(" ");
entry->pixelsize = 0;
entry->pointsize = 0;
entry->xres = 0;
entry->yres = 0;
entry->avg_width = 0;
entry->registry = cstrdup("utf");
entry->encoding = cstrdup("8");
if(!FcPatternGetString(font, FC_STYLE, 0, &style) == FcResultMatch)
force_style = 0;
// If font has a style unmanaged by titler plugin, force style to be displayed on name
// in this way we can shown all available fonts styles.
if(force_style) {
sprintf(tmpstring, "%s (%s)", entry->family, style);
entry->displayname = cstrdup(tmpstring);
}
else {
if(strcmp(entry->foundry, "unknown")) {
sprintf(tmpstring, "%s (%s)", entry->family, entry->foundry);
entry->displayname = cstrdup(tmpstring);
}
else {
sprintf(tmpstring, "%s", entry->family);
entry->displayname = cstrdup(tmpstring);
}
}
fontlist->append(entry);
}
FcFontSetDestroy(fs);
if(freetype_library)
FT_Done_FreeType(freetype_library);
// for(int i = 0; i < fonts->total; i++)
// fonts->values[i]->dump();
FcConfigAppFontAddDir(0, (const FcChar8*)search_path);
FcConfigSetRescanInterval(0, 0);
os = FcObjectSetBuild(FC_FAMILY, FC_FILE, FC_FOUNDRY, FC_WEIGHT,
FC_WIDTH, FC_SLANT, FC_SPACING, FC_STYLE, (char *)0);
pat = FcPatternCreate();
FcPatternAddBool(pat, FC_SCALABLE, true);
if(language[0])
{
char langstr[LEN_LANG * 3];
strcpy(langstr, language);
if(region[0])
{
strcat(langstr, "-");
strcat(langstr, region);
}
FcLangSet *ls = FcLangSetCreate();
if(FcLangSetAdd(ls, (const FcChar8*)langstr))
if(FcPatternAddLangSet(pat, FC_LANG, ls))
FcLangSetDestroy(ls);
}
fs = FcFontList(0, pat, os);
FcPatternDestroy(pat);
FcObjectSetDestroy(os);
for(int i = 0; i < fs->nfont; i++)
{
FcPattern *font = fs->fonts[i];
BC_FontEntry *entry = new BC_FontEntry;
FcChar8 *strvalue;
if(FcPatternGetString(font, FC_FILE, 0, &strvalue) == FcResultMatch)
{
entry->path = new char[strlen((char*)strvalue) + 1];
strcpy(entry->path, (char*)strvalue);
}
if(FcPatternGetString(font, FC_FOUNDRY, 0, &strvalue) == FcResultMatch)
{
entry->foundry = new char[strlen((char*)strvalue) + 1];
strcpy(entry->foundry, (char *)strvalue);
}
if(FcPatternGetString(font, FC_FAMILY, 0, &strvalue) == FcResultMatch)
{
entry->family = new char[strlen((char*)strvalue) + 2];
strcpy(entry->family, (char*)strvalue);
}
int intvalue;
if(FcPatternGetInteger(font, FC_SLANT, 0, &intvalue) == FcResultMatch)
{
switch(intvalue)
{
case FC_SLANT_ROMAN:
default:
entry->style |= FL_SLANT_ROMAN;
break;
case FC_SLANT_ITALIC:
entry->style |= FL_SLANT_ITALIC;
break;
case FC_SLANT_OBLIQUE:
entry->style |= FL_SLANT_OBLIQUE;
break;
}
}
if(FcPatternGetInteger(font, FC_WEIGHT, 0, &intvalue) == FcResultMatch)
{
switch(intvalue)
{
case FC_WEIGHT_THIN:
entry->style |= FL_WEIGHT_THIN;
break;
case FC_WEIGHT_EXTRALIGHT:
entry->style |= FL_WEIGHT_EXTRALIGHT;
break;
case FC_WEIGHT_LIGHT:
entry->style |= FL_WEIGHT_LIGHT;
break;
case FC_WEIGHT_BOOK:
entry->style |= FL_WEIGHT_BOOK;
break;
case FC_WEIGHT_NORMAL:
default:
entry->style |= FL_WEIGHT_NORMAL;
break;
case FC_WEIGHT_MEDIUM:
entry->style |= FL_WEIGHT_MEDIUM;
break;
case FC_WEIGHT_DEMIBOLD:
entry->style |= FL_WEIGHT_DEMIBOLD;
break;
case FC_WEIGHT_BOLD:
entry->style |= FL_WEIGHT_BOLD;
break;
case FC_WEIGHT_EXTRABOLD:
entry->style |= FL_WEIGHT_EXTRABOLD;
break;
case FC_WEIGHT_BLACK:
entry->style |= FL_WEIGHT_BLACK;
break;
case FC_WEIGHT_EXTRABLACK:
entry->style |= FL_WEIGHT_EXTRABLACK;
break;
}
}
if(FcPatternGetInteger(font, FC_WIDTH, 0, &intvalue) == FcResultMatch)
{
switch(intvalue)
{
case FC_WIDTH_ULTRACONDENSED:
entry->style |= FL_WIDTH_ULTRACONDENSED;
break;
case FC_WIDTH_EXTRACONDENSED:
entry->style |= FL_WIDTH_EXTRACONDENSED;
break;
case FC_WIDTH_CONDENSED:
entry->style |= FL_WIDTH_CONDENSED;
break;
case FC_WIDTH_SEMICONDENSED:
entry->style = FL_WIDTH_SEMICONDENSED;
break;
case FC_WIDTH_NORMAL:
default:
entry->style |= FL_WIDTH_NORMAL;
break;
case FC_WIDTH_SEMIEXPANDED:
entry->style |= FL_WIDTH_SEMIEXPANDED;
break;
case FC_WIDTH_EXPANDED:
entry->style |= FL_WIDTH_EXPANDED;
break;
case FC_WIDTH_EXTRAEXPANDED:
entry->style |= FL_WIDTH_EXTRAEXPANDED;
break;
case FC_WIDTH_ULTRAEXPANDED:
entry->style |= FL_WIDTH_ULTRAEXPANDED;
break;
}
}
if(FcPatternGetInteger(font, FC_SPACING, 0, &intvalue) == FcResultMatch)
{
switch(intvalue)
{
case FC_PROPORTIONAL:
default:
entry->style |= FL_PROPORTIONAL;
break;
case FC_DUAL:
entry->style |= FL_DUAL;
break;
case FC_MONO:
entry->style |= FL_MONO;
break;
case FC_CHARCELL:
entry->style |= FL_CHARCELL;
break;
}
}
if(entry->foundry && strcmp(entry->foundry, "unknown"))
{
char tempstr[BCTEXTLEN];
sprintf(tempstr, "%s (%s)", entry->family, entry->foundry);
entry->displayname = new char[strlen(tempstr) + 1];
strcpy(entry->displayname, tempstr);
}
else
{
entry->displayname = new char[strlen(entry->family) + 1];
strcpy(entry->displayname, entry->family);
}
fontlist->append(entry);
}
FcFontSetDestroy(fs);
return 0;
}
int main(int argc, char* argv[])
{
#ifdef Q_WS_X11
FcInit();
FcConfig *config = FcConfigCreate();
QByteArray fontDir = getenv("WEBKIT_TESTFONTS");
if (fontDir.isEmpty() || !QDir(fontDir).exists()) {
fprintf(stderr,
"\n\n"
"--------------------------------------------------------------------\n"
"WEBKIT_TESTFONTS environment variable is not set correctly.\n"
"This variable has to point to the directory containing the fonts\n"
"you can checkout from svn://labs.trolltech.com/svn/webkit/testfonts\n"
"--------------------------------------------------------------------\n"
);
exit(1);
}
char currentPath[PATH_MAX+1];
getcwd(currentPath, PATH_MAX);
QByteArray configFile = currentPath;
configFile += "/WebKitTools/DumpRenderTree/qt/fonts.conf";
if (!FcConfigParseAndLoad (config, (FcChar8*) configFile.data(), true))
qFatal("Couldn't load font configuration file");
if (!FcConfigAppFontAddDir (config, (FcChar8*) fontDir.data()))
qFatal("Couldn't add font dir!");
FcConfigSetCurrent(config);
#endif
QApplication app(argc, argv);
#ifdef Q_WS_X11
QX11Info::setAppDpiY(0, 96);
QX11Info::setAppDpiX(0, 96);
#endif
QFont f("Sans Serif");
f.setPointSize(9);
f.setWeight(QFont::Normal);
f.setStyle(QFont::StyleNormal);
app.setFont(f);
app.setStyle(QLatin1String("Plastique"));
signal(SIGILL, crashHandler); /* 4: illegal instruction (not reset when caught) */
signal(SIGTRAP, crashHandler); /* 5: trace trap (not reset when caught) */
signal(SIGFPE, crashHandler); /* 8: floating point exception */
signal(SIGBUS, crashHandler); /* 10: bus error */
signal(SIGSEGV, crashHandler); /* 11: segmentation violation */
signal(SIGSYS, crashHandler); /* 12: bad argument to system call */
signal(SIGPIPE, crashHandler); /* 13: write on a pipe with no reader */
signal(SIGXCPU, crashHandler); /* 24: exceeded CPU time limit */
signal(SIGXFSZ, crashHandler); /* 25: exceeded file size limit */
QStringList args = app.arguments();
if (args.count() < 2) {
qDebug() << "Usage: DumpRenderTree [-v] filename";
exit(0);
}
// supress debug output from Qt if not started with -v
if (!args.contains(QLatin1String("-v")))
qInstallMsgHandler(messageHandler);
WebCore::DumpRenderTree dumper;
if (args.last() == QLatin1String("-")) {
dumper.open();
} else {
if (!args.last().startsWith("/")
&& !args.last().startsWith("file:")
&& !args.last().startsWith("http:")
&& !args.last().startsWith("https:")) {
QString path = QDir::currentPath();
if (!path.endsWith('/'))
path.append('/');
args.last().prepend(path);
}
dumper.open(QUrl(args.last()));
}
return app.exec();
#ifdef Q_WS_X11
FcConfigSetCurrent(0);
#endif
}
/**
* \brief Init fontconfig.
* \param library libass library object
* \param ftlibrary freetype library object
* \param family default font family
* \param path default font path
* \return pointer to fontconfig private data
*/
fc_instance_t* fontconfig_init(ass_library_t* library, FT_Library ftlibrary, const char* family, const char* path)
{
int rc;
fc_instance_t* priv = calloc(1, sizeof(fc_instance_t));
const char* dir = library->fonts_dir;
int i;
rc = FcInit();
assert(rc);
priv->config = FcConfigGetCurrent();
if (!priv->config) {
mp_msg(MSGT_ASS, MSGL_FATAL, MSGTR_LIBASS_FcInitLoadConfigAndFontsFailed);
return 0;
}
for (i = 0; i < library->num_fontdata; ++i)
process_fontdata(priv, library, ftlibrary, i);
if (FcDirCacheValid((const FcChar8 *)dir) == FcFalse)
{
mp_msg(MSGT_ASS, MSGL_INFO, MSGTR_LIBASS_UpdatingFontCache);
if (FcGetVersion() >= 20390 && FcGetVersion() < 20400)
mp_msg(MSGT_ASS, MSGL_WARN,
MSGTR_LIBASS_BetaVersionsOfFontconfigAreNotSupported);
// FontConfig >= 2.4.0 updates cache automatically in FcConfigAppFontAddDir()
if (FcGetVersion() < 20390) {
FcFontSet* fcs;
FcStrSet* fss;
fcs = FcFontSetCreate();
fss = FcStrSetCreate();
rc = FcStrSetAdd(fss, (const FcChar8*)dir);
if (!rc) {
mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FcStrSetAddFailed);
goto ErrorFontCache;
}
rc = FcDirScan(fcs, fss, NULL, FcConfigGetBlanks(priv->config), (const FcChar8 *)dir, FcFalse);
if (!rc) {
mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FcDirScanFailed);
goto ErrorFontCache;
}
rc = FcDirSave(fcs, fss, (const FcChar8 *)dir);
if (!rc) {
mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FcDirSave);
goto ErrorFontCache;
}
ErrorFontCache:
;
}
}
rc = FcConfigAppFontAddDir(priv->config, (const FcChar8*)dir);
if (!rc) {
mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FcConfigAppFontAddDirFailed);
}
priv->family_default = family ? strdup(family) : 0;
priv->path_default = path ? strdup(path) : 0;
priv->index_default = 0;
return priv;
}
