2008-09-30 20:04:10 -07:00
|
|
|
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
|
|
* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
|
|
*
|
|
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
|
|
* the License. You may obtain a copy of the License at
|
|
|
|
* http://www.mozilla.org/MPL/
|
|
|
|
*
|
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
|
|
|
*
|
|
|
|
* The Original Code is thebes gfx code.
|
|
|
|
*
|
2009-12-21 13:50:30 -08:00
|
|
|
* The Initial Developer of the Original Code is Mozilla Foundation.
|
2009-08-30 06:55:24 -07:00
|
|
|
* Portions created by the Initial Developer are Copyright (C) 2008-2009
|
2008-09-30 20:04:10 -07:00
|
|
|
* the Initial Developer. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
|
|
|
* John Daggett <jdaggett@mozilla.com>
|
2009-08-30 06:55:24 -07:00
|
|
|
* Jonathan Kew <jfkthame@gmail.com>
|
2008-09-30 20:04:10 -07:00
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
|
|
|
|
#ifdef MOZ_LOGGING
|
|
|
|
#define FORCE_PR_LOG /* Allow logging in the release build */
|
|
|
|
#endif /* MOZ_LOGGING */
|
|
|
|
#include "prlog.h"
|
|
|
|
|
|
|
|
#include "gfxUserFontSet.h"
|
|
|
|
#include "gfxPlatform.h"
|
|
|
|
#include "nsReadableUtils.h"
|
|
|
|
#include "nsUnicharUtils.h"
|
|
|
|
#include "prlong.h"
|
|
|
|
|
2009-08-30 06:55:24 -07:00
|
|
|
#include "woff.h"
|
|
|
|
|
2008-09-30 20:04:10 -07:00
|
|
|
#ifdef PR_LOGGING
|
|
|
|
static PRLogModuleInfo *gUserFontsLog = PR_NewLogModule("userfonts");
|
|
|
|
#endif /* PR_LOGGING */
|
|
|
|
|
|
|
|
#define LOG(args) PR_LOG(gUserFontsLog, PR_LOG_DEBUG, args)
|
|
|
|
#define LOG_ENABLED() PR_LOG_TEST(gUserFontsLog, PR_LOG_DEBUG)
|
|
|
|
|
|
|
|
static PRUint64 sFontSetGeneration = LL_INIT(0, 0);
|
|
|
|
|
|
|
|
// TODO: support for unicode ranges not yet implemented
|
|
|
|
|
2010-07-13 13:31:31 -07:00
|
|
|
gfxProxyFontEntry::gfxProxyFontEntry(const nsTArray<gfxFontFaceSrc>& aFontFaceSrcList,
|
2008-12-05 15:19:27 -08:00
|
|
|
gfxMixedFontFamily *aFamily,
|
2010-07-13 13:31:31 -07:00
|
|
|
PRUint32 aWeight,
|
|
|
|
PRUint32 aStretch,
|
|
|
|
PRUint32 aItalicStyle,
|
|
|
|
const nsTArray<gfxFontFeature> *aFeatureSettings,
|
|
|
|
PRUint32 aLanguageOverride,
|
2008-09-30 20:04:10 -07:00
|
|
|
gfxSparseBitSet *aUnicodeRanges)
|
2009-08-16 06:52:12 -07:00
|
|
|
: gfxFontEntry(NS_LITERAL_STRING("Proxy"), aFamily), mIsLoading(PR_FALSE)
|
2008-09-30 20:04:10 -07:00
|
|
|
{
|
|
|
|
mIsProxy = PR_TRUE;
|
|
|
|
mSrcList = aFontFaceSrcList;
|
|
|
|
mSrcIndex = 0;
|
|
|
|
mWeight = aWeight;
|
|
|
|
mStretch = aStretch;
|
|
|
|
mItalic = (aItalicStyle & (FONT_STYLE_ITALIC | FONT_STYLE_OBLIQUE)) != 0;
|
2010-07-13 13:31:31 -07:00
|
|
|
if (aFeatureSettings) {
|
|
|
|
mFeatureSettings = new nsTArray<gfxFontFeature>;
|
|
|
|
mFeatureSettings->AppendElements(*aFeatureSettings);
|
|
|
|
}
|
|
|
|
mLanguageOverride = aLanguageOverride;
|
2009-06-24 02:04:20 -07:00
|
|
|
mIsUserFont = PR_TRUE;
|
2008-09-30 20:04:10 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
gfxProxyFontEntry::~gfxProxyFontEntry()
|
|
|
|
{
|
2009-10-07 08:26:58 -07:00
|
|
|
}
|
2008-09-30 20:04:10 -07:00
|
|
|
|
2009-10-07 08:26:58 -07:00
|
|
|
gfxFont*
|
|
|
|
gfxProxyFontEntry::CreateFontInstance(const gfxFontStyle *aFontStyle, PRBool aNeedsBold)
|
|
|
|
{
|
|
|
|
// cannot create an actual font for a proxy entry
|
|
|
|
return nsnull;
|
2008-09-30 20:04:10 -07:00
|
|
|
}
|
|
|
|
|
2008-12-11 23:31:51 -08:00
|
|
|
gfxUserFontSet::gfxUserFontSet()
|
2008-09-30 20:04:10 -07:00
|
|
|
{
|
|
|
|
mFontFamilies.Init(5);
|
|
|
|
IncrementGeneration();
|
|
|
|
}
|
|
|
|
|
|
|
|
gfxUserFontSet::~gfxUserFontSet()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-07-13 13:31:31 -07:00
|
|
|
gfxUserFontSet::AddFontFace(const nsAString& aFamilyName,
|
|
|
|
const nsTArray<gfxFontFaceSrc>& aFontFaceSrcList,
|
|
|
|
PRUint32 aWeight,
|
|
|
|
PRUint32 aStretch,
|
|
|
|
PRUint32 aItalicStyle,
|
|
|
|
const nsString& aFeatureSettings,
|
|
|
|
const nsString& aLanguageOverride,
|
2008-09-30 20:04:10 -07:00
|
|
|
gfxSparseBitSet *aUnicodeRanges)
|
|
|
|
{
|
|
|
|
nsAutoString key(aFamilyName);
|
|
|
|
ToLowerCase(key);
|
|
|
|
|
|
|
|
PRBool found;
|
|
|
|
|
|
|
|
if (aWeight == 0)
|
|
|
|
aWeight = FONT_WEIGHT_NORMAL;
|
|
|
|
|
|
|
|
// stretch, italic/oblique ==> zero implies normal
|
|
|
|
|
|
|
|
gfxMixedFontFamily *family = mFontFamilies.GetWeak(key, &found);
|
|
|
|
if (!family) {
|
|
|
|
family = new gfxMixedFontFamily(aFamilyName);
|
|
|
|
mFontFamilies.Put(key, family);
|
|
|
|
}
|
|
|
|
|
|
|
|
// construct a new face and add it into the family
|
|
|
|
if (family) {
|
2010-07-13 13:31:31 -07:00
|
|
|
nsTArray<gfxFontFeature> featureSettings;
|
|
|
|
gfxFontStyle::ParseFontFeatureSettings(aFeatureSettings,
|
|
|
|
featureSettings);
|
|
|
|
PRUint32 languageOverride =
|
|
|
|
gfxFontStyle::ParseFontLanguageOverride(aLanguageOverride);
|
2008-09-30 20:04:10 -07:00
|
|
|
gfxProxyFontEntry *proxyEntry =
|
2008-12-05 15:19:27 -08:00
|
|
|
new gfxProxyFontEntry(aFontFaceSrcList, family, aWeight, aStretch,
|
2010-07-13 13:31:31 -07:00
|
|
|
aItalicStyle,
|
|
|
|
featureSettings.Length() > 0 ?
|
|
|
|
&featureSettings : nsnull,
|
|
|
|
languageOverride,
|
|
|
|
aUnicodeRanges);
|
2008-09-30 20:04:10 -07:00
|
|
|
family->AddFontEntry(proxyEntry);
|
|
|
|
#ifdef PR_LOGGING
|
|
|
|
if (LOG_ENABLED()) {
|
|
|
|
LOG(("userfonts (%p) added (%s) with style: %s weight: %d stretch: %d",
|
|
|
|
this, NS_ConvertUTF16toUTF8(aFamilyName).get(),
|
|
|
|
(aItalicStyle & FONT_STYLE_ITALIC ? "italic" :
|
|
|
|
(aItalicStyle & FONT_STYLE_OBLIQUE ? "oblique" : "normal")),
|
|
|
|
aWeight, aStretch));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
gfxFontEntry*
|
|
|
|
gfxUserFontSet::FindFontEntry(const nsAString& aName,
|
|
|
|
const gfxFontStyle& aFontStyle,
|
|
|
|
PRBool& aNeedsBold)
|
|
|
|
{
|
2008-12-05 15:19:27 -08:00
|
|
|
gfxMixedFontFamily *family = GetFamily(aName);
|
2008-09-30 20:04:10 -07:00
|
|
|
|
|
|
|
// no user font defined for this name
|
|
|
|
if (!family)
|
|
|
|
return nsnull;
|
|
|
|
|
|
|
|
gfxFontEntry* fe = family->FindFontForStyle(aFontStyle, aNeedsBold);
|
|
|
|
|
|
|
|
// if not a proxy, font has already been loaded
|
|
|
|
if (!fe->mIsProxy)
|
|
|
|
return fe;
|
|
|
|
|
|
|
|
gfxProxyFontEntry *proxyEntry = static_cast<gfxProxyFontEntry*> (fe);
|
|
|
|
|
|
|
|
// if currently loading, return null for now
|
|
|
|
if (proxyEntry->mIsLoading)
|
|
|
|
return nsnull;
|
|
|
|
|
|
|
|
// hasn't been loaded yet, start the load process
|
|
|
|
LoadStatus status;
|
|
|
|
|
|
|
|
status = LoadNext(proxyEntry);
|
|
|
|
|
|
|
|
// if the load succeeded immediately, the font entry was replaced so
|
|
|
|
// search again
|
|
|
|
if (status == STATUS_LOADED)
|
|
|
|
return family->FindFontForStyle(aFontStyle, aNeedsBold);
|
|
|
|
|
|
|
|
// if either loading or an error occurred, return null
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
2009-08-30 06:55:24 -07:00
|
|
|
// Given a buffer of downloaded font data, do any necessary preparation
|
|
|
|
// to make it into usable OpenType.
|
|
|
|
// May return the original pointer unchanged, or a newly-allocated
|
|
|
|
// block (in which case the passed-in block is NS_Free'd).
|
|
|
|
// aLength is updated if necessary to the new length of the data.
|
|
|
|
// Returns NULL and NS_Free's the incoming data in case of errors.
|
|
|
|
const PRUint8*
|
|
|
|
PrepareOpenTypeData(const PRUint8* aData, PRUint32* aLength)
|
|
|
|
{
|
|
|
|
switch(gfxFontUtils::DetermineFontDataType(aData, *aLength)) {
|
|
|
|
|
|
|
|
case GFX_USERFONT_OPENTYPE:
|
|
|
|
// nothing to do
|
|
|
|
return aData;
|
|
|
|
|
|
|
|
case GFX_USERFONT_WOFF: {
|
|
|
|
PRUint32 status = eWOFF_ok;
|
|
|
|
PRUint32 bufferSize = woffGetDecodedSize(aData, *aLength, &status);
|
|
|
|
if (WOFF_FAILURE(status)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
PRUint8* decodedData = static_cast<PRUint8*>(NS_Alloc(bufferSize));
|
|
|
|
if (!decodedData) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
woffDecodeToBuffer(aData, *aLength,
|
|
|
|
decodedData, bufferSize,
|
|
|
|
aLength, &status);
|
|
|
|
// replace original data with the decoded version
|
|
|
|
NS_Free((void*)aData);
|
|
|
|
aData = decodedData;
|
|
|
|
if (WOFF_FAILURE(status)) {
|
|
|
|
// something went wrong, discard the data and return NULL
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// success, return the decoded data
|
|
|
|
return aData;
|
|
|
|
}
|
|
|
|
|
|
|
|
// xxx - add support for other wrappers here
|
|
|
|
|
|
|
|
default:
|
|
|
|
NS_WARNING("unknown font format");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// discard downloaded data that couldn't be used
|
|
|
|
NS_Free((void*)aData);
|
2008-09-30 20:04:10 -07:00
|
|
|
|
2009-08-30 06:55:24 -07:00
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
// This is called when a font download finishes.
|
|
|
|
// Ownership of aFontData passes in here, and the font set must
|
|
|
|
// ensure that it is eventually deleted via NS_Free().
|
2008-09-30 20:04:10 -07:00
|
|
|
PRBool
|
2008-12-05 15:19:27 -08:00
|
|
|
gfxUserFontSet::OnLoadComplete(gfxFontEntry *aFontToLoad,
|
2008-10-29 11:09:50 -07:00
|
|
|
const PRUint8 *aFontData, PRUint32 aLength,
|
2008-09-30 20:04:10 -07:00
|
|
|
nsresult aDownloadStatus)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aFontToLoad->mIsProxy, "trying to load font data for wrong font entry type");
|
|
|
|
|
2009-08-30 06:55:24 -07:00
|
|
|
if (!aFontToLoad->mIsProxy) {
|
|
|
|
NS_Free((void*)aFontData);
|
2008-09-30 20:04:10 -07:00
|
|
|
return PR_FALSE;
|
2009-08-30 06:55:24 -07:00
|
|
|
}
|
2008-09-30 20:04:10 -07:00
|
|
|
|
|
|
|
gfxProxyFontEntry *pe = static_cast<gfxProxyFontEntry*> (aFontToLoad);
|
|
|
|
|
|
|
|
// download successful, make platform font using font data
|
|
|
|
if (NS_SUCCEEDED(aDownloadStatus)) {
|
2009-08-30 06:55:24 -07:00
|
|
|
gfxFontEntry *fe = nsnull;
|
|
|
|
|
|
|
|
// Unwrap/decompress or otherwise munge the downloaded data
|
|
|
|
// to make a usable sfnt structure.
|
|
|
|
// This may cause aFontData to point to a new buffer, or be NULL.
|
|
|
|
aFontData = PrepareOpenTypeData(aFontData, &aLength);
|
|
|
|
if (aFontData &&
|
|
|
|
gfxFontUtils::ValidateSFNTHeaders(aFontData, aLength)) {
|
|
|
|
// Here ownership of aFontData is passed to the platform,
|
|
|
|
// which will delete it when no longer required
|
|
|
|
fe = gfxPlatform::GetPlatform()->MakePlatformFont(pe,
|
|
|
|
aFontData,
|
|
|
|
aLength);
|
2010-07-16 18:32:18 -07:00
|
|
|
if (fe) {
|
|
|
|
if (pe->mFeatureSettings) {
|
|
|
|
fe->mFeatureSettings = new nsTArray<gfxFontFeature>;
|
|
|
|
fe->mFeatureSettings->AppendElements(*pe->mFeatureSettings);
|
|
|
|
}
|
|
|
|
fe->mLanguageOverride = pe->mLanguageOverride;
|
2010-07-13 13:31:31 -07:00
|
|
|
}
|
2009-08-30 06:55:24 -07:00
|
|
|
aFontData = nsnull; // the platform may have freed the data now!
|
|
|
|
} else {
|
|
|
|
// the data was unusable, so just discard it
|
|
|
|
// (error will be reported below, if logging is enabled)
|
|
|
|
if (aFontData) {
|
|
|
|
NS_Free((void*)aFontData);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-09-30 20:04:10 -07:00
|
|
|
if (fe) {
|
2009-08-16 06:52:12 -07:00
|
|
|
static_cast<gfxMixedFontFamily*>(pe->mFamily)->ReplaceFontEntry(pe, fe);
|
2008-09-30 20:04:10 -07:00
|
|
|
IncrementGeneration();
|
|
|
|
#ifdef PR_LOGGING
|
|
|
|
if (LOG_ENABLED()) {
|
|
|
|
nsCAutoString fontURI;
|
|
|
|
pe->mSrcList[pe->mSrcIndex].mURI->GetSpec(fontURI);
|
2009-08-30 06:55:24 -07:00
|
|
|
LOG(("userfonts (%p) [src %d] loaded uri: (%s) for (%s) gen: %8.8x\n",
|
|
|
|
this, pe->mSrcIndex, fontURI.get(),
|
|
|
|
NS_ConvertUTF16toUTF8(pe->mFamily->Name()).get(),
|
2008-10-29 11:09:50 -07:00
|
|
|
PRUint32(mGeneration)));
|
2008-09-30 20:04:10 -07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return PR_TRUE;
|
|
|
|
} else {
|
|
|
|
#ifdef PR_LOGGING
|
|
|
|
if (LOG_ENABLED()) {
|
|
|
|
nsCAutoString fontURI;
|
|
|
|
pe->mSrcList[pe->mSrcIndex].mURI->GetSpec(fontURI);
|
2009-08-30 06:55:24 -07:00
|
|
|
LOG(("userfonts (%p) [src %d] failed uri: (%s) for (%s) error making platform font\n",
|
|
|
|
this, pe->mSrcIndex, fontURI.get(),
|
2008-09-30 20:04:10 -07:00
|
|
|
NS_ConvertUTF16toUTF8(pe->mFamily->Name()).get()));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// download failed
|
2009-08-30 06:55:24 -07:00
|
|
|
if (aFontData) {
|
|
|
|
NS_Free((void*)aFontData);
|
|
|
|
}
|
2008-09-30 20:04:10 -07:00
|
|
|
#ifdef PR_LOGGING
|
|
|
|
if (LOG_ENABLED()) {
|
|
|
|
nsCAutoString fontURI;
|
|
|
|
pe->mSrcList[pe->mSrcIndex].mURI->GetSpec(fontURI);
|
2009-08-30 06:55:24 -07:00
|
|
|
LOG(("userfonts (%p) [src %d] failed uri: (%s) for (%s) error %8.8x downloading font data\n",
|
|
|
|
this, pe->mSrcIndex, fontURI.get(),
|
|
|
|
NS_ConvertUTF16toUTF8(pe->mFamily->Name()).get(),
|
2008-09-30 20:04:10 -07:00
|
|
|
aDownloadStatus));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
// error occurred, load next src
|
|
|
|
LoadStatus status;
|
|
|
|
|
|
|
|
status = LoadNext(pe);
|
2009-02-22 20:40:47 -08:00
|
|
|
if (status == STATUS_LOADED) {
|
|
|
|
// load may succeed if external font resource followed by
|
|
|
|
// local font, in this case need to bump generation
|
|
|
|
IncrementGeneration();
|
2008-09-30 20:04:10 -07:00
|
|
|
return PR_TRUE;
|
2009-02-22 20:40:47 -08:00
|
|
|
}
|
2008-09-30 20:04:10 -07:00
|
|
|
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
gfxUserFontSet::LoadStatus
|
|
|
|
gfxUserFontSet::LoadNext(gfxProxyFontEntry *aProxyEntry)
|
|
|
|
{
|
|
|
|
PRUint32 numSrc = aProxyEntry->mSrcList.Length();
|
|
|
|
|
|
|
|
NS_ASSERTION(aProxyEntry->mSrcIndex < numSrc, "already at the end of the src list for user font");
|
|
|
|
|
|
|
|
if (aProxyEntry->mIsLoading) {
|
|
|
|
aProxyEntry->mSrcIndex++;
|
|
|
|
} else {
|
|
|
|
aProxyEntry->mIsLoading = PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
// load each src entry in turn, until a local face is found or a download begins successfully
|
|
|
|
while (aProxyEntry->mSrcIndex < numSrc) {
|
|
|
|
const gfxFontFaceSrc& currSrc = aProxyEntry->mSrcList[aProxyEntry->mSrcIndex];
|
|
|
|
|
|
|
|
// src local ==> lookup and load
|
|
|
|
|
|
|
|
if (currSrc.mIsLocal) {
|
2009-01-02 19:21:49 -08:00
|
|
|
gfxFontEntry *fe =
|
|
|
|
gfxPlatform::GetPlatform()->LookupLocalFont(aProxyEntry,
|
|
|
|
currSrc.mLocalName);
|
2008-09-30 20:04:10 -07:00
|
|
|
if (fe) {
|
|
|
|
LOG(("userfonts (%p) [src %d] loaded local: (%s) for (%s) gen: %8.8x\n",
|
|
|
|
this, aProxyEntry->mSrcIndex,
|
|
|
|
NS_ConvertUTF16toUTF8(currSrc.mLocalName).get(),
|
|
|
|
NS_ConvertUTF16toUTF8(aProxyEntry->mFamily->Name()).get(),
|
|
|
|
PRUint32(mGeneration)));
|
2010-07-13 13:31:31 -07:00
|
|
|
if (aProxyEntry->mFeatureSettings) {
|
|
|
|
fe->mFeatureSettings = new nsTArray<gfxFontFeature>;
|
|
|
|
fe->mFeatureSettings->AppendElements(*aProxyEntry->mFeatureSettings);
|
|
|
|
}
|
|
|
|
fe->mLanguageOverride = aProxyEntry->mLanguageOverride;
|
2009-08-16 06:52:12 -07:00
|
|
|
static_cast<gfxMixedFontFamily*>(aProxyEntry->mFamily)->ReplaceFontEntry(aProxyEntry, fe);
|
2008-09-30 20:04:10 -07:00
|
|
|
return STATUS_LOADED;
|
|
|
|
} else {
|
|
|
|
LOG(("userfonts (%p) [src %d] failed local: (%s) for (%s)\n",
|
|
|
|
this, aProxyEntry->mSrcIndex,
|
|
|
|
NS_ConvertUTF16toUTF8(currSrc.mLocalName).get(),
|
|
|
|
NS_ConvertUTF16toUTF8(aProxyEntry->mFamily->Name()).get()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// src url ==> start the load process
|
|
|
|
else {
|
|
|
|
if (gfxPlatform::GetPlatform()->IsFontFormatSupported(currSrc.mURI,
|
|
|
|
currSrc.mFormatFlags)) {
|
2008-12-11 23:31:51 -08:00
|
|
|
nsresult rv = StartLoad(aProxyEntry, &currSrc);
|
2008-11-05 16:32:12 -08:00
|
|
|
PRBool loadOK = NS_SUCCEEDED(rv);
|
|
|
|
|
2008-09-30 20:04:10 -07:00
|
|
|
if (loadOK) {
|
|
|
|
#ifdef PR_LOGGING
|
|
|
|
if (LOG_ENABLED()) {
|
|
|
|
nsCAutoString fontURI;
|
|
|
|
currSrc.mURI->GetSpec(fontURI);
|
|
|
|
LOG(("userfonts (%p) [src %d] loading uri: (%s) for (%s)\n",
|
|
|
|
this, aProxyEntry->mSrcIndex, fontURI.get(),
|
|
|
|
NS_ConvertUTF16toUTF8(aProxyEntry->mFamily->Name()).get()));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return STATUS_LOADING;
|
|
|
|
} else {
|
|
|
|
#ifdef PR_LOGGING
|
|
|
|
if (LOG_ENABLED()) {
|
|
|
|
nsCAutoString fontURI;
|
|
|
|
currSrc.mURI->GetSpec(fontURI);
|
|
|
|
LOG(("userfonts (%p) [src %d] failed uri: (%s) for (%s) download failed\n",
|
|
|
|
this, aProxyEntry->mSrcIndex, fontURI.get(),
|
|
|
|
NS_ConvertUTF16toUTF8(aProxyEntry->mFamily->Name()).get()));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
#ifdef PR_LOGGING
|
|
|
|
if (LOG_ENABLED()) {
|
|
|
|
nsCAutoString fontURI;
|
|
|
|
currSrc.mURI->GetSpec(fontURI);
|
|
|
|
LOG(("userfonts (%p) [src %d] failed uri: (%s) for (%s) format not supported\n",
|
|
|
|
this, aProxyEntry->mSrcIndex, fontURI.get(),
|
|
|
|
NS_ConvertUTF16toUTF8(aProxyEntry->mFamily->Name()).get()));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
aProxyEntry->mSrcIndex++;
|
|
|
|
}
|
|
|
|
|
|
|
|
// all src's failed, remove this face
|
|
|
|
LOG(("userfonts (%p) failed all src for (%s)\n",
|
|
|
|
this, NS_ConvertUTF16toUTF8(aProxyEntry->mFamily->Name()).get()));
|
|
|
|
|
2009-08-16 06:52:12 -07:00
|
|
|
gfxMixedFontFamily *family = static_cast<gfxMixedFontFamily*>(aProxyEntry->mFamily);
|
2008-09-30 20:04:10 -07:00
|
|
|
|
2009-08-16 06:52:12 -07:00
|
|
|
family->RemoveFontEntry(aProxyEntry);
|
2008-09-30 20:04:10 -07:00
|
|
|
|
|
|
|
// no more faces? remove the entire family
|
|
|
|
if (family->mAvailableFonts.Length() == 0) {
|
|
|
|
LOG(("userfonts (%p) failed all faces, remove family (%s)\n",
|
|
|
|
this, NS_ConvertUTF16toUTF8(family->Name()).get()));
|
|
|
|
RemoveFamily(family->Name());
|
|
|
|
}
|
|
|
|
|
|
|
|
return STATUS_END_OF_LIST;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
gfxUserFontSet::IncrementGeneration()
|
|
|
|
{
|
|
|
|
// add one, increment again if zero
|
|
|
|
LL_ADD(sFontSetGeneration, sFontSetGeneration, 1);
|
|
|
|
if (LL_IS_ZERO(sFontSetGeneration))
|
|
|
|
LL_ADD(sFontSetGeneration, sFontSetGeneration, 1);
|
|
|
|
mGeneration = sFontSetGeneration;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-12-05 15:19:27 -08:00
|
|
|
gfxMixedFontFamily*
|
|
|
|
gfxUserFontSet::GetFamily(const nsAString& aFamilyName) const
|
|
|
|
{
|
|
|
|
nsAutoString key(aFamilyName);
|
|
|
|
ToLowerCase(key);
|
|
|
|
|
|
|
|
return mFontFamilies.GetWeak(key);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-09-30 20:04:10 -07:00
|
|
|
void
|
|
|
|
gfxUserFontSet::RemoveFamily(const nsAString& aFamilyName)
|
|
|
|
{
|
|
|
|
nsAutoString key(aFamilyName);
|
|
|
|
ToLowerCase(key);
|
|
|
|
|
|
|
|
mFontFamilies.Remove(key);
|
|
|
|
}
|