int PsychShutdownText(void)
{
if (faceT || faceM) {
if (_verbosity > 3) fprintf(stderr, "libptbdrawtext_ftgl: In shutdown: faceT = %p faceM = %p\n", faceT, faceM);
// Delete OGLFT face objects:
if (faceT) delete(faceT);
faceT = NULL;
if (faceM) delete(faceM);
faceM = NULL;
// Delete Freetype face object:
FT_Done_Face(ft_face);
ft_face = NULL;
if (_verbosity > 3) fprintf(stderr, "libptbdrawtext_ftgl: Shutting down.\n");
}
_needsRebuild = true;
_firstCall = false;
// Shutdown fontmapper library:
FcFini();
return(0);
}
void enesim_text_shutdown(void)
{
#ifdef HAVE_FONTCONFIG
FcFini();
#endif
enesim_text_engine_freetype_shutdown();
}
void
cairo_test_fini (cairo_test_context_t *ctx)
{
if (ctx->log_file == NULL)
return;
if (ctx->log_file != stderr)
fclose (ctx->log_file);
ctx->log_file = NULL;
free (ctx->ref_name);
cairo_surface_destroy (ctx->ref_image);
cairo_surface_destroy (ctx->ref_image_flattened);
if (ctx->test_name != NULL)
free ((char *) ctx->test_name);
if (ctx->own_targets)
cairo_boilerplate_free_targets (ctx->targets_to_test);
cairo_boilerplate_fini ();
cairo_debug_reset_static_data ();
#if HAVE_FCFINI
FcFini ();
#endif
}
static void findfont(char *fontname, char *fontpath)
{
FcPattern *p = NULL;
FcChar8 *strval = NULL;
FcObjectSet *attr = NULL;
if (!FcInit())
return;
attr = FcObjectSetBuild (FC_FILE, (char *) 0);
p = FcNameParse((FcChar8*)fontname);
if (p == NULL)
return;
FcFontSet *fs = FcFontList (0, p, attr);
if (fs->nfont == 0)
return;
if (FcPatternGetString(fs->fonts[0], FC_FILE, 0, &strval) == FcResultTypeMismatch
|| strval == NULL)
return;
strcpy(fontpath, strval);
FcFontSetDestroy(fs);
FcObjectSetDestroy(attr);
FcPatternDestroy(p);
FcFini();
return;
}
std::string FindDefaultFont()
{
std::string answer("/usr/share/fonts/liberation/LiberationSans-Regular.ttf");
FcFontSet *fs;
FcPattern *pat;
FcResult result;
if (!FcInit())
{
return answer;
}
pat = FcNameParse((FcChar8 *)"LiberationSans-Regular.ttf");
FcConfigSubstitute(0, pat, FcMatchPattern);
FcDefaultSubstitute(pat);
fs = FcFontSetCreate();
FcPattern *match;
match = FcFontMatch(0, pat, &result);
if (match)
{
FcChar8 *file;
if (FcPatternGetString(match, FC_FILE, 0, &file) == FcResultMatch)
{
answer = (const char *)file;
}
FcPatternDestroy(match);
}
FcPatternDestroy(pat);
FcFini();
return answer;
}
void
evas_font_dir_cache_free(void)
{
if (font_dirs)
{
eina_hash_foreach(font_dirs, font_cache_dir_free, NULL);
eina_hash_free(font_dirs);
font_dirs = NULL;
}
#ifdef HAVE_FONTCONFIG
if (fc_init > 0)
{
fc_init--;
/* this is bad i got a:
* fccache.c:512: FcCacheFini: Assertion fcCacheChains[i] == ((void *)0)' failed.
*
* all i can do for now is shut this puppy down. butthat breaks, so disable
* it as in reality - there is little reason to care about the memory not
* being freed etc.
*
* note 04/08/2012 - this doesnt seem to cause an issue anymore?
*/
if (fc_init == 0) FcFini();
}
#endif
}
gfxQtPlatform::~gfxQtPlatform()
{
gfxFontconfigUtils::Shutdown();
sFontconfigUtils = nsnull;
delete gPlatformFonts;
gPlatformFonts = NULL;
delete gPlatformFontAliases;
gPlatformFontAliases = NULL;
delete gPrefFonts;
gPrefFonts = NULL;
delete gCodepointsWithNoFonts;
gCodepointsWithNoFonts = NULL;
cairo_debug_reset_static_data();
FT_Done_FreeType(gPlatformFTLibrary);
gPlatformFTLibrary = NULL;
#if 0
// It would be nice to do this (although it might need to be after
// the cairo shutdown that happens in ~gfxPlatform). It even looks
// idempotent. But it has fatal assertions that fire if stuff is
// leaked, and we hit them.
FcFini();
#endif
}
void platform_font_shutdown(void)
{
gfx::_free_fonts();
#if ENABLE(FONT_CONFIG)
FcFini();
#endif
}
/**
* Match and create font from given fontconfig pattern
*/
decltype(auto) make_font(cairo_t* cairo, string&& fontname, double offset, double dpi_x, double dpi_y) {
static bool fc_init{false};
if (!fc_init && !(fc_init = FcInit())) {
throw application_error("Could not load fontconfig");
} else if (FT_Init_FreeType(&g_ftlib) != FT_Err_Ok) {
throw application_error("Could not load FreeType");
}
static auto fc_cleanup = scope_util::make_exit_handler([] {
FT_Done_FreeType(g_ftlib);
FcFini();
});
auto pattern = FcNameParse((FcChar8*)fontname.c_str());
FcDefaultSubstitute(pattern);
FcConfigSubstitute(nullptr, pattern, FcMatchPattern);
FcResult result;
FcPattern* match = FcFontMatch(nullptr, pattern, &result);
FcPatternDestroy(pattern);
if (match == nullptr) {
throw application_error("Could not load font \"" + fontname + "\"");
}
#ifdef DEBUG_FONTCONFIG
FcPatternPrint(match);
#endif
return make_shared<font_fc>(cairo, match, offset, dpi_x, dpi_y);
}
int main(int argc,char **argv)
{
pthread_t threads[NTHR];
int i, j;
printf("Creating %d threads\n",NTHR);
for(i = 0;i<NTHR;i++)
{
struct thr_arg_s thr_arg;
int result;
thr_arg.thr_num=i;
result = pthread_create(&threads[i],NULL,run_test_in_thread,
(void *)&thr_arg);
if(result!=0)
{
fprintf(stderr,"Cannot create thread %d\n",i);
break;
}
}
for(j=0;j<i;j++)
{
pthread_join(threads[j],NULL);
printf("Joined thread %d\n",j);
}
FcFini();
return 0;
}
static void
cairo_perf_fini (void)
{
cairo_debug_reset_static_data ();
#if HAVE_FCFINI
FcFini ();
#endif
}
void
cairo_test_fini (void)
{
fclose (cairo_test_log_file);
cairo_debug_reset_static_data ();
#if HAVE_FCFINI
FcFini ();
#endif
}
static void
cairo_perf_fini (cairo_perf_t *perf)
{
cairo_boilerplate_free_targets (perf->targets);
free (perf->times);
cairo_debug_reset_static_data ();
#if HAVE_FCFINI
FcFini ();
#endif
}
bool SetFallbackFont(FreeTypeSettings *settings, const char *language_isocode, int winlangid, SetFallbackFontCallback *callback)
{
if (!FcInit()) return false;
bool ret = false;
/* Fontconfig doesn't handle full language isocodes, only the part
* before the _ of e.g. en_GB is used, so "remove" everything after
* the _. */
char lang[16];
seprintf(lang, lastof(lang), ":lang=%s", language_isocode);
char *split = strchr(lang, '_');
if (split != NULL) *split = '\0';
/* First create a pattern to match the wanted language. */
FcPattern *pat = FcNameParse((FcChar8*)lang);
/* We only want to know the filename. */
FcObjectSet *os = FcObjectSetBuild(FC_FILE, NULL);
/* Get the list of filenames matching the wanted language. */
FcFontSet *fs = FcFontList(NULL, pat, os);
/* We don't need these anymore. */
FcObjectSetDestroy(os);
FcPatternDestroy(pat);
if (fs != NULL) {
for (int i = 0; i < fs->nfont; i++) {
FcPattern *font = fs->fonts[i];
FcChar8 *file = NULL;
FcResult res = FcPatternGetString(font, FC_FILE, 0, &file);
if (res != FcResultMatch || file == NULL) {
continue;
}
strecpy(settings->small_font, (const char*)file, lastof(settings->small_font));
strecpy(settings->medium_font, (const char*)file, lastof(settings->medium_font));
strecpy(settings->large_font, (const char*)file, lastof(settings->large_font));
bool missing = callback(NULL);
DEBUG(freetype, 1, "Font \"%s\" misses%s glyphs", file, missing ? "" : " no");
if (!missing) {
ret = true;
break;
}
}
/* Clean up the list of filenames. */
FcFontSetDestroy(fs);
}
FcFini();
return ret;
}
bool platform_get_font_path(TTFFontDescriptor *font, utf8 *buffer, size_t size)
{
assert(buffer != NULL);
assert(font != NULL);
log_verbose("Looking for font %s with FontConfig.", font->font_name);
FcConfig* config = FcInitLoadConfigAndFonts();
if (!config)
{
log_error("Failed to initialize FontConfig library");
FcFini();
return false;
}
FcPattern* pat = FcNameParse((const FcChar8*) font->font_name);
FcConfigSubstitute(config, pat, FcMatchPattern);
FcDefaultSubstitute(pat);
bool found = false;
FcResult result = FcResultNoMatch;
FcPattern* match = FcFontMatch(config, pat, &result);
if (match)
{
FcChar8* filename = NULL;
if (FcPatternGetString(match, FC_FILE, 0, &filename) == FcResultMatch)
{
found = true;
safe_strcpy(buffer, (utf8*) filename, size);
log_verbose("FontConfig provided font %s", filename);
}
FcPatternDestroy(match);
} else {
log_warning("Failed to find required font.");
}
FcPatternDestroy(pat);
FcConfigDestroy(config);
FcFini();
return found;
}
void
WINGDIPAPI GdiplusShutdown (ULONG_PTR token)
{
if (startup) {
releaseCodecList ();
gdip_font_clear_pattern_cache ();
#if HAVE_FCFINI
FcFini ();
#endif
startup = FALSE; /* in case we want to restart it */
}
}
FontconfigFontProvider::FontconfigFontProvider() : _config(0) {
if (!FcInit()) {
warning("Failed to initialize fontconfig");
return;
}
_config = FcInitLoadConfigAndFonts();
if (!_config) {
warning("Failed to create fontconfig config");
FcFini();
}
}
gfxBeOSPlatform::~gfxBeOSPlatform()
{
gfxFontconfigUtils::Shutdown();
sFontconfigUtils = nsnull;
gfxPangoFontGroup::Shutdown();
#if 0
// It would be nice to do this (although it might need to be after
// the cairo shutdown that happens in ~gfxPlatform). It even looks
// idempotent. But it has fatal assertions that fire if stuff is
// leaked, and we hit them.
FcFini();
#endif
}
int
main (int argc, char **argv)
{
FcConfig *config;
FcConfigFileInfoIter iter;
#if HAVE_GETOPT_LONG || HAVE_GETOPT
int c;
setlocale (LC_ALL, "");
#if HAVE_GETOPT_LONG
while ((c = getopt_long (argc, argv, "Vh", longopts, NULL)) != -1)
#else
while ((c = getopt (argc, argv, "Vh")) != -1)
#endif
{
switch (c) {
case 'V':
fprintf (stderr, "fontconfig version %d.%d.%d\n",
FC_MAJOR, FC_MINOR, FC_REVISION);
exit (0);
case 'h':
usage (argv[0], 0);
default:
usage (argv[0], 1);
}
}
#endif
config = FcConfigGetCurrent ();
FcConfigFileInfoIterInit (config, &iter);
do
{
FcChar8 *name, *desc;
FcBool enabled;
if (FcConfigFileInfoIterGet (config, &iter, &name, &desc, &enabled))
{
printf ("%c %s: %s\n", enabled ? '+' : '-', name, desc);
FcStrFree (name);
FcStrFree (desc);
}
} while (FcConfigFileInfoIterNext (config, &iter));
FcFini ();
return 0;
}
/**
* using fontconfig for just getting the font file name by a wanted font name and style.
*/
char *get_font_filename(const char *family, const char *style) {
//initialize fontconfig
if (!FcInit()) {
throw util::Error{MSG(err) << "Failed to initialize fontconfig."};
}
//FcPattern *font_pattern = FcNameParse((const unsigned char *)"DejaVu Serif:style=Book");
FcPattern *font_pattern = FcPatternBuild(nullptr, FC_FAMILY, FcTypeString, family, nullptr);
FcPatternBuild(font_pattern, FC_STYLE, FcTypeString, style, nullptr);
//debug output: display above pattern as parsable string.
FcChar8 *query_string = FcNameUnparse(font_pattern);
log::log(MSG(info) << "Font queried: " << query_string);
free(query_string);
//tell fontconfig to find the best match
FcResult font_match_result;
FcPattern *font_match = FcFontMatch(nullptr, font_pattern, &font_match_result);
/*
//debug output: display matching font pattern as parsable string
FcChar8 *match_string = FcNameUnparse(font_match);
log::dbg2("resulting font: %s", match_string);
free(match_string);
*/
//get attibute FC_FILE (= filename) of best-matched font
FcChar8 *font_filename_tmp;
if (FcPatternGetString(font_match, FC_FILE, 0, &font_filename_tmp) != FcResultMatch) {
throw util::Error(MSG(err) << "Fontconfig could not provide font " << family << " " << style);
}
//copy the font filename because it will be freed when the pattern is destroyed.
char *font_filename = util::copy((const char *)font_filename_tmp);
log::log(MSG(info) << "Font file: " << font_filename);
//deinitialize fontconfig.
FcPatternDestroy(font_match);
FcPatternDestroy(font_pattern);
FcFini();
return font_filename;
}
// translated to utf8_main
int main(int argc, char *argv[])
{
int res = 0;
// disable I/O buffering
setvbuf(stdout, (char *) nullptr, _IONBF, 0);
setvbuf(stderr, (char *) nullptr, _IONBF, 0);
// Initialize crash diagnostics
diagnostics_module::get_instance()->init_crash_diagnostics();
#if defined(SDLMAME_ANDROID)
/* Enable standard application logging */
SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_VERBOSE);
#endif
// FIXME: this should be done differently
#ifdef SDLMAME_UNIX
sdl_entered_debugger = 0;
#if (!defined(SDLMAME_MACOSX)) && (!defined(SDLMAME_HAIKU)) && (!defined(SDLMAME_EMSCRIPTEN)) && (!defined(SDLMAME_ANDROID))
FcInit();
#endif
#endif
{
sdl_options options;
sdl_osd_interface osd(options);
osd.register_options();
res = emulator_info::start_frontend(options, osd, argc, argv);
}
#ifdef SDLMAME_UNIX
#if (!defined(SDLMAME_MACOSX)) && (!defined(SDLMAME_HAIKU)) && (!defined(SDLMAME_EMSCRIPTEN)) && (!defined(SDLMAME_ANDROID))
if (!sdl_entered_debugger)
{
FcFini();
}
#endif
#endif
exit(res);
}
gfxPlatform::~gfxPlatform()
{
// The cairo folks think we should only clean up in debug builds,
// but we're generally in the habit of trying to shut down as
// cleanly as possible even in production code, so call this
// cairo_debug_* function unconditionally.
//
// because cairo can assert and thus crash on shutdown, don't do this in release builds
#if MOZ_TREE_CAIRO && (defined(DEBUG) || defined(NS_BUILD_REFCNT_LOGGING) || defined(NS_TRACE_MALLOC))
cairo_debug_reset_static_data();
#endif
#if 0
// It would be nice to do this (although it might need to be after
// the cairo shutdown that happens in ~gfxPlatform). It even looks
// idempotent. But it has fatal assertions that fire if stuff is
// leaked, and we hit them.
FcFini();
#endif
}
/**
* cairo_os2_fini:
*
* Uninitializes the Cairo library. This function is automatically called if
* Cairo was compiled to be a DLL (however it's not a problem if it's called
* multiple times). But if you link to Cairo statically, you have to call it
* once to shut down Cairo, to let it free all the resources it has allocated.
*
* Since: 1.4
**/
cairo_public void
cairo_os2_fini (void)
{
/* This has to uninitialize some stuffs, like destroy mutex semaphores etc.. */
if (cairo_os2_initialization_count <= 0) return;
cairo_os2_initialization_count--;
if (cairo_os2_initialization_count > 0) return;
DisableFPUException ();
cairo_debug_reset_static_data ();
#if CAIRO_HAS_FC_FONT
# if HAVE_FCFINI
/* Uninitialize FontConfig */
FcFini ();
# endif
#endif
#ifdef __WATCOMC__
/* It can happen that the libraries we use have memory leaks,
* so there are still memory chunks allocated at this point.
* In these cases, Watcom might still have a bigger memory chunk,
* called "the heap" allocated from the OS.
* As we want to minimize the memory we lose from the point of
* view of the OS, we call this function to shrink that heap
* as much as possible.
*/
_heapshrink ();
#else
/* GCC has a heapmin function that approximately corresponds to
* what the Watcom function does
*/
_heapmin ();
#endif
}
int gt_lib_clean(void)
{
int fa_fptr_rval, fa_mmap_rval, gt_rval;
if (spacepeak) {
gt_ma_show_space_peak(stdout);
gt_fa_show_space_peak(stdout);
gt_spacepeak_show_space_peak(stdout);
gt_ma_disable_global_spacepeak();
}
fa_fptr_rval = gt_fa_check_fptr_leak();
fa_mmap_rval = gt_fa_check_mmap_leak();
gt_fa_clean();
gt_symbol_clean();
gt_class_alloc_clean();
gt_ya_rand_clean();
gt_log_clean();
gt_spacepeak_clean();
gt_rval = gt_ma_check_space_leak();
gt_ma_clean();
#ifndef WITHOUT_CAIRO
FcFini();
#endif
return fa_fptr_rval || fa_mmap_rval || gt_rval;
}
// translated to utf8_main
int main(int argc, char *argv[])
{
int res = 0;
// disable I/O buffering
setvbuf(stdout, (char *) NULL, _IONBF, 0);
setvbuf(stderr, (char *) NULL, _IONBF, 0);
// FIXME: this should be done differently
#ifdef SDLMAME_UNIX
sdl_entered_debugger = 0;
#if (!defined(SDLMAME_MACOSX)) && (!defined(SDLMAME_HAIKU)) && (!defined(SDLMAME_EMSCRIPTEN))
FcInit();
#endif
#endif
{
sdl_options options;
sdl_osd_interface osd(options);
osd.register_options();
cli_frontend frontend(options, osd);
res = frontend.execute(argc, argv);
}
#ifdef SDLMAME_UNIX
#if (!defined(SDLMAME_MACOSX)) && (!defined(SDLMAME_HAIKU)) && (!defined(SDLMAME_EMSCRIPTEN))
if (!sdl_entered_debugger)
{
FcFini();
}
#endif
#endif
exit(res);
}
static void
cairo_perf_trace (cairo_perf_t *perf,
const cairo_boilerplate_target_t *target,
const char *trace)
{
cairo_surface_t *surface;
void *closure;
surface = (target->create_surface) (NULL,
CAIRO_CONTENT_COLOR_ALPHA,
1, 1,
1, 1,
CAIRO_BOILERPLATE_MODE_PERF,
0,
&closure);
if (surface == NULL) {
fprintf (stderr,
"Error: Failed to create target surface: %s\n",
target->name);
return;
}
cairo_perf_timer_set_synchronize (target->synchronize, closure);
execute (perf, closure, surface, trace);
cairo_surface_destroy (surface);
if (target->cleanup)
target->cleanup (closure);
cairo_debug_reset_static_data ();
#if HAVE_FCFINI
FcFini ();
#endif
}
int
main (int argc, char **argv)
{
int brief = 0;
FcChar8 *format = NULL;
int i;
FcFontSet *fs;
#if HAVE_GETOPT_LONG || HAVE_GETOPT
int c;
setlocale (LC_ALL, "");
#if HAVE_GETOPT_LONG
while ((c = getopt_long (argc, argv, "bf:Vh", longopts, NULL)) != -1)
#else
while ((c = getopt (argc, argv, "bf:Vh")) != -1)
#endif
{
switch (c) {
case 'b':
brief = 1;
break;
case 'f':
format = (FcChar8 *) strdup (optarg);
break;
case 'V':
fprintf (stderr, "fontconfig version %d.%d.%d\n",
FC_MAJOR, FC_MINOR, FC_REVISION);
exit (0);
case 'h':
usage (argv[0], 0);
default:
usage (argv[0], 1);
}
}
i = optind;
#else
i = 1;
#endif
if (i == argc)
usage (argv[0], 1);
fs = FcFontSetCreate ();
for (; i < argc; i++)
{
const FcChar8 *file = (FcChar8*) argv[i];
if (!FcFileIsDir (file))
FcFileScan (fs, NULL, NULL, NULL, file, FcTrue);
else
{
FcStrSet *dirs = FcStrSetCreate ();
FcStrList *strlist = FcStrListCreate (dirs);
do
{
FcDirScan (fs, dirs, NULL, NULL, file, FcTrue);
}
while ((file = FcStrListNext (strlist)));
FcStrListDone (strlist);
FcStrSetDestroy (dirs);
}
}
for (i = 0; i < fs->nfont; i++)
{
FcPattern *pat = fs->fonts[i];
if (brief)
{
FcPatternDel (pat, FC_CHARSET);
FcPatternDel (pat, FC_LANG);
}
if (format)
{
FcChar8 *s;
s = FcPatternFormat (pat, format);
if (s)
{
printf ("%s", s);
FcStrFree (s);
}
}
else
{
FcPatternPrint (pat);
}
}
FcFontSetDestroy (fs);
FcFini ();
return i > 0 ? 0 : 1;
}
int
main (int argc, char **argv)
{
int i;
int ret = 0;
FcFontSet *fs;
FcStrSet *dirs;
FcStrSet *args = NULL;
FcStrList *arglist;
FcCache *cache;
FcConfig *config;
FcChar8 *arg;
int verbose = 0;
int recurse = 0;
FcBool first = FcTrue;
#if HAVE_GETOPT_LONG || HAVE_GETOPT
int c;
#if HAVE_GETOPT_LONG
while ((c = getopt_long (argc, argv, "Vvrh", longopts, NULL)) != -1)
#else
while ((c = getopt (argc, argv, "Vvrh")) != -1)
#endif
{
switch (c) {
case 'V':
fprintf (stderr, "fontconfig version %d.%d.%d\n",
FC_MAJOR, FC_MINOR, FC_REVISION);
exit (0);
case 'v':
verbose++;
break;
case 'r':
recurse++;
break;
case 'h':
usage (argv[0], 0);
default:
usage (argv[0], 1);
}
}
i = optind;
#else
i = 1;
#endif
config = FcInitLoadConfig ();
if (!config)
{
fprintf (stderr, "%s: Can't init font config library\n", argv[0]);
return 1;
}
FcConfigSetCurrent (config);
args = FcStrSetCreate ();
if (!args)
{
fprintf (stderr, "%s: malloc failure\n", argv[0]);
return 1;
}
if (i < argc)
{
for (; i < argc; i++)
{
if (!FcStrSetAddFilename (args, (const FcChar8 *) argv[i]))
{
fprintf (stderr, "%s: malloc failure\n", argv[0]);
return 1;
}
}
arglist = FcStrListCreate (args);
if (!arglist)
{
fprintf (stderr, "%s: malloc failure\n", argv[0]);
return 1;
}
}
else
{
recurse++;
arglist = FcConfigGetFontDirs (config);
while ((arg = FcStrListNext (arglist)))
if (!FcStrSetAdd (args, arg))
{
fprintf (stderr, "%s: malloc failure\n", argv[0]);
return 1;
}
FcStrListDone (arglist);
}
arglist = FcStrListCreate (args);
if (!arglist)
{
fprintf (stderr, "%s: malloc failure\n", argv[0]);
return 1;
}
while ((arg = FcStrListNext (arglist)))
{
int j;
FcChar8 *cache_file = NULL;
struct stat file_stat;
if (FcFileIsDir (arg))
cache = FcDirCacheLoad (arg, config, &cache_file);
else
cache = FcDirCacheLoadFile (arg, &file_stat);
if (!cache)
{
perror ((char *) arg);
ret++;
continue;
}
dirs = FcStrSetCreate ();
fs = FcCacheCopySet (cache);
for (j = 0; j < FcCacheNumSubdir (cache); j++)
{
FcStrSetAdd (dirs, FcCacheSubdir (cache, j));
if (recurse)
FcStrSetAdd (args, FcCacheSubdir (cache, j));
}
if (verbose)
{
if (!first)
printf ("\n");
printf ("Directory: %s\nCache: %s\n--------\n",
FcCacheDir(cache), cache_file ? cache_file : arg);
first = FcFalse;
}
cache_print_set (fs, dirs, FcCacheDir (cache), verbose);
FcStrSetDestroy (dirs);
FcFontSetDestroy (fs);
FcDirCacheUnload (cache);
if (cache_file)
FcStrFree (cache_file);
}
FcFini ();
return 0;
}
FontconfigFontProvider::~FontconfigFontProvider() {
if (_config) {
FcConfigDestroy(_config);
FcFini();
}
}
// translated to utf8_main
int main(int argc, char *argv[])
{
int res = 0;
#if defined(SDLMAME_X11) && !(SDLMAME_SDL2)
XInitThreads();
#endif
#if defined(SDLMAME_WIN32)
#if !(SDLMAME_SDL2)
/* Load SDL dynamic link library */
if ( SDL_Init(SDL_INIT_NOPARACHUTE) < 0 ) {
fprintf(stderr, "WinMain() error: %s", SDL_GetError());
return(FALSE);
}
SDL_SetModuleHandle(GetModuleHandle(NULL));
#endif
#endif
// disable I/O buffering
setvbuf(stdout, (char *) NULL, _IONBF, 0);
setvbuf(stderr, (char *) NULL, _IONBF, 0);
// FIXME: this should be done differently
#ifdef SDLMAME_UNIX
sdl_entered_debugger = 0;
#if (!defined(SDLMAME_MACOSX)) && (!defined(SDLMAME_HAIKU)) && (!defined(SDLMAME_EMSCRIPTEN))
FcInit();
#endif
#endif
#ifdef SDLMAME_OS2
MorphToPM();
#endif
#if defined(SDLMAME_X11) && (SDL_MAJOR_VERSION == 1) && (SDL_MINOR_VERSION == 2)
if (SDL_Linked_Version()->patch < 10)
/* workaround for SDL choosing a 32-bit ARGB visual */
{
Display *display;
if ((display = XOpenDisplay(NULL)) && (DefaultDepth(display, DefaultScreen(display)) >= 24))
{
XVisualInfo vi;
char buf[130];
if (XMatchVisualInfo(display, DefaultScreen(display), 24, TrueColor, &vi)) {
snprintf(buf, sizeof(buf), "0x%lx", vi.visualid);
osd_setenv(SDLENV_VISUALID, buf, 0);
}
}
if (display)
XCloseDisplay(display);
}
#endif
{
sdl_options options;
sdl_osd_interface osd(options);
osd.register_options();
cli_frontend frontend(options, osd);
res = frontend.execute(argc, argv);
}
#ifdef SDLMAME_UNIX
#if (!defined(SDLMAME_MACOSX)) && (!defined(SDLMAME_HAIKU)) && (!defined(SDLMAME_EMSCRIPTEN))
if (!sdl_entered_debugger)
{
FcFini();
}
#endif
#endif
exit(res);
}
