CPFont.j

Go to the documentation of this file.

/*
 * CPFont.j
 * AppKit
 *
 * Created by Francisco Tolmasky.
 * Copyright 2008, 280 North, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */



CPFontDefaultSystemFontFace = @"Arial, sans-serif";
CPFontDefaultSystemFontSize = 12;

CPFontCurrentSystemSize = -1;

// For internal use only by this class and subclasses
_CPFontSystemFacePlaceholder = "_CPFontSystemFacePlaceholder";

var _CPFontCache          = {},
    _CPSystemFontCache    = {},
    _CPFontSystemFontFace = CPFontDefaultSystemFontFace,
    _CPFontSystemFontSize = 12,
    _CPFontFallbackFaces  = CPFontDefaultSystemFontFace.split(", "),
    _CPFontStripRegExp    = new RegExp("(^\\s*[\"']?|[\"']?\\s*$)", "g");


#define _CPRealFontSize(aSize)  (aSize <= 0 ? _CPFontSystemFontSize : aSize)
#define _CPFontNormalizedNames(aName)  _CPFontNormalizedNameArray(aName).join(", ")
#define _CPCachedFont(aName, aSize, isBold, isItalic)  _CPFontCache[_CPFontCreateCSSString(_CPFontNormalizedNames(aName), aSize, isBold, isItalic)]
#define _CPUserFont(aName, aSize, isBold, isItalic)  _CPCachedFont(aName, aSize, isBold, isItalic) || [[CPFont alloc] _initWithName:aName size:aSize bold:isBold italic:isItalic system:NO]

#define _CPSystemFontCacheKey(aSize, isBold)  (String(aSize) + (isBold ? "b" : ""))
#define _CPCachedSystemFont(aSize, isBold)  _CPSystemFontCache[_CPSystemFontCacheKey(aSize, isBold)]
#define _CPSystemFont(aSize, isBold)  (_CPCachedSystemFont(aSize, isBold) || [[CPFont alloc] _initWithName:_CPFontSystemFacePlaceholder size:aSize bold:isBold italic:NO system:YES])

@implementation CPFont : CPObject
{
    CPString    _name;
    float       _size;
    float       _ascender;
    float       _descender;
    float       _lineHeight;
    BOOL        _isBold;
    BOOL        _isItalic;
    BOOL        _isSystem;

    CPString    _cssString;
}

+ (void)initialize
{
    if (self !== [CPFont class])
        return;

    var systemFontFace = [[CPBundle mainBundle] objectForInfoDictionaryKey:@"CPSystemFontFace"];

    if (!systemFontFace)
        systemFontFace = [[CPBundle bundleForClass:[CPView class]] objectForInfoDictionaryKey:@"CPSystemFontFace"];

    if (systemFontFace)
        _CPFontSystemFontFace = _CPFontNormalizedNames(systemFontFace);

    var systemFontSize = [[CPBundle mainBundle] objectForInfoDictionaryKey:@"CPSystemFontSize"];

    if (!systemFontSize)
        systemFontSize = [[CPBundle bundleForClass:[CPView class]] objectForInfoDictionaryKey:@"CPSystemFontSize"];

    if (systemFontSize)
        _CPFontSystemFontSize = systemFontSize;
}

+ (CPString)systemFontFace
{
    return _CPFontSystemFontFace;
}

+ (CPString)setSystemFontFace:(CPString)aFace
{
    var normalizedFaces = _CPFontNormalizedNames(aFace);

    if (normalizedFaces === _CPFontSystemFontFace)
        return;

    [self _invalidateSystemFontCache];
    _CPFontSystemFontFace = aFace;
}

+ (float)systemFontSize
{
    return _CPFontSystemFontSize;
}

+ (CPFont)systemFontForControlSize:(CPControlSize)aSize
{
    // TODO These sizes should be themable or made less arbitrary in some other way.
    switch (aSize)
    {
        case CPSmallControlSize:
            return [self systemFontOfSize:_CPFontSystemFontSize - 1];

        case CPMiniControlSize:
            return [self systemFontOfSize:_CPFontSystemFontSize - 2];

        case CPRegularControlSize:
        default:
            return [self systemFontOfSize:_CPFontSystemFontSize];
    }
}

+ (float)setSystemFontSize:(float)size
{
    if (size > 0 && size !== _CPFontSystemFontSize)
    {
        [self _invalidateSystemFontCache];
        _CPFontSystemFontSize = size;
    }
}

+ (void)_invalidateSystemFontCache
{
    var systemSize = String(_CPFontSystemFontSize),
        currentSize = String(CPFontCurrentSystemSize);

    for (var key in _CPSystemFontCache)
    {
        if (_CPSystemFontCache.hasOwnProperty(key) &&
            (key.indexOf(systemSize) === 0 || key.indexOf(currentSize) === 0))
        {
            delete _CPSystemFontCache[key];
        }
    }
}

+ (CPFont)fontWithName:(CPString)aName size:(float)aSize
{
    return _CPUserFont(aName, aSize <= 0 ? _CPFontSystemFontSize : aSize, NO, NO);
}

+ (CPFont)fontWithName:(CPString)aName size:(float)aSize italic:(BOOL)italic
{
    return _CPUserFont(aName, aSize <= 0 ? _CPFontSystemFontSize : aSize, NO, italic);
}

+ (CPFont)boldFontWithName:(CPString)aName size:(float)aSize
{
    return _CPUserFont(aName, aSize <= 0 ? _CPFontSystemFontSize : aSize, YES, NO);
}

+ (CPFont)boldFontWithName:(CPString)aName size:(float)aSize italic:(BOOL)italic
{
    return _CPUserFont(aName, aSize <= 0 ? _CPFontSystemFontSize : aSize, YES, italic);
}

+ (CPFont)_fontWithName:(CPString)aName size:(float)aSize bold:(BOOL)bold italic:(BOOL)italic
{
    return _CPUserFont(aName, aSize <= 0 ? _CPFontSystemFontSize : aSize, bold, italic);
}

+ (CPFont)systemFontOfSize:(CGSize)aSize
{
    return _CPSystemFont(aSize === 0 ? _CPFontSystemFontSize : aSize, NO);
}

+ (CPFont)boldSystemFontOfSize:(CGSize)aSize
{
    return _CPSystemFont(aSize === 0 ? _CPFontSystemFontSize : aSize, YES);
}

- (id)_initWithName:(CPString)aName size:(float)aSize bold:(BOOL)isBold italic:(BOOL)isItalic system:(BOOL)isSystem
{
    self = [super init];

    if (self)
    {
        _size = aSize;
        _ascender = 0;
        _descender = 0;
        _lineHeight = 0;
        _isBold = isBold;
        _isItalic = isItalic;
        _isSystem = isSystem;

        if (isSystem)
        {
            _name = aName;
            _cssString = _CPFontCreateCSSString(_CPFontSystemFontFace, _size, _isBold, _isItalic);
            _CPSystemFontCache[_CPSystemFontCacheKey(_size, _isBold)] = self;
        }
        else
        {
            _name = _CPFontNormalizedNames(aName);
            _cssString = _CPFontCreateCSSString(_name, _size, _isBold, _isItalic);
            _CPFontCache[_cssString] = self;
        }
    }

    return self;
}

- (float)ascender
{
    var font = _isSystem ? _CPSystemFont(_size, _isBold) : self;

    if (!font._ascender)
        [font _getMetrics];

    return font._ascender;
}

- (float)descender
{
    var font = _isSystem ? _CPSystemFont(_size, _isBold) : self;

    if (!font._descender)
        [font _getMetrics];

    return font._descender;
}

- (float)defaultLineHeightForFont
{
    var font = _isSystem ? _CPSystemFont(_size, _isBold) : self;

    if (!font._lineHeight)
        [font _getMetrics];

    return font._lineHeight;
}

- (float)size
{
    return _CPRealFontSize(_size);
}

- (CPString)cssString
{
    var font = _isSystem ? _CPSystemFont(_size, _isBold) : self;

    return font._cssString;
}

- (CPString)familyName
{
    if (_isSystem)
        return _CPFontSystemFontFace;

    return _name;
}

- (BOOL)isSystemSize
{
    return _size <= 0;
}

- (BOOL)isEqual:(id)anObject
{
    return [anObject isKindOfClass:[CPFont class]] && [anObject cssString] === _cssString;
}

- (CPString)description
{
    return [CPString stringWithFormat:@"%@ %@", [super description], [self cssString]];
}

- (id)copy
{
    return [[CPFont alloc] _initWithName:_name size:_size bold:_isBold italic:_isItalic system:_isSystem];
}

- (void)_getMetrics
{
    var metrics = [CPString metricsOfFont:self];

    _ascender = [metrics objectForKey:@"ascender"];
    _descender = [metrics objectForKey:@"descender"];
    _lineHeight = [metrics objectForKey:@"lineHeight"];
}

@end

@implementation CPFont(DescriptorAdditions)

- (id)_initWithFontDescriptor:(CPFontDescriptor)fontDescriptor
{
    var aName = [fontDescriptor objectForKey: CPFontNameAttribute] ,
        aSize = [fontDescriptor pointSize],
        isBold = [fontDescriptor symbolicTraits] & CPFontBoldTrait,
        isItalic = [fontDescriptor symbolicTraits] & CPFontItalicTrait;

    return [self _initWithName:aName size:aSize bold:isBold italic:isItalic system:NO];
}

+ (CPFont)fontWithDescriptor:(CPFontDescriptor)fontDescriptor size:(float)aSize
{
    var aName = [fontDescriptor objectForKey: CPFontNameAttribute],
        isBold = [fontDescriptor symbolicTraits] & CPFontBoldTrait,
        isItalic = [fontDescriptor symbolicTraits] & CPFontItalicTrait;

    return [self _fontWithName:aName size:aSize || [fontDescriptor pointSize] bold:isBold italic:isItalic];
}

- (CPFontDescriptor)fontDescriptor
{
    var traits = 0;

    if ([self isBold])
        traits |= CPFontBoldTrait;

    if ([self isItalic])
        traits |= CPFontItalicTrait;

    return [[CPFontDescriptor fontDescriptorWithName:_name size:_size] fontDescriptorWithSymbolicTraits:traits];
}

@end


var CPFontNameKey     = @"CPFontNameKey",
    CPFontSizeKey     = @"CPFontSizeKey",
    CPFontIsBoldKey   = @"CPFontIsBoldKey",
    CPFontIsItalicKey = @"CPFontIsItalicKey",
    CPFontIsSystemKey = @"CPFontIsSystemKey";

@implementation CPFont (CPCoding)

- (id)initWithCoder:(CPCoder)aCoder
{
    var fontName = [aCoder decodeObjectForKey:CPFontNameKey],
        size = [aCoder decodeFloatForKey:CPFontSizeKey],
        isBold = [aCoder decodeBoolForKey:CPFontIsBoldKey],
        isItalic = [aCoder decodeBoolForKey:CPFontIsItalicKey],
        isSystem = [aCoder decodeBoolForKey:CPFontIsSystemKey];

    return [self _initWithName:fontName size:size bold:isBold italic:isItalic system:isSystem];
}

- (void)encodeWithCoder:(CPCoder)aCoder
{
    [aCoder encodeObject:_name forKey:CPFontNameKey];
    [aCoder encodeFloat:_size forKey:CPFontSizeKey];
    [aCoder encodeBool:_isBold forKey:CPFontIsBoldKey];
    [aCoder encodeBool:_isItalic forKey:CPFontIsItalicKey];
    [aCoder encodeBool:_isSystem forKey:CPFontIsSystemKey];
}

@end


// aName must be normalized
var _CPFontCreateCSSString = function(aName, aSize, isBold, isItalic)
{
    var properties = (isItalic ? "italic " : "") + (isBold ? "bold " : "") + _CPRealFontSize(aSize) + "px ";

    return properties + _CPFontConcatNameWithFallback(aName);
};

var _CPFontConcatNameWithFallback = function(aName)
{
    var names = _CPFontNormalizedNameArray(aName),
        fallbackFaces = _CPFontFallbackFaces.slice(0);

    // Remove the fallback names used in the names passed in
    for (var i = 0; i < names.length; ++i)
    {
        for (var j = 0; j < fallbackFaces.length; ++j)
        {
            if (names[i].toLowerCase() === fallbackFaces[j].toLowerCase())
            {
                fallbackFaces.splice(j, 1);
                break;
            }
        }

        if (names[i].indexOf(" ") > 0)
            names[i] = '"' + names[i] + '"';
    }

    return names.concat(fallbackFaces).join(", ");
};

var _CPFontNormalizedNameArray = function(aName)
{
    var names = aName.split(",");

    for (var i = 0; i < names.length; ++i)
        names[i] = names[i].replace(_CPFontStripRegExp, "");

    return names;
};

@implementation CPFont (CPSynthesizedAccessors)

- (BOOL)isBold
{
    return _isBold;
}

- (BOOL)isItalic
{
    return _isItalic;
}

- (BOOL)isSystem
{
    return _isSystem;
}

@end