FadingTextView.m

/*
     File: FadingTextView.m
 Abstract: A view that implements NSTextInputClient by using the Cocoa text system objects NSTextStorage, NSLayoutManager, and NSTextContainer. The view centers and displays any typed text. When the user enters a newline, the text fades out, leaving an empty field. The view also handles marked text, such as the acute accent that appears when typing the character "é" (option-e, then e). Marked characters are displayed in gray.
  Version: 1.2
 
 Disclaimer: IMPORTANT:  This Apple software is supplied to you by Apple
 Inc. ("Apple") in consideration of your agreement to the following
 terms, and your use, installation, modification or redistribution of
 this Apple software constitutes acceptance of these terms.  If you do
 not agree with these terms, please do not use, install, modify or
 redistribute this Apple software.
 
 In consideration of your agreement to abide by the following terms, and
 subject to these terms, Apple grants you a personal, non-exclusive
 license, under Apple's copyrights in this original Apple software (the
 "Apple Software"), to use, reproduce, modify and redistribute the Apple
 Software, with or without modifications, in source and/or binary forms;
 provided that if you redistribute the Apple Software in its entirety and
 without modifications, you must retain this notice and the following
 text and disclaimers in all such redistributions of the Apple Software.
 Neither the name, trademarks, service marks or logos of Apple Inc. may
 be used to endorse or promote products derived from the Apple Software
 without specific prior written permission from Apple.  Except as
 expressly stated in this notice, no other rights or licenses, express or
 implied, are granted by Apple herein, including but not limited to any
 patent rights that may be infringed by your derivative works or by other
 works in which the Apple Software may be incorporated.
 
 The Apple Software is provided by Apple on an "AS IS" basis.  APPLE
 MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
 THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
 FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
 OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
 
 IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
 OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
 MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
 AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
 STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 
 Copyright (C) 2012 Apple Inc. All Rights Reserved.
 
 */
 
 
#import "FadingTextView.h"
 
static const NSTimeInterval kDefaultAnimationInterval = 0.02;
static const NSTimeInterval kDefaultAnimationTime = 1.0;
 
static const CGFloat kLargeWidthForTextContainer = 5e6; // large enough to not clip/wrap text, but not so large the text system stops centering for us
static const CGFloat kTextToFrameRatio = 0.5; // tall enough for most characters to fit in the default window
 
@implementation FadingTextView
 
- (id)initWithFrame:(NSRect)frame {
    self = [super initWithFrame:frame];
    if (self) {
        // Set up text attributes
        NSMutableParagraphStyle *paragraphStyle = [[NSParagraphStyle defaultParagraphStyle] mutableCopy];
        [paragraphStyle setAlignment:NSCenterTextAlignment];
        NSFont *font = [NSFont systemFontOfSize:ceil(NSHeight(frame) * kTextToFrameRatio)];
        
        defaultAttributes = [[NSMutableDictionary alloc] initWithObjectsAndKeys:
            paragraphStyle, NSParagraphStyleAttributeName,
            font, NSFontAttributeName,
            nil];
        markedAttributes = [[NSMutableDictionary alloc] initWithObjectsAndKeys:
            paragraphStyle, NSParagraphStyleAttributeName,
            font, NSFontAttributeName,
            [NSColor lightGrayColor], NSForegroundColorAttributeName,
            nil];
        [paragraphStyle release];
        
        // Set up the text system
        backingStore = [[NSTextStorage alloc] initWithString:@"" attributes:defaultAttributes];
        
        layoutManager = [[NSLayoutManager alloc] init];
        [backingStore addLayoutManager:layoutManager];
        textContainer = [[NSTextContainer alloc] initWithContainerSize:NSMakeSize(kLargeWidthForTextContainer, NSHeight(frame))];
        [layoutManager addTextContainer:textContainer];
 
        // Calculate offset from our very wide text container
        centerOffset = floor((NSWidth(frame) - kLargeWidthForTextContainer) / 2.0);
        lineHeight = floor([layoutManager defaultLineHeightForFont:font]);
        
        // Initial values for various things
        selectedRange = NSMakeRange(0, 0);
        markedRange = NSMakeRange(NSNotFound, 0);
        
        // For animation
        currentAlpha = 1.0;
        animationInterval = kDefaultAnimationInterval;
        animationTime = kDefaultAnimationTime;
        cacheImage = [[NSImage alloc] initWithSize:NSZeroSize];
    }
    return self;
}
 
- (void)dealloc {
    [animateTimer invalidate];
    [animateTimer release];
    [cacheImage release];
    
    [backingStore release];
    [layoutManager release];
    [textContainer release];
    
    [defaultAttributes release];
    [markedAttributes release];
    
    [super dealloc];
}
 
- (void)finalize {
    [animateTimer invalidate];
    
    [super finalize];
}
 
- (void)animate:(NSTimer *)timer {    
    if (currentAlpha < 0.0) {
        [self endAnimation];
    } else {
        currentAlpha = 1.0 + ([(NSDate *)[timer userInfo] timeIntervalSinceNow] / animationTime);
    }
    
    [self setNeedsDisplay:YES];
}
 
- (void)endAnimation {
    [animateTimer invalidate];
    [animateTimer release];
    animateTimer = nil;
    
    [cacheImage recache]; // clear the image data
    [self recalculateDimensions];
    lineHeight = floor([layoutManager defaultLineHeightForFont:[defaultAttributes objectForKey:NSFontAttributeName]]);
}
 
- (void)recalculateDimensions {
    NSRect bounds = [self bounds];
    
    // Resize font to match new height
    NSFont *font = [NSFont systemFontOfSize:ceil(NSHeight(bounds) * kTextToFrameRatio)];
    [defaultAttributes setValue:font forKey:NSFontAttributeName];
    [markedAttributes setValue:font forKey:NSFontAttributeName];
    [backingStore addAttribute:NSFontAttributeName value:font range:NSMakeRange(0, [backingStore length])];
    
    // Resize text container to match new height
    [textContainer setContainerSize:NSMakeSize(kLargeWidthForTextContainer, NSHeight(bounds))];
    centerOffset = floor((NSWidth(bounds) - kLargeWidthForTextContainer) / 2.0);
    lineHeight = floor([layoutManager defaultLineHeightForFont:font]);
    
    // Pass the word along to our input context
    [[self inputContext] invalidateCharacterCoordinates];
}
 
#pragma mark -
 
- (BOOL)isFlipped {
    return YES;
}
 
- (void)setFrame:(NSRect)frame {
    [super setFrame:frame];
    
    if (!animateTimer) {
        [self recalculateDimensions];
    }
}
 
- (void)drawRect:(NSRect)rect {    
    // First, redraw the background
    [[NSColor whiteColor] set];
    NSRectFill(rect);
    
    NSRect bounds = [self bounds];
    if (animateTimer) {
        // Use our cached image, which needs to be centered
        NSSize imageSize = [cacheImage size];
        CGFloat offsetX = floor((NSWidth(bounds) - imageSize.width) / 2.0);
        CGFloat offsetY = ceil((NSHeight(bounds) - lineHeight) / 2.0);
        
        NSRect imageRect = rect;
        
        // If the image is larger than the frame, draw the correct part of it
        // Although this changes the destination rect as well, the transform accounts for that
        if (imageSize.width > NSWidth(bounds)) {
            imageRect.origin.x -= offsetX;
        } else {
            rect.origin.x += offsetX;
        }
        
        if (imageSize.height > NSHeight(bounds)) {
            imageRect.origin.y -= offsetY;
        } else {
            rect.origin.y += offsetY;
        }
        
        // Draw it!
        
        [cacheImage drawInRect:rect fromRect:imageRect operation:NSCompositeSourceOver fraction:currentAlpha respectFlipped:YES hints:nil];        
    } else {
        // Draw the text...but only what we need to!
        NSRange glyphRange = [layoutManager glyphRangeForBoundingRect:rect inTextContainer:textContainer];
        
        // Center everything, account for our very wide text container
        NSPoint origin;
        origin.x = centerOffset;
        origin.y = floor((NSHeight(bounds) - lineHeight) / 2.0);
        
        // Draw it!
        [layoutManager drawGlyphsForGlyphRange:glyphRange atPoint:origin];
    }
}
 
#pragma mark -
 
- (BOOL)acceptsFirstResponder {
    return YES;
}
 
- (BOOL)becomeFirstResponder {
    return YES;
}
 
- (BOOL)resignFirstResponder {
    return YES;
}
 
- (void)keyDown:(NSEvent *)theEvent {
    [[self inputContext] handleEvent:theEvent];
}
 
- (void)mouseDown:(NSEvent *)theEvent {
    [[self inputContext] handleEvent:theEvent];
}
 
- (void)mouseDragged:(NSEvent *)theEvent {
    [[self inputContext] handleEvent:theEvent];
}
 
- (void)mouseUp:(NSEvent *)theEvent {
    [[self inputContext] handleEvent:theEvent];
}
 
- (void)insertNewline:(id)sender {
    // Save the current text to an image, so we can draw it quickly during animation
    // Then start the animation
    
    // Figure out how much room we need
    NSRange glyphRange = [layoutManager glyphRangeForTextContainer:textContainer];
    NSRect glyphRect = NSIntegralRect([layoutManager boundingRectForGlyphRange:glyphRange inTextContainer:textContainer]);
    
    // And where the glyphs go
    NSPoint glyphOrigin;
    glyphOrigin.x = ceil((NSWidth(glyphRect) - kLargeWidthForTextContainer) / 2.0);
    glyphOrigin.y = NSHeight(glyphRect) - lineHeight;
    
    // Size the image and lock focus
    NSSize imageSize = glyphRect.size;
    if (NSEqualSizes(imageSize, NSZeroSize)) {
        imageSize = NSMakeSize(1,1);
    }
    [cacheImage setSize:imageSize];
    [cacheImage lockFocusFlipped:YES];
    
    // First fill the background, for proper anti-aliasing
    [[NSColor whiteColor] set];
    NSRectFill(NSMakeRect(0, 0, imageSize.width, imageSize.height));
    
    // Then draw the glyphs and unlock focus
    [layoutManager drawGlyphsForGlyphRange:glyphRange atPoint:glyphOrigin];
    [cacheImage unlockFocus];
    
    // Erase the backing store; new text will stop the animation anyway
    [backingStore deleteCharactersInRange:NSMakeRange(0, [backingStore length])];
    selectedRange = NSMakeRange(0,0);
    [self unmarkText];
 
    // Start fully opaque
    currentAlpha = 1.0;
 
    // Create the timer...
    [animateTimer invalidate];
    [animateTimer release];
    animateTimer = [[NSTimer timerWithTimeInterval:animationInterval target:self selector:@selector(animate:) userInfo:[NSDate date] repeats:YES] retain];
    
    // And start the animation!
    NSRunLoop *runLoop = [NSRunLoop currentRunLoop];
    [runLoop addTimer:animateTimer forMode:NSDefaultRunLoopMode];
    [runLoop addTimer:animateTimer forMode:NSEventTrackingRunLoopMode]; // for live resize
}
 
- (void)deleteBackward:(id)sender {
    // Find the range to delete, handling an empty selection and the input point being at 0
    NSRange deleteRange = selectedRange;
    if (deleteRange.length == 0) {
        if (deleteRange.location == 0) {
            return;
        } else {
            deleteRange.location -= 1;
            deleteRange.length = 1;
            
            // Make sure we handle composed characters correctly
            deleteRange = [[backingStore string] rangeOfComposedCharacterSequencesForRange:deleteRange];
        }
    }
    
    [self deleteCharactersInRange:deleteRange];
}
 
- (void)deleteForward:(id)sender {
    // Find the range to delete, handling an empty selection and the input point being at the end
    NSRange deleteRange = selectedRange;
    if (deleteRange.length == 0) {
        if (deleteRange.location == [backingStore length]) {
            return;
        } else {
            deleteRange.length = 1;
            
            // Make sure we handle composed characters correctly
            deleteRange = [[backingStore string] rangeOfComposedCharacterSequencesForRange:deleteRange];
        }
    }
    
    [self deleteCharactersInRange:deleteRange];
}
 
- (void)deleteCharactersInRange:(NSRange)range {
    // Update the marked range
    if (NSLocationInRange(NSMaxRange(range), markedRange)) {
        markedRange.length -= NSMaxRange(range) - markedRange.location;
        markedRange.location = range.location;
    } else if (markedRange.location > range.location) {
        markedRange.location -= range.length;
    }
    
    if (markedRange.length == 0) {
        [self unmarkText];
    }
    
    // Actually delete the characters
    [backingStore deleteCharactersInRange:range];
    selectedRange.location = range.location;
    selectedRange.length = 0;
    
    [[self inputContext] invalidateCharacterCoordinates];
    [self setNeedsDisplay:YES];
}
 
#pragma mark -
 
- (void)doCommandBySelector:(SEL)aSelector {
    [super doCommandBySelector:aSelector]; // NSResponder's implementation will do nicely
}
 
- (void)insertText:(id)aString replacementRange:(NSRange)replacementRange {
    // Get a valid range
    if (animateTimer) {
        [self endAnimation];
        replacementRange = NSMakeRange(0, 0);
    } else if (replacementRange.location == NSNotFound) {
        if (markedRange.location != NSNotFound) {
            replacementRange = markedRange;
        } else {
            replacementRange = selectedRange;
        }
    }
 
    // Add the text
    [backingStore beginEditing];
    if ([aString isKindOfClass:[NSAttributedString class]]) {
        [backingStore replaceCharactersInRange:replacementRange withAttributedString:aString];
    } else {
        [backingStore replaceCharactersInRange:replacementRange withString:aString];
    }
    [backingStore setAttributes:defaultAttributes range:NSMakeRange(replacementRange.location, [aString length])];
    [backingStore endEditing];
    
    // Redisplay
    selectedRange = NSMakeRange([backingStore length], 0); // We don't support selection, so just place the insertion point at the end
    [self unmarkText];
    [[self inputContext] invalidateCharacterCoordinates]; // recentering
    [self setNeedsDisplay:YES];
}
 
- (void)setMarkedText:(id)aString selectedRange:(NSRange)newSelection replacementRange:(NSRange)replacementRange {
    // Get a valid range
    if (animateTimer) {
        [self endAnimation];
        replacementRange = NSMakeRange(0, 0);
    } else if (replacementRange.location == NSNotFound) {
        if (markedRange.location != NSNotFound) {
            replacementRange = markedRange;
        } else {
            replacementRange = selectedRange;
        }
    }
 
    // Add the text
    [backingStore beginEditing];
    if ([aString length] == 0) {
        [backingStore deleteCharactersInRange:replacementRange];
        [self unmarkText];
    } else {
        markedRange = NSMakeRange(replacementRange.location, [aString length]);
        if ([aString isKindOfClass:[NSAttributedString class]]) {
            [backingStore replaceCharactersInRange:replacementRange withAttributedString:aString];
        } else {
            [backingStore replaceCharactersInRange:replacementRange withString:aString];
        }
        [backingStore addAttributes:markedAttributes range:markedRange];
    }
    [backingStore endEditing];
    
    // Redisplay
    selectedRange.location = replacementRange.location + newSelection.location; // Just for now, only select the marked text
    selectedRange.length = newSelection.length;
    [[self inputContext] invalidateCharacterCoordinates]; // recentering
    [self setNeedsDisplay:YES];
}
 
- (void)unmarkText {
    markedRange = NSMakeRange(NSNotFound, 0);
    [[self inputContext] discardMarkedText];
}
 
- (NSRange)selectedRange {
    return selectedRange;
}
 
- (NSRange)markedRange {
    return markedRange;
}
 
- (BOOL)hasMarkedText {
    return (markedRange.location == NSNotFound ? NO : YES);
}
 
- (NSAttributedString *)attributedSubstringForProposedRange:(NSRange)aRange actualRange:(NSRangePointer)actualRange {
    // We choose not to adjust the range, though we have the option
    if (actualRange) {
        *actualRange = aRange;
    }
    return [backingStore attributedSubstringFromRange:aRange];
}
 
- (NSArray *)validAttributesForMarkedText {
    // We only allow these attributes to be set on our marked text (plus standard attributes)
    // NSMarkedClauseSegmentAttributeName is important for CJK input, among other uses
    // NSGlyphInfoAttributeName allows alternate forms of characters
    return [NSArray arrayWithObjects:NSMarkedClauseSegmentAttributeName, NSGlyphInfoAttributeName, nil];
}
 
- (NSRect)firstRectForCharacterRange:(NSRange)aRange actualRange:(NSRangePointer)actualRange {
    // Ask the layout manager
    NSRange glyphRange = [layoutManager glyphRangeForCharacterRange:aRange actualCharacterRange:actualRange];
    NSRect glyphRect = [layoutManager boundingRectForGlyphRange:glyphRange inTextContainer:textContainer];
    glyphRect.origin.x += centerOffset;
    
    // Convert the rect to screen coordinates
    glyphRect = [self convertRectToBase:glyphRect];
    glyphRect.origin = [[self window] convertBaseToScreen:glyphRect.origin];
    return glyphRect;
}
 
- (NSUInteger)characterIndexForPoint:(NSPoint)aPoint {
    // Convert the point from screen coordinates
    NSPoint localPoint = [self convertPointFromBase:[[self window] convertScreenToBase:aPoint]];
    localPoint.x -= centerOffset;
    
    // Ask the layout manager
    NSUInteger glyphIndex = [layoutManager glyphIndexForPoint:localPoint inTextContainer:textContainer fractionOfDistanceThroughGlyph:NULL];
    return [layoutManager characterIndexForGlyphAtIndex:glyphIndex];
}
 
- (NSAttributedString *)attributedString {
    // This method is optional, but our backing store is an attributed string anyway
    return backingStore;
}
 
- (NSInteger)windowLevel {
    // This method is optional but easy to implement
    return [[self window] level];
}
 
- (CGFloat)fractionOfDistanceThroughGlyphForPoint:(NSPoint)aPoint {
    // This method is optional but would help with mouse-related activities, such as selection
    // Unfortunately we don't support selection
    
    // Convert the point from screen coordinates
    NSPoint localPoint = [self convertPointFromBase:[[self window] convertScreenToBase:aPoint]];
    localPoint.x -= centerOffset;
    
    // Ask the layout manager
    CGFloat fraction = 0.5;
    [layoutManager glyphIndexForPoint:localPoint inTextContainer:textContainer fractionOfDistanceThroughGlyph:&fraction];
    return fraction;
}
 
- (CGFloat)baselineDeltaForCharacterAtIndex:(NSUInteger)anIndex {
    // This method is optional but helps position other elements next to the characters, such as the box that allows you to choose which Chinese or Japanese characters you want to input.
    
    // Get the first glyph corresponding to this character
    NSUInteger glyphIndex = [layoutManager glyphIndexForCharacterAtIndex:anIndex];
    
    if (glyphIndex != NSNotFound) {
        // Ask the layout manager's typesetter
        return [[layoutManager typesetter] baselineOffsetInLayoutManager:layoutManager glyphIndex:glyphIndex];
    } else {
        // Fall back to the layout manager and font
        return [layoutManager defaultBaselineOffsetForFont:[defaultAttributes objectForKey:NSFontAttributeName]];
    }
}
 
// No implementation of -drawsVerticallyForCharacterAtIndex:, which means all characters are assumed to be drawn horizontally.
// This is consistent with the current behavior of NSLayoutManager.
// If you are drawing vertically, you should implement this method.
 
#pragma mark -
 
- (NSString *)stringValue {
    return [[[backingStore string] retain] autorelease];
}
 
- (void)setStringValue:(NSString *)aString {
    [backingStore beginEditing];
    [backingStore replaceCharactersInRange:NSMakeRange(0, [backingStore length]) withString:aString];
    [backingStore setAttributes:defaultAttributes range:NSMakeRange(0, [aString length])];
    [backingStore endEditing];
        
    [self unmarkText];
    selectedRange = NSMakeRange([aString length], 0);
    
    if (animateTimer) {
        [self endAnimation];
    }
    
    [[self inputContext] invalidateCharacterCoordinates];
    [self setNeedsDisplay:YES];
}
 
@synthesize animationInterval, animationTime;
@end


Copyright © 2012 Apple Inc. All Rights Reserved. Terms of Use | Privacy Policy | Updated: 2012-06-05