screen_ios.git - Gitblit

New file
			@@ -0,0 +1,3830 @@
			//
			// YYTextView.m
			// YYText <https://github.com/ibireme/YYText>
			//
			// Created by ibireme on 15/2/25.
			// Copyright (c) 2015 ibireme.
			//
			// This source code is licensed under the MIT-style license found in the
			// LICENSE file in the root directory of this source tree.
			//

			#import "YYTextView.h"
			#import "YYTextInput.h"
			#import "YYTextContainerView.h"
			#import "YYTextSelectionView.h"
			#import "YYTextMagnifier.h"
			#import "YYTextEffectWindow.h"
			#import "YYTextKeyboardManager.h"
			#import "YYTextUtilities.h"
			#import "YYTextTransaction.h"
			#import "YYTextWeakProxy.h"
			#import "NSAttributedString+YYText.h"
			#import "UIPasteboard+YYText.h"
			#import "UIView+YYText.h"


			static double _YYDeviceSystemVersion() {
			static double version;
			static dispatch_once_t onceToken;
			dispatch_once(&onceToken, ^{
			version = [UIDevice currentDevice].systemVersion.doubleValue;
			});
			return version;
			}

			#ifndef kSystemVersion
			#define kSystemVersion _YYDeviceSystemVersion()
			#endif

			#ifndef kiOS6Later
			#define kiOS6Later (kSystemVersion >= 6)
			#endif

			#ifndef kiOS7Later
			#define kiOS7Later (kSystemVersion >= 7)
			#endif

			#ifndef kiOS8Later
			#define kiOS8Later (kSystemVersion >= 8)
			#endif

			#ifndef kiOS9Later
			#define kiOS9Later (kSystemVersion >= 9)
			#endif



			#define kDefaultUndoLevelMax 20 // Default maximum undo level

			#define kAutoScrollMinimumDuration 0.1 // Time in seconds to tick auto-scroll.
			#define kLongPressMinimumDuration 0.5 // Time in seconds the fingers must be held down for long press gesture.
			#define kLongPressAllowableMovement 10.0 // Maximum movement in points allowed before the long press fails.

			#define kMagnifierRangedTrackFix -6.0 // Magnifier ranged offset fix.
			#define kMagnifierRangedPopoverOffset 4.0 // Magnifier ranged popover offset.
			#define kMagnifierRangedCaptureOffset -6.0 // Magnifier ranged capture center offset.

			#define kHighlightFadeDuration 0.15 // Time in seconds for highlight fadeout animation.

			#define kDefaultInset UIEdgeInsetsMake(6, 4, 6, 4)
			#define kDefaultVerticalInset UIEdgeInsetsMake(4, 6, 4, 6)


			NSString *const YYTextViewTextDidBeginEditingNotification = @"YYTextViewTextDidBeginEditing";
			NSString *const YYTextViewTextDidChangeNotification = @"YYTextViewTextDidChange";
			NSString *const YYTextViewTextDidEndEditingNotification = @"YYTextViewTextDidEndEditing";


			typedef NS_ENUM (NSUInteger, YYTextGrabberDirection) {
			kStart = 1,
			kEnd = 2,
			};

			typedef NS_ENUM(NSUInteger, YYTextMoveDirection) {
			kLeft = 1,
			kTop = 2,
			kRight = 3,
			kBottom = 4,
			};


			/// An object that captures the state of the text view. Used for undo and redo.
			@interface _YYTextViewUndoObject : NSObject
			@property (nonatomic, strong) NSAttributedString *text;
			@property (nonatomic, assign) NSRange selectedRange;
			@end
			@implementation _YYTextViewUndoObject
			+ (instancetype)objectWithText:(NSAttributedString *)text range:(NSRange)range {
			_YYTextViewUndoObject *obj = [self new];
			obj.text = text ? text : [NSAttributedString new];
			obj.selectedRange = range;
			return obj;
			}
			@end


			@interface YYTextView () <UIScrollViewDelegate, UIAlertViewDelegate, YYTextDebugTarget, YYTextKeyboardObserver> {

			YYTextRange *_selectedTextRange; /// nonnull
			YYTextRange *_markedTextRange;

			__weak id<YYTextViewDelegate> _outerDelegate;

			UIImageView *_placeHolderView;

			NSMutableAttributedString *_innerText; ///< nonnull, inner attributed text
			NSMutableAttributedString *_delectedText; ///< detected text for display
			YYTextContainer *_innerContainer; ///< nonnull, inner text container
			YYTextLayout *_innerLayout; ///< inner text layout, the text in this layout is longer than `_innerText` by appending '\n'

			YYTextContainerView *_containerView; ///< nonnull
			YYTextSelectionView *_selectionView; ///< nonnull
			YYTextMagnifier *_magnifierCaret; ///< nonnull
			YYTextMagnifier *_magnifierRanged; ///< nonnull

			NSMutableAttributedString *_typingAttributesHolder; ///< nonnull, typing attributes
			NSDataDetector *_dataDetector;
			CGFloat _magnifierRangedOffset;

			NSRange _highlightRange; ///< current highlight range
			YYTextHighlight *_highlight; ///< highlight attribute in `_highlightRange`
			YYTextLayout *_highlightLayout; ///< when _state.showingHighlight=YES, this layout should be displayed
			YYTextRange *_trackingRange; ///< the range in _innerLayout, may out of _innerText.

			BOOL _insetModifiedByKeyboard; ///< text is covered by keyboard, and the contentInset is modified
			UIEdgeInsets _originalContentInset; ///< the original contentInset before modified
			UIEdgeInsets _originalScrollIndicatorInsets; ///< the original scrollIndicatorInsets before modified

			NSTimer *_longPressTimer;
			NSTimer *_autoScrollTimer;
			CGFloat _autoScrollOffset; ///< current auto scroll offset which shoud add to scroll view
			NSInteger _autoScrollAcceleration; ///< an acceleration coefficient for auto scroll
			NSTimer *_selectionDotFixTimer; ///< fix the selection dot in window if the view is moved by parents
			CGPoint _previousOriginInWindow;

			CGPoint _touchBeganPoint;
			CGPoint _trackingPoint;
			NSTimeInterval _touchBeganTime;
			NSTimeInterval _trackingTime;

			NSMutableArray *_undoStack;
			NSMutableArray *_redoStack;
			NSRange _lastTypeRange;

			struct {
			unsigned int trackingGrabber : 2; ///< YYTextGrabberDirection, current tracking grabber
			unsigned int trackingCaret : 1; ///< track the caret
			unsigned int trackingPreSelect : 1; ///< track pre-select
			unsigned int trackingTouch : 1; ///< is in touch phase
			unsigned int swallowTouch : 1; ///< don't forward event to next responder
			unsigned int touchMoved : 3; ///< YYTextMoveDirection, move direction after touch began
			unsigned int selectedWithoutEdit : 1; ///< show selected range but not first responder
			unsigned int deleteConfirm : 1; ///< delete a binding text range
			unsigned int ignoreFirstResponder : 1; ///< ignore become first responder temporary
			unsigned int ignoreTouchBegan : 1; ///< ignore begin tracking touch temporary

			unsigned int showingMagnifierCaret : 1;
			unsigned int showingMagnifierRanged : 1;
			unsigned int showingMenu : 1;
			unsigned int showingHighlight : 1;

			unsigned int typingAttributesOnce : 1; ///< apply the typing attributes once
			unsigned int clearsOnInsertionOnce : 1; ///< select all once when become first responder
			unsigned int autoScrollTicked : 1; ///< auto scroll did tick scroll at this timer period
			unsigned int firstShowDot : 1; ///< the selection grabber dot has displayed at least once
			unsigned int needUpdate : 1; ///< the layout or selection view is 'dirty' and need update
			unsigned int placeholderNeedUpdate : 1; ///< the placeholder need update it's contents

			unsigned int insideUndoBlock : 1;
			unsigned int firstResponderBeforeUndoAlert : 1;
			} _state;
			}

			@end


			@implementation YYTextView

			#pragma mark - @protocol UITextInputTraits
			@synthesize autocapitalizationType = _autocapitalizationType;
			@synthesize autocorrectionType = _autocorrectionType;
			@synthesize spellCheckingType = _spellCheckingType;
			@synthesize keyboardType = _keyboardType;
			@synthesize keyboardAppearance = _keyboardAppearance;
			@synthesize returnKeyType = _returnKeyType;
			@synthesize enablesReturnKeyAutomatically = _enablesReturnKeyAutomatically;
			@synthesize secureTextEntry = _secureTextEntry;

			#pragma mark - @protocol UITextInput
			@synthesize selectedTextRange = _selectedTextRange; //copy nonnull (YYTextRange*)
			@synthesize markedTextRange = _markedTextRange; //readonly (YYTextRange*)
			@synthesize markedTextStyle = _markedTextStyle; //copy
			@synthesize inputDelegate = _inputDelegate; //assign
			@synthesize tokenizer = _tokenizer; //readonly

			#pragma mark - @protocol UITextInput optional
			@synthesize selectionAffinity = _selectionAffinity;


			#pragma mark - Private

			/// Update layout and selection before runloop sleep/end.
			- (void)_commitUpdate {
			#if !TARGET_INTERFACE_BUILDER
			_state.needUpdate = YES;
			[[YYTextTransaction transactionWithTarget:self selector:@selector(_updateIfNeeded)] commit];
			#else
			[self _update];
			#endif
			}

			/// Update layout and selection view if needed.
			- (void)_updateIfNeeded {
			if (_state.needUpdate) {
			[self _update];
			}
			}

			/// Update layout and selection view immediately.
			- (void)_update {
			_state.needUpdate = NO;
			[self _updateLayout];
			[self _updateSelectionView];
			}

			/// Update layout immediately.
			- (void)_updateLayout {
			NSMutableAttributedString *text = _innerText.mutableCopy;
			_placeHolderView.hidden = text.length > 0;
			if ([self _detectText:text]) {
			_delectedText = text;
			} else {
			_delectedText = nil;
			}
			[text replaceCharactersInRange:NSMakeRange(text.length, 0) withString:@"\r"]; // add for nextline caret
			[text yy_removeDiscontinuousAttributesInRange:NSMakeRange(_innerText.length, 1)];
			[text removeAttribute:YYTextBorderAttributeName range:NSMakeRange(_innerText.length, 1)];
			[text removeAttribute:YYTextBackgroundBorderAttributeName range:NSMakeRange(_innerText.length, 1)];
			if (_innerText.length == 0) {
			[text yy_setAttributes:_typingAttributesHolder.yy_attributes]; // add for empty text caret
			}
			if (_selectedTextRange.end.offset == _innerText.length) {
			[_typingAttributesHolder.yy_attributes enumerateKeysAndObjectsUsingBlock:^(NSString key, id value, BOOL stop) {
			[text yy_setAttribute:key value:value range:NSMakeRange(_innerText.length, 1)];
			}];
			}
			[self willChangeValueForKey:@"textLayout"];
			_innerLayout = [YYTextLayout layoutWithContainer:_innerContainer text:text];
			[self didChangeValueForKey:@"textLayout"];
			CGSize size = [_innerLayout textBoundingSize];
			CGSize visibleSize = [self _getVisibleSize];
			if (_innerContainer.isVerticalForm) {
			size.height = visibleSize.height;
			if (size.width < visibleSize.width) size.width = visibleSize.width;
			} else {
			size.width = visibleSize.width;
			}

			[_containerView setLayout:_innerLayout withFadeDuration:0];
			_containerView.frame = (CGRect){.size = size};
			_state.showingHighlight = NO;
			self.contentSize = size;
			}

			/// Update selection view immediately.
			/// This method should be called after "layout update" finished.
			- (void)_updateSelectionView {
			_selectionView.frame = _containerView.frame;
			_selectionView.caretBlinks = NO;
			_selectionView.caretVisible = NO;
			_selectionView.selectionRects = nil;
			[[YYTextEffectWindow sharedWindow] hideSelectionDot:_selectionView];
			if (!_innerLayout) return;

			NSMutableArray *allRects = [NSMutableArray new];
			BOOL containsDot = NO;

			YYTextRange *selectedRange = _selectedTextRange;
			if (_state.trackingTouch && _trackingRange) {
			selectedRange = _trackingRange;
			}

			if (_markedTextRange) {
			NSArray *rects = [_innerLayout selectionRectsWithoutStartAndEndForRange:_markedTextRange];
			if (rects) [allRects addObjectsFromArray:rects];
			if (selectedRange.asRange.length > 0) {
			rects = [_innerLayout selectionRectsWithOnlyStartAndEndForRange:selectedRange];
			if (rects) [allRects addObjectsFromArray:rects];
			containsDot = rects.count > 0;
			} else {
			CGRect rect = [_innerLayout caretRectForPosition:selectedRange.end];
			_selectionView.caretRect = [self _convertRectFromLayout:rect];
			_selectionView.caretVisible = YES;
			_selectionView.caretBlinks = YES;
			}
			} else {
			if (selectedRange.asRange.length == 0) { // only caret
			if (self.isFirstResponder \|\| _state.trackingPreSelect) {
			CGRect rect = [_innerLayout caretRectForPosition:selectedRange.end];
			_selectionView.caretRect = [self _convertRectFromLayout:rect];
			_selectionView.caretVisible = YES;
			if (!_state.trackingCaret && !_state.trackingPreSelect) {
			_selectionView.caretBlinks = YES;
			}
			}
			} else { // range selected
			if ((self.isFirstResponder && !_state.deleteConfirm) \|\|
			(!self.isFirstResponder && _state.selectedWithoutEdit)) {
			NSArray *rects = [_innerLayout selectionRectsForRange:selectedRange];
			if (rects) [allRects addObjectsFromArray:rects];
			containsDot = rects.count > 0;
			} else if ((!self.isFirstResponder && _state.trackingPreSelect) \|\|
			(self.isFirstResponder && _state.deleteConfirm)){
			NSArray *rects = [_innerLayout selectionRectsWithoutStartAndEndForRange:selectedRange];
			if (rects) [allRects addObjectsFromArray:rects];
			}
			}
			}
			[allRects enumerateObjectsUsingBlock:^(YYTextSelectionRect rect, NSUInteger idx, BOOL stop) {
			rect.rect = [self _convertRectFromLayout:rect.rect];
			}];
			_selectionView.selectionRects = allRects;
			if (!_state.firstShowDot && containsDot) {
			_state.firstShowDot = YES;
			/*
			The dot position may be wrong at the first time displayed.
			I can't find the reason. Here's a workaround.
			*/
			dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.02 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
			[[YYTextEffectWindow sharedWindow] showSelectionDot:_selectionView];
			});
			}
			[[YYTextEffectWindow sharedWindow] showSelectionDot:_selectionView];

			if (containsDot) {
			[self _startSelectionDotFixTimer];
			} else {
			[self _endSelectionDotFixTimer];
			}
			}

			/// Update inner contains's size.
			- (void)_updateInnerContainerSize {
			CGSize size = [self _getVisibleSize];
			if (_innerContainer.isVerticalForm) size.width = CGFLOAT_MAX;
			else size.height = CGFLOAT_MAX;
			_innerContainer.size = size;
			}

			/// Update placeholder before runloop sleep/end.
			- (void)_commitPlaceholderUpdate {
			#if !TARGET_INTERFACE_BUILDER
			_state.placeholderNeedUpdate = YES;
			[[YYTextTransaction transactionWithTarget:self selector:@selector(_updatePlaceholderIfNeeded)] commit];
			#else
			[self _updatePlaceholder];
			#endif
			}

			/// Update placeholder if needed.
			- (void)_updatePlaceholderIfNeeded {
			if (_state.placeholderNeedUpdate) {
			_state.placeholderNeedUpdate = NO;
			[self _updatePlaceholder];
			}
			}

			/// Update placeholder immediately.
			- (void)_updatePlaceholder {
			CGRect frame = CGRectZero;
			_placeHolderView.image = nil;
			_placeHolderView.frame = frame;
			if (_placeholderAttributedText.length > 0) {
			YYTextContainer *container = _innerContainer.copy;
			container.size = self.bounds.size;
			container.truncationType = YYTextTruncationTypeEnd;
			container.truncationToken = nil;
			YYTextLayout *layout = [YYTextLayout layoutWithContainer:container text:_placeholderAttributedText];
			CGSize size = [layout textBoundingSize];
			BOOL needDraw = size.width > 1 && size.height > 1;
			if (needDraw) {
			UIGraphicsBeginImageContextWithOptions(size, NO, 0);
			CGContextRef context = UIGraphicsGetCurrentContext();
			[layout drawInContext:context size:size debug:self.debugOption];
			UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
			UIGraphicsEndImageContext();
			_placeHolderView.image = image;
			frame.size = image.size;
			if (container.isVerticalForm) {
			frame.origin.x = self.bounds.size.width - image.size.width;
			} else {
			frame.origin = CGPointZero;
			}
			_placeHolderView.frame = frame;
			}
			}
			}

			/// Update the `_selectedTextRange` to a single position by `_trackingPoint`.
			- (void)_updateTextRangeByTrackingCaret {
			if (!_state.trackingTouch) return;

			CGPoint trackingPoint = [self _convertPointToLayout:_trackingPoint];
			YYTextPosition *newPos = [_innerLayout closestPositionToPoint:trackingPoint];
			if (newPos) {
			newPos = [self _correctedTextPosition:newPos];
			if (_markedTextRange) {
			if ([newPos compare:_markedTextRange.start] == NSOrderedAscending) {
			newPos = _markedTextRange.start;
			} else if ([newPos compare:_markedTextRange.end] == NSOrderedDescending) {
			newPos = _markedTextRange.end;
			}
			}
			YYTextRange *newRange = [YYTextRange rangeWithRange:NSMakeRange(newPos.offset, 0) affinity:newPos.affinity];
			_trackingRange = newRange;
			}
			}

			/// Update the `_selectedTextRange` to a new range by `_trackingPoint` and `_state.trackingGrabber`.
			- (void)_updateTextRangeByTrackingGrabber {
			if (!_state.trackingTouch \|\| !_state.trackingGrabber) return;

			BOOL isStart = _state.trackingGrabber == kStart;
			CGPoint magPoint = _trackingPoint;
			magPoint.y += kMagnifierRangedTrackFix;
			magPoint = [self _convertPointToLayout:magPoint];
			YYTextPosition *position = [_innerLayout positionForPoint:magPoint
			oldPosition:(isStart ? _selectedTextRange.start : _selectedTextRange.end)
			otherPosition:(isStart ? _selectedTextRange.end : _selectedTextRange.start)];
			if (position) {
			position = [self _correctedTextPosition:position];
			if ((NSUInteger)position.offset > _innerText.length) {
			position = [YYTextPosition positionWithOffset:_innerText.length];
			}
			YYTextRange *newRange = [YYTextRange rangeWithStart:(isStart ? position : _selectedTextRange.start)
			end:(isStart ? _selectedTextRange.end : position)];
			_trackingRange = newRange;
			}
			}

			/// Update the `_selectedTextRange` to a new range/position by `_trackingPoint`.
			- (void)_updateTextRangeByTrackingPreSelect {
			if (!_state.trackingTouch) return;
			YYTextRange *newRange = [self _getClosestTokenRangeAtPoint:_trackingPoint];
			_trackingRange = newRange;
			}

			/// Show or update `_magnifierCaret` based on `_trackingPoint`, and hide `_magnifierRange`.
			- (void)_showMagnifierCaret {
			if (YYTextIsAppExtension()) return;

			if (_state.showingMagnifierRanged) {
			_state.showingMagnifierRanged = NO;
			[[YYTextEffectWindow sharedWindow] hideMagnifier:_magnifierRanged];
			}

			_magnifierCaret.hostPopoverCenter = _trackingPoint;
			_magnifierCaret.hostCaptureCenter = _trackingPoint;
			if (!_state.showingMagnifierCaret) {
			_state.showingMagnifierCaret = YES;
			[[YYTextEffectWindow sharedWindow] showMagnifier:_magnifierCaret];
			} else {
			[[YYTextEffectWindow sharedWindow] moveMagnifier:_magnifierCaret];
			}
			}

			/// Show or update `_magnifierRanged` based on `_trackingPoint`, and hide `_magnifierCaret`.
			- (void)_showMagnifierRanged {
			if (YYTextIsAppExtension()) return;

			if (_verticalForm) { // hack for vertical form...
			[self _showMagnifierCaret];
			return;
			}

			if (_state.showingMagnifierCaret) {
			_state.showingMagnifierCaret = NO;
			[[YYTextEffectWindow sharedWindow] hideMagnifier:_magnifierCaret];
			}

			CGPoint magPoint = _trackingPoint;
			if (_verticalForm) {
			magPoint.x += kMagnifierRangedTrackFix;
			} else {
			magPoint.y += kMagnifierRangedTrackFix;
			}

			YYTextRange *selectedRange = _selectedTextRange;
			if (_state.trackingTouch && _trackingRange) {
			selectedRange = _trackingRange;
			}

			YYTextPosition *position;
			if (_markedTextRange) {
			position = selectedRange.end;
			} else {
			position = [_innerLayout positionForPoint:[self _convertPointToLayout:magPoint]
			oldPosition:(_state.trackingGrabber == kStart ? selectedRange.start : selectedRange.end)
			otherPosition:(_state.trackingGrabber == kStart ? selectedRange.end : selectedRange.start)];
			}

			NSUInteger lineIndex = [_innerLayout lineIndexForPosition:position];
			if (lineIndex < _innerLayout.lines.count) {
			YYTextLine *line = _innerLayout.lines[lineIndex];
			CGRect lineRect = [self _convertRectFromLayout:line.bounds];
			if (_verticalForm) {
			magPoint.x = YYTEXT_CLAMP(magPoint.x, CGRectGetMinX(lineRect), CGRectGetMaxX(lineRect));
			} else {
			magPoint.y = YYTEXT_CLAMP(magPoint.y, CGRectGetMinY(lineRect), CGRectGetMaxY(lineRect));
			}
			CGPoint linePoint = [_innerLayout linePositionForPosition:position];
			linePoint = [self _convertPointFromLayout:linePoint];

			CGPoint popoverPoint = linePoint;
			if (_verticalForm) {
			popoverPoint.x = linePoint.x + _magnifierRangedOffset;
			} else {
			popoverPoint.y = linePoint.y + _magnifierRangedOffset;
			}

			CGPoint capturePoint;
			if (_verticalForm) {
			capturePoint.x = linePoint.x + kMagnifierRangedCaptureOffset;
			capturePoint.y = linePoint.y;
			} else {
			capturePoint.x = linePoint.x;
			capturePoint.y = linePoint.y + kMagnifierRangedCaptureOffset;
			}

			_magnifierRanged.hostPopoverCenter = popoverPoint;
			_magnifierRanged.hostCaptureCenter = capturePoint;
			if (!_state.showingMagnifierRanged) {
			_state.showingMagnifierRanged = YES;
			[[YYTextEffectWindow sharedWindow] showMagnifier:_magnifierRanged];
			} else {
			[[YYTextEffectWindow sharedWindow] moveMagnifier:_magnifierRanged];
			}
			}
			}

			/// Update the showing magnifier.
			- (void)_updateMagnifier {
			if (YYTextIsAppExtension()) return;

			if (_state.showingMagnifierCaret) {
			[[YYTextEffectWindow sharedWindow] moveMagnifier:_magnifierCaret];
			}
			if (_state.showingMagnifierRanged) {
			[[YYTextEffectWindow sharedWindow] moveMagnifier:_magnifierRanged];
			}
			}

			/// Hide the `_magnifierCaret` and `_magnifierRanged`.
			- (void)_hideMagnifier {
			if (YYTextIsAppExtension()) return;

			if (_state.showingMagnifierCaret \|\| _state.showingMagnifierRanged) {
			// disable touch began temporary to ignore caret animation overlap
			_state.ignoreTouchBegan = YES;
			__weak typeof(self) _self = self;
			dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.15 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
			__strong typeof(_self) self = _self;
			if (self) self->_state.ignoreTouchBegan = NO;
			});
			}

			if (_state.showingMagnifierCaret) {
			_state.showingMagnifierCaret = NO;
			[[YYTextEffectWindow sharedWindow] hideMagnifier:_magnifierCaret];
			}
			if (_state.showingMagnifierRanged) {
			_state.showingMagnifierRanged = NO;
			[[YYTextEffectWindow sharedWindow] hideMagnifier:_magnifierRanged];
			}
			}

			/// Show and update the UIMenuController.
			- (void)_showMenu {
			CGRect rect;
			if (_selectionView.caretVisible) {
			rect = _selectionView.caretView.frame;
			} else if (_selectionView.selectionRects.count > 0) {
			YYTextSelectionRect *sRect = _selectionView.selectionRects.firstObject;
			rect = sRect.rect;
			for (NSUInteger i = 1; i < _selectionView.selectionRects.count; i++) {
			sRect = _selectionView.selectionRects[i];
			rect = CGRectUnion(rect, sRect.rect);
			}

			CGRect inter = CGRectIntersection(rect, self.bounds);
			if (!CGRectIsNull(inter) && inter.size.height > 1) {
			rect = inter; //clip to bounds
			} else {
			if (CGRectGetMinY(rect) < CGRectGetMinY(self.bounds)) {
			rect.size.height = 1;
			rect.origin.y = CGRectGetMinY(self.bounds);
			} else {
			rect.size.height = 1;
			rect.origin.y = CGRectGetMaxY(self.bounds);
			}
			}

			YYTextKeyboardManager *mgr = [YYTextKeyboardManager defaultManager];
			if (mgr.keyboardVisible) {
			CGRect kbRect = [mgr convertRect:mgr.keyboardFrame toView:self];
			CGRect kbInter = CGRectIntersection(rect, kbRect);
			if (!CGRectIsNull(kbInter) && kbInter.size.height > 1 && kbInter.size.width > 1) {
			// self is covered by keyboard
			if (CGRectGetMinY(kbInter) > CGRectGetMinY(rect)) { // keyboard at bottom
			rect.size.height -= kbInter.size.height;
			} else if (CGRectGetMaxY(kbInter) < CGRectGetMaxY(rect)) { // keyboard at top
			rect.origin.y += kbInter.size.height;
			rect.size.height -= kbInter.size.height;
			}
			}
			}
			} else {
			rect = _selectionView.bounds;
			}

			if (!self.isFirstResponder) {
			if (!_containerView.isFirstResponder) {
			[_containerView becomeFirstResponder];
			}
			}

			if (self.isFirstResponder \|\| _containerView.isFirstResponder) {
			dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.01 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
			UIMenuController *menu = [UIMenuController sharedMenuController];
			[menu setTargetRect:CGRectStandardize(rect) inView:_selectionView];
			[menu update];
			if (!_state.showingMenu \|\| !menu.menuVisible) {
			_state.showingMenu = YES;
			[menu setMenuVisible:YES animated:YES];
			}
			});
			}
			}

			/// Hide the UIMenuController.
			- (void)_hideMenu {
			if (_state.showingMenu) {
			_state.showingMenu = NO;
			UIMenuController *menu = [UIMenuController sharedMenuController];
			[menu setMenuVisible:NO animated:YES];
			}
			if (_containerView.isFirstResponder) {
			_state.ignoreFirstResponder = YES;
			[_containerView resignFirstResponder]; // it will call [self becomeFirstResponder], ignore it temporary.
			_state.ignoreFirstResponder = NO;
			}
			}

			/// Show highlight layout based on `_highlight` and `_highlightRange`
			/// If the `_highlightLayout` is nil, try to create.
			- (void)_showHighlightAnimated:(BOOL)animated {
			NSTimeInterval fadeDuration = animated ? kHighlightFadeDuration : 0;
			if (!_highlight) return;
			if (!_highlightLayout) {
			NSMutableAttributedString *hiText = (_delectedText ? _delectedText : _innerText).mutableCopy;
			NSDictionary *newAttrs = _highlight.attributes;
			[newAttrs enumerateKeysAndObjectsUsingBlock:^(NSString key, id value, BOOL stop) {
			[hiText yy_setAttribute:key value:value range:_highlightRange];
			}];
			_highlightLayout = [YYTextLayout layoutWithContainer:_innerContainer text:hiText];
			if (!_highlightLayout) _highlight = nil;
			}

			if (_highlightLayout && !_state.showingHighlight) {
			_state.showingHighlight = YES;
			[_containerView setLayout:_highlightLayout withFadeDuration:fadeDuration];
			}
			}

			/// Show `_innerLayout` instead of `_highlightLayout`.
			/// It does not destory the `_highlightLayout`.
			- (void)_hideHighlightAnimated:(BOOL)animated {
			NSTimeInterval fadeDuration = animated ? kHighlightFadeDuration : 0;
			if (_state.showingHighlight) {
			_state.showingHighlight = NO;
			[_containerView setLayout:_innerLayout withFadeDuration:fadeDuration];
			}
			}

			/// Show `_innerLayout` and destory the `_highlight` and `_highlightLayout`.
			- (void)_removeHighlightAnimated:(BOOL)animated {
			[self _hideHighlightAnimated:animated];
			_highlight = nil;
			_highlightLayout = nil;
			}

			/// Scroll current selected range to visible.
			- (void)_scrollSelectedRangeToVisible {
			[self _scrollRangeToVisible:_selectedTextRange];
			}

			/// Scroll range to visible, take account into keyboard and insets.
			- (void)_scrollRangeToVisible:(YYTextRange *)range {
			if (!range) return;
			CGRect rect = [_innerLayout rectForRange:range];
			if (CGRectIsNull(rect)) return;
			rect = [self _convertRectFromLayout:rect];
			rect = [_containerView convertRect:rect toView:self];

			if (rect.size.width < 1) rect.size.width = 1;
			if (rect.size.height < 1) rect.size.height = 1;
			CGFloat extend = 3;

			BOOL insetModified = NO;
			YYTextKeyboardManager *mgr = [YYTextKeyboardManager defaultManager];

			if (mgr.keyboardVisible && self.window && self.superview && self.isFirstResponder && !_verticalForm) {
			CGRect bounds = self.bounds;
			bounds.origin = CGPointZero;
			CGRect kbRect = [mgr convertRect:mgr.keyboardFrame toView:self];
			kbRect.origin.y -= _extraAccessoryViewHeight;
			kbRect.size.height += _extraAccessoryViewHeight;

			kbRect.origin.x -= self.contentOffset.x;
			kbRect.origin.y -= self.contentOffset.y;
			CGRect inter = CGRectIntersection(bounds, kbRect);
			if (!CGRectIsNull(inter) && inter.size.height > 1 && inter.size.width > extend) { // self is covered by keyboard
			if (CGRectGetMinY(inter) > CGRectGetMinY(bounds)) { // keyboard below self.top

			UIEdgeInsets originalContentInset = self.contentInset;
			UIEdgeInsets originalScrollIndicatorInsets = self.scrollIndicatorInsets;
			if (_insetModifiedByKeyboard) {
			originalContentInset = _originalContentInset;
			originalScrollIndicatorInsets = _originalScrollIndicatorInsets;
			}

			if (originalContentInset.bottom < inter.size.height + extend) {
			insetModified = YES;
			if (!_insetModifiedByKeyboard) {
			_insetModifiedByKeyboard = YES;
			_originalContentInset = self.contentInset;
			_originalScrollIndicatorInsets = self.scrollIndicatorInsets;
			}
			UIEdgeInsets newInset = originalContentInset;
			UIEdgeInsets newIndicatorInsets = originalScrollIndicatorInsets;
			newInset.bottom = inter.size.height + extend;
			newIndicatorInsets.bottom = newInset.bottom;
			UIViewAnimationOptions curve;
			if (kiOS7Later) {
			curve = 7 << 16;
			} else {
			curve = UIViewAnimationOptionCurveEaseInOut;
			}
			[UIView animateWithDuration:0.25 delay:0 options:UIViewAnimationOptionBeginFromCurrentState \| UIViewAnimationOptionAllowUserInteraction \| curve animations:^{
			[super setContentInset:newInset];
			[super setScrollIndicatorInsets:newIndicatorInsets];
			[self scrollRectToVisible:CGRectInset(rect, -extend, -extend) animated:NO];
			} completion:NULL];
			}
			}
			}
			}
			if (!insetModified) {
			[UIView animateWithDuration:0.25 delay:0 options:UIViewAnimationOptionBeginFromCurrentState \| UIViewAnimationOptionAllowUserInteraction \| UIViewAnimationCurveEaseOut animations:^{
			[self _restoreInsetsAnimated:NO];
			[self scrollRectToVisible:CGRectInset(rect, -extend, -extend) animated:NO];
			} completion:NULL];
			}
			}

			/// Restore contents insets if modified by keyboard.
			- (void)_restoreInsetsAnimated:(BOOL)animated {
			if (_insetModifiedByKeyboard) {
			_insetModifiedByKeyboard = NO;
			if (animated) {
			[UIView animateWithDuration:0.25 delay:0 options:UIViewAnimationOptionBeginFromCurrentState \| UIViewAnimationOptionAllowUserInteraction \| UIViewAnimationCurveEaseOut animations:^{
			[super setContentInset:_originalContentInset];
			[super setScrollIndicatorInsets:_originalScrollIndicatorInsets];
			} completion:NULL];
			} else {
			[super setContentInset:_originalContentInset];
			[super setScrollIndicatorInsets:_originalScrollIndicatorInsets];
			}
			}
			}

			/// Keyboard frame changed, scroll the caret to visible range, or modify the content insets.
			- (void)_keyboardChanged {
			if (!self.isFirstResponder) return;
			dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
			if ([YYTextKeyboardManager defaultManager].keyboardVisible) {
			[self _scrollRangeToVisible:_selectedTextRange];
			} else {
			[self _restoreInsetsAnimated:YES];
			}
			[self _updateMagnifier];
			if (_state.showingMenu) {
			[self _showMenu];
			}
			});
			}

			/// Start long press timer, used for 'highlight' range text action.
			- (void)_startLongPressTimer {
			[_longPressTimer invalidate];
			_longPressTimer = [NSTimer timerWithTimeInterval:kLongPressMinimumDuration
			target:[YYTextWeakProxy proxyWithTarget:self]
			selector:@selector(_trackDidLongPress)
			userInfo:nil
			repeats:NO];
			[[NSRunLoop currentRunLoop] addTimer:_longPressTimer forMode:NSRunLoopCommonModes];
			}

			/// Invalidate the long press timer.
			- (void)_endLongPressTimer {
			[_longPressTimer invalidate];
			_longPressTimer = nil;
			}

			/// Long press detected.
			- (void)_trackDidLongPress {
			[self _endLongPressTimer];

			BOOL dealLongPressAction = NO;
			if (_state.showingHighlight) {
			[self _hideMenu];

			if (_highlight.longPressAction) {
			dealLongPressAction = YES;
			CGRect rect = [_innerLayout rectForRange:[YYTextRange rangeWithRange:_highlightRange]];
			rect = [self _convertRectFromLayout:rect];
			_highlight.longPressAction(self, _innerText, _highlightRange, rect);
			[self _endTouchTracking];
			} else {
			BOOL shouldHighlight = YES;
			if ([self.delegate respondsToSelector:@selector(textView:shouldLongPressHighlight:inRange:)]) {
			shouldHighlight = [self.delegate textView:self shouldLongPressHighlight:_highlight inRange:_highlightRange];
			}
			if (shouldHighlight && [self.delegate respondsToSelector:@selector(textView:didLongPressHighlight:inRange:rect:)]) {
			dealLongPressAction = YES;
			CGRect rect = [_innerLayout rectForRange:[YYTextRange rangeWithRange:_highlightRange]];
			rect = [self _convertRectFromLayout:rect];
			[self.delegate textView:self didLongPressHighlight:_highlight inRange:_highlightRange rect:rect];
			[self _endTouchTracking];
			}
			}
			}

			if (!dealLongPressAction){
			[self _removeHighlightAnimated:NO];
			if (_state.trackingTouch) {
			if (_state.trackingGrabber) {
			self.panGestureRecognizer.enabled = NO;
			[self _hideMenu];
			[self _showMagnifierRanged];
			} else if (self.isFirstResponder){
			self.panGestureRecognizer.enabled = NO;
			_selectionView.caretBlinks = NO;
			_state.trackingCaret = YES;
			CGPoint trackingPoint = [self _convertPointToLayout:_trackingPoint];
			YYTextPosition *newPos = [_innerLayout closestPositionToPoint:trackingPoint];
			newPos = [self _correctedTextPosition:newPos];
			if (newPos) {
			if (_markedTextRange) {
			if ([newPos compare:_markedTextRange.start] != NSOrderedDescending) {
			newPos = _markedTextRange.start;
			} else if ([newPos compare:_markedTextRange.end] != NSOrderedAscending) {
			newPos = _markedTextRange.end;
			}
			}
			_trackingRange = [YYTextRange rangeWithRange:NSMakeRange(newPos.offset, 0) affinity:newPos.affinity];
			[self _updateSelectionView];
			}
			[self _hideMenu];

			if (_markedTextRange) {
			[self _showMagnifierRanged];
			} else {
			[self _showMagnifierCaret];
			}
			} else if (self.selectable) {
			self.panGestureRecognizer.enabled = NO;
			_state.trackingPreSelect = YES;
			_state.selectedWithoutEdit = NO;
			[self _updateTextRangeByTrackingPreSelect];
			[self _updateSelectionView];
			[self _showMagnifierCaret];
			}
			}
			}
			}

			/// Start auto scroll timer, used for auto scroll tick.
			- (void)_startAutoScrollTimer {
			if (!_autoScrollTimer) {
			[_autoScrollTimer invalidate];
			_autoScrollTimer = [NSTimer timerWithTimeInterval:kAutoScrollMinimumDuration
			target:[YYTextWeakProxy proxyWithTarget:self]
			selector:@selector(_trackDidTickAutoScroll)
			userInfo:nil
			repeats:YES];
			[[NSRunLoop currentRunLoop] addTimer:_autoScrollTimer forMode:NSRunLoopCommonModes];
			}
			}

			/// Invalidate the auto scroll, and restore the text view state.
			- (void)_endAutoScrollTimer {
			if (_state.autoScrollTicked) [self flashScrollIndicators];
			[_autoScrollTimer invalidate];
			_autoScrollTimer = nil;
			_autoScrollOffset = 0;
			_autoScrollAcceleration = 0;
			_state.autoScrollTicked = NO;

			if (_magnifierCaret.captureDisabled) {
			_magnifierCaret.captureDisabled = NO;
			if (_state.showingMagnifierCaret) {
			[self _showMagnifierCaret];
			}
			}
			if (_magnifierRanged.captureDisabled) {
			_magnifierRanged.captureDisabled = NO;
			if (_state.showingMagnifierRanged) {
			[self _showMagnifierRanged];
			}
			}
			}

			/// Auto scroll ticked by timer.
			- (void)_trackDidTickAutoScroll {
			if (_autoScrollOffset != 0) {
			_magnifierCaret.captureDisabled = YES;
			_magnifierRanged.captureDisabled = YES;

			CGPoint offset = self.contentOffset;
			if (_verticalForm) {
			offset.x += _autoScrollOffset;

			if (_autoScrollAcceleration > 0) {
			offset.x += ((_autoScrollOffset > 0 ? 1 : -1) * _autoScrollAcceleration * _autoScrollAcceleration * 0.5);
			}
			_autoScrollAcceleration++;
			offset.x = round(offset.x);
			if (_autoScrollOffset < 0) {
			if (offset.x < -self.contentInset.left) offset.x = -self.contentInset.left;
			} else {
			CGFloat maxOffsetX = self.contentSize.width - self.bounds.size.width + self.contentInset.right;
			if (offset.x > maxOffsetX) offset.x = maxOffsetX;
			}
			if (offset.x < -self.contentInset.left) offset.x = -self.contentInset.left;
			} else {
			offset.y += _autoScrollOffset;
			if (_autoScrollAcceleration > 0) {
			offset.y += ((_autoScrollOffset > 0 ? 1 : -1) * _autoScrollAcceleration * _autoScrollAcceleration * 0.5);
			}
			_autoScrollAcceleration++;
			offset.y = round(offset.y);
			if (_autoScrollOffset < 0) {
			if (offset.y < -self.contentInset.top) offset.y = -self.contentInset.top;
			} else {
			CGFloat maxOffsetY = self.contentSize.height - self.bounds.size.height + self.contentInset.bottom;
			if (offset.y > maxOffsetY) offset.y = maxOffsetY;
			}
			if (offset.y < -self.contentInset.top) offset.y = -self.contentInset.top;
			}

			BOOL shouldScroll;
			if (_verticalForm) {
			shouldScroll = fabs(offset.x -self.contentOffset.x) > 0.5;
			} else {
			shouldScroll = fabs(offset.y -self.contentOffset.y) > 0.5;
			}

			if (shouldScroll) {
			_state.autoScrollTicked = YES;
			_trackingPoint.x += offset.x - self.contentOffset.x;
			_trackingPoint.y += offset.y - self.contentOffset.y;
			[UIView animateWithDuration:kAutoScrollMinimumDuration delay:0 options:UIViewAnimationOptionBeginFromCurrentState \| UIViewAnimationOptionAllowUserInteraction \| UIViewAnimationOptionCurveLinear animations:^{
			[self setContentOffset:offset];
			} completion:^(BOOL finished) {
			if (_state.trackingTouch) {
			if (_state.trackingGrabber) {
			[self _showMagnifierRanged];
			[self _updateTextRangeByTrackingGrabber];
			} else if (_state.trackingPreSelect) {
			[self _showMagnifierCaret];
			[self _updateTextRangeByTrackingPreSelect];
			} else if (_state.trackingCaret) {
			if (_markedTextRange) {
			[self _showMagnifierRanged];
			} else {
			[self _showMagnifierCaret];
			}
			[self _updateTextRangeByTrackingCaret];
			}
			[self _updateSelectionView];
			}
			}];
			} else {
			[self _endAutoScrollTimer];
			}
			} else {
			[self _endAutoScrollTimer];
			}
			}

			/// End current touch tracking (if is tracking now), and update the state.
			- (void)_endTouchTracking {
			if (!_state.trackingTouch) return;

			_state.trackingTouch = NO;
			_state.trackingGrabber = NO;
			_state.trackingCaret = NO;
			_state.trackingPreSelect = NO;
			_state.touchMoved = NO;
			_state.deleteConfirm = NO;
			_state.clearsOnInsertionOnce = NO;
			_trackingRange = nil;
			_selectionView.caretBlinks = YES;

			[self _removeHighlightAnimated:YES];
			[self _hideMagnifier];
			[self _endLongPressTimer];
			[self _endAutoScrollTimer];
			[self _updateSelectionView];

			self.panGestureRecognizer.enabled = self.scrollEnabled;
			}

			/// Start a timer to fix the selection dot.
			- (void)_startSelectionDotFixTimer {
			[_selectionDotFixTimer invalidate];
			_longPressTimer = [NSTimer timerWithTimeInterval:1/15.0
			target:[YYTextWeakProxy proxyWithTarget:self]
			selector:@selector(_fixSelectionDot)
			userInfo:nil
			repeats:NO];
			[[NSRunLoop currentRunLoop] addTimer:_longPressTimer forMode:NSRunLoopCommonModes];
			}

			/// End the timer.
			- (void)_endSelectionDotFixTimer {
			[_selectionDotFixTimer invalidate];
			_selectionDotFixTimer = nil;
			}

			/// If it shows selection grabber and this view was moved by super view,
			/// update the selection dot in window.
			- (void)_fixSelectionDot {
			if (YYTextIsAppExtension()) return;
			CGPoint origin = [self yy_convertPoint:CGPointZero toViewOrWindow:[YYTextEffectWindow sharedWindow]];
			if (!CGPointEqualToPoint(origin, _previousOriginInWindow)) {
			_previousOriginInWindow = origin;
			[[YYTextEffectWindow sharedWindow] hideSelectionDot:_selectionView];
			[[YYTextEffectWindow sharedWindow] showSelectionDot:_selectionView];
			}
			}

			/// Try to get the character range/position with word granularity from the tokenizer.
			- (YYTextRange )_getClosestTokenRangeAtPosition:(YYTextPosition )position {
			position = [self _correctedTextPosition:position];
			if (!position) return nil;
			YYTextRange *range = nil;
			if (_tokenizer) {
			range = (id)[_tokenizer rangeEnclosingPosition:position withGranularity:UITextGranularityWord inDirection:UITextStorageDirectionForward];
			if (range.asRange.length == 0) {
			range = (id)[_tokenizer rangeEnclosingPosition:position withGranularity:UITextGranularityWord inDirection:UITextStorageDirectionBackward];
			}
			}

			if (!range \|\| range.asRange.length == 0) {
			range = [_innerLayout textRangeByExtendingPosition:position inDirection:UITextLayoutDirectionRight offset:1];
			range = [self _correctedTextRange:range];
			if (range.asRange.length == 0) {
			range = [_innerLayout textRangeByExtendingPosition:position inDirection:UITextLayoutDirectionLeft offset:1];
			range = [self _correctedTextRange:range];
			}
			} else {
			YYTextRange *extStart = [_innerLayout textRangeByExtendingPosition:range.start];
			YYTextRange *extEnd = [_innerLayout textRangeByExtendingPosition:range.end];
			if (extStart && extEnd) {
			NSArray *arr = [@[extStart.start, extStart.end, extEnd.start, extEnd.end] sortedArrayUsingSelector:@selector(compare:)];
			range = [YYTextRange rangeWithStart:arr.firstObject end:arr.lastObject];
			}
			}

			range = [self _correctedTextRange:range];
			if (range.asRange.length == 0) {
			range = [YYTextRange rangeWithRange:NSMakeRange(0, _innerText.length)];
			}

			return [self _correctedTextRange:range];
			}

			/// Try to get the character range/position with word granularity from the tokenizer.
			- (YYTextRange *)_getClosestTokenRangeAtPoint:(CGPoint)point {
			point = [self _convertPointToLayout:point];
			YYTextRange *touchRange = [_innerLayout closestTextRangeAtPoint:point];
			touchRange = [self _correctedTextRange:touchRange];

			if (_tokenizer && touchRange) {
			YYTextRange *encEnd = (id)[_tokenizer rangeEnclosingPosition:touchRange.end withGranularity:UITextGranularityWord inDirection:UITextStorageDirectionBackward];
			YYTextRange *encStart = (id)[_tokenizer rangeEnclosingPosition:touchRange.start withGranularity:UITextGranularityWord inDirection:UITextStorageDirectionForward];
			if (encEnd && encStart) {
			NSArray *arr = [@[encEnd.start, encEnd.end, encStart.start, encStart.end] sortedArrayUsingSelector:@selector(compare:)];
			touchRange = [YYTextRange rangeWithStart:arr.firstObject end:arr.lastObject];
			}
			}

			if (touchRange) {
			YYTextRange *extStart = [_innerLayout textRangeByExtendingPosition:touchRange.start];
			YYTextRange *extEnd = [_innerLayout textRangeByExtendingPosition:touchRange.end];
			if (extStart && extEnd) {
			NSArray *arr = [@[extStart.start, extStart.end, extEnd.start, extEnd.end] sortedArrayUsingSelector:@selector(compare:)];
			touchRange = [YYTextRange rangeWithStart:arr.firstObject end:arr.lastObject];
			}
			}

			if (!touchRange) touchRange = [YYTextRange defaultRange];

			if (_innerText.length && touchRange.asRange.length == 0) {
			touchRange = [YYTextRange rangeWithRange:NSMakeRange(0, _innerText.length)];
			}

			return touchRange;
			}

			/// Try to get the highlight property. If exist, the range will be returnd by the range pointer.
			/// If the delegate ignore the highlight, returns nil.
			- (YYTextHighlight *)_getHighlightAtPoint:(CGPoint)point range:(NSRangePointer)range {
			if (!_highlightable \|\| !_innerLayout.containsHighlight) return nil;
			point = [self _convertPointToLayout:point];
			YYTextRange *textRange = [_innerLayout textRangeAtPoint:point];
			textRange = [self _correctedTextRange:textRange];
			if (!textRange) return nil;
			NSUInteger startIndex = textRange.start.offset;
			if (startIndex == _innerText.length) {
			if (startIndex == 0) return nil;
			else startIndex--;
			}
			NSRange highlightRange = {0};
			NSAttributedString *text = _delectedText ? _delectedText : _innerText;
			YYTextHighlight *highlight = [text attribute:YYTextHighlightAttributeName
			atIndex:startIndex
			longestEffectiveRange:&highlightRange
			inRange:NSMakeRange(0, _innerText.length)];

			if (!highlight) return nil;

			BOOL shouldTap = YES, shouldLongPress = YES;
			if (!highlight.tapAction && !highlight.longPressAction) {
			if ([self.delegate respondsToSelector:@selector(textView:shouldTapHighlight:inRange:)]) {
			shouldTap = [self.delegate textView:self shouldTapHighlight:highlight inRange:highlightRange];
			}
			if ([self.delegate respondsToSelector:@selector(textView:shouldLongPressHighlight:inRange:)]) {
			shouldLongPress = [self.delegate textView:self shouldLongPressHighlight:highlight inRange:highlightRange];
			}
			}
			if (!shouldTap && !shouldLongPress) return nil;
			if (range) *range = highlightRange;
			return highlight;
			}

			/// Return the ranged magnifier popover offset from the baseline, base on `_trackingPoint`.
			- (CGFloat)_getMagnifierRangedOffset {
			CGPoint magPoint = _trackingPoint;
			magPoint = [self _convertPointToLayout:magPoint];
			if (_verticalForm) {
			magPoint.x += kMagnifierRangedTrackFix;
			} else {
			magPoint.y += kMagnifierRangedTrackFix;
			}
			YYTextPosition *position = [_innerLayout closestPositionToPoint:magPoint];
			NSUInteger lineIndex = [_innerLayout lineIndexForPosition:position];
			if (lineIndex < _innerLayout.lines.count) {
			YYTextLine *line = _innerLayout.lines[lineIndex];
			if (_verticalForm) {
			magPoint.x = YYTEXT_CLAMP(magPoint.x, line.left, line.right);
			return magPoint.x - line.position.x + kMagnifierRangedPopoverOffset;
			} else {
			magPoint.y = YYTEXT_CLAMP(magPoint.y, line.top, line.bottom);
			return magPoint.y - line.position.y + kMagnifierRangedPopoverOffset;
			}
			} else {
			return 0;
			}
			}

			/// Return a YYTextMoveDirection from `_touchBeganPoint` to `_trackingPoint`.
			- (unsigned int)_getMoveDirection {
			CGFloat moveH = _trackingPoint.x - _touchBeganPoint.x;
			CGFloat moveV = _trackingPoint.y - _touchBeganPoint.y;
			if (fabs(moveH) > fabs(moveV)) {
			if (fabs(moveH) > kLongPressAllowableMovement) {
			return moveH > 0 ? kRight : kLeft;
			}
			} else {
			if (fabs(moveV) > kLongPressAllowableMovement) {
			return moveV > 0 ? kBottom : kTop;
			}
			}
			return 0;
			}

			/// Get the auto scroll offset in one tick time.
			- (CGFloat)_getAutoscrollOffset {
			if (!_state.trackingTouch) return 0;

			CGRect bounds = self.bounds;
			bounds.origin = CGPointZero;
			YYTextKeyboardManager *mgr = [YYTextKeyboardManager defaultManager];
			if (mgr.keyboardVisible && self.window && self.superview && self.isFirstResponder && !_verticalForm) {
			CGRect kbRect = [mgr convertRect:mgr.keyboardFrame toView:self];
			kbRect.origin.y -= _extraAccessoryViewHeight;
			kbRect.size.height += _extraAccessoryViewHeight;

			kbRect.origin.x -= self.contentOffset.x;
			kbRect.origin.y -= self.contentOffset.y;
			CGRect inter = CGRectIntersection(bounds, kbRect);
			if (!CGRectIsNull(inter) && inter.size.height > 1 && inter.size.width > 1) {
			if (CGRectGetMinY(inter) > CGRectGetMinY(bounds)) {
			bounds.size.height -= inter.size.height;
			}
			}
			}

			CGPoint point = _trackingPoint;
			point.x -= self.contentOffset.x;
			point.y -= self.contentOffset.y;

			CGFloat maxOfs = 32; // a good value ~
			CGFloat ofs = 0;
			if (_verticalForm) {
			if (point.x < self.contentInset.left) {
			ofs = (point.x - self.contentInset.left - 5) * 0.5;
			if (ofs < -maxOfs) ofs = -maxOfs;
			} else if (point.x > bounds.size.width) {
			ofs = ((point.x - bounds.size.width) + 5) * 0.5;
			if (ofs > maxOfs) ofs = maxOfs;
			}
			} else {
			if (point.y < self.contentInset.top) {
			ofs = (point.y - self.contentInset.top - 5) * 0.5;
			if (ofs < -maxOfs) ofs = -maxOfs;
			} else if (point.y > bounds.size.height) {
			ofs = ((point.y - bounds.size.height) + 5) * 0.5;
			if (ofs > maxOfs) ofs = maxOfs;
			}
			}
			return ofs;
			}

			/// Visible size based on bounds and insets
			- (CGSize)_getVisibleSize {
			CGSize visibleSize = self.bounds.size;
			visibleSize.width -= self.contentInset.left - self.contentInset.right;
			visibleSize.height -= self.contentInset.top - self.contentInset.bottom;
			if (visibleSize.width < 0) visibleSize.width = 0;
			if (visibleSize.height < 0) visibleSize.height = 0;
			return visibleSize;
			}

			/// Returns whether the text view can paste data from pastboard.
			- (BOOL)_isPasteboardContainsValidValue {
			UIPasteboard *pasteboard = [UIPasteboard generalPasteboard];
			if (pasteboard.string.length > 0) {
			return YES;
			}
			if (pasteboard.yy_AttributedString.length > 0) {
			if (_allowsPasteAttributedString) {
			return YES;
			}
			}
			if (pasteboard.image \|\| pasteboard.yy_ImageData.length > 0) {
			if (_allowsPasteImage) {
			return YES;
			}
			}
			return NO;
			}

			/// Save current selected attributed text to pasteboard.
			- (void)_copySelectedTextToPasteboard {
			if (_allowsCopyAttributedString) {
			NSAttributedString *text = [_innerText attributedSubstringFromRange:_selectedTextRange.asRange];
			if (text.length) {
			[UIPasteboard generalPasteboard].yy_AttributedString = text;
			}
			} else {
			NSString *string = [_innerText yy_plainTextForRange:_selectedTextRange.asRange];
			if (string.length) {
			[UIPasteboard generalPasteboard].string = string;
			}
			}
			}

			/// Update the text view state when pasteboard changed.
			- (void)_pasteboardChanged {
			if (_state.showingMenu) {
			UIMenuController *menu = [UIMenuController sharedMenuController];
			[menu update];
			}
			}

			/// Whether the position is valid (not out of bounds).
			- (BOOL)_isTextPositionValid:(YYTextPosition *)position {
			if (!position) return NO;
			if (position.offset < 0) return NO;
			if (position.offset > _innerText.length) return NO;
			if (position.offset == 0 && position.affinity == YYTextAffinityBackward) return NO;
			if (position.offset == _innerText.length && position.affinity == YYTextAffinityBackward) return NO;
			return YES;
			}

			/// Whether the range is valid (not out of bounds).
			- (BOOL)_isTextRangeValid:(YYTextRange *)range {
			if (![self _isTextPositionValid:range.start]) return NO;
			if (![self _isTextPositionValid:range.end]) return NO;
			return YES;
			}

			/// Correct the position if it out of bounds.
			- (YYTextPosition )_correctedTextPosition:(YYTextPosition )position {
			if (!position) return nil;
			if ([self _isTextPositionValid:position]) return position;
			if (position.offset < 0) {
			return [YYTextPosition positionWithOffset:0];
			}
			if (position.offset > _innerText.length) {
			return [YYTextPosition positionWithOffset:_innerText.length];
			}
			if (position.offset == 0 && position.affinity == YYTextAffinityBackward) {
			return [YYTextPosition positionWithOffset:position.offset];
			}
			if (position.offset == _innerText.length && position.affinity == YYTextAffinityBackward) {
			return [YYTextPosition positionWithOffset:position.offset];
			}
			return position;
			}

			/// Correct the range if it out of bounds.
			- (YYTextRange )_correctedTextRange:(YYTextRange )range {
			if (!range) return nil;
			if ([self _isTextRangeValid:range]) return range;
			YYTextPosition *start = [self _correctedTextPosition:range.start];
			YYTextPosition *end = [self _correctedTextPosition:range.end];
			return [YYTextRange rangeWithStart:start end:end];
			}

			/// Convert the point from this view to text layout.
			- (CGPoint)_convertPointToLayout:(CGPoint)point {
			CGSize boundingSize = _innerLayout.textBoundingSize;
			if (_innerLayout.container.isVerticalForm) {
			CGFloat w = _innerLayout.textBoundingSize.width;
			if (w < self.bounds.size.width) w = self.bounds.size.width;
			point.x += _innerLayout.container.size.width - w;
			if (boundingSize.width < self.bounds.size.width) {
			if (_textVerticalAlignment == YYTextVerticalAlignmentCenter) {
			point.x += (self.bounds.size.width - boundingSize.width) * 0.5;
			} else if (_textVerticalAlignment == YYTextVerticalAlignmentBottom) {
			point.x += (self.bounds.size.width - boundingSize.width);
			}
			}
			return point;
			} else {
			if (boundingSize.height < self.bounds.size.height) {
			if (_textVerticalAlignment == YYTextVerticalAlignmentCenter) {
			point.y -= (self.bounds.size.height - boundingSize.height) * 0.5;
			} else if (_textVerticalAlignment == YYTextVerticalAlignmentBottom) {
			point.y -= (self.bounds.size.height - boundingSize.height);
			}
			}
			return point;
			}
			}

			/// Convert the point from text layout to this view.
			- (CGPoint)_convertPointFromLayout:(CGPoint)point {
			CGSize boundingSize = _innerLayout.textBoundingSize;
			if (_innerLayout.container.isVerticalForm) {
			CGFloat w = _innerLayout.textBoundingSize.width;
			if (w < self.bounds.size.width) w = self.bounds.size.width;
			point.x -= _innerLayout.container.size.width - w;
			if (boundingSize.width < self.bounds.size.width) {
			if (_textVerticalAlignment == YYTextVerticalAlignmentCenter) {
			point.x -= (self.bounds.size.width - boundingSize.width) * 0.5;
			} else if (_textVerticalAlignment == YYTextVerticalAlignmentBottom) {
			point.x -= (self.bounds.size.width - boundingSize.width);
			}
			}
			return point;
			} else {
			if (boundingSize.height < self.bounds.size.height) {
			if (_textVerticalAlignment == YYTextVerticalAlignmentCenter) {
			point.y += (self.bounds.size.height - boundingSize.height) * 0.5;
			} else if (_textVerticalAlignment == YYTextVerticalAlignmentBottom) {
			point.y += (self.bounds.size.height - boundingSize.height);
			}
			}
			return point;
			}
			}

			/// Convert the rect from this view to text layout.
			- (CGRect)_convertRectToLayout:(CGRect)rect {
			rect.origin = [self _convertPointToLayout:rect.origin];
			return rect;
			}

			/// Convert the rect from text layout to this view.
			- (CGRect)_convertRectFromLayout:(CGRect)rect {
			rect.origin = [self _convertPointFromLayout:rect.origin];
			return rect;
			}

			/// Replace the range with the text, and change the `_selectTextRange`.
			/// The caller should make sure the `range` and `text` are valid before call this method.
			- (void)_replaceRange:(YYTextRange )range withText:(NSString )text notifyToDelegate:(BOOL)notify{
			if (NSEqualRanges(range.asRange, _selectedTextRange.asRange)) {
			if (notify) [_inputDelegate selectionWillChange:self];
			NSRange newRange = NSMakeRange(0, 0);
			newRange.location = _selectedTextRange.start.offset + text.length;
			_selectedTextRange = [YYTextRange rangeWithRange:newRange];
			if (notify) [_inputDelegate selectionDidChange:self];
			} else {
			if (range.asRange.length != text.length) {
			if (notify) [_inputDelegate selectionWillChange:self];
			NSRange unionRange = NSIntersectionRange(_selectedTextRange.asRange, range.asRange);
			if (unionRange.length == 0) {
			// no intersection
			if (range.end.offset <= _selectedTextRange.start.offset) {
			NSInteger ofs = (NSInteger)text.length - (NSInteger)range.asRange.length;
			NSRange newRange = _selectedTextRange.asRange;
			newRange.location += ofs;
			_selectedTextRange = [YYTextRange rangeWithRange:newRange];
			}
			} else if (unionRange.length == _selectedTextRange.asRange.length) {
			// target range contains selected range
			_selectedTextRange = [YYTextRange rangeWithRange:NSMakeRange(range.start.offset + text.length, 0)];
			} else if (range.start.offset >= _selectedTextRange.start.offset &&
			range.end.offset <= _selectedTextRange.end.offset) {
			// target range inside selected range
			NSInteger ofs = (NSInteger)text.length - (NSInteger)range.asRange.length;
			NSRange newRange = _selectedTextRange.asRange;
			newRange.length += ofs;
			_selectedTextRange = [YYTextRange rangeWithRange:newRange];
			} else {
			// interleaving
			if (range.start.offset < _selectedTextRange.start.offset) {
			NSRange newRange = _selectedTextRange.asRange;
			newRange.location = range.start.offset + text.length;
			newRange.length -= unionRange.length;
			_selectedTextRange = [YYTextRange rangeWithRange:newRange];
			} else {
			NSRange newRange = _selectedTextRange.asRange;
			newRange.length -= unionRange.length;
			_selectedTextRange = [YYTextRange rangeWithRange:newRange];
			}
			}
			_selectedTextRange = [self _correctedTextRange:_selectedTextRange];
			if (notify) [_inputDelegate selectionDidChange:self];
			}
			}
			if (notify) [_inputDelegate textWillChange:self];
			NSRange newRange = NSMakeRange(range.asRange.location, text.length);
			[_innerText replaceCharactersInRange:range.asRange withString:text];
			[_innerText yy_removeDiscontinuousAttributesInRange:newRange];
			if (notify) [_inputDelegate textDidChange:self];
			}

			/// Save current typing attributes to the attributes holder.
			- (void)_updateAttributesHolder {
			if (_innerText.length > 0) {
			NSUInteger index = _selectedTextRange.end.offset == 0 ? 0 : _selectedTextRange.end.offset - 1;
			NSDictionary *attributes = [_innerText yy_attributesAtIndex:index];
			if (!attributes) attributes = @{};
			_typingAttributesHolder.yy_attributes = attributes;
			[_typingAttributesHolder yy_removeDiscontinuousAttributesInRange:NSMakeRange(0, _typingAttributesHolder.length)];
			[_typingAttributesHolder removeAttribute:YYTextBorderAttributeName range:NSMakeRange(0, _typingAttributesHolder.length)];
			[_typingAttributesHolder removeAttribute:YYTextBackgroundBorderAttributeName range:NSMakeRange(0, _typingAttributesHolder.length)];
			}
			}

			/// Update outer properties from current inner data.
			- (void)_updateOuterProperties {
			[self _updateAttributesHolder];
			NSParagraphStyle *style = _innerText.yy_paragraphStyle;
			if (!style) style = _typingAttributesHolder.yy_paragraphStyle;
			if (!style) style = [NSParagraphStyle defaultParagraphStyle];

			UIFont *font = _innerText.yy_font;
			if (!font) font = _typingAttributesHolder.yy_font;
			if (!font) font = [self _defaultFont];

			UIColor *color = _innerText.yy_color;
			if (!color) color = _typingAttributesHolder.yy_color;
			if (!color) color = [UIColor blackColor];

			[self _setText:[_innerText yy_plainTextForRange:NSMakeRange(0, _innerText.length)]];
			[self _setFont:font];
			[self _setTextColor:color];
			[self _setTextAlignment:style.alignment];
			[self _setSelectedRange:_selectedTextRange.asRange];
			[self _setTypingAttributes:_typingAttributesHolder.yy_attributes];
			[self _setAttributedText:_innerText];
			}

			/// Parse text with `textParser` and update the _selectedTextRange.
			/// @return Whether changed (text or selection)
			- (BOOL)_parseText {
			if (self.textParser) {
			YYTextRange *oldTextRange = _selectedTextRange;
			NSRange newRange = _selectedTextRange.asRange;

			[_inputDelegate textWillChange:self];
			BOOL textChanged = [self.textParser parseText:_innerText selectedRange:&newRange];
			[_inputDelegate textDidChange:self];

			YYTextRange *newTextRange = [YYTextRange rangeWithRange:newRange];
			newTextRange = [self _correctedTextRange:newTextRange];

			if (![oldTextRange isEqual:newTextRange]) {
			[_inputDelegate selectionWillChange:self];
			_selectedTextRange = newTextRange;
			[_inputDelegate selectionDidChange:self];
			}
			return textChanged;
			}
			return NO;
			}

			/// Returns whether the text should be detected by the data detector.
			- (BOOL)_shouldDetectText {
			if (!_dataDetector) return NO;
			if (!_highlightable) return NO;
			if (_linkTextAttributes.count == 0 && _highlightTextAttributes.count == 0) return NO;
			if (self.isFirstResponder \|\| _containerView.isFirstResponder) return NO;
			return YES;
			}

			/// Detect the data in text and add highlight to the data range.
			/// @return Whether detected.
			- (BOOL)_detectText:(NSMutableAttributedString *)text {
			if (![self _shouldDetectText]) return NO;
			if (text.length == 0) return NO;
			__block BOOL detected = NO;
			[_dataDetector enumerateMatchesInString:text.string options:kNilOptions range:NSMakeRange(0, text.length) usingBlock: ^(NSTextCheckingResult result, NSMatchingFlags flags, BOOL stop) {
			switch (result.resultType) {
			case NSTextCheckingTypeDate:
			case NSTextCheckingTypeAddress:
			case NSTextCheckingTypeLink:
			case NSTextCheckingTypePhoneNumber: {
			detected = YES;
			if (_highlightTextAttributes.count) {
			YYTextHighlight *highlight = [YYTextHighlight highlightWithAttributes:_highlightTextAttributes];
			[text yy_setTextHighlight:highlight range:result.range];
			}
			if (_linkTextAttributes.count) {
			[_linkTextAttributes enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop) {
			[text yy_setAttribute:key value:obj range:result.range];
			}];
			}
			} break;
			default:
			break;
			}
			}];
			return detected;
			}

			/// Returns the `root` view controller (returns nil if not found).
			- (UIViewController *)_getRootViewController {
			UIViewController *ctrl = nil;
			UIApplication *app = YYTextSharedApplication();
			if (!ctrl) ctrl = app.keyWindow.rootViewController;
			if (!ctrl) ctrl = [app.windows.firstObject rootViewController];
			if (!ctrl) ctrl = self.yy_viewController;
			if (!ctrl) return nil;

			while (!ctrl.view.window && ctrl.presentedViewController) {
			ctrl = ctrl.presentedViewController;
			}
			if (!ctrl.view.window) return nil;
			return ctrl;
			}

			/// Clear the undo and redo stack, and capture current state to undo stack.
			- (void)_resetUndoAndRedoStack {
			[_undoStack removeAllObjects];
			[_redoStack removeAllObjects];
			_YYTextViewUndoObject *object = [_YYTextViewUndoObject objectWithText:_innerText.copy range:_selectedTextRange.asRange];
			_lastTypeRange = _selectedTextRange.asRange;
			[_undoStack addObject:object];
			}

			/// Clear the redo stack.
			- (void)_resetRedoStack {
			[_redoStack removeAllObjects];
			}

			/// Capture current state to undo stack.
			- (void)_saveToUndoStack {
			if (!_allowsUndoAndRedo) return;
			_YYTextViewUndoObject *lastObject = _undoStack.lastObject;
			if ([lastObject.text isEqualToAttributedString:self.attributedText]) return;

			_YYTextViewUndoObject *object = [_YYTextViewUndoObject objectWithText:_innerText.copy range:_selectedTextRange.asRange];
			_lastTypeRange = _selectedTextRange.asRange;
			[_undoStack addObject:object];
			while (_undoStack.count > _maximumUndoLevel) {
			[_undoStack removeObjectAtIndex:0];
			}
			}

			/// Capture current state to redo stack.
			- (void)_saveToRedoStack {
			if (!_allowsUndoAndRedo) return;
			_YYTextViewUndoObject *lastObject = _redoStack.lastObject;
			if ([lastObject.text isEqualToAttributedString:self.attributedText]) return;

			_YYTextViewUndoObject *object = [_YYTextViewUndoObject objectWithText:_innerText.copy range:_selectedTextRange.asRange];
			[_redoStack addObject:object];
			while (_redoStack.count > _maximumUndoLevel) {
			[_redoStack removeObjectAtIndex:0];
			}
			}

			- (BOOL)_canUndo {
			if (_undoStack.count == 0) return NO;
			_YYTextViewUndoObject *object = _undoStack.lastObject;
			if ([object.text isEqualToAttributedString:_innerText]) return NO;
			return YES;
			}

			- (BOOL)_canRedo {
			if (_redoStack.count == 0) return NO;
			_YYTextViewUndoObject *object = _undoStack.lastObject;
			if ([object.text isEqualToAttributedString:_innerText]) return NO;
			return YES;
			}

			- (void)_undo {
			if (![self _canUndo]) return;
			[self _saveToRedoStack];
			_YYTextViewUndoObject *object = _undoStack.lastObject;
			[_undoStack removeLastObject];

			_state.insideUndoBlock = YES;
			self.attributedText = object.text;
			self.selectedRange = object.selectedRange;
			_state.insideUndoBlock = NO;
			}

			- (void)_redo {
			if (![self _canRedo]) return;
			[self _saveToUndoStack];
			_YYTextViewUndoObject *object = _redoStack.lastObject;
			[_redoStack removeLastObject];

			_state.insideUndoBlock = YES;
			self.attributedText = object.text;
			self.selectedRange = object.selectedRange;
			_state.insideUndoBlock = NO;
			}

			- (void)_restoreFirstResponderAfterUndoAlert {
			if (_state.firstResponderBeforeUndoAlert) {
			[self performSelector:@selector(becomeFirstResponder) withObject:nil afterDelay:0];
			}
			}

			/// Show undo alert if it can undo or redo.
			#ifdef __IPHONE_OS_VERSION_MIN_REQUIRED
			- (void)_showUndoRedoAlert NS_EXTENSION_UNAVAILABLE_IOS(""){
			_state.firstResponderBeforeUndoAlert = self.isFirstResponder;
			__weak typeof(self) _self = self;
			NSArray *strings = [self _localizedUndoStrings];
			BOOL canUndo = [self _canUndo];
			BOOL canRedo = [self _canRedo];

			UIViewController *ctrl = [self _getRootViewController];

			if (canUndo && canRedo) {
			if (kiOS8Later) {
			UIAlertController *alert = [UIAlertController alertControllerWithTitle:strings[4] message:@"" preferredStyle:UIAlertControllerStyleAlert];
			[alert addAction:[UIAlertAction actionWithTitle:strings[3] style:UIAlertActionStyleDefault handler:^(UIAlertAction *action) {
			[_self _undo];
			[_self _restoreFirstResponderAfterUndoAlert];
			}]];
			[alert addAction:[UIAlertAction actionWithTitle:strings[2] style:UIAlertActionStyleDefault handler:^(UIAlertAction *action) {
			[_self _redo];
			[_self _restoreFirstResponderAfterUndoAlert];
			}]];
			[alert addAction:[UIAlertAction actionWithTitle:strings[0] style:UIAlertActionStyleCancel handler:^(UIAlertAction *action) {
			[_self _restoreFirstResponderAfterUndoAlert];
			}]];
			[ctrl presentViewController:alert animated:YES completion:nil];
			} else {
			#pragma clang diagnostic push
			#pragma clang diagnostic ignored "-Wdeprecated-declarations"
			UIAlertView *alert = [[UIAlertView alloc] initWithTitle:strings[4] message:@"" delegate:self cancelButtonTitle:strings[0] otherButtonTitles:strings[3], strings[2], nil];
			[alert show];
			#pragma clang diagnostic pop
			}
			} else if (canUndo) {
			if (kiOS8Later) {
			UIAlertController *alert = [UIAlertController alertControllerWithTitle:strings[4] message:@"" preferredStyle:UIAlertControllerStyleAlert];
			[alert addAction:[UIAlertAction actionWithTitle:strings[3] style:UIAlertActionStyleDefault handler:^(UIAlertAction *action) {
			[_self _undo];
			[_self _restoreFirstResponderAfterUndoAlert];
			}]];
			[alert addAction:[UIAlertAction actionWithTitle:strings[0] style:UIAlertActionStyleCancel handler:^(UIAlertAction *action) {
			[_self _restoreFirstResponderAfterUndoAlert];
			}]];
			[ctrl presentViewController:alert animated:YES completion:nil];
			} else {
			#pragma clang diagnostic push
			#pragma clang diagnostic ignored "-Wdeprecated-declarations"
			UIAlertView *alert = [[UIAlertView alloc] initWithTitle:strings[4] message:@"" delegate:self cancelButtonTitle:strings[0] otherButtonTitles:strings[3], nil];
			[alert show];
			#pragma clang diagnostic pop
			}
			} else if (canRedo) {
			if (kiOS8Later) {
			UIAlertController *alert = [UIAlertController alertControllerWithTitle:strings[2] message:@"" preferredStyle:UIAlertControllerStyleAlert];
			[alert addAction:[UIAlertAction actionWithTitle:strings[1] style:UIAlertActionStyleDefault handler:^(UIAlertAction *action) {
			[_self _redo];
			[_self _restoreFirstResponderAfterUndoAlert];
			}]];
			[alert addAction:[UIAlertAction actionWithTitle:strings[0] style:UIAlertActionStyleCancel handler:^(UIAlertAction *action) {
			[_self _restoreFirstResponderAfterUndoAlert];
			}]];
			[ctrl presentViewController:alert animated:YES completion:nil];
			} else {
			#pragma clang diagnostic push
			#pragma clang diagnostic ignored "-Wdeprecated-declarations"
			UIAlertView *alert = [[UIAlertView alloc] initWithTitle:strings[2] message:@"" delegate:self cancelButtonTitle:strings[0] otherButtonTitles:strings[1], nil];
			[alert show];
			#pragma clang diagnostic pop
			}
			}
			}
			#endif

			/// Get the localized undo alert strings based on app's main bundle.
			- (NSArray *)_localizedUndoStrings {
			static NSArray *strings = nil;
			static dispatch_once_t onceToken;
			dispatch_once(&onceToken, ^{
			NSDictionary *dic = @{
			@"ar" : @[ @"إلغاء", @"إعادة", @"إعادة الكتابة", @"تراجع", @"تراجع عن الكتابة" ],
			@"ca" : @[ @"Cancel·lar", @"Refer", @"Refer l’escriptura", @"Desfer", @"Desfer l’escriptura" ],
			@"cs" : @[ @"Zrušit", @"Opakovat akci", @"Opakovat akci Psát", @"Odvolat akci", @"Odvolat akci Psát" ],
			@"da" : @[ @"Annuller", @"Gentag", @"Gentag Indtastning", @"Fortryd", @"Fortryd Indtastning" ],
			@"de" : @[ @"Abbrechen", @"Wiederholen", @"Eingabe wiederholen", @"Widerrufen", @"Eingabe widerrufen" ],
			@"el" : @[ @"Ακύρωση", @"Επανάληψη", @"Επανάληψη πληκτρολόγησης", @"Αναίρεση", @"Αναίρεση πληκτρολόγησης" ],
			@"en" : @[ @"Cancel", @"Redo", @"Redo Typing", @"Undo", @"Undo Typing" ],
			@"es" : @[ @"Cancelar", @"Rehacer", @"Rehacer escritura", @"Deshacer", @"Deshacer escritura" ],
			@"es_MX" : @[ @"Cancelar", @"Rehacer", @"Rehacer escritura", @"Deshacer", @"Deshacer escritura" ],
			@"fi" : @[ @"Kumoa", @"Tee sittenkin", @"Kirjoita sittenkin", @"Peru", @"Peru kirjoitus" ],
			@"fr" : @[ @"Annuler", @"Rétablir", @"Rétablir la saisie", @"Annuler", @"Annuler la saisie" ],
			@"he" : @[ @"ביטול", @"חזור על הפעולה האחרונה", @"חזור על הקלדה", @"בטל", @"בטל הקלדה" ],
			@"hr" : @[ @"Odustani", @"Ponovi", @"Ponovno upiši", @"Poništi", @"Poništi upisivanje" ],
			@"hu" : @[ @"Mégsem", @"Ismétlés", @"Gépelés ismétlése", @"Visszavonás", @"Gépelés visszavonása" ],
			@"id" : @[ @"Batalkan", @"Ulang", @"Ulang Pengetikan", @"Kembalikan", @"Batalkan Pengetikan" ],
			@"it" : @[ @"Annulla", @"Ripristina originale", @"Ripristina Inserimento", @"Annulla", @"Annulla Inserimento" ],
			@"ja" : @[ @"キャンセル", @"やり直す", @"やり直す - 入力", @"取り消す", @"取り消す - 入力" ],
			@"ko" : @[ @"취소", @"실행 복귀", @"입력 복귀", @"실행 취소", @"입력 실행 취소" ],
			@"ms" : @[ @"Batal", @"Buat semula", @"Ulang Penaipan", @"Buat asal", @"Buat asal Penaipan" ],
			@"nb" : @[ @"Avbryt", @"Utfør likevel", @"Utfør skriving likevel", @"Angre", @"Angre skriving" ],
			@"nl" : @[ @"Annuleer", @"Opnieuw", @"Opnieuw typen", @"Herstel", @"Herstel typen" ],
			@"pl" : @[ @"Anuluj", @"Przywróć", @"Przywróć Wpisz", @"Cofnij", @"Cofnij Wpisz" ],
			@"pt" : @[ @"Cancelar", @"Refazer", @"Refazer Digitação", @"Desfazer", @"Desfazer Digitação" ],
			@"pt_PT" : @[ @"Cancelar", @"Refazer", @"Refazer digitar", @"Desfazer", @"Desfazer digitar" ],
			@"ro" : @[ @"Renunță", @"Refă", @"Refă tastare", @"Anulează", @"Anulează tastare" ],
			@"ru" : @[ @"Отменить", @"Повторить", @"Повторить набор на клавиатуре", @"Отменить", @"Отменить набор на клавиатуре" ],
			@"sk" : @[ @"Zrušiť", @"Obnoviť", @"Obnoviť písanie", @"Odvolať", @"Odvolať písanie" ],
			@"sv" : @[ @"Avbryt", @"Gör om", @"Gör om skriven text", @"Ångra", @"Ångra skriven text" ],
			@"th" : @[ @"ยกเลิก", @"ทำกลับมาใหม่", @"ป้อนกลับมาใหม่", @"เลิกทำ", @"เลิกป้อน" ],
			@"tr" : @[ @"Vazgeç", @"Yinele", @"Yazmayı Yinele", @"Geri Al", @"Yazmayı Geri Al" ],
			@"uk" : @[ @"Скасувати", @"Повторити", @"Повторити введення", @"Відмінити", @"Відмінити введення" ],
			@"vi" : @[ @"Hủy", @"Làm lại", @"Làm lại thao tác Nhập", @"Hoàn tác", @"Hoàn tác thao tác Nhập" ],
			@"zh" : @[ @"取消", @"重做", @"重做键入", @"撤销", @"撤销键入" ],
			@"zh_CN" : @[ @"取消", @"重做", @"重做键入", @"撤销", @"撤销键入" ],
			@"zh_HK" : @[ @"取消", @"重做", @"重做輸入", @"還原", @"還原輸入" ],
			@"zh_TW" : @[ @"取消", @"重做", @"重做輸入", @"還原", @"還原輸入" ]
			};
			NSString *preferred = [[NSBundle mainBundle] preferredLocalizations].firstObject;
			if (preferred.length == 0) preferred = @"English";
			NSString *canonical = [NSLocale canonicalLocaleIdentifierFromString:preferred];
			if (canonical.length == 0) canonical = @"en";
			strings = dic[canonical];
			if (!strings && ([canonical rangeOfString:@"_"].location != NSNotFound)) {
			NSString *prefix = [canonical componentsSeparatedByString:@"_"].firstObject;
			if (prefix.length) strings = dic[prefix];
			}
			if (!strings) strings = dic[@"en"];
			});
			return strings;
			}

			/// Returns the default font for text view (same as CoreText).
			- (UIFont *)_defaultFont {
			return [UIFont systemFontOfSize:12];
			}

			/// Returns the default tint color for text view (used for caret and select range background).
			- (UIColor *)_defaultTintColor {
			return [UIColor colorWithRed:69/255.0 green:111/255.0 blue:238/255.0 alpha:1];
			}

			/// Returns the default placeholder color for text view (same as UITextField).
			- (UIColor *)_defaultPlaceholderColor {
			return [UIColor colorWithRed:0 green:0 blue:25/255.0 alpha:44/255.0];
			}

			#pragma mark - Private Setter

			- (void)_setText:(NSString *)text {
			if (_text == text \|\| [_text isEqualToString:text]) return;
			[self willChangeValueForKey:@"text"];
			_text = text.copy;
			if (!_text) _text = @"";
			[self didChangeValueForKey:@"text"];
			self.accessibilityLabel = _text;
			}

			- (void)_setFont:(UIFont *)font {
			if (_font == font \|\| [_font isEqual:font]) return;
			[self willChangeValueForKey:@"font"];
			_font = font;
			[self didChangeValueForKey:@"font"];
			}

			- (void)_setTextColor:(UIColor *)textColor {
			if (_textColor == textColor) return;
			if (_textColor && textColor) {
			if (CFGetTypeID(_textColor.CGColor) == CFGetTypeID(textColor.CGColor) &&
			CFGetTypeID(_textColor.CGColor) == CGColorGetTypeID()) {
			if ([_textColor isEqual:textColor]) {
			return;
			}
			}
			}
			[self willChangeValueForKey:@"textColor"];
			_textColor = textColor;
			[self didChangeValueForKey:@"textColor"];
			}

			- (void)_setTextAlignment:(NSTextAlignment)textAlignment {
			if (_textAlignment == textAlignment) return;
			[self willChangeValueForKey:@"textAlignment"];
			_textAlignment = textAlignment;
			[self didChangeValueForKey:@"textAlignment"];
			}

			- (void)_setDataDetectorTypes:(UIDataDetectorTypes)dataDetectorTypes {
			if (_dataDetectorTypes == dataDetectorTypes) return;
			[self willChangeValueForKey:@"dataDetectorTypes"];
			_dataDetectorTypes = dataDetectorTypes;
			[self didChangeValueForKey:@"dataDetectorTypes"];
			}

			- (void)_setLinkTextAttributes:(NSDictionary *)linkTextAttributes {
			if (_linkTextAttributes == linkTextAttributes \|\| [_linkTextAttributes isEqual:linkTextAttributes]) return;
			[self willChangeValueForKey:@"linkTextAttributes"];
			_linkTextAttributes = linkTextAttributes.copy;
			[self didChangeValueForKey:@"linkTextAttributes"];
			}

			- (void)_setHighlightTextAttributes:(NSDictionary *)highlightTextAttributes {
			if (_highlightTextAttributes == highlightTextAttributes \|\| [_highlightTextAttributes isEqual:highlightTextAttributes]) return;
			[self willChangeValueForKey:@"highlightTextAttributes"];
			_highlightTextAttributes = highlightTextAttributes.copy;
			[self didChangeValueForKey:@"highlightTextAttributes"];
			}
			- (void)_setTextParser:(id<YYTextParser>)textParser {
			if (_textParser == textParser \|\| [_textParser isEqual:textParser]) return;
			[self willChangeValueForKey:@"textParser"];
			_textParser = textParser;
			[self didChangeValueForKey:@"textParser"];
			}

			- (void)_setAttributedText:(NSAttributedString *)attributedText {
			if (_attributedText == attributedText \|\| [_attributedText isEqual:attributedText]) return;
			[self willChangeValueForKey:@"attributedText"];
			_attributedText = attributedText.copy;
			if (!_attributedText) _attributedText = [NSAttributedString new];
			[self didChangeValueForKey:@"attributedText"];
			}

			- (void)_setTextContainerInset:(UIEdgeInsets)textContainerInset {
			if (UIEdgeInsetsEqualToEdgeInsets(_textContainerInset, textContainerInset)) return;
			[self willChangeValueForKey:@"textContainerInset"];
			_textContainerInset = textContainerInset;
			[self didChangeValueForKey:@"textContainerInset"];
			}

			- (void)_setExclusionPaths:(NSArray *)exclusionPaths {
			if (_exclusionPaths == exclusionPaths \|\| [_exclusionPaths isEqual:exclusionPaths]) return;
			[self willChangeValueForKey:@"exclusionPaths"];
			_exclusionPaths = exclusionPaths.copy;
			[self didChangeValueForKey:@"exclusionPaths"];
			}

			- (void)_setVerticalForm:(BOOL)verticalForm {
			if (_verticalForm == verticalForm) return;
			[self willChangeValueForKey:@"verticalForm"];
			_verticalForm = verticalForm;
			[self didChangeValueForKey:@"verticalForm"];
			}

			- (void)_setLinePositionModifier:(id<YYTextLinePositionModifier>)linePositionModifier {
			if (_linePositionModifier == linePositionModifier) return;
			[self willChangeValueForKey:@"linePositionModifier"];
			_linePositionModifier = [(NSObject *)linePositionModifier copy];
			[self didChangeValueForKey:@"linePositionModifier"];
			}

			- (void)_setSelectedRange:(NSRange)selectedRange {
			if (NSEqualRanges(_selectedRange, selectedRange)) return;
			[self willChangeValueForKey:@"selectedRange"];
			_selectedRange = selectedRange;
			[self didChangeValueForKey:@"selectedRange"];
			if ([self.delegate respondsToSelector:@selector(textViewDidChangeSelection:)]) {
			[self.delegate textViewDidChangeSelection:self];
			}
			}

			- (void)_setTypingAttributes:(NSDictionary *)typingAttributes {
			if (_typingAttributes == typingAttributes \|\| [_typingAttributes isEqual:typingAttributes]) return;
			[self willChangeValueForKey:@"typingAttributes"];
			_typingAttributes = typingAttributes.copy;
			[self didChangeValueForKey:@"typingAttributes"];
			}

			#pragma mark - Private Init

			- (void)_initTextView {
			self.delaysContentTouches = NO;
			self.canCancelContentTouches = YES;
			self.multipleTouchEnabled = NO;
			self.clipsToBounds = YES;
			[super setDelegate:self];

			_text = @"";
			_attributedText = [NSAttributedString new];

			// UITextInputTraits
			_autocapitalizationType = UITextAutocapitalizationTypeSentences;
			_autocorrectionType = UITextAutocorrectionTypeDefault;
			_spellCheckingType = UITextSpellCheckingTypeDefault;
			_keyboardType = UIKeyboardTypeDefault;
			_keyboardAppearance = UIKeyboardAppearanceDefault;
			_returnKeyType = UIReturnKeyDefault;
			_enablesReturnKeyAutomatically = NO;
			_secureTextEntry = NO;

			// UITextInput
			_selectedTextRange = [YYTextRange defaultRange];
			_markedTextRange = nil;
			_markedTextStyle = nil;
			_tokenizer = [[UITextInputStringTokenizer alloc] initWithTextInput:self];

			_editable = YES;
			_selectable = YES;
			_highlightable = YES;
			_allowsCopyAttributedString = YES;
			_textAlignment = NSTextAlignmentNatural;

			_innerText = [NSMutableAttributedString new];
			_innerContainer = [YYTextContainer new];
			_innerContainer.insets = kDefaultInset;
			_textContainerInset = kDefaultInset;
			_typingAttributesHolder = [[NSMutableAttributedString alloc] initWithString:@" "];
			_linkTextAttributes = @{NSForegroundColorAttributeName : [self _defaultTintColor],
			(id)kCTForegroundColorAttributeName : (id)[self _defaultTintColor].CGColor};

			YYTextHighlight *highlight = [YYTextHighlight new];
			YYTextBorder * border = [YYTextBorder new];
			border.insets = UIEdgeInsetsMake(-2, -2, -2, -2);
			border.fillColor = [UIColor colorWithWhite:0.1 alpha:0.2];
			border.cornerRadius = 3;
			[highlight setBorder:border];
			_highlightTextAttributes = highlight.attributes.copy;

			_placeHolderView = [UIImageView new];
			_placeHolderView.userInteractionEnabled = NO;
			_placeHolderView.hidden = YES;

			_containerView = [YYTextContainerView new];
			_containerView.hostView = self;

			_selectionView = [YYTextSelectionView new];
			_selectionView.userInteractionEnabled = NO;
			_selectionView.hostView = self;
			_selectionView.color = [self _defaultTintColor];

			_magnifierCaret = [YYTextMagnifier magnifierWithType:YYTextMagnifierTypeCaret];
			_magnifierCaret.hostView = _containerView;
			_magnifierRanged = [YYTextMagnifier magnifierWithType:YYTextMagnifierTypeRanged];
			_magnifierRanged.hostView = _containerView;

			[self addSubview:_placeHolderView];
			[self addSubview:_containerView];
			[self addSubview:_selectionView];

			_undoStack = [NSMutableArray new];
			_redoStack = [NSMutableArray new];
			_allowsUndoAndRedo = YES;
			_maximumUndoLevel = kDefaultUndoLevelMax;

			self.debugOption = [YYTextDebugOption sharedDebugOption];
			[YYTextDebugOption addDebugTarget:self];

			[self _updateInnerContainerSize];
			[self _update];

			[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(_pasteboardChanged) name:UIPasteboardChangedNotification object:nil];
			[[YYTextKeyboardManager defaultManager] addObserver:self];

			self.isAccessibilityElement = YES;
			}

			#pragma mark - Public

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

			- (void)dealloc {
			[[NSNotificationCenter defaultCenter] removeObserver:self name:UIPasteboardChangedNotification object:nil];
			[[YYTextKeyboardManager defaultManager] removeObserver:self];

			[[YYTextEffectWindow sharedWindow] hideSelectionDot:_selectionView];
			[[YYTextEffectWindow sharedWindow] hideMagnifier:_magnifierCaret];
			[[YYTextEffectWindow sharedWindow] hideMagnifier:_magnifierRanged];

			[YYTextDebugOption removeDebugTarget:self];

			[_longPressTimer invalidate];
			[_autoScrollTimer invalidate];
			[_selectionDotFixTimer invalidate];
			}

			- (void)scrollRangeToVisible:(NSRange)range {
			YYTextRange *textRange = [YYTextRange rangeWithRange:range];
			textRange = [self _correctedTextRange:textRange];
			[self _scrollRangeToVisible:textRange];
			}

			#pragma mark - Property

			- (void)setText:(NSString *)text {
			if (_text == text \|\| [_text isEqualToString:text]) return;
			[self _setText:text];

			_state.selectedWithoutEdit = NO;
			_state.deleteConfirm = NO;
			[self _endTouchTracking];
			[self _hideMenu];
			[self _resetUndoAndRedoStack];
			[self replaceRange:[YYTextRange rangeWithRange:NSMakeRange(0, _innerText.length)] withText:text];
			}

			- (void)setFont:(UIFont *)font {
			if (_font == font \|\| [_font isEqual:font]) return;
			[self _setFont:font];

			_state.typingAttributesOnce = NO;
			_typingAttributesHolder.yy_font = font;
			_innerText.yy_font = font;
			[self _resetUndoAndRedoStack];
			[self _commitUpdate];
			}

			- (void)setTextColor:(UIColor *)textColor {
			if (_textColor == textColor \|\| [_textColor isEqual:textColor]) return;
			[self _setTextColor:textColor];

			_state.typingAttributesOnce = NO;
			_typingAttributesHolder.yy_color = textColor;
			_innerText.yy_color = textColor;
			[self _resetUndoAndRedoStack];
			[self _commitUpdate];
			}

			- (void)setTextAlignment:(NSTextAlignment)textAlignment {
			if (_textAlignment == textAlignment) return;
			[self _setTextAlignment:textAlignment];

			_typingAttributesHolder.yy_alignment = textAlignment;
			_innerText.yy_alignment = textAlignment;
			[self _resetUndoAndRedoStack];
			[self _commitUpdate];
			}

			- (void)setDataDetectorTypes:(UIDataDetectorTypes)dataDetectorTypes {
			if (_dataDetectorTypes == dataDetectorTypes) return;
			[self _setDataDetectorTypes:dataDetectorTypes];
			NSTextCheckingType type = YYTextNSTextCheckingTypeFromUIDataDetectorType(dataDetectorTypes);
			_dataDetector = type ? [NSDataDetector dataDetectorWithTypes:type error:NULL] : nil;
			[self _resetUndoAndRedoStack];
			[self _commitUpdate];
			}

			- (void)setLinkTextAttributes:(NSDictionary *)linkTextAttributes {
			if (_linkTextAttributes == linkTextAttributes \|\| [_linkTextAttributes isEqual:linkTextAttributes]) return;
			[self _setLinkTextAttributes:linkTextAttributes];
			if (_dataDetector) {
			[self _commitUpdate];
			}
			}

			- (void)setHighlightTextAttributes:(NSDictionary *)highlightTextAttributes {
			if (_highlightTextAttributes == highlightTextAttributes \|\| [_highlightTextAttributes isEqual:highlightTextAttributes]) return;
			[self _setHighlightTextAttributes:highlightTextAttributes];
			if (_dataDetector) {
			[self _commitUpdate];
			}
			}

			- (void)setTextParser:(id<YYTextParser>)textParser {
			if (_textParser == textParser \|\| [_textParser isEqual:textParser]) return;
			[self _setTextParser:textParser];
			if (textParser && _text.length) {
			[self replaceRange:[YYTextRange rangeWithRange:NSMakeRange(0, _text.length)] withText:_text];
			}
			[self _resetUndoAndRedoStack];
			[self _commitUpdate];
			}

			- (void)setTypingAttributes:(NSDictionary *)typingAttributes {
			[self _setTypingAttributes:typingAttributes];
			_state.typingAttributesOnce = YES;
			[typingAttributes enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop) {
			[_typingAttributesHolder yy_setAttribute:key value:obj];
			}];
			[self _commitUpdate];
			}

			- (void)setAttributedText:(NSAttributedString *)attributedText {
			if (_attributedText == attributedText) return;
			[self _setAttributedText:attributedText];
			_state.typingAttributesOnce = NO;

			NSMutableAttributedString *text = attributedText.mutableCopy;
			if (text.length == 0) {
			[self replaceRange:[YYTextRange rangeWithRange:NSMakeRange(0, _innerText.length)] withText:@""];
			return;
			}
			if ([self.delegate respondsToSelector:@selector(textView:shouldChangeTextInRange:replacementText:)]) {
			BOOL should = [self.delegate textView:self shouldChangeTextInRange:NSMakeRange(0, _innerText.length) replacementText:text.string];
			if (!should) return;
			}

			_state.selectedWithoutEdit = NO;
			_state.deleteConfirm = NO;
			[self _endTouchTracking];
			[self _hideMenu];

			[_inputDelegate selectionWillChange:self];
			[_inputDelegate textWillChange:self];
			_innerText = text;
			[self _parseText];
			_selectedTextRange = [YYTextRange rangeWithRange:NSMakeRange(0, _innerText.length)];
			[_inputDelegate textDidChange:self];
			[_inputDelegate selectionDidChange:self];

			[self _setAttributedText:text];
			if (_innerText.length > 0) {
			_typingAttributesHolder.yy_attributes = [_innerText yy_attributesAtIndex:_innerText.length - 1];
			}

			[self _updateOuterProperties];
			[self _updateLayout];
			[self _updateSelectionView];

			if (self.isFirstResponder) {
			[self _scrollRangeToVisible:_selectedTextRange];
			}

			if ([self.delegate respondsToSelector:@selector(textViewDidChange:)]) {
			[self.delegate textViewDidChange:self];
			}
			[[NSNotificationCenter defaultCenter] postNotificationName:YYTextViewTextDidChangeNotification object:self];

			if (!_state.insideUndoBlock) {
			[self _resetUndoAndRedoStack];
			}
			}

			- (void)setTextVerticalAlignment:(YYTextVerticalAlignment)textVerticalAlignment {
			if (_textVerticalAlignment == textVerticalAlignment) return;
			[self willChangeValueForKey:@"textVerticalAlignment"];
			_textVerticalAlignment = textVerticalAlignment;
			[self didChangeValueForKey:@"textVerticalAlignment"];
			_containerView.textVerticalAlignment = textVerticalAlignment;
			[self _commitUpdate];
			}

			- (void)setTextContainerInset:(UIEdgeInsets)textContainerInset {
			if (UIEdgeInsetsEqualToEdgeInsets(_textContainerInset, textContainerInset)) return;
			[self _setTextContainerInset:textContainerInset];
			_innerContainer.insets = textContainerInset;
			[self _commitUpdate];
			}

			- (void)setExclusionPaths:(NSArray *)exclusionPaths {
			if (_exclusionPaths == exclusionPaths \|\| [_exclusionPaths isEqual:exclusionPaths]) return;
			[self _setExclusionPaths:exclusionPaths];
			_innerContainer.exclusionPaths = exclusionPaths;
			if (_innerContainer.isVerticalForm) {
			CGAffineTransform trans = CGAffineTransformMakeTranslation(_innerContainer.size.width - self.bounds.size.width, 0);
			[_innerContainer.exclusionPaths enumerateObjectsUsingBlock:^(UIBezierPath path, NSUInteger idx, BOOL stop) {
			[path applyTransform:trans];
			}];
			}
			[self _commitUpdate];
			}

			- (void)setVerticalForm:(BOOL)verticalForm {
			if (_verticalForm == verticalForm) return;
			[self _setVerticalForm:verticalForm];
			_innerContainer.verticalForm = verticalForm;
			_selectionView.verticalForm = verticalForm;

			[self _updateInnerContainerSize];

			if (verticalForm) {
			if (UIEdgeInsetsEqualToEdgeInsets(_innerContainer.insets, kDefaultInset)) {
			_innerContainer.insets = kDefaultVerticalInset;
			[self _setTextContainerInset:kDefaultVerticalInset];
			}
			} else {
			if (UIEdgeInsetsEqualToEdgeInsets(_innerContainer.insets, kDefaultVerticalInset)) {
			_innerContainer.insets = kDefaultInset;
			[self _setTextContainerInset:kDefaultInset];
			}
			}

			_innerContainer.exclusionPaths = _exclusionPaths;
			if (verticalForm) {
			CGAffineTransform trans = CGAffineTransformMakeTranslation(_innerContainer.size.width - self.bounds.size.width, 0);
			[_innerContainer.exclusionPaths enumerateObjectsUsingBlock:^(UIBezierPath path, NSUInteger idx, BOOL stop) {
			[path applyTransform:trans];
			}];
			}

			[self _keyboardChanged];
			[self _commitUpdate];
			}

			- (void)setLinePositionModifier:(id<YYTextLinePositionModifier>)linePositionModifier {
			if (_linePositionModifier == linePositionModifier) return;
			[self _setLinePositionModifier:linePositionModifier];
			_innerContainer.linePositionModifier = linePositionModifier;
			[self _commitUpdate];
			}

			- (void)setSelectedRange:(NSRange)selectedRange {
			if (NSEqualRanges(_selectedRange, selectedRange)) return;
			if (_markedTextRange) return;
			_state.typingAttributesOnce = NO;

			YYTextRange *range = [YYTextRange rangeWithRange:selectedRange];
			range = [self _correctedTextRange:range];
			[self _endTouchTracking];
			_selectedTextRange = range;
			[self _updateSelectionView];

			[self _setSelectedRange:range.asRange];

			if (!_state.insideUndoBlock) {
			[self _resetUndoAndRedoStack];
			}
			}

			- (void)setHighlightable:(BOOL)highlightable {
			if (_highlightable == highlightable) return;
			[self willChangeValueForKey:@"highlightable"];
			_highlightable = highlightable;
			[self didChangeValueForKey:@"highlightable"];
			[self _commitUpdate];
			}

			- (void)setEditable:(BOOL)editable {
			if (_editable == editable) return;
			[self willChangeValueForKey:@"editable"];
			_editable = editable;
			[self didChangeValueForKey:@"editable"];
			if (!editable) {
			[self resignFirstResponder];
			}
			}

			- (void)setSelectable:(BOOL)selectable {
			if (_selectable == selectable) return;
			[self willChangeValueForKey:@"selectable"];
			_selectable = selectable;
			[self didChangeValueForKey:@"selectable"];
			if (!selectable) {
			if (self.isFirstResponder) {
			[self resignFirstResponder];
			} else {
			_state.selectedWithoutEdit = NO;
			[self _endTouchTracking];
			[self _hideMenu];
			[self _updateSelectionView];
			}
			}
			}

			- (void)setClearsOnInsertion:(BOOL)clearsOnInsertion {
			if (_clearsOnInsertion == clearsOnInsertion) return;
			_clearsOnInsertion = clearsOnInsertion;
			if (clearsOnInsertion) {
			if (self.isFirstResponder) {
			self.selectedRange = NSMakeRange(0, _attributedText.length);
			} else {
			_state.clearsOnInsertionOnce = YES;
			}
			}
			}

			- (void)setDebugOption:(YYTextDebugOption *)debugOption {
			_containerView.debugOption = debugOption;
			}

			- (YYTextDebugOption *)debugOption {
			return _containerView.debugOption;
			}

			- (YYTextLayout *)textLayout {
			[self _updateIfNeeded];
			return _innerLayout;
			}

			- (void)setPlaceholderText:(NSString *)placeholderText {
			if (_placeholderAttributedText.length > 0) {
			if (placeholderText.length > 0) {
			[((NSMutableAttributedString *)_placeholderAttributedText) replaceCharactersInRange:NSMakeRange(0, _placeholderAttributedText.length) withString:placeholderText];
			} else {
			[((NSMutableAttributedString *)_placeholderAttributedText) replaceCharactersInRange:NSMakeRange(0, _placeholderAttributedText.length) withString:@""];
			}
			((NSMutableAttributedString *)_placeholderAttributedText).yy_font = _placeholderFont;
			((NSMutableAttributedString *)_placeholderAttributedText).yy_color = _placeholderTextColor;
			} else {
			if (placeholderText.length > 0) {
			NSMutableAttributedString *atr = [[NSMutableAttributedString alloc] initWithString:placeholderText];
			if (!_placeholderFont) _placeholderFont = _font;
			if (!_placeholderFont) _placeholderFont = [self _defaultFont];
			if (!_placeholderTextColor) _placeholderTextColor = [self _defaultPlaceholderColor];
			atr.yy_font = _placeholderFont;
			atr.yy_color = _placeholderTextColor;
			_placeholderAttributedText = atr;
			}
			}
			_placeholderText = [_placeholderAttributedText yy_plainTextForRange:NSMakeRange(0, _placeholderAttributedText.length)];
			[self _commitPlaceholderUpdate];
			}

			- (void)setPlaceholderFont:(UIFont *)placeholderFont {
			_placeholderFont = placeholderFont;
			((NSMutableAttributedString *)_placeholderAttributedText).yy_font = _placeholderFont;
			[self _commitPlaceholderUpdate];
			}

			- (void)setPlaceholderTextColor:(UIColor *)placeholderTextColor {
			_placeholderTextColor = placeholderTextColor;
			((NSMutableAttributedString *)_placeholderAttributedText).yy_color = _placeholderTextColor;
			[self _commitPlaceholderUpdate];
			}

			- (void)setPlaceholderAttributedText:(NSAttributedString *)placeholderAttributedText {
			_placeholderAttributedText = placeholderAttributedText.mutableCopy;
			_placeholderText = [_placeholderAttributedText yy_plainTextForRange:NSMakeRange(0, _placeholderAttributedText.length)];
			_placeholderFont = _placeholderAttributedText.yy_font;
			_placeholderTextColor = _placeholderAttributedText.yy_color;
			[self _commitPlaceholderUpdate];
			}

			#pragma mark - Override For Protect

			- (void)setMultipleTouchEnabled:(BOOL)multipleTouchEnabled {
			[super setMultipleTouchEnabled:NO]; // must not enabled
			}

			- (void)setContentInset:(UIEdgeInsets)contentInset {
			UIEdgeInsets oldInsets = self.contentInset;
			if (_insetModifiedByKeyboard) {
			_originalContentInset = contentInset;
			} else {
			[super setContentInset:contentInset];
			BOOL changed = !UIEdgeInsetsEqualToEdgeInsets(oldInsets, contentInset);
			if (changed) {
			[self _updateInnerContainerSize];
			[self _commitUpdate];
			[self _commitPlaceholderUpdate];
			}
			}
			}

			- (void)setScrollIndicatorInsets:(UIEdgeInsets)scrollIndicatorInsets {
			if (_insetModifiedByKeyboard) {
			_originalScrollIndicatorInsets = scrollIndicatorInsets;
			} else {
			[super setScrollIndicatorInsets:scrollIndicatorInsets];
			}
			}

			- (void)setFrame:(CGRect)frame {
			CGSize oldSize = self.bounds.size;
			[super setFrame:frame];
			CGSize newSize = self.bounds.size;
			BOOL changed = _innerContainer.isVerticalForm ? (oldSize.height != newSize.height) : (oldSize.width != newSize.width);
			if (changed) {
			[self _updateInnerContainerSize];
			[self _commitUpdate];
			}
			if (!CGSizeEqualToSize(oldSize, newSize)) {
			[self _commitPlaceholderUpdate];
			}
			}

			- (void)setBounds:(CGRect)bounds {
			CGSize oldSize = self.bounds.size;
			[super setBounds:bounds];
			CGSize newSize = self.bounds.size;
			BOOL changed = _innerContainer.isVerticalForm ? (oldSize.height != newSize.height) : (oldSize.width != newSize.width);
			if (changed) {
			[self _updateInnerContainerSize];
			[self _commitUpdate];
			}
			if (!CGSizeEqualToSize(oldSize, newSize)) {
			[self _commitPlaceholderUpdate];
			}
			}

			- (void)tintColorDidChange {
			if ([self respondsToSelector:@selector(tintColor)]) {
			UIColor *color = self.tintColor;
			NSMutableDictionary *attrs = _highlightTextAttributes.mutableCopy;
			NSMutableDictionary *linkAttrs = _linkTextAttributes.mutableCopy;
			if (!linkAttrs) linkAttrs = @{}.mutableCopy;
			if (!color) {
			[attrs removeObjectForKey:NSForegroundColorAttributeName];
			[attrs removeObjectForKey:(id)kCTForegroundColorAttributeName];
			[linkAttrs setObject:[self _defaultTintColor] forKey:NSForegroundColorAttributeName];
			[linkAttrs setObject:(id)[self _defaultTintColor].CGColor forKey:(id)kCTForegroundColorAttributeName];
			} else {
			[attrs setObject:color forKey:NSForegroundColorAttributeName];
			[attrs setObject:(id)color.CGColor forKey:(id)kCTForegroundColorAttributeName];
			[linkAttrs setObject:color forKey:NSForegroundColorAttributeName];
			[linkAttrs setObject:(id)color.CGColor forKey:(id)kCTForegroundColorAttributeName];
			}
			self.highlightTextAttributes = attrs;
			_selectionView.color = color ? color : [self _defaultTintColor];
			_linkTextAttributes = linkAttrs;
			[self _commitUpdate];
			}
			}

			- (CGSize)sizeThatFits:(CGSize)size {
			if (!_verticalForm && size.width <= 0) size.width = YYTextContainerMaxSize.width;
			if (_verticalForm && size.height <= 0) size.height = YYTextContainerMaxSize.height;

			if ((!_verticalForm && size.width == self.bounds.size.width) \|\|
			(_verticalForm && size.height == self.bounds.size.height)) {
			[self _updateIfNeeded];
			if (!_verticalForm) {
			if (_containerView.bounds.size.height <= size.height) {
			return _containerView.bounds.size;
			}
			} else {
			if (_containerView.bounds.size.width <= size.width) {
			return _containerView.bounds.size;
			}
			}
			}

			if (!_verticalForm) {
			size.height = YYTextContainerMaxSize.height;
			} else {
			size.width = YYTextContainerMaxSize.width;
			}

			YYTextContainer *container = [_innerContainer copy];
			container.size = size;

			YYTextLayout *layout = [YYTextLayout layoutWithContainer:container text:_innerText];
			return layout.textBoundingSize;
			}

			#pragma mark - Override UIResponder

			- (void)touchesBegan:(NSSet )touches withEvent:(UIEvent )event {
			[self _updateIfNeeded];
			UITouch *touch = touches.anyObject;
			CGPoint point = [touch locationInView:_containerView];

			_touchBeganTime = _trackingTime = touch.timestamp;
			_touchBeganPoint = _trackingPoint = point;
			_trackingRange = _selectedTextRange;

			_state.trackingGrabber = NO;
			_state.trackingCaret = NO;
			_state.trackingPreSelect = NO;
			_state.trackingTouch = YES;
			_state.swallowTouch = YES;
			_state.touchMoved = NO;

			if (!self.isFirstResponder && !_state.selectedWithoutEdit && self.highlightable) {
			_highlight = [self _getHighlightAtPoint:point range:&_highlightRange];
			_highlightLayout = nil;
			}

			if ((!self.selectable && !_highlight) \|\| _state.ignoreTouchBegan) {
			_state.swallowTouch = NO;
			_state.trackingTouch = NO;
			}

			if (_state.trackingTouch) {
			[self _startLongPressTimer];
			if (_highlight) {
			[self _showHighlightAnimated:NO];
			} else {
			if ([_selectionView isGrabberContainsPoint:point]) { // track grabber
			self.panGestureRecognizer.enabled = NO; // disable scroll view
			[self _hideMenu];
			_state.trackingGrabber = [_selectionView isStartGrabberContainsPoint:point] ? kStart : kEnd;
			_magnifierRangedOffset = [self _getMagnifierRangedOffset];
			} else {
			if (_selectedTextRange.asRange.length == 0 && self.isFirstResponder) {
			if ([_selectionView isCaretContainsPoint:point]) { // track caret
			_state.trackingCaret = YES;
			self.panGestureRecognizer.enabled = NO; // disable scroll view
			}
			}
			}
			}
			[self _updateSelectionView];
			}

			if (!_state.swallowTouch) [super touchesBegan:touches withEvent:event];
			}

			- (void)touchesMoved:(NSSet )touches withEvent:(UIEvent )event {
			[self _updateIfNeeded];
			UITouch *touch = touches.anyObject;
			CGPoint point = [touch locationInView:_containerView];

			_trackingTime = touch.timestamp;
			_trackingPoint = point;

			if (!_state.touchMoved) {
			_state.touchMoved = [self _getMoveDirection];
			if (_state.touchMoved) [self _endLongPressTimer];
			}
			_state.clearsOnInsertionOnce = NO;

			if (_state.trackingTouch) {
			BOOL showMagnifierCaret = NO;
			BOOL showMagnifierRanged = NO;

			if (_highlight) {

			YYTextHighlight *highlight = [self _getHighlightAtPoint:_trackingPoint range:NULL];
			if (highlight == _highlight) {
			[self _showHighlightAnimated:YES];
			} else {
			[self _hideHighlightAnimated:YES];
			}

			} else {
			_trackingRange = _selectedTextRange;
			if (_state.trackingGrabber) {
			self.panGestureRecognizer.enabled = NO;
			[self _hideMenu];
			[self _updateTextRangeByTrackingGrabber];
			showMagnifierRanged = YES;
			} else if (_state.trackingPreSelect) {
			[self _updateTextRangeByTrackingPreSelect];
			showMagnifierCaret = YES;
			} else if (_state.trackingCaret \|\| _markedTextRange \|\| self.isFirstResponder) {
			if (_state.trackingCaret \|\| _state.touchMoved) {
			_state.trackingCaret = YES;
			[self _hideMenu];
			if (_verticalForm) {
			if (_state.touchMoved == kTop \|\| _state.touchMoved == kBottom) {
			self.panGestureRecognizer.enabled = NO;
			}
			} else {
			if (_state.touchMoved == kLeft \|\| _state.touchMoved == kRight) {
			self.panGestureRecognizer.enabled = NO;
			}
			}
			[self _updateTextRangeByTrackingCaret];
			if (_markedTextRange) {
			showMagnifierRanged = YES;
			} else {
			showMagnifierCaret = YES;
			}
			}
			}
			}
			[self _updateSelectionView];
			if (showMagnifierCaret) [self _showMagnifierCaret];
			if (showMagnifierRanged) [self _showMagnifierRanged];
			}

			CGFloat autoScrollOffset = [self _getAutoscrollOffset];
			if (_autoScrollOffset != autoScrollOffset) {
			if (fabs(autoScrollOffset) < fabs(_autoScrollOffset)) {
			_autoScrollAcceleration *= 0.5;
			}
			_autoScrollOffset = autoScrollOffset;
			if (_autoScrollOffset != 0 && _state.touchMoved) {
			[self _startAutoScrollTimer];
			}
			}

			if (!_state.swallowTouch) [super touchesMoved:touches withEvent:event];
			}

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

			UITouch *touch = touches.anyObject;
			CGPoint point = [touch locationInView:_containerView];

			_trackingTime = touch.timestamp;
			_trackingPoint = point;

			if (!_state.touchMoved) {
			_state.touchMoved = [self _getMoveDirection];
			}
			if (_state.trackingTouch) {
			[self _hideMagnifier];

			if (_highlight) {
			if (_state.showingHighlight) {
			if (_highlight.tapAction) {
			CGRect rect = [_innerLayout rectForRange:[YYTextRange rangeWithRange:_highlightRange]];
			rect = [self _convertRectFromLayout:rect];
			_highlight.tapAction(self, _innerText, _highlightRange, rect);
			} else {
			BOOL shouldTap = YES;
			if ([self.delegate respondsToSelector:@selector(textView:shouldTapHighlight:inRange:)]) {
			shouldTap = [self.delegate textView:self shouldTapHighlight:_highlight inRange:_highlightRange];
			}
			if (shouldTap && [self.delegate respondsToSelector:@selector(textView:didTapHighlight:inRange:rect:)]) {
			CGRect rect = [_innerLayout rectForRange:[YYTextRange rangeWithRange:_highlightRange]];
			rect = [self _convertRectFromLayout:rect];
			[self.delegate textView:self didTapHighlight:_highlight inRange:_highlightRange rect:rect];
			}
			}
			[self _removeHighlightAnimated:YES];
			}
			} else {
			if (_state.trackingCaret) {
			if (_state.touchMoved) {
			[self _updateTextRangeByTrackingCaret];
			[self _showMenu];
			} else {
			if (_state.showingMenu) [self _hideMenu];
			else [self _showMenu];
			}
			} else if (_state.trackingGrabber) {
			[self _updateTextRangeByTrackingGrabber];
			[self _showMenu];
			} else if (_state.trackingPreSelect) {
			[self _updateTextRangeByTrackingPreSelect];
			if (_trackingRange.asRange.length > 0) {
			_state.selectedWithoutEdit = YES;
			[self _showMenu];
			} else {
			[self performSelector:@selector(becomeFirstResponder) withObject:nil afterDelay:0];
			}
			} else if (_state.deleteConfirm \|\| _markedTextRange) {
			[self _updateTextRangeByTrackingCaret];
			[self _hideMenu];
			} else {
			if (!_state.touchMoved) {
			if (_state.selectedWithoutEdit) {
			_state.selectedWithoutEdit = NO;
			[self _hideMenu];
			} else {
			if (self.isFirstResponder) {
			YYTextRange *_oldRange = _trackingRange;
			[self _updateTextRangeByTrackingCaret];
			if ([_oldRange isEqual:_trackingRange]) {
			if (_state.showingMenu) [self _hideMenu];
			else [self _showMenu];
			} else {
			[self _hideMenu];
			}
			} else {
			[self _hideMenu];
			if (_state.clearsOnInsertionOnce) {
			_state.clearsOnInsertionOnce = NO;
			_selectedTextRange = [YYTextRange rangeWithRange:NSMakeRange(0, _innerText.length)];
			[self _setSelectedRange:_selectedTextRange.asRange];
			} else {
			[self _updateTextRangeByTrackingCaret];
			}
			[self performSelector:@selector(becomeFirstResponder) withObject:nil afterDelay:0];
			}
			}
			}
			}
			}

			if (_trackingRange && (![_trackingRange isEqual:_selectedTextRange] \|\| _state.trackingPreSelect)) {
			if (![_trackingRange isEqual:_selectedTextRange]) {
			[_inputDelegate selectionWillChange:self];
			_selectedTextRange = _trackingRange;
			[_inputDelegate selectionDidChange:self];
			[self _updateAttributesHolder];
			[self _updateOuterProperties];
			}
			if (!_state.trackingGrabber && !_state.trackingPreSelect) {
			[self _scrollRangeToVisible:_selectedTextRange];
			}
			}

			[self _endTouchTracking];
			}

			if (!_state.swallowTouch) [super touchesEnded:touches withEvent:event];
			}

			- (void)touchesCancelled:(NSSet )touches withEvent:(UIEvent )event {
			[self _endTouchTracking];
			[self _hideMenu];

			if (!_state.swallowTouch) [super touchesCancelled:touches withEvent:event];
			}

			- (void)motionEnded:(UIEventSubtype)motion withEvent:(UIEvent *)event {
			if (motion == UIEventSubtypeMotionShake && _allowsUndoAndRedo) {
			if (!YYTextIsAppExtension()) {
			#pragma clang diagnostic push
			#pragma clang diagnostic ignored "-Wundeclared-selector"
			[self performSelector:@selector(_showUndoRedoAlert)];
			#pragma clang diagnostic pop
			}
			} else {
			[super motionEnded:motion withEvent:event];
			}
			}

			- (BOOL)canBecomeFirstResponder {
			if (!self.isSelectable) return NO;
			if (!self.isEditable) return NO;
			if (_state.ignoreFirstResponder) return NO;
			if ([self.delegate respondsToSelector:@selector(textViewShouldBeginEditing:)]) {
			if (![self.delegate textViewShouldBeginEditing:self]) return NO;
			}
			return YES;
			}

			- (BOOL)becomeFirstResponder {
			BOOL isFirstResponder = self.isFirstResponder;
			if (isFirstResponder) return YES;
			BOOL shouldDetectData = [self _shouldDetectText];
			BOOL become = [super becomeFirstResponder];
			if (!isFirstResponder && become) {
			[self _endTouchTracking];
			[self _hideMenu];

			_state.selectedWithoutEdit = NO;
			if (shouldDetectData != [self _shouldDetectText]) {
			[self _update];
			}
			[self _updateIfNeeded];
			[self _updateSelectionView];
			[self performSelector:@selector(_scrollSelectedRangeToVisible) withObject:nil afterDelay:0];
			if ([self.delegate respondsToSelector:@selector(textViewDidBeginEditing:)]) {
			[self.delegate textViewDidBeginEditing:self];
			}
			[[NSNotificationCenter defaultCenter] postNotificationName:YYTextViewTextDidBeginEditingNotification object:self];
			}
			return become;
			}

			- (BOOL)canResignFirstResponder {
			if (!self.isFirstResponder) return YES;
			if ([self.delegate respondsToSelector:@selector(textViewShouldEndEditing:)]) {
			if (![self.delegate textViewShouldEndEditing:self]) return NO;
			}
			return YES;
			}

			- (BOOL)resignFirstResponder {
			BOOL isFirstResponder = self.isFirstResponder;
			if (!isFirstResponder) return YES;
			BOOL resign = [super resignFirstResponder];
			if (resign) {
			if (_markedTextRange) {
			_markedTextRange = nil;
			[self _parseText];
			[self _setText:[_innerText yy_plainTextForRange:NSMakeRange(0, _innerText.length)]];
			}
			_state.selectedWithoutEdit = NO;
			if ([self _shouldDetectText]) {
			[self _update];
			}
			[self _endTouchTracking];
			[self _hideMenu];
			[self _updateIfNeeded];
			[self _updateSelectionView];
			[self _restoreInsetsAnimated:YES];
			if ([self.delegate respondsToSelector:@selector(textViewDidEndEditing:)]) {
			[self.delegate textViewDidEndEditing:self];
			}
			[[NSNotificationCenter defaultCenter] postNotificationName:YYTextViewTextDidEndEditingNotification object:self];
			}
			return resign;
			}

			- (BOOL)canPerformAction:(SEL)action withSender:(id)sender {
			/*
			------------------------------------------------------
			Default menu actions list:
			cut: Cut
			copy: Copy
			select: Select
			selectAll: Select All
			paste: Paste
			delete: Delete
			_promptForReplace: Replace...
			_transliterateChinese: 简⇄繁
			_showTextStyleOptions: 𝐁𝐼𝐔
			_define: Define
			_addShortcut: Add...
			_accessibilitySpeak: Speak
			_accessibilitySpeakLanguageSelection: Speak...
			_accessibilityPauseSpeaking: Pause Speak
			makeTextWritingDirectionRightToLeft: ⇋
			makeTextWritingDirectionLeftToRight: ⇌

			------------------------------------------------------
			Default attribute modifier list:
			toggleBoldface:
			toggleItalics:
			toggleUnderline:
			increaseSize:
			decreaseSize:
			*/

			if (_selectedTextRange.asRange.length == 0) {
			if (action == @selector(select:) \|\|
			action == @selector(selectAll:)) {
			return _innerText.length > 0;
			}
			if (action == @selector(paste:)) {
			return [self _isPasteboardContainsValidValue];
			}
			} else {
			if (action == @selector(cut:)) {
			return self.isFirstResponder && self.editable;
			}
			if (action == @selector(copy:)) {
			return YES;
			}
			if (action == @selector(selectAll:)) {
			return _selectedTextRange.asRange.length < _innerText.length;
			}
			if (action == @selector(paste:)) {
			return self.isFirstResponder && self.editable && [self _isPasteboardContainsValidValue];
			}
			NSString *selString = NSStringFromSelector(action);
			if ([selString hasSuffix:@"define:"] && [selString hasPrefix:@"_"]) {
			return [self _getRootViewController] != nil;
			}
			}
			return NO;
			}

			- (void)reloadInputViews {
			[super reloadInputViews];
			if (_markedTextRange) {
			[self unmarkText];
			}
			}

			#pragma mark - Override NSObject(UIResponderStandardEditActions)

			- (void)cut:(id)sender {
			[self _endTouchTracking];
			if (_selectedTextRange.asRange.length == 0) return;

			[self _copySelectedTextToPasteboard];
			[self _saveToUndoStack];
			[self _resetRedoStack];
			[self replaceRange:_selectedTextRange withText:@""];
			}

			- (void)copy:(id)sender {
			[self _endTouchTracking];
			[self _copySelectedTextToPasteboard];
			}

			- (void)paste:(id)sender {
			[self _endTouchTracking];
			UIPasteboard *p = [UIPasteboard generalPasteboard];
			NSAttributedString *atr = nil;

			if (_allowsPasteAttributedString) {
			atr = p.yy_AttributedString;
			if (atr.length == 0) atr = nil;
			}
			if (!atr && _allowsPasteImage) {
			UIImage *img = nil;

			Class cls = NSClassFromString(@"YYImage");
			if (cls) {
			#pragma clang diagnostic push
			#pragma clang diagnostic ignored "-Wundeclared-selector"
			if (p.yy_GIFData) {
			img = [(id)cls performSelector:@selector(imageWithData:scale:) withObject:p.yy_GIFData withObject:nil];
			}
			if (!img && p.yy_PNGData) {
			img = [(id)cls performSelector:@selector(imageWithData:scale:) withObject:p.yy_PNGData withObject:nil];
			}
			if (!img && p.yy_WEBPData) {
			img = [(id)cls performSelector:@selector(imageWithData:scale:) withObject:p.yy_WEBPData withObject:nil];
			}
			#pragma clang diagnostic pop
			}

			if (!img) {
			img = p.image;
			}
			if (!img && p.yy_ImageData) {
			img = [UIImage imageWithData:p.yy_ImageData scale:YYTextScreenScale()];
			}
			if (img && img.size.width > 1 && img.size.height > 1) {
			id content = img;

			if (cls) {
			if ([img conformsToProtocol:NSProtocolFromString(@"YYAnimatedImage")]) {
			NSNumber *frameCount = [img valueForKey:@"animatedImageFrameCount"];
			if (frameCount.integerValue > 1) {
			Class viewCls = NSClassFromString(@"YYAnimatedImageView");
			UIImageView *imgView = [(id)viewCls new];
			imgView.image = img;
			imgView.frame = CGRectMake(0, 0, img.size.width, img.size.height);
			if (imgView) {
			content = imgView;
			}
			}
			}
			}

			if ([content isKindOfClass:[UIImage class]] && img.images.count > 1) {
			UIImageView *imgView = [UIImageView new];
			imgView.image = img;
			imgView.frame = CGRectMake(0, 0, img.size.width, img.size.height);
			if (imgView) {
			content = imgView;
			}
			}

			NSMutableAttributedString *attText = [NSAttributedString yy_attachmentStringWithContent:content contentMode:UIViewContentModeScaleToFill width:img.size.width ascent:img.size.height descent:0];
			NSDictionary *attrs = _typingAttributesHolder.yy_attributes;
			if (attrs) [attText addAttributes:attrs range:NSMakeRange(0, attText.length)];
			atr = attText;
			}
			}

			if (atr) {
			NSUInteger endPosition = _selectedTextRange.start.offset + atr.length;
			NSMutableAttributedString *text = _innerText.mutableCopy;
			[text replaceCharactersInRange:_selectedTextRange.asRange withAttributedString:atr];
			self.attributedText = text;
			YYTextPosition *pos = [self _correctedTextPosition:[YYTextPosition positionWithOffset:endPosition]];
			YYTextRange *range = [_innerLayout textRangeByExtendingPosition:pos];
			range = [self _correctedTextRange:range];
			if (range) {
			self.selectedRange = NSMakeRange(range.end.offset, 0);
			}
			} else {
			NSString *string = p.string;
			if (string.length > 0) {
			[self _saveToUndoStack];
			[self _resetRedoStack];
			[self replaceRange:_selectedTextRange withText:string];
			}
			}
			}

			- (void)select:(id)sender {
			[self _endTouchTracking];

			if (_selectedTextRange.asRange.length > 0 \|\| _innerText.length == 0) return;
			YYTextRange *newRange = [self _getClosestTokenRangeAtPosition:_selectedTextRange.start];
			if (newRange.asRange.length > 0) {
			[_inputDelegate selectionWillChange:self];
			_selectedTextRange = newRange;
			[_inputDelegate selectionDidChange:self];
			}

			[self _updateIfNeeded];
			[self _updateOuterProperties];
			[self _updateSelectionView];
			[self _hideMenu];
			[self _showMenu];
			}

			- (void)selectAll:(id)sender {
			_trackingRange = nil;
			[_inputDelegate selectionWillChange:self];
			_selectedTextRange = [YYTextRange rangeWithRange:NSMakeRange(0, _innerText.length)];
			[_inputDelegate selectionDidChange:self];

			[self _updateIfNeeded];
			[self _updateOuterProperties];
			[self _updateSelectionView];
			[self _hideMenu];
			[self _showMenu];
			}

			- (void)_define:(id)sender {
			[self _hideMenu];

			NSString *string = [_innerText yy_plainTextForRange:_selectedTextRange.asRange];
			if (string.length == 0) return;
			BOOL resign = [self resignFirstResponder];
			if (!resign) return;

			UIReferenceLibraryViewController* ref = [[UIReferenceLibraryViewController alloc] initWithTerm:string];
			ref.view.backgroundColor = [UIColor whiteColor];
			[[self _getRootViewController] presentViewController:ref animated:YES completion:^{}];
			}


			#pragma mark - Overrice NSObject(NSKeyValueObservingCustomization)

			+ (BOOL)automaticallyNotifiesObserversForKey:(NSString *)key {
			static NSSet *keys = nil;
			static dispatch_once_t onceToken;
			dispatch_once(&onceToken, ^{
			keys = [NSSet setWithArray:@[
			@"text",
			@"font",
			@"textColor",
			@"textAlignment",
			@"dataDetectorTypes",
			@"linkTextAttributes",
			@"highlightTextAttributes",
			@"textParser",
			@"attributedText",
			@"textVerticalAlignment",
			@"textContainerInset",
			@"exclusionPaths",
			@"verticalForm",
			@"linePositionModifier",
			@"selectedRange",
			@"typingAttributes"
			]];
			});
			if ([keys containsObject:key]) {
			return NO;
			}
			return [super automaticallyNotifiesObserversForKey:key];
			}

			#pragma mark - @protocol NSCoding

			- (instancetype)initWithCoder:(NSCoder *)aDecoder {
			self = [super initWithCoder:aDecoder];
			[self _initTextView];
			self.attributedText = [aDecoder decodeObjectForKey:@"attributedText"];
			self.selectedRange = ((NSValue *)[aDecoder decodeObjectForKey:@"selectedRange"]).rangeValue;
			self.textVerticalAlignment = [aDecoder decodeIntegerForKey:@"textVerticalAlignment"];
			self.dataDetectorTypes = [aDecoder decodeIntegerForKey:@"dataDetectorTypes"];
			self.textContainerInset = ((NSValue *)[aDecoder decodeObjectForKey:@"textContainerInset"]).UIEdgeInsetsValue;
			self.exclusionPaths = [aDecoder decodeObjectForKey:@"exclusionPaths"];
			self.verticalForm = [aDecoder decodeBoolForKey:@"verticalForm"];
			return self;
			}

			- (void)encodeWithCoder:(NSCoder *)aCoder {
			[super encodeWithCoder:aCoder];
			[aCoder encodeObject:self.attributedText forKey:@"attributedText"];
			[aCoder encodeObject:[NSValue valueWithRange:self.selectedRange] forKey:@"selectedRange"];
			[aCoder encodeInteger:self.textVerticalAlignment forKey:@"textVerticalAlignment"];
			[aCoder encodeInteger:self.dataDetectorTypes forKey:@"dataDetectorTypes"];
			[aCoder encodeUIEdgeInsets:self.textContainerInset forKey:@"textContainerInset"];
			[aCoder encodeObject:self.exclusionPaths forKey:@"exclusionPaths"];
			[aCoder encodeBool:self.verticalForm forKey:@"verticalForm"];
			}

			#pragma mark - @protocol UIScrollViewDelegate

			- (id<YYTextViewDelegate>)delegate {
			return _outerDelegate;
			}

			- (void)setDelegate:(id<YYTextViewDelegate>)delegate {
			_outerDelegate = delegate;
			}

			- (void)scrollViewDidScroll:(UIScrollView *)scrollView {
			[[YYTextEffectWindow sharedWindow] hideSelectionDot:_selectionView];

			if ([_outerDelegate respondsToSelector:_cmd]) {
			[_outerDelegate scrollViewDidScroll:scrollView];
			}
			}

			- (void)scrollViewDidZoom:(UIScrollView *)scrollView {
			if ([_outerDelegate respondsToSelector:_cmd]) {
			[_outerDelegate scrollViewDidZoom:scrollView];
			}
			}

			- (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView {
			if ([_outerDelegate respondsToSelector:_cmd]) {
			[_outerDelegate scrollViewWillBeginDragging:scrollView];
			}
			}

			- (void)scrollViewWillEndDragging:(UIScrollView )scrollView withVelocity:(CGPoint)velocity targetContentOffset:(inout CGPoint )targetContentOffset {
			if ([_outerDelegate respondsToSelector:_cmd]) {
			[_outerDelegate scrollViewWillEndDragging:scrollView withVelocity:velocity targetContentOffset:targetContentOffset];
			}
			}

			- (void)scrollViewDidEndDragging:(UIScrollView *)scrollView willDecelerate:(BOOL)decelerate {
			if (!decelerate) {
			[[YYTextEffectWindow sharedWindow] showSelectionDot:_selectionView];
			}

			if ([_outerDelegate respondsToSelector:_cmd]) {
			[_outerDelegate scrollViewDidEndDragging:scrollView willDecelerate:decelerate];
			}
			}

			- (void)scrollViewWillBeginDecelerating:(UIScrollView *)scrollView {
			if ([_outerDelegate respondsToSelector:_cmd]) {
			[_outerDelegate scrollViewWillBeginDecelerating:scrollView];
			}
			}

			- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView {
			[[YYTextEffectWindow sharedWindow] showSelectionDot:_selectionView];

			if ([_outerDelegate respondsToSelector:_cmd]) {
			[_outerDelegate scrollViewDidEndDecelerating:scrollView];
			}
			}

			- (void)scrollViewDidEndScrollingAnimation:(UIScrollView *)scrollView {
			if ([_outerDelegate respondsToSelector:_cmd]) {
			[_outerDelegate scrollViewDidEndScrollingAnimation:scrollView];
			}
			}

			- (UIView )viewForZoomingInScrollView:(UIScrollView )scrollView {
			if ([_outerDelegate respondsToSelector:_cmd]) {
			return [_outerDelegate viewForZoomingInScrollView:scrollView];
			} else {
			return nil;
			}
			}

			- (void)scrollViewWillBeginZooming:(UIScrollView )scrollView withView:(UIView )view{
			if ([_outerDelegate respondsToSelector:_cmd]) {
			[_outerDelegate scrollViewWillBeginZooming:scrollView withView:view];
			}
			}

			- (void)scrollViewDidEndZooming:(UIScrollView )scrollView withView:(UIView )view atScale:(CGFloat)scale {
			if ([_outerDelegate respondsToSelector:_cmd]) {
			[_outerDelegate scrollViewDidEndZooming:scrollView withView:view atScale:scale];
			}
			}

			- (BOOL)scrollViewShouldScrollToTop:(UIScrollView *)scrollView {
			if ([_outerDelegate respondsToSelector:_cmd]) {
			return [_outerDelegate scrollViewShouldScrollToTop:scrollView];
			}
			return YES;
			}

			- (void)scrollViewDidScrollToTop:(UIScrollView *)scrollView {
			if ([_outerDelegate respondsToSelector:_cmd]) {
			[_outerDelegate scrollViewDidScrollToTop:scrollView];
			}
			}

			#pragma mark - @protocol YYTextKeyboardObserver

			- (void)keyboardChangedWithTransition:(YYTextKeyboardTransition)transition {
			[self _keyboardChanged];
			}

			#pragma mark - @protocol UIALertViewDelegate

			- (void)alertView:(UIAlertView *)alertView clickedButtonAtIndex:(NSInteger)buttonIndex {
			NSString *title = [alertView buttonTitleAtIndex:buttonIndex];
			if (title.length == 0) return;
			NSArray *strings = [self _localizedUndoStrings];
			if ([title isEqualToString:strings[1]] \|\| [title isEqualToString:strings[2]]) {
			[self _redo];
			} else if ([title isEqualToString:strings[3]] \|\| [title isEqualToString:strings[4]]) {
			[self _undo];
			}
			[self _restoreFirstResponderAfterUndoAlert];
			}

			#pragma mark - @protocol UIKeyInput

			- (BOOL)hasText {
			return _innerText.length > 0;
			}

			- (void)insertText:(NSString *)text {
			if (text.length == 0) return;
			if (!NSEqualRanges(_lastTypeRange, _selectedTextRange.asRange)) {
			[self _saveToUndoStack];
			[self _resetRedoStack];
			}
			[self replaceRange:_selectedTextRange withText:text];
			}

			- (void)deleteBackward {
			[self _updateIfNeeded];
			NSRange range = _selectedTextRange.asRange;
			if (range.location == 0 && range.length == 0) return;
			_state.typingAttributesOnce = NO;

			// test if there's 'TextBinding' before the caret
			if (!_state.deleteConfirm && range.length == 0 && range.location > 0) {
			NSRange effectiveRange;
			YYTextBinding *binding = [_innerText attribute:YYTextBindingAttributeName atIndex:range.location - 1 longestEffectiveRange:&effectiveRange inRange:NSMakeRange(0, _innerText.length)];
			if (binding && binding.deleteConfirm) {
			_state.deleteConfirm = YES;
			[_inputDelegate selectionWillChange:self];
			_selectedTextRange = [YYTextRange rangeWithRange:effectiveRange];
			_selectedTextRange = [self _correctedTextRange:_selectedTextRange];
			[_inputDelegate selectionDidChange:self];

			[self _updateOuterProperties];
			[self _updateSelectionView];
			return;
			}
			}

			_state.deleteConfirm = NO;
			if (range.length == 0) {
			YYTextRange *extendRange = [_innerLayout textRangeByExtendingPosition:_selectedTextRange.end inDirection:UITextLayoutDirectionLeft offset:1];
			if ([self _isTextRangeValid:extendRange]) {
			range = extendRange.asRange;
			}
			}
			if (!NSEqualRanges(_lastTypeRange, _selectedTextRange.asRange)) {
			[self _saveToUndoStack];
			[self _resetRedoStack];
			}
			[self replaceRange:[YYTextRange rangeWithRange:range] withText:@""];
			}

			#pragma mark - @protocol UITextInput

			- (void)setInputDelegate:(id<UITextInputDelegate>)inputDelegate {
			_inputDelegate = inputDelegate;
			}

			- (void)setSelectedTextRange:(YYTextRange *)selectedTextRange {
			if (!selectedTextRange) return;
			selectedTextRange = [self _correctedTextRange:selectedTextRange];
			if ([selectedTextRange isEqual:_selectedTextRange]) return;
			[self _updateIfNeeded];
			[self _endTouchTracking];
			[self _hideMenu];
			_state.deleteConfirm = NO;
			_state.typingAttributesOnce = NO;

			[_inputDelegate selectionWillChange:self];
			_selectedTextRange = selectedTextRange;
			_lastTypeRange = _selectedTextRange.asRange;
			[_inputDelegate selectionDidChange:self];

			[self _updateOuterProperties];
			[self _updateSelectionView];

			if (self.isFirstResponder) {
			[self _scrollRangeToVisible:_selectedTextRange];
			}
			}

			- (void)setMarkedTextStyle:(NSDictionary *)markedTextStyle {
			_markedTextStyle = markedTextStyle.copy;
			}

			/*
			Replace current markedText with the new markedText
			@param markedText New marked text.
			@param selectedRange The range from the '_markedTextRange'
			*/
			- (void)setMarkedText:(NSString *)markedText selectedRange:(NSRange)selectedRange {
			[self _updateIfNeeded];
			[self _endTouchTracking];
			[self _hideMenu];

			if ([self.delegate respondsToSelector:@selector(textView:shouldChangeTextInRange:replacementText:)]) {
			NSRange range = _markedTextRange ? _markedTextRange.asRange : NSMakeRange(_selectedTextRange.end.offset, 0);
			BOOL should = [self.delegate textView:self shouldChangeTextInRange:range replacementText:markedText];
			if (!should) return;
			}


			if (!NSEqualRanges(_lastTypeRange, _selectedTextRange.asRange)) {
			[self _saveToUndoStack];
			[self _resetRedoStack];
			}

			BOOL needApplyHolderAttribute = NO;
			if (_innerText.length > 0 && _markedTextRange) {
			[self _updateAttributesHolder];
			} else {
			needApplyHolderAttribute = YES;
			}

			if (_selectedTextRange.asRange.length > 0) {
			[self replaceRange:_selectedTextRange withText:@""];
			}

			[_inputDelegate textWillChange:self];
			[_inputDelegate selectionWillChange:self];

			if (!markedText) markedText = @"";
			if (_markedTextRange == nil) {
			_markedTextRange = [YYTextRange rangeWithRange:NSMakeRange(_selectedTextRange.end.offset, markedText.length)];
			[_innerText replaceCharactersInRange:NSMakeRange(_selectedTextRange.end.offset, 0) withString:markedText];
			_selectedTextRange = [YYTextRange rangeWithRange:NSMakeRange(_selectedTextRange.start.offset + selectedRange.location, selectedRange.length)];
			} else {
			_markedTextRange = [self _correctedTextRange:_markedTextRange];
			[_innerText replaceCharactersInRange:_markedTextRange.asRange withString:markedText];
			_markedTextRange = [YYTextRange rangeWithRange:NSMakeRange(_markedTextRange.start.offset, markedText.length)];
			_selectedTextRange = [YYTextRange rangeWithRange:NSMakeRange(_markedTextRange.start.offset + selectedRange.location, selectedRange.length)];
			}

			_selectedTextRange = [self _correctedTextRange:_selectedTextRange];
			_markedTextRange = [self _correctedTextRange:_markedTextRange];
			if (_markedTextRange.asRange.length == 0) {
			_markedTextRange = nil;
			} else {
			if (needApplyHolderAttribute) {
			[_innerText setAttributes:_typingAttributesHolder.yy_attributes range:_markedTextRange.asRange];
			}
			[_innerText yy_removeDiscontinuousAttributesInRange:_markedTextRange.asRange];
			}

			[_inputDelegate selectionDidChange:self];
			[_inputDelegate textDidChange:self];

			[self _updateOuterProperties];
			[self _updateLayout];
			[self _updateSelectionView];
			[self _scrollRangeToVisible:_selectedTextRange];

			if ([self.delegate respondsToSelector:@selector(textViewDidChange:)]) {
			[self.delegate textViewDidChange:self];
			}
			[[NSNotificationCenter defaultCenter] postNotificationName:YYTextViewTextDidChangeNotification object:self];

			_lastTypeRange = _selectedTextRange.asRange;
			}

			- (void)unmarkText {
			_markedTextRange = nil;
			[self _endTouchTracking];
			[self _hideMenu];
			if ([self _parseText]) _state.needUpdate = YES;

			[self _updateIfNeeded];
			[self _updateOuterProperties];
			[self _updateSelectionView];
			[self _scrollRangeToVisible:_selectedTextRange];
			}

			- (void)replaceRange:(YYTextRange )range withText:(NSString )text {
			if (!range) return;
			if (!text) text = @"";
			if (range.asRange.length == 0 && text.length == 0) return;
			range = [self _correctedTextRange:range];

			if ([self.delegate respondsToSelector:@selector(textView:shouldChangeTextInRange:replacementText:)]) {
			BOOL should = [self.delegate textView:self shouldChangeTextInRange:range.asRange replacementText:text];
			if (!should) return;
			}

			BOOL useInnerAttributes = NO;
			if (_innerText.length > 0) {
			if (range.start.offset == 0 && range.end.offset == _innerText.length) {
			if (text.length == 0) {
			NSMutableDictionary *attrs = [_innerText yy_attributesAtIndex:0].mutableCopy;
			[attrs removeObjectsForKeys:[NSMutableAttributedString yy_allDiscontinuousAttributeKeys]];
			_typingAttributesHolder.yy_attributes = attrs;
			}
			}
			} else { // no text
			useInnerAttributes = YES;
			}
			BOOL applyTypingAttributes = NO;
			if (_state.typingAttributesOnce) {
			_state.typingAttributesOnce = NO;
			if (!useInnerAttributes) {
			if (range.asRange.length == 0 && text.length > 0) {
			applyTypingAttributes = YES;
			}
			}
			}

			_state.selectedWithoutEdit = NO;
			_state.deleteConfirm = NO;
			[self _endTouchTracking];
			[self _hideMenu];

			[self _replaceRange:range withText:text notifyToDelegate:YES];
			if (useInnerAttributes) {
			[_innerText yy_setAttributes:_typingAttributesHolder.yy_attributes];
			} else if (applyTypingAttributes) {
			NSRange newRange = NSMakeRange(range.asRange.location, text.length);
			[_typingAttributesHolder.yy_attributes enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop) {
			[_innerText yy_setAttribute:key value:obj range:newRange];
			}];
			}
			[self _parseText];
			[self _updateOuterProperties];
			[self _update];

			if (self.isFirstResponder) {
			[self _scrollRangeToVisible:_selectedTextRange];
			}

			if ([self.delegate respondsToSelector:@selector(textViewDidChange:)]) {
			[self.delegate textViewDidChange:self];
			}
			[[NSNotificationCenter defaultCenter] postNotificationName:YYTextViewTextDidChangeNotification object:self];

			_lastTypeRange = _selectedTextRange.asRange;
			}

			- (void)setBaseWritingDirection:(UITextWritingDirection)writingDirection forRange:(YYTextRange *)range {
			if (!range) return;
			range = [self _correctedTextRange:range];
			[_innerText yy_setBaseWritingDirection:(NSWritingDirection)writingDirection range:range.asRange];
			[self _commitUpdate];
			}

			- (NSString )textInRange:(YYTextRange )range {
			range = [self _correctedTextRange:range];
			if (!range) return @"";
			return [_innerText.string substringWithRange:range.asRange];
			}

			- (UITextWritingDirection)baseWritingDirectionForPosition:(YYTextPosition *)position inDirection:(UITextStorageDirection)direction {
			[self _updateIfNeeded];
			position = [self _correctedTextPosition:position];
			if (!position) return UITextWritingDirectionNatural;
			if (_innerText.length == 0) return UITextWritingDirectionNatural;
			NSUInteger idx = position.offset;
			if (idx == _innerText.length) idx--;

			NSDictionary *attrs = [_innerText yy_attributesAtIndex:idx];
			CTParagraphStyleRef paraStyle = (__bridge CFTypeRef)(attrs[NSParagraphStyleAttributeName]);
			if (paraStyle) {
			CTWritingDirection baseWritingDirection;
			if (CTParagraphStyleGetValueForSpecifier(paraStyle, kCTParagraphStyleSpecifierBaseWritingDirection, sizeof(CTWritingDirection), &baseWritingDirection)) {
			return (UITextWritingDirection)baseWritingDirection;
			}
			}

			return UITextWritingDirectionNatural;
			}

			- (YYTextPosition *)beginningOfDocument {
			return [YYTextPosition positionWithOffset:0];
			}

			- (YYTextPosition *)endOfDocument {
			return [YYTextPosition positionWithOffset:_innerText.length];
			}

			- (YYTextPosition )positionFromPosition:(YYTextPosition )position offset:(NSInteger)offset {
			if (offset == 0) return position;

			NSUInteger location = position.offset;
			NSInteger newLocation = (NSInteger)location + offset;
			if (newLocation < 0 \|\| newLocation > _innerText.length) return nil;

			if (newLocation != 0 && newLocation != _innerText.length) {
			// fix emoji
			[self _updateIfNeeded];
			YYTextRange *extendRange = [_innerLayout textRangeByExtendingPosition:[YYTextPosition positionWithOffset:newLocation]];
			if (extendRange.asRange.length > 0) {
			if (offset < 0) {
			newLocation = extendRange.start.offset;
			} else {
			newLocation = extendRange.end.offset;
			}
			}
			}

			YYTextPosition *p = [YYTextPosition positionWithOffset:newLocation];
			return [self _correctedTextPosition:p];
			}

			- (YYTextPosition )positionFromPosition:(YYTextPosition )position inDirection:(UITextLayoutDirection)direction offset:(NSInteger)offset {
			[self _updateIfNeeded];
			YYTextRange *range = [_innerLayout textRangeByExtendingPosition:position inDirection:direction offset:offset];

			BOOL forward;
			if (_innerContainer.isVerticalForm) {
			forward = direction == UITextLayoutDirectionLeft \|\| direction == UITextLayoutDirectionDown;
			} else {
			forward = direction == UITextLayoutDirectionDown \|\| direction == UITextLayoutDirectionRight;
			}
			if (!forward && offset < 0) {
			forward = -forward;
			}

			YYTextPosition *newPosition = forward ? range.end : range.start;
			if (newPosition.offset > _innerText.length) {
			newPosition = [YYTextPosition positionWithOffset:_innerText.length affinity:YYTextAffinityBackward];
			}

			return [self _correctedTextPosition:newPosition];
			}

			- (YYTextRange )textRangeFromPosition:(YYTextPosition )fromPosition toPosition:(YYTextPosition *)toPosition {
			return [YYTextRange rangeWithStart:fromPosition end:toPosition];
			}

			- (NSComparisonResult)comparePosition:(YYTextPosition )position toPosition:(YYTextPosition )other {
			return [position compare:other];
			}

			- (NSInteger)offsetFromPosition:(YYTextPosition )from toPosition:(YYTextPosition )toPosition {
			return toPosition.offset - from.offset;
			}

			- (YYTextPosition )positionWithinRange:(YYTextRange )range farthestInDirection:(UITextLayoutDirection)direction {
			NSRange nsRange = range.asRange;
			if (direction == UITextLayoutDirectionLeft \| direction == UITextLayoutDirectionUp) {
			return [YYTextPosition positionWithOffset:nsRange.location];
			} else {
			return [YYTextPosition positionWithOffset:nsRange.location + nsRange.length affinity:YYTextAffinityBackward];
			}
			}

			- (YYTextRange )characterRangeByExtendingPosition:(YYTextPosition )position inDirection:(UITextLayoutDirection)direction {
			[self _updateIfNeeded];
			YYTextRange *range = [_innerLayout textRangeByExtendingPosition:position inDirection:direction offset:1];
			return [self _correctedTextRange:range];
			}

			- (YYTextPosition *)closestPositionToPoint:(CGPoint)point {
			[self _updateIfNeeded];
			point = [self _convertPointToLayout:point];
			YYTextPosition *position = [_innerLayout closestPositionToPoint:point];
			return [self _correctedTextPosition:position];
			}

			- (YYTextPosition )closestPositionToPoint:(CGPoint)point withinRange:(YYTextRange )range {
			YYTextPosition *pos = (id)[self closestPositionToPoint:point];
			if (!pos) return nil;

			range = [self _correctedTextRange:range];
			if ([pos compare:range.start] == NSOrderedAscending) {
			pos = range.start;
			} else if ([pos compare:range.end] == NSOrderedDescending) {
			pos = range.end;
			}
			return pos;
			}

			- (YYTextRange *)characterRangeAtPoint:(CGPoint)point {
			[self _updateIfNeeded];
			point = [self _convertPointToLayout:point];
			YYTextRange *r = [_innerLayout closestTextRangeAtPoint:point];
			return [self _correctedTextRange:r];
			}

			- (CGRect)firstRectForRange:(YYTextRange *)range {
			[self _updateIfNeeded];
			CGRect rect = [_innerLayout firstRectForRange:range];
			if (CGRectIsNull(rect)) rect = CGRectZero;
			return [self _convertRectFromLayout:rect];
			}

			- (CGRect)caretRectForPosition:(YYTextPosition *)position {
			[self _updateIfNeeded];
			CGRect caretRect = [_innerLayout caretRectForPosition:position];
			if (!CGRectIsNull(caretRect)) {
			caretRect = [self _convertRectFromLayout:caretRect];
			caretRect = CGRectStandardize(caretRect);
			if (_verticalForm) {
			if (caretRect.size.height == 0) {
			caretRect.size.height = 2;
			caretRect.origin.y -= 2 * 0.5;
			}
			if (caretRect.origin.y < 0) {
			caretRect.origin.y = 0;
			} else if (caretRect.origin.y + caretRect.size.height > self.bounds.size.height) {
			caretRect.origin.y = self.bounds.size.height - caretRect.size.height;
			}
			} else {
			if (caretRect.size.width == 0) {
			caretRect.size.width = 2;
			caretRect.origin.x -= 2 * 0.5;
			}
			if (caretRect.origin.x < 0) {
			caretRect.origin.x = 0;
			} else if (caretRect.origin.x + caretRect.size.width > self.bounds.size.width) {
			caretRect.origin.x = self.bounds.size.width - caretRect.size.width;
			}
			}
			return YYTextCGRectPixelRound(caretRect);
			}
			return CGRectZero;
			}

			- (NSArray )selectionRectsForRange:(YYTextRange )range {
			[self _updateIfNeeded];
			NSArray *rects = [_innerLayout selectionRectsForRange:range];
			[rects enumerateObjectsUsingBlock:^(YYTextSelectionRect rect, NSUInteger idx, BOOL stop) {
			rect.rect = [self _convertRectFromLayout:rect.rect];
			}];
			return rects;
			}

			#pragma mark - @protocol UITextInput optional

			- (UITextStorageDirection)selectionAffinity {
			if (_selectedTextRange.end.affinity == YYTextAffinityForward) {
			return UITextStorageDirectionForward;
			} else {
			return UITextStorageDirectionBackward;
			}
			}

			- (void)setSelectionAffinity:(UITextStorageDirection)selectionAffinity {
			_selectedTextRange = [YYTextRange rangeWithRange:_selectedTextRange.asRange affinity:selectionAffinity == UITextStorageDirectionForward ? YYTextAffinityForward : YYTextAffinityBackward];
			[self _updateSelectionView];
			}

			- (NSDictionary )textStylingAtPosition:(YYTextPosition )position inDirection:(UITextStorageDirection)direction {
			if (!position) return nil;
			if (_innerText.length == 0) return _typingAttributesHolder.yy_attributes;
			NSDictionary *attrs = nil;
			if (0 <= position.offset && position.offset <= _innerText.length) {
			NSUInteger ofs = position.offset;
			if (position.offset == _innerText.length \|\|
			direction == UITextStorageDirectionBackward) {
			ofs--;
			}
			attrs = [_innerText attributesAtIndex:ofs effectiveRange:NULL];
			}
			return attrs;
			}

			- (YYTextPosition )positionWithinRange:(YYTextRange )range atCharacterOffset:(NSInteger)offset {
			if (!range) return nil;
			if (offset < range.start.offset \|\| offset > range.end.offset) return nil;
			if (offset == range.start.offset) return range.start;
			else if (offset == range.end.offset) return range.end;
			else return [YYTextPosition positionWithOffset:offset];
			}

			- (NSInteger)characterOffsetOfPosition:(YYTextPosition )position withinRange:(YYTextRange )range {
			return position ? position.offset : NSNotFound;
			}

			@end



			@interface YYTextView(IBInspectableProperties)
			@end

			@implementation YYTextView(IBInspectableProperties)

			- (BOOL)fontIsBold_:(UIFont *)font {
			if (![font respondsToSelector:@selector(fontDescriptor)]) return NO;
			return (font.fontDescriptor.symbolicTraits & UIFontDescriptorTraitBold) > 0;
			}

			- (UIFont )boldFont_:(UIFont )font {
			if (![font respondsToSelector:@selector(fontDescriptor)]) return font;
			return [UIFont fontWithDescriptor:[font.fontDescriptor fontDescriptorWithSymbolicTraits:UIFontDescriptorTraitBold] size:font.pointSize];
			}

			- (UIFont )normalFont_:(UIFont )font {
			if (![font respondsToSelector:@selector(fontDescriptor)]) return font;
			return [UIFont fontWithDescriptor:[font.fontDescriptor fontDescriptorWithSymbolicTraits:0] size:font.pointSize];
			}

			- (void)setFontName_:(NSString *)fontName {
			if (!fontName) return;
			UIFont *font = self.font;
			if (!font) font = [self _defaultFont];
			if ((fontName.length == 0 \|\| [fontName.lowercaseString isEqualToString:@"system"]) && ![self fontIsBold_:font]) {
			font = [UIFont systemFontOfSize:font.pointSize];
			} else if ([fontName.lowercaseString isEqualToString:@"system bold"]) {
			font = [UIFont boldSystemFontOfSize:font.pointSize];
			} else {
			if ([self fontIsBold_:font] && ([fontName.lowercaseString rangeOfString:@"bold"].location == NSNotFound)) {
			font = [UIFont fontWithName:fontName size:font.pointSize];
			font = [self boldFont_:font];
			} else {
			font = [UIFont fontWithName:fontName size:font.pointSize];
			}
			}
			if (font) self.font = font;
			}

			- (void)setFontSize_:(CGFloat)fontSize {
			if (fontSize <= 0) return;
			UIFont *font = self.font;
			if (!font) font = [self _defaultFont];
			if (!font) font = [self _defaultFont];
			font = [font fontWithSize:fontSize];
			if (font) self.font = font;
			}

			- (void)setFontIsBold_:(BOOL)fontBold {
			UIFont *font = self.font;
			if (!font) font = [self _defaultFont];
			if ([self fontIsBold_:font] == fontBold) return;
			if (fontBold) {
			font = [self boldFont_:font];
			} else {
			font = [self normalFont_:font];
			}
			if (font) self.font = font;
			}

			- (void)setPlaceholderFontName_:(NSString *)fontName {
			if (!fontName) return;
			UIFont *font = self.placeholderFont;
			if (!font) font = [self _defaultFont];
			if ((fontName.length == 0 \|\| [fontName.lowercaseString isEqualToString:@"system"]) && ![self fontIsBold_:font]) {
			font = [UIFont systemFontOfSize:font.pointSize];
			} else if ([fontName.lowercaseString isEqualToString:@"system bold"]) {
			font = [UIFont boldSystemFontOfSize:font.pointSize];
			} else {
			if ([self fontIsBold_:font] && ([fontName.lowercaseString rangeOfString:@"bold"].location == NSNotFound)) {
			font = [UIFont fontWithName:fontName size:font.pointSize];
			font = [self boldFont_:font];
			} else {
			font = [UIFont fontWithName:fontName size:font.pointSize];
			}
			}
			if (font) self.placeholderFont = font;
			}

			- (void)setPlaceholderFontSize_:(CGFloat)fontSize {
			if (fontSize <= 0) return;
			UIFont *font = self.placeholderFont;
			if (!font) font = [self _defaultFont];
			font = [font fontWithSize:fontSize];
			if (font) self.placeholderFont = font;
			}

			- (void)setPlaceholderFontIsBold_:(BOOL)fontBold {
			UIFont *font = self.placeholderFont;
			if (!font) font = [self _defaultFont];
			if ([self fontIsBold_:font] == fontBold) return;
			if (fontBold) {
			font = [self boldFont_:font];
			} else {
			font = [self normalFont_:font];
			}
			if (font) self.placeholderFont = font;
			}

			- (void)setInsetTop_:(CGFloat)textInsetTop {
			UIEdgeInsets insets = self.textContainerInset;
			insets.top = textInsetTop;
			self.textContainerInset = insets;
			}

			- (void)setInsetBottom_:(CGFloat)textInsetBottom {
			UIEdgeInsets insets = self.textContainerInset;
			insets.bottom = textInsetBottom;
			self.textContainerInset = insets;
			}

			- (void)setInsetLeft_:(CGFloat)textInsetLeft {
			UIEdgeInsets insets = self.textContainerInset;
			insets.left = textInsetLeft;
			self.textContainerInset = insets;

			}

			- (void)setInsetRight_:(CGFloat)textInsetRight {
			UIEdgeInsets insets = self.textContainerInset;
			insets.right = textInsetRight;
			self.textContainerInset = insets;
			}

			- (void)setDebugEnabled_:(BOOL)enabled {
			if (!enabled) {
			self.debugOption = nil;
			} else {
			YYTextDebugOption *debugOption = [YYTextDebugOption new];
			debugOption.baselineColor = [UIColor redColor];
			debugOption.CTFrameBorderColor = [UIColor redColor];
			debugOption.CTLineFillColor = [UIColor colorWithRed:0.000 green:0.463 blue:1.000 alpha:0.180];
			debugOption.CGGlyphBorderColor = [UIColor colorWithRed:1.000 green:0.524 blue:0.000 alpha:0.200];
			self.debugOption = debugOption;
			}
			}

			@end