C++ FontCache类代码示例

/**
 * @param typefaceName[in]  Name of the typeface.
 * @param pointSize[in]     Size of the font in points.
 *
 * Checks the global font cache for the named font and returns a reference to
 * it.  If the font is not in the cache, it gets loaded first.
 */
NoDice::Font& NoDice::
getFont(const std::string& typefaceName, unsigned int pointSize)
{
  typedef std::map<std::string, Font> FontCache;
  static FontCache s_fontCache;

  std::ostringstream ostr;
  ostr << typefaceName << '_' << pointSize;
  std::string fontKey = ostr.str();
  FontCache::iterator it = s_fontCache.find(fontKey);
  if (it != s_fontCache.end())
  {
    return  it->second;
  }

  // allow in-build-directory to take precedence
  std::string filename = "./assets/" + typefaceName + ".ttf";
  if (0 != access(filename.c_str(), R_OK))
  {
    filename = DATA_DIR + std::string("/") + typefaceName + ".ttf";
    if (0 != access(filename.c_str(), R_OK))
    {
      filename = typefaceName;
    }
  }
  std::pair<FontCache::iterator,bool> p = s_fontCache.insert(
                std::make_pair(fontKey, Font(filename, pointSize)));
  return p.first->second;
}

/**
 * Free everything allocated w.r.t. fonts.
 */
void UninitFreeType()
{
	for (FontSize fs = FS_BEGIN; fs < FS_END; fs++) {
		FontCache *fc = FontCache::Get(fs);
		if (fc->HasParent()) delete fc;
	}

#ifdef WITH_FREETYPE
	FT_Done_FreeType(_library);
	_library = NULL;
#endif /* WITH_FREETYPE */
}

void
InitializeSystemFontCache(FontCache& fc, const string& fong_file,
	const string& font_dir)
{
	puts("Loading font files...");
	try
	{
		size_t nFileLoaded(fc.LoadTypefaces(fong_file) != 0);

		if(!font_dir.empty())
			//读取字体文件目录并载入目录下指定后缀名的字体文件。
			try
			{
				HDirectory dir{font_dir.c_str()};
				IO::PathNorm nm;

				std::for_each(FileIterator(&dir), FileIterator(),
					[&](const std::string& name){
					if(!nm.is_self(name) && !dir.IsDirectory()
						/*&& IsExtensionOf(ext, dir.GetName())*/)
					{
						FontPath path(font_dir + dir.GetName());

						if(path != fong_file)
							nFileLoaded += fc.LoadTypefaces(path) != 0;
					}
				});
			}
			catch(FileOperationFailure&)
			{}
		fc.InitializeDefaultTypeface();
		if(const auto nFaces = fc.GetFaces().size())
			std::printf("%u face(s) in %u font file(s)"
				" are loaded\nsuccessfully.\n", nFaces, nFileLoaded);
		else
			throw LoggedEvent("No fonts found.");
		puts("Setting default font face...");
		if(const auto* const pf = fc.GetDefaultTypefacePtr())
			std::printf("\"%s\":\"%s\",\nsuccessfully.\n",
				pf->GetFamilyName().c_str(), pf->GetStyleName().c_str());
		else
			throw LoggedEvent("Setting default font face failed.");
		return;
	}
	// TODO: Use %std::nested_exception.
	catch(std::exception& e)
	{
		puts(e.what());
	}
	throw FatalError("      Font Caching Failure      ",
		" Please make sure the fonts are\n"
		" stored in correct path.\n");
}

/**
 * (Re)initialize the freetype related things, i.e. load the non-sprite fonts.
 * @param monospace Whether to initialise the monospace or regular fonts.
 */
void InitFreeType(bool monospace)
{
	for (FontSize fs = FS_BEGIN; fs < FS_END; fs++) {
		if (monospace != (fs == FS_MONO)) continue;

		FontCache *fc = FontCache::Get(fs);
		if (fc->HasParent()) delete fc;

#ifdef WITH_FREETYPE
		LoadFreeTypeFont(fs);
#endif
	}
}

PassRefPtr<SimpleFontData> FontFallbackIterator::uniqueSystemFontForHint(
    UChar32 hint) {
  // When we're asked for a fallback for the same characters again, we give up
  // because the shaper must have previously tried shaping with the font
  // already.
  if (!hint || m_previouslyAskedForHint.contains(hint))
    return nullptr;

  FontCache* fontCache = FontCache::fontCache();
  m_previouslyAskedForHint.add(hint);
  return fontCache->fallbackFontForCharacter(
      m_fontDescription, hint,
      m_fontFallbackList->primarySimpleFontData(m_fontDescription));
}

const PassRefPtr<SimpleFontData> FontFallbackIterator::uniqueSystemFontForHint(UChar32 hint)
{
    FontCache* fontCache = FontCache::fontCache();

    // When we're asked for a fallback for the same characters again, we give up
    // because the shaper must have previously tried shaping with the font
    // already.
    if (m_visitedSystemFonts.find(hint) != m_visitedSystemFonts.end()) {
        return nullptr;
    }

    RefPtr<SimpleFontData> fallbackFont = fontCache->fallbackFontForCharacter(m_fontDescription, hint, m_fontFallbackList->primarySimpleFontData(m_fontDescription));

    return m_visitedSystemFonts.add(hint, fallbackFont).storedValue->value;
}

TEST(FontCacheAndroid, fallbackFontForCharacter)
{
    // A Latin character in the common locale system font, but not in the
    // Chinese locale-preferred font.
    const UChar32 testChar = 228;

    FontDescription fontDescription;
    fontDescription.setScript(USCRIPT_SIMPLIFIED_HAN);
    fontDescription.setGenericFamily(FontDescription::StandardFamily);

    FontCache* fontCache = FontCache::fontCache();
    ASSERT_TRUE(fontCache);
    RefPtr<SimpleFontData> fontData = fontCache->fallbackFontForCharacter(fontDescription, testChar, 0);
    EXPECT_TRUE(fontData);
}

TEST(FontCache, getLastResortFallbackFont)
{
    FontCache* fontCache = FontCache::fontCache();
    ASSERT_TRUE(fontCache);

    EmptyPlatform platform;

    FontDescription fontDescription;
    fontDescription.setGenericFamily(FontDescription::StandardFamily);
    RefPtr<SimpleFontData> fontData = fontCache->getLastResortFallbackFont(fontDescription, Retain);
    EXPECT_TRUE(fontData);

    fontDescription.setGenericFamily(FontDescription::SansSerifFamily);
    fontData = fontCache->getLastResortFallbackFont(fontDescription, Retain);
    EXPECT_TRUE(fontData);
}

TEST(FontCache, getLastResortFallbackFont)
{
    FontCache* fontCache = FontCache::fontCache();
    ASSERT_TRUE(fontCache);

    Platform* oldPlatform = Platform::current();
    OwnPtr<EmptyPlatform> platform = adoptPtr(new EmptyPlatform);
    Platform::initialize(platform.get());

    FontDescription fontDescription;
    fontDescription.setGenericFamily(FontDescription::StandardFamily);
    RefPtr<SimpleFontData> fontData = fontCache->getLastResortFallbackFont(fontDescription, Retain);
    EXPECT_TRUE(fontData);

    fontDescription.setGenericFamily(FontDescription::SansSerifFamily);
    fontData = fontCache->getLastResortFallbackFont(fontDescription, Retain);
    EXPECT_TRUE(fontData);

    Platform::initialize(oldPlatform);
}

namespace mui {

class FontCache {
    struct Entry{
        WCHAR *     name;
        float       size;
        FontStyle   style;
        Font *      font;

        bool operator==(Entry& other){
            return size == other.size && style == other.style && str::Eq(name, other.name);
        }
    };

    ScopedGdiPlus scope;
    Vec<Entry> cache;

public:
    FontCache() { }
    ~FontCache() {
        for (Entry *e = cache.IterStart(); e; e = cache.IterNext()) {
            free(e->name);
            ::delete e->font;
        }
    }

    Font *GetFont(const WCHAR *name, float size, FontStyle style) {
        Entry f = { (WCHAR *)name, size, style, NULL };
        for (Entry *e = cache.IterStart(); e; e = cache.IterNext()) {
            if (f == *e)
                return e->font;
        }

        f.font = ::new Font(name, size, style);
        if (!f.font) {
            // fall back to the default font, if a desired font can't be created
            f.font = ::new Font(L"Times New Roman", size, style);
            if (!f.font) {
                if (cache.Count() > 0)
                    return cache.At(0).font;
                return NULL;
            }
        }
        f.name = str::Dup(f.name);
        cache.Append(f);
        return f.font;
    }
};

static FontCache gFontCache;

Font *GetCachedFont(const WCHAR *name, float size, FontStyle style)
{
    return gFontCache.GetFont(name, size, style);
}

static void InitGraphicsMode(Graphics *g)
{
    g->SetCompositingQuality(CompositingQualityHighQuality);
    g->SetSmoothingMode(SmoothingModeAntiAlias);
    //g.SetSmoothingMode(SmoothingModeHighQuality);
    g->SetTextRenderingHint(TextRenderingHintClearTypeGridFit);
    g->SetPageUnit(UnitPixel);
}

class GlobalGraphicsHack {
    ScopedGdiPlus scope;
    Bitmap bmp;
public:
    Graphics gfx;

    GlobalGraphicsHack() : bmp(1, 1, PixelFormat32bppARGB), gfx(&bmp) {
        // cf. EbookEngine::RenderPage
        gfx.SetCompositingQuality(CompositingQualityHighQuality);
        gfx.SetSmoothingMode(SmoothingModeAntiAlias);
        gfx.SetTextRenderingHint(TextRenderingHintClearTypeGridFit);
        gfx.SetPageUnit(UnitPixel);
    }
};

static GlobalGraphicsHack gGH;

Graphics *AllocGraphicsForMeasureText()
{
    return &gGH.gfx;
}

void FreeGraphicsForMeasureText(Graphics *g) { }

}

Font *GetCachedFont(const WCHAR *name, float size, FontStyle style)
{
    return gFontCache.GetFont(name, size, style);
}

const FontDataForRangeSet FontFallbackIterator::next(const Vector<UChar32>& hintList)
{
    if (m_fallbackStage == OutOfLuck)
        return FontDataForRangeSet();

    if (m_fallbackStage == FallbackPriorityFonts) {
        // Only try one fallback priority font,
        // then proceed to regular system fallback.
        m_fallbackStage = SystemFonts;
        FontDataForRangeSet fallbackPriorityFontRange(fallbackPriorityFont(hintList[0]));
        if (fallbackPriorityFontRange.hasFontData())
            return fallbackPriorityFontRange;
        return next(hintList);
    }

    if (m_fallbackStage == SystemFonts) {
        // We've reached pref + system fallback.
        ASSERT(hintList.size());
        RefPtr<SimpleFontData> systemFont = uniqueSystemFontForHint(hintList[0]);
        if (systemFont)
            return FontDataForRangeSet(systemFont);

        // If we don't have options from the system fallback anymore or had
        // previously returned them, we only have the last resort font left.
        // TODO: crbug.com/42217 Improve this by doing the last run with a last
        // resort font that has glyphs for everything, for example the Unicode
        // LastResort font, not just Times or Arial.
        FontCache* fontCache = FontCache::fontCache();
        m_fallbackStage = OutOfLuck;
        RefPtr<SimpleFontData> lastResort = fontCache->getLastResortFallbackFont(m_fontDescription).get();
        RELEASE_ASSERT(lastResort);
        return FontDataForRangeSet(lastResort);
    }

    ASSERT(m_fallbackStage == FontGroupFonts
        || m_fallbackStage == SegmentedFace);
    const FontData* fontData = m_fontFallbackList->fontDataAt(
        m_fontDescription, m_currentFontDataIndex);

    if (!fontData) {
        // If there is no fontData coming from the fallback list, it means
        // we are now looking at system fonts, either for prioritized symbol
        // or emoji fonts or by calling system fallback API.
        m_fallbackStage = isNonTextFallbackPriority(m_fontFallbackPriority)
            ? FallbackPriorityFonts
            : SystemFonts;
        return next(hintList);
    }

    // Otherwise we've received a fontData from the font-family: set of fonts,
    // and a non-segmented one in this case.
    if (!fontData->isSegmented()) {
        // Skip forward to the next font family for the next call to next().
        m_currentFontDataIndex++;
        if (!fontData->isLoading()) {
            RefPtr<SimpleFontData> nonSegmented = const_cast<SimpleFontData*>(toSimpleFontData(fontData));
            return FontDataForRangeSet(nonSegmented);
        }
        return next(hintList);
    }

    // Iterate over ranges of a segmented font below.

    const SegmentedFontData* segmented = toSegmentedFontData(fontData);
    if (m_fallbackStage != SegmentedFace) {
        m_segmentedFaceIndex = 0;
        m_fallbackStage = SegmentedFace;
    }

    ASSERT(m_segmentedFaceIndex < segmented->numFaces());
    FontDataForRangeSet currentSegmentedFace = segmented->faceAt(m_segmentedFaceIndex);
    m_segmentedFaceIndex++;

    if (m_segmentedFaceIndex == segmented->numFaces()) {
        // Switch from iterating over a segmented face to the next family from
        // the font-family: group of fonts.
        m_fallbackStage = FontGroupFonts;
        m_currentFontDataIndex++;
    }

    if (rangeSetContributesForHint(hintList, currentSegmentedFace)) {
        if (currentSegmentedFace.fontData()->customFontData())
            currentSegmentedFace.fontData()->customFontData()->beginLoadIfNeeded();
        if (!currentSegmentedFace.fontData()->isLoading())
            return currentSegmentedFace;
        m_trackedLoadingRangeSets.append(currentSegmentedFace);
    }

    return next(hintList);
}

void CEngineSurface :: drawPrintText( const char* text, int textLen )
{
	static bool hasColor = 0;
	static int numColor = 7;

	if( !text || !_hCurrentFont || _drawTextColor[3] >= 255 )
		return;

	int x = _drawTextPos[0] + _translateX;
	int y = _drawTextPos[1] + _translateY;

	int iTall = _hCurrentFont->getTall();

	int j, iTotalWidth = 0;
	int curTextColor[4];

	//  HACKHACK: allow color strings in VGUI
	if( numColor != 7 && vgui_colorstrings->integer )
	{
		for( j = 0; j < 3; j++ ) // grab predefined color
			curTextColor[j] = g_color_table[numColor][j];
          }
          else
          {
		for( j = 0; j < 3; j++ ) // revert default color
			curTextColor[j] = _drawTextColor[j];
	}
	curTextColor[3] = _drawTextColor[3]; // copy alpha

	if( textLen == 1 && vgui_colorstrings->integer )
	{
		if( *text == '^' )
		{
			hasColor = true;
			return; // skip '^'
		}
		else if( hasColor && isdigit( *text ))
		{
			numColor = ColorIndex( *text );
			hasColor = false; // handled
			return; // skip colornum
		}
		else hasColor = false;
	}

	for( int i = 0; i < textLen; i++ )
	{
		char ch = text[i];

		int abcA,abcB,abcC;
		_hCurrentFont->getCharABCwide( ch, abcA, abcB, abcC );

		iTotalWidth += abcA;
		int iWide = abcB;

		if( !iswspace( ch ))
		{
			// get the character texture from the cache
			int iTexId = 0;
			float *texCoords = NULL;

			if( !g_FontCache.GetTextureForChar( _hCurrentFont, ch, &iTexId, &texCoords ))
				continue;

			Assert( texCoords != NULL );

			vpoint_t ul, lr;

			ul.point[0] = x + iTotalWidth;
			ul.point[1] = y;
			lr.point[0] = ul.point[0] + iWide;
			lr.point[1] = ul.point[1] + iTall;

			// gets at the texture coords for this character in its texture page
			ul.coord[0] = texCoords[0];
			ul.coord[1] = texCoords[1];
			lr.coord[0] = texCoords[2];
			lr.coord[1] = texCoords[3];

			vpoint_t clippedRect[2];

			if( !ClipRect( ul, lr, &clippedRect[0], &clippedRect[1] ))
				continue;
                                        
			drawSetTexture( iTexId );
			VGUI_SetupDrawingText( curTextColor );
			VGUI_DrawQuad(  &clippedRect[0], &clippedRect[1] ); // draw the letter
		}

		iTotalWidth += iWide + abcC;
	}

	_drawTextPos[0] += iTotalWidth;
}

namespace mui {

class FontCache {
    struct Entry {
        WCHAR *     name;
        float       size;
        FontStyle   style;
        Font *      font;

        Entry(WCHAR *name=NULL, float size=0.0f, FontStyle style=FontStyleRegular, Font *font=NULL) :
            name(name), size(size), style(style), font(font) { }
        bool operator==(const Entry& other) const {
            return size == other.size && style == other.style && str::Eq(name, other.name);
        }
    };

    ScopedGdiPlus scope;
    Vec<Entry> cache;

public:
    FontCache() { }
    ~FontCache() {
        for (Entry *e = cache.IterStart(); e; e = cache.IterNext()) {
            free(e->name);
            ::delete e->font;
        }
    }

    Font *GetFont(const WCHAR *name, float size, FontStyle style) {
        int idx = cache.Find(Entry((WCHAR *)name, size, style));
        if (idx != -1)
            return cache.At(idx).font;

        Font *font = ::new Font(name, size, style);
        if (!font) {
            // fall back to the default font, if a desired font can't be created
            font = ::new Font(L"Times New Roman", size, style);
            if (!font) {
                return cache.Count() > 0 ? cache.At(0).font : NULL;
            }
        }
        cache.Append(Entry(str::Dup(name), size, style, font));
        return font;
    }
};

static FontCache gFontCache;

Font *GetCachedFont(const WCHAR *name, float size, FontStyle style)
{
    return gFontCache.GetFont(name, size, style);
}

class GlobalGraphicsHack {
    ScopedGdiPlus scope;
    Bitmap bmp;
public:
    Graphics gfx;

    GlobalGraphicsHack() : bmp(1, 1, PixelFormat32bppARGB), gfx(&bmp) {
        // cf. EbookEngine::RenderPage
        gfx.SetCompositingQuality(CompositingQualityHighQuality);
        gfx.SetSmoothingMode(SmoothingModeAntiAlias);
        gfx.SetTextRenderingHint(TextRenderingHintClearTypeGridFit);
        gfx.SetPageUnit(UnitPixel);
    }
};

static GlobalGraphicsHack gGH;

Graphics *AllocGraphicsForMeasureText()
{
    return &gGH.gfx;
}

void FreeGraphicsForMeasureText(Graphics *g) { }

}

/**
 * @param FontName Name of the font to load
 */
void Font::Load(string FontName)
{
	VFile* fontfile;
	Uint16 wpos;
	Uint16 hpos;
	Uint16 cdata;
	Uint16 nchars;
	Uint8 fnheight;
	Uint8 fnmaxw;
	Uint32 fntotalw;
	Uint32 ypos;
	Uint32 pos;
	Uint32 curchar;
	Uint8		data;
	SDL_Surface* OrgFonImg = 0;



	this->fontname = FontName;

#ifdef USE_FONTCACHE
	if (fontCache.Get (this->fontname, &this->fontimg, this->chrdest)){
		return;
	}
#endif //USE_FONTCACHE

	//logger->debug("%s line %i: Load the font: %s\n\n", __FILE__, __LINE__, FontName.c_str());
	fontfile = VFSUtils::VFS_Open(fontname.c_str());
	if (0 == fontfile) {
		string s("Unable to load font ");
		s += fontname;
		throw(runtime_error(s));
	}

	fontfile->seekSet(8);
	fontfile->readWord(&wpos, 1);
	fontfile->readWord(&cdata, 1);
	fontfile->readWord(&hpos, 1);
	fontfile->seekCur(2);
	fontfile->readWord(&nchars, 1);
	nchars = SDL_Swap16(nchars); // Yes, even on LE systems.
	fontfile->readByte(&fnheight, 1);
	fontfile->readByte(&fnmaxw, 1);

	nchars++;

	vector<Uint8> wchar(nchars);
	vector<Uint8> hchar(nchars<<1);

	vector<Uint16> dataoffsets(nchars);
	fontfile->readWord(&dataoffsets[0], nchars);

	fontfile->seekSet(wpos);
	fontfile->readByte(&wchar[0], nchars);
	fontfile->seekSet(hpos);
	fontfile->readByte(&hchar[0], nchars<<1);

	chrdest.resize(nchars);

	fntotalw = 0;
	for(unsigned int i = 0 ; i < nchars; i++)
    {
		chrdest[i].x = fntotalw;
		chrdest[i].y = 0;
		chrdest[i].h = fnheight;
		chrdest[i].w = wchar[i];
		fntotalw += wchar[i];
	}
	vector<Uint8> chardata(fnheight*fntotalw);

	for( curchar = 0; curchar < nchars; curchar++ )
    {
		fontfile->seekSet(dataoffsets[curchar]);
		for( ypos = hchar[curchar<<1]; ypos < (Uint32)(hchar[curchar<<1]+hchar[(curchar<<1)+1]); ypos++ )
        {
			pos = chrdest[curchar].x+ypos*fntotalw;
			for(unsigned int i = 0; i < wchar[curchar]; i+=2 )
            {
				fontfile->readByte( &data, 1 );
#if 1
				/* Each 4 bits contain a index to the pallete */
				chardata[pos+i] = data&0xf;
				if( i+1<wchar[curchar] )
					chardata[pos+i+1] = (data>>4);
#else
				/* Each 4 bits contain a index to the pallete, convert them to 0 or 1 */
				chardata[pos+i] = (data&0xb)!=0?1:0;
				if( i+1<wchar[curchar] )
					chardata[pos+i+1] = (data>>4)!=0?1:0;
			//printf ("Data = %i\n", chardata[pos+i+1]);
#endif
			}
		}
	}

	SDL_FreeSurface(fontimg);
	fontimg = NULL;
//.........这里部分代码省略.........