ASEditableTextNode.mm

//
//  ASEditableTextNode.mm
//  Texture
//
//  Copyright (c) Facebook, Inc. and its affiliates.  All rights reserved.
//  Changes after 4/13/2017 are: Copyright (c) Pinterest, Inc.  All rights reserved.
//  Licensed under Apache 2.0: http://www.apache.org/licenses/LICENSE-2.0
//

#import <AsyncDisplayKit/ASEditableTextNode.h>

#import <objc/message.h>
#import <tgmath.h>

#import <AsyncDisplayKit/ASDisplayNode+Subclasses.h>
#import <AsyncDisplayKit/ASEqualityHelpers.h>
#import <AsyncDisplayKit/ASTextKitComponents.h>
#import "ASTextNodeWordKerner.h"
#import <AsyncDisplayKit/ASThread.h>

@implementation ASEditableTextNodeTargetForAction

- (instancetype)initWithTarget:(id _Nullable)target {
  self = [super init];
  if (self != nil) {
    _target = target;
  }
  return self;
}

@end

/**
 @abstract Object to hold UITextView's pending UITextInputTraits
**/
@interface _ASTextInputTraitsPendingState : NSObject

@property UITextAutocapitalizationType autocapitalizationType;
@property UITextAutocorrectionType autocorrectionType;
@property UITextSpellCheckingType spellCheckingType;
@property UIKeyboardAppearance keyboardAppearance;
@property UIKeyboardType keyboardType;
@property UIReturnKeyType returnKeyType;
@property BOOL enablesReturnKeyAutomatically;
@property (getter=isSecureTextEntry) BOOL secureTextEntry;

@end

@implementation _ASTextInputTraitsPendingState

- (instancetype)init
{
  if (!(self = [super init]))
    return nil;
  
  // set default values, as defined in Apple's comments in UITextInputTraits.h
  _autocapitalizationType = UITextAutocapitalizationTypeSentences;
  _autocorrectionType = UITextAutocorrectionTypeDefault;
  _spellCheckingType = UITextSpellCheckingTypeDefault;
  _keyboardAppearance = UIKeyboardAppearanceDefault;
  _keyboardType = UIKeyboardTypeDefault;
  _returnKeyType = UIReturnKeyDefault;
  
  return self;
}

@end

/**
 @abstract As originally reported in rdar://14729288, when scrollEnabled = NO,
   UITextView does not calculate its contentSize. This makes it difficult 
   for a client to embed a UITextView inside a different scroll view with 
   other content (setting scrollEnabled = NO on the UITextView itself,
   because the containing scroll view will handle the gesture)...
   because accessing contentSize is typically necessary to perform layout.
   Apple later closed the issue as expected behavior. This works around
   the issue by ensuring that contentSize is always calculated, while
   still providing control over the UITextView's scrolling.

 See issue: https://github.com/facebook/AsyncDisplayKit/issues/1063
 */

@interface ASPanningOverriddenUITextView : ASTextKitComponentsTextView
{
  BOOL _shouldBlockPanGesture;
}

@property (nonatomic, copy) bool (^shouldCopy)();
@property (nonatomic, copy) bool (^shouldPaste)();
@property (nonatomic, copy) ASEditableTextNodeTargetForAction *(^targetForActionImpl)(SEL);
@property (nonatomic, copy) bool (^shouldReturn)();
@property (nonatomic, copy) void (^backspaceWhileEmpty)();

@property (nonatomic, strong) NSString * _Nullable initialPrimaryLanguage;
@property (nonatomic) bool initializedPrimaryInputLanguage;

@end

@implementation ASPanningOverriddenUITextView

#if TARGET_OS_IOS
 // tvOS doesn't support self.scrollsToTop
- (BOOL)scrollEnabled
{
  return _shouldBlockPanGesture;
}

- (void)setScrollEnabled:(BOOL)scrollEnabled
{
  _shouldBlockPanGesture = !scrollEnabled;
  self.scrollsToTop = scrollEnabled;

  [super setScrollEnabled:YES];
}

- (void)setContentSize:(CGSize)contentSize {
    if (_shouldBlockPanGesture) {
        return;
    }
    [super setContentSize:contentSize];
}

- (void)setContentOffset:(CGPoint)contentOffset {
    if (_shouldBlockPanGesture) {
        return;
    }
    [super setContentOffset:contentOffset];
}

- (void)setContentOffset:(CGPoint)contentOffset animated:(BOOL)animated {
    if (_shouldBlockPanGesture) {
        return;
    }
    [super setContentOffset:contentOffset animated:animated];
}

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

- (BOOL)canPerformAction:(SEL)action withSender:(id)sender
{
  if (_targetForActionImpl) {
    ASEditableTextNodeTargetForAction *result = _targetForActionImpl(action);
    if (result) {
      return result.target != nil;
    }
  }
  
  if (action == @selector(paste:)) {
    NSArray *items = [UIMenuController sharedMenuController].menuItems;
    if (((UIMenuItem *)items.firstObject).action == @selector(toggleBoldface:)) {
      return false;
    }
    return true;
  }
  
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wundeclared-selector"
  static SEL promptForReplaceSelector;
  static dispatch_once_t onceToken;
  dispatch_once(&onceToken, ^{
    promptForReplaceSelector = NSSelectorFromString(@"_promptForReplace:");
  });
  if (action == promptForReplaceSelector) {
    return false;
  }
#pragma clang diagnostic pop
  
  if (action == @selector(toggleUnderline:)) {
    return false;
  }
  
  return [super canPerformAction:action withSender:sender];
}

- (id)targetForAction:(SEL)action withSender:(id)__unused sender
{
  if (_targetForActionImpl) {
    ASEditableTextNodeTargetForAction *result = _targetForActionImpl(action);
    if (result) {
      return result.target;
    }
  }
  return [super targetForAction:action withSender:sender];
}
  
- (void)copy:(id)sender {
  if (_shouldCopy == nil || _shouldCopy()) {
    [super copy:sender];
  }
}

- (void)paste:(id)sender
{
  if (_shouldPaste == nil || _shouldPaste()) {
    [super paste:sender];
  }
}

- (NSArray *)keyCommands {
  UIKeyCommand *plainReturn = [UIKeyCommand keyCommandWithInput:@"\r" modifierFlags:kNilOptions action:@selector(handlePlainReturn:)];
  return @[
    plainReturn
  ];
}

- (void)handlePlainReturn:(id)__unused sender {
  if (_shouldReturn) {
    _shouldReturn();
  }
}

- (void)deleteBackward {
  bool notify = self.text.length == 0;
  [super deleteBackward];
  if (notify) {
    if (_backspaceWhileEmpty) {
      _backspaceWhileEmpty();
    }
  }
}

- (UIKeyboardAppearance)keyboardAppearance {
  return [super keyboardAppearance];
}

- (UITextInputMode *)textInputMode {
  if (!_initializedPrimaryInputLanguage) {
    _initializedPrimaryInputLanguage = true;
      if (_initialPrimaryLanguage != nil) {
      for (UITextInputMode *inputMode in [UITextInputMode activeInputModes]) {
        NSString *primaryLanguage = inputMode.primaryLanguage;
        if (primaryLanguage != nil && [primaryLanguage isEqualToString:_initialPrimaryLanguage]) {
          return inputMode;
        }
      }
    }
  }
  return [super textInputMode];
}

- (void)scrollRectToVisible:(CGRect)rect animated:(BOOL)animated {
    [super scrollRectToVisible:rect animated:false];
}

#endif

- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gestureRecognizer
{
  // Never allow our pans to begin when _shouldBlockPanGesture is true.
  if (_shouldBlockPanGesture && gestureRecognizer == self.panGestureRecognizer)
    return NO;

  // Otherwise, proceed as usual.
  if ([UITextView instancesRespondToSelector:_cmd])
    return [super gestureRecognizerShouldBegin:gestureRecognizer];
  return YES;
}

@end

#pragma mark -
@interface ASEditableTextNode () <UITextViewDelegate, NSLayoutManagerDelegate, UIGestureRecognizerDelegate>
{
  @private
  // Configuration.
  NSDictionary *_typingAttributes;

  // Core.
  id <ASEditableTextNodeDelegate> __weak _delegate;
  BOOL _delegateDidUpdateEnqueued;

  // TextKit.
  AS::RecursiveMutex _textKitLock;
  ASTextKitComponents *_textKitComponents;
  ASTextKitComponents *_placeholderTextKitComponents;
  // Forwards NSLayoutManagerDelegate methods related to word kerning
  ASTextNodeWordKerner *_wordKerner;
  
  // UITextInputTraits
  AS::RecursiveMutex _textInputTraitsLock;
  _ASTextInputTraitsPendingState *_textInputTraits;

  // Misc. State.
  BOOL _displayingPlaceholder; // Defaults to YES.
  BOOL _isPreservingSelection;
  BOOL _isPreservingText;
  BOOL _selectionChangedForEditedText;
  NSRange _previousSelectedRange;
}

@property (nonatomic, readonly) _ASTextInputTraitsPendingState *textInputTraits;

@end

@implementation ASEditableTextNode

#pragma mark - NSObject Overrides
- (instancetype)init
{
  return [self initWithTextKitComponents:[ASTextKitComponents componentsWithAttributedSeedString:nil textContainerSize:CGSizeZero]
            placeholderTextKitComponents:[ASTextKitComponents componentsWithAttributedSeedString:nil textContainerSize:CGSizeZero]];
}

- (instancetype)initWithTextKitComponents:(ASTextKitComponents *)textKitComponents
             placeholderTextKitComponents:(ASTextKitComponents *)placeholderTextKitComponents
{
  if (!(self = [super init]))
    return nil;

  _displayingPlaceholder = YES;
  _scrollEnabled = YES;

  // Create the scaffolding for the text view.
  _textKitComponents = textKitComponents;
  _textKitComponents.layoutManager.delegate = self;
  _wordKerner = [[ASTextNodeWordKerner alloc] init];
  _textContainerInset = UIEdgeInsetsZero;
  
  // Create the placeholder scaffolding.
  _placeholderTextKitComponents = placeholderTextKitComponents;
  _placeholderTextKitComponents.layoutManager.delegate = self;
  
  return self;
}

#pragma mark - ASDisplayNode Overrides
- (void)didLoad
{
  [super didLoad];

  void (^configureTextView)(UITextView *) = ^(UITextView *textView) {
    if (!_displayingPlaceholder || textView != _textKitComponents.textView) {
      // If showing the placeholder, don't propagate backgroundColor/opaque to the editable textView.  It is positioned over the placeholder to accept taps to begin editing, and if it's opaque/colored then it'll obscure the placeholder.
      textView.backgroundColor = self.backgroundColor;
      textView.opaque = self.opaque;
    } else if (_displayingPlaceholder && textView == _textKitComponents.textView) {
      // The default backgroundColor for a textView is white.  Due to the reason described above, make sure the editable textView starts out transparent.
      textView.backgroundColor = nil;
      textView.opaque = NO;
    }
    textView.textContainerInset = self.textContainerInset;
    
    // Configure textView with UITextInputTraits
    {
      AS::MutexLocker l(_textInputTraitsLock);
      if (_textInputTraits) {
        textView.autocapitalizationType         = _textInputTraits.autocapitalizationType;
        textView.autocorrectionType             = _textInputTraits.autocorrectionType;
        textView.spellCheckingType              = _textInputTraits.spellCheckingType;
        textView.keyboardType                   = _textInputTraits.keyboardType;
        textView.keyboardAppearance             = _textInputTraits.keyboardAppearance;
        textView.returnKeyType                  = _textInputTraits.returnKeyType;
        textView.enablesReturnKeyAutomatically  = _textInputTraits.enablesReturnKeyAutomatically;
        textView.secureTextEntry                = _textInputTraits.isSecureTextEntry;
      }
    }
    
    [self.view addSubview:textView];
  };

  AS::MutexLocker l(_textKitLock);

  // Create and configure the placeholder text view.
  _placeholderTextKitComponents.textView = [[ASTextKitComponentsTextView alloc] initWithFrame:CGRectZero textContainer:_placeholderTextKitComponents.textContainer];
  _placeholderTextKitComponents.textView.userInteractionEnabled = NO;
  _placeholderTextKitComponents.textView.accessibilityElementsHidden = YES;
  configureTextView(_placeholderTextKitComponents.textView);

  // Create and configure our text view.
  ASPanningOverriddenUITextView *textView = [[ASPanningOverriddenUITextView alloc] initWithFrame:CGRectZero textContainer:_textKitComponents.textContainer];
  textView.initialPrimaryLanguage = _initialPrimaryLanguage;
  __weak ASEditableTextNode *weakSelf = self;
  textView.shouldCopy = ^bool{
    __strong ASEditableTextNode *strongSelf = weakSelf;
    if (strongSelf != nil) {
      if ([strongSelf->_delegate respondsToSelector:@selector(editableTextNodeShouldCopy:)]) {
        return [strongSelf->_delegate editableTextNodeShouldCopy:strongSelf];
      }
    }
    return true;
  };
  textView.shouldPaste = ^bool{
    __strong ASEditableTextNode *strongSelf = weakSelf;
    if (strongSelf != nil) {
      if ([strongSelf->_delegate respondsToSelector:@selector(editableTextNodeShouldPaste:)]) {
        return [strongSelf->_delegate editableTextNodeShouldPaste:strongSelf];
      }
    }
    return true;
  };
  textView.targetForActionImpl = ^id(SEL action) {
    __strong ASEditableTextNode *strongSelf = weakSelf;
    if (strongSelf != nil) {
      if ([strongSelf->_delegate respondsToSelector:@selector(editableTextNodeTargetForAction:)]) {
        return [strongSelf->_delegate editableTextNodeTargetForAction:action];
      }
    }
    return nil;
  };
  textView.shouldReturn = ^bool {
    __strong ASEditableTextNode *strongSelf = weakSelf;
    if (strongSelf != nil) {
      if ([strongSelf->_delegate respondsToSelector:@selector(editableTextNodeShouldReturn:)]) {
        return [strongSelf->_delegate editableTextNodeShouldReturn:strongSelf];
      }
    }
    return true;
  };
  textView.backspaceWhileEmpty = ^{
    __strong ASEditableTextNode *strongSelf = weakSelf;
    if (strongSelf != nil) {
      if ([strongSelf->_delegate respondsToSelector:@selector(editableTextNodeBackspaceWhileEmpty:)]) {
        [strongSelf->_delegate editableTextNodeBackspaceWhileEmpty:strongSelf];
      }
    }
  };
  _textKitComponents.textView = textView;
  _textKitComponents.textView.scrollEnabled = _scrollEnabled;
  _textKitComponents.textView.delegate = self;
  #if TARGET_OS_IOS
  _textKitComponents.textView.editable = YES;
  #endif
  _textKitComponents.textView.typingAttributes = _typingAttributes;
  _textKitComponents.textView.accessibilityHint = _placeholderTextKitComponents.textStorage.string;
  configureTextView(_textKitComponents.textView);

  [self _updateDisplayingPlaceholder];
    
  // once view is loaded, setters set directly on view
  _textInputTraits = nil;
  
  UITapGestureRecognizer *tapRecognizer = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(tapGesture:)];
  tapRecognizer.cancelsTouchesInView = false;
  tapRecognizer.delaysTouchesBegan = false;
  tapRecognizer.delaysTouchesEnded = false;
  tapRecognizer.delegate = self;
  [self.view addGestureRecognizer:tapRecognizer];
}

- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer {
  return true;
}

- (void)tapGesture:(UITapGestureRecognizer *)recognizer {
  static Class promptClass = nil;
  static dispatch_once_t onceToken;
  dispatch_once(&onceToken, ^{
    promptClass = NSClassFromString([[NSString alloc] initWithFormat:@"%@AutocorrectInlinePrompt", @"UI"]);
  });
  
  if (recognizer.state == UIGestureRecognizerStateEnded) {
    UIView *result = [self hitTest:[recognizer locationInView:self.view] withEvent:nil];
    if (result != nil && [result class] == promptClass) {
      [self dropAutocorrection];
    }
  }
}

- (CGSize)calculateSizeThatFits:(CGSize)constrainedSize
{
  ASTextKitComponents *displayedComponents = [self isDisplayingPlaceholder] ? _placeholderTextKitComponents : _textKitComponents;
  
  CGSize textSize;
  
  if (_maximumLinesToDisplay > 0) {
    textSize = [displayedComponents sizeForConstrainedWidth:constrainedSize.width
                                        forMaxNumberOfLines: _maximumLinesToDisplay];
  } else {
    textSize = [displayedComponents sizeForConstrainedWidth:constrainedSize.width];
  }
  
  CGFloat width = std::ceil(constrainedSize.width);
  CGFloat height = std::ceil(textSize.height + _textContainerInset.top + _textContainerInset.bottom);
  return CGSizeMake(std::fmin(width, constrainedSize.width), std::fmin(height, constrainedSize.height));
}

- (void)layout
{
  ASDisplayNodeAssertMainThread();

  [super layout];
  [self _layoutTextView];
}

- (void)setBackgroundColor:(UIColor *)backgroundColor
{
  [super setBackgroundColor:backgroundColor];

  AS::MutexLocker l(_textKitLock);

  // If showing the placeholder, don't propagate backgroundColor/opaque to the editable textView.  It is positioned over the placeholder to accept taps to begin editing, and if it's opaque/colored then it'll obscure the placeholder.
  // The backgroundColor/opaque will be propagated to the editable textView when editing begins.
  if (!_displayingPlaceholder) {
    _textKitComponents.textView.backgroundColor = backgroundColor;
  }
  _placeholderTextKitComponents.textView.backgroundColor = backgroundColor;
}

- (void)setTextContainerInset:(UIEdgeInsets)textContainerInset
{
  AS::MutexLocker l(_textKitLock);

  _textContainerInset = textContainerInset;
  _textKitComponents.textView.textContainerInset = textContainerInset;
  _placeholderTextKitComponents.textView.textContainerInset = textContainerInset;
}

- (void)setOpaque:(BOOL)opaque
{
  [super setOpaque:opaque];

  AS::MutexLocker l(_textKitLock);

  // If showing the placeholder, don't propagate backgroundColor/opaque to the editable textView.  It is positioned over the placeholder to accept taps to begin editing, and if it's opaque/colored then it'll obscure the placeholder.
  // The backgroundColor/opaque will be propagated to the editable textView when editing begins.
  if (!_displayingPlaceholder) {
    _textKitComponents.textView.opaque = opaque;
  }
  _placeholderTextKitComponents.textView.opaque = opaque;
}

- (void)setLayerBacked:(BOOL)layerBacked
{
  ASDisplayNodeAssert(!layerBacked, @"Cannot set layerBacked to YES on ASEditableTextNode – instances must be view-backed in order to ensure touch events can be passed to the internal UITextView during editing.");
  [super setLayerBacked:layerBacked];
}

- (BOOL)supportsLayerBacking
{
  return NO;
}

#pragma mark - Configuration
@synthesize delegate = _delegate;

- (void)setScrollEnabled:(BOOL)scrollEnabled
{
  AS::MutexLocker l(_textKitLock);
  _scrollEnabled = scrollEnabled;
  [_textKitComponents.textView setScrollEnabled:_scrollEnabled];
}

- (UITextView *)textView
{
  ASDisplayNodeAssertMainThread();
  [self view];
  ASDisplayNodeAssert(_textKitComponents.textView != nil, @"UITextView must be created in -[ASEditableTextNode didLoad]");
  return _textKitComponents.textView;
}

- (void)setMaximumLinesToDisplay:(NSUInteger)maximumLines
{
  _maximumLinesToDisplay = maximumLines;
  [self setNeedsLayout];
}

#pragma mark -
@dynamic typingAttributes;

- (NSDictionary *)typingAttributes
{
  return _typingAttributes;
}

- (void)setTypingAttributes:(NSDictionary *)typingAttributes
{
  if (ASObjectIsEqual(typingAttributes, _typingAttributes))
    return;

  _typingAttributes = [typingAttributes copy];

  AS::MutexLocker l(_textKitLock);

  _textKitComponents.textView.typingAttributes = _typingAttributes;
}

#pragma mark -
@dynamic selectedRange;

- (NSRange)selectedRange
{
  AS::MutexLocker l(_textKitLock);
  return _textKitComponents.textView.selectedRange;
}

- (void)setSelectedRange:(NSRange)selectedRange
{
  AS::MutexLocker l(_textKitLock);
  _textKitComponents.textView.selectedRange = selectedRange;
}

- (CGRect)selectionRect {
    UITextRange *range = [_textKitComponents.textView selectedTextRange];
    if (range != nil) {
        return [_textKitComponents.textView firstRectForRange:range];
    } else {
        return [_textKitComponents.textView bounds];
    }
}

#pragma mark - Placeholder
- (BOOL)isDisplayingPlaceholder
{
  return _displayingPlaceholder;
}

#pragma mark -
@dynamic attributedPlaceholderText;
- (NSAttributedString *)attributedPlaceholderText
{
  AS::MutexLocker l(_textKitLock);

  return [_placeholderTextKitComponents.textStorage copy];
}

- (void)setAttributedPlaceholderText:(NSAttributedString *)attributedPlaceholderText
{
  AS::MutexLocker l(_textKitLock);

  if (ASObjectIsEqual(_placeholderTextKitComponents.textStorage, attributedPlaceholderText))
    return;

  [_placeholderTextKitComponents.textStorage setAttributedString:attributedPlaceholderText ? : [[NSAttributedString alloc] initWithString:@""]];
  _textKitComponents.textView.accessibilityHint = attributedPlaceholderText.string;
}

#pragma mark - Modifying User Text
@dynamic attributedText;
- (NSAttributedString *)attributedText
{
  // Per contract in our header, this value is nil when the placeholder is displayed.
  if ([self isDisplayingPlaceholder])
    return nil;

  AS::MutexLocker l(_textKitLock);

  return [_textKitComponents.textStorage copy];
}

- (void)setAttributedText:(NSAttributedString *)attributedText
{
  AS::MutexLocker l(_textKitLock);

  // If we (_cmd) are called while the text view itself is updating (-textViewDidUpdate:), you cannot update the text storage and expect perfect propagation to the text view.
  // Thus, we always update the textview directly if it's been created already.
  if (ASObjectIsEqual((_textKitComponents.textView.attributedText ? : _textKitComponents.textStorage), attributedText))
    return;

  // If the cursor isn't at the end of the text, we need to preserve the selected range to avoid moving the cursor.
  NSRange selectedRange = _textKitComponents.textView.selectedRange;
  BOOL preserveSelectedRange = (selectedRange.location != _textKitComponents.textStorage.length);

  NSAttributedString *attributedStringToDisplay = nil;

  if (attributedText)
    attributedStringToDisplay = attributedText;
  // Otherwise, note that we don't simply nil out attributed text. Because the insertion point is guided by the attributes at index 0, we need to attribute an empty string to ensure the insert point obeys our typing attributes.
  else
    attributedStringToDisplay = [[NSAttributedString alloc] initWithString:@"" attributes:self.typingAttributes];

  // Always prefer updating the text view directly if it's been created (see above).
  if (_textKitComponents.textView)
    [_textKitComponents.textView setAttributedText:attributedStringToDisplay];
  else
    [_textKitComponents.textStorage setAttributedString:attributedStringToDisplay];

  // Calculated size depends on the seeded text.
  [self setNeedsLayout];

  // Update if placeholder is shown.
  [self _updateDisplayingPlaceholder];

  // Preserve cursor range, if necessary.
  if (preserveSelectedRange) {
    _isPreservingSelection = YES; // Used in -textViewDidChangeSelection: to avoid informing our delegate about our preservation.
    [_textKitComponents.textView setSelectedRange:selectedRange];
    _isPreservingSelection = NO;
  }
}

- (void)setInitialPrimaryLanguage:(NSString *)initialPrimaryLanguage {
  _initialPrimaryLanguage = initialPrimaryLanguage;
  ((ASPanningOverriddenUITextView *)_textKitComponents.textView).initialPrimaryLanguage = initialPrimaryLanguage;
}

- (void)resetInitialPrimaryLanguage {
  ((ASPanningOverriddenUITextView *)_textKitComponents.textView).initializedPrimaryInputLanguage = false;
}

- (void)dropAutocorrection {
  _isPreservingSelection = YES; // Used in -textViewDidChangeSelection: to avoid informing our delegate about our preservation.
  _isPreservingText = YES;
  
  UITextView *textView = _textKitComponents.textView;
  
  NSRange rangeCopy = textView.selectedRange;
  NSRange fakeRange = rangeCopy;
  if (fakeRange.location != 0) {
    fakeRange.location--;
  }
  [textView unmarkText];
  [textView setSelectedRange:fakeRange];
  [textView setSelectedRange:rangeCopy];
  
  //[_textKitComponents.textView.inputDelegate textWillChange:_textKitComponents.textView];
  //[_textKitComponents.textView.inputDelegate textDidChange:_textKitComponents.textView];
  
  _isPreservingSelection = NO;
  _isPreservingText = NO;
}

- (bool)isCurrentlyEmoji {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
  NSString *value = [[UITextInputMode currentInputMode] primaryLanguage];
#pragma clang diagnostic pop
  if ([value isEqualToString:@"emoji"]) {
    return true;
  } else {
    return false;
  }
}

#pragma mark - Core
- (void)_updateDisplayingPlaceholder
{
  AS::MutexLocker l(_textKitLock);

  // Show the placeholder if necessary.
  _displayingPlaceholder = (_textKitComponents.textStorage.length == 0);
  _placeholderTextKitComponents.textView.hidden = !_displayingPlaceholder;

  // If hiding the placeholder, propagate backgroundColor/opaque to the editable textView.  It is positioned over the placeholder to accept taps to begin editing, and was kept transparent so it doesn't obscure the placeholder text.  Now that we're editing it and the placeholder is hidden, we can make it opaque to avoid unnecessary blending.
  if (!_displayingPlaceholder) {
    _textKitComponents.textView.opaque = self.isOpaque;
    _textKitComponents.textView.backgroundColor = self.backgroundColor;
  } else {
    _textKitComponents.textView.opaque = NO;
    _textKitComponents.textView.backgroundColor = nil;
  }
}

- (void)_layoutTextView
{
  AS::MutexLocker l(_textKitLock);

  // Layout filling our bounds.
  _textKitComponents.textView.frame = self.bounds;
  _placeholderTextKitComponents.textView.frame = self.bounds;

  // Note that both of these won't be necessary once we can disable scrolling, pending rdar://14729288
  // When we resize to fit (above) the prior layout becomes invalid. For whatever reason, UITextView doesn't invalidate its layout when its frame changes on its own, so we have to do so ourselves.
  [_textKitComponents.layoutManager invalidateLayoutForCharacterRange:NSMakeRange(0, [_textKitComponents.textStorage length]) actualCharacterRange:NULL];

  // When you type beyond UITextView's bounds it scrolls you down a line. We need to remain at the top.
  [_textKitComponents.textView setContentOffset:CGPointZero animated:NO];
  [_textKitComponents.layoutManager ensureGlyphsForCharacterRange:NSMakeRange(0, [_textKitComponents.textStorage length])];
  NSRange range = [self selectedRange];
  range.location = range.location + range.length - 1;
  range.length = 1;
    
  UITextPosition *caretPosition = [self.textView positionFromPosition:self.textView.beginningOfDocument offset:range.location];
  if (caretPosition) {
    CGRect caretRect = [self.textView caretRectForPosition:caretPosition];
    caretRect.origin.y -= self.textView.contentInset.top;
    caretRect.size.height += self.textView.contentInset.top + self.textView.contentInset.bottom + 4.0f;
    [self.textView scrollRectToVisible:caretRect animated:false];
  }
    
  //[self.textView scrollRangeToVisible:range];
}

#pragma mark - Keyboard
@dynamic textInputMode;
- (UITextInputMode *)textInputMode
{
  AS::MutexLocker l(_textKitLock);
  return [_textKitComponents.textView textInputMode];
}

- (BOOL)isFirstResponder
{
  AS::MutexLocker l(_textKitLock);
  return [_textKitComponents.textView isFirstResponder];
}

- (BOOL)canBecomeFirstResponder {
    AS::MutexLocker l(_textKitLock);
    return [_textKitComponents.textView canBecomeFirstResponder];
}

- (BOOL)becomeFirstResponder
{
  AS::MutexLocker l(_textKitLock);
  return [_textKitComponents.textView becomeFirstResponder];
}

- (BOOL)canResignFirstResponder {
    AS::MutexLocker l(_textKitLock);
    return [_textKitComponents.textView canResignFirstResponder];
}

- (BOOL)resignFirstResponder
{
  AS::MutexLocker l(_textKitLock);
  return [_textKitComponents.textView resignFirstResponder];
}

#pragma mark - UITextInputTraits

- (_ASTextInputTraitsPendingState *)textInputTraits
{
  if (!_textInputTraits) {
    _textInputTraits = [[_ASTextInputTraitsPendingState alloc] init];
  }
  return _textInputTraits;
}

- (void)setAutocapitalizationType:(UITextAutocapitalizationType)autocapitalizationType
{
  AS::MutexLocker l(_textInputTraitsLock);
  if (self.isNodeLoaded) {
    [self.textView setAutocapitalizationType:autocapitalizationType];
  } else {
    [self.textInputTraits setAutocapitalizationType:autocapitalizationType];
  }
}

- (UITextAutocapitalizationType)autocapitalizationType
{
  AS::MutexLocker l(_textInputTraitsLock);
  if (self.isNodeLoaded) {
    return [self.textView autocapitalizationType];
  } else {
    return [self.textInputTraits autocapitalizationType];
  }
}

- (void)setAutocorrectionType:(UITextAutocorrectionType)autocorrectionType
{
  AS::MutexLocker l(_textInputTraitsLock);
  if (self.isNodeLoaded) {
    [self.textView setAutocorrectionType:autocorrectionType];
  } else {
    [self.textInputTraits setAutocorrectionType:autocorrectionType];
  }
}

- (UITextAutocorrectionType)autocorrectionType
{
  AS::MutexLocker l(_textInputTraitsLock);
  if (self.isNodeLoaded) {
    return [self.textView autocorrectionType];
  } else {
    return [self.textInputTraits autocorrectionType];
  }
}

- (void)setSpellCheckingType:(UITextSpellCheckingType)spellCheckingType
{
  AS::MutexLocker l(_textInputTraitsLock);
  if (self.isNodeLoaded) {
    [self.textView setSpellCheckingType:spellCheckingType];
  } else {
    [self.textInputTraits setSpellCheckingType:spellCheckingType];
  }
}

- (UITextSpellCheckingType)spellCheckingType
{
  AS::MutexLocker l(_textInputTraitsLock);
  if (self.isNodeLoaded) {
    return [self.textView spellCheckingType];
  } else {
    return [self.textInputTraits spellCheckingType];
  }
}

- (void)setEnablesReturnKeyAutomatically:(BOOL)enablesReturnKeyAutomatically
{
  AS::MutexLocker l(_textInputTraitsLock);
  if (self.isNodeLoaded) {
    [self.textView setEnablesReturnKeyAutomatically:enablesReturnKeyAutomatically];
  } else {
    [self.textInputTraits setEnablesReturnKeyAutomatically:enablesReturnKeyAutomatically];
  }
}

- (BOOL)enablesReturnKeyAutomatically
{
  AS::MutexLocker l(_textInputTraitsLock);
  if (self.isNodeLoaded) {
    return [self.textView enablesReturnKeyAutomatically];
  } else {
    return [self.textInputTraits enablesReturnKeyAutomatically];
  }
}

- (void)setKeyboardAppearance:(UIKeyboardAppearance)setKeyboardAppearance
{
  AS::MutexLocker l(_textInputTraitsLock);
  if (self.isNodeLoaded) {
    [self.textView setKeyboardAppearance:setKeyboardAppearance];
  } else {
    [self.textInputTraits setKeyboardAppearance:setKeyboardAppearance];
  }
}

- (UIKeyboardAppearance)keyboardAppearance
{
  AS::MutexLocker l(_textInputTraitsLock);
  if (self.isNodeLoaded) {
    return [self.textView keyboardAppearance];
  } else {
    return [self.textInputTraits keyboardAppearance];
  }
}

- (void)setKeyboardType:(UIKeyboardType)keyboardType
{
  AS::MutexLocker l(_textInputTraitsLock);
  if (self.isNodeLoaded) {
    [self.textView setKeyboardType:keyboardType];
  } else {
    [self.textInputTraits setKeyboardType:keyboardType];
  }
}

- (UIKeyboardType)keyboardType
{
  AS::MutexLocker l(_textInputTraitsLock);
  if (self.isNodeLoaded) {
    return [self.textView keyboardType];
  } else {
    return [self.textInputTraits keyboardType];
  }
}

- (void)setReturnKeyType:(UIReturnKeyType)returnKeyType
{
  AS::MutexLocker l(_textInputTraitsLock);
  if (self.isNodeLoaded) {
    [self.textView setReturnKeyType:returnKeyType];
  } else {
    [self.textInputTraits setReturnKeyType:returnKeyType];
  }
}

- (UIReturnKeyType)returnKeyType
{
  AS::MutexLocker l(_textInputTraitsLock);
  if (self.isNodeLoaded) {
    return [self.textView returnKeyType];
  } else {
    return [self.textInputTraits returnKeyType];
  }
}

- (void)setSecureTextEntry:(BOOL)secureTextEntry
{
  AS::MutexLocker l(_textInputTraitsLock);
  if (self.isNodeLoaded) {
    [self.textView setSecureTextEntry:secureTextEntry];
  } else {
    [self.textInputTraits setSecureTextEntry:secureTextEntry];
  }
}

- (BOOL)isSecureTextEntry
{
  AS::MutexLocker l(_textInputTraitsLock);
  if (self.isNodeLoaded) {
    return [self.textView isSecureTextEntry];
  } else {
    return [self.textInputTraits isSecureTextEntry];
  }
}

#pragma mark - UITextView Delegate
- (BOOL)textViewShouldBeginEditing:(UITextView *)textView
{
  // Delegateify.
  return [self _delegateShouldBeginEditing];
}

- (void)textViewDidBeginEditing:(UITextView *)textView
{
  // Delegateify.
  [self _delegateDidBeginEditing];
}

- (BOOL)textView:(UITextView *)textView shouldChangeTextInRange:(NSRange)range replacementText:(NSString *)text
{
  if (_isPreservingText) {
    return false;
  }
  // Delegateify.
  return [self _delegateShouldChangeTextInRange:range replacementText:text];