Κάνοντας μια περγαμηνή UITableView όταν έχει επιλεγεί το πεδίο κειμένου

Εάν χρησιμοποιείτε UITableViewController αντί UIViewController, θα κάνει αυτόματα έτσι.

Η λειτουργία που κάνει την κύλιση θα μπορούσε να είναι πολύ πιο απλή:

- (void) textFieldDidBeginEditing:(UITextField *)textField {
    UITableViewCell *cell;

    if (floor(NSFoundationVersionNumber) <= NSFoundationVersionNumber_iOS_6_1) {
    // Load resources for iOS 6.1 or earlier
        cell = (UITableViewCell *) textField.superview.superview;

    } else {
        // Load resources for iOS 7 or later
        cell = (UITableViewCell *) textField.superview.superview.superview; 
       // TextField -> UITableVieCellContentView -> (in iOS 7!)ScrollView -> Cell!
    }
    [tView scrollToRowAtIndexPath:[tView indexPathForCell:cell] atScrollPosition:UITableViewScrollPositionTop animated:YES];
}

Αυτό είναι. Δεν υπολογισμούς καθόλου.

Κάνω κάτι παρόμοιο είναι γενική, δεν χρειάζεται να υπολογίσουμε κάτι συγκεκριμένο για τον κωδικό σας. Απλά ελέγξτε τις παρατηρήσεις σχετικά με τον κωδικό:

Σε MyUIViewController.h

@interface MyUIViewController: UIViewController <UITableViewDelegate, UITableViewDataSource>
{
     UITableView *myTableView;
     UITextField *actifText;
}

@property (nonatomic, retain) IBOutlet UITableView *myTableView;
@property (nonatomic, retain) IBOutlet UITextField *actifText;

- (IBAction)textFieldDidBeginEditing:(UITextField *)textField;
- (IBAction)textFieldDidEndEditing:(UITextField *)textField;

-(void) keyboardWillHide:(NSNotification *)note;
-(void) keyboardWillShow:(NSNotification *)note;

@end

Σε MyUIViewController.m

@implementation MyUIViewController

@synthesize myTableView;
@synthesize actifText;

- (void)viewDidLoad 
{
    // Register notification when the keyboard will be show
    [[NSNotificationCenter defaultCenter] addObserver:self
                                          selector:@selector(keyboardWillShow:)
                                          name:UIKeyboardWillShowNotification
                                          object:nil];

    // Register notification when the keyboard will be hide
    [[NSNotificationCenter defaultCenter] addObserver:self
                                          selector:@selector(keyboardWillHide:)
                                          name:UIKeyboardWillHideNotification
                                          object:nil];
}

// To be link with your TextField event "Editing Did Begin"
//  memoryze the current TextField
- (IBAction)textFieldDidBeginEditing:(UITextField *)textField
{
    self.actifText = textField;
}

// To be link with your TextField event "Editing Did End"
//  release current TextField
- (IBAction)textFieldDidEndEditing:(UITextField *)textField
{
    self.actifText = nil;
}

-(void) keyboardWillShow:(NSNotification *)note
{
    // Get the keyboard size
    CGRect keyboardBounds;
    [[note.userInfo valueForKey:UIKeyboardFrameBeginUserInfoKey] getValue: &keyboardBounds];

    // Detect orientation
    UIInterfaceOrientation orientation = [[UIApplication sharedApplication] statusBarOrientation];
    CGRect frame = self.myTableView.frame;

    // Start animation
    [UIView beginAnimations:nil context:NULL];
    [UIView setAnimationBeginsFromCurrentState:YES];
    [UIView setAnimationDuration:0.3f];

    // Reduce size of the Table view 
    if (orientation == UIInterfaceOrientationPortrait || orientation == UIInterfaceOrientationPortraitUpsideDown)
        frame.size.height -= keyboardBounds.size.height;
    else 
        frame.size.height -= keyboardBounds.size.width;

    // Apply new size of table view
    self.myTableView.frame = frame;

    // Scroll the table view to see the TextField just above the keyboard
    if (self.actifText)
      {
        CGRect textFieldRect = [self.myTableView convertRect:self.actifText.bounds fromView:self.actifText];
        [self.myTableView scrollRectToVisible:textFieldRect animated:NO];
      }

    [UIView commitAnimations];
}

-(void) keyboardWillHide:(NSNotification *)note
{
    // Get the keyboard size
    CGRect keyboardBounds;
    [[note.userInfo valueForKey:UIKeyboardFrameBeginUserInfoKey] getValue: &keyboardBounds];

    // Detect orientation
    UIInterfaceOrientation orientation = [[UIApplication sharedApplication] statusBarOrientation];
    CGRect frame = self.myTableView.frame;

    [UIView beginAnimations:nil context:NULL];
    [UIView setAnimationBeginsFromCurrentState:YES];
    [UIView setAnimationDuration:0.3f];

    // Increase size of the Table view 
    if (orientation == UIInterfaceOrientationPortrait || orientation == UIInterfaceOrientationPortraitUpsideDown)
        frame.size.height += keyboardBounds.size.height;
    else 
        frame.size.height += keyboardBounds.size.width;

    // Apply new size of table view
    self.myTableView.frame = frame;

    [UIView commitAnimations];
}

@end

Swift 1.2+ έκδοση:

class ViewController: UIViewController, UITextFieldDelegate {
    @IBOutlet weak var activeText: UITextField!
    @IBOutlet weak var tableView: UITableView!

    override func viewDidLoad() {
        NSNotificationCenter.defaultCenter().addObserver(self,
            selector: Selector("keyboardWillShow:"),
            name: UIKeyboardWillShowNotification,
            object: nil)
        NSNotificationCenter.defaultCenter().addObserver(self,
            selector: Selector("keyboardWillHide:"),
            name: UIKeyboardWillHideNotification,
            object: nil)
    }

    func textFieldDidBeginEditing(textField: UITextField) {
        activeText = textField
    }

    func textFieldDidEndEditing(textField: UITextField) {
        activeText = nil
    }

    func keyboardWillShow(note: NSNotification) {
        if let keyboardSize = (note.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
            var frame = tableView.frame
            UIView.beginAnimations(nil, context: nil)
            UIView.setAnimationBeginsFromCurrentState(true)
            UIView.setAnimationDuration(0.3)
            frame.size.height -= keyboardSize.height
            tableView.frame = frame
            if activeText != nil {
                let rect = tableView.convertRect(activeText.bounds, fromView: activeText)
                tableView.scrollRectToVisible(rect, animated: false)
            }
            UIView.commitAnimations()
        }
    }

    func keyboardWillHide(note: NSNotification) {
        if let keyboardSize = (note.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
            var frame = tableView.frame
            UIView.beginAnimations(nil, context: nil)
            UIView.setAnimationBeginsFromCurrentState(true)
            UIView.setAnimationDuration(0.3)
            frame.size.height += keyboardSize.height
            tableView.frame = frame
            UIView.commitAnimations()
        }
    }
}

Είχα το ίδιο πρόβλημα, αλλά παρατήρησα ότι εμφανίζεται μόνο σε μία προβολή. Έτσι άρχισα να ψάξουν για τις διαφορές των ελεγκτών.

Ανακάλυψα ότι η κύλιση συμπεριφορά βρίσκεται στο - (void)viewWillAppear:(BOOL)animatedτου σούπερ παράδειγμα.

Ώστε να είναι σίγουρος για την εφαρμογή της ως εξής:

- (void)viewWillAppear:(BOOL)animated {
    [super viewWillAppear:animated];
    // your code
}

Και δεν έχει σημασία αν χρησιμοποιείτε UIViewControllerή UITableViewController? ελέγχεται ότι βάζοντας ένα UITableViewως δευτερεύουσας προβολής της self.view στο UIViewController. Ήταν η ίδια συμπεριφορά. Η θέα δεν επιτρέπουν να μετακινηθείτε αν η κλήση [super viewWillAppear:animated];έλειπε.

μπορεί να είχα χάσει αυτό, όπως δεν είχα διαβάσει ολόκληρο το post εδώ, αλλά αυτό που ήρθε με φαίνεται απατηλά απλό. δεν έχω θέσει αυτό μέσα από το στραγγιστό, τον έλεγχο σε όλες τις καταστάσεις, αλλά φαίνεται ότι θα πρέπει να λειτουργεί μια χαρά.

απλά ρυθμίστε το contentInset της TableView από το ύψος του πληκτρολογίου, και στη συνέχεια κύλιση του κυττάρου προς τα κάτω:

- (void)keyboardWasShown:(NSNotification *)aNotification
{
    NSDictionary* info = [aNotification userInfo];
    CGSize kbSize = [[info objectForKey:UIKeyboardFrameBeginUserInfoKey] CGRectValue].size;

    UIEdgeInsets contentInsets = UIEdgeInsetsMake(0.0, 0.0, kbSize.height, 0.0);
    self.myTableView.contentInset = contentInsets;
    self.myTableView.scrollIndicatorInsets = contentInsets;

    [self.myTableView scrollToRowAtIndexPath:self.currentField.indexPath atScrollPosition:UITableViewScrollPositionBottom animated:YES];
}

και φυσικά

- (void)keyboardWasHidden:(NSNotification *)aNotification
{
    [UIView animateWithDuration:.3 animations:^(void) 
    {
        self.myTableView.contentInset = UIEdgeInsetsZero;
        self.myTableView.scrollIndicatorInsets = UIEdgeInsetsZero;
    }];
}

Είναι αυτό το πάρα πολύ απλό; είμαι εγώ λείπει κάτι; μέχρι τώρα δουλεύει για μένα μια χαρά, αλλά όπως είπα, δεν το έχω βάλει μέσα από το στραγγιστό ...

Η απλούστερη λύση για Swift 3 , βασίζεται σε διάλυμα Bartłomiej Semańczyk :

override func viewDidLoad() {
    super.viewDidLoad()

    NotificationCenter.default.addObserver(self, selector: #selector(CreateEditRitualViewController.keyboardWillShow(notification:)), name: NSNotification.Name.UIKeyboardDidShow, object: nil)
    NotificationCenter.default.addObserver(self, selector: #selector(CreateEditRitualViewController.keyboardWillHide(notification:)), name: NSNotification.Name.UIKeyboardDidHide, object: nil)
}

deinit {
    NotificationCenter.default.removeObserver(self)
}

// MARK: Keyboard Notifications

@objc func keyboardWillShow(notification: NSNotification) {
    if let keyboardHeight = (notification.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue.height {
        tableView.contentInset = UIEdgeInsetsMake(0, 0, keyboardHeight, 0)
    }
}

@objc func keyboardWillHide(notification: NSNotification) {
    UIView.animate(withDuration: 0.2, animations: {
        // For some reason adding inset in keyboardWillShow is animated by itself but removing is not, that's why we have to use animateWithDuration here
        self.tableView.contentInset = UIEdgeInsetsMake(0, 0, 0, 0)
    })
}

Εάν μπορείτε να χρησιμοποιήσετε UITableViewController, μπορείτε να πάρετε τη λειτουργικότητα δωρεάν. Μερικές φορές, όμως, αυτό δεν είναι μια επιλογή, ειδικά αν χρειάζεστε πολλαπλών προβολών όχι μόνο το UITableView.

Μερικές από τις λύσεις που παρουσιάζονται εδώ δεν λειτουργούν σε iOS ≥4, κάποια δεν λειτουργούν στο iPad ή σε οριζόντια διάταξη, κάποια δεν λειτουργούν για πληκτρολόγια Bluetooth (όπου δεν θέλουμε οποιαδήποτε κύλιση), μερικοί δεν το κάνουν λειτουργούν κατά την εναλλαγή μεταξύ πολλαπλά πεδία κειμένου. Έτσι, αν επιλέξετε οποιαδήποτε λύση, φροντίστε να ελέγξετε αυτές τις περιπτώσεις. Αυτή είναι η λύση που χρησιμοποιούμε χρησιμοποιούνται στην InAppSettingsKit :

- (void)_keyboardWillShow:(NSNotification*)notification {
    if (self.navigationController.topViewController == self) {
        NSDictionary* userInfo = [notification userInfo];

        // we don't use SDK constants here to be universally compatible with all SDKs ≥ 3.0
        NSValue* keyboardFrameValue = [userInfo objectForKey:@"UIKeyboardBoundsUserInfoKey"];
        if (!keyboardFrameValue) {
            keyboardFrameValue = [userInfo objectForKey:@"UIKeyboardFrameEndUserInfoKey"];
        }

        // Reduce the tableView height by the part of the keyboard that actually covers the tableView
        CGRect windowRect = [[UIApplication sharedApplication] keyWindow].bounds;
        if (UIInterfaceOrientationLandscapeLeft == self.interfaceOrientation ||UIInterfaceOrientationLandscapeRight == self.interfaceOrientation ) {
            windowRect = IASKCGRectSwap(windowRect);
        }
        CGRect viewRectAbsolute = [_tableView convertRect:_tableView.bounds toView:[[UIApplication sharedApplication] keyWindow]];
        if (UIInterfaceOrientationLandscapeLeft == self.interfaceOrientation ||UIInterfaceOrientationLandscapeRight == self.interfaceOrientation ) {
            viewRectAbsolute = IASKCGRectSwap(viewRectAbsolute);
        }
        CGRect frame = _tableView.frame;
        frame.size.height -= [keyboardFrameValue CGRectValue].size.height - CGRectGetMaxY(windowRect) + CGRectGetMaxY(viewRectAbsolute);

        [UIView beginAnimations:nil context:NULL];
        [UIView setAnimationDuration:[[userInfo objectForKey:UIKeyboardAnimationDurationUserInfoKey] doubleValue]];
        [UIView setAnimationCurve:[[userInfo objectForKey:UIKeyboardAnimationCurveUserInfoKey] intValue]];
        _tableView.frame = frame;
        [UIView commitAnimations];

        UITableViewCell *textFieldCell = (id)((UITextField *)self.currentFirstResponder).superview.superview;
        NSIndexPath *textFieldIndexPath = [_tableView indexPathForCell:textFieldCell];

        // iOS 3 sends hide and show notifications right after each other
        // when switching between textFields, so cancel -scrollToOldPosition requests
        [NSObject cancelPreviousPerformRequestsWithTarget:self];

        [_tableView scrollToRowAtIndexPath:textFieldIndexPath atScrollPosition:UITableViewScrollPositionMiddle animated:YES];
    }
}

- (void) scrollToOldPosition {
  [_tableView scrollToRowAtIndexPath:_topmostRowBeforeKeyboardWasShown atScrollPosition:UITableViewScrollPositionTop animated:YES];
}

- (void)_keyboardWillHide:(NSNotification*)notification {
    if (self.navigationController.topViewController == self) {
        NSDictionary* userInfo = [notification userInfo];

        [UIView beginAnimations:nil context:NULL];
        [UIView setAnimationDuration:[[userInfo objectForKey:UIKeyboardAnimationDurationUserInfoKey] doubleValue]];
        [UIView setAnimationCurve:[[userInfo objectForKey:UIKeyboardAnimationCurveUserInfoKey] intValue]];
        _tableView.frame = self.view.bounds;
        [UIView commitAnimations];

        [self performSelector:@selector(scrollToOldPosition) withObject:nil afterDelay:0.1];
    }
}   

Εδώ είναι ο πλήρης κωδικός της κατηγορίας σε InAppSettingsKit. Για να το ελέγξετε, χρησιμοποιήστε το «Πλήρης κατάλογος» παράθυρο παιδί, όπου μπορείτε να δοκιμάσετε τα σενάρια που αναφέρονται παραπάνω.

Νομίζω ότι έχω καταλήξει σε λύση για να ταιριάζει με τη συμπεριφορά των εφαρμογών της Apple.

Κατ 'αρχάς, το viewWillAppear σας: εγγραφείτε στις κοινοποιήσεις πληκτρολόγιο, ώστε να γνωρίζετε πότε το πληκτρολόγιο θα εμφανίσετε και να αποκρύψετε, και το σύστημα θα σας πω το μέγεθος του πληκτρολογίου, αλλά μην»ξεχάσετε να καταργήσετε το viewWillDisappear σας :.

[[NSNotificationCenter defaultCenter]
    addObserver:self
       selector:@selector(keyboardWillShow:)
           name:UIKeyboardWillShowNotification
         object:nil];
[[NSNotificationCenter defaultCenter]
    addObserver:self
       selector:@selector(keyboardWillHide:)
           name:UIKeyboardWillHideNotification
         object:nil];

Εφαρμογή των μεθόδων παρόμοιο με το παρακάτω έτσι ώστε να μπορείτε να προσαρμόσετε το μέγεθος της TableView σας για να ταιριάζει με την ορατή περιοχή μία φορά δείχνει το πληκτρολόγιο. Εδώ είμαι παρακολουθεί την κατάσταση του πληκτρολογίου ξεχωριστά ώστε να μπορώ να επιλέξει πότε να ρυθμίσετε το TableView πίσω στο πλήρες ύψος εαυτό μου, δεδομένου ότι μπορείτε να πάρετε αυτές τις ειδοποιήσεις για κάθε αλλαγή γηπέδου. Μην ξεχάσετε να εφαρμόσει keyboardWillHide: και επιλέξτε κάπου σκόπιμο να καθοριστεί το μέγεθος σας TableView.

-(void) keyboardWillShow:(NSNotification *)note
{
    CGRect keyboardBounds;
    [[note.userInfo valueForKey:UIKeyboardBoundsUserInfoKey] getValue: &keyboardBounds];
    keyboardHeight = keyboardBounds.size.height;
    if (keyboardIsShowing == NO)
    {
        keyboardIsShowing = YES;
        CGRect frame = self.view.frame;
        frame.size.height -= keyboardHeight;

        [UIView beginAnimations:nil context:NULL];
        [UIView setAnimationBeginsFromCurrentState:YES];
        [UIView setAnimationDuration:0.3f];
        self.view.frame = frame;
        [UIView commitAnimations];
    }
}

Τώρα εδώ είναι το bit κύλιση, δουλεύουμε έξω μερικά μεγέθη πρώτα, και μετά θα δούμε πού βρισκόμαστε στην ορατή περιοχή, και που με την Οδηγία θέλουμε να μεταβείτε στην επιλογή να είναι είτε το μισό θέα πάνω ή κάτω από το κέντρο του γηπέδου κειμένου με βάση σχετικά με το πού είναι κατά την άποψη. Σε αυτή την περίπτωση, έχουμε μια σειρά από UITextFields και ένα enum που παρακολουθεί τους, έτσι τον πολλαπλασιασμό του rowHeight από τον αριθμό σειράς μας δίνει την πραγματική μετατόπιση του πλαισίου εντός αυτού του εξωτερικού άποψη.

- (void) textFieldDidBeginEditing:(UITextField *)textField
{
    CGRect frame = textField.frame;
    CGFloat rowHeight = self.tableView.rowHeight;
    if (textField == textFields[CELL_FIELD_ONE])
    {
        frame.origin.y += rowHeight * CELL_FIELD_ONE;
    }
    else if (textField == textFields[CELL_FIELD_TWO])
    {
        frame.origin.y += rowHeight * CELL_FIELD_TWO;
    }
    else if (textField == textFields[CELL_FIELD_THREE])
    {
        frame.origin.y += rowHeight * CELL_FIELD_THREE;
    }
    else if (textField == textFields[CELL_FIELD_FOUR])
    {
        frame.origin.y += rowHeight * CELL_FIELD_FOUR;
    }
    CGFloat viewHeight = self.tableView.frame.size.height;
    CGFloat halfHeight = viewHeight / 2;
    CGFloat midpoint = frame.origin.y + (textField.frame.size.height / 2);
    if (midpoint < halfHeight)
    {
        frame.origin.y = 0;
        frame.size.height = midpoint;
    }
    else
    {
        frame.origin.y = midpoint;
        frame.size.height = midpoint;
    }
    [self.tableView scrollRectToVisible:frame animated:YES];
}

Αυτό φαίνεται να λειτουργεί αρκετά καλά.

Η απλούστερη λύση για Swift :

override func viewDidLoad() {
    super.viewDidLoad()

    searchBar?.becomeFirstResponder()
    NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(MyViewController.keyboardWillShow(_:)), name: UIKeyboardDidShowNotification, object: nil)
    NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(MyViewController.keyboardWillHide(_:)), name: UIKeyboardDidHideNotification, object: nil)
}

deinit {
    NSNotificationCenter.defaultCenter().removeObserver(self)
}

func keyboardWillShow(notification: NSNotification) {
    if let userInfo = notification.userInfo {
        if let keyboardHeight = userInfo[UIKeyboardFrameEndUserInfoKey]?.CGRectValue.size.height {
            tableView.contentInset = UIEdgeInsetsMake(0, 0, keyboardHeight, 0)
        }
    }
}

func keyboardWillHide(notification: NSNotification) {
    UIView.animateWithDuration(0.2, animations: { self.table_create_issue.contentInset = UIEdgeInsetsMake(0, 0, 0, 0) })
    // For some reason adding inset in keyboardWillShow is animated by itself but removing is not, that's why we have to use animateWithDuration here
    }

Ελπίζω εσείς ήδη μια λύση ανάγνωση όλων εκείνων. Αλλά βρήκα λύση μου ως εξής. Περιμένω ότι έχετε ήδη ένα κελί με UITextField. Έτσι, για την προετοιμασία απλά να κρατήσει το δείκτη σειράς στην ετικέτα του πεδίου κειμένου.

cell.textField.tag = IndexPath.row;

Δημιουργία activeTextField, παρουσία του UITextFieldμε παγκόσμια εμβέλεια, όπως παρακάτω:

@interface EditViewController (){

    UITextField *activeTextField;

}

Έτσι, τώρα μπορείτε απλά να αντιγράψετε επικολλήσετε τον κωδικό μου στο τέλος. Και επίσης μην ξεχάσετε να προσθέσετεUITextFieldDelegate

#pragma mark - TextField Delegation

- (BOOL)textFieldShouldBeginEditing:(UITextField *)textField{

    activeTextField = textField;

    return YES;
}

- (void)textFieldDidEndEditing:(UITextField *)textField{

    activeTextField = nil;

}

πληκτρολόγιο μητρώα notifications

#pragma mark - Keyboard Activity

- (void)registerForKeyboardNotifications

{

    [[NSNotificationCenter defaultCenter] addObserver:self

                                         selector:@selector(keyboardWasShown:)

                                             name:UIKeyboardDidShowNotification object:nil];



    [[NSNotificationCenter defaultCenter] addObserver:self

                                         selector:@selector(keyboardWillBeHidden:)

                                             name:UIKeyboardWillHideNotification object:nil];



}

Λαβές πληκτρολογίου Notifications:

Ονομάζεται όταν η UIKeyboardDidShowNotificationαποστολή.

- (void)keyboardWasShown:(NSNotification*)aNotification

{

    NSDictionary* info = [aNotification userInfo];

    CGSize kbSize = [[info objectForKey:UIKeyboardFrameBeginUserInfoKey] CGRectValue].size;

    UIEdgeInsets contentInsets = UIEdgeInsetsMake(0.0, 0.0, kbSize.height, 0.0);

    [self.tableView setContentInset:contentInsets];

    [self.tableView setScrollIndicatorInsets:contentInsets];

    NSIndexPath *currentRowIndex = [NSIndexPath indexPathForRow:activeTextField.tag inSection:0];

    [self.tableView scrollToRowAtIndexPath:currentRowIndex atScrollPosition:UITableViewScrollPositionTop animated:YES];

}

Ονομάζεται όταν η UIKeyboardWillHideNotificationαποστολή

- (void)keyboardWillBeHidden:(NSNotification*)aNotification

{

    UIEdgeInsets contentInsets = UIEdgeInsetsZero;

    [self.tableView setContentInset:contentInsets];

    [self.tableView setScrollIndicatorInsets:contentInsets];

}

Τώρα, ένα πράγμα είναι αριστερά, Καλέστε την registerForKeyboardNotificationsμέθοδο για να ViewDidLoadμέθοδο ως εξής:

- (void)viewDidLoad {

    [super viewDidLoad];

    // Registering keyboard notification

    [self registerForKeyboardNotifications];

    // Your codes here...

}

Θα γίνονται, ελπίζω σας textFieldsθέληση κρύβεται πλέον από το πληκτρολόγιο.

Συνδυάζοντας και συμπληρώνοντας τα κενά από διάφορες απαντήσεις (ιδίως Ortwin Gentz ​​χρήστη 98013) και άλλη θέση, αυτό θα λειτουργήσει έξω από το κουτί για το SDK 4.3 για ένα iPad σε οριζόντια ή κατακόρυφη προβολή:

@implementation UIView (FindFirstResponder)
- (UIResponder *)findFirstResponder
{
  if (self.isFirstResponder) {        
    return self;     
  }

  for (UIView *subView in self.subviews) {
    UIResponder *firstResponder = [subView findFirstResponder];
    if (firstResponder != nil) {
      return firstResponder;
    }
  }

  return nil;
}
@end

@implementation MyViewController

- (UIResponder *)currentFirstResponder {
  return [self.view findFirstResponder];
}

- (IBAction)editingEnded:sender {
  [sender resignFirstResponder];
}

- (BOOL)textFieldShouldReturn:(UITextField *)textField {
  [textField resignFirstResponder];
  return NO;
}

- (void)textFieldDidBeginEditing:(UITextField *)textField {
  UITableViewCell *cell = (UITableViewCell*) [[textField superview] superview];
  [_tableView scrollToRowAtIndexPath:[_tableView indexPathForCell:cell] atScrollPosition:UITableViewScrollPositionTop animated:YES];
}

- (void)keyboardWillShow:(NSNotification*)notification {
  if ([self currentFirstResponder] != nil) {
    NSDictionary* userInfo = [notification userInfo];

    // we don't use SDK constants here to be universally compatible with all SDKs ≥ 3.0
    NSValue* keyboardFrameValue = [userInfo objectForKey:@"UIKeyboardBoundsUserInfoKey"];
    if (!keyboardFrameValue) {
      keyboardFrameValue = [userInfo objectForKey:@"UIKeyboardFrameEndUserInfoKey"];
    }

    // Reduce the tableView height by the part of the keyboard that actually covers the tableView
    CGRect windowRect = [[UIApplication sharedApplication] keyWindow].bounds;
    CGRect viewRectAbsolute = [_tableView convertRect:_tableView.bounds toView:[[UIApplication sharedApplication] keyWindow]];
    CGRect frame = _tableView.frame;
    if (UIInterfaceOrientationLandscapeLeft == self.interfaceOrientation ||UIInterfaceOrientationLandscapeRight == self.interfaceOrientation ) {
      windowRect = CGRectMake(windowRect.origin.y, windowRect.origin.x, windowRect.size.height, windowRect.size.width);
      viewRectAbsolute = CGRectMake(viewRectAbsolute.origin.y, viewRectAbsolute.origin.x, viewRectAbsolute.size.height, viewRectAbsolute.size.width);
    }
    frame.size.height -= [keyboardFrameValue CGRectValue].size.height - CGRectGetMaxY(windowRect) + CGRectGetMaxY(viewRectAbsolute);

    [UIView beginAnimations:nil context:NULL];
    [UIView setAnimationDuration:[[userInfo objectForKey:UIKeyboardAnimationDurationUserInfoKey] doubleValue]];
    [UIView setAnimationCurve:[[userInfo objectForKey:UIKeyboardAnimationCurveUserInfoKey] intValue]];
    _tableView.frame = frame;
    [UIView commitAnimations];

    UITableViewCell *textFieldCell = (id)((UITextField *)self.currentFirstResponder).superview.superview;
    NSIndexPath *textFieldIndexPath = [_tableView indexPathForCell:textFieldCell];

    // iOS 3 sends hide and show notifications right after each other
    // when switching between textFields, so cancel -scrollToOldPosition requests
    [NSObject cancelPreviousPerformRequestsWithTarget:self];
    _topmostRowBeforeKeyboardWasShown = [[_tableView indexPathsForVisibleRows] objectAtIndex:0];
    [_tableView scrollToRowAtIndexPath:textFieldIndexPath atScrollPosition:UITableViewScrollPositionMiddle animated:YES];
  }
}

- (void) scrollToOldPosition {
  [_tableView scrollToRowAtIndexPath:_topmostRowBeforeKeyboardWasShown atScrollPosition:UITableViewScrollPositionTop animated:YES];
}

- (void)keyboardWillHide:(NSNotification*)notification {
  if ([self currentFirstResponder] != nil) {

    NSDictionary* userInfo = [notification userInfo];

    [UIView beginAnimations:nil context:NULL];
    [UIView setAnimationDuration:[[userInfo objectForKey:UIKeyboardAnimationDurationUserInfoKey] doubleValue]];
    [UIView setAnimationCurve:[[userInfo objectForKey:UIKeyboardAnimationCurveUserInfoKey] intValue]];
    _tableView.frame = self.view.bounds;
    [UIView commitAnimations];

    [self performSelector:@selector(scrollToOldPosition) withObject:nil afterDelay:0.1];
  }
}   

@end

Η προσέγγισή μου:

Θέλω πρώτα υποκατηγορία UITextField και πρόσθεσε ένα ακίνητο indexPath. Στο cellFor ... Μέθοδος i παραδώσει το ακίνητο indexPath.

Τότε μπορώ να προσθέσω ακόλουθο κώδικα:

UITableViewCell *cell = [self.tableView cellForRowAtIndexPath:textField.indexPath];

CGPoint cellPoint = [cell convertPoint:textField.center toView:self.tableView];
[UIView animateWithDuration:0.3 animations:^(void){self.tableView.contentOffset = CGPointMake(0, cellPoint.y-50);}];

στο textFieldShould / WillBegin ... κλπ.

Όταν το πληκτρολόγιο εξαφανίζεται πρέπει να το ανατρέψει με:

[UIView animateWithDuration:0.3 animations:^(void){self.tableView.contentOffset = CGPointMake(0, 0);}];

Χρησιμοποιήστε UITextField's delegateτη μέθοδο:

Ταχύς

func textFieldShouldBeginEditing(textField: UITextField) -> bool {
  let txtFieldPosition = textField.convertPoint(textField.bounds.origin, toView: yourTableViewHere)
  let indexPath = yourTablViewHere.indexPathForRowAtPoint(txtFieldPosition)
  if indexPath != nil {
     yourTablViewHere.scrollToRowAtIndexPath(indexPath!, atScrollPosition: .Top, animated: true)
  }
  return true
}

Στόχος-C

- (BOOL)textFieldShouldBeginEditing:(UITextField *)textField
{
  CGPoint txtFieldPosition = [textField convertPoint:CGPointZero toView: yourTablViewHere];
  NSLog(@"Begin txtFieldPosition : %@",NSStringFromCGPoint(txtFieldPosition));
  NSIndexPath *indexPath = [yourTablViewHere indexPathForRowAtPoint:txtFieldPosition];

  if (indexPath != nil) {
     [yourTablViewHere scrollToRowAtIndexPath:indexPath atScrollPosition:UITableViewScrollPositionMiddle animated:YES];
  }
  return YES;
}

Η σωστή απάντηση είναι η απάντηση Sam Ho είναι:

«Εάν χρησιμοποιείτε UITableViewController αντί UIViewController, θα κάνει αυτόματα έτσι.».

Απλά φροντίστε να συνδέσετε UITableView Σας ενδιαφέρει το ακίνητο TableView του UITableViewController (έτσι π.χ. μην το προσθέσετε ως δευτερεύουσας προβολής της Δείτε την παρουσίαση του UITableViewController).

Επίσης, φροντίστε να ορίσετε την ιδιότητα AutoresizingMask του UITableView σας για να FlexibleHeight

Εάν χρησιμοποιείτε Three20, στη συνέχεια, χρησιμοποιήστε το autoresizesForKeyboardακίνητο. Απλά ρυθμίστε στον ελεγκτή τη γνώμη σας -initWithNibName:bundleμέθοδο

self.autoresizesForKeyboard = YES

Αυτό φροντίζει για:

1. Ακρόαση για ειδοποιήσεις πληκτρολόγιο και ρύθμιση του πλαισίου του άποψη τραπεζιού
2. Κύλιση στην πρώτη ανταπόκρισης

Έγινε και γίνεται.

ειδοποιήσεις πληκτρολόγιο λειτουργεί, αλλά δείγμα κώδικα της Apple για το ότι θεωρεί ότι η άποψη κύλισης είναι η άποψη ρίζα του παραθύρου. Αυτό δεν συμβαίνει συνήθως. Θα πρέπει να αντισταθμίσει την καρτέλα μπαρ, κλπ, για να πάρει το σωστό offset.

Είναι πιο εύκολο από όσο ακούγεται. Εδώ είναι ο κώδικας που χρησιμοποιώ σε ένα UITableViewController. Έχει δύο μεταβλητές παράδειγμα, hiddenRect και keyboardShown.

// Called when the UIKeyboardDidShowNotification is sent.
- (void)keyboardWasShown:(NSNotification*)aNotification {
    if (keyboardShown)
        return;

    NSDictionary* info = [aNotification userInfo];

    // Get the frame of the keyboard.
    NSValue *centerValue = [info objectForKey:UIKeyboardCenterEndUserInfoKey];
    NSValue *boundsValue = [info objectForKey:UIKeyboardBoundsUserInfoKey];
    CGPoint keyboardCenter = [centerValue CGPointValue];
    CGRect keyboardBounds = [boundsValue CGRectValue];
    CGPoint keyboardOrigin = CGPointMake(keyboardCenter.x - keyboardBounds.size.width / 2.0,
                                         keyboardCenter.y - keyboardBounds.size.height / 2.0);
    CGRect keyboardScreenFrame = { keyboardOrigin, keyboardBounds.size };


    // Resize the scroll view.
    UIScrollView *scrollView = (UIScrollView *) self.tableView;
    CGRect viewFrame = scrollView.frame;
    CGRect keyboardFrame = [scrollView.superview convertRect:keyboardScreenFrame fromView:nil];
    hiddenRect = CGRectIntersection(viewFrame, keyboardFrame);

    CGRect remainder, slice;
    CGRectDivide(viewFrame, &slice, &remainder, CGRectGetHeight(hiddenRect), CGRectMaxYEdge);
    scrollView.frame = remainder;

    // Scroll the active text field into view.
    CGRect textFieldRect = [/* selected cell */ frame];
    [scrollView scrollRectToVisible:textFieldRect animated:YES];

    keyboardShown = YES;
}


// Called when the UIKeyboardDidHideNotification is sent
- (void)keyboardWasHidden:(NSNotification*)aNotification
{
    // Reset the height of the scroll view to its original value
    UIScrollView *scrollView = (UIScrollView *) self.tableView;
    CGRect viewFrame = [scrollView frame];
    scrollView.frame = CGRectUnion(viewFrame, hiddenRect);

    keyboardShown = NO;
}

Εάν χρησιμοποιείτε ένα uitableview να τοποθετήσετε textfields σας ( από Jeff Lamarche ), μπορείτε να μεταβείτε μόνο το TableView χρησιμοποιώντας τη μέθοδο εκπρόσωπο όπως έτσι.

(Σημείωση: τα πεδία κειμένου μου αποθηκεύονται σε έναν πίνακα με τον ίδιο δείκτη, όπως η σειρά υπάρχει στο TableView)

- (void) textFieldDidBeginEditing:(UITextField *)textField
    {

        int index;
        for(UITextField *aField in textFields){

            if (textField == aField){
                index = [textFields indexOfObject:aField]-1;
            }
        }

         if(index >= 0) 
            [self.tableView scrollToRowAtIndexPath:[NSIndexPath indexPathForRow:index inSection:0] atScrollPosition:UITableViewScrollPositionTop animated:YES];

        [super textFieldDidBeginEditing:textField];
    }

Μια πιο ρεύμα επένδυση διάλυμα. Είναι γλιστρά μέσα στις μεθόδους εκπρόσωπος UITextField, γι 'αυτό δεν απαιτεί πειράξουν w / ειδοποιήσεις UIKeyboard.

Παρατηρήσεις:

kSettingsRowHeight - το ύψος του UITableViewCell.

offsetTarget και offsetThreshold είναι baed μακριά από kSettingsRowHeight. Αν χρησιμοποιείτε διαφορετικό ύψος της γραμμής, που αυτές τις τιμές στο y ακίνητο σημείο του. [Alt: τον υπολογισμό της σειράς αντισταθμίζεται με διαφορετικό τρόπο.]

- (BOOL)textFieldShouldBeginEditing:(UITextField *)textField {
CGFloat offsetTarget    = 113.0f; // 3rd row
CGFloat offsetThreshold = 248.0f; // 6th row (i.e. 2nd-to-last row)

CGPoint point = [self.tableView convertPoint:CGPointZero fromView:textField];

[UIView beginAnimations:nil context:nil];
[UIView setAnimationDuration:0.2];
[UIView setAnimationCurve:UIViewAnimationCurveEaseOut];

CGRect frame = self.tableView.frame;
if (point.y > offsetThreshold) {
    self.tableView.frame = CGRectMake(0.0f,
                      offsetTarget - point.y + kSettingsRowHeight,
                      frame.size.width,
                      frame.size.height);
} else if (point.y > offsetTarget) {
    self.tableView.frame = CGRectMake(0.0f,
                      offsetTarget - point.y,
                      frame.size.width,
                      frame.size.height);
} else {
    self.tableView.frame = CGRectMake(0.0f,
                      0.0f,
                      frame.size.width,
                      frame.size.height);
}

[UIView commitAnimations];

return YES;

}

- (BOOL)textFieldShouldReturn:(UITextField *)textField {
[textField resignFirstResponder];

[UIView beginAnimations:nil context:nil];
[UIView setAnimationBeginsFromCurrentState:YES];
[UIView setAnimationDuration:0.2];
[UIView setAnimationCurve:UIViewAnimationCurveEaseOut];

CGRect frame = self.tableView.frame;
self.tableView.frame = CGRectMake(0.0f,
                  0.0f,
                  frame.size.width,
                  frame.size.height);

[UIView commitAnimations];

return YES;

}

Έτρεξα σε κάτι σαν το πρόβλημά σας (Ήθελα μια οθόνη παρόμοια με settings.app του iPhone με μια δέσμη των επεξεργάσιμο κύτταρα στοιβάζονται το ένα πάνω στο άλλο) και διαπίστωσε ότι η προσέγγιση αυτή λειτούργησε καλά:

συρόμενη uitextfields γύρω για να αποφευχθεί

Ένα παράδειγμα το Swift, χρησιμοποιώντας το ακριβές σημείο του πεδίου κειμένου από Λάβετε indexPath της UITextField σε UITableViewCell με Swift :

func textFieldDidBeginEditing(textField: UITextField) {
    let pointInTable = textField.convertPoint(textField.bounds.origin, toView: self.accountsTableView)
    let textFieldIndexPath = self.accountsTableView.indexPathForRowAtPoint(pointInTable)
    accountsTableView.scrollToRowAtIndexPath(textFieldIndexPath!, atScrollPosition: .Top, animated: true)
}

Πολύ ενδιαφέρον θέμα συζήτησης, i αντιμετώπισε επίσης το ίδιο πρόβλημα μπορεί να είναι χειρότερα, διότι

1. Ήμουν χρησιμοποιώντας μια προσαρμοσμένη κυττάρων και το πεδίο κειμένου ήταν μέσα από αυτό.
2. Έπρεπε να χρησιμοποιήσει UIViewController να ανταποκριθεί στις απαιτήσεις μου, έτσι επίκλιση να επωφεληθούν από UITableViewController.
3. Είχα κριτήρια φίλτρου / ταξινόμησης στο κελί τραπέζι μου, δηλαδή ur κύτταρα συνεχίζει να αλλάζει και την παρακολούθηση της indexpath και όλα δεν θα βοηθήσει.

Έτσι, διαβάστε τα θέματα που εδώ και υλοποιούνται έκδοση μου, που με βοήθησε στην άνοδο των περιεχομένων μου στο iPad το τοπίο λειτουργία. Εδώ είναι ο κώδικας (αυτό δεν είναι ανόητος απόδειξη και όλα, αλλά σταθερά το θέμα μου) Πρώτα u πρέπει να έχουν έναν αντιπρόσωπο στην τάξη έθιμο των κυττάρων σας, η οποία σε επεξεργασία αρχίζει, στέλνει το πεδίο κειμένου για να ur viewcontroller και να ρυθμίσετε το activefield = theTextField εκεί

// υλοποιούνται προκειμένου να αντιμετωπιστούν ΤΟΠΙΟ ΛΕΙΤΟΥΡΓΙΑ ΜΟΝΟ

- (void)keyboardWasShown:(NSNotification*)aNotification
{
    NSDictionary* info = [aNotification userInfo];
    CGSize kbValue = [[info objectForKey:UIKeyboardFrameBeginUserInfoKey] CGRectValue].size;
    CGRect aRect = myTable.frame;

    CGSize kbSize = CGSizeMake(kbValue.height, kbValue.width);

    aRect.size.height -= kbSize.height+50;
// This will the exact rect in which your textfield is present
        CGRect rect =  [myTable convertRect:activeField.bounds fromView:activeField];
// Scroll up only if required
    if (!CGRectContainsPoint(aRect, rect.origin) ) {


            [myTable setContentOffset:CGPointMake(0.0, rect.origin.y) animated:YES];

    }


}

// Καλείται όταν η UIKeyboardWillHideNotification αποστέλλεται

- (void)keyboardWillHide:(NSNotification*)aNotification
{
    UIEdgeInsets contentInsets = UIEdgeInsetsZero;
    myTable.contentInset = contentInsets;
    myTable.scrollIndicatorInsets = contentInsets;
    NSDictionary* info = [aNotification userInfo];
    CGSize kbValue = [[info objectForKey:UIKeyboardFrameBeginUserInfoKey] CGRectValue].size;
    CGSize kbSize = CGSizeMake(kbValue.height, kbValue.width);
    CGRect bkgndRect = activeField.superview.frame;
    bkgndRect.size.height += kbSize.height;
    [activeField.superview setFrame:bkgndRect];
    [myTable setContentOffset:CGPointMake(0.0, 10.0) animated:YES];
}

-anoop4real

Αυτό soluton λειτουργεί για μένα, παρακαλώ σημειώστε τη γραμμή

[tableView setContentOffset:CGPointMake(0.0, activeField.frame.origin.y-kbSize.height+160) animated:YES];

Μπορείτε να αλλάξετε την τιμή 160 για να ταιριάζει με το συνεργαστούμε μαζί σας

- (void)keyboardWasShown:(NSNotification*)aNotification
{
    NSDictionary* info = [aNotification userInfo];
    CGSize kbSize = [[info objectForKey:UIKeyboardFrameBeginUserInfoKey] CGRectValue].size;
    CGRect bkgndRect = activeField.superview.frame;
                        bkgndRect.size.height += kbSize.height;
     [activeField.superview setFrame:bkgndRect];
     [tableView setContentOffset:CGPointMake(0.0, activeField.frame.origin.y-kbSize.height+160) animated:YES];
}

- (void)textFieldDidBeginEditing:(UITextField *)textField
{
   activeField = textField;
}
-(void)textFieldDidEndEditing:(UITextField *)textField
 {
     activeField = nil;
 }
// Called when the UIKeyboardWillHideNotification is sent
- (void)keyboardWillBeHidden:(NSNotification*)aNotification
{
    UIEdgeInsets contentInsets = UIEdgeInsetsZero;
    tableView.contentInset = contentInsets;
    tableView.scrollIndicatorInsets = contentInsets;
    NSDictionary* info = [aNotification userInfo];
    CGSize kbSize = [[info objectForKey:UIKeyboardFrameBeginUserInfoKey] CGRectValue].size;
    CGRect bkgndRect = activeField.superview.frame;
    //bkgndRect.size.height += kbSize.height;
    [activeField.superview setFrame:bkgndRect];
    [tableView setContentOffset:CGPointMake(0.0, activeField.frame.origin.y-kbSize.height) animated:YES];
}

Δεδομένου ότι έχετε textfields σε έναν πίνακα, ο καλύτερος τρόπος είναι πραγματικά να αλλάξετε το μέγεθος του πίνακα - πρέπει να ρυθμίσετε το tableView.frame να είναι μικρότερα σε ύψος από το μέγεθος του πληκτρολογίου (νομίζω περίπου 165 pixels) και στη συνέχεια, αναπτύξτε το ξανά όταν το πληκτρολόγιο απορρίπτεται.

Μπορείτε να προαιρετικά επίσης να απενεργοποιήσετε την αλληλεπίδραση του χρήστη για την TableView εκείνη την εποχή, καθώς, αν δεν θέλετε την κύλιση του χρήστη.

Μικρές διαφορές με Swift 4.2 ...

Σε UITableView μου είχα πολλούς τομείς, αλλά εγώ έπρεπε να αποφύγει την πλωτή επίδραση κεφαλίδα γι 'αυτό χρησιμοποιείται ένα « dummyViewHeight προσέγγιση», όπως φαίνεται κάπου αλλού εδώ για υπερχείλιση στοίβας ... Έτσι, αυτό είναι η λύση μου για το πρόβλημα αυτό (λειτουργεί επίσης για το πληκτρολόγιο + προτάσεις γραμμή εργαλείων +):

Κηρύξει ως σταθερή τάξη:

let dummyViewHeight: CGFloat = 40.0

Επειτα

override func viewDidLoad() {
    super.viewDidLoad()
    //... some stuff here, not needed for this example

    // Create non floating header
    tableView.tableHeaderView = UIView(frame: CGRect(x: 0, y: 0, width: tableView.bounds.size.width, height: dummyViewHeight))
    tableView.contentInset = UIEdgeInsets(top: -dummyViewHeight, left: 0, bottom: 0, right: 0)

    addObservers()
}

override func viewWillDisappear(_ animated: Bool) {
    super.viewWillDisappear(animated)
    removeObservers()
}

Και εδώ όλη η μαγεία ...

@objc func keyboardWillShow(notification: NSNotification) {
    if let userInfo = notification.userInfo {
        let keyboardHeight = (userInfo[UIResponder.keyboardFrameEndUserInfoKey] as AnyObject).cgRectValue.size.height
        tableView.tableHeaderView = UIView(frame: CGRect(x: 0, y: 0, width: self.tableView.bounds.size.width, height: dummyViewHeight))
        tableView.contentInset = UIEdgeInsets(top: -dummyViewHeight, left: 0, bottom: keyboardHeight, right: 0)
    }
}

@objc func keyboardWillHide(notification: NSNotification) {
    UIView.animate(withDuration: 0.25) {
        self.tableView.tableHeaderView = UIView(frame: CGRect(x: 0, y: 0, width: self.tableView.bounds.size.width, height: self.dummyViewHeight))
        self.tableView.contentInset = UIEdgeInsets(top: -self.dummyViewHeight, left: 0, bottom: 0, right: 0)
    }
}

στην viewDidLoad

-(void)viewdidload{

[super viewdidload];

    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(keyboardWillChange:) name:UIKeyboardWillChangeFrameNotification object:nil];
}

    -(void)keyboardWillChange:(NSNotification*)sender{

        NSLog(@"keyboardwillchange sender %@",sender);

float margin=0  // set your own topmargin


        CGFloat originY = [[sender.userInfo objectForKey:UIKeyboardFrameEndUserInfoKey] CGRectValue].origin.y;


        if (originY >= self.view.frame.size.height){

            NSLog(@"keyboardclose");



            [tb_ setFrame:CGRectMake(0, margin, self.view.frame.size.width, self.view.frame.size.height-margin)];

        }else{

            NSLog(@"keyobard on");

            float adjustedHeight = self.view.frame.size.height - margin - (self.view.frame.size.height-originY);

            [tb_ setFrame:CGRectMake(0, margin, self.view.frame.size.width, adjustedHeight)];
        }







    }

Είμαι χρησιμοποιώντας αυτά και λειτουργούν σαν μια γοητεία:

BSKeyboardControls - BSKeyboardControls GitHub

TPKeyboardAvoiding - TPKeyboardAvoiding GitHub

Χρησιμοποιώ αυτό συχνά στα έργα μου. Η λύση αυτή λειτουργεί με scrollviews, tableviews ή collectionviews και είναι εύκολο στην εγκατάσταση. Επίσης, αγκίστρια αυτόματα κουμπιά «Επόμενο» στο πληκτρολόγιο για να αλλάξετε μέσα από τα πεδία κειμένου.

Δείτε το εδώ

Θα ρίξει λύση μου (Ή QuickDialog ότι είναι) σε καπέλο. Βασικά περιμένω να εμψυχώσει την κύλιση. Θα ήταν ωραίο να πάρετε την κίνηση του πληκτρολογίου ΚΟΕ αντί του μαγικό αριθμό.

-(void)textFieldDidBeginEditing:(UITextField *)textField
{
    if (textField == self.emailTextField) {
        NSIndexPath *indexPath = [NSIndexPath indexPathForRow:0 inSection:0];
        dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, 50 * USEC_PER_SEC);
        dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
            [self.tableView scrollToRowAtIndexPath:indexPath atScrollPosition:UITableViewScrollPositionTop animated:YES];
        });
    }
}

Εύκολη και γρήγορη λύση.

Απλά μετακινηθείτε προς τα δεξιά κελί κάθε φορά που κύλιση συμβαίνει

    - (void)scrollViewDidScroll:(UIScrollView *)scrollView 

Υποθέτοντας ότι ξέρω τραπέζι τώρα είναι σε αυτή την κατάσταση «_keepMyCellOnTop» και ξέρω επιλεγμένο κελί «_selectedCellIndex» ή μεταβείτε στο επιλεγμένο κελί

- (void)scrollViewDidScroll:(UIScrollView *)scrollView 
{

    if (_keepMyCellOnTop)
    {
        [self.tableView scrollToRowAtIndexPath:_selectedCellIndex atScrollPosition:UITableViewScrollPositionTop animated:NO];
    }
}

Αυτό θα αποτρέψει την κύλιση.

Τοποθετώντας τον κώδικα -(void) scrollViewDidEndScrollingAnimation:(UIScrollView *)scrollView θα έχει ως αποτέλεσμα μια περγαμηνή πάνω και κάτω

Έχω λυθεί μόνο ένα τέτοιο πρόβλημα με τον εαυτό μου αφού αναφέρεται μια μάζα των λύσεων που βρέθηκαν μέσω του Google και Υπερχείλιση στοίβας.

Πρώτον, παρακαλούμε να διαβεβαιώσω ότι έχετε δημιουργήσει ένα IBOutlet της UIScrollView σας, τότε μπορείτε να ρίξετε μια προσεκτική ματιά στο μήλο Doc: Διαχείριση πληκτρολογίου . Τέλος, αν μπορείτε να μετακινηθείτε το φόντο, αλλά το πληκτρολόγιο εξακολουθεί να καλύπτει το πεδία κειμένου, παρακαλώ ρίξτε μια ματιά σε αυτό το κομμάτι του κώδικα:

// If active text field is hidden by keyboard, scroll it so it's visible
// Your application might not need or want this behavior.
CGRect aRect = self.view.frame;
aRect.size.height -= kbSize.height;

if (aRect.size.height < activeField.frame.origin.y+activeField.frame.size.height) {

    CGPoint scrollPoint = CGPointMake(0.0, activeField.frame.origin.y+activeField.frame.size.height-aRect.size.height);

    [scrollView setContentOffset:scrollPoint animated:YES];

Η κύρια διαφορά μεταξύ αυτού του κομματιού και τα ψέματα της Apple στο αν η κατάσταση. Πιστεύω υπολογισμό της Apple απόσταση κύλισης και την κατάσταση του κατά πόσον το πεδίο κειμένου που καλύπτεται από το πληκτρολόγιο δεν είναι ακριβή, έτσι έκανα τροποποίησης μου ως ανωτέρω.

Επιτρέψτε μου να ξέρω αν αυτό δουλεύει

Εδώ είναι το πώς θα γίνει αυτό το έργο, το οποίο είναι ένα μίγμα Sam Ho και απαντήσεις Marcel W, καθώς και κάποιες από τις δικές μου διορθώσεις σφαλμάτων γίνεται με μίζερη τον κωδικό μου. Ήμουν χρησιμοποιώντας ένα UITableViewController. Ο πίνακας αλλάζει το μέγεθος πλέον σωστά όταν το πληκτρολόγιο εμφανίζεται.

1) Στο viewDidLoadΙ προστίθεται:

self.tableView.autoresizingMask = UIViewAutoresizingFlexibleHeight;

2) Είχα ξεχάσει να καλέσει τα superισοδύναμα στο viewWillAppearκαι awakeFromNib. Πρόσθεσα αυτά πίσω.

Αν UITableView σας διοικείται από μια υποκατηγορία των UITableViewController και όχι UITableView, και ο εκπρόσωπος πεδίο κειμένου είναι η UITableViewController, θα πρέπει να διαχειριστεί όλα τα κύλιση αυτόματα - όλα αυτά τα άλλα σχόλια είναι πολύ δύσκολο να εφαρμοστεί στην πράξη.

Για ένα καλό παράδειγμα δείτε το σχέδιο παράδειγμα κώδικα μήλου: TaggedLocations.

Μπορείτε να δείτε ότι μετακινείται αυτόματα, αλλά δεν φαίνεται να υπάρχει καμία κώδικα που το κάνει αυτό. Το έργο έχει επίσης προσαρμοσμένο πίνακα κύτταρα άποψη, οπότε αν χτίζετε την αίτησή σας με αυτό ως οδηγό, θα πρέπει να έχετε το επιθυμητό αποτέλεσμα.

Μια άλλη εύκολη μέθοδος (λειτουργεί μόνο με ένα τμήμα)

//cellForRowAtIndexPath
UItextField *tf;
[cell addSubview:tf];
tf.tag = indexPath.row;
tf.delegate = self;

//textFieldDidBeginEditing:(UITextField *)text
[[self.tableView scrollToRowsAtIndexPath:[NSIndexPath indexPathForRow:text.tag in section:SECTIONINTEGER] animated:YES];

Έτσι, μετά από ώρες εξαντλητικής εργασίας προσπαθεί να χρησιμοποιήσει αυτές τις τρέχουσες λύσεις (και εντελώς μη) πήρα τελικά τα πράγματα λειτουργούν καλά, και να ενημερώνονται για την χρήση των νέων μπλοκ animation. Η απάντησή μου βασίζεται εξ ολοκλήρου σε απάντηση Ortwin της παραπάνω .

Έτσι, για οποιοδήποτε λόγο ο κωδικός παραπάνω απλά δεν λειτουργεί για μένα. setup μου φάνηκε αρκετά παρόμοια με τους άλλους, αλλά ίσως επειδή ήμουν σε ένα iPad ή 4.3 ... χωρίς την ιδέα. Είχε κάνει κάποια τρελή μαθηματικά και τα γυρίσματα TableView μου από την οθόνη.

Δείτε τελικό αποτέλεσμα της λύσης μου: http://screencast.com/t/hjBCuRrPC (Παρακαλούμε να αγνοήσει τη φωτογραφία :-P).

Έτσι, πήγα με την ουσία του τι έκανε Ortwin, αλλά άλλαξε το πώς ήταν να κάνει κάποια μαθηματικά για να προσθέσετε το origin.y & size.height άποψη μου τραπέζι με το ύψος του πληκτρολογίου. Όταν αφαιρέσετε το ύψος του παραθύρου από αυτό το αποτέλεσμα, μου λέει πόσο πολύ διασταύρωση έχω σε εξέλιξη. Εάν του μεγαλύτερη από 0 (aka υπάρχει κάποια επικάλυψη) Ι εκτελέσει την κίνηση του ύψους πλαισίου.

Επιπλέον, υπήρχαν κάποια επανασχεδίαση ζητήματα που επιλύθηκαν από 1) Αναμονή για να μετακινηθείτε στο κελί μέχρι να γίνει η κίνηση και 2) χρησιμοποιώντας την επιλογή UIViewAnimationOptionBeginFromCurrentState όταν κρύβει το πληκτρολόγιο.

Ένα ζευγάρι πράγματα που πρέπει να λάβετε υπόψη.

• _topmostRowBeforeKeyboardWasShown & _originalFrame είναι παράδειγμα μεταβλητές δηλώνονται στην επικεφαλίδα.
• self.guestEntryTableView είναι TableView μου (είμαι σε ένα εξωτερικό αρχείο)
• IASKCGRectSwap είναι μέθοδος Ortwin του για το αναποδογύρισμα των συντεταγμένων ενός πλαισίου
• Θα ενημερώσετε μόνο το ύψος του TableView εάν τουλάχιστον 50px του πρόκειται να δείχνει
• Επειδή δεν είμαι σε UIViewController δεν έχω self.view, γι 'αυτό ακριβώς επιστρέψει το TableView στο αρχικό πλαίσιο του

Και πάλι, δεν θα είχα πάρει κοντά σε αυτήν την απάντηση αν Ortwin δεν παρέχουν την ουσία του. Εδώ είναι ο κώδικας:

- (IBAction)textFieldDidBeginEditing:(UITextField *)textField
{
    self.activeTextField = textField;

    if ([self.guestEntryTableView indexPathsForVisibleRows].count) {
        _topmostRowBeforeKeyboardWasShown = (NSIndexPath*)[[self.guestEntryTableView indexPathsForVisibleRows] objectAtIndex:0];
    } else {
        // this should never happen
        _topmostRowBeforeKeyboardWasShown = [NSIndexPath indexPathForRow:0 inSection:0];
        [textField resignFirstResponder];
    }
}

- (IBAction)textFieldDidEndEditing:(UITextField *)textField
{
    self.activeTextField = nil;
}

- (void)keyboardWillShow:(NSNotification*)notification {
    NSDictionary* userInfo = [notification userInfo];

    NSValue* keyboardFrameValue = [userInfo objectForKey:UIKeyboardFrameEndUserInfoKey];

    // Reduce the tableView height by the part of the keyboard that actually covers the tableView
    UIInterfaceOrientation orientation = [[UIApplication sharedApplication] statusBarOrientation];
    CGRect windowRect = [[UIApplication sharedApplication] keyWindow].bounds;
    CGRect viewRectAbsolute = [self.guestEntryTableView convertRect:self.guestEntryTableView.bounds toView:[[UIApplication sharedApplication] keyWindow]];
    CGRect keyboardFrame = [keyboardFrameValue CGRectValue];
    if (UIInterfaceOrientationLandscapeLeft == orientation ||UIInterfaceOrientationLandscapeRight == orientation ) {
        windowRect = IASKCGRectSwap(windowRect);
        viewRectAbsolute = IASKCGRectSwap(viewRectAbsolute);
        keyboardFrame = IASKCGRectSwap(keyboardFrame);
    }

    // fix the coordinates of our rect to have a top left origin 0,0
    viewRectAbsolute = FixOriginRotation(viewRectAbsolute, orientation, windowRect.size.width, windowRect.size.height);

    CGRect frame = self.guestEntryTableView.frame;
    _originalFrame = self.guestEntryTableView.frame;

    int remainder = (viewRectAbsolute.origin.y + viewRectAbsolute.size.height + keyboardFrame.size.height) - windowRect.size.height;

    if (remainder > 0 && !(remainder > frame.size.height + 50)) {
        frame.size.height = frame.size.height - remainder;
        float duration = [[userInfo objectForKey:UIKeyboardAnimationDurationUserInfoKey] doubleValue];
        [UIView animateWithDuration: duration
                        animations:^{
                            self.guestEntryTableView.frame = frame;
                        }
                        completion:^(BOOL finished){
                            UITableViewCell *textFieldCell = (UITableViewCell*) [[self.activeTextField superview] superview];
                            NSIndexPath *textFieldIndexPath = [self.guestEntryTableView indexPathForCell:textFieldCell];
                            [self.guestEntryTableView scrollToRowAtIndexPath:textFieldIndexPath atScrollPosition:UITableViewScrollPositionMiddle animated:YES];
                        }];
    }

}

- (void)keyboardWillHide:(NSNotification*)notification {
    NSDictionary* userInfo = [notification userInfo];
    float duration = [[userInfo objectForKey:UIKeyboardAnimationDurationUserInfoKey] doubleValue];
    [UIView animateWithDuration: duration
                          delay: 0.0
                        options: (UIViewAnimationOptionBeginFromCurrentState)
                     animations:^{
                         self.guestEntryTableView.frame = _originalFrame;
                     }
                     completion:^(BOOL finished){
                         [self.guestEntryTableView scrollToRowAtIndexPath:_topmostRowBeforeKeyboardWasShown atScrollPosition:UITableViewScrollPositionTop animated:YES];
                     }];

}   

#pragma mark CGRect Utility function
CGRect IASKCGRectSwap(CGRect rect) {
    CGRect newRect;
    newRect.origin.x = rect.origin.y;
    newRect.origin.y = rect.origin.x;
    newRect.size.width = rect.size.height;
    newRect.size.height = rect.size.width;
    return newRect;
}

CGRect FixOriginRotation(CGRect rect, UIInterfaceOrientation orientation, int parentWidth, int parentHeight) {
    CGRect newRect;
    switch(orientation)
    {
        case UIInterfaceOrientationLandscapeLeft:
            newRect = CGRectMake(parentWidth - (rect.size.width + rect.origin.x), rect.origin.y, rect.size.width, rect.size.height);
            break;
        case UIInterfaceOrientationLandscapeRight:
            newRect = CGRectMake(rect.origin.x, parentHeight - (rect.size.height + rect.origin.y), rect.size.width, rect.size.height);
            break;
        case UIInterfaceOrientationPortrait:
            newRect = rect;
            break;
        case UIInterfaceOrientationPortraitUpsideDown:
            newRect = CGRectMake(parentWidth - (rect.size.width + rect.origin.x), parentHeight - (rect.size.height + rect.origin.y), rect.size.width, rect.size.height);
            break;
    }
    return newRect;
}

Έχω δοκιμάσει σχεδόν την ίδια προσέγγιση και ήρθε με ένα απλούστερο και μικρότερο κωδικός για τον ίδιο. Δημιούργησα ένα IBOutlet iTextView και συνδέονται με την UITextView στο IB.

 -(void)keyboardWillShow:(NSNotification *)notification
    {
        NSLog(@"Keyboard");
        CGRect keyFrame = [[[notification userInfo]objectForKey:UIKeyboardFrameEndUserInfoKey]CGRectValue];

        [UIView beginAnimations:@"resize view" context:nil];
        [UIView setAnimationCurve:1];
        [UIView setAnimationDuration:1.0];
        CGRect frame = iTableView.frame;
        frame.size.height = frame.size.height -  keyFrame.size.height;
        iTableView.frame = frame;
        [iTableView scrollRectToVisible:frame animated:YES];
        [UIView commitAnimations];

    }

Αυτό λειτουργεί τέλεια, και στο iPad πάρα πολύ.

- (BOOL)textFieldShouldReturn:(UITextField *)textField 
{

    if(textField == textfield1){
            [accountName1TextField becomeFirstResponder];
        }else if(textField == textfield2){
            [self.tableView scrollToRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:1] atScrollPosition:UITableViewScrollPositionTop animated:YES];
            [textfield3 becomeFirstResponder];

        }else if(textField == textfield3){
            [self.tableView scrollToRowAtIndexPath:[NSIndexPath indexPathForRow:1 inSection:1] atScrollPosition:UITableViewScrollPositionTop animated:YES];
            [textfield4 becomeFirstResponder];

        }else if(textField == textfield4){
            [self.tableView scrollToRowAtIndexPath:[NSIndexPath indexPathForRow:2 inSection:1] atScrollPosition:UITableViewScrollPositionTop animated:YES];
            [textfield5 becomeFirstResponder];

        }else if(textField == textfield5){
            [self.tableView scrollToRowAtIndexPath:[NSIndexPath indexPathForRow:3 inSection:1] atScrollPosition:UITableViewScrollPositionTop animated:YES];
            [textfield6 becomeFirstResponder];

        }else if(textField == textfield6){
            [self.tableView scrollToRowAtIndexPath:[NSIndexPath indexPathForRow:4 inSection:1] atScrollPosition:UITableViewScrollPositionTop animated:YES];
            [textfield7 becomeFirstResponder];

        }else if(textField == textfield7){
            [self.tableView scrollToRowAtIndexPath:[NSIndexPath indexPathForRow:5 inSection:1] atScrollPosition:UITableViewScrollPositionTop animated:YES];
            [textfield8 becomeFirstResponder];

        }else if(textField == textfield8){
            [self.tableView scrollToRowAtIndexPath:[NSIndexPath indexPathForRow:6 inSection:1] atScrollPosition:UITableViewScrollPositionTop animated:YES];
            [textfield9 becomeFirstResponder];

        }else if(textField == textfield9){
            [self.tableView scrollToRowAtIndexPath:[NSIndexPath indexPathForRow:7 inSection:1] atScrollPosition:UITableViewScrollPositionTop animated:YES];
            [textField resignFirstResponder];
        }

Μόλις ανακάλυψα ένα άλλο σφάλμα κατά τη χρήση UITableViewController. Δεν ήταν κύλιση αυτόματα όταν το πληκτρολόγιο εμφανίστηκε. Παρατήρησα ότι ήταν λόγω της contentInsetAdjustmentBehavior = .never για UITableView.

Λύση για Swift 3-4 με κινούμενα σχέδια και αλλαγή πλαισίου πληκτρολόγιο:

Πρώτον, να δημιουργήσει μια Bool:

// MARK: - Private Properties
private var isKeyboardShowing = false

Δεύτερον, προσθέστε παρατηρητές στις Ειδοποιήσεις Πληκτρολόγιο Σύστημα:

// MARK: - Overriding ViewController Life Cycle Methods
override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)

    NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillShow), name: .UIKeyboardWillShow, object: nil)

    NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillHide), name: .UIKeyboardWillHide, object: nil)

    NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillChangeFrame), name: .UIKeyboardWillChangeFrame, object: nil)
}

Τρίτον, να προετοιμάσει τη λειτουργία animation:

func adjustTableViewInsets(keyboardHeight: CGFloat, duration: NSNumber, curve: NSNumber){
    var extraHeight: CGFloat = 0
    if keyboardHeight > 0 {
        extraHeight = 20
        isKeyboardShowing = true
    } else {
        isKeyboardShowing = false
    }

    let contentInset = UIEdgeInsets(top: 0, left: 0, bottom: keyboardHeight + extraHeight, right: 0)
    func animateFunc() {
        //refresh constraints
        //self.view.layoutSubviews()
        tableView.contentInset = contentInset
    }

    UIView.animate(withDuration: TimeInterval(duration), delay: 0, options: [UIViewAnimationOptions(rawValue: UInt(curve))], animations: animateFunc, completion: nil)
}

Στη συνέχεια, προσθέστε τις μεθόδους στόχους / δράσεις (που ονομάζεται από τους παρατηρητές):

// MARK: - Target/Selector Actions
func keyboardWillShow(notification: NSNotification) {
    if !isKeyboardShowing {
        if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
            let keyboardHeight = keyboardSize.height

            let duration = notification.userInfo?[UIKeyboardAnimationDurationUserInfoKey] as! NSNumber
            let curve = notification.userInfo?[UIKeyboardAnimationCurveUserInfoKey] as! NSNumber

            adjustTableViewInsets(keyboardHeight: keyboardHeight, duration: duration, curve: curve)
        }
    }
}

func keyboardWillHide(notification: NSNotification) {
    let duration = notification.userInfo?[UIKeyboardAnimationDurationUserInfoKey] as! NSNumber
    let curve = notification.userInfo?[UIKeyboardAnimationCurveUserInfoKey] as! NSNumber
    adjustTableViewInsets(keyboardHeight: 0, duration: duration, curve: curve)
}

func keyboardWillChangeFrame(notification: NSNotification) {
    if isKeyboardShowing {
        let duration = notification.userInfo?[UIKeyboardAnimationDurationUserInfoKey] as! NSNumber
        let curve = notification.userInfo?[UIKeyboardAnimationCurveUserInfoKey] as! NSNumber

        if let newKeyboardSize = (notification.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue {
            let keyboardHeight = newKeyboardSize.height
            adjustTableViewInsets(keyboardHeight: keyboardHeight, duration: duration, curve: curve)
        }
    }
}

Τέλος, μην ξεχάσετε να αφαιρέσετε παρατηρητές στην deinit ή viewWillDisappear:

deinit {
    NotificationCenter.default.removeObserver(self)
}

Δεν χρειάζεται καμία υπολογισμοί, Χρησιμοποιήστε τον παρακάτω κωδικό αυτό θα λειτουργήσει: Ο κωδικός αυτός θα χρησιμοποιηθεί στην Προσαρμοσμένη UITableviewcell μου, Είναι εργασίας:

override func viewDidLoad() {
super.viewDidLoad()

NotificationCenter.default.addObserver(self, selector: #selector(ViewController.keyboardWillShow), name: NSNotification.Name.UIKeyboardWillShow, object: nil)

NotificationCenter.default.addObserver(self, selector: #selector(ViewController.keyboardWillHide), name: NSNotification.Name.UIKeyboardWillHide, object: nil)}


func keyboardWillShow(_ notification:Notification) {

if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
    tableView.contentInset = UIEdgeInsetsMake(0, 0, keyboardSize.height, 0)
}}


func keyboardWillHide(_ notification:Notification) {

if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
    tableView.contentInset = UIEdgeInsetsMake(0, 0, 0, 0)
}}

Swift 4 ολοκληρωμένη λύση:

• Σωστά λειτουργεί με αλλαγές πλαισίου πληκτρολόγιο (π.χ. ύψος πληκτρολόγιο αλλάζει σαν emojii → κανονικό πληκτρολόγιο).
• Tabbar & γραμμή εργαλείων υποστήριξης για UITableView παράδειγμα (σε άλλα παραδείγματα θα λάβετε λανθασμένες ένθετα).
• Δυναμική διάρκεια animation (δεν είναι δύσκολο-κωδικοποιημένα).
• Πρωτόκολλο προσανατολισμό, έτσι ώστε να μπορείτε εύκολα να το χρησιμοποιήσετε σε οποιαδήποτε κατάσταση.
• Μεταβείτε ένθετα δουλεύει πάρα πολύ.

Έγραψα το πρωτόκολλο βοηθός (μπορείτε να το κατεβάσετε ως ουσία , επειδή είναι πολύ μεγάλο για να δημοσιεύσετε στο StackOverflow), οπότε η άποψή σας απλά πρέπει να:

1. Υιοθέτηση KeyboardChangeFrameObserverπρωτοκόλλου:

   func willChangeKeyboardFrame(height: CGFloat, animationDuration: TimeInterval, animationOptions: UIViewAnimationOptions)
   

2. Καλέστε observeKeyboardFrameChanges()για να εμφανιστεί.

Παράδειγμα εφαρμογής του εν λόγω πρωτοκόλλου για TableView:

class TestViewController: UITableViewController, KeyboardChangeFrameObserver {

    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)

        observeKeyboardFrameChanges()
    }

    func willChangeKeyboardFrame(height: CGFloat, animationDuration: TimeInterval, animationOptions: UIViewAnimationOptions) {
        var adjustedHeight = height

        if let tabBarHeight = self.tabBarController?.tabBar.frame.height {
            adjustedHeight -= tabBarHeight
        } else if let toolbarHeight = navigationController?.toolbar.frame.height, navigationController?.isToolbarHidden == false {
            adjustedHeight -= toolbarHeight
        }

        if adjustedHeight < 0 { adjustedHeight = 0 }

        UIView.animate(withDuration: animationDuration, animations: {
            let newInsets = UIEdgeInsets(top: 0, left: 0, bottom: adjustedHeight, right: 0)
            self.tableView.contentInset = newInsets
            self.tableView.scrollIndicatorInsets = newInsets
        })
    }

}

// scroll tableview so content ends at the middle of the tableview (out of the way of the keyboard)
CGPoint newContentOffset = CGPointMake(0, [self.tableView contentSize].height - (self.tableView.bounds.size.height / 2));
[self.tableView setContentOffset:newContentOffset animated:YES];

Κοιτάξτε έκδοση μου :)

    - (void)keyboardWasShown:(NSNotification *)aNotification
{
    NSDictionary* info = [aNotification userInfo];
    CGSize kbSize = [[info objectForKey:UIKeyboardFrameBeginUserInfoKey] CGRectValue].size;
    CGRect bkgndRect = cellSelected.superview.frame;
    bkgndRect.size.height += kbSize.height;
    [cellSelected.superview setFrame:bkgndRect];
    [tableView setContentOffset:CGPointMake(0.0, cellSelected.frame.origin.y-kbSize.height) animated:YES];
}


- (void)keyboardWasHidden:(NSNotification *)aNotification
{
    [tableView setContentOffset:CGPointMake(0.0, 0.0) animated:YES];
}

Εδώ είναι η λύση μου εμπνευσμένο από την οθόνη «Επεξεργασία συμβάντος» από iOS7 εφαρμογής Ημερολόγιο.

Ένα από τα βασικά σημεία αυτής της λύσης είναι ότι το πληκτρολόγιο έχει απορριφθεί όταν τραπέζι κύλιση χρήστη.

Εκτέλεση:

1) Ανάθεση ακινήτου που θα αποθηκεύουν επιλεγμένα πεδίο κειμένου:

@property (strong) UITextField *currentTextField;

και BOOL μεταβλητές που θα χρησιμοποιήσουμε για να ελέγξετε αν θα χρειαστεί να αποκρύψετε το πληκτρολόγιο όταν ειλητάρια χρήστη πίνακα.

BOOL hideKeyboardOnScroll;

2) Χειρολαβή UITextField callbacks εκπρόσωπος:

#pragma mark - UITextFieldDelegate

- (void) textFieldDidBeginEditing: (UITextField *) textField {
    self.currentTextField = textField;
}

- (void) textFieldDidEndEditing: (UITextField *) textField {
    self.currentTextField = nil;
}

- (BOOL) textFieldShouldReturn: (UITextField *) textField {
   [textField resignFirstResponder];

    CGPoint newContentOffset = CGPointZero;
    if (tableView.contentSize.height > tableView.frame.size.height) {
        newContentOffset.y = MIN(tableView.contentOffset.y, tableView.contentSize.height - tableView.frame.size.height);
    }
    [tableView setContentOffset: newContentOffset animated: YES];

    return YES;
}

3) Να χειρίζεστε τη μέθοδο UIScrollViewDelegate για να ελέγξετε την άποψη κύλισης χρήστη.

#pragma mark - UIScrollViewDelegate

- (void) scrollViewDidScroll: (UIScrollView *) scrollView {
    if (hideKeyboardOnScroll == YES) {
        [self.currentTextField resignFirstResponder];
    }
}

4) Εγγραφή σε κοινοποιήσεις πληκτρολόγιο σε [viewWillAppear] μέθοδο viewcontroller και διαγραφείτε σε [viewWillDisappear] μέθοδο.

- (void) viewWillAppear: (BOOL) animated {
    [super viewWillAppear: animated];

    [ [NSNotificationCenter defaultCenter] addObserver: self selector: @selector(keyboardWillShow:)
                                                  name: UIKeyboardWillShowNotification object: nil];
    [ [NSNotificationCenter defaultCenter] addObserver: self selector: @selector(keyboardWillHide:)
                                                  name: UIKeyboardWillHideNotification object: nil];
}

- (void) viewWillDisappear: (BOOL) animated {
    [super viewWillDisappear: animated];

    [ [NSNotificationCenter defaultCenter] removeObserver: self name: UIKeyboardDidShowNotification object: nil];
    [ [NSNotificationCenter defaultCenter] removeObserver: self name: UIKeyboardWillHideNotification object: nil];    
}

5) Λαβή ειδοποιήσεις πληκτρολόγιο:

- (void) keyboardWillShow: (NSNotification *) notification {
    CGRect keyboardFrame = [ [ [notification userInfo] objectForKey: UIKeyboardFrameBeginUserInfoKey] CGRectValue];

    // Find cell with textfield.
    CGRect textFieldFrame = [tableView convertRect: self.currentTextField.frame fromView: self.currentTextField];
    NSIndexPath *indexPath = [tableView indexPathForRowAtPoint: textFieldFrame.origin];
    UITableViewCell *cell = [tableView cellForRowAtIndexPath: indexPath];
    //

    // Shrink tableView size.
    CGRect tableViewFrame = tableView.frame;
    tableView.frame = CGRectMake(tableView.frame.origin.x, tableView.frame.origin.y, tableView.frame.size.width,
                             self.view.frame.size.height - tableView.frame.origin.y - keyboardFrame.size.height);
    //

    // Check if cell is visible in shrinked table size.
    BOOL cellIsFullyVisible = YES;
    if ( cell.frame.origin.y < tableView.contentOffset.y ||
        (cell.frame.origin.y + cell.frame.size.height) > (tableView.contentOffset.y + tableView.frame.size.height) ) {
        cellIsFullyVisible = NO;
    }
    //

    // If cell is not fully visible when scroll table to show cell;
    if (cellIsFullyVisible == NO) {
        CGPoint contentOffset = CGPointMake(tableView.contentOffset.x, CGRectGetMaxY(cell.frame) - tableView.frame.size.height);
        if (cell.frame.origin.y < tableView.contentOffset.y) {
            contentOffset.y = cell.frame.origin.y;
        }
        contentOffset.y = MAX(0, contentOffset.y);

        // For some reason [setContentOffset] is called without delay then
        // this code may not work for some cells. That why we call it with brief delay.
        dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.1 * NSEC_PER_SEC));
        dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
            [UIView animateWithDuration: 0.5 animations:^{
                [tableView setContentOffset: contentOffset animated: NO];
            } completion: ^(BOOL finished) {
                hideKeyboardOnScroll = YES;
            }];
        });
    } else {
        hideKeyboardOnScroll = YES;
    }
    //

    // Finally restore original table frame.
    tableView.frame = tableViewFrame;
    //
}

- (void) keyboardWillHide: (NSNotification *) notification {
    [super keyboardWillHide: notification];

    hideKeyboardOnScroll = NO;
}

Νομίζω ότι ο καλύτερος τρόπος είναι μέσω UITableViewController.

Αν θέλετε ένα UITableView σε UIViewController , απλά κάνει ένα ContentView με ενσωματωμένο UITableViewController και να θέσει τις ακόλουθες γραμμές στο viedDidLoad του UIViewController:

self.tableView = ((UITableViewController*)self.childViewControllers[0]).tableView;
self.tableView.delegate = self;
self.tableView.dataSource = self;

Εύκολη?)

Νομίζω ότι δεν υπάρχει «σωστό» τρόπο για να γίνει αυτό. Θα πρέπει να επιλέξετε το καλύτερο κατάλληλο λύση για την περίπτωση χρήσης σας. Στο iPad App μου έχω ένα UIViewControllerπου παρουσιάζεται τρόπων μεταφοράς, όπως UIModalPresentationFormSheetκαι αποτελείται από ένα UITableView. Ο πίνακας αυτός περιέχει δύο UITextFieldsανά κύτταρο. Απλά καλώντας scrollToRowAtIndexPath:atScrollPosition:animated:στον textFieldDidBeginEditing:μέθοδος δεν λειτουργεί για μένα. Ως εκ τούτου έχω δημιουργήσει ένα tableFooterView:

- (void)viewDidLoad
{
    [super viewDidLoad];

    m_footerView = [[UIView alloc] initWithFrame:CGRectMake(0.0f, 0.0f, m_tableView.frame.size.width, 300.0f)];
    [m_footerView setBackgroundColor:[UIColor clearColor]];
    [m_tableView setTableFooterView:m_footerView];
    [m_footerView release];
}

Η ιδέα είναι ότι το πληκτρολόγιο κρύβει η tableFooterViewκαι όχι το UITextFields. Έτσι, η tableFooterViewπρέπει να είναι αρκετά υψηλή. Μετά από αυτό μπορείτε να χρησιμοποιήσετε scrollToRowAtIndexPath:atScrollPosition:animated:στη textFieldDidBeginEditing:μέθοδο.

Νομίζω ότι είναι επίσης δυνατό να εμφανίσετε και να αποκρύψετε τα tableFooterViewδυναμικά με την προσθήκη των παρατηρητών για τις κοινοποιήσεις πληκτρολόγιο, αλλά δεν το έχω δοκιμάσει ακόμα:

- (void)viewWillAppear:(BOOL)animated
{
    [super viewWillAppear:animated];

    [[NSNotificationCenter defaultCenter] addObserver:self 
                                             selector:@selector(keyboardWillShow:) 
                                                 name:UIKeyboardWillShowNotification 
                                               object:nil];
    [[NSNotificationCenter defaultCenter] addObserver:self 
                                             selector:@selector(keyboardWillHide:) 
                                                 name:UIKeyboardWillHideNotification 
                                               object:nil];
}

- (void)keyboardWillShow:(NSNotification *)notification 
{
     [m_tableView setTableFooterView:m_footerView];
}

- (void)keyboardWillHide:(NSNotification *)notification 
{
     [m_tableView setTableFooterView:nil];
}

- (void)viewWillDisappear:(BOOL)animated
{
    [super viewWillDisappear:animated];

    [[NSNotificationCenter defaultCenter] removeObserver:self name:UIKeyboardWillShowNotification object:nil];
    [[NSNotificationCenter defaultCenter] removeObserver:self name:UIKeyboardWillHideNotification object:nil];
}

έκανα δημιουργήσει ένα μικρό έργο που λύνει αυτό το πρόβλημα με το πληκτρολόγιο, στην περίπτωσή μου εγώ μόνο που χρειάζεται να κάνει η προβολή πίνακα ανεβαίνουν όταν το πληκτρολόγιο εμφανίζεται.

Η ελπίδα αυτό βοηθά!

http://git.io/BrH9eQ

Απλά κοίταξε ξανά μέσα στο iOS 5.0 lib αναφοράς και βρήκε αυτή την ενότητα με τίτλο «Moving το περιεχόμενο που βρίσκεται κάτω από το πληκτρολόγιο»: TextAndWebiPhoneOS KeyboardManagement

Είναι αυτό το νέο από το iOS 5, ίσως; Δεν έχω διαβάσει σε αυτό ακόμα και είμαι στη μέση του κάτι άλλο, αλλά ίσως άλλοι ξέρουν περισσότερα και μπορεί εμένα και τους άλλους διαφωτίσει εδώ.

Μήπως το έγγραφο της Apple αντικαθιστούν αυτά που έχουν συζητηθεί εδώ ή είναι οι πληροφορίες που εδώ ακόμα χρήσιμο για τους χρήστες iOS 5 SDK;

UITableViewControllerλειτουργεί η κύλιση αυτόματα, πράγματι. Η διαφορά σε σχέση με τη χρήση ενός UIViewControllerείναι, ότι θα πρέπει να δημιουργήσετε Navbar-Buttonitems προγραμματισμού με τη χρήση του NavigationController, όταν χρησιμοποιείτε ένα TableViewController.