Affichage des articles dont le libellé est Vues tableau. Afficher tous les articles
Affichage des articles dont le libellé est Vues tableau. Afficher tous les articles

samedi 10 mars 2012

Cellules Voir tableau Redux

Il ya assez longtemps, j'ai posté au sujet Méthode recommandée par Apple de faire usage des cellules de tableau dans Interface Builder. Le code de ce poste a été disponible pendant 9 mois et aujourd'hui, pour la première fois, quelqu'un m'a fait remarquer que le projet ci-jointe ne pas réutiliser les cellules dequeued parce que j'ai oublié de taper l'identifiant de la cellule dans Interface Builder.

Quelle est la faiblesse de l'approche recommandée Apple. C'est un véritable talon d'Achille. C'est vraiment, vraiment facile d'oublier cette étape, et le code fonctionne parfaitement bien si vous ne l'oubliez, vous êtes juste de manger la mémoire et les performances deviennent plus pauvres que vous devriez. Sauf si vous le profil de vos applications ou de test avec des ensembles de données très volumineux, vous pourriez très bien expédier votre app de ce genre et même pas s'en rendre compte. Vous ne voulez jamais à vos clients de découvrir ces choses avant vous.

Maintenant, je ne savais même pas que j'avais fait cette erreur jusqu'à aujourd'hui, mais j'ai su que c'était un problème potentiel pour un certain temps, ce qui explique pourquoi, dans mon contrat de travail, j'ai commencé à utiliser une version modifiée du technique. Mon erreur précédemment donne-moi maintenant une bonne excuse pour après cette modification.

Surtout, c'est la même technique que j'ai discuté avant, seulement je commence par définir une constante pour l'identifiant. En fait, j'ai créer un fichier en-tête dans mes projets Xcode ConstantsAndMacros.h dans mon projet, qui je ajouter à mon fichier d'entête pré-compilés. Cela signifie que toutes les constantes et les macros j'ai mis dans ConstantsAndMacros.h sera disponible pour tous mes fichiers de code source dans mon projet sans avoir à les importer manuellement. Pour un projet simple, ce fichier pourrait ressembler à ceci:


#define TABLE_CELL_IDENTIFIER @"Table Cell Identifier"
#define NSStubLog() NSLog(@"%s", __PRETTY_FUNCTION__)^1

Une fois que j'ai ce fichier, je l'ajouter au fichier. Pch dans le Autres sources folder:

#ifdef __OBJC__
#import <Foundation/Foundation.h>
#import <UIKit/UIKit.h>
#import "ConstantsAndMacros.h"
#endif

Maintenant que constante est disponible vaste projet ^ 2. Ensuite, dans mon sous-classe UITableViewCell, je substituer la méthode reuseIdentifier et ajouter une méthode de classe avec le même nom, comme ceci:

+ (NSString *)reuseIdentifier
{
return (NSString *)TABLE_CELL_IDENTIFIER;
}

- (NSString *)reuseIdentifier
{
return [[self class] reuseIdentifier];
}

En faisant cela, le système va ignorer tout identifiant j'ai mis dans Interface Builder, ou tout autre valeur que j'ai mis dans le code en utilisant les setBundleIdentifier: méthode mutateur. Pour les instances de cette classe particulière, il sera toujours utiliser le même identifiant. En créant la méthode de classe, j'ai accès à cet identifiant, même si je ne dispose pas encore d'une instance de la classe.

Pour toutes les autres étapes de l'aide personnalisée de cellules de tableau chargé à partir d'une plume, le processus est le même que le didacticiel précédent et il fonctionne très bien. Voici un exemple de tableView: cellForRowAtIndexPath: méthode utilisant cette technique:

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath 
{
TestCell *cell = (TestCell *)[tableView dequeueReusableCellWithIdentifier:[TestCell reuseIdentifier]];
if (cell == nil)
{
NSLog(@"Loading new cell");
[[NSBundle mainBundle] loadNibNamed:@"TestCell" owner:self options:nil];
cell = loadCell;
self.loadCell = nil;
}

cell.cellLabel.text = [NSString stringWithFormat:@"Row %d", [indexPath row]];
return cell;
}

Notez le NSLog () déclaration? Je peux ouvrir ma cellule de tableau dans Interface Builder et mettre tout identifiant que je veux, ou un ensemble pas d'identifiant à tous, et il sera toujours ré-utiliser des cellules de tableau. Exécuter l'application, et peu importe ce que vous faites dans Interface Builder, vous ne verrez une poignée de lignes chargées à partir du fichier nib. Après le chargement initial, il va tout simplement continuer de réutiliser les instances même cellule à plusieurs reprises. Ce qui est loin moins fragiles que d'avoir à s'assurer que l'identifiant de l'IB et celui de votre match de code.

Il pourrait y avoir des moments où vous ne voulez pas l'installer comme ça - quand vous avez besoin d'avoir plusieurs identifiants pour la classe d'affichage d'une même table, mais ces situations seront extrêmement rares. Dans la plupart des situations pratiques où vous êtes sous-classes UITableViewCell, vous voulez un identifiant unique pour toutes les instances de cette classe. Ce que vous ne voulez normalement est la fragilité d'avoir à vous assurer de la valeur dans votre code correspond à celle de IB exactement, surtout étant donné qu'il n'y a aucun signe évident que vous avez oublié de le faire.


1 Cette macro journaux juste le nom de la méthode de la fonction qu'il est placé dans lorsque cette méthode est appelée. Je l'utilise chaque fois que je bouchonner une méthode pour s'assurer IBAction mes connexions sont toutes faites correctement, d'où le nom, mais c'est utile pour le débogage ainsi.

2 Si vous utilisez uniquement une cellule de tableau dans un seul contrôleur, vous n'avez probablement pas le voulez ici. En général, j'essaie de créer des cellules de tableau pour être suffisamment générique pour être utilisé dans plus d'un contrôleur. Parfois, ce n'est pas possible ou pratique, et dans ces cas, # define votre identifiant dans l'en-tête du contrôleur de table tenu à la place.

Vous pouvez trouver un projet de mise en œuvre de l'échantillon ici/

jeudi 8 mars 2012

Chapitre 4 et le conte de la NSFetchedResultsController

Bon, certaines personnes ont eu des problèmes sporadiques avec le chapitre 4 application comme décrit ici. La solution que je voudrais utiliser, il faudrait être capable de déterminer le nombre de cours, des encarts et supprime la section non engagés qui a une vue de table. Bien que je peux obtenir cette information, je ne peux le faire en accédant à une variable d'instance privée de UITableView. Évidemment, je ne veux pas vous donner tous une solution qui va devenir votre application rejetés au cours du processus d'examen.

Donc, je suis retourné à la planche à dessin. Je n'aime pas cette solution comme beaucoup depuis qu'il nous oblige à reproduire le travail que la vue de table est déjà fait en gardant un décompte ombre d'insertions et des suppressions, mais il semble bien fonctionner et ne pas ajouter trop de complexité. J'ai maintenant un cas de test assez approfondie pour l'insertion et la suppression de lignes dans une table qui utilise une NSFetchedResultsController et cette solution passe, alors croisons les doigts.

La solution


La première étape est d'ajouter une des variables d'instance privées @ NSUInteger à la classe contrôleur qui gère la table et alla chercher le contrôleur résultats. Cela permet de garder un compte courant du nombre de sections insérées et supprimées lors d'une lot de mises à jour de table.

Dans le contexte de l'application de chapitre 4, ce qui signifie en ajoutant la ligne suivante en gras du code HeroListViewController.h:

#import <UIKit/UIKit.h>

#define kSelectedTabDefaultsKey @"Selected Tab"
enum {
kByName = 0,
kBySecretIdentity,
}
;
@class HeroEditController;
@interface HeroListViewController : UIViewController <UITableViewDelegate, UITableViewDataSource, UITabBarDelegate, UIAlertViewDelegate, NSFetchedResultsControllerDelegate>{

UITableView *tableView;
UITabBar *tabBar;
HeroEditController *detailController;

@private
NSFetchedResultsController *_fetchedResultsController;
NSUInteger sectionInsertCount;
}

@property (nonatomic, retain) IBOutlet UITableView *tableView;
@property (nonatomic, retain) IBOutlet UITabBar *tabBar;
@property (nonatomic, retain) IBOutlet HeroEditController *detailController;
@property (nonatomic, readonly) NSFetchedResultsController *fetchedResultsController;
- (void)addHero;
- (IBAction)toggleEdit;
@end



Maintenant, nous devons passer à la mise en œuvre du fichier, HeroListViewController.m et ajouter une ligne de code pour réinitialiser le compteur d'insérer quand nous serons avisés par le contrôleur chercher des résultats que des changements sont à venir. Pour ce faire, nous ajoutons une ligne de code à l'controllerWillChangeContent méthode:, comme ceci:

- (void)controllerWillChangeContent:(NSFetchedResultsController *)controller {
sectionInsertCount = 0;
[self.tableView beginUpdates];
}

Ensuite, nous avons pour incrémenter cette variable lorsque nous insérer une section, et il décrémente chaque fois que nous supprimer une section dans le contrôleur: didChangeSection: atIndex: forChangeType:. Nous faisons cela en ajoutant le code en gras ci-dessous:

- (void)controller:(NSFetchedResultsController *)controller didChangeSection:(id <NSFetchedResultsSectionInfo>)sectionInfo atIndex:(NSUInteger)sectionIndex forChangeType:(NSFetchedResultsChangeType)type {
switch(type) {

case NSFetchedResultsChangeInsert:
if (!((sectionIndex == 0) && ([self.tableView numberOfSections] == 1))) {
[self.tableView insertSections:[NSIndexSet indexSetWithIndex:sectionIndex] withRowAnimation:UITableViewRowAnimationFade];
sectionInsertCount++;
}


break;
case NSFetchedResultsChangeDelete:
if (!((sectionIndex == 0) && ([self.tableView numberOfSections] == 1) )) {
[self.tableView deleteSections:[NSIndexSet indexSetWithIndex:sectionIndex] withRowAnimation:UITableViewRowAnimationFade];
sectionInsertCount--;
}


break;
case NSFetchedResultsChangeMove:
break;
case NSFetchedResultsChangeUpdate:
break;
default:
break;
}

}

Enfin, chaque fois que nous faisons notre vérification de la cohérence dans le contrôleur: didChangeObject: atIndexPath: forChangeType: newIndexPath: nous avons à prendre les inserts en attente et supprime en compte. Puisque nous ne l'cocher plus d'une fois et insérez de nouvelles sections lorsque la vérification échoue, nous avons également incrémenter la variable si nous ne nous insérer de nouvelles lignes. Nous faisons tout cela en ajoutant le code ci-dessous en gras dans cette méthode:

- (void)controller:(NSFetchedResultsController *)controller didChangeObject:(id)anObject atIndexPath:(NSIndexPath *)indexPath forChangeType:(NSFetchedResultsChangeType)type newIndexPath:(NSIndexPath *)newIndexPath {
switch(type) {
case NSFetchedResultsChangeInsert:
[self.tableView insertRowsAtIndexPaths:[NSArray arrayWithObject:newIndexPath] withRowAnimation:UITableViewRowAnimationFade];
break;
case NSFetchedResultsChangeDelete:
[self.tableView deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath] withRowAnimation:UITableViewRowAnimationFade];
break;
case NSFetchedResultsChangeUpdate: {
NSString *sectionKeyPath = [controller sectionNameKeyPath];
if (sectionKeyPath == nil)
break;
NSManagedObject *changedObject = [controller objectAtIndexPath:indexPath];
NSArray *keyParts = [sectionKeyPath componentsSeparatedByString:@"."];
id currentKeyValue = [changedObject valueForKeyPath:sectionKeyPath];
for (int i = 0; i < [keyParts count] - 1; i++) {
NSString *onePart = [keyParts objectAtIndex:i];
changedObject = [changedObject valueForKey:onePart];
}

sectionKeyPath = [keyParts lastObject];
NSDictionary *committedValues = [changedObject committedValuesForKeys:nil];

if ([[committedValues valueForKeyPath:sectionKeyPath] isEqual:currentKeyValue])
break;

NSUInteger tableSectionCount = [self.tableView numberOfSections];
NSUInteger frcSectionCount = [[controller sections] count];
if (tableSectionCount + sectionInsertCount != frcSectionCount) {
// Need to insert a section
NSArray *sections = controller.sections;
NSInteger newSectionLocation = -1;
for (id oneSection in sections) {
NSString *sectionName = [oneSection name];
if ([currentKeyValue isEqual:sectionName]) {
newSectionLocation = [sections indexOfObject:oneSection];
break;
}

}

if (newSectionLocation == -1)
return; // uh oh

if (!((newSectionLocation == 0) && (tableSectionCount == 1) && ([self.tableView numberOfRowsInSection:0] == 0))) {
[self.tableView insertSections:[NSIndexSet indexSetWithIndex:newSectionLocation] withRowAnimation:UITableViewRowAnimationFade];
sectionInsertCount++;
}


NSUInteger indices[2] = {newSectionLocation, 0};
newIndexPath = [[[NSIndexPath alloc] initWithIndexes:indices length:2] autorelease];
}

}

case NSFetchedResultsChangeMove:
if (newIndexPath != nil) {

NSUInteger tableSectionCount = [self.tableView numberOfSections];
NSUInteger frcSectionCount = [[controller sections] count];
if (frcSectionCount != tableSectionCount + sectionInsertCount) {
[self.tableView insertSections:[NSIndexSet indexSetWithIndex:[newIndexPath section]] withRowAnimation:UITableViewRowAnimationNone];
sectionInsertCount++;
}



[self.tableView deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath] withRowAnimation:UITableViewRowAnimationFade];
[self.tableView insertRowsAtIndexPaths: [NSArray arrayWithObject:newIndexPath]
withRowAnimation: UITableViewRowAnimationRight
]
;

}

else {
[self.tableView reloadSections:[NSIndexSet indexSetWithIndex:[indexPath section]] withRowAnimation:UITableViewRowAnimationFade];
}

break;
default:
break;
}

}


Je vais pousser ce nouveau code dans l'archive du projet dès que possible et obtenir qu'il affichés apress.com et iphonedevbook.com, mais voici la version actualisée du projet de chapitre 4 Xcode dans l'intervalle.

Ne vous inquiétez pas si vous ne comprenez pas tout ce qui se passe dans ce code. Ceci est du code conçu pour être méchant complètement générique de sorte que vous n'avez pas à vous soucier du tout. Espérons que ce sera la fin de nos ennuis avec NSFetchedResultsController.

Un autre Gotcha TableView / NSFetchedResultsController

Si vous avez suivi ce blog, pour toute longueur de temps, vous savez que j'ai été de verrouillage cornes avec NSFetchedResultsController et périodiquement libérant versions mises à jour du modèle de navigation basé sur Core Data Xcode pour répondre aux différents problèmes, des incohérences et pièges que j'ai découverts au cours de mon combat.

Since Plus l'iPhone 3 de développement a été libéré, j'ai été faire des rapports sporadiques d'un problème avec le chapitre 4 version de l'application des données de base qui, jusqu'à hier soir, je n'avais pas été capable de se reproduire. Un lecteur a pu enfin me faire parvenir des instructions précises, et voilà, j'ai été capable de reproduire le problème.

Donc, j'ai commencé à parcourir le code, et a constaté que dans certaines situations (dont les paramètres, je n'ai pas totalement compris encore), mon code est d'essayer d'insérer deux sections dans la table quand une seule nouvelle section est requis par la mise à jour. Il se produit quand une valeur utilisée dans le chemin de clé section est changé, mais pas toujours quand ça arrive.

Qu'est-ce qui se passe est, dans le contrôleur: didChangeSection: atIndex: forChangeType:, je averti d'une nouvelle section étant insérée dans le contrôleur de chercher les résultats et insérez une section correspondant à l'endroit approprié dans le tableau, comme ceci:

    [self.tableView insertSections:[NSIndexSet indexSetWithIndex:sectionIndex] withRowAnimation:UITableViewRowAnimationFade];

Tout va bien, non? Mais alors, dans le contrôleur: didChangeObject: atIndexPath: forChangeType: newIndexPath: qui tire après, j'ai du code qui vérifie que le nombre de correspondances entre le contrôleur sections chercher les résultats et la vue du tableau. Ce code est nécessaire parce que dans certaines situations, NSFetchedResultController ne pas dire son délégué, si une nouvelle section a été créée. C'est un chèque assez simple, je viens de trouver le nombre de sections dans le contrôleur de chercher les résultats et dans le tableau et quand ils ne correspondent pas, je insérer une nouvelle section dans la table.

    NSUInteger tableSectionCount = [self.tableView numberOfSections];
NSUInteger frcSectionCount = [[controller sections] count];
if (frcSectionCount != tableSectionCount)
[self.tableView insertSections:[NSIndexSet indexSetWithIndex:[newIndexPath section]] withRowAnimation:UITableViewRowAnimationNone];

Et cela fonctionne la plupart du temps. Mais, parfois, elle n'existe pas. La nature sporadique, il est difficile à déboguer, mais j'ai finalement réussi à progresser dans le code quand il se passait. Dans le contrôleur: didChangeSection: atIndex: forChangeType: avant la ligne de code qui insère une nouvelle section, j'ai vérifié le nombre de sections dans la vue du tableau. Il y avait cinq.

Puis, après la ligne de code qui a inséré l'article, j'ai vérifié à nouveau. Il y avait encore cinq ans.

Sonne comme un bug dans le code d'Apple, non? En fait, il n'est pas. Il est documenté comportement.

La documentation pour insertRowsAtIndexPath: withRowAnimation: sur UITableView dit:
UITableView reporte toutes les insertions de lignes ou de sections jusqu'à ce qu'il ait manipulé les suppressions de lignes ou de sections. Cela se produit indépendamment de la commande de l'insertion et appelle la méthode de suppression.
Cela me laisse avec un bon casse-tête. Depuis mon code n'est pas directement la gestion de la table, mais NSFetchedResultsController reporte certaines tâches à son délégué, qui is mon code, je n'ai pas un moyen facile (que je connais encore) afin de déterminer quand l'insertion de la ligne du code précédent va être reporté par conséquent la cause de mes plus tard, vérifiez à l'échec.

Une solution, qui se sent kludgey, serait d'avoir une variable d'instance BOOL à suivre quand une méthode déléguée appel antérieur a inséré une ligne. Je n'aime pas cette solution, bien, donc je suis à la recherche d'une meilleure option à intégrer dans mes méthodes déléguée génériques.

Je vous tiendrai tous les jour sur ma progression, mais si vous avez des idées comment je peux déterminer si il ya un insert en attente dans une table, n'hésitez pas à les partager dans les commentaires.

Mise à jour 1: Il est un organisme privé mutables tableau appelé _insertItems qui détient les insertions différé. Même si c'est publié dans le fichier d'entête, je pense que l'accès à ce utiliser directement serait techniquement considéré comme une API privée. Les variables d'instance avec un trait de soulignement sont considérées comme privées par Apple, même s'ils sont publiés dans un fichier d'entête.

Mise à jour 2/>: Je possède une version fonctionnant illicites! Malheureusement, je ne peux pas l'utiliser car il nécessite l'accès aux variables d'instance privées de UITableView. Une fois que Rapporteur de bogues d'Apple est de retour, je vais mettre dans une demande d'amélioration de l'information dont j'ai besoin rendue publique, mais je vais probablement devoir trouver une autre solution provisoire, et il sera probablement hacky .

Pour les curieux, ce que j'ai fait était de créer une catégorie sur UITableView qui a ajouté cette méthode:

- (NSUInteger)numberOfPendingSectionInserts
{
NSUInteger ret = 0;
for (id /* UIUpdateItem */ oneUpdateItem in _insertItems)
{
if ([oneUpdateItem isSectionOperation])
ret++;
}

return ret;
}

Maintenant, ne pas l'utiliser dans vos applications, comme vous aurez rejetée de l'App Store. UIUpdateItem n'est pas une classe publique, et _insertItems n'est pas une variable d'instance publique (même si c'est contenu dans un fichier en-tête du public). Si cette information soit rendue disponible, alors je serais capable de faire un contrôle de cohérence plus robuste qui permettrait d'éliminer le problème d'insertion double:

    NSUInteger tableSectionCount = [self.tableView numberOfSections] + [self.tableView numberOfPendingSectionInserts];
NSUInteger frcSectionCount = [[controller sections] count];
if (frcSectionCount != tableSectionCount)
[self.tableView insertSections:[NSIndexSet indexSetWithIndex:[newIndexPath section]] withRowAnimation:UITableViewRowAnimationNone];


Utiliser les mises à jour le tableau KVO

Si vous avez suivi les lignes directrices Apple Guide de mise en œuvre du modèle d'objet lorsque vous créez votre modèle de données objets, vous pouvez gérer vos mises à jour en utilisant UITableView KVO. Cela vous évite d'avoir à répandre des appels à reloadData, insertRowsAtIndexPaths: withRowAnimation: ou deleteRowsAtIndexPaths: withRowAnimation: tout au long de votre classe contrôleur où les données de votre table peut se changer.

Au lieu de cela, tout ce que vous avez à faire est d'observer l'keypath sur votre objet modèle de données qui contient la collection d'objets d'être affichées dans le tableau. La meilleure façon de faire qui est dans la méthode viewDidLoad votre contrôleur de tableau, comme ceci:

    [self.data addObserver:self
forKeyPath:@"items"
options:0
context:NULL
]
;

Ensuite, il vous suffit œuvre observeValueForKeyPath: ofObject: le changement: le contexte d'insérer ou de supprimer des lignes en fonction des changements observés à la collecte. Les informations sur les lignes qui ont été insérées ou supprimées vient dans le dictionnaire modifications stockées sous la NSKeyValueChangeIndexesKey clés. L'information vient sous la forme d'ensembles d'index, et ceux qui doivent être convertis en chemins d'index afin de mettre à jour la table. Mais c'est la seule chose sur ce code qui n'est pas assez simple, et cette mise en œuvre est assez générique, donc vous devriez être capable de copier à peu près et de le coller dans votre contrôleur si vous voulez l'utiliser.

Si vous ne faites cela, assurez-vous de supprimer tous les autres appels retirer et insérer, sinon vous allez supprimer double et double-insert, ce qui provoquera des erreurs à l'exécution.

- (void)observeValueForKeyPath:(NSString *)keyPath
ofObject:(id)object
change:(NSDictionary *)change
context:(void *)context
{
NSIndexSet *indices = [change objectForKey:NSKeyValueChangeIndexesKey];
if (indices == nil)
return; // Nothing to do


// Build index paths from index sets
NSUInteger indexCount = [indices count];
NSUInteger buffer[indexCount];
[indices getIndexes:buffer maxCount:indexCount inIndexRange:nil];

NSMutableArray *indexPathArray = [NSMutableArray array];
for (int i = 0; i < indexCount; i++) {
NSUInteger indexPathIndices[2];
indexPathIndices[0] = 0;
indexPathIndices[1] = buffer[i];
NSIndexPath *newPath = [NSIndexPath indexPathWithIndexes:indexPathIndices length:2];
[indexPathArray addObject:newPath];
}


NSNumber *kind = [change objectForKey:NSKeyValueChangeKindKey];
if ([kind integerValue] == NSKeyValueChangeInsertion) // Rows were added
[self.tableView insertRowsAtIndexPaths:indexPathArray withRowAnimation:UITableViewRowAnimationFade];
else if ([kind integerValue] == NSKeyValueChangeRemoval) // Rows were removed
[self.tableView deleteRowsAtIndexPaths:indexPathArray withRowAnimation:UITableViewRowAnimationFade];

}

Une fois que vous avez fait cela, vous pouvez oublier rechargement de votre table. Toute modification apportée aux données sous-jacentes - même les modifications apportées sur d'autres threads (en supposant que votre classe de modèle de données est thread-safe) déclenchera automatiquement une suppression ou l'insertion d'animation. Bien que le code ci-dessus peut sembler un peu intimidant, cela permet effectivement une conception beaucoup plus propre en général.

J'ai créé un assez simple projet Xcode qui illustre à l'aide KVO de mettre à jour une vue de table.

jeudi 23 février 2012

Cellules Table View dans Interface Builder - la manière dont Apple ™

Lorsque Dave et j'ai écrit Début de développement iPhone, Le SDK a été très bien en version bêta, et beaucoup de la documentation était incomplète ou totalement absente. Étant donné que, je pense que nous avons fait un très bon travail essayant de coller avec Apple "meilleures pratiques" et à deviner ce qui allait plus tard les techniques évoluer vers les meilleures pratiques. Dans un nombre surprenant d'endroits, nous le faisons de la WayTM Apple, même si nous n'étions pas sûrs à 100% ce que le WayTM Apple serait quand nous étions l'écriture du livre.

Nous avons bien fait, mais nous n'avons pas de chauve-souris 1,000.

Un endroit où nous avons manqué de chargement était dans les cellules de tableau créé dans Interface Builder.

Dans la première édition du livre, nous avons codé en dur de l'indice de la cellule. Cela a été mauvaise, parce que quand 2,1 expédiée, la structure du tableau retourné par NSBundle changé et notre code cassé. Whoops!

Dans la seconde édition, nous l'avons changé pour que le code n'utilise plus un indice codé en dur, mais au lieu itère sur le tableau retourné à la recherche d'un objet de la classe à droite (UITableViewCell). Ce fut une bien meilleure approche et fonctionne très bien.

Quelqu'un chez Apple pensé une meilleure façon. C'est effing brillant. Si brillante, en fait, que lorsque j'ai rencontré la documentation pour cela, il m'a fallu un certain temps pour comprendre exactement ce qu'ils faisaient. Voici le code exemple de la documentation d'Apple:

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
static NSString *MyIdentifier = @"MyIdentifier";

UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:MyIdentifier];
if (cell == nil) {
[[NSBundle mainBundle] loadNibNamed:@"TVCell" owner:self options:nil];
cell = tvCell;
self.tvCell = nil;
}

UILabel *label;
label = (UILabel *)[cell viewWithTag:1];
label.text = [NSString stringWithFormat:@"%d", indexPath.row];

label = (UILabel *)[cell viewWithTag:2];
label.text = [NSString stringWithFormat:@"%d", NUMBER_OF_ROWS - indexPath.row];

return cell;
}

C'est ce qui me confond au premier abord:

    if (cell == nil) {
[[NSBundle mainBundle] loadNibNamed:@"TVCell" owner:self options:nil];
cell = tvCell;
self.tvCell = nil;
}

La méthode loadNibNamed: le propriétaire: options retourne un NSArray avec le contenu de la plume, mais ce code ignore complètement ce tableau. Il n'a même pas le capturer. Ensuite, elle va sur et ayants allègrement quelques variables d'instance à une autre variable, par exemple, puis définit la variable première instance à néant.

Documentation d'Apple n'est pas parfait, mais habituellement, il est sacrément bon, si j'étais assez sûr que ce code a été bonne, je n'étais pas obtenir quelque chose. Il y avait une pièce du puzzle manquant.

Alors, j'ai regardé tvCell, qui a été déclaré plus tôt, et j'ai vu que c'était une IBOutlet.

"Plus curieux!" S'écria Alice.

Puis il m'est apparu. Le chargeur se connecte automatiquement bundle points faits pour Fichier de propriétaire quand il charge un fichier nib si la sortie est nulle. Notez que lorsque la plume est chargé, le code précise l'auto que le propriétaire du bundle. Donc, puisque cette classe est le contrôleur de Fichier de propriétaire, Lorsque nous avons la charge de la plume, la prise aurez connecté à un objet dans la plume si la sortie de ce nom sur les Fichier de propriétaire est relié à un objet dans la plume.

Alors, qu'est-ce qui se passe est, la cellule est créée dans son propre fichier nib. L' Fichier de propriétaire pour ce fichier nib est notre contrôleur de tableau où le code réside au-dessus. Dans le fichier nib, la prise sur le tvCell Fichier de propriétaire est relié à la cellule personnalisé qui est créé.

Donc, après cette ligne de code:
[[NSBundle mainBundle] loadNibNamed:@"TVCell" owner:self options:nil];

tvCellis automatiquement connecté à la cellule personnalisé qui a été créé en vertu de la connexion de sortie de la plume. Il n'y a aucun besoin de s'inquiéter de boucle ou des indices. Le chargeur de bundle fait ça automatiquement. Ainsi, cette cellule personnalisé est ensuite affecté à la cellule qui est la cellule de tableau que cette méthode revient à la table pour afficher le contenu de cette ligne. Après cela, tvCell est fixé à zéro de sorte que la prochaine fois que cette méthode est appelée, le chargeur une fois encore bundle relie la sortie pour nous.

C'est tout simplement génial. Bravo à quiconque chez Apple pensait d'elle.

Si vous souhaitez le voir en action, Voici un projet Xcode qui utilise cette technique.

dimanche 29 janvier 2012

Voir la table Multi-Mode Edition Row


Si vous avez joué autour du tout avec UITableView de "Edit Mode", vous avez probablement été déçu qu'il ne supporte pas la possibilité de sélectionner puis supprimer plusieurs lignes dans la table, la façon dont vous pouvez faire dans l'application Mail d'Apple . Il a été l'une des améliorations les bienvenus faite dans l'iPhone OS 2.0, et j'ai été un peu déçu quand j'ai découvert que la capacité de faire qui n'a pas été ajouté à UITableView avec la version 2.0.

Personnellement, j'aimerais voir la fonctionnalité dans les applications iPhone plus basée sur des tables, donc j'ai jeté ensemble un projet petit échantillon iPhone qui montre comment le faire. Vous pouvez trouver le projet Right Here.

Je ne vais pas à marcher à travers les projets entiers, comme la plupart des applications standards, il est des capacités, mais je tenais à souligner l'approche générale que j'ai utilisé. Je ne sais pas si c'est exactement ce courrier qu'il fait, et je ne suis certainement pas sûr que ce soit la meilleure façon de le faire, mais ça fonctionne. Le seul aspect de la mise en œuvre Mail Je n'ai pas change la couleur de fond des lignes sélectionnées en mode édition. Je l'ai essayé, mais devenait un comportement bizarre où la dernière ligne sélectionnés a été de retour en arrière vers le blanc, mais quand une autre ligne a été ajoutée à la sélection, alors il serait revenir à la couleur correcte. À un certain moment, je vais plonger et essayer de comprendre ce qui n'allait pas avec ce code, mais pour le moment, cela devrait fonctionner assez bien pour vous et pour au moins vous donner une idée de comment le processus peut fonctionner.

Dans ma classe contrôleur, j'ai défini quelques constantes et des macros:

#define kCellImageViewTag 1000
#define kCellLabelTag 1001

#define kLabelIndentedRect CGRectMake(40.0, 12.0, 275.0, 20.0)
#define kLabelRect CGRectMake(15.0, 12.0, 275.0, 20.0)

Les deux premiers seront utilisés plus tard pour récupérer les sous-vues correct de la cellule de tableau. Les deux derniers de définir les positions possibles du texte de la ligne. Si nous sommes en mode édition, le texte va être déplacé sur un peu (ce qui sera animé). En définissant les deux rectangles ici, nous pouvons changer le texte plus facilement simplement en assignant une nouvelle valeur à la propriété frame du label.

Dans mon contrôleur, j'ai deux tableaux mutables. On va contenir les valeurs d'affichage, l'autre sera utilisée pour maintenir les lignes qui sont sélectionnées quand nous sommes en mode édition. J'ai également définir un booléen qui va déterminer le moment où nous sommes en mode édition. Je n'appelle pas le modifier en mode parce que je ne veux pas risquer un conflit de nom ou de la confusion avec le code d'Apple.

NSMutableArray *countries;
NSMutableArray *selectedArray;
BOOL inPseudoEditMode;

J'ai également deux pointeurs UIImage qui contiennent l'image cochée ou décochée. C'est un peu klugey - le non contrôlée est juste un cercle, donc je devrais probablement avoir simplement utilisé CoreGraphics pour dessiner le cercle, mais ce fut plus facile.

UIImage *selectedImage;
UIImage *unselectedImage;

J'ai créé une méthode qui va créer le selectedArray, il peupler avec des objets NSNumber qui détiennent une valeur NO pour chaque ligne. Ce me permet facilement réinitialiser la sélection après une suppression.

- (void)populateSelectedArray
{
NSMutableArray *array = [[NSMutableArray alloc] initWithCapacity:[countries count]];
for (int i=0; i [array addObject:[NSNumber numberWithBool:NO]];
self.selectedArray = array;
[array release];
}

Cette méthode est appelée dans le viewDidLoad, et aussi chaque fois que nous supprimer des lignes. La méthode viewDidLoad embarque également un tableau avec des chaînes tiré à partir d'un fichier texte et les charges des deux UIImages.

Il ya une méthode IBAction pour passer en mode édition. Cette est appelée lorsque l'utilisateur appuie sur le bouton "Supprimer" dans la barre de navigation. Il change la valeur de inPsuedoEditMode et aussi des peaux ou Révèle la barre d'outils en bas, qui a le bouton "Supprimer" qui provoque les lignes sélectionnées pour obtenir supprimé.

-(IBAction)togglePseudoEditMode
{
self.inPseudoEditMode = !inPseudoEditMode;
toolbar.hidden = !inPseudoEditMode;

[self.tableView reloadData];
}


La plupart des travaux est ici dans le tableView: cellForRowAtIndexPath: méthode. C'est là que nous devons examiner si nous sommes en mode édition, et si nous sommes en mode édition, regardez les lignes qui sont sélectionnées.


- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
static NSString *EditCellIdentifier = @" editcell";


UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:EditCellIdentifier];
if (cell == nil) {
cell = [[[UITableViewCell alloc] initWithFrame:CGRectZero reuseIdentifier:EditCellIdentifier] autorelease];


UILabel *label = [[UILabel alloc] initWithFrame:kLabelRect];
label.tag = kCellLabelTag;
[cell.contentView addSubview:label];
[label release];

UIImageView *imageView = [[UIImageView alloc] initWithImage:unselectedImage];
imageView.frame = CGRectMake(5.0, 10.0, 23.0, 23.0);
[cell.contentView addSubview:imageView];
imageView.hidden = !inPseudoEditMode;
imageView.tag = kCellImageViewTag;
[imageView release];

}

[UIView beginAnimations:@"cell shift" context:nil];

UILabel *label = (UILabel *)[cell.contentView viewWithTag:kCellLabelTag];
label.text = [countries objectAtIndex:[indexPath row]];
label.frame = (inPseudoEditMode) ? kLabelIndentedRect : kLabelRect;

UIImageView *imageView = (UIImageView *)[cell.contentView viewWithTag:kCellImageViewTag];
NSNumber *selected = [selectedArray objectAtIndex:[indexPath row]];
imageView.image = ([selected boolValue]) ? selectedImage : unselectedImage;
imageView.hidden = !inPseudoEditMode;
[UIView commitAnimations];

return cell;
}

Avis quelques choses

  • nous créer manuellement les sous-vues pour afficher le contenu de la cellule de tableau, et nous leur assignons balises. Les balises nous permettent de récupérer les sous-vue correcte quand nous arriverons dequeued cellules au lieu de créer un nouveau.

  • Nous appelons beginAnimations: forContext: et commitAnimations: autour de nos modifications afin que les changements s'animent pour nous. C'est tout ce que nous avons à faire pour faire tourner le mode édition sur et en dehors d'animation


Quand une ligne est touché, et nous sommes en mode édition, nous avons à définir la ligne correspondante dans le tableau de sélection pour OUI si c'est actuellement le NO et vice versa.

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath
{
[self.tableView deselectRowAtIndexPath:indexPath animated:YES];
if (inPseudoEditMode)
{
BOOL selected = [[selectedArray objectAtIndex:[indexPath row]] boolValue];
[selectedArray replaceObjectAtIndex:[indexPath row] withObject:[NSNumber numberWithBool:!selected]];
[self.tableView reloadData];
}
}

Il ya une autre méthode que la clé de ce processus, qui est une autre méthode d'action qui est appelée lorsque le bouton Supprimer dans la barre d'outils devient pressé. Parce que cette barre d'outils est affichée uniquement lorsque nous sommes en mode édition, nous n'avons pas de vérifier que, nous venons de faire le supprimer. Parce que vous ne pouvez pas supprimer des objets d'une collection tout en énumérant sur eux, cette méthode est un peu plus complexe que vous pourriez vous attendre.

-(IBAction)doDelete
{
NSMutableArray *rowsToBeDeleted = [[NSMutableArray alloc] init];
NSMutableArray *indexPaths = [[NSMutableArray alloc] init];
int index = 0;
for (NSNumber *rowSelected in selectedArray)
{
if ([rowSelected boolValue])
{

[rowsToBeDeleted addObject:[countries objectAtIndex:index]];
NSUInteger pathSource[2] = {0, index};
NSIndexPath *path = [NSIndexPath indexPathWithIndexes:pathSource length:2];
[indexPaths addObject:path];
}
index++;
}

for (id value in rowsToBeDeleted)
{
[countries removeObject:value];
}

[self.tableView deleteRowsAtIndexPaths:indexPaths withRowAnimation:UITableViewRowAnimationFade];

[indexPaths release];
[rowsToBeDeleted release];
inPseudoEditMode = NO;
[self populateSelectedArray];
[self.tableView reloadData];
}

Quoi qu'il en soit, j'espère que cela est utile pour certaines personnes. Si vous avez des questions, mettez-les dans les commentaires, ou envoyez-moi un e-mail.