2009-08-16 06:52:12 -07:00
|
|
|
/* -*- Mode: ObjC; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
|
|
* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: BSD
|
|
|
|
*
|
|
|
|
* Copyright (C) 2006-2009 Mozilla Corporation. All rights reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
|
|
|
* Vladimir Vukicevic <vladimir@pobox.com>
|
|
|
|
* Masayuki Nakano <masayuki@d-toybox.com>
|
|
|
|
* John Daggett <jdaggett@mozilla.com>
|
|
|
|
* Jonathan Kew <jfkthame@gmail.com>
|
2009-10-12 16:43:43 -07:00
|
|
|
*
|
2009-08-16 06:52:12 -07:00
|
|
|
* Copyright (C) 2006 Apple Computer, Inc. All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
*
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
|
|
|
|
* its contributors may be used to endorse or promote products derived
|
|
|
|
* from this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
|
|
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
|
* DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
|
|
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
|
2011-01-21 08:44:33 -08:00
|
|
|
#ifdef MOZ_LOGGING
|
|
|
|
#define FORCE_PR_LOG /* Allow logging in the release build */
|
|
|
|
#endif
|
|
|
|
#include "prlog.h"
|
|
|
|
|
2009-08-16 06:52:12 -07:00
|
|
|
#include <Carbon/Carbon.h>
|
|
|
|
|
|
|
|
#import <AppKit/AppKit.h>
|
|
|
|
|
|
|
|
#include "gfxPlatformMac.h"
|
|
|
|
#include "gfxMacPlatformFontList.h"
|
2010-03-10 04:46:41 -08:00
|
|
|
#include "gfxMacFont.h"
|
2009-08-16 06:52:12 -07:00
|
|
|
#include "gfxUserFontSet.h"
|
|
|
|
|
|
|
|
#include "nsServiceManagerUtils.h"
|
|
|
|
#include "nsTArray.h"
|
|
|
|
|
|
|
|
#include "nsDirectoryServiceUtils.h"
|
|
|
|
#include "nsDirectoryServiceDefs.h"
|
|
|
|
#include "nsISimpleEnumerator.h"
|
|
|
|
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <time.h>
|
|
|
|
|
2010-03-09 08:37:56 -08:00
|
|
|
class nsAutoreleasePool {
|
|
|
|
public:
|
|
|
|
nsAutoreleasePool()
|
|
|
|
{
|
|
|
|
mLocalPool = [[NSAutoreleasePool alloc] init];
|
|
|
|
}
|
|
|
|
~nsAutoreleasePool()
|
|
|
|
{
|
|
|
|
[mLocalPool release];
|
|
|
|
}
|
|
|
|
private:
|
|
|
|
NSAutoreleasePool *mLocalPool;
|
|
|
|
};
|
|
|
|
|
2009-08-16 06:52:12 -07:00
|
|
|
// font info loader constants
|
|
|
|
static const PRUint32 kDelayBeforeLoadingCmaps = 8 * 1000; // 8secs
|
|
|
|
static const PRUint32 kIntervalBetweenLoadingCmaps = 150; // 150ms
|
|
|
|
static const PRUint32 kNumFontsPerSlice = 10; // read in info 10 fonts at a time
|
|
|
|
|
|
|
|
// indexes into the NSArray objects that the Cocoa font manager returns
|
|
|
|
// as the available members of a family
|
|
|
|
#define INDEX_FONT_POSTSCRIPT_NAME 0
|
|
|
|
#define INDEX_FONT_FACE_NAME 1
|
|
|
|
#define INDEX_FONT_WEIGHT 2
|
|
|
|
#define INDEX_FONT_TRAITS 3
|
|
|
|
|
|
|
|
static const int kAppleMaxWeight = 14;
|
|
|
|
static const int kAppleExtraLightWeight = 3;
|
|
|
|
static const int kAppleUltraLightWeight = 2;
|
|
|
|
|
|
|
|
static const int gAppleWeightToCSSWeight[] = {
|
|
|
|
0,
|
2009-10-12 16:43:43 -07:00
|
|
|
1, // 1.
|
2009-08-16 06:52:12 -07:00
|
|
|
1, // 2. W1, ultralight
|
|
|
|
2, // 3. W2, extralight
|
|
|
|
3, // 4. W3, light
|
|
|
|
4, // 5. W4, semilight
|
|
|
|
5, // 6. W5, medium
|
|
|
|
6, // 7.
|
|
|
|
6, // 8. W6, semibold
|
|
|
|
7, // 9. W7, bold
|
|
|
|
8, // 10. W8, extrabold
|
|
|
|
8, // 11.
|
|
|
|
9, // 12. W9, ultrabold
|
|
|
|
9, // 13
|
|
|
|
9 // 14
|
|
|
|
};
|
|
|
|
|
2009-10-12 16:43:43 -07:00
|
|
|
// cache Cocoa's "shared font manager" for performance
|
|
|
|
static NSFontManager *sFontManager;
|
2009-08-16 06:52:12 -07:00
|
|
|
|
|
|
|
static void GetStringForNSString(const NSString *aSrc, nsAString& aDist)
|
|
|
|
{
|
|
|
|
aDist.SetLength([aSrc length]);
|
|
|
|
[aSrc getCharacters:aDist.BeginWriting()];
|
|
|
|
}
|
|
|
|
|
|
|
|
static NSString* GetNSStringForString(const nsAString& aSrc)
|
|
|
|
{
|
|
|
|
return [NSString stringWithCharacters:aSrc.BeginReading()
|
|
|
|
length:aSrc.Length()];
|
|
|
|
}
|
|
|
|
|
2009-10-07 07:13:40 -07:00
|
|
|
#ifdef PR_LOGGING
|
|
|
|
|
2011-01-21 08:44:33 -08:00
|
|
|
#define LOG_FONTLIST(args) PR_LOG(gfxPlatform::GetLog(eGfxLog_fontlist), \
|
|
|
|
PR_LOG_DEBUG, args)
|
|
|
|
#define LOG_FONTLIST_ENABLED() PR_LOG_TEST( \
|
|
|
|
gfxPlatform::GetLog(eGfxLog_fontlist), \
|
|
|
|
PR_LOG_DEBUG)
|
|
|
|
|
|
|
|
#endif // PR_LOGGING
|
2009-08-16 06:52:12 -07:00
|
|
|
|
|
|
|
/* MacOSFontEntry */
|
|
|
|
#pragma mark-
|
|
|
|
|
2009-10-12 16:43:43 -07:00
|
|
|
MacOSFontEntry::MacOSFontEntry(const nsAString& aPostscriptName,
|
2009-08-16 06:52:12 -07:00
|
|
|
PRInt32 aWeight,
|
|
|
|
gfxFontFamily *aFamily,
|
|
|
|
PRBool aIsStandardFace)
|
|
|
|
: gfxFontEntry(aPostscriptName, aFamily, aIsStandardFace),
|
|
|
|
mATSFontRef(0),
|
2010-07-22 02:25:21 -07:00
|
|
|
mATSFontRefInitialized(PR_FALSE),
|
2010-10-07 00:59:16 -07:00
|
|
|
mRequiresAAT(PR_FALSE),
|
|
|
|
mIsCFF(PR_FALSE),
|
|
|
|
mIsCFFInitialized(PR_FALSE)
|
2009-08-16 06:52:12 -07:00
|
|
|
{
|
|
|
|
mWeight = aWeight;
|
|
|
|
}
|
|
|
|
|
|
|
|
MacOSFontEntry::MacOSFontEntry(const nsAString& aPostscriptName, ATSFontRef aFontRef,
|
|
|
|
PRUint16 aWeight, PRUint16 aStretch, PRUint32 aItalicStyle,
|
|
|
|
gfxUserFontData *aUserFontData)
|
|
|
|
: gfxFontEntry(aPostscriptName),
|
|
|
|
mATSFontRef(aFontRef),
|
2010-07-22 02:25:21 -07:00
|
|
|
mATSFontRefInitialized(PR_TRUE),
|
2010-10-07 00:59:16 -07:00
|
|
|
mRequiresAAT(PR_FALSE),
|
|
|
|
mIsCFFInitialized(PR_FALSE)
|
2009-08-16 06:52:12 -07:00
|
|
|
{
|
|
|
|
// xxx - stretch is basically ignored for now
|
|
|
|
|
|
|
|
mUserFontData = aUserFontData;
|
|
|
|
mWeight = aWeight;
|
|
|
|
mStretch = aStretch;
|
|
|
|
mFixedPitch = PR_FALSE; // xxx - do we need this for downloaded fonts?
|
|
|
|
mItalic = (aItalicStyle & (FONT_STYLE_ITALIC | FONT_STYLE_OBLIQUE)) != 0;
|
|
|
|
mIsUserFont = aUserFontData != nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
ATSFontRef
|
2009-10-12 16:43:43 -07:00
|
|
|
MacOSFontEntry::GetFontRef()
|
2009-08-16 06:52:12 -07:00
|
|
|
{
|
|
|
|
if (!mATSFontRefInitialized) {
|
|
|
|
mATSFontRefInitialized = PR_TRUE;
|
|
|
|
NSString *psname = GetNSStringForString(mName);
|
|
|
|
mATSFontRef = ::ATSFontFindFromPostScriptName(CFStringRef(psname),
|
|
|
|
kATSOptionFlagsDefault);
|
|
|
|
}
|
|
|
|
return mATSFontRef;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ATSUI requires AAT-enabled fonts to render complex scripts correctly.
|
|
|
|
// For now, simple clear out the cmap codepoints for fonts that have
|
|
|
|
// codepoints for complex scripts. (Bug 361986)
|
|
|
|
// Core Text is similar, but can render Arabic using OpenType fonts as well.
|
|
|
|
|
|
|
|
enum eComplexScript {
|
|
|
|
eComplexScriptArabic,
|
|
|
|
eComplexScriptIndic,
|
|
|
|
eComplexScriptTibetan
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ScriptRange {
|
|
|
|
eComplexScript script;
|
|
|
|
PRUint32 rangeStart;
|
|
|
|
PRUint32 rangeEnd;
|
|
|
|
};
|
|
|
|
|
|
|
|
const ScriptRange gScriptsThatRequireShaping[] = {
|
2010-11-20 09:49:12 -08:00
|
|
|
{ eComplexScriptArabic, 0x0600, 0x077F }, // Basic Arabic, Syriac, Arabic Supplement
|
2009-08-16 06:52:12 -07:00
|
|
|
{ eComplexScriptIndic, 0x0900, 0x0D7F }, // Indic scripts - Devanagari, Bengali, ..., Malayalam
|
|
|
|
{ eComplexScriptTibetan, 0x0F00, 0x0FFF } // Tibetan
|
|
|
|
// Thai seems to be "renderable" without AAT morphing tables
|
|
|
|
// xxx - Lao, Khmer?
|
|
|
|
};
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
MacOSFontEntry::ReadCMAP()
|
|
|
|
{
|
|
|
|
ByteCount size;
|
|
|
|
|
|
|
|
// attempt this once, if errors occur leave a blank cmap
|
|
|
|
if (mCmapInitialized)
|
|
|
|
return NS_OK;
|
|
|
|
mCmapInitialized = PR_TRUE;
|
|
|
|
|
|
|
|
PRUint32 kCMAP = TRUETYPE_TAG('c','m','a','p');
|
2009-10-12 16:43:43 -07:00
|
|
|
|
2011-01-06 20:45:10 -08:00
|
|
|
AutoFallibleTArray<PRUint8,16384> cmap;
|
2009-12-10 12:18:14 -08:00
|
|
|
if (GetFontTable(kCMAP, cmap) != NS_OK)
|
2009-08-16 06:52:12 -07:00
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
PRPackedBool unicodeFont, symbolFont; // currently ignored
|
2009-12-10 12:18:14 -08:00
|
|
|
nsresult rv = gfxFontUtils::ReadCMAP(cmap.Elements(), cmap.Length(),
|
2010-07-22 02:25:21 -07:00
|
|
|
mCharacterMap, mUVSOffset,
|
|
|
|
unicodeFont, symbolFont);
|
2009-09-17 17:45:29 -07:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
mCharacterMap.reset();
|
|
|
|
return rv;
|
|
|
|
}
|
2009-10-07 10:16:52 -07:00
|
|
|
mHasCmapTable = PR_TRUE;
|
2009-08-16 06:52:12 -07:00
|
|
|
|
|
|
|
ATSFontRef fontRef = GetFontRef();
|
|
|
|
|
2010-12-06 02:41:29 -08:00
|
|
|
// for layout support, check for the presence of mort/morx and/or
|
|
|
|
// opentype layout tables
|
2010-07-22 02:25:21 -07:00
|
|
|
PRBool hasAATLayout =
|
|
|
|
(::ATSFontGetTable(fontRef, TRUETYPE_TAG('m','o','r','x'),
|
|
|
|
0, 0, 0, &size) == noErr) ||
|
|
|
|
(::ATSFontGetTable(fontRef, TRUETYPE_TAG('m','o','r','t'),
|
|
|
|
0, 0, 0, &size) == noErr);
|
|
|
|
|
2010-12-06 02:41:29 -08:00
|
|
|
PRBool hasGSUB =
|
2010-07-22 02:25:21 -07:00
|
|
|
(::ATSFontGetTable(fontRef, TRUETYPE_TAG('G','S','U','B'),
|
2010-12-06 02:41:29 -08:00
|
|
|
0, 0, 0, &size) == noErr);
|
|
|
|
PRBool hasGPOS =
|
2010-07-22 02:25:21 -07:00
|
|
|
(::ATSFontGetTable(fontRef, TRUETYPE_TAG('G','P','O','S'),
|
|
|
|
0, 0, 0, &size) == noErr);
|
|
|
|
|
2010-12-06 02:41:29 -08:00
|
|
|
if (hasAATLayout && !(hasGSUB || hasGPOS)) {
|
|
|
|
mRequiresAAT = PR_TRUE; // prefer CoreText if font has no OTL tables
|
2010-07-22 02:25:21 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
PRUint32 numScripts =
|
|
|
|
sizeof(gScriptsThatRequireShaping) / sizeof(ScriptRange);
|
|
|
|
|
|
|
|
for (PRUint32 s = 0; s < numScripts; s++) {
|
2009-08-16 06:52:12 -07:00
|
|
|
eComplexScript whichScript = gScriptsThatRequireShaping[s].script;
|
2009-10-12 16:43:43 -07:00
|
|
|
|
2009-08-16 06:52:12 -07:00
|
|
|
// check to see if the cmap includes complex script codepoints
|
|
|
|
if (mCharacterMap.TestRange(gScriptsThatRequireShaping[s].rangeStart,
|
|
|
|
gScriptsThatRequireShaping[s].rangeEnd)) {
|
|
|
|
PRBool omitRange = PR_TRUE;
|
|
|
|
|
2010-07-22 02:25:21 -07:00
|
|
|
if (hasAATLayout) {
|
2009-08-16 06:52:12 -07:00
|
|
|
omitRange = PR_FALSE;
|
2010-12-06 02:41:29 -08:00
|
|
|
// prefer CoreText for Apple's complex-script fonts,
|
|
|
|
// even if they also have some OpenType tables
|
|
|
|
// (e.g. Geeza Pro Bold on 10.6; see bug 614903)
|
|
|
|
mRequiresAAT = PR_TRUE;
|
2010-07-22 02:25:21 -07:00
|
|
|
} else if (whichScript == eComplexScriptArabic) {
|
|
|
|
// special-case for Arabic:
|
2010-02-26 06:20:38 -08:00
|
|
|
// even if there's no morph table, CoreText can shape Arabic
|
2010-11-20 09:49:12 -08:00
|
|
|
// using OpenType layout; or if it's a downloaded font,
|
|
|
|
// assume the site knows what it's doing (as harfbuzz will
|
2010-12-06 02:41:29 -08:00
|
|
|
// be able to shape even though the font itself lacks tables
|
|
|
|
// stripped during sanitization).
|
|
|
|
// We check for GSUB here, as GPOS alone would not be ok
|
|
|
|
// for Arabic shaping.
|
|
|
|
if (hasGSUB || (mIsUserFont && !mIsLocalUserFont)) {
|
2010-07-22 02:25:21 -07:00
|
|
|
// TODO: to be really thorough, we could check that the
|
|
|
|
// GSUB table actually supports the 'arab' script tag.
|
2010-02-26 06:20:38 -08:00
|
|
|
omitRange = PR_FALSE;
|
2009-08-16 06:52:12 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (omitRange) {
|
|
|
|
mCharacterMap.ClearRange(gScriptsThatRequireShaping[s].rangeStart,
|
|
|
|
gScriptsThatRequireShaping[s].rangeEnd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-21 08:44:33 -08:00
|
|
|
#ifdef PR_LOGGING
|
|
|
|
LOG_FONTLIST(("(fontlist-cmap) name: %s, size: %d\n",
|
|
|
|
NS_ConvertUTF16toUTF8(mName).get(),
|
|
|
|
mCharacterMap.GetSize()));
|
|
|
|
#endif
|
2009-10-12 16:43:43 -07:00
|
|
|
|
2009-08-16 06:52:12 -07:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
2011-01-06 20:45:10 -08:00
|
|
|
MacOSFontEntry::GetFontTable(PRUint32 aTableTag, FallibleTArray<PRUint8>& aBuffer)
|
2009-08-16 06:52:12 -07:00
|
|
|
{
|
2010-03-09 08:37:56 -08:00
|
|
|
nsAutoreleasePool localPool;
|
|
|
|
|
2009-08-16 06:52:12 -07:00
|
|
|
ATSFontRef fontRef = GetFontRef();
|
2010-06-11 12:14:38 -07:00
|
|
|
if (fontRef == (ATSFontRef)kATSUInvalidFontID) {
|
2009-08-16 06:52:12 -07:00
|
|
|
return NS_ERROR_FAILURE;
|
2010-06-11 12:14:38 -07:00
|
|
|
}
|
2009-08-16 06:52:12 -07:00
|
|
|
|
|
|
|
ByteCount dataLength;
|
|
|
|
OSStatus status = ::ATSFontGetTable(fontRef, aTableTag, 0, 0, 0, &dataLength);
|
2010-06-11 12:14:38 -07:00
|
|
|
if (status != noErr) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
2009-08-16 06:52:12 -07:00
|
|
|
|
2010-06-11 12:14:38 -07:00
|
|
|
if (!aBuffer.AppendElements(dataLength)) {
|
2009-08-16 06:52:12 -07:00
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
2010-06-11 12:14:38 -07:00
|
|
|
}
|
2009-08-16 06:52:12 -07:00
|
|
|
PRUint8 *dataPtr = aBuffer.Elements();
|
|
|
|
|
|
|
|
status = ::ATSFontGetTable(fontRef, aTableTag, 0, dataLength, dataPtr, &dataLength);
|
|
|
|
NS_ENSURE_TRUE(status == noErr, NS_ERROR_FAILURE);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2009-09-28 03:25:22 -07:00
|
|
|
|
2009-10-07 08:26:58 -07:00
|
|
|
gfxFont*
|
|
|
|
MacOSFontEntry::CreateFontInstance(const gfxFontStyle *aFontStyle, PRBool aNeedsBold)
|
|
|
|
{
|
2010-03-10 04:46:41 -08:00
|
|
|
return new gfxMacFont(this, aFontStyle, aNeedsBold);
|
2009-10-07 08:26:58 -07:00
|
|
|
}
|
|
|
|
|
2010-10-07 00:59:16 -07:00
|
|
|
PRBool
|
|
|
|
MacOSFontEntry::IsCFF()
|
|
|
|
{
|
|
|
|
if (!mIsCFFInitialized) {
|
|
|
|
mIsCFFInitialized = PR_TRUE;
|
|
|
|
ATSFontRef fontRef = GetFontRef();
|
|
|
|
if (fontRef != (ATSFontRef)kATSUInvalidFontID) {
|
|
|
|
ByteCount dataLength;
|
|
|
|
OSStatus status = ::ATSFontGetTable(fontRef,
|
|
|
|
TRUETYPE_TAG('C','F','F',' '),
|
|
|
|
0, 0, 0, &dataLength);
|
|
|
|
if (status == noErr && dataLength > 0) {
|
|
|
|
mIsCFF = PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return mIsCFF;
|
|
|
|
}
|
|
|
|
|
2009-09-28 03:25:22 -07:00
|
|
|
|
|
|
|
/* gfxMacFontFamily */
|
|
|
|
#pragma mark-
|
|
|
|
|
|
|
|
class gfxMacFontFamily : public gfxFontFamily
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
gfxMacFontFamily(nsAString& aName) :
|
|
|
|
gfxFontFamily(aName)
|
|
|
|
{}
|
|
|
|
|
|
|
|
virtual ~gfxMacFontFamily() {}
|
|
|
|
|
|
|
|
virtual void LocalizedName(nsAString& aLocalizedName);
|
2009-10-12 16:43:43 -07:00
|
|
|
|
|
|
|
virtual void FindStyleVariations();
|
|
|
|
|
|
|
|
void EliminateDuplicateFaces();
|
2009-09-28 03:25:22 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
void
|
|
|
|
gfxMacFontFamily::LocalizedName(nsAString& aLocalizedName)
|
|
|
|
{
|
2010-03-09 08:37:56 -08:00
|
|
|
nsAutoreleasePool localPool;
|
|
|
|
|
2009-09-28 03:25:22 -07:00
|
|
|
if (!HasOtherFamilyNames()) {
|
|
|
|
aLocalizedName = mName;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
NSString *family = GetNSStringForString(mName);
|
2009-10-12 16:43:43 -07:00
|
|
|
NSString *localized = [sFontManager
|
2009-09-28 03:25:22 -07:00
|
|
|
localizedNameForFamily:family
|
|
|
|
face:nil];
|
|
|
|
|
|
|
|
if (localized) {
|
|
|
|
GetStringForNSString(localized, aLocalizedName);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// failed to get localized name, just use the canonical one
|
|
|
|
aLocalizedName = mName;
|
|
|
|
}
|
|
|
|
|
2009-10-12 16:43:43 -07:00
|
|
|
void
|
|
|
|
gfxMacFontFamily::FindStyleVariations()
|
|
|
|
{
|
|
|
|
if (mHasStyles)
|
|
|
|
return;
|
|
|
|
|
2010-03-09 08:37:56 -08:00
|
|
|
nsAutoreleasePool localPool;
|
|
|
|
|
2009-10-12 16:43:43 -07:00
|
|
|
NSString *family = GetNSStringForString(mName);
|
|
|
|
|
|
|
|
// create a font entry for each face
|
|
|
|
NSArray *fontfaces = [sFontManager
|
|
|
|
availableMembersOfFontFamily:family]; // returns an array of [psname, style name, weight, traits] elements, goofy api
|
|
|
|
int faceCount = [fontfaces count];
|
|
|
|
int faceIndex;
|
|
|
|
|
|
|
|
// Bug 420981 - under 10.5, UltraLight and Light have the same weight value
|
|
|
|
PRBool needToCheckLightFaces =
|
|
|
|
(gfxPlatformMac::GetPlatform()->OSXVersion() >= MAC_OS_X_VERSION_10_5_HEX);
|
|
|
|
|
|
|
|
for (faceIndex = 0; faceIndex < faceCount; faceIndex++) {
|
|
|
|
NSArray *face = [fontfaces objectAtIndex:faceIndex];
|
|
|
|
NSString *psname = [face objectAtIndex:INDEX_FONT_POSTSCRIPT_NAME];
|
|
|
|
PRInt32 appKitWeight = [[face objectAtIndex:INDEX_FONT_WEIGHT] unsignedIntValue];
|
|
|
|
PRUint32 macTraits = [[face objectAtIndex:INDEX_FONT_TRAITS] unsignedIntValue];
|
|
|
|
NSString *facename = [face objectAtIndex:INDEX_FONT_FACE_NAME];
|
|
|
|
PRBool isStandardFace = PR_FALSE;
|
|
|
|
|
|
|
|
if (needToCheckLightFaces && appKitWeight == kAppleExtraLightWeight) {
|
|
|
|
// if the facename contains UltraLight, set the weight to the ultralight weight value
|
|
|
|
NSRange range = [facename rangeOfString:@"ultralight" options:NSCaseInsensitiveSearch];
|
|
|
|
if (range.location != NSNotFound) {
|
|
|
|
appKitWeight = kAppleUltraLightWeight;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
PRInt32 cssWeight = gfxMacPlatformFontList::AppleWeightToCSSWeight(appKitWeight) * 100;
|
|
|
|
|
|
|
|
// make a nsString
|
|
|
|
nsAutoString postscriptFontName;
|
|
|
|
GetStringForNSString(psname, postscriptFontName);
|
|
|
|
|
|
|
|
if ([facename isEqualToString:@"Regular"] ||
|
|
|
|
[facename isEqualToString:@"Bold"] ||
|
|
|
|
[facename isEqualToString:@"Italic"] ||
|
|
|
|
[facename isEqualToString:@"Oblique"] ||
|
|
|
|
[facename isEqualToString:@"Bold Italic"] ||
|
|
|
|
[facename isEqualToString:@"Bold Oblique"])
|
|
|
|
{
|
|
|
|
isStandardFace = PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
// create a font entry
|
|
|
|
MacOSFontEntry *fontEntry = new MacOSFontEntry(postscriptFontName,
|
|
|
|
cssWeight, this, isStandardFace);
|
|
|
|
if (!fontEntry) break;
|
|
|
|
|
|
|
|
// set additional properties based on the traits reported by Cocoa
|
|
|
|
if (macTraits & (NSCondensedFontMask | NSNarrowFontMask | NSCompressedFontMask)) {
|
|
|
|
fontEntry->mStretch = NS_FONT_STRETCH_CONDENSED;
|
|
|
|
} else if (macTraits & NSExpandedFontMask) {
|
|
|
|
fontEntry->mStretch = NS_FONT_STRETCH_EXPANDED;
|
|
|
|
}
|
2010-11-16 00:34:38 -08:00
|
|
|
// Cocoa fails to set the Italic traits bit for HelveticaLightItalic,
|
|
|
|
// at least (see bug 611855), so check for style name endings as well
|
|
|
|
if ((macTraits & NSItalicFontMask) ||
|
|
|
|
[facename hasSuffix:@"Italic"] ||
|
|
|
|
[facename hasSuffix:@"Oblique"])
|
|
|
|
{
|
2009-10-12 16:43:43 -07:00
|
|
|
fontEntry->mItalic = PR_TRUE;
|
|
|
|
}
|
|
|
|
if (macTraits & NSFixedPitchFontMask) {
|
|
|
|
fontEntry->mFixedPitch = PR_TRUE;
|
|
|
|
}
|
|
|
|
|
2009-10-07 07:13:40 -07:00
|
|
|
#ifdef PR_LOGGING
|
2011-01-21 08:44:33 -08:00
|
|
|
if (LOG_FONTLIST_ENABLED()) {
|
|
|
|
LOG_FONTLIST(("(fontlist) added (%s) to family (%s)"
|
2009-10-07 07:13:40 -07:00
|
|
|
" with style: %s weight: %d stretch: %d"
|
|
|
|
" (apple-weight: %d macTraits: %8.8x)",
|
|
|
|
NS_ConvertUTF16toUTF8(fontEntry->Name()).get(),
|
|
|
|
NS_ConvertUTF16toUTF8(Name()).get(),
|
|
|
|
fontEntry->IsItalic() ? "italic" : "normal",
|
|
|
|
cssWeight, fontEntry->Stretch(),
|
|
|
|
appKitWeight, macTraits));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-10-12 16:43:43 -07:00
|
|
|
// insert into font entry array of family
|
|
|
|
AddFontEntry(fontEntry);
|
|
|
|
}
|
|
|
|
|
|
|
|
SortAvailableFonts();
|
|
|
|
SetHasStyles(PR_TRUE);
|
|
|
|
|
|
|
|
if (mIsBadUnderlineFamily) {
|
|
|
|
SetBadUnderlineFonts();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gfxMacFontFamily::EliminateDuplicateFaces()
|
|
|
|
{
|
|
|
|
PRUint32 i, bold, numFonts, italicIndex;
|
|
|
|
MacOSFontEntry *italic, *nonitalic;
|
|
|
|
|
|
|
|
FindStyleVariations();
|
|
|
|
|
|
|
|
// if normal and italic have the same ATS font ref, delete italic
|
|
|
|
// if bold and bold-italic have the same ATS font ref, delete bold-italic
|
|
|
|
|
|
|
|
// two iterations, one for normal, one for bold
|
|
|
|
for (bold = 0; bold < 2; bold++) {
|
|
|
|
numFonts = mAvailableFonts.Length();
|
|
|
|
|
|
|
|
// find the non-italic face
|
|
|
|
nonitalic = nsnull;
|
|
|
|
for (i = 0; i < numFonts; i++) {
|
|
|
|
if ((mAvailableFonts[i]->IsBold() == (bold == 1)) &&
|
|
|
|
!mAvailableFonts[i]->IsItalic()) {
|
|
|
|
nonitalic = static_cast<MacOSFontEntry*>(mAvailableFonts[i].get());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// find the italic face
|
|
|
|
if (nonitalic) {
|
|
|
|
italic = nsnull;
|
|
|
|
for (i = 0; i < numFonts; i++) {
|
|
|
|
if ((mAvailableFonts[i]->IsBold() == (bold == 1)) &&
|
|
|
|
mAvailableFonts[i]->IsItalic()) {
|
|
|
|
italic = static_cast<MacOSFontEntry*>(mAvailableFonts[i].get());
|
|
|
|
italicIndex = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// if italic face and non-italic face have matching ATS refs,
|
|
|
|
// or if the italic returns 0 rather than an actual ATSFontRef,
|
|
|
|
// then the italic face is bogus so remove it
|
|
|
|
if (italic && (italic->GetFontRef() == 0 ||
|
|
|
|
italic->GetFontRef() == nonitalic->GetFontRef())) {
|
|
|
|
mAvailableFonts.RemoveElementAt(italicIndex);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-28 03:25:22 -07:00
|
|
|
|
|
|
|
/* gfxSingleFaceMacFontFamily */
|
|
|
|
#pragma mark-
|
|
|
|
|
|
|
|
class gfxSingleFaceMacFontFamily : public gfxFontFamily
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
gfxSingleFaceMacFontFamily(nsAString& aName) :
|
|
|
|
gfxFontFamily(aName)
|
|
|
|
{}
|
|
|
|
|
|
|
|
virtual ~gfxSingleFaceMacFontFamily() {}
|
|
|
|
|
|
|
|
virtual void LocalizedName(nsAString& aLocalizedName);
|
|
|
|
|
2010-01-28 17:41:25 -08:00
|
|
|
virtual void ReadOtherFamilyNames(gfxPlatformFontList *aPlatformFontList);
|
2009-09-28 03:25:22 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
void
|
|
|
|
gfxSingleFaceMacFontFamily::LocalizedName(nsAString& aLocalizedName)
|
|
|
|
{
|
2010-03-09 08:37:56 -08:00
|
|
|
nsAutoreleasePool localPool;
|
|
|
|
|
2009-09-28 03:25:22 -07:00
|
|
|
if (!HasOtherFamilyNames()) {
|
|
|
|
aLocalizedName = mName;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
gfxFontEntry *fe = mAvailableFonts[0];
|
|
|
|
NSFont *font = [NSFont fontWithName:GetNSStringForString(fe->Name())
|
|
|
|
size:0.0];
|
|
|
|
if (font) {
|
|
|
|
NSString *localized = [font displayName];
|
|
|
|
if (localized) {
|
|
|
|
GetStringForNSString(localized, aLocalizedName);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// failed to get localized name, just use the canonical one
|
|
|
|
aLocalizedName = mName;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-01-28 17:41:25 -08:00
|
|
|
gfxSingleFaceMacFontFamily::ReadOtherFamilyNames(gfxPlatformFontList *aPlatformFontList)
|
2009-09-28 03:25:22 -07:00
|
|
|
{
|
2009-10-12 16:43:43 -07:00
|
|
|
if (mOtherFamilyNamesInitialized)
|
2009-09-28 03:25:22 -07:00
|
|
|
return;
|
|
|
|
|
2010-01-28 17:41:25 -08:00
|
|
|
gfxFontEntry *fe = mAvailableFonts[0];
|
|
|
|
if (!fe)
|
|
|
|
return;
|
|
|
|
|
|
|
|
const PRUint32 kNAME = TRUETYPE_TAG('n','a','m','e');
|
2011-01-06 20:45:10 -08:00
|
|
|
AutoFallibleTArray<PRUint8,8192> buffer;
|
2010-01-28 17:41:25 -08:00
|
|
|
|
|
|
|
if (fe->GetFontTable(kNAME, buffer) != NS_OK)
|
|
|
|
return;
|
|
|
|
|
|
|
|
mHasOtherFamilyNames = ReadOtherFamilyNamesForFace(aPlatformFontList,
|
|
|
|
buffer,
|
2009-09-28 03:25:22 -07:00
|
|
|
PR_TRUE);
|
|
|
|
mOtherFamilyNamesInitialized = PR_TRUE;
|
|
|
|
}
|
|
|
|
|
2009-08-16 06:52:12 -07:00
|
|
|
|
|
|
|
/* gfxMacPlatformFontList */
|
|
|
|
#pragma mark-
|
|
|
|
|
2009-10-12 16:43:43 -07:00
|
|
|
gfxMacPlatformFontList::gfxMacPlatformFontList() :
|
2010-01-28 17:41:25 -08:00
|
|
|
gfxPlatformFontList(PR_FALSE), mATSGeneration(PRUint32(kATSGenerationInitial))
|
2009-08-16 06:52:12 -07:00
|
|
|
{
|
|
|
|
::ATSFontNotificationSubscribe(ATSNotification,
|
|
|
|
kATSFontNotifyOptionDefault,
|
|
|
|
(void*)this, nsnull);
|
|
|
|
|
|
|
|
// this should always be available (though we won't actually fail if it's missing,
|
|
|
|
// we'll just end up doing a search and then caching the new result instead)
|
|
|
|
mReplacementCharFallbackFamily = NS_LITERAL_STRING("Lucida Grande");
|
2009-10-12 16:43:43 -07:00
|
|
|
|
|
|
|
// cache this in a static variable so that MacOSFontFamily objects
|
|
|
|
// don't have to repeatedly look it up
|
|
|
|
sFontManager = [NSFontManager sharedFontManager];
|
2009-08-16 06:52:12 -07:00
|
|
|
}
|
|
|
|
|
2010-11-08 03:02:27 -08:00
|
|
|
nsresult
|
2009-08-16 06:52:12 -07:00
|
|
|
gfxMacPlatformFontList::InitFontList()
|
|
|
|
{
|
2010-03-09 08:37:56 -08:00
|
|
|
nsAutoreleasePool localPool;
|
|
|
|
|
2009-08-16 06:52:12 -07:00
|
|
|
ATSGeneration currentGeneration = ::ATSGetGeneration();
|
2009-10-12 16:43:43 -07:00
|
|
|
|
2009-08-16 06:52:12 -07:00
|
|
|
// need to ignore notifications after adding each font
|
|
|
|
if (mATSGeneration == currentGeneration)
|
2010-11-08 03:02:27 -08:00
|
|
|
return NS_OK;
|
2009-08-16 06:52:12 -07:00
|
|
|
|
|
|
|
mATSGeneration = currentGeneration;
|
2011-01-21 08:44:33 -08:00
|
|
|
#ifdef PR_LOGGING
|
|
|
|
LOG_FONTLIST(("(fontlist) updating to generation: %d", mATSGeneration));
|
|
|
|
#endif
|
2009-10-12 16:43:43 -07:00
|
|
|
|
2010-01-28 17:41:25 -08:00
|
|
|
// reset font lists
|
|
|
|
gfxPlatformFontList::InitFontList();
|
|
|
|
|
2009-08-16 06:52:12 -07:00
|
|
|
// iterate over available families
|
2009-10-12 16:43:43 -07:00
|
|
|
NSEnumerator *families = [[sFontManager availableFontFamilies]
|
|
|
|
objectEnumerator]; // returns "canonical", non-localized family name
|
|
|
|
|
|
|
|
nsAutoString availableFamilyName;
|
2009-08-16 06:52:12 -07:00
|
|
|
|
|
|
|
NSString *availableFamily = nil;
|
|
|
|
while ((availableFamily = [families nextObject])) {
|
|
|
|
|
|
|
|
// make a nsString
|
|
|
|
GetStringForNSString(availableFamily, availableFamilyName);
|
2009-10-12 16:43:43 -07:00
|
|
|
|
2009-08-16 06:52:12 -07:00
|
|
|
// create a family entry
|
2009-09-28 03:25:22 -07:00
|
|
|
gfxFontFamily *familyEntry = new gfxMacFontFamily(availableFamilyName);
|
2009-08-16 06:52:12 -07:00
|
|
|
if (!familyEntry) break;
|
|
|
|
|
|
|
|
// add the family entry to the hash table
|
|
|
|
ToLowerCase(availableFamilyName);
|
|
|
|
mFontFamilies.Put(availableFamilyName, familyEntry);
|
2010-01-27 22:56:16 -08:00
|
|
|
|
|
|
|
// check the bad underline blacklist
|
2010-02-11 04:00:07 -08:00
|
|
|
if (mBadUnderlineFamilyNames.Contains(availableFamilyName))
|
2010-01-27 22:56:16 -08:00
|
|
|
familyEntry->SetBadUnderlineFamily();
|
2009-08-16 06:52:12 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
InitSingleFaceList();
|
|
|
|
|
2009-10-12 16:43:43 -07:00
|
|
|
// to avoid full search of font name tables, seed the other names table with localized names from
|
2009-08-16 06:52:12 -07:00
|
|
|
// some of the prefs fonts which are accessed via their localized names. changes in the pref fonts will only cause
|
|
|
|
// a font lookup miss earlier. this is a simple optimization, it's not required for correctness
|
|
|
|
PreloadNamesList();
|
|
|
|
|
|
|
|
// clean up various minor 10.4 font problems for specific fonts
|
|
|
|
if (gfxPlatformMac::GetPlatform()->OSXVersion() < MAC_OS_X_VERSION_10_5_HEX) {
|
|
|
|
// Cocoa calls report that italic faces exist for Courier and Helvetica,
|
|
|
|
// even though only bold faces exist so test for this using ATS font refs (10.5 has proper faces)
|
|
|
|
EliminateDuplicateFaces(NS_LITERAL_STRING("Courier"));
|
|
|
|
EliminateDuplicateFaces(NS_LITERAL_STRING("Helvetica"));
|
2009-10-12 16:43:43 -07:00
|
|
|
|
2009-08-16 06:52:12 -07:00
|
|
|
// Cocoa reports that Courier and Monaco are not fixed-pitch fonts
|
|
|
|
// so explicitly tweak these settings
|
|
|
|
SetFixedPitch(NS_LITERAL_STRING("Courier"));
|
|
|
|
SetFixedPitch(NS_LITERAL_STRING("Monaco"));
|
|
|
|
}
|
|
|
|
|
|
|
|
// start the delayed cmap loader
|
2009-10-12 16:43:43 -07:00
|
|
|
StartLoader(kDelayBeforeLoadingCmaps, kIntervalBetweenLoadingCmaps);
|
2010-11-08 03:02:27 -08:00
|
|
|
|
|
|
|
return NS_OK;
|
2009-08-16 06:52:12 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gfxMacPlatformFontList::InitSingleFaceList()
|
|
|
|
{
|
|
|
|
nsAutoTArray<nsString, 10> singleFaceFonts;
|
|
|
|
gfxFontUtils::GetPrefsFontList("font.single-face-list", singleFaceFonts);
|
|
|
|
|
|
|
|
PRUint32 numFonts = singleFaceFonts.Length();
|
|
|
|
for (PRUint32 i = 0; i < numFonts; i++) {
|
2011-01-21 08:44:33 -08:00
|
|
|
#ifdef PR_LOGGING
|
|
|
|
LOG_FONTLIST(("(fontlist-singleface) face name: %s\n",
|
|
|
|
NS_ConvertUTF16toUTF8(singleFaceFonts[i]).get()));
|
|
|
|
#endif
|
2009-08-16 06:52:12 -07:00
|
|
|
gfxFontEntry *fontEntry = LookupLocalFont(nsnull, singleFaceFonts[i]);
|
|
|
|
if (fontEntry) {
|
|
|
|
nsAutoString familyName, key;
|
2009-09-28 17:38:59 -07:00
|
|
|
familyName = singleFaceFonts[i];
|
2009-08-16 06:52:12 -07:00
|
|
|
GenerateFontListKey(familyName, key);
|
2011-01-21 08:44:33 -08:00
|
|
|
#ifdef PR_LOGGING
|
|
|
|
LOG_FONTLIST(("(fontlist-singleface) family name: %s, key: %s\n",
|
|
|
|
NS_ConvertUTF16toUTF8(familyName).get(),
|
|
|
|
NS_ConvertUTF16toUTF8(key).get()));
|
|
|
|
#endif
|
2009-08-16 06:52:12 -07:00
|
|
|
|
|
|
|
// add only if doesn't exist already
|
|
|
|
PRBool found;
|
|
|
|
gfxFontFamily *familyEntry;
|
|
|
|
if (!(familyEntry = mFontFamilies.GetWeak(key, &found))) {
|
2009-09-28 03:25:22 -07:00
|
|
|
familyEntry = new gfxSingleFaceMacFontFamily(familyName);
|
2009-08-16 06:52:12 -07:00
|
|
|
familyEntry->AddFontEntry(fontEntry);
|
|
|
|
familyEntry->SetHasStyles(PR_TRUE);
|
|
|
|
mFontFamilies.Put(key, familyEntry);
|
|
|
|
fontEntry->mFamily = familyEntry;
|
2011-01-21 08:44:33 -08:00
|
|
|
#ifdef PR_LOGGING
|
|
|
|
LOG_FONTLIST(("(fontlist-singleface) added new family\n",
|
|
|
|
NS_ConvertUTF16toUTF8(familyName).get(),
|
|
|
|
NS_ConvertUTF16toUTF8(key).get()));
|
|
|
|
#endif
|
2009-08-16 06:52:12 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-12 16:43:43 -07:00
|
|
|
void
|
2009-08-16 06:52:12 -07:00
|
|
|
gfxMacPlatformFontList::EliminateDuplicateFaces(const nsAString& aFamilyName)
|
|
|
|
{
|
2009-10-12 16:43:43 -07:00
|
|
|
gfxMacFontFamily *family =
|
|
|
|
static_cast<gfxMacFontFamily*>(FindFamily(aFamilyName));
|
2009-08-16 06:52:12 -07:00
|
|
|
|
2009-10-12 16:43:43 -07:00
|
|
|
if (family)
|
|
|
|
family->EliminateDuplicateFaces();
|
2009-08-16 06:52:12 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
PRBool
|
|
|
|
gfxMacPlatformFontList::GetStandardFamilyName(const nsAString& aFontName, nsAString& aFamilyName)
|
|
|
|
{
|
|
|
|
gfxFontFamily *family = FindFamily(aFontName);
|
|
|
|
if (family) {
|
2009-09-28 03:25:22 -07:00
|
|
|
family->LocalizedName(aFamilyName);
|
2009-08-16 06:52:12 -07:00
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Gecko 1.8 used Quickdraw font api's which produce a slightly different set of "family"
|
|
|
|
// names. Try to resolve based on these names, in case this is stored in an old profile
|
|
|
|
// 1.8: "Futura", "Futura Condensed" ==> 1.9: "Futura"
|
|
|
|
|
|
|
|
// convert the name to a Pascal-style Str255 to try as Quickdraw name
|
|
|
|
Str255 qdname;
|
|
|
|
NS_ConvertUTF16toUTF8 utf8name(aFontName);
|
|
|
|
qdname[0] = PR_MAX(255, strlen(utf8name.get()));
|
|
|
|
memcpy(&qdname[1], utf8name.get(), qdname[0]);
|
|
|
|
|
|
|
|
// look up the Quickdraw name
|
|
|
|
ATSFontFamilyRef atsFamily = ::ATSFontFamilyFindFromQuickDrawName(qdname);
|
|
|
|
if (atsFamily == (ATSFontFamilyRef)kInvalidFontFamily) {
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
// if we found a family, get its ATS name
|
|
|
|
CFStringRef cfName;
|
|
|
|
OSStatus status = ::ATSFontFamilyGetName(atsFamily, kATSOptionFlagsDefault, &cfName);
|
|
|
|
if (status != noErr) {
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
// then use this to locate the family entry and retrieve its localized name
|
|
|
|
nsAutoString familyName;
|
|
|
|
GetStringForNSString((const NSString*)cfName, familyName);
|
|
|
|
::CFRelease(cfName);
|
|
|
|
|
|
|
|
family = FindFamily(familyName);
|
|
|
|
if (family) {
|
2009-09-28 03:25:22 -07:00
|
|
|
family->LocalizedName(aFamilyName);
|
2009-08-16 06:52:12 -07:00
|
|
|
return PR_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return PR_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gfxMacPlatformFontList::ATSNotification(ATSFontNotificationInfoRef aInfo,
|
|
|
|
void* aUserArg)
|
|
|
|
{
|
|
|
|
// xxx - should be carefully pruning the list of fonts, not rebuilding it from scratch
|
|
|
|
gfxMacPlatformFontList *qfc = (gfxMacPlatformFontList*)aUserArg;
|
|
|
|
qfc->UpdateFontList();
|
|
|
|
}
|
|
|
|
|
|
|
|
gfxFontEntry*
|
|
|
|
gfxMacPlatformFontList::GetDefaultFont(const gfxFontStyle* aStyle, PRBool& aNeedsBold)
|
|
|
|
{
|
2010-03-09 08:37:56 -08:00
|
|
|
nsAutoreleasePool localPool;
|
|
|
|
|
2009-08-16 06:52:12 -07:00
|
|
|
NSString *defaultFamily = [[NSFont userFontOfSize:aStyle->size] familyName];
|
|
|
|
nsAutoString familyName;
|
|
|
|
|
|
|
|
GetStringForNSString(defaultFamily, familyName);
|
|
|
|
return FindFontForFamily(familyName, aStyle, aNeedsBold);
|
|
|
|
}
|
|
|
|
|
2009-10-12 16:43:43 -07:00
|
|
|
PRInt32
|
2009-08-16 06:52:12 -07:00
|
|
|
gfxMacPlatformFontList::AppleWeightToCSSWeight(PRInt32 aAppleWeight)
|
|
|
|
{
|
|
|
|
if (aAppleWeight < 1)
|
|
|
|
aAppleWeight = 1;
|
|
|
|
else if (aAppleWeight > kAppleMaxWeight)
|
|
|
|
aAppleWeight = kAppleMaxWeight;
|
|
|
|
return gAppleWeightToCSSWeight[aAppleWeight];
|
|
|
|
}
|
|
|
|
|
2009-10-12 16:43:43 -07:00
|
|
|
gfxFontEntry*
|
2009-08-16 06:52:12 -07:00
|
|
|
gfxMacPlatformFontList::LookupLocalFont(const gfxProxyFontEntry *aProxyEntry,
|
2009-10-07 07:13:40 -07:00
|
|
|
const nsAString& aFontName)
|
2009-08-16 06:52:12 -07:00
|
|
|
{
|
2010-03-09 08:37:56 -08:00
|
|
|
nsAutoreleasePool localPool;
|
|
|
|
|
2009-08-16 06:52:12 -07:00
|
|
|
NSString *faceName = GetNSStringForString(aFontName);
|
2009-10-12 16:43:43 -07:00
|
|
|
|
2009-08-16 06:52:12 -07:00
|
|
|
// first lookup a single face based on postscript name
|
2009-10-12 16:43:43 -07:00
|
|
|
ATSFontRef fontRef = ::ATSFontFindFromPostScriptName(CFStringRef(faceName),
|
2009-08-16 06:52:12 -07:00
|
|
|
kATSOptionFlagsDefault);
|
|
|
|
|
|
|
|
// if not found, lookup using full font name
|
|
|
|
if (fontRef == kInvalidFont)
|
2009-10-12 16:43:43 -07:00
|
|
|
fontRef = ::ATSFontFindFromName(CFStringRef(faceName),
|
2009-08-16 06:52:12 -07:00
|
|
|
kATSOptionFlagsDefault);
|
2009-10-12 16:43:43 -07:00
|
|
|
|
|
|
|
// not found
|
2009-08-16 06:52:12 -07:00
|
|
|
if (fontRef == kInvalidFont)
|
|
|
|
return nsnull;
|
|
|
|
|
|
|
|
MacOSFontEntry *newFontEntry;
|
|
|
|
if (aProxyEntry) {
|
|
|
|
PRUint16 w = aProxyEntry->mWeight;
|
|
|
|
NS_ASSERTION(w >= 100 && w <= 900, "bogus font weight value!");
|
|
|
|
|
|
|
|
newFontEntry =
|
|
|
|
new MacOSFontEntry(aFontName, fontRef,
|
2009-10-12 16:43:43 -07:00
|
|
|
w, aProxyEntry->mStretch,
|
2009-08-16 06:52:12 -07:00
|
|
|
aProxyEntry->mItalic ?
|
|
|
|
FONT_STYLE_ITALIC : FONT_STYLE_NORMAL,
|
|
|
|
nsnull);
|
|
|
|
} else {
|
|
|
|
newFontEntry =
|
|
|
|
new MacOSFontEntry(aFontName, fontRef,
|
|
|
|
400, 0, FONT_STYLE_NORMAL, nsnull);
|
|
|
|
}
|
|
|
|
|
|
|
|
return newFontEntry;
|
|
|
|
}
|
|
|
|
|
|
|
|
// grumble, another non-publised Apple API dependency (found in Webkit code)
|
|
|
|
// activated with this value, font will not be found via system lookup routines
|
|
|
|
// it can only be used via the created ATSFontRef
|
|
|
|
// needed to prevent one doc from finding a font used in a separate doc
|
|
|
|
|
|
|
|
enum {
|
|
|
|
kPrivateATSFontContextPrivate = 3
|
|
|
|
};
|
|
|
|
|
|
|
|
class MacOSUserFontData : public gfxUserFontData {
|
|
|
|
public:
|
|
|
|
MacOSUserFontData(ATSFontContainerRef aContainerRef)
|
|
|
|
: mContainerRef(aContainerRef)
|
|
|
|
{ }
|
|
|
|
|
|
|
|
virtual ~MacOSUserFontData()
|
|
|
|
{
|
|
|
|
// deactivate font
|
|
|
|
if (mContainerRef)
|
|
|
|
::ATSFontDeactivate(mContainerRef, NULL, kATSOptionFlagsDefault);
|
|
|
|
}
|
|
|
|
|
|
|
|
ATSFontContainerRef mContainerRef;
|
|
|
|
};
|
|
|
|
|
2009-10-12 16:43:43 -07:00
|
|
|
gfxFontEntry*
|
2009-10-07 07:13:40 -07:00
|
|
|
gfxMacPlatformFontList::MakePlatformFont(const gfxProxyFontEntry *aProxyEntry,
|
2009-08-30 06:55:24 -07:00
|
|
|
const PRUint8 *aFontData,
|
|
|
|
PRUint32 aLength)
|
2009-08-16 06:52:12 -07:00
|
|
|
{
|
|
|
|
OSStatus err;
|
2009-10-12 16:43:43 -07:00
|
|
|
|
2009-08-30 06:55:24 -07:00
|
|
|
NS_ASSERTION(aFontData, "MakePlatformFont called with null data");
|
2009-08-16 06:52:12 -07:00
|
|
|
|
2009-10-07 07:13:40 -07:00
|
|
|
// MakePlatformFont is responsible for deleting the font data with NS_Free
|
|
|
|
// so we set up a stack object to ensure it is freed even if we take an
|
|
|
|
// early exit
|
|
|
|
struct FontDataDeleter {
|
|
|
|
FontDataDeleter(const PRUint8 *aFontData)
|
|
|
|
: mFontData(aFontData) { }
|
|
|
|
~FontDataDeleter() { NS_Free((void*)mFontData); }
|
|
|
|
const PRUint8 *mFontData;
|
|
|
|
};
|
|
|
|
FontDataDeleter autoDelete(aFontData);
|
|
|
|
|
2009-08-16 06:52:12 -07:00
|
|
|
ATSFontRef fontRef;
|
|
|
|
ATSFontContainerRef containerRef;
|
|
|
|
|
|
|
|
// we get occasional failures when multiple fonts are activated in quick succession
|
|
|
|
// if the ATS font cache is damaged; to work around this, we can retry the activation
|
|
|
|
const PRUint32 kMaxRetries = 3;
|
|
|
|
PRUint32 retryCount = 0;
|
|
|
|
while (retryCount++ < kMaxRetries) {
|
2009-08-30 06:55:24 -07:00
|
|
|
err = ::ATSFontActivateFromMemory(const_cast<PRUint8*>(aFontData), aLength,
|
2009-08-16 06:52:12 -07:00
|
|
|
kPrivateATSFontContextPrivate,
|
|
|
|
kATSFontFormatUnspecified,
|
2009-10-12 16:43:43 -07:00
|
|
|
NULL,
|
|
|
|
kATSOptionFlagsDoNotNotify,
|
2009-08-16 06:52:12 -07:00
|
|
|
&containerRef);
|
|
|
|
mATSGeneration = ::ATSGetGeneration();
|
|
|
|
|
|
|
|
if (err != noErr) {
|
|
|
|
#if DEBUG
|
|
|
|
char warnBuf[1024];
|
|
|
|
sprintf(warnBuf, "downloaded font error, ATSFontActivateFromMemory err: %d for (%s)",
|
|
|
|
PRInt32(err),
|
2009-10-07 07:13:40 -07:00
|
|
|
NS_ConvertUTF16toUTF8(aProxyEntry->mFamily->Name()).get());
|
2009-08-16 06:52:12 -07:00
|
|
|
NS_WARNING(warnBuf);
|
2009-10-12 16:43:43 -07:00
|
|
|
#endif
|
2009-08-16 06:52:12 -07:00
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ignoring containers with multiple fonts, use the first face only for now
|
2009-10-12 16:43:43 -07:00
|
|
|
err = ::ATSFontFindFromContainer(containerRef, kATSOptionFlagsDefault, 1,
|
2009-08-16 06:52:12 -07:00
|
|
|
&fontRef, NULL);
|
|
|
|
if (err != noErr) {
|
|
|
|
#if DEBUG
|
|
|
|
char warnBuf[1024];
|
|
|
|
sprintf(warnBuf, "downloaded font error, ATSFontFindFromContainer err: %d for (%s)",
|
|
|
|
PRInt32(err),
|
2009-10-07 07:13:40 -07:00
|
|
|
NS_ConvertUTF16toUTF8(aProxyEntry->mFamily->Name()).get());
|
2009-08-16 06:52:12 -07:00
|
|
|
NS_WARNING(warnBuf);
|
2009-10-12 16:43:43 -07:00
|
|
|
#endif
|
2009-08-16 06:52:12 -07:00
|
|
|
::ATSFontDeactivate(containerRef, NULL, kATSOptionFlagsDefault);
|
|
|
|
return nsnull;
|
|
|
|
}
|
2009-10-12 16:43:43 -07:00
|
|
|
|
2009-08-16 06:52:12 -07:00
|
|
|
// now lookup the Postscript name; this may fail if the font cache is bad
|
|
|
|
OSStatus err;
|
|
|
|
NSString *psname = NULL;
|
|
|
|
err = ::ATSFontGetPostScriptName(fontRef, kATSOptionFlagsDefault, (CFStringRef*) (&psname));
|
|
|
|
if (err == noErr) {
|
|
|
|
[psname release];
|
|
|
|
} else {
|
|
|
|
#ifdef DEBUG
|
|
|
|
char warnBuf[1024];
|
|
|
|
sprintf(warnBuf, "ATSFontGetPostScriptName err = %d for (%s), retries = %d", (PRInt32)err,
|
2009-10-07 07:13:40 -07:00
|
|
|
NS_ConvertUTF16toUTF8(aProxyEntry->mFamily->Name()).get(), retryCount);
|
2009-08-16 06:52:12 -07:00
|
|
|
NS_WARNING(warnBuf);
|
|
|
|
#endif
|
|
|
|
::ATSFontDeactivate(containerRef, NULL, kATSOptionFlagsDefault);
|
|
|
|
// retry the activation a couple of times if this fails
|
|
|
|
// (may be a transient failure due to ATS font cache issues)
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// font entry will own this
|
|
|
|
MacOSUserFontData *userFontData = new MacOSUserFontData(containerRef);
|
|
|
|
|
|
|
|
if (!userFontData) {
|
|
|
|
::ATSFontDeactivate(containerRef, NULL, kATSOptionFlagsDefault);
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
|
|
|
PRUint16 w = aProxyEntry->mWeight;
|
|
|
|
NS_ASSERTION(w >= 100 && w <= 900, "bogus font weight value!");
|
|
|
|
|
|
|
|
// create the font entry
|
|
|
|
nsAutoString uniqueName;
|
|
|
|
|
|
|
|
nsresult rv = gfxFontUtils::MakeUniqueUserFontName(uniqueName);
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
delete userFontData;
|
|
|
|
return nsnull;
|
|
|
|
}
|
2009-10-12 16:43:43 -07:00
|
|
|
|
|
|
|
MacOSFontEntry *newFontEntry =
|
2009-08-16 06:52:12 -07:00
|
|
|
new MacOSFontEntry(uniqueName,
|
|
|
|
fontRef,
|
2009-10-12 16:43:43 -07:00
|
|
|
w, aProxyEntry->mStretch,
|
2009-08-16 06:52:12 -07:00
|
|
|
aProxyEntry->mItalic ?
|
2009-10-12 16:43:43 -07:00
|
|
|
FONT_STYLE_ITALIC : FONT_STYLE_NORMAL,
|
2009-08-16 06:52:12 -07:00
|
|
|
userFontData);
|
|
|
|
|
|
|
|
if (!newFontEntry) {
|
|
|
|
delete userFontData;
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|
2009-09-17 17:45:29 -07:00
|
|
|
// if succeeded and font cmap is good, return the new font
|
|
|
|
if (newFontEntry->mIsValid && NS_SUCCEEDED(newFontEntry->ReadCMAP()))
|
2009-08-16 06:52:12 -07:00
|
|
|
return newFontEntry;
|
|
|
|
|
|
|
|
// if something is funky about this font, delete immediately
|
|
|
|
#if DEBUG
|
|
|
|
char warnBuf[1024];
|
2009-10-12 16:43:43 -07:00
|
|
|
sprintf(warnBuf, "downloaded font not loaded properly, removed face for (%s)",
|
2009-10-07 07:13:40 -07:00
|
|
|
NS_ConvertUTF16toUTF8(aProxyEntry->mFamily->Name()).get());
|
2009-08-16 06:52:12 -07:00
|
|
|
NS_WARNING(warnBuf);
|
2009-10-12 16:43:43 -07:00
|
|
|
#endif
|
2009-08-16 06:52:12 -07:00
|
|
|
delete newFontEntry;
|
|
|
|
|
|
|
|
// We don't retry from here; the ATS font cache issue would have caused failure earlier
|
|
|
|
// so if we get here, there's something else bad going on within our font data structures.
|
|
|
|
// Currently, there should be no way to reach here, as fontentry creation cannot fail
|
|
|
|
// except by memory allocation failure.
|
|
|
|
NS_WARNING("invalid font entry for a newly activated font");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// if we get here, the activation failed (even with possible retries); can't use this font
|
|
|
|
return nsnull;
|
|
|
|
}
|
|
|
|
|