Récupérer personnalisé prototype de la hauteur de la cellule de storyboard?

Lors de l'utilisation de "Dynamique des Prototypes" pour spécifier UITableView contenu sur la table de montage séquentiel, il y a une "Hauteur de Ligne" les biens qui peuvent être mis à la Coutume.

Lors de l'instanciation des cellules, cette coutume hauteur de ligne n'est pas pris en compte. Cela a du sens, puisque ce qui prototype de cellule que j'utilise est décidé par mon code d'application au moment de la cellule doit être instancié. Pour instancier toutes les cellules lors du calcul de la disposition introduirait une pénalité sur les performances, donc je comprends pourquoi cela ne peut pas être fait.

La question qui se pose alors, je peux en quelque sorte de récupérer la hauteur de la donnée d'une cellule de réutilisation de l'identificateur, par exemple 

[myTableView heightForCellWithReuseIdentifier:@"MyCellPrototype"];

ou quelque chose le long de cette ligne? Ou dois-je répéter l'explicite les hauteurs de ligne dans mon code de l'application, avec le fardeau de l'entretien qui suit?

Résolu, avec l'aide de @TimothyMoose:

Les hauteurs sont stockés dans les cellules elles-mêmes, ce qui signifie que le seul moyen de se les hauteurs consiste à instancier les prototypes. Une façon de le faire est de retirer les cellules à l'extérieur de la cellule normale de la méthode de rappel. Voici mon petit POC, qui fonctionne:

#import "ViewController.h"

@interface ViewController () {
    NSDictionary* heights;
}
@end

@implementation ViewController

- (NSString*) _reusableIdentifierForIndexPath:(NSIndexPath *)indexPath
{
    return [NSString stringWithFormat:@"C%d", indexPath.row];
}

- (CGFloat) tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath
{
    if(!heights) {
        NSMutableDictionary* hts = [NSMutableDictionary dictionary];
        for(NSString* reusableIdentifier in [NSArray arrayWithObjects:@"C0", @"C1", @"C2", nil]) {
            CGFloat height = [[tableView dequeueReusableCellWithIdentifier:reusableIdentifier] bounds].size.height;
            hts[reusableIdentifier] = [NSNumber numberWithFloat:height];
        }
        heights = [hts copy];
    }
    NSString* prototype = [self _reusableIdentifierForIndexPath:indexPath];
    return [heights[prototype] floatValue];
}

- (NSInteger) tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
    return 3;
}

- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView
{
    return 1;
}

- (UITableViewCell*) tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    NSString* prototype = [self _reusableIdentifierForIndexPath:indexPath];
    UITableViewCell* cell = [tableView dequeueReusableCellWithIdentifier:prototype];
    return cell;
}

@end
  • J'avais été en utilisant cette méthode pendant un certain temps, puis sur un nouveau storyboard, j'étais surtout zéro-hauteur (et largeur) dimensions pour les cellules. Même les non-zéro ont des valeurs inattendues. La désactivation de la taille des classes restauré cette fonctionnalité. Décevant, bien que, depuis cette "solution", désactivé, d'importantes fonctions dans le storyboard. Cependant, cela a fonctionné pour mon besoin immédiat.
  • J'ai trouvé une solution plus complète pour la résolution de ce problème avec la taille des classes activé.
InformationsquelleAutor Krumelur | 2012-12-01
  1. 28

    Statique (non-piloté par les données) de la hauteur, vous pouvez simplement retirer la cellule une fois et stocker de la hauteur:

    - (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath
{
    static NSNumber *height;
    if (!height) {
        UITableViewCell *cell = [self.tableView dequeueReusableCellWithIdentifier:@"MyCustomCell"];
        height = @(cell.bounds.size.height);
    }
    return [height floatValue];
}

    Dynamique (data-driven) de la hauteur, vous pouvez stocker un prototype de cellule dans la vue de contrôleur et d'ajouter une méthode à la cellule de la classe qui calcule la hauteur, en prenant en compte le contenu par défaut du prototype de l'instance, comme la sous-vue de placement, les polices, etc.:

    - (MyCustomCell *)prototypeCell
{
    if (!_prototypeCell) {
        _prototypeCell = [self.tableView dequeueReusableCellWithIdentifier:@"MyCustomCell"];
    }
    return _prototypeCell;
}

- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath
{
    //Data for the cell, e.g. text for label
    id myData = [self myDataForIndexPath:indexPath];

    //Prototype knows how to calculate its height for the given data
    return [self.prototypeCell myHeightForData:myData];
}

    Bien sûr, si vous êtes à l'aide personnalisée hauteur, vous avez sans doute plusieurs cellules prototypes, donc, si vous voulez les stocker dans un dictionnaire ou quelque chose.

    Aussi loin que je peux dire, la vue de la table n'essayez pas de réutiliser le prototype, sans doute parce qu'il a été retiré à l'extérieur de cellForRowAtIndexPath:. Cette approche a très bien fonctionné pour nous, car elle permet à l'utilisateur de modifier les cellules mises en page dans la table de montage séquentiel sans nécessiter aucune modification de code.

    Edit: précisé le sens de l'exemple de code et ajout d'un exemple pour le cas de la hauteur statique.

    • Je ne reconnais pas le heightForData: méthode. Que faut-il faire?
    • heightForData: est une méthode que vous voulez écrire pour calculer la hauteur de la cellule de données.
    • Je vois. Le problème c'est que je veux utiliser la hauteur stockées dans la table de montage séquentiel du fichier lui-même (d'une hauteur statique). Votre pré-dequeueing de cellules peuvent travailler pour que trop bien. Je vais l'essayer.
    • Elle fonctionne. Merci! Je mettrai à jour la question avec la solution complète pour aider les autres.
    • Yep, mon montage est un exemple de la hauteur statique ainsi.
    • Jetez un oeil à TLIndexPathTools. Il calcule la hauteur de cellule en créant automatiquement un prototype et a) le retour des prototypes hauteur statique ou, b) si la cellule met en œuvre la TLDynamicSizeView prototype, le retour de la dynamique de la hauteur. Voir le Dynamique de la Hauteur exemple de projet. C'est vraiment un élément secondaire de la bibliothèque, mais il vaut la peine de vérifier.
    • Le problème avec cette approche est qu'elle ne fonctionne pas lorsque votre interface changements d'orientation de Portrait à Paysage. Solution Possible: Réinitialisation de l'image/largeur de la cellule à la largeur du tableau, avant le calcul de la hauteur en heightForRowAtIndexPath: la méthode. Espérons que cette aide.

    InformationsquelleAutor Timothy Moose
  2. 5

    J'ai créé une catégorie pour UITableView il y a quelques temps qui pourraient venir en aide pour cela. Il stocke des "prototypes" de cellules à l'aide de associée objets pour la réutilisation des prototypes et fournit une méthode pratique pour l'obtention de la hauteur de la ligne assigné dans le storyboard. Les prototypes sont libérés lors de l'affichage de la table est libéré.

    UITableView+PrototypeCells.h

    #import <UIKit/UIKit.h>

@interface UITableView (PrototypeCells)

- (CGFloat)heightForRowWithReuseIdentifier:(NSString*)reuseIdentifier;
- (UITableViewCell*)prototypeCellWithReuseIdentifier:(NSString*)reuseIdentifier;

@end

    UITableView+PrototypeCells.m

    #import "UITableView+PrototypeCells.h"
#import <objc/runtime.h>

static char const * const key = "prototypeCells";

@implementation UITableView (PrototypeCells)
- (void)setPrototypeCells:(NSMutableDictionary *)prototypeCells {
    objc_setAssociatedObject(self, key, prototypeCells, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

- (NSMutableDictionary *)prototypeCells {
    return objc_getAssociatedObject(self, key);
}

- (CGFloat)heightForRowWithReuseIdentifier:(NSString*)reuseIdentifier {
    return [self prototypeCellWithReuseIdentifier:reuseIdentifier].frame.size.height;
}

- (UITableViewCell*)prototypeCellWithReuseIdentifier:(NSString*)reuseIdentifier {
    if (self.prototypeCells == nil) {
        self.prototypeCells = [[NSMutableDictionary alloc] init];
    }

    UITableViewCell* cell = self.prototypeCells[reuseIdentifier];
    if (cell == nil) {
        cell = [self dequeueReusableCellWithIdentifier:reuseIdentifier];
        self.prototypeCells[reuseIdentifier] = cell;
    }
    return cell;
}

@end

    Utilisation

    L'obtention de la hauteur statique définie dans la table de montage est aussi simple que cela:

    - (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath {
    return [tableView heightForRowWithReuseIdentifier:@"cellIdentifier"];
}

    En supposant une multi-section d'affichage de tableau:

    enum {
    kFirstSection = 0,
    kSecondSection
};

static NSString* const kFirstSectionRowId = @"section1Id";
static NSString* const kSecondSectionRowId = @"section2Id";

- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath {
    CGFloat height = tableView.rowHeight; //Default UITableView row height
    switch (indexPath.section) {
        case kFirstSection:
            height = [tableView heightForRowWithReuseIdentifier:kFirstSectionRowId];
            break;
        case kSecondSection:
            height = [tableView heightForRowWithReuseIdentifier:kSecondSectionRowId];
    }
    return height;
}

    Et, enfin, si la hauteur de ligne est dynamique:

    - (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath {
    id thisRowData = self.allData[indexPath.row]; //Obtain the data for this row

    //Obtain the prototype cell
    MyTableViewCell* cell = (MyTableViewCell*)[self prototypeCellWithReuseIdentifier:@"cellIdentifier"];

    //Ask the prototype cell for its own height when showing the specified data
    return [cell heightForData:thisRowData];
}
    • Cela ressemble vraiment utile. Merci!
    • Grande mise en œuvre, vous devriez le mettre sur github & pot
    InformationsquelleAutor redent84