usergrid-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From snoopd...@apache.org
Subject [47/89] [partial] usergrid git commit: Initial commit of the Swift SDK.
Date Thu, 18 Feb 2016 15:52:55 GMT
http://git-wip-us.apache.org/repos/asf/usergrid/blob/7442c881/sdks/swift/Samples/ActivityFeed/Pods/SlackTextViewController/Source/SLKTextViewController.m
----------------------------------------------------------------------
diff --git a/sdks/swift/Samples/ActivityFeed/Pods/SlackTextViewController/Source/SLKTextViewController.m b/sdks/swift/Samples/ActivityFeed/Pods/SlackTextViewController/Source/SLKTextViewController.m
new file mode 100644
index 0000000..5febfcb
--- /dev/null
+++ b/sdks/swift/Samples/ActivityFeed/Pods/SlackTextViewController/Source/SLKTextViewController.m
@@ -0,0 +1,2392 @@
+//
+//   Copyright 2014 Slack Technologies, Inc.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+//
+
+#import "SLKTextViewController.h"
+#import "SLKInputAccessoryView.h"
+
+#import "UIResponder+SLKAdditions.h"
+
+/** Feature flagged while waiting to implement a more reliable technique. */
+#define SLKBottomPanningEnabled 0
+
+#define kSLKAlertViewClearTextTag [NSStringFromClass([SLKTextViewController class]) hash]
+
+NSString * const SLKKeyboardWillShowNotification =      @"SLKKeyboardWillShowNotification";
+NSString * const SLKKeyboardDidShowNotification =       @"SLKKeyboardDidShowNotification";
+NSString * const SLKKeyboardWillHideNotification =      @"SLKKeyboardWillHideNotification";
+NSString * const SLKKeyboardDidHideNotification =       @"SLKKeyboardDidHideNotification";
+
+CGFloat const SLKAutoCompletionViewDefaultHeight = 140.0;
+
+@interface SLKTextViewController ()
+{
+    CGPoint _scrollViewOffsetBeforeDragging;
+    CGFloat _keyboardHeightBeforeDragging;
+}
+
+// The shared scrollView pointer, either a tableView or collectionView
+@property (nonatomic, weak) UIScrollView *scrollViewProxy;
+
+// A hairline displayed on top of the auto-completion view, to better separate the content from the control.
+@property (nonatomic, strong) UIView *autoCompletionHairline;
+
+// Auto-Layout height constraints used for updating their constants
+@property (nonatomic, strong) NSLayoutConstraint *scrollViewHC;
+@property (nonatomic, strong) NSLayoutConstraint *textInputbarHC;
+@property (nonatomic, strong) NSLayoutConstraint *typingIndicatorViewHC;
+@property (nonatomic, strong) NSLayoutConstraint *autoCompletionViewHC;
+@property (nonatomic, strong) NSLayoutConstraint *keyboardHC;
+
+// YES if the user is moving the keyboard with a gesture
+@property (nonatomic, assign, getter = isMovingKeyboard) BOOL movingKeyboard;
+
+// The current keyboard status (hidden, showing, etc.)
+@property (nonatomic) SLKKeyboardStatus keyboardStatus;
+
+// YES if the view controller did appear and everything is finished configurating. This allows blocking some layout animations among other things.
+@property (nonatomic, getter=isViewVisible) BOOL viewVisible;
+
+// YES if the view controller's view's size is changing by its parent (i.e. when its window rotates or is resized)
+@property (nonatomic, getter = isTransitioning) BOOL transitioning;
+
+// Optional classes to be used instead of the default ones.
+@property (nonatomic, strong) Class textViewClass;
+@property (nonatomic, strong) Class typingIndicatorViewClass;
+
+@end
+
+@implementation SLKTextViewController
+@synthesize tableView = _tableView;
+@synthesize collectionView = _collectionView;
+@synthesize scrollView = _scrollView;
+@synthesize typingIndicatorProxyView = _typingIndicatorProxyView;
+@synthesize textInputbar = _textInputbar;
+@synthesize autoCompletionView = _autoCompletionView;
+@synthesize autoCompleting = _autoCompleting;
+@synthesize scrollViewProxy = _scrollViewProxy;
+@synthesize presentedInPopover = _presentedInPopover;
+
+#pragma mark - Initializer
+
+- (instancetype)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil
+{
+    return [self initWithTableViewStyle:UITableViewStylePlain];
+}
+
+- (instancetype)init
+{
+    return [self initWithTableViewStyle:UITableViewStylePlain];
+}
+
+- (instancetype)initWithTableViewStyle:(UITableViewStyle)style
+{
+    NSAssert([self class] != [SLKTextViewController class], @"Oops! You must subclass SLKTextViewController.");
+    
+    if (self = [super initWithNibName:nil bundle:nil])
+    {
+        self.scrollViewProxy = [self tableViewWithStyle:style];
+        [self slk_commonInit];
+    }
+    return self;
+}
+
+- (instancetype)initWithCollectionViewLayout:(UICollectionViewLayout *)layout
+{
+    NSAssert([self class] != [SLKTextViewController class], @"Oops! You must subclass SLKTextViewController.");
+    
+    if (self = [super initWithNibName:nil bundle:nil])
+    {
+        self.scrollViewProxy = [self collectionViewWithLayout:layout];
+        [self slk_commonInit];
+    }
+    return self;
+}
+
+- (instancetype)initWithScrollView:(UIScrollView *)scrollView
+{
+    NSAssert([self class] != [SLKTextViewController class], @"Oops! You must subclass SLKTextViewController.");
+    
+    if (self = [super initWithNibName:nil bundle:nil])
+    {
+        _scrollView = scrollView;
+        _scrollView.translatesAutoresizingMaskIntoConstraints = NO; // Makes sure the scrollView plays nice with auto-layout
+        
+        self.scrollViewProxy = _scrollView;
+        [self slk_commonInit];
+    }
+    return self;
+}
+
+- (instancetype)initWithCoder:(NSCoder *)decoder
+{
+    NSAssert([self class] != [SLKTextViewController class], @"Oops! You must subclass SLKTextViewController.");
+    
+    if (self = [super initWithCoder:decoder])
+    {
+        UITableViewStyle tableViewStyle = [[self class] tableViewStyleForCoder:decoder];
+        UICollectionViewLayout *collectionViewLayout = [[self class] collectionViewLayoutForCoder:decoder];
+        
+        if ([collectionViewLayout isKindOfClass:[UICollectionViewLayout class]]) {
+            self.scrollViewProxy = [self collectionViewWithLayout:collectionViewLayout];
+        }
+        else {
+            self.scrollViewProxy = [self tableViewWithStyle:tableViewStyle];
+        }
+        
+        [self slk_commonInit];
+    }
+    return self;
+}
+
+- (void)slk_commonInit
+{
+    [self slk_registerNotifications];
+    
+    self.bounces = YES;
+    self.inverted = YES;
+    self.shakeToClearEnabled = NO;
+    self.keyboardPanningEnabled = YES;
+    self.shouldClearTextAtRightButtonPress = YES;
+    self.shouldScrollToBottomAfterKeyboardShows = NO;
+    
+    self.automaticallyAdjustsScrollViewInsets = YES;
+    self.extendedLayoutIncludesOpaqueBars = YES;
+}
+
+
+#pragma mark - View lifecycle
+
+- (void)loadView
+{
+    [super loadView];
+}
+
+- (void)viewDidLoad
+{
+    [super viewDidLoad];
+    
+    [self.view addSubview:self.scrollViewProxy];
+    [self.view addSubview:self.autoCompletionView];
+    [self.view addSubview:self.typingIndicatorProxyView];
+    [self.view addSubview:self.textInputbar];
+    
+    [self slk_setupViewConstraints];
+}
+
+- (void)viewWillAppear:(BOOL)animated
+{
+    [super viewWillAppear:animated];
+    
+    // Invalidates this flag when the view appears
+    self.textView.didNotResignFirstResponder = NO;
+    
+    // Forces laying out the recently added subviews and update their constraints
+    [self.view layoutIfNeeded];
+    
+    [UIView performWithoutAnimation:^{
+        // Reloads any cached text
+        [self slk_reloadTextView];
+    }];
+}
+
+- (void)viewDidAppear:(BOOL)animated
+{
+    [super viewDidAppear:animated];
+    
+    [self.scrollViewProxy flashScrollIndicators];
+    
+    self.viewVisible = YES;
+}
+
+- (void)viewWillDisappear:(BOOL)animated
+{
+    [super viewWillDisappear:animated];
+    
+    // Stops the keyboard from being dismissed during the navigation controller's "swipe-to-pop"
+    self.textView.didNotResignFirstResponder = self.isMovingFromParentViewController;
+    
+    self.viewVisible = NO;
+    
+    // Caches the text before it's too late!
+    [self slk_cacheTextView];
+}
+
+- (void)viewDidDisappear:(BOOL)animated
+{
+    [super viewDidDisappear:animated];
+}
+
+- (void)viewWillLayoutSubviews
+{
+    [super viewWillLayoutSubviews];
+    
+    [self slk_adjustContentConfigurationIfNeeded];
+}
+
+- (void)viewDidLayoutSubviews
+{
+    [super viewDidLayoutSubviews];
+}
+
+
+#pragma mark - Getters
+
++ (UITableViewStyle)tableViewStyleForCoder:(NSCoder *)decoder
+{
+    return UITableViewStylePlain;
+}
+
++ (UICollectionViewLayout *)collectionViewLayoutForCoder:(NSCoder *)decoder
+{
+    return nil;
+}
+
+- (UITableView *)tableViewWithStyle:(UITableViewStyle)style
+{
+    if (!_tableView) {
+        _tableView = [[UITableView alloc] initWithFrame:CGRectZero style:style];
+        _tableView.translatesAutoresizingMaskIntoConstraints = NO;
+        _tableView.scrollsToTop = YES;
+        _tableView.dataSource = self;
+        _tableView.delegate = self;
+        _tableView.clipsToBounds = NO;
+    }
+    return _tableView;
+}
+
+- (UICollectionView *)collectionViewWithLayout:(UICollectionViewLayout *)layout
+{
+    if (!_collectionView) {
+        _collectionView = [[UICollectionView alloc] initWithFrame:CGRectZero collectionViewLayout:layout];
+        _collectionView.translatesAutoresizingMaskIntoConstraints = NO;
+        _collectionView.scrollsToTop = YES;
+        _collectionView.dataSource = self;
+        _collectionView.delegate = self;
+    }
+    return _collectionView;
+}
+
+- (UITableView *)autoCompletionView
+{
+    if (!_autoCompletionView) {
+        _autoCompletionView = [[UITableView alloc] initWithFrame:CGRectZero style:UITableViewStylePlain];
+        _autoCompletionView.translatesAutoresizingMaskIntoConstraints = NO;
+        _autoCompletionView.backgroundColor = [UIColor colorWithWhite:0.97 alpha:1.0];
+        _autoCompletionView.scrollsToTop = NO;
+        _autoCompletionView.dataSource = self;
+        _autoCompletionView.delegate = self;
+        
+#ifdef __IPHONE_9_0
+        if ([_autoCompletionView respondsToSelector:@selector(cellLayoutMarginsFollowReadableWidth)]) {
+            _autoCompletionView.cellLayoutMarginsFollowReadableWidth = NO;
+        }
+#endif
+        
+        CGRect rect = CGRectZero;
+        rect.size = CGSizeMake(CGRectGetWidth(self.view.frame), 0.5);
+        
+        _autoCompletionHairline = [[UIView alloc] initWithFrame:rect];
+        _autoCompletionHairline.autoresizingMask = UIViewAutoresizingFlexibleWidth;
+        _autoCompletionHairline.backgroundColor = _autoCompletionView.separatorColor;
+        [_autoCompletionView addSubview:_autoCompletionHairline];
+    }
+    return _autoCompletionView;
+}
+
+- (SLKTextInputbar *)textInputbar
+{
+    if (!_textInputbar) {
+        _textInputbar = [[SLKTextInputbar alloc] initWithTextViewClass:self.textViewClass];
+        _textInputbar.translatesAutoresizingMaskIntoConstraints = NO;
+        _textInputbar.controller = self;
+        
+        [_textInputbar.leftButton addTarget:self action:@selector(didPressLeftButton:) forControlEvents:UIControlEventTouchUpInside];
+        [_textInputbar.rightButton addTarget:self action:@selector(didPressRightButton:) forControlEvents:UIControlEventTouchUpInside];
+        [_textInputbar.editorLeftButton addTarget:self action:@selector(didCancelTextEditing:) forControlEvents:UIControlEventTouchUpInside];
+        [_textInputbar.editorRightButton addTarget:self action:@selector(didCommitTextEditing:) forControlEvents:UIControlEventTouchUpInside];
+        
+        _textInputbar.textView.delegate = self;
+        
+        _verticalPanGesture = [[UIPanGestureRecognizer alloc] initWithTarget:self action:@selector(slk_didPanTextInputBar:)];
+        _verticalPanGesture.delegate = self;
+        
+        [_textInputbar addGestureRecognizer:self.verticalPanGesture];
+    }
+    return _textInputbar;
+}
+
+- (UIView <SLKTypingIndicatorProtocol> *)typingIndicatorProxyView
+{
+    if (!_typingIndicatorProxyView) {
+        Class class = self.typingIndicatorViewClass ? : [SLKTypingIndicatorView class];
+        
+        _typingIndicatorProxyView = [[class alloc] init];
+        _typingIndicatorProxyView.translatesAutoresizingMaskIntoConstraints = NO;
+        _typingIndicatorProxyView.hidden = YES;
+        
+        [_typingIndicatorProxyView addObserver:self forKeyPath:@"visible" options:NSKeyValueObservingOptionNew context:nil];
+    }
+    return _typingIndicatorProxyView;
+}
+
+- (SLKTypingIndicatorView *)typingIndicatorView
+{
+    if ([_typingIndicatorProxyView isKindOfClass:[SLKTypingIndicatorView class]]) {
+        return (SLKTypingIndicatorView *)self.typingIndicatorProxyView;
+    }
+    return nil;
+}
+
+- (BOOL)isPresentedInPopover
+{
+    return _presentedInPopover && SLK_IS_IPAD;
+}
+
+- (SLKTextView *)textView
+{
+    return self.textInputbar.textView;
+}
+
+- (UIButton *)leftButton
+{
+    return self.textInputbar.leftButton;
+}
+
+- (UIButton *)rightButton
+{
+    return self.textInputbar.rightButton;
+}
+
+- (UIModalPresentationStyle)modalPresentationStyle
+{
+    if (self.navigationController) {
+        return self.navigationController.modalPresentationStyle;
+    }
+    return [super modalPresentationStyle];
+}
+
+- (CGFloat)slk_appropriateKeyboardHeightFromNotification:(NSNotification *)notification
+{
+    // Let's first detect keyboard special states such as external keyboard, undocked or split layouts.
+    [self slk_detectKeyboardStatesInNotification:notification];
+    
+    if ([self ignoreTextInputbarAdjustment]) {
+        return [self slk_appropriateBottomMargin];
+    }
+    
+    CGRect keyboardRect = [notification.userInfo[UIKeyboardFrameEndUserInfoKey] CGRectValue];
+    
+    return [self slk_appropriateKeyboardHeightFromRect:keyboardRect];
+}
+
+- (CGFloat)slk_appropriateKeyboardHeightFromRect:(CGRect)rect
+{
+    CGRect keyboardRect = [self.view convertRect:rect fromView:nil];
+    
+    CGFloat viewHeight = CGRectGetHeight(self.view.bounds);
+    CGFloat keyboardMinY = CGRectGetMinY(keyboardRect);
+    
+    CGFloat keyboardHeight = MAX(0.0, viewHeight - keyboardMinY);
+    CGFloat bottomMargin = [self slk_appropriateBottomMargin];
+    
+    // When the keyboard height is zero, we can assume there is no keyboard visible
+    // In that case, let's see if there are any other views outside of the view hiearchy
+    // requiring to adjust the text input bottom margin
+    if (keyboardHeight < bottomMargin) {
+        keyboardHeight = bottomMargin;
+    }
+    
+    return keyboardHeight;
+}
+
+- (CGFloat)slk_appropriateBottomMargin
+{
+    // A bottom margin is required only if the view is extended out of it bounds
+    if ((self.edgesForExtendedLayout & UIRectEdgeBottom) > 0) {
+        if (self.tabBarController) {
+            return CGRectGetHeight(self.tabBarController.tabBar.frame);
+        }
+    }
+    
+    return 0.0;
+}
+
+- (CGFloat)slk_appropriateScrollViewHeight
+{
+    CGFloat scrollViewHeight = CGRectGetHeight(self.view.bounds);
+    
+    scrollViewHeight -= self.keyboardHC.constant;
+    scrollViewHeight -= self.textInputbarHC.constant;
+    scrollViewHeight -= self.autoCompletionViewHC.constant;
+    scrollViewHeight -= self.typingIndicatorViewHC.constant;
+    
+    if (scrollViewHeight < 0) return 0;
+    else return scrollViewHeight;
+}
+
+- (CGFloat)slk_topBarsHeight
+{
+    // No need to adjust if the edge isn't available
+    if ((self.edgesForExtendedLayout & UIRectEdgeTop) == 0) {
+        return 0.0;
+    }
+    
+    CGFloat topBarsHeight = CGRectGetHeight(self.navigationController.navigationBar.frame);
+    
+    if ((SLK_IS_IPHONE && SLK_IS_LANDSCAPE && SLK_IS_IOS8_AND_HIGHER) ||
+        (SLK_IS_IPAD && self.modalPresentationStyle == UIModalPresentationFormSheet) ||
+        self.isPresentedInPopover) {
+        return topBarsHeight;
+    }
+    
+    topBarsHeight += CGRectGetHeight([UIApplication sharedApplication].statusBarFrame);
+    
+    return topBarsHeight;
+}
+
+- (NSString *)slk_appropriateKeyboardNotificationName:(NSNotification *)notification
+{
+    NSString *name = notification.name;
+    
+    if ([name isEqualToString:UIKeyboardWillShowNotification]) {
+        return SLKKeyboardWillShowNotification;
+    }
+    if ([name isEqualToString:UIKeyboardWillHideNotification]) {
+        return SLKKeyboardWillHideNotification;
+    }
+    if ([name isEqualToString:UIKeyboardDidShowNotification]) {
+        return SLKKeyboardDidShowNotification;
+    }
+    if ([name isEqualToString:UIKeyboardDidHideNotification]) {
+        return SLKKeyboardDidHideNotification;
+    }
+    return nil;
+}
+
+- (SLKKeyboardStatus)slk_keyboardStatusForNotification:(NSNotification *)notification
+{
+    NSString *name = notification.name;
+    
+    if ([name isEqualToString:UIKeyboardWillShowNotification]) {
+        return SLKKeyboardStatusWillShow;
+    }
+    if ([name isEqualToString:UIKeyboardDidShowNotification]) {
+        return SLKKeyboardStatusDidShow;
+    }
+    if ([name isEqualToString:UIKeyboardWillHideNotification]) {
+        return SLKKeyboardStatusWillHide;
+    }
+    if ([name isEqualToString:UIKeyboardDidHideNotification]) {
+        return SLKKeyboardStatusDidHide;
+    }
+    return -1;
+}
+
+- (BOOL)slk_isIllogicalKeyboardStatus:(SLKKeyboardStatus)newStatus
+{
+    if ((self.keyboardStatus == SLKKeyboardStatusDidHide && newStatus == SLKKeyboardStatusWillShow) ||
+        (self.keyboardStatus == SLKKeyboardStatusWillShow && newStatus == SLKKeyboardStatusDidShow) ||
+        (self.keyboardStatus == SLKKeyboardStatusDidShow && newStatus == SLKKeyboardStatusWillHide) ||
+        (self.keyboardStatus == SLKKeyboardStatusWillHide && newStatus == SLKKeyboardStatusDidHide)) {
+        return NO;
+    }
+    return YES;
+}
+
+
+#pragma mark - Setters
+
+- (void)setEdgesForExtendedLayout:(UIRectEdge)rectEdge
+{
+    if (self.edgesForExtendedLayout == rectEdge) {
+        return;
+    }
+    
+    [super setEdgesForExtendedLayout:rectEdge];
+    
+    [self slk_updateViewConstraints];
+}
+
+- (void)setScrollViewProxy:(UIScrollView *)scrollView
+{
+    if ([_scrollViewProxy isEqual:scrollView]) {
+        return;
+    }
+    
+    _singleTapGesture = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(slk_didTapScrollView:)];
+    _singleTapGesture.delegate = self;
+    [_singleTapGesture requireGestureRecognizerToFail:scrollView.panGestureRecognizer];
+    
+    [scrollView addGestureRecognizer:self.singleTapGesture];
+    
+    [scrollView.panGestureRecognizer addTarget:self action:@selector(slk_didPanTextInputBar:)];
+    
+    _scrollViewProxy = scrollView;
+}
+
+- (void)setAutoCompleting:(BOOL)autoCompleting
+{
+    if (_autoCompleting == autoCompleting) {
+        return;
+    }
+    
+    _autoCompleting = autoCompleting;
+    
+    self.scrollViewProxy.scrollEnabled = !autoCompleting;
+}
+
+- (void)setInverted:(BOOL)inverted
+{
+    if (_inverted == inverted) {
+        return;
+    }
+    
+    _inverted = inverted;
+    
+    self.scrollViewProxy.transform = inverted ? CGAffineTransformMake(1, 0, 0, -1, 0, 0) : CGAffineTransformIdentity;
+}
+
+- (BOOL)slk_updateKeyboardStatus:(SLKKeyboardStatus)status
+{
+    // Skips if trying to update the same status
+    if (_keyboardStatus == status) {
+        return NO;
+    }
+    
+    // Skips illogical conditions
+    if ([self slk_isIllogicalKeyboardStatus:status]) {
+        return NO;
+    }
+    
+    _keyboardStatus = status;
+    
+    [self didChangeKeyboardStatus:status];
+    
+    return YES;
+}
+
+
+#pragma mark - Public & Subclassable Methods
+
+- (void)presentKeyboard:(BOOL)animated
+{
+    // Skips if already first responder
+    if ([self.textView isFirstResponder]) {
+        return;
+    }
+    
+    if (!animated) {
+        [UIView performWithoutAnimation:^{
+            [self.textView becomeFirstResponder];
+        }];
+    }
+    else {
+        [self.textView becomeFirstResponder];
+    }
+}
+
+- (void)dismissKeyboard:(BOOL)animated
+{
+    // Dismisses the keyboard from any first responder in the window.
+    if (![self.textView isFirstResponder] && self.keyboardHC.constant > 0) {
+        [self.view.window endEditing:NO];
+    }
+    
+    if (!animated) {
+        [UIView performWithoutAnimation:^{
+            [self.textView resignFirstResponder];
+        }];
+    }
+    else {
+        [self.textView resignFirstResponder];
+    }
+}
+
+- (BOOL)forceTextInputbarAdjustmentForResponder:(UIResponder *)responder
+{
+    return NO;
+}
+
+- (BOOL)ignoreTextInputbarAdjustment
+{
+    if (self.isExternalKeyboardDetected || self.isKeyboardUndocked) {
+        return YES;
+    }
+    
+    return NO;
+}
+
+- (void)didChangeKeyboardStatus:(SLKKeyboardStatus)status
+{
+    // No implementation here. Meant to be overriden in subclass.
+}
+
+- (void)textWillUpdate
+{
+    // No implementation here. Meant to be overriden in subclass.
+}
+
+- (void)textDidUpdate:(BOOL)animated
+{
+    if (self.textInputbarHidden) {
+        return;
+    }
+    
+    CGFloat inputbarHeight = self.textInputbar.appropriateHeight;
+    
+    self.textInputbar.rightButton.enabled = [self canPressRightButton];
+    self.textInputbar.editorRightButton.enabled = [self canPressRightButton];
+    
+    if (inputbarHeight != self.textInputbarHC.constant)
+    {
+        self.textInputbarHC.constant = inputbarHeight;
+        self.scrollViewHC.constant = [self slk_appropriateScrollViewHeight];
+        
+        if (animated) {
+            
+            BOOL bounces = self.bounces && [self.textView isFirstResponder];
+            
+            [self.view slk_animateLayoutIfNeededWithBounce:bounces
+                                                   options:UIViewAnimationOptionCurveEaseInOut|UIViewAnimationOptionLayoutSubviews|UIViewAnimationOptionBeginFromCurrentState
+                                                animations:^{
+                                                    if (self.textInputbar.isEditing) {
+                                                        [self.textView slk_scrollToCaretPositonAnimated:NO];
+                                                    }
+                                                }];
+        }
+        else {
+            [self.view layoutIfNeeded];
+        }
+    }
+    
+    // Toggles auto-correction if requiered
+    [self slk_enableTypingSuggestionIfNeeded];
+}
+
+- (void)textSelectionDidChange
+{
+    // The text view must be first responder
+    if (![self.textView isFirstResponder]) {
+        return;
+    }
+    
+    // Skips there is a real text selection
+    if (self.textView.isTrackpadEnabled) {
+        return;
+    }
+    
+    if (self.textView.selectedRange.length > 0) {
+        if (self.isAutoCompleting) {
+            [self cancelAutoCompletion];
+        }
+        return;
+    }
+    
+    // Process the text at every caret movement
+    [self slk_processTextForAutoCompletion];
+}
+
+- (BOOL)canPressRightButton
+{
+    NSString *text = [self.textView.text stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
+    
+    if (text.length > 0 && ![self.textInputbar limitExceeded]) {
+        return YES;
+    }
+    
+    return NO;
+}
+
+- (void)didPressLeftButton:(id)sender
+{
+    // No implementation here. Meant to be overriden in subclass.
+}
+
+- (void)didPressRightButton:(id)sender
+{
+    if (self.shouldClearTextAtRightButtonPress) {
+        // Clears the text and the undo manager
+        [self.textView slk_clearText:YES];
+    }
+    
+    // Clears cache
+    [self clearCachedText];
+}
+
+- (void)editText:(NSString *)text
+{
+    if (![self.textInputbar canEditText:text]) {
+        return;
+    }
+    
+    // Caches the current text, in case the user cancels the edition
+    [self slk_cacheTextToDisk:self.textView.text];
+    
+    [self.textInputbar beginTextEditing];
+    
+    // Setting the text after calling -beginTextEditing is safer
+    [self.textView setText:text];
+    
+    [self.textView slk_scrollToCaretPositonAnimated:YES];
+    
+    // Brings up the keyboard if needed
+    [self presentKeyboard:YES];
+}
+
+- (void)didCommitTextEditing:(id)sender
+{
+    if (!self.textInputbar.isEditing) {
+        return;
+    }
+    
+    [self.textInputbar endTextEdition];
+    
+    // Clears the text and but not the undo manager
+    [self.textView slk_clearText:NO];
+}
+
+- (void)didCancelTextEditing:(id)sender
+{
+    if (!self.textInputbar.isEditing) {
+        return;
+    }
+    
+    [self.textInputbar endTextEdition];
+    
+    // Clears the text and but not the undo manager
+    [self.textView slk_clearText:NO];
+    
+    // Restores any previous cached text before entering in editing mode
+    [self slk_reloadTextView];
+}
+
+- (BOOL)canShowTypingIndicator
+{
+    // Don't show if the text is being edited or auto-completed.
+    if (self.textInputbar.isEditing || self.isAutoCompleting) {
+        return NO;
+    }
+    
+    // Don't show if the content offset is not at top (when inverted) or at bottom (when not inverted)
+    if ((self.isInverted && ![self.scrollViewProxy slk_isAtTop]) || (!self.isInverted && ![self.scrollViewProxy slk_isAtBottom])) {
+        return NO;
+    }
+    
+    return YES;
+}
+
+- (CGFloat)heightForAutoCompletionView
+{
+    return 0.0;
+}
+
+- (CGFloat)maximumHeightForAutoCompletionView
+{
+    CGFloat maxiumumHeight = SLKAutoCompletionViewDefaultHeight;
+    
+    if (self.isAutoCompleting) {
+        CGFloat scrollViewHeight = self.scrollViewHC.constant;
+        scrollViewHeight -= [self slk_topBarsHeight];
+        
+        if (scrollViewHeight < maxiumumHeight) {
+            maxiumumHeight = scrollViewHeight;
+        }
+    }
+    
+    return maxiumumHeight;
+}
+
+- (void)didPasteMediaContent:(NSDictionary *)userInfo
+{
+    // No implementation here. Meant to be overriden in subclass.
+}
+
+- (void)willRequestUndo
+{
+    NSString *title = NSLocalizedString(@"Undo Typing", nil);
+    NSString *acceptTitle = NSLocalizedString(@"Undo", nil);
+    NSString *cancelTitle = NSLocalizedString(@"Cancel", nil);
+    
+#ifdef __IPHONE_8_0
+    UIAlertController *alertController = [UIAlertController alertControllerWithTitle:title message:nil preferredStyle:UIAlertControllerStyleAlert];
+    
+    [alertController addAction:[UIAlertAction actionWithTitle:acceptTitle style:UIAlertActionStyleDefault handler:^(UIAlertAction *action) {
+        // Clears the text but doesn't clear the undo manager
+        if (self.shakeToClearEnabled) {
+            [self.textView slk_clearText:NO];
+        }
+    }]];
+    
+    [alertController addAction:[UIAlertAction actionWithTitle:cancelTitle style:UIAlertActionStyleCancel handler:NULL]];
+    
+    [self presentViewController:alertController animated:YES completion:nil];
+#else
+    UIAlertView *alert = [UIAlertView new];
+    [alert setTitle:title];
+    [alert addButtonWithTitle:acceptTitle];
+    [alert addButtonWithTitle:cancelTitle];
+    [alert setCancelButtonIndex:1];
+    [alert setTag:kSLKAlertViewClearTextTag];
+    [alert setDelegate:self];
+    [alert show];
+#endif
+}
+
+- (void)setTextInputbarHidden:(BOOL)hidden
+{
+    [self setTextInputbarHidden:hidden animated:NO];
+}
+
+- (void)setTextInputbarHidden:(BOOL)hidden animated:(BOOL)animated
+{
+    if (self.isTextInputbarHidden == hidden) {
+        return;
+    }
+    
+    _textInputbarHidden = hidden;
+    
+    __weak typeof(self) weakSelf = self;
+    
+    void (^animations)() = ^void(){
+        
+        weakSelf.textInputbarHC.constant = hidden ? 0 : weakSelf.textInputbar.appropriateHeight;
+        
+        [weakSelf.view layoutIfNeeded];
+    };
+    
+    void (^completion)(BOOL finished) = ^void(BOOL finished){
+        if (hidden) {
+            [self dismissKeyboard:YES];
+        }
+    };
+    
+    if (animated) {
+        [UIView animateWithDuration:0.25 animations:animations completion:completion];
+    }
+    else {
+        animations();
+        completion(NO);
+    }
+}
+
+
+#pragma mark - Private Methods
+
+- (void)slk_didPanTextInputBar:(UIPanGestureRecognizer *)gesture
+{
+    // Textinput dragging isn't supported when
+    if (!self.view.window || !self.keyboardPanningEnabled ||
+        [self ignoreTextInputbarAdjustment] || self.isPresentedInPopover) {
+        return;
+    }
+    
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self slk_handlePanGestureRecognizer:gesture];
+    });
+}
+
+- (void)slk_handlePanGestureRecognizer:(UIPanGestureRecognizer *)gesture
+{
+    // Local variables
+    static CGPoint startPoint;
+    static CGRect originalFrame;
+    static BOOL dragging = NO;
+    static BOOL presenting = NO;
+    
+    __block UIView *keyboardView = [self.textInputbar.inputAccessoryView keyboardViewProxy];
+    
+    // When no keyboard view has been detecting, let's skip any handling.
+    if (!keyboardView) {
+        return;
+    }
+    
+    // Dynamic variables
+    CGPoint gestureLocation = [gesture locationInView:self.view];
+    CGPoint gestureVelocity = [gesture velocityInView:self.view];
+    
+    CGFloat keyboardMaxY = CGRectGetHeight(SLKKeyWindowBounds());
+    CGFloat keyboardMinY = keyboardMaxY - CGRectGetHeight(keyboardView.frame);
+    
+    
+    // Skips this if it's not the expected textView.
+    // Checking the keyboard height constant helps to disable the view constraints update on iPad when the keyboard is undocked.
+    // Checking the keyboard status allows to keep the inputAccessoryView valid when still reacing the bottom of the screen.
+    if (![self.textView isFirstResponder] || (self.keyboardHC.constant == 0 && self.keyboardStatus == SLKKeyboardStatusDidHide)) {
+#if SLKBottomPanningEnabled
+        if ([gesture.view isEqual:self.scrollViewProxy]) {
+            if (gestureVelocity.y > 0) {
+                return;
+            }
+            else if ((self.isInverted && ![self.scrollViewProxy slk_isAtTop]) || (!self.isInverted && ![self.scrollViewProxy slk_isAtBottom])) {
+                return;
+            }
+        }
+        
+        presenting = YES;
+#else
+        if ([gesture.view isEqual:self.textInputbar] && gestureVelocity.y < 0) {
+            [self presentKeyboard:YES];
+        }
+        return;
+#endif
+    }
+    
+    switch (gesture.state) {
+        case UIGestureRecognizerStateBegan: {
+            
+            startPoint = CGPointZero;
+            dragging = NO;
+            
+            if (presenting) {
+                // Let's first present the keyboard without animation
+                [self presentKeyboard:NO];
+                
+                // So we can capture the keyboard's view
+                keyboardView = [self.textInputbar.inputAccessoryView keyboardViewProxy];
+                
+                originalFrame = keyboardView.frame;
+                originalFrame.origin.y = CGRectGetMaxY(self.view.frame);
+                
+                // And move the keyboard to the bottom edge
+                // TODO: Fix an occasional layout glitch when the keyboard appears for the first time.
+                keyboardView.frame = originalFrame;
+            }
+            
+            break;
+        }
+        case UIGestureRecognizerStateChanged: {
+            
+            if (CGRectContainsPoint(self.textInputbar.frame, gestureLocation) || dragging || presenting){
+                
+                if (CGPointEqualToPoint(startPoint, CGPointZero)) {
+                    startPoint = gestureLocation;
+                    dragging = YES;
+                    
+                    if (!presenting) {
+                        originalFrame = keyboardView.frame;
+                    }
+                }
+                
+                self.movingKeyboard = YES;
+                
+                CGPoint transition = CGPointMake(gestureLocation.x - startPoint.x, gestureLocation.y - startPoint.y);
+                
+                CGRect keyboardFrame = originalFrame;
+                
+                if (presenting) {
+                    keyboardFrame.origin.y += transition.y;
+                }
+                else {
+                    keyboardFrame.origin.y += MAX(transition.y, 0.0);
+                }
+                
+                // Makes sure they keyboard is always anchored to the bottom
+                if (CGRectGetMinY(keyboardFrame) < keyboardMinY) {
+                    keyboardFrame.origin.y = keyboardMinY;
+                }
+                
+                keyboardView.frame = keyboardFrame;
+                
+                
+                self.keyboardHC.constant = [self slk_appropriateKeyboardHeightFromRect:keyboardFrame];
+                self.scrollViewHC.constant = [self slk_appropriateScrollViewHeight];
+                
+                // layoutIfNeeded must be called before any further scrollView internal adjustments (content offset and size)
+                [self.view layoutIfNeeded];
+                
+                // Overrides the scrollView's contentOffset to allow following the same position when dragging the keyboard
+                CGPoint offset = _scrollViewOffsetBeforeDragging;
+                
+                if (self.isInverted) {
+                    if (!self.scrollViewProxy.isDecelerating && self.scrollViewProxy.isTracking) {
+                        self.scrollViewProxy.contentOffset = _scrollViewOffsetBeforeDragging;
+                    }
+                }
+                else {
+                    CGFloat keyboardHeightDelta = _keyboardHeightBeforeDragging-self.keyboardHC.constant;
+                    offset.y -= keyboardHeightDelta;
+                    
+                    self.scrollViewProxy.contentOffset = offset;
+                }
+            }
+            
+            break;
+        }
+        case UIGestureRecognizerStatePossible:
+        case UIGestureRecognizerStateCancelled:
+        case UIGestureRecognizerStateEnded:
+        case UIGestureRecognizerStateFailed: {
+            
+            if (!dragging) {
+                break;
+            }
+            
+            CGPoint transition = CGPointMake(0.0, fabs(gestureLocation.y - startPoint.y));
+            
+            CGRect keyboardFrame = originalFrame;
+            
+            if (presenting) {
+                keyboardFrame.origin.y = keyboardMinY;
+            }
+            
+            // The velocity can be changed to hide or show the keyboard based on the gesture
+            CGFloat minVelocity = 20.0;
+            CGFloat minDistance = CGRectGetHeight(keyboardFrame)/2.0;
+            
+            BOOL hide = (gestureVelocity.y > minVelocity) || (presenting && transition.y < minDistance) || (!presenting && transition.y > minDistance);
+            
+            if (hide) keyboardFrame.origin.y = keyboardMaxY;
+            
+            self.keyboardHC.constant = [self slk_appropriateKeyboardHeightFromRect:keyboardFrame];
+            self.scrollViewHC.constant = [self slk_appropriateScrollViewHeight];
+            
+            [UIView animateWithDuration:0.25
+                                  delay:0.0
+                                options:UIViewAnimationOptionCurveEaseInOut|UIViewAnimationOptionBeginFromCurrentState
+                             animations:^{
+                                 [self.view layoutIfNeeded];
+                                 keyboardView.frame = keyboardFrame;
+                             }
+                             completion:^(BOOL finished) {
+                                 if (hide) {
+                                     [self dismissKeyboard:NO];
+                                 }
+                                 
+                                 // Tear down
+                                 startPoint = CGPointZero;
+                                 originalFrame = CGRectZero;
+                                 dragging = NO;
+                                 presenting = NO;
+                                 
+                                 self.movingKeyboard = NO;
+                             }];
+            
+            break;
+        }
+            
+        default:
+            break;
+    }
+}
+
+- (void)slk_didTapScrollView:(UIGestureRecognizer *)gesture
+{
+    if (!self.isPresentedInPopover && ![self ignoreTextInputbarAdjustment]) {
+        [self dismissKeyboard:YES];
+    }
+}
+
+- (void)slk_didPanTextView:(UIGestureRecognizer *)gesture
+{
+    [self presentKeyboard:YES];
+}
+
+- (void)slk_performRightAction
+{
+    NSArray *actions = [self.rightButton actionsForTarget:self forControlEvent:UIControlEventTouchUpInside];
+    
+    if (actions.count > 0 && [self canPressRightButton]) {
+        [self.rightButton sendActionsForControlEvents:UIControlEventTouchUpInside];
+    }
+}
+
+- (void)slk_postKeyboarStatusNotification:(NSNotification *)notification
+{
+    if ([self ignoreTextInputbarAdjustment] || self.isTransitioning) {
+        return;
+    }
+    
+    NSMutableDictionary *userInfo = [notification.userInfo mutableCopy];
+    
+    CGRect beginFrame = [notification.userInfo[UIKeyboardFrameBeginUserInfoKey] CGRectValue];
+    CGRect endFrame = [notification.userInfo[UIKeyboardFrameEndUserInfoKey] CGRectValue];
+    
+    // Fixes iOS7 oddness with inverted values on landscape orientation
+    if (!SLK_IS_IOS8_AND_HIGHER && SLK_IS_LANDSCAPE) {
+        beginFrame = SLKRectInvert(beginFrame);
+        endFrame = SLKRectInvert(endFrame);
+    }
+    
+    CGFloat keyboardHeight = CGRectGetHeight(endFrame);
+    
+    beginFrame.size.height = keyboardHeight;
+    endFrame.size.height = keyboardHeight;
+    
+    [userInfo setObject:[NSValue valueWithCGRect:beginFrame] forKey:UIKeyboardFrameBeginUserInfoKey];
+    [userInfo setObject:[NSValue valueWithCGRect:endFrame] forKey:UIKeyboardFrameEndUserInfoKey];
+    
+    NSString *name = [self slk_appropriateKeyboardNotificationName:notification];
+    [[NSNotificationCenter defaultCenter] postNotificationName:name object:self.textView userInfo:userInfo];
+}
+
+- (void)slk_enableTypingSuggestionIfNeeded
+{
+    if (![self.textView isFirstResponder]) {
+        return;
+    }
+    
+    BOOL enable = !self.isAutoCompleting;
+    
+    // Toggling autocorrect on Japanese keyboards breaks autocompletion by replacing the autocompletion prefix by an empty string.
+    // So for now, let's not disable autocorrection for Japanese.
+    if ([self.textView.textInputMode.primaryLanguage isEqualToString:@"ja-JP"]) {
+        return;
+    }
+    
+    // During text autocompletion, the iOS 8 QuickType bar is hidden and auto-correction and spell checking are disabled.
+    [self.textView setTypingSuggestionEnabled:enable];
+}
+
+- (void)slk_dismissTextInputbarIfNeeded
+{
+    if (self.keyboardHC.constant == 0) {
+        return;
+    }
+    
+    self.keyboardHC.constant = 0.0;
+    self.scrollViewHC.constant = [self slk_appropriateScrollViewHeight];
+    
+    [self slk_hideAutoCompletionViewIfNeeded];
+    
+    [self.view layoutIfNeeded];
+}
+
+- (void)slk_detectKeyboardStatesInNotification:(NSNotification *)notification
+{
+    // Tear down
+    _externalKeyboardDetected = NO;
+    _keyboardUndocked = NO;
+    
+    if (self.isMovingKeyboard) {
+        return;
+    }
+    
+    // Based on http://stackoverflow.com/a/5760910/287403
+    // We can determine if the external keyboard is showing by adding the origin.y of the target finish rect (end when showing, begin when hiding) to the inputAccessoryHeight.
+    // If it's greater(or equal) the window height, it's an external keyboard.
+    CGRect beginRect = [notification.userInfo[UIKeyboardFrameBeginUserInfoKey] CGRectValue];
+    CGRect endRect = [notification.userInfo[UIKeyboardFrameEndUserInfoKey] CGRectValue];
+    
+    // Grab the base view for conversions as we don't want window coordinates in < iOS 8
+    // iOS 8 fixes the whole coordinate system issue for us, but iOS 7 doesn't rotate the app window coordinate space.
+    UIView *baseView = self.view.window.rootViewController.view;
+    
+    CGRect screenBounds = [UIScreen mainScreen].bounds;
+    
+    // Convert the main screen bounds into the correct coordinate space but ignore the origin.
+    CGRect viewBounds = [self.view convertRect:SLKKeyWindowBounds() fromView:nil];
+    viewBounds = CGRectMake(0, 0, viewBounds.size.width, viewBounds.size.height);
+    
+    // We want these rects in the correct coordinate space as well.
+    CGRect convertBegin = [baseView convertRect:beginRect fromView:nil];
+    CGRect convertEnd = [baseView convertRect:endRect fromView:nil];
+    
+    if ([notification.name isEqualToString:UIKeyboardWillShowNotification]) {
+        if (convertEnd.origin.y >= viewBounds.size.height) {
+            _externalKeyboardDetected = YES;
+        }
+    }
+    else if ([notification.name isEqualToString:UIKeyboardWillHideNotification]) {
+        // The additional logic check here (== to width) accounts for a glitch (iOS 8 only?) where the window has rotated it's coordinates
+        // but the beginRect doesn't yet reflect that. It should never cause a false positive.
+        if (convertBegin.origin.y >= viewBounds.size.height ||
+            convertBegin.origin.y == viewBounds.size.width) {
+            _externalKeyboardDetected = YES;
+        }
+    }
+    
+    if (SLK_IS_IPAD && CGRectGetMaxY(convertEnd) < CGRectGetMaxY(screenBounds)) {
+        
+        // The keyboard is undocked or split (iPad Only)
+        _keyboardUndocked = YES;
+        
+        // An external keyboard cannot be detected anymore
+        _externalKeyboardDetected = NO;
+    }
+}
+
+- (void)slk_adjustContentConfigurationIfNeeded
+{
+    UIEdgeInsets contentInset = self.scrollViewProxy.contentInset;
+    
+    // When inverted, we need to substract the top bars height (generally status bar + navigation bar's) to align the top of the
+    // scrollView correctly to its top edge.
+    if (self.inverted) {
+        contentInset.bottom = [self slk_topBarsHeight];
+        contentInset.top = contentInset.bottom > 0.0 ? 0.0 : contentInset.top;
+    }
+    else {
+        contentInset.bottom = 0.0;
+    }
+    
+    self.scrollViewProxy.contentInset = contentInset;
+    self.scrollViewProxy.scrollIndicatorInsets = contentInset;
+}
+
+- (void)slk_prepareForInterfaceTransitionWithDuration:(NSTimeInterval)duration
+{
+    self.transitioning = YES;
+    
+    [self.view layoutIfNeeded];
+    
+    if ([self.textView isFirstResponder]) {
+        [self.textView slk_scrollToCaretPositonAnimated:NO];
+    }
+    else {
+        [self.textView slk_scrollToBottomAnimated:NO];
+    }
+    
+    // Disables the flag after the rotation animation is finished
+    // Hacky but works.
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(duration * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+        self.transitioning = NO;
+    });
+}
+
+
+#pragma mark - Keyboard Events
+
+- (void)didPressReturnKey:(id)sender
+{
+    if (self.textInputbar.isEditing) {
+        [self didCommitTextEditing:sender];
+    }
+    else {
+        [self slk_performRightAction];
+    }
+}
+
+- (void)didPressEscapeKey:(id)sender
+{
+    if (self.isAutoCompleting) {
+        [self cancelAutoCompletion];
+    }
+    else if (self.textInputbar.isEditing) {
+        [self didCancelTextEditing:sender];
+    }
+    
+    if ([self ignoreTextInputbarAdjustment] || ([self.textView isFirstResponder] && self.keyboardHC.constant == 0)) {
+        return;
+    }
+    
+    [self dismissKeyboard:YES];
+}
+
+- (void)didPressArrowKey:(id)sender
+{
+    [self.textView didPressAnyArrowKey:sender];
+}
+
+
+#pragma mark - Notification Events
+
+- (void)slk_willShowOrHideKeyboard:(NSNotification *)notification
+{
+    // Skips if the view isn't visible.
+    if (!self.view.window) {
+        return;
+    }
+    
+    // Skips if it is presented inside of a popover.
+    if (self.isPresentedInPopover) {
+        return;
+    }
+    
+    // Skips if textview did refresh only.
+    if (self.textView.didNotResignFirstResponder) {
+        return;
+    }
+    
+    SLKKeyboardStatus status = [self slk_keyboardStatusForNotification:notification];
+    
+    // Skips if it's the current status
+    if (self.keyboardStatus == status) {
+        return;
+    }
+    
+    // Updates and notifies about the keyboard status update
+    if ([self slk_updateKeyboardStatus:status]) {
+        // Posts custom keyboard notification, if logical conditions apply
+        [self slk_postKeyboarStatusNotification:notification];
+    }
+    
+    // Skips this it's not the expected textView and shouldn't force adjustment of the text input bar.
+    // This will also dismiss the text input bar if it's visible, and exit auto-completion mode if enabled.
+    if (![self.textView isFirstResponder]) {
+        // Detect the current first responder. If there is no first responder, we should just ignore these notifications.
+        UIResponder *currentResponder = [UIResponder slk_currentFirstResponder];
+        
+        if (!currentResponder) {
+            return;
+        }
+        else if (![self forceTextInputbarAdjustmentForResponder:currentResponder]) {
+            return [self slk_dismissTextInputbarIfNeeded];
+        }
+    }
+    
+    // Programatically stops scrolling before updating the view constraints (to avoid scrolling glitch).
+    if (status == SLKKeyboardStatusWillShow) {
+        [self.scrollViewProxy slk_stopScrolling];
+    }
+    
+    // Hides the auto-completion view if the keyboard is being dismissed.
+    if (![self.textView isFirstResponder] || status == SLKKeyboardStatusWillHide) {
+        [self slk_hideAutoCompletionViewIfNeeded];
+    }
+    
+    // Updates the height constraints' constants
+    self.keyboardHC.constant = [self slk_appropriateKeyboardHeightFromNotification:notification];
+    self.scrollViewHC.constant = [self slk_appropriateScrollViewHeight];
+    
+    
+    NSInteger curve = [notification.userInfo[UIKeyboardAnimationCurveUserInfoKey] integerValue];
+    NSTimeInterval duration = [notification.userInfo[UIKeyboardAnimationDurationUserInfoKey] doubleValue];
+    
+    CGRect beginFrame = [notification.userInfo[UIKeyboardFrameBeginUserInfoKey] CGRectValue];
+    CGRect endFrame = [notification.userInfo[UIKeyboardFrameEndUserInfoKey] CGRectValue];
+    
+    void (^animations)() = ^void() {
+        // Scrolls to bottom only if the keyboard is about to show.
+        if (self.shouldScrollToBottomAfterKeyboardShows && self.keyboardStatus == SLKKeyboardStatusWillShow) {
+            if (self.isInverted) {
+                [self.scrollViewProxy slk_scrollToTopAnimated:YES];
+            }
+            else {
+                [self.scrollViewProxy slk_scrollToBottomAnimated:YES];
+            }
+        }
+    };
+    
+    // Begin and end frames are the same when the keyboard is shown during navigation controller's push animation.
+    // The animation happens in window coordinates (slides from right to left) but doesn't in the view controller's view coordinates.
+    if (!CGRectEqualToRect(beginFrame, endFrame))
+    {
+        // Only for this animation, we set bo to bounce since we want to give the impression that the text input is glued to the keyboard.
+        [self.view slk_animateLayoutIfNeededWithDuration:duration
+                                                  bounce:NO
+                                                 options:(curve<<16)|UIViewAnimationOptionLayoutSubviews|UIViewAnimationOptionBeginFromCurrentState
+                                              animations:animations
+                                              completion:NULL];
+    }
+    else {
+        animations();
+    }
+}
+
+- (void)slk_didShowOrHideKeyboard:(NSNotification *)notification
+{
+    // Skips if the view isn't visible
+    if (!self.view.window) {
+        return;
+    }
+    
+    // Skips if it is presented inside of a popover
+    if (self.isPresentedInPopover) {
+        return;
+    }
+    
+    // Skips if textview did refresh only
+    if (self.textView.didNotResignFirstResponder) {
+        return;
+    }
+    
+    SLKKeyboardStatus status = [self slk_keyboardStatusForNotification:notification];
+    
+    // Skips if it's the current status
+    if (self.keyboardStatus == status) {
+        return;
+    }
+    
+    // Updates and notifies about the keyboard status update
+    if ([self slk_updateKeyboardStatus:status]) {
+        // Posts custom keyboard notification, if logical conditions apply
+        [self slk_postKeyboarStatusNotification:notification];
+    }
+    
+    // After showing keyboard, check if the current cursor position could diplay autocompletion
+    if ([self.textView isFirstResponder] && status == SLKKeyboardStatusDidShow && !self.isAutoCompleting) {
+        
+        // Wait till the end of the current run loop
+        dispatch_async(dispatch_get_main_queue(), ^{
+            [self slk_processTextForAutoCompletion];
+        });
+    }
+    
+    // Very important to invalidate this flag after the keyboard is dismissed or presented, to start with a clean state next time.
+    self.movingKeyboard = NO;
+}
+
+- (void)slk_didPostSLKKeyboardNotification:(NSNotification *)notification
+{
+    if (![notification.object isEqual:self.textView]) {
+        return;
+    }
+    
+    // Used for debug only
+    NSLog(@"%@ %s: %@", NSStringFromClass([self class]), __FUNCTION__, notification);
+}
+
+- (void)slk_willChangeTextViewText:(NSNotification *)notification
+{
+    // Skips this it's not the expected textView.
+    if (![notification.object isEqual:self.textView] || !self.textView.window) {
+        return;
+    }
+    
+    [self textWillUpdate];
+}
+
+- (void)slk_didChangeTextViewText:(NSNotification *)notification
+{
+    // Skips this it's not the expected textView.
+    if (![notification.object isEqual:self.textView] || !self.textView.window) {
+        return;
+    }
+    
+    // Animated only if the view already appeared.
+    [self textDidUpdate:self.isViewVisible];
+    
+    // Process the text at every change, when the view is visible
+    if (self.isViewVisible) {
+        [self slk_processTextForAutoCompletion];
+    }
+}
+
+- (void)slk_didChangeTextViewContentSize:(NSNotification *)notification
+{
+    // Skips this it's not the expected textView.
+    if (![notification.object isEqual:self.textView] || !self.textView.window) {
+        return;
+    }
+    
+    // Animated only if the view already appeared.
+    [self textDidUpdate:self.isViewVisible];
+}
+
+- (void)slk_didChangeTextViewSelectedRange:(NSNotification *)notification
+{
+    // Skips this it's not the expected textView.
+    if (![notification.object isEqual:self.textView] || !self.textView.window) {
+        return;
+    }
+    
+    [self textSelectionDidChange];
+}
+
+- (void)slk_didChangeTextViewPasteboard:(NSNotification *)notification
+{
+    // Skips this if it's not the expected textView.
+    if (![self.textView isFirstResponder]) {
+        return;
+    }
+    
+    // Notifies only if the pasted item is nested in a dictionary.
+    if ([notification.userInfo isKindOfClass:[NSDictionary class]]) {
+        [self didPasteMediaContent:notification.userInfo];
+    }
+}
+
+- (void)slk_didShakeTextView:(NSNotification *)notification
+{
+    // Skips this if it's not the expected textView.
+    if (![self.textView isFirstResponder]) {
+        return;
+    }
+    
+    // Notifies of the shake gesture if undo mode is on and the text view is not empty
+    if (self.shakeToClearEnabled && self.textView.text.length > 0) {
+        [self willRequestUndo];
+    }
+}
+
+- (void)slk_willShowOrHideTypeIndicatorView:(UIView <SLKTypingIndicatorProtocol> *)typingIndicatorView
+{
+    // Skips if the typing indicator should not show. Ignores the checking if it's trying to hide.
+    if (![self canShowTypingIndicator] && typingIndicatorView.isVisible) {
+        return;
+    }
+    
+    CGFloat systemLayoutSizeHeight = [typingIndicatorView systemLayoutSizeFittingSize:UILayoutFittingCompressedSize].height;
+    CGFloat height = typingIndicatorView.isVisible ? systemLayoutSizeHeight : 0.0;
+    
+    self.typingIndicatorViewHC.constant = height;
+    self.scrollViewHC.constant -= height;
+    
+    if (typingIndicatorView.isVisible) {
+        typingIndicatorView.hidden = NO;
+    }
+    
+    [self.view slk_animateLayoutIfNeededWithBounce:self.bounces
+                                           options:UIViewAnimationOptionCurveEaseInOut
+                                        animations:NULL
+                                        completion:^(BOOL finished) {
+                                            if (!typingIndicatorView.isVisible) {
+                                                typingIndicatorView.hidden = YES;
+                                            }
+                                        }];
+}
+
+- (void)slk_willTerminateApplication:(NSNotification *)notification
+{
+    // Caches the text before it's too late!
+    if (self.isViewVisible) {
+        [self slk_cacheTextView];
+    }
+}
+
+
+#pragma mark - KVO Events
+
+- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
+{
+    if ([object conformsToProtocol:@protocol(SLKTypingIndicatorProtocol)] && [keyPath isEqualToString:@"visible"]) {
+        [self slk_willShowOrHideTypeIndicatorView:object];
+    }
+    else {
+        [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
+    }
+}
+
+
+#pragma mark - Auto-Completion Text Processing
+
+- (void)registerPrefixesForAutoCompletion:(NSArray *)prefixes
+{
+    NSMutableArray *array = [NSMutableArray arrayWithArray:self.registeredPrefixes];
+    
+    for (NSString *prefix in prefixes) {
+        // Skips if the prefix is not a valid string
+        if (![prefix isKindOfClass:[NSString class]] || prefix.length == 0) {
+            continue;
+        }
+        
+        // Adds the prefix if not contained already
+        if (![array containsObject:prefix]) {
+            [array addObject:prefix];
+        }
+    }
+    
+    if (_registeredPrefixes) {
+        _registeredPrefixes = nil;
+    }
+    
+    _registeredPrefixes = [[NSArray alloc] initWithArray:array];
+}
+
+- (void)didChangeAutoCompletionPrefix:(NSString *)prefix andWord:(NSString *)word
+{
+    // No implementation here. Meant to be overriden in subclass.
+}
+
+- (BOOL)canShowAutoCompletion
+{
+    // Let's keep this around for a bit, for backwards compatibility.
+    return NO;
+}
+
+- (void)showAutoCompletionView:(BOOL)show
+{
+    // Reloads the tableview before showing/hiding
+    if (show) {
+        [self.autoCompletionView reloadData];
+    }
+    
+    self.autoCompleting = show;
+    
+    // Toggles auto-correction if requiered
+    [self slk_enableTypingSuggestionIfNeeded];
+    
+    CGFloat viewHeight = show ? [self heightForAutoCompletionView] : 0.0;
+    
+    if (self.autoCompletionViewHC.constant == viewHeight) {
+        return;
+    }
+    
+    // If the auto-completion view height is bigger than the maximum height allows, it is reduce to that size. Default 140 pts.
+    CGFloat maximumHeight = [self maximumHeightForAutoCompletionView];
+    
+    if (viewHeight > maximumHeight) {
+        viewHeight = maximumHeight;
+    }
+    
+    CGFloat contentViewHeight = self.scrollViewHC.constant + self.autoCompletionViewHC.constant;
+    
+    // On iPhone, the auto-completion view can't extend beyond the content view height
+    if (SLK_IS_IPHONE && viewHeight > contentViewHeight) {
+        viewHeight = contentViewHeight;
+    }
+    
+    self.autoCompletionViewHC.constant = viewHeight;
+    
+    [self.view slk_animateLayoutIfNeededWithBounce:self.bounces
+                                           options:UIViewAnimationOptionCurveEaseInOut|UIViewAnimationOptionLayoutSubviews|UIViewAnimationOptionBeginFromCurrentState|UIViewAnimationOptionAllowUserInteraction
+                                        animations:NULL];
+}
+
+- (void)acceptAutoCompletionWithString:(NSString *)string
+{
+    [self acceptAutoCompletionWithString:string keepPrefix:YES];
+}
+
+- (void)acceptAutoCompletionWithString:(NSString *)string keepPrefix:(BOOL)keepPrefix
+{
+    if (string.length == 0) {
+        return;
+    }
+    
+    SLKTextView *textView = self.textView;
+    
+    NSUInteger location = self.foundPrefixRange.location;
+    if (keepPrefix) {
+        location += self.foundPrefixRange.length;
+    }
+    
+    NSUInteger length = self.foundWord.length;
+    if (!keepPrefix) {
+        length += self.foundPrefixRange.length;
+    }
+    
+    NSRange range = NSMakeRange(location, length);
+    NSRange insertionRange = [textView slk_insertText:string inRange:range];
+    
+    textView.selectedRange = NSMakeRange(insertionRange.location, 0);
+    
+    [self cancelAutoCompletion];
+    
+    [textView slk_scrollToCaretPositonAnimated:NO];
+}
+
+- (void)cancelAutoCompletion
+{
+    [self slk_invalidateAutoCompletion];
+    [self slk_hideAutoCompletionViewIfNeeded];
+}
+
+- (void)slk_processTextForAutoCompletion
+{
+    if (self.isTransitioning) {
+        return;
+    }
+    
+    // Avoids text processing for auto-completion if the registered prefix list is empty.
+    if (self.registeredPrefixes.count == 0) {
+        return;
+    }
+    
+    NSString *text = self.textView.text;
+    
+    // Skip, when there is no text to process
+    if (text.length == 0) {
+        return [self cancelAutoCompletion];
+    }
+    
+    NSRange range;
+    NSString *word = [self.textView slk_wordAtCaretRange:&range];
+    
+    [self slk_invalidateAutoCompletion];
+    
+    if (word.length > 0) {
+        
+        for (NSString *prefix in self.registeredPrefixes) {
+            if ([word hasPrefix:prefix]) {
+                // Captures the detected symbol prefix
+                _foundPrefix = prefix;
+                
+                // Used later for replacing the detected range with a new string alias returned in -acceptAutoCompletionWithString:
+                _foundPrefixRange = NSMakeRange(range.location, prefix.length);
+            }
+        }
+    }
+    
+    [self slk_handleProcessedWord:word range:range];
+}
+
+- (void)slk_handleProcessedWord:(NSString *)word range:(NSRange)range
+{
+    // Cancel auto-completion if the cursor is placed before the prefix
+    if (self.textView.selectedRange.location <= self.foundPrefixRange.location) {
+        return [self cancelAutoCompletion];
+    }
+    
+    if (self.foundPrefix.length > 0) {
+        if (range.length == 0 || range.length != word.length) {
+            return [self cancelAutoCompletion];
+        }
+        
+        if (word.length > 0) {
+            // Removes the found prefix
+            _foundWord = [word substringFromIndex:self.foundPrefix.length];
+            
+            // If the prefix is still contained in the word, cancels
+            if ([self.foundWord rangeOfString:self.foundPrefix].location != NSNotFound) {
+                return [self cancelAutoCompletion];
+            }
+        }
+        else {
+            return [self cancelAutoCompletion];
+        }
+    }
+    else {
+        return [self cancelAutoCompletion];
+    }
+    
+    [self didChangeAutoCompletionPrefix:self.foundPrefix andWord:self.foundWord];
+}
+
+- (void)slk_invalidateAutoCompletion
+{
+    _foundPrefix = nil;
+    _foundWord = nil;
+    _foundPrefixRange = NSMakeRange(0, 0);
+    
+    [self.autoCompletionView setContentOffset:CGPointZero];
+}
+
+- (void)slk_hideAutoCompletionViewIfNeeded
+{
+    if (self.isAutoCompleting) {
+        [self showAutoCompletionView:NO];
+    }
+}
+
+
+#pragma mark - Text Caching
+
+- (NSString *)keyForTextCaching
+{
+    // No implementation here. Meant to be overriden in subclass.
+    return nil;
+}
+
+- (NSString *)slk_keyForPersistency
+{
+    NSString *key = [self keyForTextCaching];
+    if (key == nil) {
+        return nil;
+    }
+    return [NSString stringWithFormat:@"%@.%@", SLKTextViewControllerDomain, key];
+}
+
+- (void)slk_reloadTextView
+{
+    NSString *key = [self slk_keyForPersistency];
+    if (key == nil) {
+        return;
+    }
+    NSString *cachedText = [[NSUserDefaults standardUserDefaults] objectForKey:key];
+    
+    if (self.textView.text.length == 0 || cachedText.length > 0) {
+        self.textView.text = cachedText;
+    }
+}
+
+- (void)slk_cacheTextView
+{
+    [self slk_cacheTextToDisk:self.textView.text];
+}
+
+- (void)clearCachedText
+{
+    [self slk_cacheTextToDisk:nil];
+}
+
+- (void)slk_cacheTextToDisk:(NSString *)text
+{
+    NSString *key = [self slk_keyForPersistency];
+    
+    if (!key || key.length == 0) {
+        return;
+    }
+    
+    NSString *cachedText = [[NSUserDefaults standardUserDefaults] objectForKey:key];
+    
+    // Caches text only if its a valid string and not already cached
+    if (text.length > 0 && ![text isEqualToString:cachedText]) {
+        [[NSUserDefaults standardUserDefaults] setObject:text forKey:key];
+    }
+    // Clears cache only if it exists
+    else if (text.length == 0 && cachedText.length > 0) {
+        [[NSUserDefaults standardUserDefaults] removeObjectForKey:key];
+    }
+    else {
+        // Skips so it doesn't hit 'synchronize' unnecessarily
+        return;
+    }
+    
+    [[NSUserDefaults standardUserDefaults] synchronize];
+}
+
++ (void)clearAllCachedText
+{
+    NSMutableArray *cachedKeys = [NSMutableArray new];
+    
+    for (NSString *key in [[[NSUserDefaults standardUserDefaults] dictionaryRepresentation] allKeys]) {
+        if ([key rangeOfString:SLKTextViewControllerDomain].location != NSNotFound) {
+            [cachedKeys addObject:key];
+        }
+    }
+    
+    if (cachedKeys.count == 0) {
+        return;
+    }
+    
+    for (NSString *cachedKey in cachedKeys) {
+        [[NSUserDefaults standardUserDefaults] removeObjectForKey:cachedKey];
+    }
+    
+    [[NSUserDefaults standardUserDefaults] synchronize];
+}
+
+
+#pragma mark - Customization
+
+- (void)registerClassForTextView:(Class)aClass
+{
+    if (aClass == nil) {
+        return;
+    }
+    
+    NSAssert([aClass isSubclassOfClass:[SLKTextView class]], @"The registered class is invalid, it must be a subclass of SLKTextView.");
+    self.textViewClass = aClass;
+}
+
+- (void)registerClassForTypingIndicatorView:(Class)aClass
+{
+    if (aClass == nil) {
+        return;
+    }
+    
+    NSAssert([aClass isSubclassOfClass:[UIView class]], @"The registered class is invalid, it must be a subclass of UIView.");
+    self.typingIndicatorViewClass = aClass;
+}
+
+
+#pragma mark - UITextViewDelegate Methods
+
+- (BOOL)textView:(SLKTextView *)textView shouldChangeTextInRange:(NSRange)range replacementText:(NSString *)text
+{
+    if (![textView isKindOfClass:[SLKTextView class]]) {
+        return YES;
+    }
+    
+    BOOL newWordInserted = ([text rangeOfCharacterFromSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]].location != NSNotFound);
+    
+    // It should not change if auto-completion is active and trying to replace with an auto-correction suggested text.
+    if (self.isAutoCompleting && text.length > 1) {
+        return NO;
+    }
+    
+    // Records text for undo for every new word
+    if (newWordInserted) {
+        [textView slk_prepareForUndo:@"Word Change"];
+    }
+    
+    // Detects double spacebar tapping, to replace the default "." insert with a formatting symbol, if needed.
+    if (textView.autoCompleteFormatting && range.location > 0 && [text length] > 0 &&
+        [[NSCharacterSet whitespaceCharacterSet] characterIsMember:[text characterAtIndex:0]] &&
+        [[NSCharacterSet whitespaceCharacterSet] characterIsMember:[textView.text characterAtIndex:range.location - 1]]) {
+        
+        BOOL shouldChange = YES;
+        
+        NSRange wordRange = range;
+        wordRange.location -= 2; // minus the white space added with the double space bar tapping
+        
+        NSArray *symbols = textView.registeredSymbols;
+        
+        NSMutableCharacterSet *invalidCharacters = [NSMutableCharacterSet new];
+        [invalidCharacters formUnionWithCharacterSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
+        [invalidCharacters formUnionWithCharacterSet:[NSCharacterSet punctuationCharacterSet]];
+        [invalidCharacters removeCharactersInString:[symbols componentsJoinedByString:@""]];
+        
+        for (NSString *symbol in symbols) {
+            
+            // Detects the closest registered symbol to the caret, from right to left
+            NSRange searchRange = NSMakeRange(0, wordRange.location);
+            NSRange prefixRange = [textView.text rangeOfString:symbol options:NSBackwardsSearch range:searchRange];
+            
+            if (prefixRange.location == NSNotFound) {
+                continue;
+            }
+            
+            NSRange nextCharRange = NSMakeRange(prefixRange.location+1, 1);
+            NSString *charAfterSymbol = [textView.text substringWithRange:nextCharRange];
+            
+            if (prefixRange.location != NSNotFound && ![invalidCharacters characterIsMember:[charAfterSymbol characterAtIndex:0]]) {
+                
+                if ([self textView:textView shouldInsertSuffixForFormattingWithSymbol:symbol prefixRange:prefixRange]) {
+                    
+                    NSRange suffixRange;
+                    [textView slk_wordAtRange:wordRange rangeInText:&suffixRange];
+                    
+                    // Skip if the detected word already has a suffix
+                    if ([[textView.text substringWithRange:suffixRange] hasSuffix:symbol]) {
+                        continue;
+                    }
+                    
+                    suffixRange.location += suffixRange.length;
+                    suffixRange.length = 0;
+                    
+                    NSString *lastCharacter = [textView.text substringWithRange:NSMakeRange(suffixRange.location, 1)];
+                    
+                    // Checks if the last character was a line break, so we append the symbol in the next line too
+                    if ([[NSCharacterSet newlineCharacterSet] characterIsMember:[lastCharacter characterAtIndex:0]]) {
+                        suffixRange.location += 1;
+                    }
+                    
+                    [textView slk_insertText:symbol inRange:suffixRange];
+                    shouldChange = NO;
+                    
+                    break; // exit
+                }
+            }
+        }
+        
+        return shouldChange;
+    }
+    else if ([text isEqualToString:@"\n"]) {
+        //Detected break. Should insert new line break programatically instead.
+        [textView slk_insertNewLineBreak];
+        
+        return NO;
+    }
+    else {
+        NSDictionary *userInfo = @{@"text": text, @"range": [NSValue valueWithRange:range]};
+        [[NSNotificationCenter defaultCenter] postNotificationName:SLKTextViewTextWillChangeNotification object:self.textView userInfo:userInfo];
+        
+        return YES;
+    }
+}
+
+- (void)textViewDidChange:(SLKTextView *)textView
+{
+    // Keep to avoid unnecessary crashes. Was meant to be overriden in subclass while calling super.
+}
+
+- (void)textViewDidChangeSelection:(SLKTextView *)textView
+{
+    // Keep to avoid unnecessary crashes. Was meant to be overriden in subclass while calling super.
+}
+
+- (BOOL)textViewShouldBeginEditing:(SLKTextView *)textView
+{
+    return YES;
+}
+
+- (BOOL)textViewShouldEndEditing:(SLKTextView *)textView
+{
+    return YES;
+}
+
+- (void)textViewDidBeginEditing:(SLKTextView *)textView
+{
+    // No implementation here. Meant to be overriden in subclass.
+}
+
+- (void)textViewDidEndEditing:(SLKTextView *)textView
+{
+    // No implementation here. Meant to be overriden in subclass.
+}
+
+
+#pragma mark - SLKTextViewDelegate Methods
+
+- (BOOL)textView:(SLKTextView *)textView shouldOfferFormattingForSymbol:(NSString *)symbol
+{
+    return YES;
+}
+
+- (BOOL)textView:(SLKTextView *)textView shouldInsertSuffixForFormattingWithSymbol:(NSString *)symbol prefixRange:(NSRange)prefixRange
+{
+    if (prefixRange.location > 0) {
+        NSRange previousCharRange = NSMakeRange(prefixRange.location-1, 1);
+        NSString *previousCharacter = [self.textView.text substringWithRange:previousCharRange];
+        
+        // Only insert a suffix if the character before the prefix was a whitespace or a line break
+        if ([previousCharacter rangeOfCharacterFromSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]].location != NSNotFound) {
+            return YES;
+        }
+        else {
+            return NO;
+        }
+    }
+    
+    return YES;
+}
+
+
+#pragma mark - UITableViewDataSource Methods
+
+- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
+{
+    return 0;
+}
+
+- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
+{
+    return nil;
+}
+
+
+#pragma mark - UICollectionViewDataSource Methods
+
+- (NSInteger)collectionView:(UICollectionView *)collectionView numberOfItemsInSection:(NSInteger)section;
+{
+    return 0;
+}
+
+- (UICollectionViewCell *)collectionView:(UICollectionView *)collectionView cellForItemAtIndexPath:(NSIndexPath *)indexPath
+{
+    return nil;
+}
+
+
+#pragma mark - UIScrollViewDelegate Methods
+
+- (BOOL)scrollViewShouldScrollToTop:(UIScrollView *)scrollView
+{
+    if (!self.scrollViewProxy.scrollsToTop || self.keyboardStatus == SLKKeyboardStatusWillShow) {
+        return NO;
+    }
+    
+    if (self.isInverted) {
+        [self.scrollViewProxy slk_scrollToBottomAnimated:YES];
+        return NO;
+    }
+    else {
+        return YES;
+    }
+}
+
+- (void)scrollViewDidEndDragging:(UIScrollView *)scrollView willDecelerate:(BOOL)decelerate
+{
+    self.movingKeyboard = NO;
+}
+
+- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView
+{
+    self.movingKeyboard = NO;
+}
+
+- (void)scrollViewDidScroll:(UIScrollView *)scrollView
+{
+    if ([scrollView isEqual:self.autoCompletionView]) {
+        CGRect frame = self.autoCompletionHairline.frame;
+        frame.origin.y = scrollView.contentOffset.y;
+        self.autoCompletionHairline.frame = frame;
+    }
+    else {
+        if (!self.isMovingKeyboard) {
+            _scrollViewOffsetBeforeDragging = scrollView.contentOffset;
+            _keyboardHeightBeforeDragging = self.keyboardHC.constant;
+        }
+    }
+}
+
+
+#pragma mark - UIGestureRecognizerDelegate Methods
+
+- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gesture
+{
+    if ([gesture isEqual:self.singleTapGesture]) {
+        return [self.textView isFirstResponder] && ![self ignoreTextInputbarAdjustment];
+    }
+    else if ([gesture isEqual:self.verticalPanGesture]) {
+        return self.keyboardPanningEnabled && ![self ignoreTextInputbarAdjustment];
+    }
+    
+    return NO;
+}
+
+
+#pragma mark - UIAlertViewDelegate Methods
+
+- (void)alertView:(UIAlertView *)alertView clickedButtonAtIndex:(NSInteger)buttonIndex
+{
+    if (alertView.tag != kSLKAlertViewClearTextTag || buttonIndex == [alertView cancelButtonIndex] ) {
+        return;
+    }
+    
+    // Clears the text but doesn't clear the undo manager
+    if (self.shakeToClearEnabled) {
+        [self.textView slk_clearText:NO];
+    }
+}
+
+
+#pragma mark - View Auto-Layout
+
+- (void)slk_setupViewConstraints
+{
+    NSDictionary *views = @{@"scrollView": self.scrollViewProxy,
+                            @"autoCompletionView": self.autoCompletionView,
+                            @"typingIndicatorView": self.typingIndicatorProxyView,
+                            @"textInputbar": self.textInputbar,
+                            };
+    
+    [self.view addConstraints:[NSLayoutConstraint constraintsWithVisualFormat:@"V:|[scrollView(0@750)][autoCompletionView(0@750)][typingIndicatorView(0)]-0@999-[textInputbar(0)]-0-|" options:0 metrics:nil views:views]];
+    [self.view addConstraints:[NSLayoutConstraint constraintsWithVisualFormat:@"H:|[scrollView]|" options:0 metrics:nil views:views]];
+    [self.view addConstraints:[NSLayoutConstraint constraintsWithVisualFormat:@"H:|[autoCompletionView]|" options:0 metrics:nil views:views]];
+    [self.view addConstraints:[NSLayoutConstraint constraintsWithVisualFormat:@"H:|[typingIndicatorView]|" options:0 metrics:nil views:views]];
+    [self.view addConstraints:[NSLayoutConstraint constraintsWithVisualFormat:@"H:|[textInputbar]|" options:0 metrics:nil views:views]];
+    
+    self.scrollViewHC = [self.view slk_constraintForAttribute:NSLayoutAttributeHeight firstItem:self.scrollViewProxy secondItem:nil];
+    self.autoCompletionViewHC = [self.view slk_constraintForAttribute:NSLayoutAttributeHeight firstItem:self.autoCompletionView secondItem:nil];
+    self.typingIndicatorViewHC = [self.view slk_constraintForAttribute:NSLayoutAttributeHeight firstItem:self.typingIndicatorProxyView secondItem:nil];
+    self.textInputbarHC = [self.view slk_constraintForAttribute:NSLayoutAttributeHeight firstItem:self.textInputbar secondItem:nil];
+    self.keyboardHC = [self.view slk_constraintForAttribute:NSLayoutAttributeBottom firstItem:self.view secondItem:self.textInputbar];
+    
+    [self slk_updateViewConstraints];
+}
+
+- (void)slk_updateViewConstraints
+{
+    self.textInputbarHC.constant = self.textInputbar.minimumInputbarHeight;
+    self.scrollViewHC.constant = [self slk_appropriateScrollViewHeight];
+    self.keyboardHC.constant = [self slk_appropriateKeyboardHeightFromRect:CGRectNull];
+    
+    if (self.textInputbar.isEditing) {
+        self.textInputbarHC.constant += self.textInputbar.editorContentViewHeight;
+    }
+    
+    [super updateViewConstraints];
+}
+
+
+#pragma mark - External Keyboard Support
+
+- (NSArray *)keyCommands
+{
+    NSMutableArray *keyboardCommands = [NSMutableArray new];
+    
+    [keyboardCommands addObject:[self slk_returnKeyCommand]];
+    [keyboardCommands addObject:[self slk_escKeyCommand]];
+    [keyboardCommands addObject:[self slk_arrowKeyCommand:UIKeyInputUpArrow]];
+    [keyboardCommands addObject:[self slk_arrowKeyCommand:UIKeyInputDownArrow]];
+    
+    return keyboardCommands;
+}
+
+- (UIKeyCommand *)slk_returnKeyCommand
+{
+    UIKeyCommand *command = [UIKeyCommand keyCommandWithInput:@"\r" modifierFlags:0 action:@selector(didPressReturnKey:)];
+    
+#ifdef __IPHONE_9_0
+    if ([UIKeyCommand respondsToSelector:@selector(keyCommandWithInput:modifierFlags:action:discoverabilityTitle:)] ) {
+        // Only available since iOS 9
+        if (self.textInputbar.isEditing) {
+            command.discoverabilityTitle = [self.textInputbar.editorRightButton titleForState:UIControlStateNormal] ? : NSLocalizedString(@"Commit Editing", nil);
+        }
+        else if (self.textView.text.length > 0) {
+            command.discoverabilityTitle = [self.rightButton titleForState:UIControlStateNormal] ? : NSLocalizedString(@"Send", nil);
+        }
+    }
+#endif
+    
+    return command;
+}
+
+- (UIKeyCommand *)slk_escKeyCommand
+{
+    UIKeyCommand *command = [UIKeyCommand keyCommandWithInput:UIKeyInputEscape modifierFlags:0 action:@selector(didPressEscapeKey:)];
+    
+#ifdef __IPHONE_9_0
+    if ([UIKeyCommand respondsToSelector:@selector(keyCommandWithInput:modifierFlags:action:discoverabilityTitle:)] ) {
+        // Only available since iOS 9
+        if (self.isAutoCompleting) {
+            command.discoverabilityTitle = NSLocalizedString(@"Exit Auto-Completion", nil);
+        }
+        else if (self.textInputbar.isEditing) {
+            command.discoverabilityTitle = [self.textInputbar.editorRightButton titleForState:UIControlStateNormal] ? : NSLocalizedString(@"Exit Editing", nil);
+        }
+        else if (!self.isExternalKeyboardDetected && self.keyboardHC.constant != 0) {
+            command.discoverabilityTitle = NSLocalizedString(@"Hide Keyboard", nil);
+        }
+    }
+#endif
+    
+    return command;
+}
+
+- (UIKeyCommand *)slk_arrowKeyCommand:(NSString *)inputUpArrow
+{
+    UIKeyCommand *command = [UIKeyCommand keyCommandWithInput:inputUpArrow modifierFlags:0 action:@selector(didPressArrowKey:)];
+    
+#ifdef __IPHONE_9_0
+    // Only available since iOS 9
+    if ([UIKeyCommand respondsToSelector:@selector(keyCommandWithInput:modifierFlags:action:discoverabilityTitle:)] ) {
+        if ([inputUpArrow isEqualToString:UIKeyInputUpArrow]) {
+            command.discoverabilityTitle = NSLocalizedString(@"Move Up", nil);
+        }
+        if ([inputUpArrow isEqualToString:UIKeyInputDownArrow]) {
+            command.discoverabilityTitle = NSLocalizedString(@"Move Down", nil);
+        }
+    }
+#endif
+    
+    return command;
+}
+
+
+#pragma mark - NSNotificationCenter register/unregister
+
+- (void)slk_registerNotifications
+{
+    [self slk_unregisterNotifications];
+    
+    // Keyboard notifications
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(slk_willShowOrHideKeyboard:) name:UIKeyboardWillShowNotification object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(slk_willShowOrHideKeyboard:) name:UIKeyboardWillHideNotification object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(slk_didShowOrHideKeyboard:) name:UIKeyboardDidShowNotification object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(slk_didShowOrHideKeyboard:) name:UIKeyboardDidHideNotification object:nil];
+    
+#if SLK_KEYBOARD_NOTIFICATION_DEBUG
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(slk_didPostSLKKeyboardNotification:) name:SLKKeyboardWillShowNotification object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(slk_didPostSLKKeyboardNotification:) name:SLKKeyboardDidShowNotification object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(slk_didPostSLKKeyboardNotification:) name:SLKKeyboardWillHideNotification object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(slk_didPostSLKKeyboardNotification:) name:SLKKeyboardDidHideNotification object:nil];
+#endif
+    
+    // TextView notifications
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(slk_willChangeTextViewText:) name:SLKTextViewTextWillChangeNotification object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(slk_didChangeTextViewText:) name:UITextViewTextDidChangeNotification object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(slk_didChangeTextViewContentSize:) name:SLKTextViewContentSizeDidChangeNotification object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(slk_didChangeTextViewSelectedRange:) name:SLKTextViewSelectedRangeDidChangeNotification object:nil];
+    
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(slk_didChangeTextViewPasteboard:) name:SLKTextViewDidPasteItemNotification object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(slk_didShakeTextView:) name:SLKTextViewDidShakeNotification object:nil];
+    
+    // Application notifications
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(slk_willTerminateApplication:) name:UIApplicationWillTerminateNotification object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(slk_willTerminateApplication:) name:UIApplicationDidReceiveMemoryWarningNotification object:nil];
+}
+
+- (void)slk_unregisterNotifications
+{
+    // Keyboard notifications
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:UIKeyboardWillShowNotification object:nil];
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:UIKeyboardWillHideNotification object:nil];
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:UIKeyboardDidShowNotification object:nil];
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:UIKeyboardDidHideNotification object:nil];
+    
+#if SLK_KEYBOARD_NOTIFICATION_DEBUG
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:SLKKeyboardWillShowNotification object:nil];
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:SLKKeyboardDidShowNotification object:nil];
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:SLKKeyboardWillHideNotification object:nil];
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:SLKKeyboardDidHideNotification object:nil];
+#endif
+    
+    // TextView notifications
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:UITextViewTextDidBeginEditingNotification object:nil];
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:UITextViewTextDidEndEditingNotification object:nil];
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:SLKTextViewTextWillChangeNotification object:nil];
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:UITextViewTextDidChangeNotification object:nil];
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:SLKTextViewContentSizeDidChangeNotification object:nil];
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:SLKTextViewSelectedRangeDidChangeNotification object:nil];
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:SLKTextViewDidPasteItemNotification object:nil];
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:SLKTextViewDidShakeNotification object:nil];
+    
+    // Application notifications
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:UIApplicationWillTerminateNotification object:nil];
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:UIApplicationDidReceiveMemoryWarningNotification object:nil];
+}
+
+
+#pragma mark - View Auto-Rotation
+
+#ifdef __IPHONE_8_0
+- (void)willTransitionToTraitCollection:(UITraitCollection *)newCollection withTransitionCoordinator:(id <UIViewControllerTransitionCoordinator>)coordinator
+{
+    [super willTransitionToTraitCollection:newCollection withTransitionCoordinator:coordinator];
+}
+
+- (void)viewWillTransitionToSize:(CGSize)size withTransitionCoordinator:(id<UIViewControllerTransitionCoordinator>)coordinator
+{
+    [self slk_prepareForInterfaceTransitionWithDuration:coordinator.transitionDuration];
+    
+    [super viewWillTransitionToSize:size withTransitionCoordinator:coordinator];
+}
+#else
+- (void)willRotateToInterfaceOrientation:(UIInterfaceOrientation)toInterfaceOrientation duration:(NSTimeInterval)duration
+{
+    if ([self respondsToSelector:@selector(viewWillTransitionToSize:withTransitionCoordinator:)]) {
+        return;
+    }
+    
+    [self slk_prepareForInterfaceTransitionWithDuration:duration];
+}
+#endif
+
+#ifdef __IPHONE_9_0
+- (UIInterfaceOrientationMask)supportedInterfaceOrientations
+#else
+- (NSUInteger)supportedInterfaceOrientations
+#endif
+{
+    return UIInterfaceOrientationMaskAll;
+}
+
+- (BOOL)shouldAutorotate
+{
+    return YES;
+}
+
+
+#pragma mark - View lifeterm
+
+- (void)didReceiveMemoryWarning
+{
+    [super didReceiveMemoryWarning];
+}
+
+- (void)dealloc
+{
+    _tableView.delegate = nil;
+    _tableView.dataSource = nil;
+    _tableView = nil;
+    
+    _collectionView.delegate = nil;
+    _collectionView.dataSource = nil;
+    _collectionView = nil;
+    
+    _scrollView = nil;
+    
+    _autoCompletionView.delegate = nil;
+    _autoCompletionView.dataSource = nil;
+    _autoCompletionView = nil;
+    
+    _textInputbar.textView.delegate = nil;
+    _textInputbar = nil;
+    _textViewClass = nil;
+    
+    [_typingIndicatorProxyView removeObserver:self forKeyPath:@"visible"];
+    _typingIndicatorProxyView = nil;
+    _typingIndicatorViewClass = nil;
+    
+    _registeredPrefixes = nil;
+    _singleTapGesture.delegate = nil;
+    _singleTapGesture = nil;
+    _verticalPanGesture.delegate = nil;
+    _verticalPanGesture = nil;
+    _scrollViewHC = nil;
+    _textInputbarHC = nil;
+    _typingIndicatorViewHC = nil;
+    _autoCompletionViewHC = nil;
+    _keyboardHC = nil;
+    
+    [self slk_unregisterNotifications];
+}
+
+@end

http://git-wip-us.apache.org/repos/asf/usergrid/blob/7442c881/sdks/swift/Samples/ActivityFeed/Pods/SlackTextViewController/Source/SLKTypingIndicatorProtocol.h
----------------------------------------------------------------------
diff --git a/sdks/swift/Samples/ActivityFeed/Pods/SlackTextViewController/Source/SLKTypingIndicatorProtocol.h b/sdks/swift/Samples/ActivityFeed/Pods/SlackTextViewController/Source/SLKTypingIndicatorProtocol.h
new file mode 100644
index 0000000..7b2deae
--- /dev/null
+++ b/sdks/swift/Samples/ActivityFeed/Pods/SlackTextViewController/Source/SLKTypingIndicatorProtocol.h
@@ -0,0 +1,37 @@
+//
+//   Copyright 2014 Slack Technologies, Inc.
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+//
+
+#import <Foundation/Foundation.h>
+
+/** Generic protocol needed when customizing your own typing indicator view. */
+@protocol SLKTypingIndicatorProtocol <NSObject>
+@required
+
+/**
+ Returns YES if the indicator is visible.
+ SLKTextViewController depends on this property internally, by observing its value changes to update the typing indicator view's constraints automatically.
+ You can simply @synthesize this property to make it KVO compliant, or override its setter method and wrap its implementation with -willChangeValueForKey: and -didChangeValueForKey: methods, for more complex KVO compliance.
+ */
+@property (nonatomic, getter = isVisible) BOOL visible;
+
+@optional
+
+/**
+ Dismisses the indicator view.
+ */
+- (void)dismissIndicator;
+
+@end
\ No newline at end of file


Mime
View raw message