//

// DTCoreTextLayoutFrame.m

// DTCoreText

//

// Created by Oliver Drobnik on 1/24/11.

// Copyright 2011 Drobnik.com. All rights reserved.

//

#import "DTCoreTextConstants.h"

#import "DTCoreTextLayouter.h"

#import "DTCoreTextLayoutLine.h"

#import "DTCoreTextLayoutFrame.h"

#import "DTCoreTextParagraphStyle.h"

#import "NSDictionary+DTCoreText.h"

#import "DTTextBlock.h"

#import "DTCoreTextFunctions.h"

#import "DTTextAttachment.h"

#import "NSString+Paragraphs.h"

#import <DTFoundation/DTLog.h>

// global flag that shows debug frames

static BOOL _DTCoreTextLayoutFramesShouldDrawDebugFrames = NO;

@implementation DTCoreTextLayoutFrame

{

CTFrameRef _textFrame;

CTFramesetterRef _framesetter;

NSRange _requestedStringRange;

NSRange _stringRange;

CGFloat _additionalPaddingAtBottom; // when last line in a text block with padding

NSInteger _numberLinesFitInFrame;

DTCoreTextLayoutFrameTextBlockHandler _textBlockHandler;

CGFloat _longestLayoutLineWidth;

}

// makes a frame for a specific part of the attributed string of the layouter

- (id)initWithFrame:(CGRect)frame layouter:(DTCoreTextLayouter *)layouter range:(NSRange)range

{

self = [super init];

if (self)

{

_frame = frame;

_attributedStringFragment = [layouter.attributedString mutableCopy];

// determine correct target range

_requestedStringRange = range;

NSUInteger stringLength = [_attributedStringFragment length];

if (_requestedStringRange.location >= stringLength)

{

return nil;

}

if (_requestedStringRange.length==0 || NSMaxRange(_requestedStringRange) > stringLength)

{

_requestedStringRange.length = stringLength - _requestedStringRange.location;

}

CFRange cfRange = CFRangeMake(_requestedStringRange.location, _requestedStringRange.length);

_framesetter = layouter.framesetter;

if (_framesetter)

{

CFRetain(_framesetter);

CGMutablePathRef path = CGPathCreateMutable();

CGPathAddRect(path, NULL, frame);

_textFrame = CTFramesetterCreateFrame(_framesetter, cfRange, path, NULL);

CGPathRelease(path);

}

else

{

// Strange, should have gotten a valid framesetter

return nil;

}

_justifyRatio = 0.6f;

}

return self;

}

// makes a frame for the entire attributed string of the layouter

- (id)initWithFrame:(CGRect)frame layouter:(DTCoreTextLayouter *)layouter

{

return [self initWithFrame:frame layouter:layouter range:NSMakeRange(0, 0)];

}

- (void)dealloc

{

if (_textFrame)

{

CFRelease(_textFrame);

}

if (_framesetter)

{

CFRelease(_framesetter);

}

}

#ifndef COVERAGE

// exclude method from coverage testing

- (NSString *)description

{

return [self.lines description];

}

#endif

#pragma mark - Positioning Lines

- (CGPoint)_algorithmLegacy_BaselineOriginToPositionLine:(DTCoreTextLayoutLine *)line afterLine:(DTCoreTextLayoutLine *)previousLine

{

CGPoint lineOrigin = previousLine.baselineOrigin;

NSInteger lineStartIndex = line.stringRange.location;

CTParagraphStyleRef lineParagraphStyle = (__bridge CTParagraphStyleRef)[_attributedStringFragment

attribute:(id)kCTParagraphStyleAttributeName

atIndex:lineStartIndex effectiveRange:NULL];

//Meet the first line in this frame

if (!previousLine)

{

// The first line may or may not be the start of paragraph. It depends on the the range passing to

// - (DTCoreTextLayoutFrame *)layoutFrameWithRect:(CGRect)frame range:(NSRange)range;

// So Check it in a safe way:

if ([self isLineFirstInParagraph:line])

{

CGFloat paraSpacingBefore = 0;

if (CTParagraphStyleGetValueForSpecifier(lineParagraphStyle, kCTParagraphStyleSpecifierParagraphSpacingBefore, sizeof(paraSpacingBefore), &paraSpacingBefore))

{

lineOrigin.y += paraSpacingBefore;

}

// preserve own baseline x

lineOrigin.x = line.baselineOrigin.x;

// origins are rounded

lineOrigin.y = ceil(lineOrigin.y);

return lineOrigin;

}

}

// get line height in px if it is specified for this line

CGFloat lineHeight = 0;

CGFloat minLineHeight = 0;

CGFloat maxLineHeight = 0;

BOOL usesForcedLineHeight = NO;

CGFloat usedLeading = line.leading;

if (usedLeading == 0.0f)

{

// font has no leading, so we fake one (e.g. Helvetica)

CGFloat tmpHeight = line.ascent + line.descent;

usedLeading = ceil(0.2f * tmpHeight);

if (usedLeading>20)

{

// we have a large image increasing the ascender too much for this calc to work

usedLeading = 0;

}

}

else

{

// make sure that we don't have less than 10% of line height as leading

usedLeading = ceil(MAX((line.ascent + line.descent)*0.1f, usedLeading));

}

if (CTParagraphStyleGetValueForSpecifier(lineParagraphStyle, kCTParagraphStyleSpecifierMinimumLineHeight, sizeof(minLineHeight), &minLineHeight))

{

usesForcedLineHeight = YES;

if (lineHeight<minLineHeight)

{

lineHeight = minLineHeight;

}

}

// is absolute line height set?

if (lineHeight==0)

{

lineHeight = line.descent + line.ascent + usedLeading;

}

if ([self isLineLastInParagraph:previousLine])

{

// need to get paragraph spacing

CTParagraphStyleRef previousLineParagraphStyle = (__bridge CTParagraphStyleRef)[_attributedStringFragment

attribute:(id)kCTParagraphStyleAttributeName

atIndex:previousLine.stringRange.location effectiveRange:NULL];

// Paragraph spacings are paragraph styles and should not be multiplied by kCTParagraphStyleSpecifierLineHeightMultiple

// So directly add them to lineOrigin.y

CGFloat paraSpacing;

if (CTParagraphStyleGetValueForSpecifier(previousLineParagraphStyle, kCTParagraphStyleSpecifierParagraphSpacing, sizeof(paraSpacing), &paraSpacing))

{

lineOrigin.y += paraSpacing;

}

CGFloat paraSpacingBefore;

if (CTParagraphStyleGetValueForSpecifier(lineParagraphStyle, kCTParagraphStyleSpecifierParagraphSpacingBefore, sizeof(paraSpacingBefore), &paraSpacingBefore))

{

lineOrigin.y += paraSpacingBefore;

}

}

CGFloat lineHeightMultiplier = 0;

if (CTParagraphStyleGetValueForSpecifier(lineParagraphStyle, kCTParagraphStyleSpecifierLineHeightMultiple, sizeof(lineHeightMultiplier), &lineHeightMultiplier))

{

if (lineHeightMultiplier>0.0f)

{

lineHeight *= lineHeightMultiplier;

}

}

if (CTParagraphStyleGetValueForSpecifier(lineParagraphStyle, kCTParagraphStyleSpecifierMaximumLineHeight, sizeof(maxLineHeight), &maxLineHeight))

{

if (maxLineHeight>0 && lineHeight>maxLineHeight)

{

lineHeight = maxLineHeight;

}

}

lineOrigin.y += lineHeight;

// preserve own baseline x

lineOrigin.x = line.baselineOrigin.x;

// prevent overlap of a line with small font size with line before it

if (!usesForcedLineHeight)

{

// only if there IS a line before it AND the line height is not fixed

CGFloat previousLineBottom = CGRectGetMaxY(previousLine.frame);

if (lineOrigin.y - line.ascent < previousLineBottom)

{

// move baseline origin down far enough

lineOrigin.y = previousLineBottom + line.ascent;

}

}

// origins are rounded

lineOrigin.y = ceil(lineOrigin.y);

return lineOrigin;

}

// determins the "half leading"

- (CGFloat)_algorithmWebKit_halfLeadingOfLine:(DTCoreTextLayoutLine *)line

{

CGFloat maxFontSize = [line lineHeight];

DTCoreTextParagraphStyle *paragraphStyle = [line paragraphStyle];

if (paragraphStyle.minimumLineHeight != 0 && paragraphStyle.minimumLineHeight > maxFontSize)

{

maxFontSize = paragraphStyle.minimumLineHeight;

}

if (paragraphStyle.maximumLineHeight != 0 && paragraphStyle.maximumLineHeight < maxFontSize)

{

maxFontSize = paragraphStyle.maximumLineHeight;

}

CGFloat leading;

if (paragraphStyle.lineHeightMultiple > 0)

{

leading = maxFontSize * paragraphStyle.lineHeightMultiple;

}

else

{

// reasonable "normal"

leading = maxFontSize * 1.1f;

}

// subtract inline box height

CGFloat inlineBoxHeight = line.ascent + line.descent;

return (leading - inlineBoxHeight)/2.0f;

}

- (CGPoint)_algorithmWebKit_BaselineOriginToPositionLine:(DTCoreTextLayoutLine *)line afterLine:(DTCoreTextLayoutLine *)previousLine

{

CGPoint baselineOrigin = previousLine.baselineOrigin;

if (previousLine)

{

baselineOrigin.y = CGRectGetMaxY(previousLine.frame);

CGFloat halfLeadingFromText = [self _algorithmWebKit_halfLeadingOfLine:previousLine];

if (previousLine.attachments)

{

// only add half leading if there are no attachments, this prevents line from being shifted up due to negative half leading

if (halfLeadingFromText>0)

{

baselineOrigin.y += halfLeadingFromText;

}

}

else

{

baselineOrigin.y += halfLeadingFromText;

}

// add previous line's after paragraph spacing

if ([self isLineLastInParagraph:previousLine])

{

DTCoreTextParagraphStyle *paragraphStyle = [previousLine paragraphStyle];

baselineOrigin.y += paragraphStyle.paragraphSpacing;

}

}

else

{

// first line in frame

baselineOrigin = _frame.origin;

}

baselineOrigin.y += line.ascent;

CGFloat halfLeadingFromText = [self _algorithmWebKit_halfLeadingOfLine:line];

if (line.attachments)

{

// only add half leading if there are no attachments, this prevents line from being shifted up due to negative half leading

if (halfLeadingFromText>0)

{

baselineOrigin.y += halfLeadingFromText;

}

}

else

{

baselineOrigin.y += halfLeadingFromText;

}

DTCoreTextParagraphStyle *paragraphStyle = [line paragraphStyle];

// add current line's before paragraph spacing

if ([self isLineFirstInParagraph:line])

{

baselineOrigin.y += paragraphStyle.paragraphSpacingBefore;

}

// add padding for closed text blocks

for (DTTextBlock *previousTextBlock in previousLine.textBlocks)

{

if (![line.textBlocks containsObject:previousTextBlock])

{

baselineOrigin.y += previousTextBlock.padding.bottom;

}

}

// add padding for newly opened text blocks

for (DTTextBlock *currentTextBlock in line.textBlocks)

{

if (![previousLine.textBlocks containsObject:currentTextBlock])

{

baselineOrigin.y += currentTextBlock.padding.top;

}

}

// origins are rounded

baselineOrigin.y = ceil(baselineOrigin.y);

return baselineOrigin;

}

- (CGPoint)baselineOriginToPositionLine:(DTCoreTextLayoutLine *)line afterLine:(DTCoreTextLayoutLine *)previousLine options:(DTCoreTextLayoutFrameLinePositioningOptions)options

{

if (options & DTCoreTextLayoutFrameLinePositioningOptionAlgorithmWebKit)

{

return [self _algorithmWebKit_BaselineOriginToPositionLine:line afterLine:previousLine];

}

if (options & DTCoreTextLayoutFrameLinePositioningOptionAlgorithmLegacy)

{

return [self _algorithmLegacy_BaselineOriginToPositionLine:line afterLine:previousLine];

}

return CGPointZero;

}

// deprecated

- (CGPoint)baselineOriginToPositionLine:(DTCoreTextLayoutLine *)line afterLine:(DTCoreTextLayoutLine *)previousLine

{

return [self baselineOriginToPositionLine:line afterLine:previousLine options:DTCoreTextLayoutFrameLinePositioningOptionAlgorithmWebKit];

}

#pragma mark - Building the Lines

/*

Builds the array of lines with the internal typesetter of our framesetter. No need to correct line origins in this case because they are placed correctly in the first place. This version supports text boxes.

*/

- (void)_buildLinesWithTypesetter

{

// framesetter keeps internal reference, no need to retain

CTTypesetterRef typesetter = CTFramesetterGetTypesetter(_framesetter);

NSMutableArray *typesetLines = [NSMutableArray array];

DTCoreTextLayoutLine *previousLine = nil;

// need the paragraph ranges to know if a line is at the beginning of paragraph

NSMutableArray *paragraphRanges = [[self paragraphRanges] mutableCopy];

NSRange currentParagraphRange = [[paragraphRanges objectAtIndex:0] rangeValue];

// we start out in the requested range, length will be set by the suggested line break function

NSRange lineRange = _requestedStringRange;

// maximum values for abort of loop

CGFloat maxY = CGRectGetMaxY(_frame);

NSUInteger maxIndex = NSMaxRange(_requestedStringRange);

NSUInteger fittingLength = 0;

BOOL shouldTruncateLine = NO;

do // for each line

{

while (lineRange.location >= (currentParagraphRange.location+currentParagraphRange.length))

{

// we are outside of this paragraph, so we go to the next

[paragraphRanges removeObjectAtIndex:0];

currentParagraphRange = [[paragraphRanges objectAtIndex:0] rangeValue];

}

BOOL isAtBeginOfParagraph = (currentParagraphRange.location == lineRange.location);

CGFloat headIndent = 0;

CGFloat tailIndent = 0;

// get the paragraph style at this index

CTParagraphStyleRef paragraphStyle = (__bridge CTParagraphStyleRef)[_attributedStringFragment attribute:(id)kCTParagraphStyleAttributeName atIndex:lineRange.location effectiveRange:NULL];

if (isAtBeginOfParagraph)

{

CTParagraphStyleGetValueForSpecifier(paragraphStyle, kCTParagraphStyleSpecifierFirstLineHeadIndent, sizeof(headIndent), &headIndent);

}

else

{

CTParagraphStyleGetValueForSpecifier(paragraphStyle, kCTParagraphStyleSpecifierHeadIndent, sizeof(headIndent), &headIndent);

}

CTParagraphStyleGetValueForSpecifier(paragraphStyle, kCTParagraphStyleSpecifierTailIndent, sizeof(tailIndent), &tailIndent);

// add left padding to offset

CGFloat lineOriginX;

CGFloat availableSpace;

NSArray *textBlocks = [_attributedStringFragment attribute:DTTextBlocksAttribute atIndex:lineRange.location effectiveRange:NULL];

CGFloat totalLeftPadding = 0;

CGFloat totalRightPadding = 0;

for (DTTextBlock *oneTextBlock in textBlocks)

{

totalLeftPadding += oneTextBlock.padding.left;

totalRightPadding += oneTextBlock.padding.right;

}

if (tailIndent<=0)

{

// negative tail indent is measured from trailing margin (we assume LTR here)

availableSpace = _frame.size.width - headIndent - totalRightPadding + tailIndent - totalLeftPadding;

}

else

{

availableSpace = tailIndent - headIndent - totalLeftPadding - totalRightPadding;

}

CGFloat offset = totalLeftPadding;

// if first character is a tab, then it is positioned without the indentation

if (![[[_attributedStringFragment string] substringWithRange:NSMakeRange(lineRange.location, 1)] isEqualToString:@"\t"])

{

offset += headIndent;

}

// find how many characters we get into this line

lineRange.length = CTTypesetterSuggestLineBreak(typesetter, lineRange.location, availableSpace);

if (NSMaxRange(lineRange) > maxIndex)

{

// only layout as much as was requested

lineRange.length = maxIndex - lineRange.location;

}

// determine whether this is a normal line or if it should be truncated

shouldTruncateLine = ((self.numberOfLines>0 && [typesetLines count]+1==self.numberOfLines) || (_numberLinesFitInFrame>0 && _numberLinesFitInFrame==[typesetLines count]+1));

CTLineRef line;

BOOL isHyphenatedString = NO;

if (!shouldTruncateLine)

{

static const unichar softHypen = 0x00AD;

NSString *lineString = [[_attributedStringFragment attributedSubstringFromRange:lineRange] string];

unichar lastChar = [lineString characterAtIndex:[lineString length] - 1];

if (softHypen == lastChar)

{

NSMutableAttributedString *hyphenatedString = [[_attributedStringFragment attributedSubstringFromRange:lineRange] mutableCopy];

NSRange replaceRange = NSMakeRange(hyphenatedString.length - 1, 1);

[hyphenatedString replaceCharactersInRange:replaceRange withString:@"-"];

line = CTLineCreateWithAttributedString((__bridge CFAttributedStringRef)hyphenatedString);

isHyphenatedString = YES;

}

else

{

// create a line to fit

line = CTTypesetterCreateLine(typesetter, CFRangeMake(lineRange.location, lineRange.length));

}

}

else

{

// extend the line to the end of the current paragraph

// if we extend to the entire to the entire text range

// it is possible to pull lines up from paragraphs below us

NSRange oldLineRange = lineRange;

lineRange.length = NSMaxRange(currentParagraphRange)-lineRange.location;

CTLineRef baseLine = CTTypesetterCreateLine(typesetter, CFRangeMake(lineRange.location, lineRange.length));

// convert lineBreakMode to CoreText type

CTLineTruncationType truncationType = DTCTLineTruncationTypeFromNSLineBreakMode(self.lineBreakMode);

// prepare truncation string

NSAttributedString * attribStr = self.truncationString;

if(attribStr == nil)

{

NSRange range;

NSInteger index = oldLineRange.location;

if (truncationType == kCTLineTruncationEnd)

{

index += (oldLineRange.length > 0 ? oldLineRange.length - 1 : 0);

}

else if (truncationType == kCTLineTruncationMiddle)

{

index += (oldLineRange.length > 1 ? (oldLineRange.length/2.0 - 1) : 0);

}

NSDictionary * attributes = [_attributedStringFragment attributesAtIndex:index effectiveRange:&range];

attribStr = [[NSAttributedString alloc] initWithString:@"…" attributes:attributes];

}

CTLineRef elipsisLineRef = CTLineCreateWithAttributedString((__bridge CFAttributedStringRef)(attribStr));

// create the truncated line

line = CTLineCreateTruncatedLine(baseLine, availableSpace, truncationType, elipsisLineRef);

// clean up

CFRelease(baseLine);

CFRelease(elipsisLineRef);

}

// we need all metrics so get the at once

CGFloat currentLineWidth = (CGFloat)CTLineGetTypographicBounds(line, NULL, NULL, NULL);

// adjust lineOrigin based on paragraph text alignment

CTTextAlignment textAlignment;

if (!CTParagraphStyleGetValueForSpecifier(paragraphStyle, kCTParagraphStyleSpecifierAlignment, sizeof(textAlignment), &textAlignment))

{

textAlignment = kCTNaturalTextAlignment;

}

// determine writing direction

BOOL isRTL = NO;

CTWritingDirection baseWritingDirection;

if (CTParagraphStyleGetValueForSpecifier(paragraphStyle, kCTParagraphStyleSpecifierBaseWritingDirection, sizeof(baseWritingDirection), &baseWritingDirection))

{

isRTL = (baseWritingDirection == kCTWritingDirectionRightToLeft);

}

else

{

baseWritingDirection = kCTWritingDirectionNatural;

}

switch (textAlignment)

{

case kCTLeftTextAlignment:

{

lineOriginX = _frame.origin.x + offset;

// nothing to do

break;

}

case kCTNaturalTextAlignment:

{

lineOriginX = _frame.origin.x + offset;

if (baseWritingDirection != kCTWritingDirectionRightToLeft)

{

break;

}

// right alignment falls through

}

case kCTRightTextAlignment:

{

lineOriginX = _frame.origin.x + offset + (CGFloat)CTLineGetPenOffsetForFlush(line, 1.0, availableSpace);

break;

}

case kCTCenterTextAlignment:

{

lineOriginX = _frame.origin.x + offset + (CGFloat)CTLineGetPenOffsetForFlush(line, 0.5, availableSpace);

break;

}

case kCTJustifiedTextAlignment:

{

BOOL isAtEndOfParagraph = (currentParagraphRange.location+currentParagraphRange.length <= lineRange.location+lineRange.length ||

[[_attributedStringFragment string] characterAtIndex:lineRange.location+lineRange.length-1]==0x2028);

// only justify if not last line, not <br>, and if the line width is longer than _justifyRatio of the frame

// avoids over-stretching

if( !isAtEndOfParagraph && (currentLineWidth > _justifyRatio * _frame.size.width) )

{

// create a justified line and replace the current one with it

CTLineRef justifiedLine = CTLineCreateJustifiedLine(line, 1.0f, availableSpace);

// CTLineCreateJustifiedLine sometimes fails if the line ends with 0x00AD (soft hyphen) and contains cyrillic chars

if (justifiedLine)

{

CFRelease(line);

line = justifiedLine;

}

}

if (isRTL)

{

// align line with right margin

lineOriginX = _frame.origin.x + offset + (CGFloat)CTLineGetPenOffsetForFlush(line, 1.0, availableSpace);

}

else

{

// align line with left margin

lineOriginX = _frame.origin.x + offset;

}

break;

}

}

if (!line)

{

continue;

}

// wrap it

DTCoreTextLayoutLine *newLine = [[DTCoreTextLayoutLine alloc] initWithLine:line

stringLocationOffset:isHyphenatedString ? lineRange.location : 0];

newLine.writingDirectionIsRightToLeft = isRTL;

CFRelease(line);

// determine position of line based on line before it

CGPoint newLineBaselineOrigin = [self _algorithmWebKit_BaselineOriginToPositionLine:newLine afterLine:previousLine];

newLineBaselineOrigin.x = lineOriginX;

newLine.baselineOrigin = newLineBaselineOrigin;

// abort layout if we left the configured frame

CGFloat lineBottom = CGRectGetMaxY(newLine.frame);

if (lineBottom>maxY)

{

if ([typesetLines count] && self.lineBreakMode)

{

_numberLinesFitInFrame = [typesetLines count];

[self _buildLinesWithTypesetter];

return;

}

else

{

// doesn't fit any more

break;

}

}

[typesetLines addObject:newLine];

fittingLength += lineRange.length;

lineRange.location += lineRange.length;

previousLine = newLine;

}

while (lineRange.location < maxIndex && !shouldTruncateLine);

_lines = typesetLines;

if (![_lines count])

{

// no lines fit

_stringRange = NSMakeRange(0, 0);

return;

}

// now we know how many characters fit

_stringRange.location = _requestedStringRange.location;

_stringRange.length = fittingLength;

// at this point we can correct the frame if it is open-ended

if (_frame.size.height == CGFLOAT_HEIGHT_UNKNOWN)

{

DTCoreTextLayoutLine *lastLine = [_lines lastObject];

CGFloat totalPadding = 0;

for (DTTextBlock *oneTextBlock in lastLine.textBlocks)

{

totalPadding += oneTextBlock.padding.bottom;

}

// need to add bottom padding if in text block

_additionalPaddingAtBottom = totalPadding;

}

}

/**

DEPRECATED: this was the original way of getting the lines

*/

- (void)_buildLinesWithStandardFramesetter

{

// get lines (don't own it so no release)

CFArrayRef cflines = CTFrameGetLines(_textFrame);

if (!cflines)

{

// probably no string set

return;

}

CGPoint *origins = malloc(sizeof(CGPoint)*CFArrayGetCount(cflines));

CTFrameGetLineOrigins(_textFrame, CFRangeMake(0, 0), origins);

NSMutableArray *tmpLines = [[NSMutableArray alloc] initWithCapacity:CFArrayGetCount(cflines)];

NSInteger lineIndex = 0;

for (id oneLine in (__bridge NSArray *)cflines)

{

CGPoint lineOrigin = origins[lineIndex];

lineOrigin.y = _frame.size.height - lineOrigin.y + _frame.origin.y;

lineOrigin.x += _frame.origin.x;

DTCoreTextLayoutLine *newLine = [[DTCoreTextLayoutLine alloc] initWithLine:(__bridge CTLineRef)oneLine];

newLine.baselineOrigin = lineOrigin;

[tmpLines addObject:newLine];

lineIndex++;

}

free(origins);

_lines = tmpLines;

// need to get the visible range here

CFRange fittingRange = CTFrameGetStringRange(_textFrame);

_stringRange.location = fittingRange.location;

_stringRange.length = fittingRange.length;

}

- (void)_buildLines

{

// only build lines if frame is legal

if (_frame.size.width<=0)

{

return;

}

// note: building line by line with typesetter

[self _buildLinesWithTypesetter];

//[self _buildLinesWithStandardFramesetter];

}

- (NSArray *)lines

{

if (!_lines)

{

[self _buildLines];

}

return _lines;

}

- (NSArray *)linesVisibleInRect:(CGRect)rect

{

NSMutableArray *tmpArray = [NSMutableArray arrayWithCapacity:[self.lines count]];

CGFloat minY = CGRectGetMinY(rect);

CGFloat maxY = CGRectGetMaxY(rect);

for (DTCoreTextLayoutLine *oneLine in self.lines)

{

CGRect lineFrame = oneLine.frame;

// lines before the rect

if (CGRectGetMaxY(lineFrame)<minY)

{

// skip

continue;

}

// line is after the rect

if (lineFrame.origin.y > maxY)

{

break;

}

// CGRectIntersectsRect returns false if the frame has 0 width, which

// lines that consist only of line-breaks have. Set the min-width

// to one to work-around.

lineFrame.size.width = lineFrame.size.width>1?lineFrame.size.width:1;

if (CGRectIntersectsRect(rect, lineFrame))

{

[tmpArray addObject:oneLine];

}

}

return tmpArray;

}

- (NSArray *)linesContainedInRect:(CGRect)rect

{

NSMutableArray *tmpArray = [NSMutableArray arrayWithCapacity:[self.lines count]];

CGFloat minY = CGRectGetMinY(rect);

CGFloat maxY = CGRectGetMaxY(rect);

for (DTCoreTextLayoutLine *oneLine in self.lines)

{

CGRect lineFrame = oneLine.frame;

// lines before the rect

if (CGRectGetMaxY(lineFrame)<minY)

{

// skip

continue;

}

// line is after the rect

if (lineFrame.origin.y > maxY)

{

break;

}

if (CGRectContainsRect(rect, lineFrame))

{

[tmpArray addObject:oneLine];

}

}

return tmpArray;

}

#pragma mark - Text Block Helpers

// determines the frame to use for a text block with a given effect range at a specific block level

- (CGRect)_blockFrameForEffectiveRange:(NSRange)effectiveRange level:(NSUInteger)level

{

CGRect blockFrame;

// we know extent of block, get frame

DTCoreTextLayoutLine *firstBlockLine = [self lineContainingIndex:effectiveRange.location];

DTCoreTextLayoutLine *lastBlockLine = [self lineContainingIndex:NSMaxRange(effectiveRange)-1];

// start with frame spanned from these lines

blockFrame.origin = firstBlockLine.frame.origin;

blockFrame.origin.x = _frame.origin.x;

blockFrame.size.width = _frame.size.width;

blockFrame.size.height = CGRectGetMaxY(lastBlockLine.frame) - blockFrame.origin.y;

// top paddings we get from first line

for (NSInteger i = [firstBlockLine.textBlocks count]-1; i>=level;i--)

{

if (i<0)

{

break;

}

DTTextBlock *oneTextBlock = [firstBlockLine.textBlocks objectAtIndex:i];

blockFrame.origin.y -= oneTextBlock.padding.top;

blockFrame.size.height += oneTextBlock.padding.top;

}

// top padding we get from last line

for (NSInteger i = [lastBlockLine.textBlocks count]-1; i>=level;i--)

{

if (i<0)

{

break;

}

DTTextBlock *oneTextBlock = [lastBlockLine.textBlocks objectAtIndex:i];

blockFrame.size.height += oneTextBlock.padding.bottom;

}

// adjust left and right margins with block stack padding

for (int i=0; i<level; i++)

{

DTTextBlock *textBlock = [firstBlockLine.textBlocks objectAtIndex:i];

blockFrame.origin.x += textBlock.padding.left;

blockFrame.size.width -= (textBlock.padding.left + textBlock.padding.right);

}

return CGRectIntegral(blockFrame);

}

// only enumerate blocks at a given level

// returns YES if there was at least one block enumerated at this level

- (BOOL)_enumerateTextBlocksAtLevel:(NSUInteger)level inRange:(NSRange)range usingBlock:(void (^)(DTTextBlock *textBlock, CGRect frame, NSRange effectiveRange, BOOL *stop))block

{

NSParameterAssert(block);

// synchronize globally to work around crashing bug in iOS accessing attributes concurrently in 2 separate layout frames, with separate attributed strings, but coming from same layouter.

@synchronized((__bridge id)_framesetter)

{

NSUInteger length = [_attributedStringFragment length];

NSUInteger index = range.location;

BOOL foundBlockAtLevel = NO;

while (index<NSMaxRange(range))

{

NSRange textBlocksArrayRange;

NSArray *textBlocks = [_attributedStringFragment attribute:DTTextBlocksAttribute atIndex:index longestEffectiveRange:&textBlocksArrayRange inRange:range];

index += textBlocksArrayRange.length;

if ([textBlocks count] <= level)

{

// has no blocks at this level

continue;

}

foundBlockAtLevel = YES;

// find extent of outermost block

DTTextBlock *blockAtLevelToHandle = [textBlocks objectAtIndex:level];

NSUInteger searchIndex = NSMaxRange(textBlocksArrayRange);

NSRange currentBlockEffectiveRange = textBlocksArrayRange;

// search forward for actual end of block

while (searchIndex < length && searchIndex < NSMaxRange(range))

{

NSRange laterBlocksRange;

NSArray *laterBlocks = [_attributedStringFragment attribute:DTTextBlocksAttribute atIndex:searchIndex longestEffectiveRange:&laterBlocksRange inRange:range];

if (![laterBlocks containsObject:blockAtLevelToHandle])

{

break;

}

currentBlockEffectiveRange = NSUnionRange(currentBlockEffectiveRange, laterBlocksRange);

searchIndex = NSMaxRange(laterBlocksRange);

}

index = searchIndex;

CGRect blockFrame = [self _blockFrameForEffectiveRange:currentBlockEffectiveRange level:level];

BOOL shouldStop = NO;