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;
}