/Frameworks/OmniUI/iPad/OUIEditableFrame.m

Large files files are truncated, but you can click here to view the full file

// Copyright 2010-2012 The Omni Group. All rights reserved.
//
// This software may only be used and reproduced according to the
// terms in the file OmniSourceLicense.html, which should be
// distributed with this project and can also be found at
// <http://www.omnigroup.com/developer/sourcecode/sourcelicense/>.

#import <OmniUI/OUIEditableFrame.h>

#import <Foundation/NSAttributedString.h>
#import <MobileCoreServices/UTCoreTypes.h>
#import <OmniAppKit/OATextStorage.h>
#import <OmniAppKit/OATextAttributes.h>
#import <OmniBase/rcsid.h>
#import <OmniFoundation/OFCharacterSet.h>
#import <OmniFoundation/OFNull.h>
#import <OmniQuartz/OQColor.h>
#import <OmniQuartz/OQDrawing.h>
#import <OmniUI/OUIColorInspectorSlice.h>
#import <OmniUI/OUIDirectTapGestureRecognizer.h>
#import <OmniUI/OUIFontAttributesInspectorSlice.h>
#import <OmniUI/OUIFontInspectorSlice.h>
#import <OmniUI/OUIParagraphStyleInspectorSlice.h>
#import <OmniUI/OUIScrollNotifier.h>
#import <OmniUI/OUIStackedSlicesInspectorPane.h>
#import <OmniUI/OUITextColorAttributeInspectorSlice.h>
#import <OmniUI/OUITextLayout.h>
#import <OmniUI/UIView-OUIExtensions.h>
#import <OmniUI/OUITextExampleInspectorSlice.h>
#import <QuartzCore/QuartzCore.h>

#import <execinfo.h>
#import <stdlib.h>

#import "OUEFTextPosition.h"
#import "OUEFTextRange.h"
#import "OUEFTextSpan.h"
#import "OUIEditMenuController.h"
#import "OUILoupeOverlay.h"
#import "OUITextCursorOverlay.h"
#import "OUITextInputStringTokenizer.h"
#import "OUITextThumb.h"

RCS_ID("$Id$");

#if 0 && defined(DEBUG)
    #define DEBUG_TEXT_ENABLED
#endif

#ifdef DEBUG_TEXT_ENABLED
    #define DEBUG_TEXT(format, ...) NSLog(@"TEXT: " format, ## __VA_ARGS__)
#else
    #define DEBUG_TEXT(format, ...)
#endif

#if 0 && defined(DEBUG)
    #define DEBUG_EDITING(format, ...) NSLog(@"TEXT EDIT: " format, ## __VA_ARGS__)
#else
    #define DEBUG_EDITING(format, ...)
#endif

#if 0 && defined(DEBUG)
    #define DEBUG_CARET(format, ...) NSLog(@"CARET: " format, ## __VA_ARGS__)
#else
    #define DEBUG_CARET(format, ...)
#endif

#if 0 && defined(DEBUG)
    #define DEBUG_CONTEXT_MENU(format, ...) NSLog(@"MENU: " format, ## __VA_ARGS__)
    #define DEBUG_CONTEXT_MENU_LOG_CALLER() OB_DEBUG_LOG_CALLER()
#else
    #define DEBUG_CONTEXT_MENU(format, ...)
    #define DEBUG_CONTEXT_MENU_LOG_CALLER()
#endif

#if 0 && defined(DEBUG_curt)
    #define DEBUG_SCROLL(format, ...) NSLog(@"SCROLL: " format, ## __VA_ARGS__)
#else
    #define DEBUG_SCROLL(format, ...)
#endif


/* TODO: If low memory and not first responder, clear out actionRecognizers[] */

#define CARET_ACTIVITY_SOLID_INTERVAL 0.75

#define OUIRound(x) roundf(x)
#define OUIFloor(x) floorf(x)

// Radar 9138543: Make UITextLayoutDirection compatible with new clang-2 warning
// clang-2 (at r127704) warns when casting enum types, but UITextLayoutDirection is an extension of UITextStorageDirection which fails to redeclare the forward/backward members. Rather than scatter casts all over, define some constants here.
#define OUITextLayoutDirectionForward ((UITextLayoutDirection)UITextStorageDirectionForward)
#define OUITextLayoutDirectionBackward ((UITextLayoutDirection)UITextStorageDirectionBackward)

NSString * const OUIEditableFrameTextDidBeginEditingNotification = @"OUIEditableFrameTextDidBeginEditingNotification";
NSString * const OUIEditableFrameTextDidEndEditingNotification = @"OUIEditableFrameTextDidEndEditingNotification";
NSString * const OUIEditableFrameTextDidChangeNotification = @"OUIEditableFrameTextDidChangeNotification";

NSString * const OUIThumbMovementMenuInhibition = @"OUIThumbMovementMenuInhibition";
NSString * const OUIScrollingMenuInhibition = @"OUIScrollingMenuInhibition";

@interface OUIEditableFrame (/*Private*/)
- (NSUInteger)_characterIndexOfPoint:(CGPoint)tapPoint inLine:(CTLineRef)line lineOrigin:(CGPoint)lineOrigin stringRange:(NSRange)stringRange lookingForTappedGlyph:(BOOL)lookingForTappedGlyph outWasBeyondLineBounds:(BOOL *)outWasBeyondLineBounds;
- (OUEFTextPosition *)_closestPositionToPoint:(CGPoint)viewPoint withinRange:(UITextRange *)range lookingForTappedGlyph:(BOOL)lookingForTappedGlyph wasBeyondLineBounds:(BOOL *)outWasBeyondLineBounds;
- (CFRange)_lineRangeForStringRange:(NSRange)queryRange;
- (double)_emptyParagraphStartOffsetForLine:(CTLineRef)line;
- (CGRect)_caretRectForPosition:(OUEFTextPosition *)position affinity:(UITextStorageDirection)affinity bloomScale:(double)bloomScale;
- (void)_setNeedsDisplayForRange:(OUEFTextRange *)range;
- (void)_setSolidCaret:(int)delta;
- (void)_setSelectionToIndex:(NSUInteger)ix;
- (void)_setSelectedTextRange:(OUEFTextRange *)newRange notifyDelegate:(BOOL)shouldNotify;
- (void)_idleTap;
- (void)_activeTap:(UITapGestureRecognizer *)r;
- (void)_inspectTap:(UILongPressGestureRecognizer *)r;
- (void)_drawDecorationsBelowText:(CGContextRef)ctx;
- (void)_drawDecorationsAboveText:(CGContextRef)ctx;
- (void)_didChangeContent;
- (void)_updateLayout:(BOOL)computeDrawnFrame;
- (void)_moveInDirection:(UITextLayoutDirection)direction;
- (UIView *)_topmostView;
- (NSAttributedString *)_attributedTextInRange:(UITextRange *)range;
@end

@implementation OUIEditableFrame

#pragma mark Debugging helpers

const OUIEnumName OUITextDirectionEnumNames[] = {
    { UITextStorageDirectionForward, CFSTR("Forward") },
    { UITextStorageDirectionBackward, CFSTR("Backward") },
    { UITextLayoutDirectionRight, CFSTR("Right") },
    { UITextLayoutDirectionLeft, CFSTR("Left") },
    { UITextLayoutDirectionUp, CFSTR("Up") },
    { UITextLayoutDirectionDown, CFSTR("Down") },
    { 0, NULL }    
};
const OUIEnumName OUITextSelectionGranularityNames[] = {
    { UITextGranularityCharacter, CFSTR("Character") },
    { UITextGranularityWord, CFSTR("Word") },
    { UITextGranularitySentence, CFSTR("Sentence") },
    { UITextGranularityParagraph, CFSTR("Paragraph") },
    { UITextGranularityLine, CFSTR("Line") },
    { UITextGranularityDocument, CFSTR("Document") },
    { 0, NULL }    
};

NSString *OUINameOfEnum(NSInteger v, const OUIEnumName *ns)
{
    int value = (int)v;
    while(ns->name) {
        if (ns->value == value)
            return (NSString *)(ns->name);
        ns ++;
    }
    return [NSString stringWithFormat:@"<%d>", value];
}

#ifdef DEBUG_TEXT_ENABLED
// Returns an ASCII art description of the selection with some context around it, if possible. Not terribly efficient, but don't care...
static NSString *_selectionDescription(OUIEditableFrame *self, OUEFTextRange *selection)
{
    NSUInteger st = [(OUEFTextPosition *)[selection start] index];
    NSUInteger en = [(OUEFTextPosition *)[selection end] index];
    static NSUInteger kContextSize = 10;
    
    NSString *string = [self->_content string];
    NSUInteger stringLength = [string length];
    OBASSERT(st <= stringLength);
    OBASSERT(en <= stringLength);
    OBASSERT(st <= en);
    
    NSMutableString *desc = [NSMutableString string];
    
    if (st > 0) {
        NSUInteger availableContext = MIN(st, kContextSize);
        [desc appendString:[string substringWithRange:NSMakeRange(st - availableContext, availableContext)]];
    }
    
    if (st == en)
        [desc appendString:@"|"];
    else {
        [desc appendString:@"["];

        if (st + 3*kContextSize > en) {
            [desc appendString:[string substringWithRange:NSMakeRange(st, en - st)]];
        } else {
            [desc appendString:[string substringWithRange:NSMakeRange(st, kContextSize)]];
            [desc appendString:@"..."];
            [desc appendString:[string substringWithRange:NSMakeRange(en - kContextSize, kContextSize)]];
        }

        [desc appendString:@"]"];
    }
    
    if (en < stringLength) {
        NSUInteger availableContext = MIN(stringLength - en, kContextSize);
        [desc appendString:[string substringWithRange:NSMakeRange(en, availableContext)]];
    }
    
    // TODO: Escape newlines and quotes?
    [desc insertString:@"\"" atIndex:0];
    [desc appendString:@"\""];
    
    return desc;
}

static NSString *_positionDescription(OUIEditableFrame *self, OUEFTextPosition *position)
{
    OUEFTextRange *range = [[[OUEFTextRange alloc] initWithStart:position end:position] autorelease];
    return _selectionDescription(self, range);
}
#endif

#ifdef DEBUG
static void btrace(void)
{
#define NUMB 24
    void *fps[NUMB];
    int numb = backtrace(fps, NUMB);
    backtrace_symbols_fd(fps + 1, numb - 1, 2);
}
#endif

+ (Class)textStorageClass;
{
    return [OATextStorage class];
}

static id do_init(OUIEditableFrame *self)
{
    self.contentMode = UIViewContentModeRedraw;
    self.clearsContextBeforeDrawing = YES;

    /* Need to have *some* fallback font. This more or less matches what UITextView does. */
    if (!self->defaultFont)
        self->defaultFont = CFRetain(OUIGlobalDefaultFont());
    
    self->_autocorrectionType = UITextAutocorrectionTypeDefault;
    self->_autocapitalizationType = UITextAutocapitalizationTypeSentences;
#if defined(__IPHONE_5_0) && (__IPHONE_5_0 <= __IPHONE_OS_VERSION_MAX_ALLOWED)
    self->_spellCheckingType = UITextSpellCheckingTypeDefault;
#endif
    self->_returnKeyType = UIReturnKeyDefault;
    self->_keyboardType = UIKeyboardTypeDefault;

    self->generation = 1;
    self->markedRange = NSMakeRange(NSNotFound, 0);
    self->layoutSize.width = 0;
    self->layoutSize.height = 0;
    self->flags.textNeedsUpdate = 1;
    self->flags.delegateRespondsToLayoutChanged = 0;
    self->flags.showSelectionThumbs = 1;
    self->flags.loadingFromNib = 0;
    self->selectionDirtyRect = CGRectNull;
    self->markedTextDirtyRect = CGRectNull;
    
    // Avoid ugly stretchy text
    self.contentMode = UIViewContentModeTopLeft;

    self->_linkTextAttributes = [[OUITextLayout defaultLinkTextAttributes] copy];
    
    self->tapSelectionGranularity = UITextGranularityWord;
    
    self.markedRangeBorderColor = [UIColor colorWithRed:213.0/255.0 green:225.0/255.0 blue:237.0/255.0 alpha:1];
    self->_markedRangeBorderThickness = 1.0;
    self.markedRangeBackgroundColor = [UIColor colorWithRed:236.0/255.0 green:240.0/255.0 blue:248.0/255.0 alpha:1];

    self->isRegisteredForScrollNotifications = NO;
    
    self->_editMenuController = [[OUIEditMenuController alloc] initWithEditableFrame:self];
    
    // We lazily initialize some attributes in didMoveToWindow.
    return self;
}

- (id)initWithFrame:(CGRect)frame;
{
    if (!(self = [super initWithFrame:frame]))
        return nil;

    self.userInteractionEnabled = YES;
    self.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
    return do_init(self);
}

- (id)initWithCoder:(NSCoder *)aDecoder;
{
    if (!(self = [super initWithCoder:aDecoder]))
        return nil;
    id result = do_init(self);
    flags.loadingFromNib = YES;
    return result;
}

#pragma mark -
#pragma mark Utility functions and private methods

/* Returns true if CFIndex i is within NSRange r. (Notice the differing types.) */
static inline BOOL in_range(NSRange r, CFIndex i)
{
    if (i < 0)
        return 0;
    NSUInteger u = (NSUInteger)i;
    return (u >= r.location && ( u - r.location ) < r.length);
}

/* Returns true if CFIndex i is within CFRange r. */
static inline BOOL in_cfrange(CFRange r, CFIndex i)
{
    return (i >= r.location && ( i - r.location ) < r.length);
}

/* Returns true if the two ranges overlap. */
static BOOL cfRangeOverlapsCFRange(CFRange r1, CFRange r2)
{
    if (r1.location < r2.location) {
        return ( r2.location - r1.location ) < r1.length;
    } else if (r1.location > r2.location) {
        return ( r1.location - r2.location ) < r2.length;
    } else {
        /* Same start location */
        return r1.length > 0 && r2.length > 0;
    }
}

static BOOL cfRangeContainedByCFRange(CFRange r1, CFRange r2)
{
    if (r1.location < r2.location)
        return NO;
    
    if (( r1.location + r1.length ) > ( r2.location + r2.length ))
        return NO;
    
    return YES;
}

/* We're assuming that a composed character sequence corresponds to one grapheme cluster.
 * This isn't strictly true (see UNICODE Standard Annex #29 for more than you want to know about grapheme segmentation).
 * Fortunately(?), Apple's composed character sequence methods are documented to actually return grapheme-cluster boundaries rather than composed character sequence boundaries.
 */
#define CFStringGetRangeOfGraphemeClusterAtIndex(s, i) CFStringGetRangeOfComposedCharactersAtIndex(s, i)

/* Returns the square of the distance between two points; useful if you only need it for comparison with other distances */
static inline CGFloat dist_sqr(CGPoint a, CGPoint b)
{
    CGFloat dx = (a.x - b.x);
    CGFloat dy = (a.y - b.y);
    return dx*dx + dy*dy;
}

/* Aligns an extent (one dimension of a rectangle) so that its edges lie on half-integer coordinates, under the 1-dimensional affine transform given by translate and scale. This attempts to keep the rectangle's size roughly the same, unlike CGRectIntegral() (but like -[NSView centerScanRect:]). */
static void alignExtentToPixelCenters(CGFloat translate, CGFloat scale, CGFloat *origin, CGFloat *size)
{
    CGFloat xsize = *size * scale;
    CGFloat xorigin = ( *origin * scale ) + translate;
    CGFloat rxsize = OUIRound(xsize);
    CGFloat adjustment = xsize - rxsize;
    CGFloat rxorigin = xorigin;
    
    if (fabs(adjustment) > 1e-3) {
        *size = ( rxsize / scale );
        rxorigin += adjustment * 0.5;
    }
    
    rxorigin = OUIFloor(rxorigin) + 0.5;
    if (fabs(rxorigin - xorigin) > 1e-3) {
        *origin = ( rxorigin - translate ) / scale;
    }
}

/*
 Searches for the CTLine containing a given string index (queryIndex), confining the search to the range [l,h).
 The line's index is returned and a line ref is stored in *foundLine.
 If the index is not found, a value outside [l,h) returned and *foundLine is not modified.
 Note that the index is interpreted as referring to a character, not to an intercharacter space.
*/
static CFIndex bsearchLines(CFArrayRef lines, CFIndex l, CFIndex h, CFIndex queryIndex, CTLineRef *foundLine)
{
    CFIndex orig_h = h;
    
    while (h > l) {
        CFIndex m = ( h + l - 1 ) >> 1;
        CTLineRef line = CFArrayGetValueAtIndex(lines, m);
        CFRange lineRange = CTLineGetStringRange(line);
        
        if (lineRange.location > queryIndex) {
            h = m;
        } else if ((lineRange.location + lineRange.length) > queryIndex) {
            if (foundLine)
                *foundLine = line;
            return m;
        } else {
            l = m + 1;
        }
    }
    return ( l < orig_h )? kCFNotFound : l;
}

/* Similar to bsearchLines(), but finds a CTRun within a CTLine. */
/* We can't do a binary search, because runs are visually ordered, not logically ordered (experimentally true, but undocumented) */
/* Hopefully a given character index will only ever be claimed by one run... */
/* Note: Probably a pre-composed character whose base or combining mark must be rendered from a fallback font will result in two runs generated from a single string index */
static CFIndex searchRuns(CFArrayRef runs, CFIndex l, CFIndex h, CFRange queryRange, CTRunRef *foundRun)
{
    while (l < h) {
        CTRunRef run = CFArrayGetValueAtIndex(runs, l);
        CFRange runRange = CTRunGetStringRange(run);
        
        if (cfRangeOverlapsCFRange(runRange, queryRange)) {
            *foundRun = run;
            return l;
        }
        
        l ++;
    }

    return kCFNotFound;
}

enum runPosition {
    pastLeft = -1,
    middle = 0,
    pastRight = 1
};

/* Given a run's range and flags, returns whether a given (logical) string index is to the left, within, or to the right of the run */
static enum runPosition __attribute__((const)) runOffset(CTRunStatus runFlags, CFRange runRange, CFIndex pos)
{
    /* TODO: Deal with nonmonotonic layouts */
    
    if (pos < runRange.location) {
        if (runFlags & kCTRunStatusRightToLeft)
            return pastRight;
        else
            return pastLeft;
    }
    
    if (pos >= (runRange.location + runRange.length)) {
        if (runFlags & kCTRunStatusRightToLeft)
            return pastLeft;
        else
            return pastRight;
    }
    
    return middle;
}

/* These flags are passed to the rectanglesInRangeCallback to indicate why the left and right edges of a given rectangle are where they are. An edge might be the beginning or the end of the range being iterated over; they might be caused by a line break; or they could be caused by a run break in mixed-direction text (if neither RangeBoundary nor LineWrap are set). */
#define rectwalker_LeftIsRangeBoundary  ( 00001 )
#define rectwalker_RightIsRangeBoundary ( 00002 )
#define rectwalker_LeftIsLineWrap       ( 00004 )
#define rectwalker_RightIsLineWrap      ( 00010 )
#define rectwalker_FirstRectInLine      ( 00020 )
#define rectwalker_FirstLine            ( 00040 )

#define rectwalker_LeftFlags (rectwalker_LeftIsRangeBoundary|rectwalker_LeftIsLineWrap)
#define rectwalker_RightFlags (rectwalker_RightIsRangeBoundary|rectwalker_RightIsLineWrap)
#define rectwalker_LineFlags (rectwalker_FirstLine /* | rectwalker_LastLine */ )

typedef BOOL (*rectanglesInRangeCallback)(CGPoint origin, CGFloat width, CGFloat trailingWhitespaceWidth, CGFloat ascent, CGFloat descent, CGFloat leading, /* NSRange textRange, */ unsigned flags, void *p);

static CGFloat __attribute__((const)) min4(CGFloat a, CGFloat b, CGFloat c, CGFloat d)
{
    a = MIN(a, b);
    c = MIN(c, d);
    return MIN(a,c);
}
static CGFloat __attribute__((const)) max4(CGFloat a, CGFloat b, CGFloat c, CGFloat d)
{
    a = MAX(a, b);
    c = MAX(c, d);
    return MAX(a,c);
}

static CGFloat leftRunBoundary(CTLineRef line, CTRunRef run)
{
    /* There doesn't seem to be an explicit way to get the left boundary of a run, so we just return the x-position of its first glyph. */
    const CGPoint *positions = CTRunGetPositionsPtr(run);
    if (positions)
        return positions[0].x;
    
    CGPoint position[1];
    CTRunGetPositions(run, (CFRange){0, 1}, position);
    
    return position[0].x;
}

/* Macros for invoking the callback (usually with a 0 for the trailing whitespace width) */
#define RECT_tww(start, end, tww, flags) do{ CGFloat start_ = (start); BOOL shouldContinue = (*cb)( (CGPoint){ lineOrigin.x + start_, lineOrigin.y }, (end) - start_, tww, ascent, descent, leading, (flags) | (rectsIssued? 0 : rectwalker_FirstRectInLine) | lineFlags, ctxt); if (!shouldContinue) return -1; rectsIssued ++; }while(0)
#define RECT(start, end, flags) RECT_tww(start, end, 0, flags)

static unsigned int rectanglesInLine(CTLineRef line, CGPoint lineOrigin, NSRange r, unsigned boundaryFlags, rectanglesInRangeCallback cb, void *ctxt)
{
    CFArrayRef runs = CTLineGetGlyphRuns(line);
    CFIndex runCount = CFArrayGetCount(runs);
    CGFloat ascent = NAN, descent = NAN, leading = NAN;
    CGFloat lineWidth = CTLineGetTypographicBounds(line, &ascent, &descent, &leading);
    int rectsIssued = 0;
    
    /* Since different runs have different layout directions, a selection of a single line can cover multiple noncontiguous rectangles. However, each rectangle boundary is either at the position of the selection's start/end, or it's at a run boundary. (I'm ignoring nonmonotonic runs since I don't know what situation might generate them or what the proper selection display is in those situations.) */
    
    CGFloat startPosSecondaryOffset, endPosSecondaryOffset;
    CGFloat startPosOffset = CTLineGetOffsetForStringIndex(line, r.location, &startPosSecondaryOffset);
    CGFloat endPosOffset = CTLineGetOffsetForStringIndex(line, r.location + r.length, &endPosSecondaryOffset);
    unsigned leftFlags = ( boundaryFlags & rectwalker_LeftFlags );   // Flags to apply to the leftmost rectangle
    unsigned rightFlags = ( boundaryFlags & rectwalker_RightFlags ); // Flags to apply to the rightmost rectangle
    unsigned lineFlags = ( boundaryFlags & rectwalker_LineFlags );   // Flags to apply to all rectangles in this line
    
    /* Loop through all the runs in the line, figuring out whether the range intersects the run's range at all, and if so, what it contributes to the list of rectangles we're delivering to the callback. */
    
    for(CFIndex i = 0; i < runCount; i++) {
        CTRunRef run = CFArrayGetValueAtIndex(runs, i);
        CFRange runRange = CTRunGetStringRange(run);
        CTRunStatus runFlags = CTRunGetStatus(run);
        
        enum runPosition p1 = runOffset(runFlags, runRange, r.location);
        enum runPosition p2 = runOffset(runFlags, runRange, r.location + r.length);
                
        CGFloat rectStart;
        int rectFlags;

        if (p1 == pastLeft) {
            if (p2 == pastLeft) {
                // If this run contains nothing from our range, we don't need to return it.
                continue;
            }
            rectStart = leftRunBoundary(line, run);
            rectFlags = 0; // Left edge of rect is synthetic (run boundary not range boundary)
            if (i == 0)
                rectFlags |= leftFlags; // But it may be a line wrap
            if (p2 == pastRight) {
                // Fall through to multiple-run case
            } else {
                // p2 == middle
                RECT(rectStart, MAX(endPosOffset, endPosSecondaryOffset), rectFlags | rectwalker_RightIsRangeBoundary);
                continue;
            }
        } else if (p1 == middle) {
            if (p2 == pastLeft) {
                rectFlags = rectwalker_RightIsRangeBoundary;
                if (i == 0)
                    rectFlags |= leftFlags; // First (leftmost) run in line may be wrapped from previous line
                RECT(leftRunBoundary(line, run), MAX(startPosOffset, startPosSecondaryOffset), rectFlags);
                continue;
            } else if (p2 == middle) {
                RECT(min4(startPosOffset, startPosSecondaryOffset, endPosOffset, endPosSecondaryOffset),
                     max4(startPosOffset, startPosSecondaryOffset, endPosOffset, endPosSecondaryOffset),
                     rectwalker_LeftIsRangeBoundary | rectwalker_RightIsRangeBoundary);
                continue;
            } else {
                // p2 == pastRight
                rectStart = MIN(startPosOffset, startPosSecondaryOffset);
                rectFlags = rectwalker_LeftIsRangeBoundary;
                // Fall through to multiple-run case
            }
        } else /* if (p1 == pastRight) */ {
            if (p2 == pastLeft) {
                rectStart = leftRunBoundary(line, run);
                rectFlags = 0; // Left edge of rect is synthetic (run boundary not range boundary)
                if (i == 0)
                    rectFlags |= leftFlags; // But leftmost run in line may be a line wrap
                // Fall through to multiple-run case
            } else if (p2 == middle) {
                rectStart = MIN(endPosOffset, endPosSecondaryOffset);
                rectFlags = rectwalker_LeftIsRangeBoundary;
                // Fall through to multiple-run case
            } else {
                // If this run contains nothing from our range, we don't need to return it.
                continue;
            }
        }
        
        // If we reach this point, either p1 or p2 was pastRight, so we've started a rect (offset stored in rectStart) but not finished it yet.
        BOOL ended = NO;
        for(i++; i < runCount; i++) {
            run = CFArrayGetValueAtIndex(runs, i);
            runRange = CTRunGetStringRange(run);
            runFlags = CTRunGetStatus(run);
            
            enum runPosition p1 = runOffset(runFlags, runRange, r.location);
            enum runPosition p2 = runOffset(runFlags, runRange, r.location + r.length);
            
            if (p1 == pastLeft) {
                if (p2 == pastLeft) {
                    // Weird, but OK.
                    RECT(rectStart, leftRunBoundary(line, run), rectFlags);
                    ended = YES;
                    break;
                } else if (p2 == middle) {
                    RECT(rectStart, MAX(endPosOffset, endPosSecondaryOffset), rectFlags | rectwalker_RightIsRangeBoundary);
                    ended = YES;
                    break;
                } else {
                    // p2 == pastRight; keep searching
                }
            } else if (p1 == middle) {
                if (p2 == pastLeft) {
                    RECT(rectStart, MAX(startPosOffset, startPosSecondaryOffset), rectFlags | rectwalker_RightIsRangeBoundary);
                    ended = YES;
                    break;
                } else if (p2 == middle) {
                    RECT(rectStart, leftRunBoundary(line, run), rectFlags);
                    RECT(min4(startPosOffset, startPosSecondaryOffset, endPosOffset, endPosSecondaryOffset),
                         max4(startPosOffset, startPosSecondaryOffset, endPosOffset, endPosSecondaryOffset),
                         rectwalker_LeftIsRangeBoundary | rectwalker_RightIsRangeBoundary);
                    ended = YES;
                    break;
                } else {
                    // p2 is pastRight; we'll need to end one rect and start another.
                    RECT(rectStart, leftRunBoundary(line, run), rectFlags);
                    rectStart = MIN(startPosOffset, startPosSecondaryOffset);
                    rectFlags = rectwalker_LeftIsRangeBoundary;
                    // ended = NO;  (actually, ended and began again)
                }
            } else {
                // p1 == pastRight
                if (p2 == pastLeft) {
                    // keep searching
                } else if (p2 == middle) {
                    // We'll need to end one rect and start another.
                    RECT(rectStart, leftRunBoundary(line, run), rectFlags);
                    rectStart = MIN(endPosOffset, endPosSecondaryOffset);
                    rectFlags = rectwalker_LeftIsRangeBoundary;
                    // ended = NO;  (actually, ended and began again)
                } else {
                    // p2 == pastRight
                    // I don't think this should happen, but I guess we can handle it
                    RECT(rectStart, leftRunBoundary(line, run), rectFlags);
                    ended = YES;
                    break;
                }
            }
        }
        
        if (!ended) {
            // Must have run off the end of the line. 
            RECT_tww(rectStart, lineWidth, CTLineGetTrailingWhitespaceWidth(line), rectFlags | rightFlags);
        }
        
    }
    
    return rectsIssued;
}

static void rectanglesInRange(CTFrameRef frame, NSRange r, BOOL sloppy, rectanglesInRangeCallback cb, void *ctxt)
{
    if (!frame)
        return;
    CFArrayRef lines = CTFrameGetLines(frame);
    if (!lines)
        return;
    CFIndex lineCount = CFArrayGetCount(lines);
    
    CFIndex firstLine = bsearchLines(lines, 0, lineCount, r.location, NULL);
    if (firstLine < 0 || firstLine >= lineCount)
        return;
    
    /* Walk through all the lines containing a part of the range */
    for (CFIndex lineIndex = firstLine; lineIndex < lineCount; lineIndex ++) {
        CTLineRef line = CFArrayGetValueAtIndex(lines, lineIndex);
        CFRange lineRange = CTLineGetStringRange(line);
        CGFloat left, right;
        CGFloat ascent = NAN, descent = NAN, leading = NAN;
        CGFloat lineWidth = CTLineGetTypographicBounds(line, &ascent, &descent, &leading);
        NSRange spanRange;
        int flags = ( lineIndex == firstLine )? rectwalker_FirstLine : 0;
        
        /* We know that lineRange.location >= 0 here, so it's safe to cast it to NSUInteger */
        if (r.location + r.length < (NSUInteger)lineRange.location)
            break;
        else if (r.location <= (NSUInteger)lineRange.location) {
            /* The range started before this line */
            left = 0;
            spanRange.location = (NSUInteger)lineRange.location;
            flags |= rectwalker_LeftIsLineWrap;
        } else {
            /* The range starts after this line does --- presumably it starts during this line */
            left = CTLineGetOffsetForStringIndex(line, r.location, NULL);
            spanRange.location = r.location;
            flags |= rectwalker_LeftIsRangeBoundary;
        }
        
        BOOL lastLine;
        
        if (in_range(r, lineRange.location + lineRange.length)) {
            /* The end of this line (or rather, the first location past this line) is still within the range, so this isn't the last line */
            right = lineWidth;
            spanRange.length = ( lineRange.location + lineRange.length ) - spanRange.location;
            if ((lineIndex+1) < lineCount)
                lastLine = NO;
            else
                lastLine = YES;
            flags |= rectwalker_RightIsLineWrap;
        } else {
            /* This is the last line that we'll be enumerating */
            right = CTLineGetOffsetForStringIndex(line, r.location + r.length, NULL);
            spanRange.length = ( r.location + r.length ) - spanRange.location;
            lastLine = YES;
            flags |= rectwalker_RightIsRangeBoundary;
        }
        
        /* Go ahead and be precise instead of sloppy if there's only one line involved */
        if (lastLine && sloppy && lineIndex == firstLine)
            sloppy = NO;
        
        CGPoint lineOrigin[1];
        CTFrameGetLineOrigins(frame, (CFRange){ lineIndex, 1 }, lineOrigin);
        
        BOOL keepGoing;
        
        if (! (flags & (rectwalker_LeftIsRangeBoundary|rectwalker_RightIsRangeBoundary))  ||  sloppy) {
            flags |= rectwalker_FirstRectInLine; // the only rect in the line, in fact
            CGFloat trailingWhitespace = (flags & rectwalker_RightIsLineWrap)? CTLineGetTrailingWhitespaceWidth(line) : 0;
            keepGoing = (*cb)( (CGPoint){ lineOrigin[0].x + left, lineOrigin[0].y }, right - left, trailingWhitespace, ascent, descent, leading, flags, ctxt);
        } else {
            int parts = rectanglesInLine(line, lineOrigin[0], r, flags, cb, ctxt);
            if (parts < 0)
                keepGoing = NO;
            else {
                keepGoing = YES;
            }
        }
        
        if (!keepGoing || lastLine)
            break;
    }
}

struct typographicPosition {
    CFIndex lineIndex;                // The line in the laid-out frame
    CTLineRef line;                   // The line object
    CFIndex adjustedIndex;            // String index
    enum typographicCaretContext {
        beginsText = -2,
        beginsLine = -1,
        midLine    =  0,
        endsLine   =  1,
        endsText   =  2
    } position;
};

static struct typographicPosition getTypographicPosition(CFArrayRef lines, NSUInteger posIndex, UITextStorageDirection affinity)
{
    struct typographicPosition result = {0};
    
    CFIndex lineCount = CFArrayGetCount(lines);
    CFIndex posIndex_s = (CFIndex)posIndex;
    CFIndex adjustedIndex;
    
    CTLineRef line = NULL;
    CFIndex caretLineNumber = bsearchLines(lines, 0, lineCount, posIndex_s, &line);
    
    if (!line) {
        if (caretLineNumber < 0 && lineCount > 0) {
            caretLineNumber = 0;
            line = CFArrayGetValueAtIndex(lines, caretLineNumber);
            result.position = beginsText;
            CFRange lineRange = CTLineGetStringRange(line);
            adjustedIndex = lineRange.location;
        } else if (lineCount == 0) {
            result.lineIndex = kCFNotFound;
            result.line = NULL;
            return result;
        } else /* if (caretLineNumber >= lineCount) */ {
            if (affinity == UITextStorageDirectionBackward) {
                caretLineNumber = lineCount-1;
                line = CFArrayGetValueAtIndex(lines, caretLineNumber);
                result.position = endsText;
                CFRange lineRange = CTLineGetStringRange(line);
                adjustedIndex = lineRange.location + lineRange.length;
            } else {
                result.lineIndex = kCFNotFound;
                result.line = NULL;
                return result;
            }
        }
    } else {
        CFRange lineRange = CTLineGetStringRange(line);
        if (lineRange.location >= posIndex_s) {
            if (affinity == UITextStorageDirectionBackward && caretLineNumber > 0) {
                caretLineNumber --;
                line = CFArrayGetValueAtIndex(lines, caretLineNumber);
                result.position = endsLine;
            } else {
                result.position = beginsLine;
            }
        } else if (lineRange.location + lineRange.length <= posIndex_s) {
            if (affinity == UITextStorageDirectionBackward && caretLineNumber+1 < lineCount) {
                caretLineNumber = caretLineNumber+1;
                line = CFArrayGetValueAtIndex(lines, caretLineNumber);
                result.position = beginsLine;
            } else {
                result.position = endsLine;
            }
        } else {
            result.position = midLine;
        }
        adjustedIndex = posIndex_s;
    }
    
    result.lineIndex = caretLineNumber;
    result.line = line;
    result.adjustedIndex = adjustedIndex;
    return result;
}

typedef enum {
    OUIEditableFrameMutationOptionNotifyInputDelegate = (1 << 0),
    OUIEditableFrameMutationOptionNotifyNotEditingTextStorage = (1 << 1), // Set if *we* aren't causing the edit or wanting to notify the text storage of the edit.
    OUIEditableFrameMutationOptionAttributesOnly = (1 << 2),
} OUIEditableFrameMutationOptions;

/* The pattern of housekeeping we need to do around every change to our content. Call beforeMutate() before changing _content, afterMutate() after changing the content, and notifyAfterMutate() some time after that before returning from the method. */
static BOOL beforeMutate(OUIEditableFrame *self, SEL _cmd, OUIEditableFrameMutationOptions options)
{
    NSUInteger wasGeneration = self->generation;
    
    // We generally don't want to show the context menu while the user is typing.
    DEBUG_CONTEXT_MENU(@"In %s", __func__);
    [self->_editMenuController hideMenu];
    
    if ((options & OUIEditableFrameMutationOptionAttributesOnly) == 0) {
        // If the inspector is visible and this isn't just an attribute change, hide it immediately (iWork does) instead of trying to keep the typing attributes up to date or whatnot (for one thing, we don't want the insertion pointer going behind the inspector). One risk here is if the inspector has some sort of deferred edit (like editing the font size via the keyboard). We'll assert that we are the first responder (so the there should be no editing text field on the inspector). There's still the possibility of some crazy inspector slice committing changes when it loses first responder, so we might want to have a reentrancy check on these mutation hooks...
        if ([self->_textInspector isVisible]) {
            OBASSERT([self isFirstResponder]);
            [self->_textInspector dismissAnimated:NO];
        }
    }
    
    if (options & OUIEditableFrameMutationOptionNotifyInputDelegate) {
        DEBUG_TEXT(@">>> textWillChange (%@)", NSStringFromSelector(_cmd));
        [self->inputDelegate textWillChange:self];
        DEBUG_TEXT(@"<<< textWillChange (%@)", NSStringFromSelector(_cmd));
        
        if (wasGeneration != self->generation) {
            DEBUG_TEXT(@"Aborting %@ due to stupidity of UITextInputDelegate (RADAR 7881864 / 7696512)", NSStringFromSelector(_cmd));
            DEBUG_TEXT(@">>> textDidChange (%@/abort)", NSStringFromSelector(_cmd));
            [self->inputDelegate textDidChange:self];
            DEBUG_TEXT(@"<<< textDidChange (%@/abort)", NSStringFromSelector(_cmd));
            return NO;
        }
    }
    
    [self->immutableContent release];
    self->immutableContent = nil;
    
    if ((options & OUIEditableFrameMutationOptionNotifyNotEditingTextStorage) == 0)
        [self->_content beginEditing];
    
    return YES;
}

static inline void afterMutate(OUIEditableFrame *self, SEL _cmd, OUIEditableFrameMutationOptions options)
{
    [self _didChangeContent];
    
    if ((options & OUIEditableFrameMutationOptionNotifyNotEditingTextStorage) == 0)
        [self->_content endEditing];
}

static void notifyAfterMutate(OUIEditableFrame *self, SEL _cmd, OUIEditableFrameMutationOptions options)
{
    if (options & OUIEditableFrameMutationOptionNotifyInputDelegate) {
        DEBUG_TEXT(@">>> textDidChange (%@)", NSStringFromSelector(_cmd));
        [self->inputDelegate textDidChange:self];
        DEBUG_TEXT(@"<<< textDidChange (%@)", NSStringFromSelector(_cmd));
    }

    if (self->flags.delegateRespondsToContentsChanged) {
        DEBUG_TEXT(@">>> textViewContentsChanged (%@)", NSStringFromSelector(_cmd));
        [self->delegate textViewContentsChanged:self];
        DEBUG_TEXT(@"<<< textViewContentsChanged (%@)", NSStringFromSelector(_cmd));
    }
    
    DEBUG_TEXT(@">>> OUIEditableFrameTextDidChangeNotification (%@)", NSStringFromSelector(_cmd));
    [[NSNotificationCenter defaultCenter] postNotificationName:OUIEditableFrameTextDidChangeNotification object:self];
    DEBUG_TEXT(@"<<< OUIEditableFrameTextDidChangeNotification (%@)", NSStringFromSelector(_cmd));
}

static void afterContentReplaced(OUIEditableFrame *self)
{
    [self unmarkText];
    
    OUEFTextRange *newSelection = [[OUEFTextRange alloc] initWithRange:(NSRange){ [self->_content length], 0 } generation:self->generation];
    [self _setSelectedTextRange:newSelection notifyDelegate:YES];
    [newSelection release];
    
    [self->inputDelegate textDidChange:self];
    
    /* GraphSketcher's TextEditor class doesn't expect us to call it back here. Not sure which way is better. 
     if (flags.delegateRespondsToContentsChanged)
     [delegate textViewContentsChanged:self];
     */
    
    [self setNeedsDisplay];
}

static BOOL _rangeIsInsertionPoint(OUIEditableFrame *self, UITextRange *r)
{
    OBPRECONDITION([r isKindOfClass:[OUEFTextRange class]]);
    
    if (r == self->selection)
        return YES;
    
    return [r isEmpty] && [(OUEFTextRange *)r isEqualToRange:self->selection];
}

- (NSRange)_rangeToReplace;
{
    NSRange replaceRange;
    
    if (markedRange.location != NSNotFound) {
        // Replace marked text.
        replaceRange = markedRange;
    } else if (selection) {
        replaceRange = selection.range;
    } else {
        replaceRange = NSMakeRange([_content length], 0);
    }
    
    return replaceRange;
}

- (void)dealloc;
{
    // If we're still registered for scroll notifications at deallocation time, then we failed to update our registrations when the view hierarchy changed.
    DEBUG_SCROLL(@"%s", __func__);
    OBASSERT(!isRegisteredForScrollNotifications);
    OUIUnregisterForScrollNotifications(self);
    
    for(int i = 0; i < EF_NUM_ACTION_RECOGNIZERS; i++) {
        [actionRecognizers[i] release];
    }

    [focusRecognizer release];
    [_rangeSelectionColor release];
    
    if (defaultParagraphStyle)
        CFRelease(defaultParagraphStyle);
    if (defaultFont)
        CFRelease(defaultFont);
    [textColor release];
    
    OBASSERT(!_content || _content.delegate == self);
    _content.delegate = nil;
    [_content release];
    
    [_backgroundSpanFilter release];
    
    [selection release];
    [_typingAttributes release];
    [_insertionPointSelectionColor release];
    [markedTextStyle release];
    [_linkTextAttributes release];
    [immutableContent release];
    if (framesetter)
        CFRelease(framesetter);
    if (drawnFrame)
        CFRelease(drawnFrame);
    [_loupe release];
    [tokenizer release];
    
    [_markedRangeBorderColor release];
    [_markedRangeBackgroundColor release];
    
    [_editMenuController invalidate];
    [_editMenuController release];
    
    [_textInspector release];
    
    [super dealloc];
}

#pragma mark -
#pragma mark Conversion between CoreGraphics text and UIKIt coodinates

/*
 We have a bunch of coordinate systems:
 
 The "view" coordinate system is the UIView frame/bounds coordinates. Its Y-coordinate always increases downwards ("flipped") and its units are the same size as the rasterization pixels (device pixels or layer pixels or whatever).
 
 The "text" or "rendering" coordinate system is the interior scaled, (de-)flipped, and possibly translated system for CoreGraphics calls to draw stuff.
 
 The "layout" coordinate system is translated from the rendering coordinate system because CTFramesetter is particular about where it puts its text.
 The layoutOrigin ivar holds the coordinates, in the rendering coordinate system, of the layout coordinate system's origin.
 
 Some locations are in a line-based coordinate system, which is the text layout coordinate system translated so that a given line's origin is at (0,0).

*/

#pragma mark -
#pragma mark Drawing and display

/* We have four possible selection display modes:
 1. No selection displayed
 2. Caret displayed
 3. Simple selection (a simple rectangle)
 4. Complex selection (arbitrary region, eg multi-line selection)
 */

#pragma mark -
#pragma mark Properties and API

- (OATextStorage *)textStorage;
{
    if (!_content) {
        Class textStorageClass = [[self class] textStorageClass];
        if (!textStorageClass)
            return nil; // returning Nil disables implicit text storage creation. Some owner will need to give us one.
        
        OBASSERT(OBClassIsSubclassOfClass(textStorageClass, [OATextStorage class]));
        
        _content = [[textStorageClass alloc] init];
        _content.delegate = self;
    }
    
    return _content;
}

- (void)setTextStorage:(OATextStorage *)textStorage;
{
    if (_content == textStorage)
        return;
    
    OUIEditableFrameMutationOptions options = OUIEditableFrameMutationOptionNotifyInputDelegate|OUIEditableFrameMutationOptionNotifyNotEditingTextStorage;
    if (!beforeMutate(self, _cmd, options))
        return;
    
    OBASSERT(!_content || _content.delegate == self);
    _content.delegate = nil;
    [_content release];
    
    OBASSERT(textStorage.delegate == nil);
    _content = [textStorage retain];
    _content.delegate = self;
    
    afterMutate(self, _cmd, options);
    afterContentReplaced(self);
}

@synthesize textColor;
@synthesize tapSelectionGranularity;
@synthesize selection;
@synthesize selectionColor = _insertionPointSelectionColor;
- (void)setSelectionColor:(UIColor *)color;
{
    if (OFISEQUAL(_insertionPointSelectionColor, color))
        return;
    
    [_insertionPointSelectionColor release];
    _insertionPointSelectionColor = [color retain];
    
    
#if 1
    /* iOS doesn't have colorspace support to speak of. Let's just hope that the color components we get are RGBA or something close enough that this works. */
    CGColorRef c = [color CGColor];
    const CGFloat *components = CGColorGetComponents(c);
    int componentCount = CGColorGetNumberOfComponents(c);
    CGFloat newComponents[5];
    CGFloat blend = 0.25 * components[componentCount-1];
    for (int componentIndex = 0; componentIndex < componentCount-1; componentIndex ++) {
        newComponents[componentIndex] = ( blend * components[componentIndex] ) + ( 1 - blend );
    }
    newComponents[componentCount-1] = 1;
    CGColorRef newColor = CGColorCreate(CGColorGetColorSpace(c), newComponents);
    
    [_rangeSelectionColor release];
    _rangeSelectionColor = [[UIColor colorWithCGColor:newColor] retain];
    CFRelease(newColor);
#else
    [_rangeSelectionColor release];
    _rangeSelectionColor = [[_insertionPointSelectionColor colorWithAlphaComponent:0.25] retain];
#endif
    
    if (selection)
        [self setNeedsDisplay];
}

@synthesize markedRangeBorderColor = _markedRangeBorderColor;
@synthesize markedRangeBackgroundColor = _markedRangeBackgroundColor;
@synthesize markedRangeBorderThickness = _markedRangeBorderThickness;

@synthesize textInset = _minimumTextInset;
- (void)setTextInset:(UIEdgeInsets)newInset;
{
    if (UIEdgeInsetsEqualToEdgeInsets(newInset, _minimumTextInset))
        return;
    
    _minimumTextInset = newInset;
    
    // We could avoid this if we are in unlimited layout mode rather than having a specific layout size or an implicit size of our frame. But likely it'll be set once before we have any text anyway.
    [self setNeedsLayout];
}

@synthesize textLayoutSize = layoutSize;
- (void)setTextLayoutSize:(CGSize)size;
{
    if (CGSizeEqualToSize(layoutSize, size))
        return;
    layoutSize = size;
    
    if (drawnFrame) {
        CFRelease(drawnFrame);
        drawnFrame = NULL;
    }
    [self setNeedsLayout];
}

- (CGSize)textUsedSize;
{
    if (!drawnFrame || flags.textNeedsUpdate)
        [self _updateLayout:YES];
    
    OBASSERT(drawnFrame);
    if (drawnFrame) {
        CGSize textSize = _usedSize;
        textSize.width += _currentTextInset.left + _currentTextInset.right;
        textSize.height += _currentTextInset.top + _currentTextInset.bottom;
        
        return textSize;
    }
    return CGSizeZero;
}

- (CGSize)viewUsedSize;
{
    CGSize textUsedSize = self.textUsedSize;
    CGFloat scale = self.scale;
    return CGSizeMake(textUsedSize.width * scale, textUsedSize.height * scale);
}

- (BOOL)shouldTryToCenterFirstLine;
{
    return flags.shouldTryToCenterFirstLine;
}

- (void)setShouldTryToCenterFirstLine:(BOOL)newValue;
{
    if (flags.shouldTryToCenterFirstLine == newValue)
        return;

    flags.shouldTryToCenterFirstLine = newValue;
    [self setNeedsLayout];
}

@synthesize firstLineCenterTarget = _firstLineCenterTarget;

- (void)setFirstLineCenterTarget:(CGFloat)newTarget;
{
    if (_firstLineCenterTarget == newTarget)
        return;

    _firstLineCenterTarget = newTarget;
    [self setNeedsLayout];
}

- (BOOL)endEditing;
{
    DEBUG_EDITING(@"-endEditing called");

    if (!flags.isEditing) {
        OBASSERT(![self isFirstResponder]);
        DEBUG_EDITING(@"Wasn't editing");
        return YES;
    }
    
    if ([self isFirstResponder]) {
        // Calling super to avoid our checks that would avoid ending editing ('should' delegate, etc).
        if (![super resignFirstResponder]) {
            DEBUG_EDITING(@"Unable to resign first responder");
            return NO;
        } else {
            DEBUG_EDITING(@"Resigned first responder");
        }
    }

    if ([delegate respondsToSelector:@selector(textViewWillEndEditing:)])
        [delegate textViewWillEndEditing:self];
    
    flags.isEditing = NO;
        
    // If user taps the close button on the simulated keyboard, for example.
    if ([_textInspector isVisible])
        [_textInspector dismissAnimated:YES];
    
    focusRecognizer.enabled = YES;
    for(int i = 0; i < EF_NUM_ACTION_RECOGNIZERS; i++) {
        UIGestureRecognizer *recognizer = actionRecognizers[i];
        if (recognizer)
            recognizer.enabled = NO;
    }
    
    if (startThumb) {
        [startThumb removeFromSuperview];
        startThumb.editor = nil;
        [startThumb release];
        startThumb = nil;
    }
    if (endThumb) {
        [endThumb removeFromSuperview];
        endThumb.editor = nil;
        [endThumb release];
        endThumb = nil;
    }
    if (_loupe) {
        [_loupe removeFromSuperview];
        [_loupe setSubjectView:nil];
        [_loupe release];
        _loupe = nil;
    }
    
    [self setNeedsLayout];
    
    if (selection)
        [self setNeedsDisplay];

    if (delegate && [delegate respondsToSelector:@selector(textViewDidEndEditing:)])
        [delegate textViewDidEndEditing:self];
    
    return YES;
}

- (void)setDelegate:(id <OUIEditableFrameDelegate>)newDelegate
{
    delegate = newDelegate;
    
    // Cache some responds-to information.
    // Don't bother caching everything, just the methods we call frequently during use.
    
    flags.delegateRespondsToLayoutChanged = [newDelegate respondsToSelector:@selector(textViewLayoutChanged:)];
    flags.delegateRespondsToContentsChanged = [newDelegate respondsToSelector:@selector(textViewContentsChanged:)];
    flags.delegateRespondsToShouldInsertText = [newDelegate respondsToSelector:@selector(textView:shouldInsertText:)];
    flags.delegateRespondsToShouldDeleteBackwardsFromIndex = [newDelegate respondsToSelector:@selector(textView:shouldDeleteBackwardsFromIndex:)];
    flags.delegateRespondsToSelectionChanged = [newDelegate respondsToSelector:@selector(textViewSelectionChanged:)];
    
    _editMenuController.delegate = delegate;
}

@synthesize delegate;

@synthesize backgroundSpanFilter = _backgroundSpanFilter;
- (void)setBackgroundSpanFilter:(OUITextLayoutSpanBackgroundFilter)backgroundSpanFilter;
{
    if (_backgroundSpanFilter == backgroundSpanFilter)
        return;
    [_backgroundSpanFilter release];
    _backgroundSpanFilter = [backgroundSpanFilter copy];
    
    [self setNeedsDisplay];
}

- (void)setDefaultCTFont:(CTFontRef)newFont
{
    if (!newFont)
        newFont = OUIGlobalDefaultFont();
    
    if (newFont == defaultFont)
        return;
    
    if (defaultFont)
        CFRelease(defaultFont);
    defaultFont = CFRetain(newFont);
}

- (CTFontRef)defaultCTFont;
{
    return defaultFont;
}

- (void)setDefaultCTParagraphStyle:(CTParagraphStyleRef)newStyle
{
    if (newStyle == defaultParagraphStyle)
        return;
    
    if (defaultParagraphStyle)
        CFRelease(defaultParagraphStyle);
    defaultParagraphStyle = CFRetain(newStyle);
}

- (CTParagraphStyleRef)defaultCTParagraphStyle;
{
    return defaultParagraphStyle;
}

@synthesize linkTextAttributes = _linkTextAttributes;

- (void)setSelectedTextRange:(UITextRange *)newRange_ showingMenu:(BOOL)show;
{
    OUEFTextRange *newRange = (OUEFTextRange *)newRange_;
    OBPRECONDITION(newRange == nil || [newRange isKindOfClass:[OUEFTextRange class]]);
    
    DEBUG_TEXT(@"-- setSelectedTextRange:%@ %@", ne…