void addFontsToEnvironment() { FcInit(); // Load our configuration file, which sets up proper aliases for family // names like sans, serif and monospace. FcConfig* config = FcConfigCreate(); const char* fontConfigFilename = FONTS_CONF_DIR "/fonts.conf"; if (!FcConfigParseAndLoad(config, reinterpret_cast<const FcChar8*>(fontConfigFilename), true)) { fprintf(stderr, "Couldn't load font configuration file from: %s\n", fontConfigFilename); exit(1); } if (!addFontDirectory(DOWNLOADED_FONTS_DIR, config)) { fprintf(stderr, "None of the font directories could be added. Either install them " "or file a bug at http://bugs.webkit.org if they are installed in " "another location.\n"); exit(1); } addFontFiles(getFontFiles(), config); if (!FcConfigSetCurrent(config)) { fprintf(stderr, "Could not set the current font configuration!\n"); exit(1); } }
static AliasStrength strengthOfFirstAlias(const FcPattern& original) { // Ideally there would exist a call like // FcResult FcPatternIsWeak(pattern, object, id, FcBool* isWeak); // // However, there is no such call and as of Fc 2.11.0 even FcPatternEquals ignores the weak bit. // Currently, the only reliable way of finding the weak bit is by its effect on matching. // The weak bit only affects the matching of FC_FAMILY and FC_POSTSCRIPT_NAME object values. // A element with the weak bit is scored after FC_LANG, without the weak bit is scored before. // Note that the weak bit is stored on the element, not on the value it holds. FcValue value; FcResult result = FcPatternGet(&original, FC_FAMILY, 0, &value); if (result != FcResultMatch) return AliasStrength::Done; RefPtr<FcPattern> pattern = adoptRef(FcPatternDuplicate(&original)); FcBool hasMultipleFamilies = true; while (hasMultipleFamilies) hasMultipleFamilies = FcPatternRemove(pattern.get(), FC_FAMILY, 1); // Create a font set with two patterns. // 1. the same FC_FAMILY as pattern and a lang object with only 'nomatchlang'. // 2. a different FC_FAMILY from pattern and a lang object with only 'matchlang'. FcUniquePtr<FcFontSet> fontSet(FcFontSetCreate()); FcUniquePtr<FcLangSet> strongLangSet(FcLangSetCreate()); FcLangSetAdd(strongLangSet.get(), reinterpret_cast<const FcChar8*>("nomatchlang")); // Ownership of this FcPattern will be transferred with FcFontSetAdd. FcPattern* strong = FcPatternDuplicate(pattern.get()); FcPatternAddLangSet(strong, FC_LANG, strongLangSet.get()); FcUniquePtr<FcLangSet> weakLangSet(FcLangSetCreate()); FcLangSetAdd(weakLangSet.get(), reinterpret_cast<const FcChar8*>("matchlang")); // Ownership of this FcPattern will be transferred via FcFontSetAdd. FcPattern* weak = FcPatternCreate(); FcPatternAddString(weak, FC_FAMILY, reinterpret_cast<const FcChar8*>("nomatchstring")); FcPatternAddLangSet(weak, FC_LANG, weakLangSet.get()); FcFontSetAdd(fontSet.get(), strong); FcFontSetAdd(fontSet.get(), weak); // Add 'matchlang' to the copy of the pattern. FcPatternAddLangSet(pattern.get(), FC_LANG, weakLangSet.get()); // Run a match against the copy of the pattern. // If the first element was weak, then we should match the pattern with 'matchlang'. // If the first element was strong, then we should match the pattern with 'nomatchlang'. // Note that this config is only used for FcFontRenderPrepare, which we don't even want. // However, there appears to be no way to match/sort without it. RefPtr<FcConfig> config = adoptRef(FcConfigCreate()); FcFontSet* fontSets[1] = { fontSet.get() }; RefPtr<FcPattern> match = adoptRef(FcFontSetMatch(config.get(), fontSets, 1, pattern.get(), &result)); FcLangSet* matchLangSet; FcPatternGetLangSet(match.get(), FC_LANG, 0, &matchLangSet); return FcLangEqual == FcLangSetHasLang(matchLangSet, reinterpret_cast<const FcChar8*>("matchlang")) ? AliasStrength::Weak : AliasStrength::Strong; }
/* * Load the configuration files */ FcConfig * FcInitLoadOwnConfig (FcConfig *config) { if (!config) { config = FcConfigCreate (); if (!config) return NULL; } FcInitDebug (); if (!FcConfigParseAndLoad (config, 0, FcTrue)) { FcConfigDestroy (config); return FcInitFallbackConfig (); } if (config->cacheDirs && config->cacheDirs->num == 0) { FcChar8 *prefix, *p; size_t plen; fprintf (stderr, "Fontconfig warning: no <cachedir> elements found. Check configuration.\n"); fprintf (stderr, "Fontconfig warning: adding <cachedir>%s</cachedir>\n", FC_CACHEDIR); prefix = FcConfigXdgCacheHome (); if (!prefix) goto bail; plen = strlen ((const char *)prefix); p = realloc (prefix, plen + 12); if (!p) goto bail; prefix = p; memcpy (&prefix[plen], FC_DIR_SEPARATOR_S "fontconfig", 11); prefix[plen + 11] = 0; fprintf (stderr, "Fontconfig warning: adding <cachedir prefix=\"xdg\">fontconfig</cachedir>\n"); if (!FcConfigAddCacheDir (config, (FcChar8 *) FC_CACHEDIR) || !FcConfigAddCacheDir (config, (FcChar8 *) prefix)) { bail: fprintf (stderr, "Fontconfig error: out of memory"); if (prefix) FcStrFree (prefix); FcConfigDestroy (config); return FcInitFallbackConfig (); } FcStrFree (prefix); } return config; }
/** * \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; }
// coverity[+alloc : arg-*0] GpStatus GdipNewPrivateFontCollection (GpFontCollection **font_collection) { GpFontCollection *result; if (!font_collection) return InvalidParameter; result = (GpFontCollection *) GdipAlloc (sizeof (GpFontCollection)); if (result) { result->fontset = NULL; result->config = FcConfigCreate (); } *font_collection = result; return Ok; }
static int Py_Config_init(Py_Config *self, PyObject *args, PyObject *kwds) { if (!PyArg_ParseTuple(args, ":Config")) { return -1; } self->x = FcConfigCreate(); if (self->x == NULL) { PyErr_SetString( PyExc_RuntimeError, "Could not create config"); return -1; } return 0; }
static FcConfig * FcInitFallbackConfig (void) { FcConfig *config; config = FcConfigCreate (); if (!config) goto bail0; if (!FcConfigAddDir (config, (FcChar8 *) FC_DEFAULT_FONTS)) goto bail1; if (!FcConfigAddCacheDir (config, (FcChar8 *) FC_CACHEDIR)) goto bail1; return config; bail1: FcConfigDestroy (config); bail0: return 0; }
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 }
/* * Load the configuration files */ FcConfig * FcInitLoadConfig (void) { FcConfig *config; FcInitDebug (); config = FcConfigCreate (); if (!config) return FcFalse; if (!FcConfigParseAndLoad (config, 0, FcTrue)) { FcConfigDestroy (config); return FcInitFallbackConfig (); } if (config->cacheDirs && config->cacheDirs->num == 0) { fprintf (stderr, "Fontconfig warning: no <cachedir> elements found. Check configuration.\n"); fprintf (stderr, "Fontconfig warning: adding <cachedir>%s</cachedir>\n", FC_CACHEDIR); fprintf (stderr, "Fontconfig warning: adding <cachedir>~/.fontconfig</cachedir>\n"); if (!FcConfigAddCacheDir (config, (FcChar8 *) FC_CACHEDIR) || !FcConfigAddCacheDir (config, (FcChar8 *) "~/.fontconfig")) { fprintf (stderr, "Fontconfig error: out of memory"); FcConfigDestroy (config); return FcInitFallbackConfig (); } } printf("4\n"); return config; }
static void setupFontconfig() { // We wish to make the layout tests reproducable with respect to fonts. Skia // uses fontconfig to resolve font family names from WebKit into actual font // files found on the current system. This means that fonts vary based on the // system and also on the fontconfig configuration. // // To avoid this we initialise fontconfig here and install a configuration // which only knows about a few, select, fonts. // We have fontconfig parse a config file from our resources file. This // sets a number of aliases ("sans"->"Arial" etc), but doesn't include any // font directories. FcInit(); char drtPath[PATH_MAX + 1]; int drtPathSize = readlink("/proc/self/exe", drtPath, PATH_MAX); if (drtPathSize < 0 || drtPathSize > PATH_MAX) { fputs("Unable to resolve /proc/self/exe.", stderr); exit(1); } drtPath[drtPathSize] = 0; std::string drtDirPath(drtPath); size_t lastPathPos = drtDirPath.rfind("/"); ASSERT(lastPathPos != std::string::npos); drtDirPath.erase(lastPathPos + 1); FcConfig* fontcfg = FcConfigCreate(); std::string fontconfigPath = drtDirPath + "fonts.conf"; if (!FcConfigParseAndLoad(fontcfg, reinterpret_cast<const FcChar8*>(fontconfigPath.c_str()), true)) { fputs("Failed to parse fontconfig config file\n", stderr); exit(1); } // This is the list of fonts that fontconfig will know about. It // will try its best to match based only on the fonts here in. The // paths are where these fonts are found on our Ubuntu boxes. static const char *const fonts[] = { "/usr/share/fonts/truetype/kochi/kochi-gothic.ttf", "/usr/share/fonts/truetype/kochi/kochi-mincho.ttf", "/usr/share/fonts/truetype/msttcorefonts/Arial.ttf", "/usr/share/fonts/truetype/msttcorefonts/Arial_Bold.ttf", "/usr/share/fonts/truetype/msttcorefonts/Arial_Bold_Italic.ttf", "/usr/share/fonts/truetype/msttcorefonts/Arial_Italic.ttf", "/usr/share/fonts/truetype/msttcorefonts/Comic_Sans_MS.ttf", "/usr/share/fonts/truetype/msttcorefonts/Comic_Sans_MS_Bold.ttf", "/usr/share/fonts/truetype/msttcorefonts/Courier_New.ttf", "/usr/share/fonts/truetype/msttcorefonts/Courier_New_Bold.ttf", "/usr/share/fonts/truetype/msttcorefonts/Courier_New_Bold_Italic.ttf", "/usr/share/fonts/truetype/msttcorefonts/Courier_New_Italic.ttf", "/usr/share/fonts/truetype/msttcorefonts/Georgia.ttf", "/usr/share/fonts/truetype/msttcorefonts/Georgia_Bold.ttf", "/usr/share/fonts/truetype/msttcorefonts/Georgia_Bold_Italic.ttf", "/usr/share/fonts/truetype/msttcorefonts/Georgia_Italic.ttf", "/usr/share/fonts/truetype/msttcorefonts/Impact.ttf", "/usr/share/fonts/truetype/msttcorefonts/Trebuchet_MS.ttf", "/usr/share/fonts/truetype/msttcorefonts/Trebuchet_MS_Bold.ttf", "/usr/share/fonts/truetype/msttcorefonts/Trebuchet_MS_Bold_Italic.ttf", "/usr/share/fonts/truetype/msttcorefonts/Trebuchet_MS_Italic.ttf", "/usr/share/fonts/truetype/msttcorefonts/Times_New_Roman.ttf", "/usr/share/fonts/truetype/msttcorefonts/Times_New_Roman_Bold.ttf", "/usr/share/fonts/truetype/msttcorefonts/Times_New_Roman_Bold_Italic.ttf", "/usr/share/fonts/truetype/msttcorefonts/Times_New_Roman_Italic.ttf", "/usr/share/fonts/truetype/msttcorefonts/Verdana.ttf", "/usr/share/fonts/truetype/msttcorefonts/Verdana_Bold.ttf", "/usr/share/fonts/truetype/msttcorefonts/Verdana_Bold_Italic.ttf", "/usr/share/fonts/truetype/msttcorefonts/Verdana_Italic.ttf", "/usr/share/fonts/truetype/thai/Garuda.ttf", // The DejaVuSans font is used by the css2.1 tests. "/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans.ttf", "/usr/share/fonts/truetype/ttf-indic-fonts-core/lohit_hi.ttf", "/usr/share/fonts/truetype/ttf-indic-fonts-core/lohit_ta.ttf", "/usr/share/fonts/truetype/ttf-indic-fonts-core/MuktiNarrow.ttf", }; for (size_t i = 0; i < arraysize(fonts); ++i) { if (access(fonts[i], R_OK)) { fprintf(stderr, "You are missing %s. Try re-running build/install-build-deps.sh. Also see " "http://code.google.com/p/chromium/wiki/LayoutTestsLinux", fonts[i]); exit(1); } if (!FcConfigAppFontAddFile(fontcfg, (FcChar8 *) fonts[i])) { fprintf(stderr, "Failed to load font %s\n", fonts[i]); exit(1); } } // We special case these fonts because they're only needed in a // few layout tests. static const char* const optionalFonts[] = { "/usr/share/fonts/truetype/ttf-indic-fonts-core/lohit_pa.ttf", }; for (size_t i = 0; i < arraysize(optionalFonts); ++i) { const char* font = optionalFonts[i]; // This font changed paths across Ubuntu releases, so try checking in both locations. if (!strcmp(font, "/usr/share/fonts/truetype/ttf-indic-fonts-core/lohit_pa.ttf") && access(font, R_OK) < 0) font = "/usr/share/fonts/truetype/ttf-punjabi-fonts/lohit_pa.ttf"; if (access(font, R_OK) < 0) { fprintf(stderr, "You are missing %s. Without this, some layout tests may fail. " "See http://code.google.com/p/chromium/wiki/LayoutTestsLinux " "for more.\n", font); } else if (!FcConfigAppFontAddFile(fontcfg, (FcChar8 *) font)) { fprintf(stderr, "Failed to load font %s\n", font); exit(1); } } // Also load the layout-test-specific "Ahem" font. std::string ahemPath = drtDirPath + "AHEM____.TTF"; if (!FcConfigAppFontAddFile(fontcfg, reinterpret_cast<const FcChar8*>(ahemPath.c_str()))) { fprintf(stderr, "Failed to load font %s\n", ahemPath.c_str()); exit(1); } if (!FcConfigSetCurrent(fontcfg)) { fputs("Failed to set the default font configuration\n", stderr); exit(1); } }
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 }
void initializeFontConfigSetting() { if (g_getenv("WEBKIT_SKIP_WEBKITTESTRUNNER_FONTCONFIG_INITIALIZATION")) return; FcInit(); // If a test resulted a font being added or removed via the @font-face rule, then // we want to reset the FontConfig configuration to prevent it from affecting other tests. static int numFonts = 0; FcFontSet* appFontSet = FcConfigGetFonts(0, FcSetApplication); if (appFontSet && numFonts && appFontSet->nfont == numFonts) return; // Load our configuration file, which sets up proper aliases for family // names like sans, serif and monospace. FcConfig* config = FcConfigCreate(); GUniquePtr<gchar> fontConfigFilename(g_build_filename(FONTS_CONF_DIR, "fonts.conf", nullptr)); if (!g_file_test(fontConfigFilename.get(), G_FILE_TEST_IS_REGULAR)) g_error("Cannot find fonts.conf at %s\n", fontConfigFilename.get()); if (!FcConfigParseAndLoad(config, reinterpret_cast<FcChar8*>(fontConfigFilename.get()), true)) g_error("Couldn't load font configuration file from: %s", fontConfigFilename.get()); CString fontsPath = getFontsPath(); if (fontsPath.isNull()) g_error("Could not locate test fonts at %s. Is WEBKIT_TOP_LEVEL set?", fontsPath.data()); GUniquePtr<GDir> fontsDirectory(g_dir_open(fontsPath.data(), 0, nullptr)); while (const char* directoryEntry = g_dir_read_name(fontsDirectory.get())) { if (!g_str_has_suffix(directoryEntry, ".ttf") && !g_str_has_suffix(directoryEntry, ".otf")) continue; GUniquePtr<gchar> fontPath(g_build_filename(fontsPath.data(), directoryEntry, nullptr)); if (!FcConfigAppFontAddFile(config, reinterpret_cast<const FcChar8*>(fontPath.get()))) g_error("Could not load font at %s!", fontPath.get()); } // Ahem is used by many layout tests. GUniquePtr<gchar> ahemFontFilename(g_build_filename(FONTS_CONF_DIR, "AHEM____.TTF", nullptr)); if (!FcConfigAppFontAddFile(config, reinterpret_cast<FcChar8*>(ahemFontFilename.get()))) g_error("Could not load font at %s!", ahemFontFilename.get()); static const char* fontFilenames[] = { "WebKitWeightWatcher100.ttf", "WebKitWeightWatcher200.ttf", "WebKitWeightWatcher300.ttf", "WebKitWeightWatcher400.ttf", "WebKitWeightWatcher500.ttf", "WebKitWeightWatcher600.ttf", "WebKitWeightWatcher700.ttf", "WebKitWeightWatcher800.ttf", "WebKitWeightWatcher900.ttf", 0 }; for (size_t i = 0; fontFilenames[i]; ++i) { GUniquePtr<gchar> fontFilename(g_build_filename(FONTS_CONF_DIR, "..", "..", "fonts", fontFilenames[i], nullptr)); if (!FcConfigAppFontAddFile(config, reinterpret_cast<FcChar8*>(fontFilename.get()))) g_error("Could not load font at %s!", fontFilename.get()); } // A font with no valid Fontconfig encoding to test https://bugs.webkit.org/show_bug.cgi?id=47452 GUniquePtr<gchar> fontWithNoValidEncodingFilename(g_build_filename(FONTS_CONF_DIR, "FontWithNoValidEncoding.fon", nullptr)); if (!FcConfigAppFontAddFile(config, reinterpret_cast<FcChar8*>(fontWithNoValidEncodingFilename.get()))) g_error("Could not load font at %s!", fontWithNoValidEncodingFilename.get()); if (!FcConfigSetCurrent(config)) g_error("Could not set the current font configuration!"); numFonts = FcConfigGetFonts(config, FcSetApplication)->nfont; }
int main(int argc, char** argv) { cairo_t *cr; cairo_status_t status; cairo_surface_t *surface; //FT_Bitmap bmp = {0}; int stride = 0; int width = 640; int height = 480; bool ok = FcConfigAppFontAddFile(NULL, (FcChar8*)"fonts/ComicSansAfrica.ttf"); if (!ok) { printf("Failed to load ComicSansAfrica.ttf\n"); } FcChar8 *configName = FcConfigFilename(NULL); printf("%s", (const char*)configName); printf("\n"); FcConfig* config = FcConfigCreate(); FcConfigParseAndLoad(config, configName, true); FcConfigSetCurrent(config); /* FT buffer */ //FT_Bitmap_New(&bmp); //bmp.rows = height; //bmp.width = width; //bmp.buffer = (unsigned char*)malloc(bmp.rows * bmp.width * 4); // if (NULL == bmp.buffer) // { // printf("+ error: cannot allocate the buffer for the output bitmap.\n"); // exit(EXIT_FAILURE); // } //bmp.pitch = ((width+3) & -4) * 4; //bmp.pixel_mode = FT_PIXEL_MODE_BGRA; //printf("%d\n", bmp.pitch); //stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width); //printf("%d\n", stride); //surface = cairo_image_surface_create_for_data(bmp.buffer, CAIRO_FORMAT_ARGB32, width, height, stride); surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height); if (CAIRO_STATUS_SUCCESS != cairo_surface_status(surface)) { printf("+ error: couldn't create the surface.\n"); exit(EXIT_FAILURE); } cr = cairo_create(surface); if (CAIRO_STATUS_NO_MEMORY == cairo_status(cr)) { printf("+ error: out of memory, cannot create cairo_t*\n"); exit(EXIT_FAILURE); } cairo_set_source_rgba(cr, 1.0, 1.0, 1.0, 1.0); cairo_paint(cr); rendertext(cr); status = cairo_surface_write_to_png(surface, "out.png"); cairo_surface_destroy(surface); cairo_destroy(cr); return 0; }
void inititializeFontConfigSetting() { FcInit(); // If a test resulted a font being added or removed via the @font-face rule, then // we want to reset the FontConfig configuration to prevent it from affecting other tests. static int numFonts = 0; FcFontSet* appFontSet = FcConfigGetFonts(0, FcSetApplication); if (appFontSet && numFonts && appFontSet->nfont == numFonts) return; // Load our configuration file, which sets up proper aliases for family // names like sans, serif and monospace. FcConfig* config = FcConfigCreate(); GOwnPtr<gchar> fontConfigFilename(g_build_filename(FONTS_CONF_DIR, "fonts.conf", NULL)); if (!g_file_test(fontConfigFilename.get(), G_FILE_TEST_IS_REGULAR)) g_error("Cannot find fonts.conf at %s\n", fontConfigFilename.get()); if (!FcConfigParseAndLoad(config, reinterpret_cast<FcChar8*>(fontConfigFilename.get()), true)) g_error("Couldn't load font configuration file from: %s", fontConfigFilename.get()); static const char *const fontDirectories[] = { "/usr/share/fonts/truetype/liberation", "/usr/share/fonts/truetype/ttf-liberation", "/usr/share/fonts/liberation", "/usr/share/fonts/truetype/ttf-dejavu", "/usr/share/fonts/dejavu", "/usr/share/fonts/opentype/stix", "/usr/share/fonts/stix" }; static const char *const fontPaths[] = { "LiberationMono-BoldItalic.ttf", "LiberationMono-Bold.ttf", "LiberationMono-Italic.ttf", "LiberationMono-Regular.ttf", "LiberationSans-BoldItalic.ttf", "LiberationSans-Bold.ttf", "LiberationSans-Italic.ttf", "LiberationSans-Regular.ttf", "LiberationSerif-BoldItalic.ttf", "LiberationSerif-Bold.ttf", "LiberationSerif-Italic.ttf", "LiberationSerif-Regular.ttf", "DejaVuSans.ttf", "DejaVuSerif.ttf", // MathML tests require the STIX fonts. "STIXGeneral.otf", "STIXGeneralBolIta.otf", "STIXGeneralBol.otf", "STIXGeneralItalic.otf" }; // TODO: Some tests use Lucida. We should load these as well, once it becomes // clear how to install these fonts easily on Fedora. for (size_t font = 0; font < G_N_ELEMENTS(fontPaths); font++) { bool found = false; for (size_t path = 0; path < G_N_ELEMENTS(fontDirectories); path++) { GOwnPtr<gchar> fullPath(g_build_filename(fontDirectories[path], fontPaths[font], NULL)); if (g_file_test(fullPath.get(), G_FILE_TEST_EXISTS)) { found = true; if (!FcConfigAppFontAddFile(config, reinterpret_cast<const FcChar8*>(fullPath.get()))) g_error("Could not load font at %s!", fullPath.get()); else break; } } if (!found) { GOwnPtr<gchar> directoriesDescription; for (size_t path = 0; path < G_N_ELEMENTS(fontDirectories); path++) directoriesDescription.set(g_strjoin(":", directoriesDescription.release(), fontDirectories[path], NULL)); g_error("Could not find font %s in %s. Either install this font or file a bug " "at http://bugs.webkit.org if it is installed in another location.", fontPaths[font], directoriesDescription.get()); } } // Ahem is used by many layout tests. GOwnPtr<gchar> ahemFontFilename(g_build_filename(FONTS_CONF_DIR, "AHEM____.TTF", NULL)); if (!FcConfigAppFontAddFile(config, reinterpret_cast<FcChar8*>(ahemFontFilename.get()))) g_error("Could not load font at %s!", ahemFontFilename.get()); static const char* fontFilenames[] = { "WebKitWeightWatcher100.ttf", "WebKitWeightWatcher200.ttf", "WebKitWeightWatcher300.ttf", "WebKitWeightWatcher400.ttf", "WebKitWeightWatcher500.ttf", "WebKitWeightWatcher600.ttf", "WebKitWeightWatcher700.ttf", "WebKitWeightWatcher800.ttf", "WebKitWeightWatcher900.ttf", 0 }; for (size_t i = 0; fontFilenames[i]; ++i) { GOwnPtr<gchar> fontFilename(g_build_filename(FONTS_CONF_DIR, "..", "..", "fonts", fontFilenames[i], NULL)); if (!FcConfigAppFontAddFile(config, reinterpret_cast<FcChar8*>(fontFilename.get()))) g_error("Could not load font at %s!", fontFilename.get()); } // A font with no valid Fontconfig encoding to test https://bugs.webkit.org/show_bug.cgi?id=47452 GOwnPtr<gchar> fontWithNoValidEncodingFilename(g_build_filename(FONTS_CONF_DIR, "FontWithNoValidEncoding.fon", NULL)); if (!FcConfigAppFontAddFile(config, reinterpret_cast<FcChar8*>(fontWithNoValidEncodingFilename.get()))) g_error("Could not load font at %s!", fontWithNoValidEncodingFilename.get()); if (!FcConfigSetCurrent(config)) g_error("Could not set the current font configuration!"); numFonts = FcConfigGetFonts(config, FcSetApplication)->nfont; }