screen_ios.git - Gitblit

New file
			@@ -0,0 +1,767 @@
			/***********************************************************************************
			*
			* The MIT License (MIT)
			*
			* Copyright (c) 2013 Matthew Styles
			*
			* Permission is hereby granted, free of charge, to any person obtaining a copy of
			* this software and associated documentation files (the "Software"), to deal in
			* the Software without restriction, including without limitation the rights to
			* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
			* the Software, and to permit persons to whom the Software is furnished to do so,
			* subject to the following conditions:
			*
			* The above copyright notice and this permission notice shall be included in all
			* copies or substantial portions of the Software.
			*
			* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
			* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
			* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
			* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
			* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
			* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
			*
			***********************************************************************************/

			#import "KILabel.h"

			NSString * const KILabelLinkTypeKey = @"linkType";
			NSString * const KILabelRangeKey = @"range";
			NSString * const KILabelLinkKey = @"link";

			#pragma mark - Private Interface

			@interface KILabel()

			// Used to control layout of glyphs and rendering
			@property (nonatomic, retain) NSLayoutManager *layoutManager;

			// Specifies the space in which to render text
			@property (nonatomic, retain) NSTextContainer *textContainer;

			// Backing storage for text that is rendered by the layout manager
			@property (nonatomic, retain) NSTextStorage *textStorage;

			// Dictionary of detected links and their ranges in the text
			@property (nonatomic, copy) NSArray *linkRanges;

			// State used to trag if the user has dragged during a touch
			@property (nonatomic, assign) BOOL isTouchMoved;

			// During a touch, range of text that is displayed as selected
			@property (nonatomic, assign) NSRange selectedRange;

			@end

			#pragma mark - Implementation

			@implementation KILabel
			{
			NSMutableDictionary *_linkTypeAttributes;
			}

			#pragma mark - Construction

			- (id)initWithFrame:(CGRect)frame
			{
			self = [super initWithFrame:frame];
			if (self)
			{
			[self setupTextSystem];
			}

			return self;
			}

			- (id)initWithCoder:(NSCoder *)aDecoder
			{
			self = [super initWithCoder:aDecoder];
			if (self)
			{
			[self setupTextSystem];
			}

			return self;
			}

			// Common initialisation. Must be done once during construction.
			- (void)setupTextSystem
			{
			// Create a text container and set it up to match our label properties
			_textContainer = [[NSTextContainer alloc] init];
			_textContainer.lineFragmentPadding = 0;
			_textContainer.maximumNumberOfLines = self.numberOfLines;
			_textContainer.lineBreakMode = self.lineBreakMode;
			_textContainer.size = self.frame.size;

			// Create a layout manager for rendering
			_layoutManager = [[NSLayoutManager alloc] init];
			_layoutManager.delegate = self;
			[_layoutManager addTextContainer:_textContainer];

			// Attach the layou manager to the container and storage
			[_textContainer setLayoutManager:_layoutManager];

			// Make sure user interaction is enabled so we can accept touches
			self.userInteractionEnabled = YES;

			// Don't go via public setter as this will have undesired side effect
			_automaticLinkDetectionEnabled = YES;

			// All links are detectable by default
			_linkDetectionTypes = KILinkTypeOptionAll;

			// Link Type Attributes. Default is empty (no attributes).
			_linkTypeAttributes = [NSMutableDictionary dictionary];

			// Don't underline URL links by default.
			_systemURLStyle = NO;

			// By default we hilight the selected link during a touch to give feedback that we are
			// responding to touch.
			_selectedLinkBackgroundColor = [UIColor colorWithWhite:0.95 alpha:1.0];

			// Establish the text store with our current text
			[self updateTextStoreWithText];
			}

			#pragma mark - Text and Style management

			- (void)setAutomaticLinkDetectionEnabled:(BOOL)decorating
			{
			_automaticLinkDetectionEnabled = decorating;

			// Make sure the text is updated properly
			[self updateTextStoreWithText];
			}

			- (void)setLinkDetectionTypes:(KILinkTypeOption)linkDetectionTypes
			{
			_linkDetectionTypes = linkDetectionTypes;

			// Make sure the text is updated properly
			[self updateTextStoreWithText];
			}

			- (NSDictionary *)linkAtPoint:(CGPoint)location
			{
			// Do nothing if we have no text
			if (_textStorage.string.length == 0)
			{
			return nil;
			}

			// Work out the offset of the text in the view
			CGPoint textOffset = [self calcGlyphsPositionInView];

			// Get the touch location and use text offset to convert to text cotainer coords
			location.x -= textOffset.x;
			location.y -= textOffset.y;

			NSUInteger touchedChar = [_layoutManager glyphIndexForPoint:location inTextContainer:_textContainer];

			// If the touch is in white space after the last glyph on the line we don't
			// count it as a hit on the text
			NSRange lineRange;
			CGRect lineRect = [_layoutManager lineFragmentUsedRectForGlyphAtIndex:touchedChar effectiveRange:&lineRange];
			if (CGRectContainsPoint(lineRect, location) == NO)
			return nil;

			// Find the word that was touched and call the detection block
			for (NSDictionary *dictionary in self.linkRanges)
			{
			NSRange range = [[dictionary objectForKey:KILabelRangeKey] rangeValue];

			if ((touchedChar >= range.location) && touchedChar < (range.location + range.length))
			{
			return dictionary;
			}
			}

			return nil;
			}

			// Applies background color to selected range. Used to hilight touched links
			- (void)setSelectedRange:(NSRange)range
			{
			// Remove the current selection if the selection is changing
			if (self.selectedRange.length && !NSEqualRanges(self.selectedRange, range))
			{
			[_textStorage removeAttribute:NSBackgroundColorAttributeName range:self.selectedRange];
			}

			// Apply the new selection to the text
			if (range.length && _selectedLinkBackgroundColor != nil)
			{
			[_textStorage addAttribute:NSBackgroundColorAttributeName value:_selectedLinkBackgroundColor range:range];
			}

			// Save the new range
			_selectedRange = range;

			[self setNeedsDisplay];
			}

			- (void)setNumberOfLines:(NSInteger)numberOfLines
			{
			[super setNumberOfLines:numberOfLines];

			_textContainer.maximumNumberOfLines = numberOfLines;
			}

			- (void)setText:(NSString *)text
			{
			// Pass the text to the super class first
			[super setText:text];

			// Update our text store with an attributed string based on the original
			// label text properties.
			if (!text)
			{
			text = @"";
			}

			NSAttributedString *attributedText = [[NSAttributedString alloc] initWithString:text attributes:[self attributesFromProperties]];
			[self updateTextStoreWithAttributedString:attributedText];
			}

			- (void)setAttributedText:(NSAttributedString *)attributedText
			{
			// Pass the text to the super class first
			[super setAttributedText:attributedText];

			[self updateTextStoreWithAttributedString:attributedText];
			}

			- (void)setSystemURLStyle:(BOOL)systemURLStyle
			{
			_systemURLStyle = systemURLStyle;

			// Force refresh
			self.text = self.text;
			}

			- (NSDictionary*)attributesForLinkType:(KILinkType)linkType
			{
			NSDictionary *attributes = _linkTypeAttributes[@(linkType)];

			if (!attributes)
			{
			attributes = @{NSForegroundColorAttributeName : self.tintColor};
			}

			return attributes;
			}

			- (void)setAttributes:(NSDictionary*)attributes forLinkType:(KILinkType)linkType
			{
			if (attributes)
			{
			_linkTypeAttributes[@(linkType)] = attributes;
			}
			else
			{
			[_linkTypeAttributes removeObjectForKey:@(linkType)];
			}

			// Force refresh text
			self.text = self.text;
			}

			#pragma mark - Text Storage Management

			- (void)updateTextStoreWithText
			{
			// Now update our storage from either the attributedString or the plain text
			if (self.attributedText)
			{
			[self updateTextStoreWithAttributedString:self.attributedText];
			}
			else if (self.text)
			{
			[self updateTextStoreWithAttributedString:[[NSAttributedString alloc] initWithString:self.text attributes:[self attributesFromProperties]]];
			}
			else
			{
			[self updateTextStoreWithAttributedString:[[NSAttributedString alloc] initWithString:@"" attributes:[self attributesFromProperties]]];
			}

			[self setNeedsDisplay];
			}

			- (void)updateTextStoreWithAttributedString:(NSAttributedString *)attributedString
			{
			if (attributedString.length != 0)
			{
			attributedString = [KILabel sanitizeAttributedString:attributedString];
			}

			if (self.isAutomaticLinkDetectionEnabled && (attributedString.length != 0))
			{
			self.linkRanges = [self getRangesForLinks:attributedString];
			attributedString = [self addLinkAttributesToAttributedString:attributedString linkRanges:self.linkRanges];
			}
			else
			{
			self.linkRanges = nil;
			}

			if (_textStorage)
			{
			// Set the string on the storage
			[_textStorage setAttributedString:attributedString];
			}
			else
			{
			// Create a new text storage and attach it correctly to the layout manager
			_textStorage = [[NSTextStorage alloc] initWithAttributedString:attributedString];
			[_textStorage addLayoutManager:_layoutManager];
			[_layoutManager setTextStorage:_textStorage];
			}
			}

			// Returns attributed string attributes based on the text properties set on the label.
			// These are styles that are only applied when NOT using the attributedText directly.
			- (NSDictionary *)attributesFromProperties
			{
			// Setup shadow attributes
			NSShadow *shadow = shadow = [[NSShadow alloc] init];
			if (self.shadowColor)
			{
			shadow.shadowColor = self.shadowColor;
			shadow.shadowOffset = self.shadowOffset;
			}
			else
			{
			shadow.shadowOffset = CGSizeMake(0, -1);
			shadow.shadowColor = nil;
			}

			// Setup color attributes
			UIColor *color = self.textColor;
			if (!self.isEnabled)
			{
			color = [UIColor lightGrayColor];
			}
			else if (self.isHighlighted)
			{
			color = self.highlightedTextColor;
			}

			// Setup paragraph attributes
			NSMutableParagraphStyle *paragraph = [[NSMutableParagraphStyle alloc] init];
			paragraph.alignment = self.textAlignment;

			// Create the dictionary
			NSDictionary *attributes = @{NSFontAttributeName : self.font,
			NSForegroundColorAttributeName : color,
			NSShadowAttributeName : shadow,
			NSParagraphStyleAttributeName : paragraph,
			};
			return attributes;
			}

			/**
			* Returns array of ranges for all special words, user handles, hashtags and urls in the specfied
			* text.
			*
			* @param text Text to parse for links
			*
			* @return Array of dictionaries describing the links.
			*/
			- (NSArray )getRangesForLinks:(NSAttributedString )text
			{
			NSMutableArray *rangesForLinks = [[NSMutableArray alloc] init];

			if (self.linkDetectionTypes & KILinkTypeOptionUserHandle)
			{
			[rangesForLinks addObjectsFromArray:[self getRangesForUserHandles:text.string]];
			}

			if (self.linkDetectionTypes & KILinkTypeOptionHashtag)
			{
			[rangesForLinks addObjectsFromArray:[self getRangesForHashtags:text.string]];
			}

			if (self.linkDetectionTypes & KILinkTypeOptionURL)
			{
			[rangesForLinks addObjectsFromArray:[self getRangesForURLs:self.attributedText]];
			}

			return rangesForLinks;
			}

			- (NSArray )getRangesForUserHandles:(NSString )text
			{
			NSMutableArray *rangesForUserHandles = [[NSMutableArray alloc] init];

			// Setup a regular expression for user handles and hashtags
			static NSRegularExpression *regex = nil;
			static dispatch_once_t onceToken;
			dispatch_once(&onceToken, ^{
			NSError *error = nil;
			regex = [[NSRegularExpression alloc] initWithPattern:@"(?<!\\w)@([\\w\\_]+)?" options:0 error:&error];
			});

			// Run the expression and get matches
			NSArray *matches = [regex matchesInString:text options:0 range:NSMakeRange(0, text.length)];

			// Add all our ranges to the result
			for (NSTextCheckingResult *match in matches)
			{
			NSRange matchRange = [match range];
			NSString *matchString = [text substringWithRange:matchRange];

			if (![self ignoreMatch:matchString])
			{
			[rangesForUserHandles addObject:@{KILabelLinkTypeKey : @(KILinkTypeUserHandle),
			KILabelRangeKey : [NSValue valueWithRange:matchRange],
			KILabelLinkKey : matchString
			}];
			}
			}

			return rangesForUserHandles;
			}

			- (NSArray )getRangesForHashtags:(NSString )text
			{
			NSMutableArray *rangesForHashtags = [[NSMutableArray alloc] init];

			// Setup a regular expression for user handles and hashtags
			static NSRegularExpression *regex = nil;
			static dispatch_once_t onceToken;
			dispatch_once(&onceToken, ^{
			NSError *error = nil;
			regex = [[NSRegularExpression alloc] initWithPattern:@"(?<!\\w)#([\\w\\_]+)?" options:0 error:&error];
			});

			// Run the expression and get matches
			NSArray *matches = [regex matchesInString:text options:0 range:NSMakeRange(0, text.length)];

			// Add all our ranges to the result
			for (NSTextCheckingResult *match in matches)
			{
			NSRange matchRange = [match range];
			NSString *matchString = [text substringWithRange:matchRange];

			if (![self ignoreMatch:matchString])
			{
			[rangesForHashtags addObject:@{KILabelLinkTypeKey : @(KILinkTypeHashtag),
			KILabelRangeKey : [NSValue valueWithRange:matchRange],
			KILabelLinkKey : matchString,
			}];
			}
			}

			return rangesForHashtags;
			}


			- (NSArray )getRangesForURLs:(NSAttributedString )text
			{
			NSMutableArray *rangesForURLs = [[NSMutableArray alloc] init];;

			// Use a data detector to find urls in the text
			NSError *error = nil;
			NSDataDetector *detector = [[NSDataDetector alloc] initWithTypes:NSTextCheckingTypeLink error:&error];

			NSString *plainText = text.string;

			NSArray *matches = [detector matchesInString:plainText
			options:0
			range:NSMakeRange(0, text.length)];

			// Add a range entry for every url we found
			for (NSTextCheckingResult *match in matches)
			{
			NSRange matchRange = [match range];

			// If there's a link embedded in the attributes, use that instead of the raw text
			NSString *realURL = [text attribute:NSLinkAttributeName atIndex:matchRange.location effectiveRange:nil];
			if (realURL == nil)
			realURL = [plainText substringWithRange:matchRange];

			if (![self ignoreMatch:realURL])
			{
			if ([match resultType] == NSTextCheckingTypeLink)
			{
			[rangesForURLs addObject:@{KILabelLinkTypeKey : @(KILinkTypeURL),
			KILabelRangeKey : [NSValue valueWithRange:matchRange],
			KILabelLinkKey : realURL,
			}];
			}
			}
			}

			return rangesForURLs;
			}

			- (BOOL)ignoreMatch:(NSString*)string
			{
			return [_ignoredKeywords containsObject:[string lowercaseString]];
			}

			- (NSAttributedString )addLinkAttributesToAttributedString:(NSAttributedString )string linkRanges:(NSArray *)linkRanges
			{
			NSMutableAttributedString *attributedString = [[NSMutableAttributedString alloc] initWithAttributedString:string];

			for (NSDictionary *dictionary in linkRanges)
			{
			NSRange range = [[dictionary objectForKey:KILabelRangeKey] rangeValue];
			KILinkType linkType = [dictionary[KILabelLinkTypeKey] unsignedIntegerValue];

			NSDictionary *attributes = [self attributesForLinkType:linkType];

			// Use our tint color to hilight the link
			[attributedString addAttributes:attributes range:range];

			// Add an URL attribute if this is a URL
			if (_systemURLStyle && ((KILinkType)[dictionary[KILabelLinkTypeKey] unsignedIntegerValue] == KILinkTypeURL))
			{
			// Add a link attribute using the stored link
			[attributedString addAttribute:NSLinkAttributeName value:dictionary[KILabelLinkKey] range:range];
			}
			}

			return attributedString;
			}

			#pragma mark - Layout and Rendering

			- (CGRect)textRectForBounds:(CGRect)bounds limitedToNumberOfLines:(NSInteger)numberOfLines
			{
			// Use our text container to calculate the bounds required. First save our
			// current text container setup
			CGSize savedTextContainerSize = _textContainer.size;
			NSInteger savedTextContainerNumberOfLines = _textContainer.maximumNumberOfLines;

			// Apply the new potential bounds and number of lines
			_textContainer.size = bounds.size;
			_textContainer.maximumNumberOfLines = numberOfLines;

			// Measure the text with the new state
			CGRect textBounds = [_layoutManager usedRectForTextContainer:_textContainer];

			// Position the bounds and round up the size for good measure
			textBounds.origin = bounds.origin;
			textBounds.size.width = ceil(textBounds.size.width);
			textBounds.size.height = ceil(textBounds.size.height);

			if (textBounds.size.height < bounds.size.height)
			{
			// Take verical alignment into account
			CGFloat offsetY = (bounds.size.height - textBounds.size.height) / 2.0;
			textBounds.origin.y += offsetY;
			}

			// Restore the old container state before we exit under any circumstances
			_textContainer.size = savedTextContainerSize;
			_textContainer.maximumNumberOfLines = savedTextContainerNumberOfLines;

			return textBounds;
			}

			- (void)drawTextInRect:(CGRect)rect
			{
			// Don't call super implementation. Might want to uncomment this out when
			// debugging layout and rendering problems.
			// [super drawTextInRect:rect];

			// Calculate the offset of the text in the view
			NSRange glyphRange = [_layoutManager glyphRangeForTextContainer:_textContainer];
			CGPoint glyphsPosition = [self calcGlyphsPositionInView];

			// Drawing code
			[_layoutManager drawBackgroundForGlyphRange:glyphRange atPoint:glyphsPosition];
			[_layoutManager drawGlyphsForGlyphRange:glyphRange atPoint:glyphsPosition];
			}

			// Returns the XY offset of the range of glyphs from the view's origin
			- (CGPoint)calcGlyphsPositionInView
			{
			CGPoint textOffset = CGPointZero;

			CGRect textBounds = [_layoutManager usedRectForTextContainer:_textContainer];
			textBounds.size.width = ceil(textBounds.size.width);
			textBounds.size.height = ceil(textBounds.size.height);

			if (textBounds.size.height < self.bounds.size.height)
			{
			CGFloat paddingHeight = (self.bounds.size.height - textBounds.size.height) / 2.0;
			textOffset.y = paddingHeight;
			}

			return textOffset;
			}

			- (void)setFrame:(CGRect)frame
			{
			[super setFrame:frame];

			_textContainer.size = self.bounds.size;
			}

			- (void)setBounds:(CGRect)bounds
			{
			[super setBounds:bounds];

			_textContainer.size = self.bounds.size;
			}

			- (void)layoutSubviews
			{
			[super layoutSubviews];

			// Update our container size when the view frame changes
			_textContainer.size = self.bounds.size;
			}

			- (void)setIgnoredKeywords:(NSSet *)ignoredKeywords
			{
			NSMutableSet *set = [NSMutableSet setWithCapacity:ignoredKeywords.count];

			[ignoredKeywords enumerateObjectsUsingBlock:^(id obj, BOOL *stop) {
			[set addObject:[obj lowercaseString]];
			}];

			_ignoredKeywords = [set copy];
			}

			#pragma mark - Interactions

			- (void)touchesBegan:(NSSet )touches withEvent:(UIEvent )event
			{
			_isTouchMoved = NO;

			// Get the info for the touched link if there is one
			NSDictionary *touchedLink;
			CGPoint touchLocation = [[touches anyObject] locationInView:self];
			touchedLink = [self linkAtPoint:touchLocation];

			if (touchedLink)
			{
			self.selectedRange = [[touchedLink objectForKey:KILabelRangeKey] rangeValue];
			}
			else
			{
			[super touchesBegan:touches withEvent:event];
			}
			}

			- (void)touchesMoved:(NSSet )touches withEvent:(UIEvent )event
			{
			[super touchesMoved:touches withEvent:event];

			_isTouchMoved = YES;
			}

			- (void)touchesEnded:(NSSet )touches withEvent:(UIEvent )event
			{
			[super touchesEnded:touches withEvent:event];

			// If the user dragged their finger we ignore the touch
			if (_isTouchMoved)
			{
			self.selectedRange = NSMakeRange(0, 0);

			return;
			}

			// Get the info for the touched link if there is one
			NSDictionary *touchedLink;
			CGPoint touchLocation = [[touches anyObject] locationInView:self];
			touchedLink = [self linkAtPoint:touchLocation];

			if (touchedLink)
			{
			NSRange range = [[touchedLink objectForKey:KILabelRangeKey] rangeValue];
			NSString *touchedSubstring = [touchedLink objectForKey:KILabelLinkKey];
			KILinkType linkType = (KILinkType)[[touchedLink objectForKey:KILabelLinkTypeKey] intValue];

			[self receivedActionForLinkType:linkType string:touchedSubstring range:range];
			}
			else
			{
			[super touchesBegan:touches withEvent:event];
			}

			self.selectedRange = NSMakeRange(0, 0);
			}

			- (void)touchesCancelled:(NSSet )touches withEvent:(UIEvent )event
			{
			[super touchesCancelled:touches withEvent:event];

			// Make sure we don't leave a selection when the touch is cancelled
			self.selectedRange = NSMakeRange(0, 0);
			}

			- (void)receivedActionForLinkType:(KILinkType)linkType string:(NSString*)string range:(NSRange)range
			{
			switch (linkType)
			{
			case KILinkTypeUserHandle:
			if (_userHandleLinkTapHandler)
			{
			_userHandleLinkTapHandler(self, string, range);
			}
			break;

			case KILinkTypeHashtag:
			if (_hashtagLinkTapHandler)
			{
			_hashtagLinkTapHandler(self, string, range);
			}
			break;

			case KILinkTypeURL:
			if (_urlLinkTapHandler)
			{
			_urlLinkTapHandler(self, string, range);
			}
			break;
			}
			}

			#pragma mark - Layout manager delegate

			-(BOOL)layoutManager:(NSLayoutManager *)layoutManager shouldBreakLineByWordBeforeCharacterAtIndex:(NSUInteger)charIndex
			{
			// Don't allow line breaks inside URLs
			NSRange range;
			NSURL *linkURL = [layoutManager.textStorage attribute:NSLinkAttributeName atIndex:charIndex effectiveRange:&range];

			return !(linkURL && (charIndex > range.location) && (charIndex <= NSMaxRange(range)));
			}

			+ (NSAttributedString )sanitizeAttributedString:(NSAttributedString )attributedString
			{
			// Setup paragraph alignement properly. IB applies the line break style
			// to the attributed string. The problem is that the text container then
			// breaks at the first line of text. If we set the line break to wrapping
			// then the text container defines the break mode and it works.
			// NOTE: This is either an Apple bug or something I've misunderstood.

			// Get the current paragraph style. IB only allows a single paragraph so
			// getting the style of the first char is fine.
			NSRange range;
			NSParagraphStyle *paragraphStyle = [attributedString attribute:NSParagraphStyleAttributeName atIndex:0 effectiveRange:&range];

			if (paragraphStyle == nil)
			{
			return attributedString;
			}

			// Remove the line breaks
			NSMutableParagraphStyle *mutableParagraphStyle = [paragraphStyle mutableCopy];
			mutableParagraphStyle.lineBreakMode = NSLineBreakByWordWrapping;

			// Apply new style
			NSMutableAttributedString *restyled = [[NSMutableAttributedString alloc] initWithAttributedString:attributedString];
			[restyled addAttribute:NSParagraphStyleAttributeName value:mutableParagraphStyle range:NSMakeRange(0, restyled.length)];

			return restyled;
			}

			@end