CPAttributedString.j

Go to the documentation of this file.

/*
 * CPAttributedString.j
 * Foundation
 *
 * Created by Ross Boucher.
 * 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
 */


@implementation CPAttributedString : CPObject
{
    CPString    _string;
    CPArray     _rangeEntries;
}

// Creating a CPAttributedString Object
- (id)init
{
    return [self initWithString:@"" attributes:nil];
}

- (id)initWithString:(CPString)aString
{
    return [self initWithString:aString attributes:nil];
}

- (id)initWithAttributedString:(CPAttributedString)aString
{
    var string = [self initWithString:@"" attributes:nil];

    [string setAttributedString:aString];

    return string;
}

- (id)initWithString:(CPString)aString attributes:(CPDictionary)attributes
{
    self = [super init];

    if (self)
    {
        if (!attributes)
            attributes = @{};

        _string = "" + aString;
        _rangeEntries = [makeRangeEntry(CPMakeRange(0, _string.length), attributes)];
    }

    return self;
}

//Retrieving Character Information
- (CPString)string
{
    return _string;
}

- (CPString)mutableString
{
    return [self string];
}

- (unsigned)length
{
    return _string.length;
}

// private method
- (unsigned)_indexOfEntryWithIndex:(unsigned)anIndex
{
    if (anIndex < 0 || anIndex > _string.length || anIndex === undefined)
        return CPNotFound;

    // find the range entry that contains anIndex.
    var sortFunction = function(index, entry)
    {
        // index is the character index we're searching for,
        // while range is the actual range entry we're comparing against
        if (CPLocationInRange(index, entry.range) || (!index && !CPMaxRange(entry.range)))
            return CPOrderedSame;
        else if (CPMaxRange(entry.range) <= index)
            return CPOrderedDescending;
        else
            return CPOrderedAscending;
    };

    return [_rangeEntries indexOfObject:anIndex inSortedRange:nil options:0 usingComparator:sortFunction];
}

//Retrieving Attribute Information
- (CPDictionary)attributesAtIndex:(CPUInteger)anIndex effectiveRange:(CPRangePointer)aRange
{
    // find the range entry that contains anIndex.
    var entryIndex = [self _indexOfEntryWithIndex:anIndex];

    if (entryIndex === CPNotFound)
        return @{};

    var matchingRange = _rangeEntries[entryIndex];

    if (aRange)
    {
        aRange.location = matchingRange.range.location;
        aRange.length = matchingRange.range.length;
    }

    return matchingRange.attributes;
}

- (CPDictionary)attributesAtIndex:(CPUInteger)anIndex longestEffectiveRange:(CPRangePointer)aRange inRange:(CPRange)rangeLimit
{
    var startingEntryIndex = [self _indexOfEntryWithIndex:anIndex];

    if (startingEntryIndex === CPNotFound)
        return @{};

    if (!aRange)
        return _rangeEntries[startingEntryIndex].attributes;

    if (CPRangeInRange(_rangeEntries[startingEntryIndex].range, rangeLimit))
    {
        aRange.location = rangeLimit.location;
        aRange.length = rangeLimit.length;

        return _rangeEntries[startingEntryIndex].attributes;
    }

    // scan backwards
    var nextRangeIndex = startingEntryIndex - 1,
        currentEntry = _rangeEntries[startingEntryIndex],
        comparisonDict = currentEntry.attributes;

    while (nextRangeIndex >= 0)
    {
        var nextEntry = _rangeEntries[nextRangeIndex];

        if (CPMaxRange(nextEntry.range) > rangeLimit.location && [nextEntry.attributes isEqualToDictionary:comparisonDict])
        {
            currentEntry = nextEntry;
            nextRangeIndex--;
        }
        else
            break;
    }

    aRange.location = MAX(currentEntry.range.location, rangeLimit.location);

    // scan forwards
    currentEntry = _rangeEntries[startingEntryIndex];
    nextRangeIndex = startingEntryIndex + 1;

    while (nextRangeIndex < _rangeEntries.length)
    {
        var nextEntry = _rangeEntries[nextRangeIndex];

        if (nextEntry.range.location < CPMaxRange(rangeLimit) && [nextEntry.attributes isEqualToDictionary:comparisonDict])
        {
            currentEntry = nextEntry;
            nextRangeIndex++;
        }
        else
            break;
    }

    aRange.length = MIN(CPMaxRange(currentEntry.range), CPMaxRange(rangeLimit)) - aRange.location;

    return comparisonDict;
}

- (id)attribute:(CPString)attribute atIndex:(CPUInteger)index effectiveRange:(CPRangePointer)aRange
{
    if (!attribute)
    {
        if (aRange)
        {
            aRange.location = 0;
            aRange.length = _string.length;
        }

        return nil;
    }

    return [[self attributesAtIndex:index effectiveRange:aRange] valueForKey:attribute];
}

- (id)attribute:(CPString)attribute atIndex:(CPUInteger)anIndex longestEffectiveRange:(CPRangePointer)aRange inRange:(CPRange)rangeLimit
{
    var startingEntryIndex = [self _indexOfEntryWithIndex:anIndex];

    if (startingEntryIndex === CPNotFound || !attribute)
        return nil;

    if (!aRange)
        return [_rangeEntries[startingEntryIndex].attributes objectForKey:attribute];

    if (CPRangeInRange(_rangeEntries[startingEntryIndex].range, rangeLimit))
    {
        aRange.location = rangeLimit.location;
        aRange.length = rangeLimit.length;

        return [_rangeEntries[startingEntryIndex].attributes objectForKey:attribute];
    }

    // scan backwards
    var nextRangeIndex = startingEntryIndex - 1,
        currentEntry = _rangeEntries[startingEntryIndex],
        comparisonAttribute = [currentEntry.attributes objectForKey:attribute];

    while (nextRangeIndex >= 0)
    {
        var nextEntry = _rangeEntries[nextRangeIndex];

        if (CPMaxRange(nextEntry.range) > rangeLimit.location && isEqual(comparisonAttribute, [nextEntry.attributes objectForKey:attribute]))
        {
            currentEntry = nextEntry;
            nextRangeIndex--;
        }
        else
            break;
    }

    aRange.location = MAX(currentEntry.range.location, rangeLimit.location);

    // scan forwards
    currentEntry = _rangeEntries[startingEntryIndex];
    nextRangeIndex = startingEntryIndex + 1;

    while (nextRangeIndex < _rangeEntries.length)
    {
        var nextEntry = _rangeEntries[nextRangeIndex];

        if (nextEntry.range.location < CPMaxRange(rangeLimit) && isEqual(comparisonAttribute, [nextEntry.attributes objectForKey:attribute]))
        {
            currentEntry = nextEntry;
            nextRangeIndex++;
        }
        else
            break;
    }

    aRange.length = MIN(CPMaxRange(currentEntry.range), CPMaxRange(rangeLimit)) - aRange.location;

    return comparisonAttribute;
}

//Comparing Attributed Strings
- (BOOL)isEqualToAttributedString:(CPAttributedString)aString
{
    if (!aString)
        return NO;

    if (_string !== [aString string])
        return NO;

    var myRange = CPMakeRange(),
        comparisonRange = CPMakeRange(),
        myAttributes = [self attributesAtIndex:0 effectiveRange:myRange],
        comparisonAttributes = [aString attributesAtIndex:0 effectiveRange:comparisonRange],
        length = _string.length;

    do
    {
        if (CPIntersectionRange(myRange, comparisonRange).length > 0 &&
            ![myAttributes isEqualToDictionary:comparisonAttributes])
        {
            return NO;
        }
        else if (CPMaxRange(myRange) < CPMaxRange(comparisonRange))
            myAttributes = [self attributesAtIndex:CPMaxRange(myRange) effectiveRange:myRange];
        else
            comparisonAttributes = [aString attributesAtIndex:CPMaxRange(comparisonRange) effectiveRange:comparisonRange];
    } while (CPMaxRange(CPUnionRange(myRange, comparisonRange)) < length);

    return YES;
}

- (BOOL)isEqual:(id)anObject
{
    if (anObject === self)
        return YES;

    if ([anObject isKindOfClass:[self class]])
        return [self isEqualToAttributedString:anObject];

    return NO;
}

//Extracting a Substring
- (CPAttributedString)attributedSubstringFromRange:(CPRange)aRange
{
    if (!aRange || CPMaxRange(aRange) > _string.length || aRange.location < 0)
        [CPException raise:CPRangeException
                    reason:"tried to get attributedSubstring for an invalid range: "+(aRange?CPStringFromRange(aRange):"nil")];

    var newString = [[CPAttributedString alloc] initWithString:_string.substring(aRange.location, CPMaxRange(aRange))],
        entryIndex = [self _indexOfEntryWithIndex:aRange.location];

    if (entryIndex === CPNotFound)
        _CPRaiseRangeException(self, _cmd, aRange.location, _string.length);

    var currentRangeEntry = _rangeEntries[entryIndex],
        lastIndex = CPMaxRange(aRange);

    newString._rangeEntries = [];

    while (currentRangeEntry && CPMaxRange(currentRangeEntry.range) < lastIndex)
    {
        var newEntry = copyRangeEntry(currentRangeEntry);
        newEntry.range.location -= aRange.location;

        if (newEntry.range.location < 0)
        {
            newEntry.range.length += newEntry.range.location;
            newEntry.range.location = 0;
        }

        newString._rangeEntries.push(newEntry);
        currentRangeEntry = _rangeEntries[++entryIndex];
    }

    if (currentRangeEntry)
    {
        var newRangeEntry = copyRangeEntry(currentRangeEntry);

        newRangeEntry.range.length = CPMaxRange(aRange) - newRangeEntry.range.location;
        newRangeEntry.range.location -= aRange.location;

        if (newRangeEntry.range.location < 0)
        {
            newRangeEntry.range.length += newRangeEntry.range.location;
            newRangeEntry.range.location = 0;
        }

        newString._rangeEntries.push(newRangeEntry);
    }

    return newString;
}

//Changing Characters
- (void)replaceCharactersInRange:(CPRange)aRange withString:(CPString)aString
{
    if (!aString)
        aString = @"";

    var lastValidIndex = MAX(_rangeEntries.length - 1, 0),
        startingIndex = [self _indexOfEntryWithIndex:aRange.location];

    if (startingIndex < 0)
        startingIndex = lastValidIndex;

    var endingIndex = [self _indexOfEntryWithIndex:CPMaxRange(aRange)];

    if (endingIndex < 0)
        endingIndex = lastValidIndex;

    var additionalLength = aString.length - aRange.length,
        patchPosition = startingIndex;

    _string = _string.substring(0, aRange.location) + aString + _string.substring(CPMaxRange(aRange));
    var originalLength = _rangeEntries[patchPosition].range.length;

    if (startingIndex === endingIndex)
        _rangeEntries[patchPosition].range.length += additionalLength;
    else
    {
        if (CPIntersectionRange(_rangeEntries[patchPosition].range, aRange).length < originalLength)
        {
            startingIndex++;
        }

        if (endingIndex > startingIndex)
        {
            var originalOffset= _rangeEntries[startingIndex].range.location,
                offsetFromSplicing = CPMaxRange(_rangeEntries[endingIndex].range) - originalOffset;
            _rangeEntries.splice(startingIndex, endingIndex - startingIndex);
            _rangeEntries[startingIndex].range = CPMakeRange(originalOffset, offsetFromSplicing);
        }

        if (patchPosition !== startingIndex)
        {
            var lhsOffset = aString.length - CPIntersectionRange(_rangeEntries[patchPosition].range, aRange).length;
            _rangeEntries[patchPosition].range.length = originalLength + lhsOffset;
            var rhsOffset = aString.length - CPIntersectionRange(_rangeEntries[startingIndex].range, aRange).length;
            _rangeEntries[startingIndex].range.location += lhsOffset;
            _rangeEntries[startingIndex].range.length += rhsOffset;
            patchPosition = startingIndex;
        } else
            _rangeEntries[patchPosition].range.length += additionalLength;
    }

    for (var patchIndex = patchPosition + 1, l = _rangeEntries.length; patchIndex < l; patchIndex++)
        _rangeEntries[patchIndex].range.location += additionalLength;
}

- (void)deleteCharactersInRange:(CPRange)aRange
{
    [self replaceCharactersInRange:aRange withString:nil];
}

//Changing Attributes
- (void)setAttributes:(CPDictionary)aDictionary range:(CPRange)aRange
{
    var startingEntryIndex = [self _indexOfRangeEntryForIndex:aRange.location splitOnMaxIndex:YES],
        endingEntryIndex = [self _indexOfRangeEntryForIndex:CPMaxRange(aRange) splitOnMaxIndex:YES],
        current = startingEntryIndex;

    if (current < 0)
        current = MAX(_rangeEntries.length - 1, 0);

    if (endingEntryIndex === CPNotFound)
        endingEntryIndex = _rangeEntries.length;

    while (current < endingEntryIndex)
        _rangeEntries[current++].attributes = [aDictionary copy];

    //necessary?
    [self _coalesceRangeEntriesFromIndex:startingEntryIndex toIndex:endingEntryIndex];
}

- (void)addAttributes:(CPDictionary)aDictionary range:(CPRange)aRange
{
    var startingEntryIndex = [self _indexOfRangeEntryForIndex:aRange.location splitOnMaxIndex:YES],
        endingEntryIndex = [self _indexOfRangeEntryForIndex:CPMaxRange(aRange) splitOnMaxIndex:YES],
        current = startingEntryIndex;

    if (endingEntryIndex === CPNotFound)
        endingEntryIndex = _rangeEntries.length;

    while (current < endingEntryIndex)
    {
        var keys = [aDictionary allKeys],
            count = [keys count];

        while (count--)
            [_rangeEntries[current].attributes setObject:[aDictionary objectForKey:keys[count]] forKey:keys[count]];

        current++;
    }

    //necessary?
    [self _coalesceRangeEntriesFromIndex:startingEntryIndex toIndex:endingEntryIndex];
}

- (void)addAttribute:(CPString)anAttribute value:(id)aValue range:(CPRange)aRange
{
    [self addAttributes:@{ anAttribute: aValue } range:aRange];
}

- (void)removeAttribute:(CPString)anAttribute range:(CPRange)aRange
{
    var startingEntryIndex = [self _indexOfRangeEntryForIndex:aRange.location splitOnMaxIndex:YES],
        endingEntryIndex = [self _indexOfRangeEntryForIndex:CPMaxRange(aRange) splitOnMaxIndex:YES],
        current = startingEntryIndex;

    if (endingEntryIndex === CPNotFound)
        endingEntryIndex = _rangeEntries.length;

    while (current < endingEntryIndex)
        [_rangeEntries[current++].attributes removeObjectForKey:anAttribute];

    //necessary?
    [self _coalesceRangeEntriesFromIndex:startingEntryIndex toIndex:endingEntryIndex];
}

//Changing Characters and Attributes
- (void)appendAttributedString:(CPAttributedString)aString
{
    [self insertAttributedString:aString atIndex:_string.length];
}

- (void)insertAttributedString:(CPAttributedString)aString atIndex:(CPUInteger)anIndex
{
    if (anIndex < 0 || anIndex > [self length])
        [CPException raise:CPRangeException reason:"tried to insert attributed string at an invalid index: " + anIndex];

    var entryIndexOfNextEntry = [self _indexOfRangeEntryForIndex:anIndex splitOnMaxIndex:YES],
        otherRangeEntries = aString._rangeEntries,
        length = [aString length];

    if (entryIndexOfNextEntry === CPNotFound)
        entryIndexOfNextEntry = _rangeEntries.length;

    _string = _string.substring(0, anIndex) + aString._string + _string.substring(anIndex);

    var current = entryIndexOfNextEntry;
    while (current < _rangeEntries.length)
        _rangeEntries[current++].range.location += length;

    var newRangeEntryCount = otherRangeEntries.length,
        index = 0;

    while (index < newRangeEntryCount)
    {
        var entryCopy = copyRangeEntry(otherRangeEntries[index++]);
        entryCopy.range.location += anIndex;

        _rangeEntries.splice(entryIndexOfNextEntry - 1 + index, 0, entryCopy);
    }

    [self _coalesceRangeEntriesFromIndex:MAX(0, entryIndexOfNextEntry - 1) toIndex:MIN(entryIndexOfNextEntry + 1, _rangeEntries.length - 1)];
}

- (void)replaceCharactersInRange:(CPRange)aRange withAttributedString:(CPAttributedString)aString
{
    [self deleteCharactersInRange:aRange];
    [self insertAttributedString:aString atIndex:aRange.location];
}

- (void)setAttributedString:(CPAttributedString)aString
{
    _string = aString._string;
    _rangeEntries = [aString._rangeEntries arrayByApplyingBlock:function(entry)
    {
        return copyRangeEntry(entry);
    }];
}

//Private methods
- (Number)_indexOfRangeEntryForIndex:(unsigned)characterIndex splitOnMaxIndex:(BOOL)split
{
    var index = [self _indexOfEntryWithIndex:characterIndex];

    if (index === CPNotFound)
        return index;

    var rangeEntry = _rangeEntries[index];

    if (rangeEntry.range.location === characterIndex || (CPMaxRange(rangeEntry.range) - 1 === characterIndex && !split))
        return index;

    var newEntries = splitRangeEntryAtIndex(rangeEntry, characterIndex);
    _rangeEntries.splice(index, 1, newEntries[0], newEntries[1]);
    index++;

    return index;
}

- (void)_coalesceRangeEntriesFromIndex:(unsigned)start toIndex:(unsigned)end
{
    var current = start;

    if (end >= _rangeEntries.length)
        end = _rangeEntries.length - 1;

    while (current < end)
    {
        var a = _rangeEntries[current],
            b = _rangeEntries[current + 1];

        if (a && b && [a.attributes isEqualToDictionary:b.attributes])
        {
            a.range.length = CPMaxRange(b.range) - a.range.location;
            _rangeEntries.splice(current + 1, 1);
            end--;
        }
        else
            current++;
    }
}

//Grouping Changes
- (void)beginEditing
{
    //do nothing (says cocotron and gnustep)
}

- (void)endEditing
{
    //do nothing (says cocotron and gnustep)
}

@end

var CPAttributedStringStringKey     = "CPAttributedStringString",
    CPAttributedStringRangesKey     = "CPAttributedStringRanges",
    CPAttributedStringAttributesKey = "CPAttributedStringAttributes";

@implementation CPAttributedString (CPCoding)

- (id)initWithCoder:(CPCoder)aCoder
{
    self = [self init];

    if (self)
    {
        _string = [aCoder decodeObjectForKey:CPAttributedStringStringKey];
        var decodedRanges = [aCoder decodeObjectForKey:CPAttributedStringRangesKey],
            decodedAttributes = [aCoder decodeObjectForKey:CPAttributedStringAttributesKey];

        _rangeEntries = [];

        for (var i = 0, l = decodedRanges.length; i < l; i++)
            _rangeEntries.push(makeRangeEntry(decodedRanges[i], decodedAttributes[i]));
    }

    return self;
}

- (void)encodeWithCoder:(CPCoder)aCoder
{
    [aCoder encodeObject:_string forKey:CPAttributedStringStringKey];

    var rangesForEncoding = [],
        dictsForEncoding = [];

    for (var i = 0, l = _rangeEntries.length; i < l; i++)
    {
        rangesForEncoding.push(_rangeEntries[i].range);
        dictsForEncoding.push(_rangeEntries[i].attributes);
    }

    [aCoder encodeObject:rangesForEncoding forKey:CPAttributedStringRangesKey];
    [aCoder encodeObject:dictsForEncoding forKey:CPAttributedStringAttributesKey];
}

@end

@implementation CPMutableAttributedString : CPAttributedString
{
    id __doxygen__;
}

@end

var isEqual = function(a, b)
{
    if (a === b)
        return YES;

    if ([a respondsToSelector:@selector(isEqual:)] && [a isEqual:b])
        return YES;

    return NO;
};

var makeRangeEntry = function(/*CPRange*/aRange, /*CPDictionary*/attributes)
{
    return {range:aRange, attributes:[attributes copy]};
};

var copyRangeEntry = function(/*RangeEntry*/aRangeEntry)
{
    return makeRangeEntry(CPMakeRangeCopy(aRangeEntry.range), [aRangeEntry.attributes copy]);
};

var splitRangeEntryAtIndex = function(/*RangeEntry*/aRangeEntry, /*unsigned*/anIndex)
{
    var newRangeEntry = copyRangeEntry(aRangeEntry),
        cachedIndex = CPMaxRange(aRangeEntry.range);

    aRangeEntry.range.length = anIndex - aRangeEntry.range.location;
    newRangeEntry.range.location = anIndex;
    newRangeEntry.range.length = cachedIndex - anIndex;
    newRangeEntry.attributes = [newRangeEntry.attributes copy];

    return [aRangeEntry, newRangeEntry];
};