SkTypeface* SkFontHost::CreateTypeface(const SkTypeface* familyFace,
const char familyName[],
SkTypeface::Style style) {
load_system_fonts();
SkAutoMutexAcquire ac(gFamilyMutex);
// clip to legal style bits
style = (SkTypeface::Style)(style & SkTypeface::kBoldItalic);
SkTypeface* tf = NULL;
if (NULL != familyFace) {
tf = find_typeface(familyFace, style);
} else if (NULL != familyName) {
// SkDebugf("======= familyName <%s>\n", familyName);
tf = find_typeface(familyName, style);
}
if (NULL == tf) {
tf = find_best_face(gDefaultFamily, style);
}
// we ref(), since the symantic is to return a new instance
tf->ref();
return tf;
}
SkTypeface* SkCreateTypefaceForScript(FallbackScripts script) {
if (!SkTypeface_ValidScript(script)) {
return NULL;
}
// ensure that our table is populated
initFBScriptInfo();
FBScriptInfo& scriptInfo = gFBScriptInfo[script];
// ensure the element with that index actually maps to the correct script
SkASSERT(scriptInfo.fScript == script);
// if a suitable script could not be found then return NULL
if (scriptInfo.fFontID == 0) {
return NULL;
}
SkAutoMutexAcquire ac(gFamilyHeadAndNameListMutex);
// retrieve the typeface the corresponds to this fontID
SkTypeface* tf = find_from_uniqueID(scriptInfo.fFontID);
// we ref(), since the semantic is to return a new instance
tf->ref();
return tf;
}
SkTypeface* SkTypefaceFromPdfStandardFont(const char* fontName, bool bold, bool italic) {
SkTDict<SkPdfStandardFontEntry>& standardFontMap = getStandardFonts();
SkTypeface* typeface = NULL;
SkPdfStandardFontEntry fontData;
if (standardFontMap.find(fontName, &fontData)) {
// TODO(edisonn): How does the bold/italic specified in standard definition combines with
// the one in /font key? use OR for now.
bold = bold || fontData.fIsBold;
italic = italic || fontData.fIsItalic;
typeface = SkTypeface::CreateFromName(
fontData.fName,
SkTypeface::Style((bold ? SkTypeface::kBold : 0) |
(italic ? SkTypeface::kItalic : 0)));
} else {
typeface = SkTypeface::CreateFromName(
fontName,
SkTypeface::kNormal);
}
if (typeface) {
typeface->ref();
}
return typeface;
}
/**
* This guy is public. It first searches the cache, and if a match is not found,
* it creates a new face.
*/
SkTypeface* SkCreateTypefaceFromLOGFONT(const LOGFONT& origLF) {
LOGFONT lf = origLF;
make_canonical(&lf);
SkTypeface* face = SkTypefaceCache::FindByProc(FindByLogFont, &lf);
if (face) {
face->ref();
} else {
face = LogFontTypeface::Create(lf);
SkTypefaceCache::Add(face, get_style(lf));
}
return face;
}
SkTypeface* SkCreateTypefaceFromCairoFont(cairo_font_face_t* fontFace, const SkFontStyle& style, bool isFixedWidth)
{
SkTypeface* typeface = reinterpret_cast<SkTypeface*>(cairo_font_face_get_user_data(fontFace, &kSkTypefaceKey));
if (typeface) {
typeface->ref();
} else {
typeface = SkCairoFTTypeface::CreateTypeface(fontFace, style, isFixedWidth);
SkTypefaceCache::Add(typeface, style);
}
return typeface;
}
SkTypeface* SkCreateFallbackTypefaceForChar(SkUnichar uni,
SkTypeface::Style style) {
{
SkAutoMutexAcquire ac(gFamilyHeadAndNameListMutex);
load_system_fonts();
}
SkTypeface* tf = findFallbackTypefaceForChar(uni);
if (!tf) {
return NULL;
}
SkAutoMutexAcquire ac(gFamilyHeadAndNameListMutex);
tf = find_typeface(tf, style);
// we ref(), since the semantic is to return a new instance
tf->ref();
return tf;
}
SkTypeface* SkCreateTypefaceFromCairoFTFontWithFontconfig(cairo_scaled_font_t* scaledFont, FcPattern* pattern)
{
cairo_font_face_t* fontFace = cairo_scaled_font_get_font_face(scaledFont);
SkASSERT(cairo_font_face_status(fontFace) == CAIRO_STATUS_SUCCESS);
SkTypeface* typeface = reinterpret_cast<SkTypeface*>(cairo_font_face_get_user_data(fontFace, &kSkTypefaceKey));
if (typeface) {
typeface->ref();
} else {
CairoLockedFTFace faceLock(scaledFont);
if (FT_Face face = faceLock.getFace()) {
typeface = SkCairoFTTypeface::CreateTypeface(fontFace, face, pattern);
SkTypefaceCache::Add(typeface, typeface->fontStyle());
}
}
return typeface;
}
SkPdfFont* SkPdfFont::fontFromFontDescriptor(SkPdfNativeDoc* doc, SkPdfFontDescriptorDictionary* fd,
bool loadFromName) {
// TODO(edisonn): partial implementation.
// Only one, at most be available
SkPdfStream* pdfStream = NULL;
if (fd->has_FontFile()) {
pdfStream = fd->FontFile(doc);
} else if (fd->has_FontFile2()) {
pdfStream = fd->FontFile2(doc);
} if (fd->has_FontFile3()) {
pdfStream = fd->FontFile3(doc);
} else {
if (loadFromName) {
return fontFromName(doc, fd, fd->FontName(doc).c_str());
}
}
const unsigned char* uncompressedStream = NULL;
size_t uncompressedStreamLength = 0;
// TODO(edisonn): report warning to be used in testing.
if (!pdfStream ||
!pdfStream->GetFilteredStreamRef(&uncompressedStream, &uncompressedStreamLength) ||
!uncompressedStream ||
!uncompressedStreamLength) {
return NULL;
}
SkMemoryStream* skStream = new SkMemoryStream(uncompressedStream, uncompressedStreamLength);
SkTypeface* face = SkTypeface::CreateFromStream(skStream);
if (face == NULL) {
// TODO(edisonn): report warning to be used in testing.
return NULL;
}
face->ref();
return new SkPdfStandardFont(face);
}
static SkTypeface *
createTypefaceLocked( const SkTypeface * familyFace, const char familyName[], const void * data, size_t bytelength, SkTypeface::Style style )
{
loadSystemFontsLocked();
style = ( SkTypeface::Style )( style & SkTypeface::kBoldItalic );
SkTypeface * tf = NULL;
if( NULL != familyFace )
{
tf = findTypefaceLocked( familyFace, style );
}
else if( NULL != familyName )
{
if( compareSystemFamilyName( familyName ) == true )
{
tf = findBestFaceLocked( gDefaultFamily, style );
}
#ifndef DEPRECATED_CODE
else if( compareSansSerifFamilyName( familyName ) == true )
{
HyLogif( "DEPRECATED_CODE" );
tf = findSansSerifFaceLocked( familyName, style );
}
#endif
else
{
tf = findTypefaceLocked( familyName, style );
}
}
if( NULL == tf )
{
tf = findBestFaceLocked( gDefaultFamily, style );
}
tf->ref();
return tf;
}
SkTypeface* SkFontHost::CreateTypeface(const SkTypeface* familyFace,
const char familyName[],
const void* data, size_t bytelength,
SkTypeface::Style style) {
static SkTypeface* gDefaultTypeface;
SkAutoMutexAcquire ac(gFTMutex);
#ifndef CAN_USE_LOGFONT_NAME
familyName = NULL;
familyFace = NULL;
#endif
// clip to legal style bits
style = (SkTypeface::Style)(style & SkTypeface::kBoldItalic);
SkTypeface* tf = NULL;
if (NULL == familyFace && NULL == familyName) {
LOGFONT lf = get_default_font();
lf.lfWeight = (style & SkTypeface::kBold) != 0 ? FW_BOLD : FW_NORMAL ;
lf.lfItalic = ((style & SkTypeface::kItalic) != 0);
// hack until we figure out if SkTypeface should cache this itself
if (style == SkTypeface::kNormal) {
if (NULL == gDefaultTypeface) {
gDefaultTypeface = SkCreateTypefaceFromLOGFONT(lf);
}
tf = gDefaultTypeface;
tf->ref();
} else {
tf = SkCreateTypefaceFromLOGFONT(lf);
}
} else {
#ifdef CAN_USE_LOGFONT_NAME
LOGFONT lf;
if (NULL != familyFace) {
uint32_t id = familyFace->uniqueID();
LogFontTypeface* rec = LogFontTypeface::FindById(id);
if (!rec) {
SkASSERT(false);
lf = get_default_font();
}
else {
lf = rec->logFont();
}
}
else {
memset(&lf, 0, sizeof(LOGFONT));
lf.lfHeight = -11; // default
lf.lfQuality = PROOF_QUALITY;
lf.lfCharSet = DEFAULT_CHARSET;
#ifdef UNICODE
// Get the buffer size needed first.
size_t str_len = ::MultiByteToWideChar(CP_UTF8, 0, familyName,
-1, NULL, 0);
// Allocate a buffer (str_len already has terminating null
// accounted for).
wchar_t *wideFamilyName = new wchar_t[str_len];
// Now actually convert the string.
::MultiByteToWideChar(CP_UTF8, 0, familyName, -1,
wideFamilyName, str_len);
::wcsncpy(lf.lfFaceName, wideFamilyName, LF_FACESIZE);
delete [] wideFamilyName;
#else
::strncpy(lf.lfFaceName, familyName, LF_FACESIZE);
#endif
lf.lfFaceName[LF_FACESIZE-1] = '\0';
}
// use the style desired
lf.lfWeight = (style & SkTypeface::kBold) != 0 ? FW_BOLD : FW_NORMAL ;
lf.lfItalic = ((style & SkTypeface::kItalic) != 0);
tf = SkCreateTypefaceFromLOGFONT(lf);
#endif
}
if (NULL == tf) {
tf = SkCreateTypefaceFromLOGFONT(get_default_font());
}
return tf;
}