Tutoriel : Créez des applications pour iPhone, iPad et iPod Touch

Eh bien, je suis désolé de vous l'apprendre, mais les développements pour iPhone, iPad et iPod Touch se font presque exclusivement sur Mac. Et ce n'est pas tout ! Le Mac doit :

1. être équipé d'un processeur Intel ;

2. posséder au moins 1 gigaoctet (1 Go) de mémoire vive ;

3. utiliser le système d'exploitation Mac OS X Lion, Snow Leopard ou Leopard ;

4. disposer d'un port USB libre et/ou d'une connexion wifi afin de connecter votre iPhone/iPod Touch/iPad à l'ordinateur et de tester vos applications.

Il est également possible de développer des applications pour les produits Apple en utilisant un ordinateur fonctionnant sous Windows ou Linux, mais ce n'est (vraiment) pas la voie la plus simple, ni bien évidemment celle recommandée par Apple.
Ce livre s'intéressera uniquement à la méthode de développement traditionnelle : sur un Mac, via l'application Xcode.

Si vous possédez déjà un Mac, je vais vous montrer comment savoir s'il est équipé en conséquence : cliquez sur la pomme dans le Finder et sélectionnez À propos de ce Mac dans le menu. À la figure suivante par exemple, le Mac est équipé d'un processeur Intel Core 2 Duo et utilise le système OS X 10.6.7, donc Snow Leopard.

Si vous devez vous équiper, allez faire un tour sur l'Apple Store. Tous les Mac vendus dans le Store peuvent être utilisés. Selon votre budget, vous choisirez un Mac Mini, un MacBook, un MacBook Air, un MacBook Pro ou un iMac.

Si votre budget est limité, rabattez-vous sur une machine reconditionnée. Vous y trouverez des Mac testés et agréés par Apple. Sous garantie pendant un an, les machines proposées sont à un prix sensiblement inférieur à celui du neuf et (sauf exception) dans un excellent état !

Dans la mesure du possible, investissez dans un écran large de 22 ou 24 pouces. Comme vous le verrez dans ce livre, l'environnement de développement est à l'aise sur un grand écran, et un 22 pouces n'est vraiment pas un luxe !
Si vous êtes déjà équipés d'un écran pour PC, vous pourrez le connecter sur votre Mac, à condition que sa connexion soit de type DVI (figure suivante).

J'entends déjà bon nombre d'entre vous se plaindre : « mon écran n'a qu'un connecteur VGA ! Est-ce que je dois acheter un nouvel écran ? »
Non, rassurez-vous, il vous suffit d'acheter un adaptateur VGA/DVI (figure suivante). Pour quelques euros, vous pourrez connecter votre Mac sur votre écran VGA.

Pour les plus ambitieux d'entre vous, sachez qu'il est possible de connecter deux écrans sur tous les Mac récents. À vous de trouver les adaptateurs qui conviennent, comme par exemple un Mini DisplayPort/VGA (figure suivante).

Un autre matériel est-il nécessaire ?

Je vais encore jouer les rabat-joie : il ne suffit pas d'être équipé d'un Mac pour écrire des applications destinées aux appareils mobiles Apple. Vous devez également posséder un iPhone, un iPod Touch et/ou un iPad. Ou encore mieux, les trois !

En effet, si l'environnement de développement est en mesure de simuler le fonctionnement de ces trois appareils, le comportement des applications est cependant biaisé car elles ne disposent pas des mêmes ressources (mémoire et processeur) si elles sont exécutées sur un Mac ou sur un device (entendez par là un iPhone, un iPad ou un iPod Touch).

Une bonne nouvelle : les iPod Touch et les iPad sont également disponibles en version reconditionnée ! Vous pourrez faire de substantielles économies en vous rendant sur ces pages. Par cet intermédiaire, je me suis équipé d'un iPad et d'un iPod Touch reconditionnés, et je dois dire que je m'en félicite tous les jours. :-)

À l'origine d'Apple, deux amis : Steve Wozniak et Steve Jobs. Le premier est un électronicien et un programmeur de génie. Le deuxième est un visionnaire qui saura imposer la marque à la pomme en lui conférant une simplicité d'utilisation et une ligne uniques. Steve Jobs est l'instigateur de cinq évolutions majeures dans le monde de l'informatique personnelle :

• l'Apple II ;

• le Macintosh ;

• l'iPod ;

• l'iPhone ;

• l'iPad.

C'est courant 1975 que naît l'Apple I dans le garage de Steve Jobs. Rencontrant un succès mitigé mais suffisant, il apporte suffisamment de capitaux pour que Steve Wozniak se consacre à temps plein à son digne successeur, l'Apple II. Cette machine révolutionnaire conquiert un large public grâce à ses innovations majeures, notamment un affichage texte et graphique, un interpréteur BASIC, le tableur VisiCalc et un lecteur de disquettes !

Début 1984, le grand public découvre le premier modèle de Macintosh. C'est encore à Steve Jobs que l'on doit ce beau succès commercial. Son design innovant, sa compacité, son écran graphique de grande qualité, sa simplicité d'utilisation et… sa souris révolutionnent l'utilisation de l'ordinateur. Le succès est immédiat et perdure depuis lors.

Mais l'aventure ne s'arrête pas là : en 2001 naît l'iPod, en 2007 l'iPhone et en 2010 l'iPad. Bien sûr, l'iPod n'est pas le premier baladeur MP3, l'iPhone n'est pas le premier téléphone cellulaire et l'iPad n'est pas la première tablette tactile. Par contre, ces trois périphériques sont vraiment simples à utiliser, et c'est ce qui fera leur succès. Une fois encore, Steve Jobs a su flairer le marché et adapter ce qui a fait le succès d'Apple : la simplicité d'utilisation et la ligne esthétique.

Aujourd'hui, Steve Jobs n'est plus avec nous, mais son empreinte demeure indélébile dans la galaxie Apple !

Les iPhone, iPod Touch et iPad

L'iPhone

Les iPhone (figure suivante) sont en tout point comparables aux iPod Touch, si ce n'est qu'ils permettent de téléphoner. Vous pouvez donc les utiliser pour :

• joindre un correspondant par téléphone ;

• écouter de la musique ;

• prendre des photos (à partir de l'iPhone 3) ;

• joindre un autre utilisateur d'iPhone/iPod Touch/iPad en visioconférence (à partir de l'iPhone 4) ;

• exécuter les applications écrites pour les iPhone.

iPod Touch

Les iPod Touch (figure suivante) sont équipés d'un écran tactile de 3,5 pouces de diagonale. Ils peuvent être utilisés pour :

• écouter de la musique ;

• prendre des photos (à partir de l'iPod Touch 4) ;

• joindre un autre utilisateur d'iPhone/iPod Touch/iPad en visioconférence (à partir de l'iPod Touch 4) ;

• exécuter les applications écrites pour les iPhone.

iPad

Les iPad (figure suivante) sont en gros des iPod Touch un peu plus grands. Ils peuvent donc être utilisés pour :

• écouter de la musique ;

• prendre des photos (à partir de l'iPad 2) ;

• joindre un autre utilisateur d'iPhone/iPod Touch/iPad en visioconférence (à partir de l'iPad 2) ;

• exécuter toutes les applications écrites pour les iPhone ainsi que les applications propres à l'iPad.

La grande taille de l'affichage les rend également plus agréables que les iPod Touch ou les iPhone pour surfer sur le Web et lire des e-books et autres fichiers PDF.

Vous avez maintenant une idée des possibilités offertes par les appareils mobiles Apple. Une question cruelle va se poser à vous : de quel(s) appareil(s) devez-vous vous équiper ?

Le mieux serait d'avoir un iPhone, un iPod Touch et un iPad. Vous pourriez ainsi développer pour ces trois périphériques et toucher un vaste public. Notez cependant que les différences entre l'iPod Touch et l'iPhone sont très réduites : grossièrement, le premier est équivalent au second, excepté qu'il ne peut pas être utilisé pour téléphoner.

Un bon choix consiste donc à acheter :

• un iPhone et un iPad si vous avez l'utilité d'un téléphone mobile ;

• un iPod Touch et un iPad si vous n'avez pas l'utilité d'un téléphone mobile ;

• un iPhone ou un iPod Touch si vos applications ne sont pas destinées aux tablettes iPad.

Limitations des appareils mobiles Apple

Les appareils mobiles Apple sont limités par :

• la taille de l'affichage :

• 480 x 320 pixels : iPod Touch 3 et iPhone 3 ;

• 960 x 640 pixels : iPod Touch 4 et iPhone 4 ;

• 1024 x 768 pixels : iPad 1 et 2 ;

• 2048 x 1536 pixels : iPad 3 ;

• la quantité de mémoire vive disponible :

• 128 Mo : iPod Touch 3 avec 8 Go de mémoire flash ;

• 256 Mo : iPod Touch 3 avec plus de 8 Go de mémoire flash, iPod Touch 4, iPhone 3 et iPad 1 ;

• 512 Mo : iPhone 4 et iPad 2 ;

• dans une moindre mesure, le type et la vitesse du processeur.

La taille de l'affichage est un facteur déterminant. Elle conditionnera la mise en page de vos applications et devra s'adapter aux tailles caractéristiques des différents appareils mobiles.
La quantité de mémoire vive est assez limitée. C'est pour cela qu'il est absolument nécessaire de tester une application sur un périphérique physique avant de la rendre disponible sur l'Apple Store.

Le type et la vitesse du processeur n'influent qu'assez peu sur la vitesse d'exécution des applications. Ils ne seront pris en compte que dans le cas de jeux manipulant un grand nombre d'éléments graphiques.

Qu'est-ce qu'un programme ?

Les ordinateurs, les téléphones, les tablettes graphiques et, d'une certaine manière, tous les appareils numériques, utilisent des programmes (appelés aussi applications) pour accomplir des tâches bien précises. Ainsi par exemple, lorsque vous démarrez votre traitement de texte, votre navigateur Web ou votre messagerie, vous utilisez un programme. Autour de ces programmes, un « super programme », appelé système d'exploitation, joue le rôle de chef d'orchestre et permet aux applications d'accéder au matériel sur lequel elles s'exécutent. On dit qu'il sert d'interface entre le matériel et les programmes. À titre d'exemple, Microsoft Windows et Mac OS X sont des systèmes d'exploitation.

Selon le matériel et le système d'exploitation utilisés, les applications sont écrites en utilisant un ou plusieurs langages de programmation. Les iPhone, iPod Touch et iPad sont orchestrés par un système d'exploitation identique. Pour écrire des applications destinées à ce système, un seul langage de programmation peut être utilisé : Objective-C.

Connaissances préalables nécessaires pour programmer

Vous êtes en train de lire un Livre du Zéro, et à ce titre, et pour ne pas déroger à la règle, aucune connaissance préalable n'est nécessaire ! Ceci étant dit, si vous avez déjà une première expérience de la programmation orientée objet ou du langage Objective-C, ce sera un vrai plus : vous comprendrez très rapidement bon nombre de notions qui seront évoquées ici et vous serez très vite capables de passer à la pratique. Si vous n'avez jamais programmé, ne vous en faites surtout pas ! Je serai votre guide tout au long de votre apprentissage. Pour peu que vous ayez un peu de temps, d'intérêt, de passion et de persévérance, vous progresserez très vite.

Langages, API et système

Tout au long de ce tutoriel, nous allons souvent parler d'Objective-C, de Cocoa Touch et d'iOS. Il est temps pour moi de vous présenter ces termes.

• Objective-C est le langage de programmation utilisé pour développer des applications pour iPhone, iPod Touch et iPad. Il s'agit d'un langage hérité du langage C, c'est-à-dire que l'Objective-C emprunte au C bon nombre de choses.

• Cocoa Touch est une API (Application Programming Interface ou, en français, interface de programmation) dédiée à l'écriture d'applications pour iPhone, iPod Touch et iPad. Une API est constituée d'un ensemble de programmes pré-écrits (classes et méthodes dans le jargon des spécialistes). Cocoa Touch ne déroge pas à la règle ; elle est spécifiquement développée pour les devices Apple. Elle est accessible à travers Xcode, le logiciel de développement que nous utiliserons.

• iOS est le système d'exploitation des iPhone/iPod Touch/iPad.

Vous trouverez à la figure suivante un schéma pour vous aider à visualiser tout ce petit monde.

Les réponses à cette question sont multiples.
Si tous les logiciels nécessaires sont installés et si vous voulez juste créer votre première application sans vraiment comprendre ce que vous faites, dix minutes sont suffisantes !

Si rien n'est encore installé (je suppose quand même que vous avez un Mac sous la main), comptez trois à quatre heures pour installer le logiciel et mettre au point une application qui affiche un texte sur votre device.

Je vous conseille cependant de ne pas compter le temps passé : vous vous lancez dans une grande aventure. Il vous faudra du temps (beaucoup de temps même) pour comprendre les mécanismes de la programmation Objective-C, mais cela en vaut la peine ! Une fois les mécanismes de base assimilés, vous pourrez réaliser tout ce qui vous vient en tête…

Xcode sur votre Mac

Xcode est le programme que vous utiliserez pour développer vos applications. La version utilisée dans ce tutoriel est la 4.2 (sous OS X Lion 10.7.2). Si vous utilisez une autre version, quelques détails différeront, mais la plupart de ce qui sera dit restera valable. Par défaut, Xcode est normalement déjà installé sur votre Mac. Pour vous en assurer, cliquez sur l'icône du Finder, à l'extrême gauche du dock. Cette action ouvre une fenêtre dans laquelle sont affichés vos principaux dossiers, comme le montre la figure suivante.

Dans le volet de gauche, sous APPAREILS, cliquez sur Macintosh HD. Dans le volet de droite, double-cliquez sur Developper, sur Applications, puis sur Xcode. Une boîte de dialogue est alors affichée, comme à la figure suivante.

La version du logiciel est affichée juste en dessous du titre « Welcome to Xcode ». Ici, il s'agit de la version 3.2.6. Si votre version de Xcode n'est pas au moins égale à la 4.2, je vous conseille vivement de télécharger puis d'installer la toute dernière version disponible. Pour cela, vous devez rejoindre la communauté des développeurs Apple. Rassurez-vous, cette opération est entièrement gratuite. Connectez-vous sur la page d'enregistrement d'Apple, cliquez sur Get Started et suivez la procédure indiquée pour rejoindre la communauté des développeurs.

Une fois enregistrés, connectez-vous sur la page de téléchargement de Xcode, cliquez sur Log in et connectez-vous en utilisant votre identifiant Apple ID.

• Leopard : Xcode 3.1 ;

• Snow Leopard : Xcode 3.2 ou 4.0 ;

• Lion : Xcode 4.2.

Et surtout, armez-vous de patience : le fichier à télécharger pèse quelque 4 Go !

Installation de Xcode

Une fois Xcode téléchargé, une icône d'installation est affichée dans le dock, comme à la figure suivante.

Cliquez sur l'icône Install Xcode. Cette action ouvre la fenêtre Install Xcode. Cliquez sur Install, sur Agree, entrez votre nom et votre mot de passe puis patientez jusqu'à la complète installation du programme. Une fois l'installation terminée, l'icône Install Xcode du dock se transforme en Xcode. Il suffit de cliquer dessus pour accéder à Xcode.

En résumé

• Les développements pour iPhone, iPod Touch et iPad se font sur un Mac équipé d'un processeur Intel.

• Pour développer des applications pour iPhone, iPod Touch et iPad, vous utiliserez l'application Xcode, normalement déjà installée sur votre Mac. Si tel n'était pas le cas, vous pouvez télécharger Xcode depuis le site pour développeurs d'Apple.

• Pour utiliser la dernière version de l'application Xcode (4.2.x), le Mac doit utiliser le système d'exploitation OS X Lion ou supérieur.

Avant toute chose, il nous faut lancer Xcode, en cliquant par exemple sur l'icône présente dans le dock (figure suivante).

La fenêtre Welcome to Xcode s'affiche alors, comme à la figure suivante.

Nous allons ensuite créer un nouveau projet. Pour cela, rien de plus simple, il vous suffit de cliquer sur Create a new Xcode project. Une nouvelle boîte de dialogue s'affiche (figure suivante). Dans le volet de gauche, sous iOS, choisissez Application. Dans la partie centrale de la boîte de dialogue, choisissez Single View Application.

Cliquez sur Next, donnez le nom « premier » au projet, tapez « test » dans la zone de texte Company Identifier, sélectionnez iPhone dans la liste Device Family, et cochez la case Include Unit Tests, comme indiqué à la figure suivante.

Cliquez sur Next et choisissez le dossier dans lequel le projet sera créé (figure suivante), au besoin en cliquant sur New Folder pour créer un nouveau dossier.

Cliquez sur Create. Le projet est alors créé et ouvert dans Xcode, comme à la figure suivante.

Cette fenêtre va vous permettre de définir l'allure de l'application, de saisir du code Objective-C et de tester l'application. Pour l'instant, nous n'allons pas entrer dans les détails de la fenêtre de Xcode, cela ne ferait que vous embrouiller.

La première étape va consister à dessiner ce que l'on souhaite voir s'afficher sur l'écran du device (Je vous rappelle que device désigne le périphérique sur lequel s'exécutera l'application ; il peut tout aussi bien s'agir d'un iPhone, d'un iPod Touch ou d'un iPad. Ici, la cible de l'application étant un iPhone ou iPod Touch, device désigne ces deux périphériques).
L'interface de Xcode est composée de plusieurs modules (éditeur de code, zone de débogage, utilitaires, éditeur d'interface, etc.). Chacun d'entre eux utilise un ou plusieurs volets, accessibles à partir de la zone de navigation ou de la barre d'outils. Dans cette première étape, vous allez utiliser Interface Builder pour construire la partie visuelle de l'application. Pour ce faire, procédez selon les trois étapes suivantes en vous aidant au besoin de la figure suivante.

1. Dans la zone de navigation, cliquez sur MainStoryboard.storyboard (1) pour accéder à Interface Builder.

2. Dans la barre d'outils, cliquez sur l'icône Hide or Show the utilites (2), au-dessus du libellé View, pour révéler le volet des utilitaires.

3. Dans la partie inférieure du volet des utilitaires, cliquez sur l'icône Show the Object library (3) pour afficher la bibliothèque d'objets. Cliquez si nécessaire sur l'icône Icon View (4) pour afficher plus de contrôles dans la bibliothèque d'objets.

Glissez-déposez un contrôle Label de la bibliothèque d'objets dans la zone d'édition. Si vous n'êtes pas (encore) familiers avec cette opération, sachez qu'elle consiste à cliquer sur le contrôle Label dans la bibliothèque d'objets, à maintenir le bouton gauche de la souris enfoncé, à déplacer l'élément ainsi sélectionné au-dessus de la zone d'édition puis à relâcher le bouton de la souris, comme le montre la figure suivante.

Glissez-déposez ensuite un contrôle Round Rect Button (un bouton) de la bibliothèque d'objets dans la zone d'édition, comme indiqué à la figure suivante.

Vous allez maintenant modifier le texte affiché par défaut dans le Label. Double-cliquez sur celui-ci dans la zone d'édition, écrivez « Cliquez sur le bouton » puis appuyez sur la touche Entrée de votre clavier.
Faites de même pour afficher un texte sur le bouton : double-cliquez sur le bouton, écrivez « Cliquez ici » et appuyez sur la touche Entrée.
La zone d'édition doit maintenant ressembler à la figure suivante.

Cette application doit afficher un texte dans le Label lorsque l'utilisateur clique sur le bouton. Pour que le code Objective-C puisse agir sur les contrôles définis dans l'étape précédente, il faut relier les contrôles au code.

Cliquez sur l'icône Show the Assistant editor, au-dessus du libellé Editor, dans la partie droite de la barre d'outils (figure suivante). Cette action affiche le code du fichier ViewController.h dans un volet vertical.

Si votre écran n'est pas assez large pour visualiser la zone d'édition et le code, désactivez la zone d'utilitaires en cliquant sur l'icône Hide or Show the Utilities, dans la partie droite de la barre d'outils, au-dessus du libellé View (figure suivante).

Le fichier ViewController.h contient les déclarations relatives aux objets manipulés.

Les applications développées avec Xcode sont composées de nombreux fichiers. Certains ont un nom qui se termine par .h, comme par exemple ViewController.h dans le cas qui nous intéresse. Ces fichiers sont dits fichiers d'en-têtes.
Ils contiennent des instructions Objective-C qui permettent d'identifier les objets (c'est-à-dire les contrôles déposés sur la zone d'édition depuis Interface Builder) utilisés dans l'application. Ces instructions sont appelées déclarations.

Pour ajouter les déclarations nécessaires pour le Label, contrôle-glissez-déposez le contrôle Label du volet d'édition dans le volet de code, juste au-dessus de la dernière ligne (figure suivante). Cette technique deviendra vite habituelle. Elle consiste à :

1. placer le pointeur de la souris sur le contrôle Label dans le volet d'édition ;

2. maintenir la touche Ctrl de votre clavier enfoncée ;

3. maintenir le bouton gauche de la souris enfoncé et déplacer le contrôle Label du volet d'édition dans le volet de code, juste au-dessus de la ligne où apparaît l'instruction @end ;

4. relâcher le bouton gauche de la souris ainsi que la touche Ctrl.

Au relâchement du bouton gauche de la souris, une boîte de dialogue est affichée. Tapez « message » dans la zone de texte Name, comme à la figure suivante.

Cliquez sur Connect. Le code du fichier ViewController.h devrait maintenant ressembler à ceci :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController

@property (weak, nonatomic) IBOutlet UILabel *message;

@end

Passons quelques minutes sur ce code si vous le voulez bien.

La première ligne, sur laquelle figure le mot import, fait référence à tout ce dont vous aurez besoin pour développer une interface utilisateur pour périphérique iOS. En ajoutant cette simple ligne au début de l'application, le code pourra afficher sur l'écran du device et répondre aux gestuelles (appui, déplacement, rotation, etc.) des utilisateurs.

La ligne 3, sur laquelle figure le mot interface, indique que l'application ViewController est de type UIViewController :

@interface ViewController : UIViewController

La ligne 5, qui contient le mot property, indique le comportement de l'objet :

@property (weak, nonatomic) IBOutlet UILabel *message;

Enfin, la ligne 7 matérialise la fin du fichier ViewController.h :

@end

Contrôle-glissez-déposez le bouton de la zone d'édition dans le volet de code, juste au-dessus de la dernière ligne, comme à la figure suivante

Au relâchement du bouton de la souris, une boîte de dialogue est affichée. Ici, nous voulons associer une action au bouton, afin qu'un message soit affiché dans le Label lorsque l'utilisateur appuie sur le bouton. Choisissez Action dans la liste déroulante Connection et tapez « reagir » dans la zone de texte Name. La boîte de dialogue devrait maintenant ressembler à la figure suivante.

Comme vous pouvez le voir sur cette image, l'action reagir (paramètre Name), exécutée lorsque l'utilisateur appuie sur le bouton (Touch Up Inside, soit « au relâchement du bouton de la souris » dans le paramètre Event), est sur le point d'être définie.

Cliquez sur Connect. Le code est complété avec une nouvelle instruction :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController

@property (weak, nonatomic) IBOutlet UILabel *message;

- (IBAction)reagir:(id)sender;

@end

Comme vous pouvez le voir, une ligne a été ajoutée dans le code pour déclarer l'action reagir dans le code (ligne 7).

Cliquez sur l'entrée ViewController.m dans le volet de navigation. Un code assez imposant apparaît dans la partie centrale de la fenêtre. Il a (gentiment) été généré par Xcode.

//
//  ViewController.m
//  premier
//
//  Created by Michel Martin on 24/10/11.
//  Copyright (c) 2011 __MyCompanyName__. All rights reserved.
//

#import "ViewController.h"

@implementation ViewController
@synthesize message;

- (void)didReceiveMemoryWarning
{
  [super didReceiveMemoryWarning];
  // Release any cached data, images, etc that aren't in use.
}

#pragma mark - View lifecycle

- (void)viewDidLoad
{
  [super viewDidLoad];
  // Do any additional setup after loading the view, typically from a nib.
}

- (void)viewDidUnload
{
  [self setMessage:nil];
  [super viewDidUnload];
  // Release any retained subviews of the main view.
  // e.g. self.myOutlet = nil;
}

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

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

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

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

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
{
  // Return YES for supported orientations
  return (interfaceOrientation != UIInterfaceOrientationPortraitUpsideDown);
}

- (IBAction)reagir:(id)sender {
}
@end

Jetez un œil aux dernières lignes du code. Est-ce que cela ne vous rappelle rien ?
La ligne 62 est la copie conforme de la déclaration qui a été générée lorsque vous avez contrôle-glissé-déposé le bouton de la zone d'édition dans le fichier ViewController.h. Avez-vous remarqué les accolades, juste après le mot sender ? C'est à cet endroit que vous allez écrire le code qui permettra d'afficher un message dans le Label lorsque l'utilisateur clique sur le bouton. Complétez cette déclaration comme suit :

- (IBAction)reagir:(id)sender {
  NSString *lemessage = [[NSString alloc] initWithFormat:@"Bravo !"];
  message.text = lemessage;
}

Ce n'est pas comme ça que parle votre iPhone, mais plutôt comme ça qu'Objective-C se fait comprendre de votre device. Je sais que la syntaxe de ces instructions a de quoi surprendre. Ne vous en faites pas, et surtout, n'essayez pas de tout comprendre tout de suite. Pour l'instant, contentez-vous de voir le mot « Bravo » sur la deuxième ligne. C'est ce mot qui sera affiché sur l'iPhone lorsque vous cliquerez sur le bouton.

Dans la barre d'outils, cliquez sur l'icône Run (figure suivante).

Au bout de quelques instants, une fenêtre complémentaire nommée Simulateur iOS est affichée, et l'application apparaît dans son état initial. Cliquez sur le bouton. Le texte « Bravo ! » remplace le texte « Cliquez sur le bouton », comme à la figure suivante. Je vous félicite ! Vous venez de réaliser votre première application sur iPhone !

En résumé

• Le design des applications est défini dans la composante Interface Builder de l'application Xcode.

• La bibliothèque d'objets est accessible en cliquant sur l'icône Hide or Show the Utilities, puis sur l'icône Show the Object library.

• Pour ajouter un contrôle dans une vue, il suffit de le glisser-déposer depuis la bibliothèque d'objets dans le Storyboard.

• Pour relier un contrôle au code, contrôle-glissez-déposez-le depuis le Storyboard dans le fichier .h correspondant et indiquez si vous voulez créer un outlet ou une action.

• Le code de l'application est écrit dans le fichier .m qui correspond à la vue.

• Pour construire et exécuter l'application dans le simulateur iOS, il suffit de cliquer sur l'icône Run, dans l'angle supérieur gauche de la fenêtre de Xcode.

Lorsque vous définissez un nouveau projet Xcode, vous devez choisir un type de device : iPhone/iPod Touch ou iPad (figure suivante).

Si vous voulez utiliser le simulateur iOS, vous pouvez à tout moment changer de device en utilisant la liste déroulante Scheme, dans la partie supérieure gauche de la fenêtre de Xcode (figure suivante).

Une autre possibilité consiste à utiliser le menu du simulateur. La fenêtre de ce dernier étant en avant-plan, déroulez le menu Matériel, pointez Appareil et choisissez un des devices proposés, comme à la figure suivante.

Le menu Matériel offre des possibilités complémentaires, puisqu'il est possible de simuler la version du système iOS (on dit aussi firmware) utilisé. Déroulez le menu Matériel, pointez Version et choisissez la version d'iOS à utiliser, comme à la figure suivante.

Une fois le simulateur iOS choisi comme cible de l'application, cliquez sur le bouton Run pour lancer l'application dans le simulateur.

Le simulateur iOS est une application Mac. Il s'exécute dans une fenêtre affichée sur l'écran relié à votre ordinateur. Étant donné que cet écran est une simple dalle réservée à l'affichage, il n'est pas capable de réagir aux gestuelles ni aux actions effectuées sur un iPhone/iPod Touch/iPad. Toutefois les ingénieurs en charge du développement de cette application ont eu la bonne idée de lui associer des raccourcis clavier pour simuler les gestuelles et les actions des utilisateurs.

Simuler les gestuelles de l'utilisateur

Vous vous en doutez, il n'est pas possible de faire tourner votre écran d'ordinateur ou de le secouer pour simuler ces actions dans le simulateur iOS. Par contre, vous pouvez utiliser des commandes dans le menu Matériel du simulateur iOS, ou les raccourcis clavier équivalents.

Simuler les actions de l'utilisateur

Les actions liées au toucher (clic, double-clic, agrandir, etc.) peuvent également être simulées dans le simulateur iOS en utilisant la souris.

Installer/désinstaller une application

Pour installer une application, il suffit de l'exécuter dans le simulateur en cliquant sur le bouton Run de Xcode. Elle est alors disponible sur l'écran des applications (figure suivante), et le restera jusqu'à ce que vous la désinstalliez.

Pour désinstaller une application, pointez son icône et maintenez le bouton gauche de la souris enfoncé jusqu'à ce que toutes les icônes se mettent à bouger. Cliquez alors sur la case de fermeture de l'application que vous voulez désinstaller (figure suivante).

Retourner à la configuration d'usine

Une commande permet de réinitialiser le simulateur iOS pour lui redonner sa configuration d'usine, c'est-à-dire sa configuration juste après l'installation de Xcode. Toutes les applications installées, contenus et réglages sont supprimés et placés dans la corbeille du Mac.
Pour réinitialiser votre simulateur iOS, cliquez sur le menu Simulateur iOS et sélectionnez Réinitialiser le contenu et les réglages. Une boîte de dialogue de confirmation est affichée. Cliquez sur Réinitialiser pour confirmer votre choix.

Déboguer une application lors de son exécution sur le simulateur

L'application Xcode est dotée d'un volet de débogage, aussi appelé « console ». Ce volet permet d'afficher des informations textuelles pendant qu'une application s'exécute, et ce, quelle qu'en soit la cible : le simulateur iOS ou un device réel. Cette section est une première approche du débogage. N'ayant pas encore abordé l'exécution d'une application sur un device, vous allez apprendre à afficher des données dans la console pendant l'exécution sur le simulateur iOS.

Pour afficher le volet de débogage, il suffit de cliquer sur l'icône Hide or show the Debug area, dans la barre d'outils de Xcode (figure suivante).

Vous utiliserez une instruction, NSLog(), pour afficher des informations dans le volet de débogage :

NSLog(@"Le texte à afficher");

Comme vous pouvez le voir sur la figure précédente, l'instruction NSLog() affiche le texte « Bonjour » dans le volet de débogage (à la dernière ligne).

En résumé

• Le simulateur iOS fait partie intégrante de l'application Xcode.

• La liste Scheme (dans l'angle supérieur gauche de la fenêtre de Xcode) permet de choisir si l'application s'exécutera dans le simulateur iPhone ou dans le simulateur iPad. Vous pouvez également utiliser la commande Appareil dans le menu Matériel pour parvenir au même résultat. Si vous le désirez, vous pouvez également choisir la version d'iOS utilisée avec la commande Version dans le menu Matériel.

• Certaines gestuelles et actions de l'utilisateur peuvent être reproduites dans le simulateur iOS, à l'aide de commandes dans le menu Matériel ou de raccourcis clavier.

• Une application peut afficher des informations textuelles dans le volet de débogage en utilisant l'instruction NSLog().

Avant tout chose, je vous rappelle que le langage Objective-C hérite du langage C, c'est-à-dire que leur syntaxe de base est relativement similaire. Si vous connaissez déjà le C, vous pouvez directement vous rendre au chapitre suivant. Si vous voulez en savoir plus sur le langage C, le Site du Zéro propose un tutoriel.

Tout ce qui va être dit dans ce chapitre est relativement théorique. Malheureusement, c'est un passage obligé pour apprendre le langage Objective-C. Cependant, rien ne vous empêche de tester ce que vous apprenez au fur et à mesure.

Pour commencer, définissez un nouveau projet appelé « test » basé sur le modèle Single View Application. Cliquez sur ViewController.m dans le volet de navigation (1) et entrez les instructions à tester dans la méthode viewDidLoad, juste après le message [super viewDidLoad]; (2), comme indiqué à la figure suivante.

Pour tester votre code, une des façons les plus simples consiste à afficher des éléments textuels dans le volet de débogage (aussi appelé « console ») avec la fonction NSLog(). À titre d'exemple, tapez cette ligne de code à la suite de [super viewDidLoad] :

NSLog(@"texte à afficher");

Cliquez sur l'icône Run (1) pour exécuter l'application et, si nécessaire, cliquez sur Hide or show the Debug area (2) pour afficher le volet de débogage. Comme vous pouvez le constater à la figure suivante, le texte passé à la fonction NSLog() est affiché dans le volet de débogage.

Oui, bien sûr. N'ayez crainte, vous découvrirez cela en temps utile. Passez vite à la suite pour faire connaissance avec vos premières instructions Objective-C.

Avant de pouvoir conduire une voiture, vous devez apprendre un certain nombre de règles. Pour cela, vous devez potasser le code de la route. Une fois cette première étape acquise, vous pouvez vous lancer dans la conduite. Là encore, vous devez apprendre plusieurs choses. Certaines ne sont pas essentielles. Par exemple, il n'est pas indispensable de savoir comment fonctionne le moteur de la voiture. D'autres sont par contre vitales : il est impensable de se mettre au volant d'une voiture si on ne sait pas mettre en route le moteur ou passer les vitesses !

Les choses sont assez similaires en programmation. Vous allez devoir apprendre des règles, acquérir des mécanismes et beaucoup pratiquer avant d'arriver à faire ce que vous voulez. Cela vous prendra du temps et de l'énergie, mais imaginez quelle joie vous éprouverez lorsqu'une de vos applications sera téléchargée, utilisée et appréciée par des milliers d'inconnus ! Pour l'instant, nous n'en sommes pas là. Commençons déjà par les bases de la programmation.

Tous les programmes sont constitués d'instructions. Une instruction demande à l'ordinateur d'effectuer quelque chose de précis. Généralement, on écrit une seule instruction par ligne.

Voici une instruction Objective-C plutôt simple :

int leNombreDix = 10;

Et voici une instruction Objective-C un peu plus compliquée :

NSDateFormatter *miseEnForme = [[NSDateFormatter alloc] init];

Je suis sûr que vous trouvez la première plus sympathique que la deuxième. Mais rassurez-vous, ces deux instructions sont très simples à comprendre du moment que l'on connaît le « code de la route » Objective-C.

Pour l'instant, contentez-vous de retenir qu'un programme est constitué d'un ensemble d'instructions. Au fil des chapitres, votre compréhension du langage Objective-C sera de plus en plus claire et vous pourrez commencer à concevoir vos propres applications.

Eh bien oui, le « ; » est obligatoire. Il indique à l'ordinateur que l'instruction est terminée. Il faudra donc vous y faire : toutes les instructions se terminent par un « ; ».

Les variables

Le langage Objective-C n'aurait aucun intérêt s'il n'était pas capable de manipuler des données. Ceci est possible grâce aux variables. En effet, ces dernières permettent de stocker temporairement des informations dans la mémoire de votre device et d'y accéder par la suite. Grâce à elles, vous allez pouvoir stocker l'âge ou la taille du visiteur, mais aussi effectuer des calculs et bien d'autres choses encore.

Pour définir une variable, vous utiliserez la syntaxe suivante :

type nomVariable;

Où :

• type est le type de la variable. Cet élément indique ce que la variable est censée représenter : un entier, un nombre à virgule, un caractère, etc.

• nomVariable est le nom de la variable.

Par exemple, pour définir une variable nommée « maVariable » dont le type est int, vous utiliserez l'instruction suivante :

int maVariable;

int vient du mot anglais integer (« entier » en français). Il faudra vous y faire : la plupart des langages de programmation sont en anglais. Pour ceux qui auraient des lacunes en maths, un entier est un nombre sans virgule, comme par exemple 12 ou 65241.

Quant à la syntaxe du deuxième mot, elle adopte la convention camelCase, qui consiste à utiliser une première lettre minuscule et une lettre majuscule pour chaque nouveau mot. Cette façon de faire n'est pas obligatoire, c'est juste une convention : vos programmes fonctionneront quand même si vous ne l'utilisez pas.

De plus, l'Objective-C interdit les espaces et les accents dans les noms de variables. Par exemple, maPremiereVariable respecte la convention camelCase et ne contient ni espace ni accent ; le nom est donc correct. A contrario, Ma première variable ne respecte pas la convention camelCase et contient des espaces et un accent ; le nom est donc incorrect.

Si vous le souhaitez, il est possible d'affecter une valeur à une variable pendant sa déclaration. Vous utiliserez alors la syntaxe suivante :

type nomVariable = valeur;

Où type est le type de la variable, nomVariable est son nom et valeur est la valeur que vous voulez lui affecter. Par exemple :

int maVariable = 10;

Ici, la valeur 10 est affectée à la variable maVariable de type int.

Vous pouvez manipuler ces variables comme bon vous semble. Par exemple :

int resultat, nombre1 = 10, nombre2 = 5;
resultat = nombre1 + nombre2;

Ici la variable resultat vaudra 15 : 10 + 5 = 15. Bon, je vous l'accorde, pour le moment ça ne nous sert pas à grand-chose. Mais croyez-moi, c'est primordial.

Que diriez-vous maintenant d'un peu de pratique ?
Ouvrez votre projet de test, celui défini quelques pages avant.

Comme vous le montre la figure suivante, cliquez sur ViewController.m (1) dans le volet de navigation, repérez la méthode viewDidLoad et ajoutez les deux lignes de code précédentes à la suite de [super viewDidLoad].

Ajoutez un NSLog pour afficher la valeur de la variable resultat dans le volet de débogage :

NSLog (@"Résultat vaut %d",resultat);

Cliquez sur Run (2) pour exécuter l'application. Si le volet de débogage n'est pas affiché, cliquez sur Hide or show the Debug area (3). Au bout de quelques instants, le volet de débogage affiche fièrement le résultat.

Le langage Objective-C peut utiliser plusieurs autres types de variables. Les plus fréquents ont été rassemblés dans le tableau ci-dessous. Ne vous attardez pas trop sur ce tableau. Vous y reviendrez dans les sections suivantes, lorsque vous testerez des variables d'un de ces types.

Les constantes

Les constantes sont comparables aux variables, à ceci près qu'une fois définies leur valeur ne peut pas changer. Voici la syntaxe à utiliser :

const type nomConstante = valeur;

La syntaxe est identique à celle des variables, à ceci près que l'on ajoute le mot-clé const au début de l'instruction.

Par exemple :

const float pi = 3.1415926536;

En résumé, vous utiliserez des variables pour mémoriser des valeurs qui peuvent changer dans le temps et des constantes pour stocker des valeurs fixes tout au long du programme (une TVA de 19,6 \% par exemple).

Les opérateurs

Comme leur nom le laisse supposer, les opérateurs permettent d'effectuer des opérations. Dans cette section, nous allons nous intéresser aux opérateurs d'affectation et aux opérateurs arithmétiques.

Opérateurs d'affectation

Les opérateurs utilisables en Objective-C sont regroupés dans le tableau qui suit.

L'instruction suivante (issue de la deuxième ligne du tableau) vous paraît certainement un peu farfelue, voire même totalement incompréhensible :

maVariable += 5;

Il s'agit d'une facilité, ou plutôt d'un raccourci d'écriture. Cette instruction est équivalente à :

maVariable = maVariable + 5;

Est-ce que c'est plus clair pour vous maintenant ? Ou avez-vous encore un peu de mal à comprendre comment on peut stocker dans maVariable la valeur maVariable + 5 ? Si vous accrochez là-dessus, sachez que le résultat de maVariable + 5 est calculé dans un premier temps, puis ensuite stocké dans maVariable.

Les autres opérateurs d'affectation fonctionnent de même. Ainsi par exemple :

maVariable %= 5;

Est équivalent à :

maVariable = maVariable % 5;

Après l'exécution de cette instruction, maVariable contient le reste de la division entière (%) de maVariable par 5 (maVariable % 5).

C'est ce qu'on appelle un modulo. Il permet d'obtenir le reste d'une division. Par exemple, si je divise 5 par 2 ($5 / 2$), il reste 1. Ainsi, $5 % 2 = 1$

Opérateurs arithmétiques

Vous connaissez forcément les quatre opérateurs arithmétiques de base : plus, moins, divisé par et multiplié par. Vous aurez également à faire à quelques autres opérateurs, moins fréquents mais très utiles en programmation. Je les ai regroupés dans le tableau suivant.

Ne soyez pas effrayés si c'est la première fois que vous rencontrez certains de ces opérateurs.

• ++ ajoute 1 à une variable entière. À titre d'exemple, variable++ ou ++variable est équivalent à variable = variable + 1.

• -- soustrait 1 d'une variable entière. À titre d'exemple, variable-- ou --variable est équivalent à variable = variable - 1.

%problème corrigé avec "variable--" qui s'affiche en "variable-"

• % renvoie le reste d'une division entière. Par exemple $15 % 2$ renvoie 1. En effet, si vous divisez 15 par 2, le reste de la division est 1.

Et maintenant, voici quelques exemples d'utilisation :

int var1 = 10;
int var2 = 15;
int result;
result = var1 *  var2;
result++;
result = 15 % 10

• Les lignes 1 et 2 définissent les variables int var1 et var2 valant (respectivement) 10 et 15.

• La ligne 3 définit la variable int result, mais ne lui affecte aucune valeur.

• La ligne 4 affecte à result le résultat de la multiplication de var1 par var2. Après l'exécution de cette instruction, result vaut donc 150 ($10 * 15$).

• La ligne 5 ajoute 1 à la variable result. Cette dernière vaut donc 151 après l'exécution de l'instruction.

• Enfin, la ligne 6 affecte à result le reste de la division entière de 15 par 10. Après l'exécution de cette instruction, result vaut 5. En effet $15 / 10 = 1$, reste 5.

Lorsque plusieurs opérateurs apparaissent dans une expression mathématique, il est nécessaire de savoir dans quel ordre ils sont utilisés. Pour les opérateurs +, -, * et /, les règles sont les mêmes que dans l'algèbre traditionnelle. À savoir que * et / sont prioritaires par rapport à + et -. En cas de priorités identiques, les calculs sont effectués de gauche à droite.

D'après vous, quelle est la valeur stockée dans la variable result ?

float result = 10 * 2 + 120 / 2;

Le résultat de cette opération est 80. L'évaluation se fait en calculant $10*2$ puis $120/2$. Ces deux valeurs sont ensuite ajoutées. Ainsi $20 + 60 = 80$.

Si nécessaire, vous pouvez utiliser un ou plusieurs jeux de parenthèses pour modifier l'ordre d'évaluation, et donc le résultat.
D'après vous, quelle est la valeur stockée dans la variable result ?

float result = 10 * (2 + 120) / 2;

Le résultat est 610. L'opération $2 + 120$ étant entourée de parenthèses, elle est prioritaire et donc calculée en premier. Les opérateurs * et / ayant le même niveau de priorité, l'expression est évaluée de la gauche vers la droite. Ainsi, result a pour valeur 10 multiplié par 122 puis divisé par 2, soit 610.

L'opérateur unaire - (en d'autres termes, le « - » qui inverse le signe d'un nombre ou d'une variable) est prioritaire. Il en va de même des opérateurs ++ et -- lorsqu'ils sont utilisés en préfixe (++variable et --variable). Ils sont donc exécutés en premier. Viennent ensuite au même niveau les opérateurs *, / et %, et enfin les opérateurs + et-.

Et maintenant, un peu de pratique !

Dans votre projet de test, cliquez sur ViewController.m dans le volet de navigation, repérez la méthode viewDidLoad et ajoutez les lignes de code précédentes à la suite de [super viewDidLoad]. Invoquez la fonction NSLog() chaque fois que vous voulez tester une variable. Voici à quoi pourrait ressembler la méthode viewDidLoad :

- (void)viewDidLoad
{
  [super viewDidLoad];
  int var1 = 10;
  int var2 = 15;
  int result;

  result = var1 *  var2;
  NSLog(@"var1 * var2 = %d",result);

  result++;
  NSLog(@"Après le ++, result vaut  %d",result);
        
  result = 15 % 10;
  NSLog(@"15 %% 10 vaut  %d",result);
            
  float result1 = 10 * 2 + 120 / 2;
  NSLog(@"10 * 2 + 120 / 2 vaut  %f",result1);
              
  float result2 = 10 * (2 + 120) / 2;
  NSLog(@"10 * (2 + 120) / 2 vaut %f",result2);
}

Cliquez sur Run pour exécuter l'application. Si le volet de débogage n'est pas affiché, cliquez sur Hide or show the Debug area. Au bout de quelques instants, le volet de débogage affiche les divers résultats. Comme vous pouvez le voir à la figure suivante, ils sont conformes aux attentes.

Avant d'en terminer avec ceci, je voudrais faire une remarque sur une des fonctions NSLog() utilisées dans ce code.

Avez-vous remarqué un détail surprenant dans l'instruction suivante, vers le milieu de la méthode viewDidLoad ?

NSLog(@"15 %% 10 vaut  %d",result);

Le signe « % » a une signification particulière. En effet, associé à une lettre (%d ou %f par exemple), il précise le type d'une variable que l'on désire afficher. Dans cette instruction, on désire afficher le signe « % » dans le volet de débogage. C'est la raison pour laquelle il est doublé.

Un commentaire est un texte dans un programme, non pris en compte lors de l'exécution de ce dernier. Ils sont très utiles en programmation puisqu'ils vous permettent de vous y retrouver dans votre code. Imaginez que vous créiez une application et que, quelques mois ou même quelques années plus tard, vous décidiez de la mettre à jour. Même si vous êtes l'auteur du code, il vous sera difficile de tout comprendre au premier coup d'œil. C'est pourquoi il est fortement recommandé d'insérer des commentaires qui expliquent de manière claire ce que vous avez fait.

Pour insérer un commentaire qui tient sur une seule ligne, vous le ferez précéder d'un double slash :

int maVariable = 10; // maVariable vaut 10

Si le commentaire s'étale sur plusieurs lignes, vous utiliserez les caractères « /* » pour marquer le début et « */ » pour marquer la fin du commentaire :

/*
Ceci est un commentaire
sur
plusieurs lignes
*/

Les variables utilisées jusqu'ici étaient de type entier (int) et à virgule (float). Ces deux types ne sont pas les seuls. Vous allez maintenant découvrir les différents types de base utilisables en Objective-C. Vous apprendrez également à effectuer des conversions entre ces différents types de données.

Booléens

Le type BOOL est utilisé lorsque vous devez manipuler des informations de type vrai/faux, oui/non ou 0/1. Ces informations sont dites « booléennes ».

Voici quelques exemples de déclaration :

BOOL booleen1 = 0;
BOOL booleen2 = NO;
BOOL booleen3 = 1;
BOOL booleen4 = YES;

Entiers

Il n'existe pas un mais plusieurs types de variables entières. Vous choisirez un type plutôt qu'un autre en fonction des valeurs maximales que peuvent prendre les variables ou constantes concernées.

Par exemple :

int variableEntiere = 123456;
short int entierCourt = -54;

Réels

Les réels, aussi appelés « nombres à virgule flottante », sont des nombres à virgule, comme par exemple 176.45 ou encore -0.561. Selon leur précision (c'est-à-dire selon le nombre de chiffres après la virgule), ils sont mémorisés dans des variables de type float ou double.

Les variables/constantes de type float peuvent être comprises entre $\$\$3.4\backslash times\; 10^\{-38\}\$\$$ et $\$\$3.4\backslash times\; 10^\{38\}\$\$$. Quant aux variables/constantes de type double, elles peuvent être comprises entre $\$\$1.7\backslash times\; 10^\{-308\}\$\$$ et $\$\$1.7\backslash times\; 10^\{308\}\$\$$.

Il s'agit d'une convention d'écriture dite « scientifique ». 10^-38 signifie 38 zéros avant la valeur numérique. Et 3.4* signifie que le nombre 3,4 est multiplié par le nombre 10^-38. Si vous avez du mal à visualiser tout ça, la figure suivante devrait vous aider.

Caractères

Le type char permet de manipuler des chaînes composées d'un et d'un seul caractère. Le caractère manipulé doit être délimité par des apostrophes :

char monCaractere = 'a';

Les pointeurs sont généralement redoutés comme la peste par les programmeurs débutants. Pourtant, ils rendent de grands services et vous devez absolument comprendre leur fonctionnement pour bien programmer en Objective-C. Pour l'instant, retenez leur principal intérêt : ils facilitent la manipulation des objets en Objective-C. Jusqu'ici, tout va bien. Nous allons donc aller un peu plus loin.

Sachez que les pointeurs ne sont pas un type de données. Il est donc impossible d'écrire quelque chose comme ceci :

pointer maVariable;

Contrairement aux types de données, les pointeurs ne sont pas utilisés pour stocker des données, mais des adresses. Par exemple, lorsque vous faites int monEntier = 10; , un espace en mémoire (dont la taille dépend du type de la variable) est réservé pour stocker la valeur 10. Cet espace se trouve à l'adresse &monEntier. Utilisons une instruction NSLog pour afficher la valeur et l'adresse de la variable monEntier :

NSLog(@"monEntier vaut %i et son adresse en mémoire est %p",monEntier, &monEntier);

Voici le résultat affiché dans la console :

2011-07-06 17:29:47.613 test[498:207] monEntier vaut 10 et son adresse en mémoire est 0xbfffd6f4

Ce qui vient d'être dit n'est peut-être pas très clair pour vous. Si tel est le cas, nous allons prendre quelques instants pour approfondir les choses. Sans vouloir jeter un froid, voici une définition sur laquelle vous devriez méditer : « un pointeur est une variable qui contient l'adresse d'une autre variable d'un type donné ».

Examinez la figure suivante.

Le rectangle horizontal représente une partie de la mémoire de votre ordinateur. Chaque case correspond à un emplacement en mémoire. Pour repérer facilement les différents emplacements, on leur affecte un nombre appelé « adresse ». Dans cette figure, l'emplacement d'adresse 17 contient un pointeur vers l'emplacement d'adresse 207. En utilisant le « pointeur » d'adresse 17, on pourra donc accéder à la donnée stockée à l'adresse 207. En résumé :

• les pointeurs sont utilisés pour mémoriser des adresses, pas des données ;

• les données contenues dans les emplacements en mémoire ainsi « pointés » peuvent changer ;

• les variables, quant à elles, ont un type défini une fois pour toutes et sont donc « figées ».

Les deux derniers points représentent la différence essentielle entre les pointeurs et les variables. Si vous réfléchissez à cela, vous découvrirez un autre intérêt majeur des pointeurs : ils font référence à des données dont le contenu et la taille peuvent changer.

Voyons comment définir un pointeur en Objective-C :

int *pointeurSurMonEntier;

Supposons que pointeurSurMonEntier représente l'adresse de la variable monEntier. Afin de relier ces deux éléments, nous allons utiliser le signe & :

int monEntier = 10;
int *pointeurSurMonEntier = &monEntier;

Il est possible de modifier la valeur d'une variable en agissant sur son pointeur. Par exemple, pour affecter la valeur 25 à la variable monEntier, on peut utiliser indifféremment les deux instructions suivantes :

monEntier = 25;
*pointeursurMonEntier = 25;

Chaînes de caractères

Les chaînes de caractères sont composées de zéro, un ou plusieurs caractères. Comme il a été vu un peu plus tôt, les variables et constantes de type char ne peuvent mémoriser qu'un et un seul caractère. Pour mémoriser des chaînes, nous utiliserons des pointeurs de char.

Les pointeurs de char sont des zones mémoire qui mémorisent l'emplacement d'une suite de zéro, un ou plusieurs char. C'est précisément ce que sont les chaînes de caractères. Les pointeurs de char sont donc particulièrement bien adaptés à leur définition.

À titre d'exemple, l'instruction suivante définit la chaîne nom et l'initialise avec une chaîne de caractères :

char *nom = "Mon nom est Bond, James Bond";

Structures

Jusqu'ici, nous avons étudié des types de données « simples » : booléens, entiers, flottants, doubles, caractères et chaînes de caractères. Il est parfois nécessaire de regrouper plusieurs informations disparates dans une seule et même variable. Imaginez par exemple que vous désiriez mémoriser le prénom, le nom et l'âge de plusieurs personnes. Le plus simple consiste à regrouper ces informations dans une structure en utilisant l'instruction struct :

struct unePersonne
{
  char *prenom;
  char *nom;
  int age;
};

Une fois cette structure définie, on peut définir une variable de type unePersonne et accéder à ses différentes composantes en utilisant des instructions « à point ». Par exemple :

struct unePersonne schwarzi;
schwarzi.prenom = "Arnold";
schwarzi.nom = "Schwarzenegger";
schwarzi.age = 64;

Conversions de type

Dans votre vie de programmeur Objective-C, vous serez souvent amenés à convertir une variable d'un certain type en une variable d'un autre type. En effet, les types des variables manipulées doivent être exactement ceux attendus dans le langage, sans quoi une erreur se produira et il sera impossible d'exécuter le programme.

La conversion peut être « implicite » (c'est-à-dire sans nécessiter l'intervention du programmeur) ou « explicite » (c'est-à-dire en utilisant un opérateur de conversion).

Conversion implicite

Examinons les quelques lignes de code suivantes :

int a = 10;
float b = 13.562;
int c = a * b;
float d = a * b;

Le produit de a par b est égal à 135.62. Cette valeur est de type flottant puisqu'elle comporte des décimales.

Quelles valeurs auront les variables c et d selon vous ?

À la ligne 3, lorsque la valeur 135.62 est stockée dans la variable entière c, elle est « tronquée » (c'est-à-dire privée de ses décimales) à 135. L'instruction int c = a * b; a effectué une conversion implicite du type float vers le type int afin que le résultat puisse être mémorisé dans la variable entière c.

Par contre, dans la ligne 4, lorsque la valeur 135.62 est stockée dans la variable flottante d, elle est égale à 135.62.

Conversion explicite

Pour effectuer une conversion explicite (on dit aussi un casting), il suffit de préciser le type visé entre parenthèses avant la valeur à convertir.

int a = 10;
float b = 13.562;
float c = a * (long int)b;
NSLog(@"%f",c);

La variable b est de type float, puisqu'elle est déclarée comme telle à la ligne 2.
Le casting (long int)b convertit la valeur de la variable b en un long int. Cette valeur est ensuite multipliée par la valeur contenue dans la variable a, de type int. Le résultat est donc de type long int.
Enfin, ce résultat est stocké dans la variable c de type float (float c =). Il est donc converti dans le type float.

Quel résultat sera affiché par l'instruction NSLog selon vous ?
Le casting de b en un long int donne la valeur entière 13. Le résultat de la multiplication est donc 130. Mais étant donné que ce résultat est stocké dans une variable float, NSLog affichera 130.000000.

Pour aller un peu plus loin, nous allons nous intéresser à un autre exemple, basé sur l'utilisation d'un code ASCII.

ASCII est l'abréviation de American Standard Code for Information Interchange. Il s'agit d'une norme d'encodage des caractères alphanumériques de l'alphabet latin. Ainsi par exemple, le nombre 64 représente le caractère « @ », le nombre 65 représente le caractère « A », le nombre 66 représente le caractère « B », et ainsi de suite. Pour avoir de plus amples informations sur le codage ASCII, je vous suggère de vous reporter à cette table ASCII.

Voici notre exemple :

int i = 65;
char c = (char)i;
NSLog(@"%c", c);

En lui appliquant un casting de type (char), la variable char c est initialisée avec le caractère A. C'est donc ce qu'affiche l'instruction NSLog. L'entier 65 est donc équivalent au caractère A.

En résumé

• Une variable permet de stocker temporairement des informations dans la mémoire de votre device et d'y accéder par la suite.

• Pour définir une variable, vous utiliserez l'instruction suivante : type nomVariable;.

• Il est possible d'affecter directement une valeur à une variable lors de sa définition : type nomVariable = valeur;.

• Pour définir une constante, utilisez la syntaxe suivante : const type nomConstante = valeur;.

• Un certain nombre de traitements peuvent être appliqués aux variables par l'intermédiaire d'opérateurs. On distingue essentiellement les opérateurs d'affectation (=, +=, -=, /=, *= et %=) et les opérateurs arithmétiques (+, -, ++, --, *, / et %).

• Les commentaires peuvent occuper une seule ligne. Dans ce cas, ils sont précédés d'un double slash (//). Ils peuvent également s'étaler sur plusieurs lignes. Dans ce cas, ils commencent par les caractères /* et se terminent par les caractères */.

• Les variables sont caractérisées par leur type : booléen, entier, réel, caractère, chaîne, pointeur et structure.

• Les conversions de types peuvent être implicites (lors de la définition d'une variable) ou explicites (en précisant le type recherché entre parenthèses avant la valeur à convertir).

En programmation, on utilise des conditions pour tester la valeur des variables. Selon le résultat obtenu, zéro, une ou plusieurs instructions peuvent alors être exécutées.
Avant de nous intéresser aux conditions, nous allons passer un peu de temps avec les opérateurs de comparaison. En effet, ces opérateurs sont très souvent utilisés dans des conditions. Par exemple pour savoir si une variable est supérieure à une autre, ou encore si une variable est égale à zéro.

Opérateurs de comparaison

Les opérateurs de comparaison (dits logiques) sont très importants. Ils permettent de comparer des valeurs entre elles. Par leur intermédiaire, vous pourrez savoir qui de Pierre ou de Jean est le plus grand, ou encore si les prunes sont plus chères au kilo que les bananes. J'ai regroupé tous les opérateurs logiques dans le tableau suivant.

Maintenant, nous allons mettre en pratique les opérateurs de comparaison en les utilisant dans des conditions.

if

Pour tester une condition, l'opérateur de base est le if ( « si » en français). Par exemple, imaginez que la variable pointure contienne une pointure de chaussures. Si la pointure est inférieure ou égale à 30, vous voulez afficher un message qui dit « Vous devez vous chausser au rayon enfants ». Vous écrirez quelque chose comme ceci :

if (pointure <= 30)
{
  NSLog(@"Vous devez vous chausser au rayon enfants");
}

Si la condition est vérifiée (si la variable pointure est inférieure ou égale à 30), alors ce qui se trouve entre les accolades sera exécuté. Les plus observateurs d'entre vous auront sans doute remarqué que la condition ainsi que les accolades la délimitant ne se terminent pas par un « ; ». C'est tout à fait normal, ce ne sont pas des instructions.

Bien entendu, il est possible d'exécuter plusieurs instructions :

if (pointure <= 30)
{
    NSLog(@"Vous avez de petits pieds");
    NSLog(@"Vous devez vous chausser au rayon enfants");
    // etc.
}

if (pointure <= 30)
  NSLog(@"Vous devez vous chausser au rayon enfants"); // Ici les accolades sont facultatives

Que diriez-vous d'un peu de pratique ?
Ouvrez le projet de test créé au chapitre précédent. Si vous ne l'avez plus, pas de panique, vous pouvez en créer un nouveau, il fera aussi bien l'affaire.

Cliquez sur ViewController.m dans le volet de navigation et complétez la méthode viewDidLoad comme suit :

- (void)viewDidLoad
{
    [super viewDidLoad];
    int pointure = 29;
    if (pointure <= 30)
    {
        NSLog(@"Vous avez de petits pieds");
        NSLog(@"Vous devez vous chausser au rayon enfants");
    }
}

À la ligne 4, la variable pointure est initialisée à 29. Mais rien ne vous empêche de choisir une autre valeur.

Exécutez l'application en cliquant sur Run. Si nécessaire, affichez le volet de déboguage en cliquant sur Hide or show the Debug area. Voici ce qui devrait s'afficher dans le volet de déboguage :

Attaching to process 877.
2011-11-18 11:35:20.428 test[877:f803] Vous avez de petits pieds
2011-11-18 11:35:20.430 test[877:f803] Vous devez vous chausser au rayon enfants

else

Il arrive parfois que l'on doive exécuter une instruction si une condition est remplie, et une autre instruction dans le cas contraire. Pour cela, on a recours au mot-clé else (c'est-à-dire « sinon » en français) :

if (pointure <= 30)
  NSLog(@"Vous devez vous chausser au rayon enfants");
else
  NSLog(@"Vous devez vous chausser au rayon adultes");

elseif

Imaginez maintenant que vous vouliez exécuter :

• une première instruction si la pointure est inférieure ou égale à 30 ;

• une deuxième instruction si la pointure est supérieure à 45 ;

• une troisième instruction si la pointure ne répond à aucune de ces deux conditions.

Pour cela, vous utiliserez les mots clés if (si), else if (sinon si) et else (sinon) :

if (pointure <= 30)
  NSLog(@"Vous devez vous chausser au rayon enfants");
else if (pointure > 45)
  NSLog(@"Vous devez vous chausser sur mesure");
else
  NSLog(@"Vous devez vous chausser au rayon adultes");

Il est bien évidemment possible d'utiliser plusieurs else if. Vous pourriez très bien écrire quelque chose comme ceci, même si l'intérêt de ce code est limité :

if (pointure <= 30)
  NSLog(@"Vous devez vous chausser au rayon enfants");
else if (pointure == 36)
  NSLog(@"Vous chaussez du trente six");
else if (pointure == 37)
  NSLog(@"Vous chaussez du trente sept");
else if (pointure == 38)
  NSLog(@"Vous chaussez du trente huit");

N'hésitez pas à tester ce code (n'oubliez pas de déclarer votre variable pointure) en changeant ses valeurs. C'est comme ça qu'on apprend !

Plusieurs conditions dans un test

Les opérateurs logiques && (et), || (ou) et ! (non) peuvent être utilisés dans une condition. Par exemple, pour tester si la pointure est supérieure à 35 et inférieure à 42, vous écrirez ceci :

if (pointure >35 && pointure <42)

D'après-vous, que devriez-vous écrire pour tester si la pointure est comprise entre 35 et 42, mais différente de 40. Je vous laisse quelques instants…

Voilà la solution :

if (pointure >35 && pointure <42 && pointure != 40)

Facile, non ?

Il est parfois nécessaire d'utiliser des parenthèses dans un test complexe pour modifier l'ordre d'exécution des éléments qui composent le test. Par exemple, les deux tests suivants ne sont pas équivalents :

if ((a+3)/4 < 10)
if (a+3/4 < 10)

Le premier test ajoute 3 à la variable a, divise cette somme par 4 et compare le résultat obtenu à 10. Le deuxième test ajoute 3/4 à la variable a et compare le résultat obtenu à 10.

À titre d'information, voici l'ordre d'exécution des principaux opérateurs, du plus prioritaire vers le moins prioritaire :

L'instruction switch

Il existe une variante de l'instruction if… elseif… else… : l'instruction switch. Voici sa syntaxe :

switch (variable)
{
  case valeur1:
    une ou plusieurs instructions;
    break;
  case valeur2:
    une ou plusieurs instructions;
    break;
  case valeur3:
    une ou plusieurs instructions;
    break;
  ...
  default:
    une ou plusieurs instructions;
    break;
}

Où :

• variable est la variable utilisée dans le test ;

• les case valeur1:, case valeur2:, etc. correspondent aux valeurs à tester ;

• une ou plusieurs instructions sont des instructions définies sur une ou plusieurs lignes;

• les instructions situées après le mot default sont exécutées lorsqu'aucune des conditions spécifiées dans les instructions case n'a été vérifiée ;

• break marque la fin des instructions qui suivent une instruction case ou default.

L'instruction switch est un peu plus complexe que celles que nous avons vu jusqu'ici. Un exemple va vous aider à en comprendre le fonctionnement.

Considérez le test suivant :

if (pointure == 30)
  NSLog(@"Vous devez vous chausser au rayon enfants");
else if (pointure ==36)
  NSLog(@"Vous chaussez du trente six");
else if (pointure ==37)
  NSLog(@"Vous chaussez du trente sept");
else if (pointure ==38)
  NSLog(@"Vous chaussez du trente huit");
else
  NSLog(@"Vous ne chaussez pas du 30, 36, 37 ou 38");

Vous pourriez tout aussi bien écrire :

switch (pointure)
{
  case 30:
    NSLog(@"Vous devez vous chausser au rayon enfants");
    break;
  case 36:
    NSLog(@"Vous chaussez du trente six");
    break;
  case 37:
    NSLog(@"Vous chaussez du trente sept");
    break;
  case 38:
    NSLog(@"Vous chaussez du trente huit");
    break;
  default:
    NSLog(@"Vous ne chaussez pas du 35, 36, 37 ou 38");
    break;
}

Encore une fois, n'hésitez pas à tester ce code en modifiant ses valeurs.

En programmation, il est souvent nécessaire d'exécuter à plusieurs reprises une instruction ou un groupe d'instructions, par exemple tant qu'une condition n'est pas vérifiée.

Supposons que vous vouliez afficher à dix reprises le mot « Bonjour ». Comment vous y prendriez-vous ? La première idée qui vient à l'esprit consiste à répéter dix fois l'instruction d'affichage NSLog :

NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");

Imaginez maintenant que vous vouliez répéter 100 fois l'affichage du mot « Bonjour ». Allez-vous écrire cent fois la même instruction ? Heureusement non ! Il existe plusieurs solutions bien plus élégantes : vous utiliserez pour cela une boucle for, while ou do while.

Dans tous les cas, la procédure est la même. Regardez la figure suivante, elle représente le fonctionnement d'une boucle.

Voici ce qui se passe:

• l'ordinateur lit les instructions de haut en bas ;

• arrivé à la fin de la boucle, il retourne à la première instruction ;

• il lit de nouveau les instructions de haut en bas ;

• il repart à la première instruction ;

• etc

Malheureusement il y a un problème : la boucle est infinie! Si on ne l'arrête pas, l'ordinateur va lire les instructions ad vitam æternam. Heureusement, les conditions vont nous aider. Lorsqu'on crée une boucle, on indique une condition pour sortir de la boucle.

La boucle for

La boucle for est là pour vous éviter une luxation du poignet. Voici sa syntaxe :

for (début; fin; incrément)
{
  //Une ou plusieurs instructions
}

Trois paramètres sont passés à l'instruction for :

• début représente la valeur initiale du compteur de boucle ;

• fin représente la condition qui permet de décider si la boucle se poursuit ou se termine ;

• incrément modifie la valeur du compteur de boucle à la fin de chaque tour de boucle.

Tout ceci vous semble peut-être obscur. Rassurez-vous, un petit exemple va vite clarifier les choses. Considérez le code suivant :

int compteur;
for (compteur = 0; compteur < 100; compteur++)
{
  NSLog(@"Bonjour");
}

Lors de la première exécution de la boucle, la variable entière compteur est initialisée à 0. La condition compteur < 100 est alors vérifiée, puisque 0 < 100. L'instruction NSLog est exécutée, l'ordinateur repart au début de la boucle.

Lors de la deuxième exécution de la boucle, le compteur est incrémenté de 1 (compteur++). Il a donc pour valeur 1. La condition étant vérifiée (1 < 100), l'instruction NSLog est de nouveau exécutée.

Ainsi de suite jusqu'à ce que compteur soit égal à 100. Dans ce cas, la boucle for prend fin et le programme continue de s'exécuter. Si vous faites le compte, l'instruction NSLog aura été exécutée … 100 fois, ce qui est exactement l'effet recherché.

Etant donné qu'une seule instruction est exécutée dans la boucle for, les accolades ne sont pas obligatoires. Dans notre exemple, vous auriez donc tout aussi bien pu écrire :

for (compteur = 0; compteur < 100; compteur++)
  NSLog(@"Bonjour");

Que diriez-vous d'un peu de pratique?

Toujours dans votre projet test, cliquez sur ViewController.m dans le volet de navigation. Repérez la méthode viewDidLoad et complétez-la comme suit :

- (void)viewDidLoad
{
    [super viewDidLoad];
    int compteur;
    for (compteur = 0; compteur < 100; compteur++)
        NSLog(@"Bonjour");
}

Exécutez l'application en cliquant sur Run. Très rapidement, cent lignes contenant le mot "Bonjour" sont affichées dans le volet de déboguage :

Attaching to process 2440.
2011-11-18 15:22:32.967 test[2440:f803] Bonjour
...
2011-11-18 15:22:33.048 test[2440:f803] Bonjour

La boucle while

La boucle while est une variante de l'instruction for. Elle exécute une ou plusieurs instructions tant qu'une condition est vérifiée. Voici sa syntaxe :

while(condition)
{
  //Une ou plusieurs instructions
}

Voyons comment résoudre notre problème précédent avec une boucle while.

int compteur = 0;
while (compteur < 100)
{
  NSLog(@"Bonjour");
  compteur++;
}

La première instruction initialise à 0 la variable compteur.

La boucle while se poursuit jusqu'à ce que la variable compteur soit supérieure ou égale à 100 (while (compteur < 100)). Lors de l'entrée dans la boucle, compteur vaut 0.

Les instructions entre les accolades sont donc exécutées: la première affiche le texte « Bonjour », la deuxième incrémente d'un la variable compteur, qui vaut alors 1.

Après l'incrémentation, la condition compteur < 100 est toujours vérifiée, puisque compteur vaut 1. Les instructions à l'intérieur des accolades sont donc exécutées une nouvelle fois.

Ainsi de suite jusqu'à ce que compteur soit égal à 100.

N'hésitez pas à tester le fonctionnement de la boucle while. Dans votre projet test, repérez la méthode viewDidLoad et complétez-la comme suit :

- (void)viewDidLoad
{
    [super viewDidLoad];
    int compteur = 0;
    while (compteur < 100)
    {
        NSLog(@"Bonjour");
        compteur++;
    }
}

Exécutez l'application en cliquant sur Run pour constater que cent lignes contenant le mot "Bonjour" sont affichées dans le volet de débogage.

Vous pouvez vous amuser à modifier la condition initiale du compteur (ligne 4) et la limite supérieure du compteur (ligne 5). Relancez l'application pour voir l'effet résultant.

La boucle do while

L'instruction do while est une variante de l'instruction while. Mais ici, la condition est testée après l'exécution des instructions entre accolades. Dans tous les cas, les instructions entre les accolades seront donc exécutées au moins une fois. Voici la syntaxe de cette instruction :

do
{
  //Une ou plusieurs instructions
} while (condition);

Si on voulait adapter notre exemple précédent, voici comment il faudrait faire avec une boucle do while :

int compteur = 0;
do
{
  NSLog(@"Bonjour");
  compteur++;
} while (compteur < 100);

La première instruction initialise la variable compteur à 0. Les instructions entre les accolades sont alors exécutées une première fois : le mot « Bonjour » est affiché avec la fonction NSLog() et la variable compteur est incrémentée de 1.

La condition à la suite du while est alors examinée. Après la première exécution des instructions entre les accolades, compteur vaut 1. Il est donc bien inférieur à 100 et la boucle se poursuit. Ainsi de suite jusqu'à ce que compteur devienne égal à 100.

Une fonction peut être comparée à une boîte dont l'intérieur ne peut être vu. On lui fournit (éventuellement) une ou plusieurs données, elle effectue un traitement et retourne (éventuellement) une ou plusieurs autres données (figure suivante).

Une fonction consiste donc en un ensemble d'instructions qui effectuent un traitement et transforment les données qui lui sont fournies en d'autres données.

Découper le code d'une application en plusieurs fonctions présente plusieurs avantages : chaque fonction étant indépendante du reste du code, il est facile de la tester et de la faire évoluer au grès des différentes versions de l'application.

Pour déclarer une fonction, vous utiliserez la syntaxe suivante :

type nom(paramètres)
{
  //Une ou plusieurs instructions
  return retour;
}

Où :

• type indique le type de la donnée retournée par la fonction (int, float etc.),

• nom est le nom de la fonction ;

• paramètres représente les éventuelles données fournies à la fonction ;

• retour représente la donnée renvoyée par la fonction.

La fonction nom utilise le ou les paramètres qui lui sont fournis pour effectuer un traitement et retourner la donnée retour.

L'appel d'une fonction n'a rien de bien compliqué : il suffit d'indiquer son nom, éventuellement suivi des paramètres qui doivent lui être passés. Si la fonction renvoie une valeur, vous l'affecterez à une variable du même type que la valeur renvoyée.

À titre d'exemple, la fonction ttc ci-après renvoie le prix TTC correspondant au prix HT qui lui est passé. Le prix HT et le prix TTC sont de type float.

float ttc(float ht)
{
  return ht * 1.196;
}

Ici un paramètre de type float doit être fourni à la fonction (le prix HT) qui renvoie une valeur de type float. L'instruction utilisée sera donc du type suivant (ici, nous calculons la valeur TTC correspondant à un prix HT de 100) :

float lePrixTTC = ttc(100);

Il est possible d'aller plus loin! Supposons que la fonction TTC doive calculer deux types de prix TTC : un avec une TVA de 5,5%, un autre avec une TVA de 19.6%. Comment devriez-vous compléter la fonction ttc précédente ? Je vous laisse réfléchir.

...

Si c'est vraiment trop difficile pour vous, je vais vous mettre sur la voie :

• La fonction va avoir besoin de connaître le prix HT et la TVA à appliquer. Ces éléments seront passés à la fonction sous la forme de paramètres, donc entre les parenthèses. La TVA peut être fournie à la fonction telle quelle, au format float, ou représentée par un nombre int, qui pourrait valoir "1" dans le cas d'une TVA à 5,5% et "2" dans le cas d'une TVA à 19,6%.

• Dans la fonction, il faudra effectuer un calcul ou un autre en fonction du taux de TVA à appliquer. Une instruction if semble donc tout à fait appropriée.

Cette fois-ci, je vous laisse vraiment réfléchir. Vous avez tous les éléments pour écrire cette fonction.

Voici le code que je vous propose :

float ttc(float ht, int tva)
{
  if (tva==1)
    return ht * 1.055;
  else
    return ht * 1.196;
}

La fonction ttc a maintenant deux paramètres : le prix HT et la TVA. Le deuxième paramètre est de type int. S'il est égal à 1, la fonction ttc renverra un prix TTC calculé avec une TVA de 5.5%. Dans tous les autres cas, la fonction ttc renverra un prix TTC calculé avec une TVA de 19.6%.

Et pour appeler la fonction:

float prix1 = ttc (100, 1); // Prix HT de 100 et TVA à 5,5%
float prix2 = ttc (100, 2); // Prix HT de 100 et TVA à 19,6%

Par exemple, une fonction qui affiche le mot « Bonjour » dans le volet de débogage ne demande aucun paramètre et ne retourne aucune valeur. Elle pourrait avoir l'allure suivante :

void bonjour(void)
{
  NSLog(@"Bonjour\n");
}

En résumé

• Pour comparer des valeurs entre elles, on utilise des opérateurs logiques.

• Pour tester une condition, on utilise if, else if et else.

• Il est possible d'effectuer plusieurs conditions dans un test, en séparant ces conditions par un opérateur logique.

• switch est équivalent à if... elseif... else.... Cela permet de comparer une variable avec plusieurs valeurs et d'exécuter une ou plusieurs instructions en conséquence.

• Pour répéter un certain nombre de fois une ou plusieurs instructions, vous utiliserez une boucle for, while ou do while. La boucle for est particulièrement bien adaptée lorsque l'on connaît le nombre d'itérations de la boucle. Les instructions while et do while prennent fin lorsqu'une condition logique est vérifiée.

• Une fonction consiste en un ensemble d'instructions qui effectuent un traitement et transforment les données qui lui sont fournies en d'autres données. Pour définir une fonction, précisez son type, la ou les variables qui lui sont passées en paramètre et utilisez return pour retourner une valeur. Pour appeler une fonction, indiquez son nom et passez-lui une ou plusieurs variables entre parenthèses.

Dans la programmation « traditionnelle », les programmes sont constitués d'un ensemble d'instructions qui s'exécutent les unes à la suite des autres (voir figure suivante).

Dans la plupart des programmes, on définit une boucle qui ne fait rien d'autre qu'attendre l'arrivée d'un événement. Par exemple, la fin d'un calcul, un changement d'heure, un clic souris ou un autre type d'événement quelconque. Si aucun événement ne se produit, la boucle se contente d'attendre, encore et encore. C'est pourquoi on l'appelle souvent « boucle d'attente ». Si un événement survient, il est identifié et traité en conséquence. La figure suivante illustre mes propos.

Dans la programmation orientée objet, les programmes sont constitués d'un ensemble de blocs de code indépendants appelés objets. Chaque objet contient sa propre boucle d'attente. Lorsqu'un événement concernant un objet particulier survient, c'est à cet objet de traiter l'événement, comme le montre la figure suivante.

Les langages orientés objet utilisent plusieurs termes techniques bien particuliers. Pour vous aider à les appréhender, je vais utiliser une analogie en me basant sur des objets courants de la vie de tous les jours : des voitures.

Une voiture est définie par un ensemble de caractéristiques : modèle et couleur entre autres. Elle est fabriquée dans une usine. Lors de la fabrication, une ou plusieurs options sont ajoutées au modèle de base.

Dans un langage orienté objet :

• l'usine est une classe : c'est elle qui fabrique les objets ;

• la voiture est un objet ;

• les caractéristiques de la voiture sont des propriétés ;

• les options sont des méthodes de la classe Usine.

Je vous ai fait un schéma en figure suivante pour vous aider à mieux visualiser tout ça.

Maintenant que vous avez le vocabulaire nécessaire, nous allons rentrer dans le vif du sujet.

Revenons au petit monde des devices Apple. Une application iOS est bâtie autour d'une classe qui contient un ensemble d'objets, de propriétés (qui représentent l'état des objets) et de méthodes (qui régissent le fonctionnement des objets) (voir figure suivante) .

Supposons que vous vouliez définir la classe maClasse (oui, je sais, c'est très original !).
Vous devrez agir dans deux fichiers distincts : maClasse.h et maClasse.m.

• maClasse.h est un fichier d'en-têtes. Il est utilisé pour déclarer les éléments manipulés dans le code.

• maClasse.m contient le code source de l'application.

Le fichier .h

Pour interagir avec ses utilisateurs, une application utilise une interface. Dans une application iOS, cette interface peut contenir du texte, des images, des vidéos, des boutons et bien d'autres choses encore. En tant que programmeur, vous devrez utiliser des classes pour définir ces différents éléments. Bien qu'il soit possible de définir à partir de zéro tous ces éléments (forme, ombrage, couleur, comportement sur l'écran etc.), vous préférerez sans aucun doute utiliser des classes toutes faites. Pour faciliter la vie des développeurs, Apple a eu la bonne idée de regrouper ces classes dans une sorte de boîte à outils (on dit aussi framework) appelée UIKit. C'est par son intermédiaire que vous pourrez ajouter du texte, des images, des boutons, des vidéos, etc. à vos applications.

Pour établir le lien entre l'application en cours de développement et le framework UIKit, la première instruction d'un fichier .h doit toujours être la suivante :

#import <UIKit/UIKit.h>

Cette simple instruction donne accès à toutes les classes du framework UIKit.

Les lignes qui suivent l'instruction #import définissent le nom et le type de l'application, ainsi que les variables utilisées dans l'application :

@interface nom : type 
{
  Une ou plusieurs variables
}

Où nom est le nom de l'application et type définit son type.

Supposons donc que vous définissiez l'application test de type UIViewController. L'instruction @interface aura l'allure suivante :

@interface testViewController : UIViewController
{
  //Une ou plusieurs variables
}

Les variables définies entre les accolades sont appelées variables d'instance.

Quand vous développez une application iOS, vous définissez une nouvelle classe. Lorsque l'application est lancée, on dit qu'une « instance de la classe » est créée. Cela signifie qu'un objet de cette classe est créé. Les variables d'instance sont propres à cette instance : si vous lancez deux fois l'application, les variables utilisées dans la première instance ne seront pas liées à la seconde, et inversement. Si vous avez du mal à comprendre, la figure suivante devrait vous éclairer.

Voici un exemple de fichier d'en-têtes .h :

#import <UIKit/UIKit.h>

@interface Voiture : NSObject {
  NSString* modele;
  NSString* couleur;
}
@end

La classe a pour nom Voiture. Le fichier qui définit l'interface a donc pour nom Voiture.h.

La classe Voiture possède deux variables d'instance NSString : modele et couleur.

NSString représente le type des variables modele et couleur. Il s'agit d'un type permettant de manipuler des chaînes de caractères.
L'astérisque indique que les variables modele et couleur sont des pointeurs de NSString. Elles contiendront donc l'adresse des chaînes et non les chaînes elles-mêmes. Comme vous le verrez tout au long de ce livre, l'utilisation de pointeurs dans Objective-C est monnaie courante.

Définir des variables d'instance, c'est bien, mais pouvoir y accéder, c'est mieux ! En effet, les variables d'instance sont là pour mémoriser des données, et ces données doivent pouvoir être écrites dans les variables d'instance et lues depuis les variables d'instance.

Pour accéder aux variables d'instance, nous allons ajouter des getters (pour connaître la valeur stockée dans les variables) et des setters (pour stocker des valeurs dans les variables et y accéder) :

- (NSString*) modele;
- (NSString*) couleur;
- (void) setModele: (NSString*)input;
- (void) setCouleur: (NSString*)input;

Les deux premières instructions sont des getters. Elles permettent de lire les valeurs stockées dans les variables d'instance modele et couleur ; en d'autres termes, de connaître le modèle et la couleur de la voiture. La valeur renvoyée est de type NSString. Au début de ces deux lignes, le signe - indique qu'il s'agit de méthodes d'instance.

Les deux dernières lignes sont des setters. Elles permettent de stocker des valeurs dans les variables d'instance modele et couleur, c'est-à-dire définir le modèle et la couleur de la voiture. Ici aussi, il s'agit de méthodes d'instance, d'où le signe - au début des instructions. Ces méthodes ne renvoient aucune valeur, ce qui explique le (void) au début des instructions.

Le fichier d'en-têtes est maintenant complet. Voici les instructions qui le composent :

#import <UIKit/UIKit.h>

@interface Voiture : NSObject {
  NSString* modele;
  NSString* couleur;
}
- (NSString*) modele;
- (NSString*) couleur;
- (void) setModele: (NSString*)input;
- (void) setCouleur: (NSString*)input;
@end

Le fichier .m

Nous allons maintenant implémenter (c'est-à-dire écrire le code de) la classe Voiture en définissant ses getters et ses setters dans le fichier Voiture.m. Je vous rappelle que les getters vont permettre de lire le contenu des variables d'instance et que les setters vont permettre de les modifier.

Commençons par les getters. Le but du jeu est d'obtenir la valeur stockée dans les variables d'instance modele et couleur. Une simple instruction return fera donc l'affaire :

#import "Voiture.h"
@implementation Voiture
- (NSString*) modele {
  return modele;
}
- (NSString*) couleur {
  return couleur;
}
@end

Passons maintenant aux setters. Leur but est de modifier les valeurs contenues dans les variables d'instance modele et couleur. Que pensez-vous du code suivant ?

- (void) setModele: (NSString*)nouvModele {
  modele = nouvModele;
}
- (void) setCouleur: (NSString*)nouvCouleur {
  couleur = nouvCouleur;
}

Vous devez encore écrire une méthode pour définir et initialiser les variables d'instance. Cette méthode est le constructeur de la classe. Elle pourrait contenir quelque chose comme ceci :

- (id) init
{
  if ( self = [super init] )
  {
    [self setModele:@"Maserati Spyder"];
    [self setCouleur:@"Rouge"];
  }
    return self;
}

La première ligne identifie le constructeur. Ne cherchez pas à comprendre le pourquoi du comment : c'est la syntaxe à utiliser !

En observant les lignes 5 et 6, vous pouvez déduire que ces deux instructions affectent la valeur « Maserati Spyder » à la variable d'instance modele en utilisant le setter setModele et la valeur « Rouge » à la variable d'instance couleur en utilisant le setter setCouleur. Rien ne vous empêche de choisir d'autres valeurs par défaut, mais j'ai pensé que ce choix n'était pas dépourvu d'intérêt.

La troisième ligne affecte le résultat de [super init] à self.

Le mot self identifie l'objet courant. Dans notre cas, une instance de la classe Voiture. Quant au mot super, il identifie la classe « parente », c'est-à-dire la classe à partir de laquelle la classe Voiture a été créée. Un simple coup d'œil au fichier Voiture.h nous montre que la classe parente de Voiture est NSObject :

@interface Voiture : NSObject {
  ...
}

[super init] exécute donc la méthode init de la classe parente. Ici, NSObject. Cette méthode initialise la classe Voiture. La valeur renvoyée est nil si un problème s'est produit pendant l'initialisation. Dans le cas contraire, l'adresse de l'objet Voiture est renvoyée.

L'instruction if teste la valeur stockée dans self, c'est-à-dire la valeur retournée par [self init]. Si la valeur renvoyée est différente de nil, les variables d'instance peuvent être initialisées. Dans le cas contraire, il est inutile de poursuivre l'exécution puisque l'initialisation de la classe a échoué.

J'espère que l'initialisation de la classe n'a maintenant plus aucun secret pour vous. N'hésitez pas à relire plusieurs fois les lignes qui précèdent jusqu'à ce que vous ayez bien compris. Ne vous en faites toutefois pas si vous ne comprenez pas encore parfaitement cette section. Cela viendra avec la pratique et vous n'en êtes encore qu'à vos premiers pas en programmation Objective-C. Et croyez-moi, c'est assurément la partie la plus difficile de votre apprentissage !

Allez, pour vous encourager, voici le code complet du fichier Voiture.m :

#import "Voiture.h"
@implementation Voiture
- (NSString*) modele {
  return modele;
}
- (NSString*) couleur {
  return couleur;
}
- (void) setModele: (NSString*)nouvModele
{
  modele = nouvModele;
}
- (void) setCouleur: (NSString*)nouvCouleur
{
  couleur = nouvCouleur;
}
- (id) init
{
  if ( self = [super init] )
  {
    [self setModele:@"Ferrari 360"];
    [self setCouleur:@"Rouge"];
  }
  return self;
}

@end

Les méthodes Objective-C peuvent être attachées à une classe (méthode de classe) ou à une instance (méthode d'instance). Par exemple, stringWithFormat est une méthode de classe, rattachée à la classe NSString ; ou encore arrayWithArray est une méthode de classe, rattachée à la classe NSArray.

Dans une de vos applications, vous pourriez être amenés à définir une méthode d'instance nombreElementsTableau qui renverrait le nombre d'éléments du tableau qui lui est communiqué en paramètre.
Voici la syntaxe générale permettant de déclarer une méthode :

typeMethode (typeRetour) nomMethode : paramètres
{
  //Une ou plusieurs instructions
};

Où :

• typeMethode vaut + pour une méthode de classe ou - pour une méthode d'instance ;

• typeRetour est le type de l'objet retourné par la méthode ;

• nomMethode est le nom de la méthode ;

• parametres correspond aux paramètres de la méthode, s'ils existent. Dans ce cas, ils sont constitués d'un ou de plusieurs couples (type)nom, où type est le type du paramètre et nom le nom du paramètre.

Quelques exemples vont vous aider à y voir plus clair.
L'instruction suivante déclare la méthode d'instance premierJour, qui renvoie le nom du premier jour de la semaine lorsqu'on lui transmet une année (an) et un numéro de semaine (numSem) :

- (NSString *) premierJour : (int) an: (int) numSem;

Cette autre instruction déclare la méthode de classe maMethode, qui ne renvoie rien (void) et qui ne demande aucun paramètre :

+ (void) maMethode ;

Enfin, cette dernière instruction déclare la méthode d'instance changePropriete, qui renvoie un booléen et qui admet deux paramètres : le nom de la propriété à modifier (prop) et la valeur à lui affecter (valeur) :

- (BOOL) changePropriete: (NSString *)prop: (NSString *)valeur;

Avant la pratique, un peu de théorie

En Objective-C, appeler une méthode de classe revient à envoyer un message. Pour cela, on utilise une syntaxe un peu particulière : le nom de l'objet est placé entre crochets et on le fait suivre du nom de la méthode :

[objet methode];

Si la méthode demande une valeur en entrée, faites suivre le nom de la méthode par le caractère « : » et entrez la valeur après ce caractère :

[objet methode:entree];

Si une méthode demande plusieurs paramètres, séparez-les par un espace et indiquez la valeur de ces paramètres après le caractère « : ». Ici par exemple, trois paramètres sont transmis à la méthode. Le premier suit le nom de la méthode (methode:valeur1) et les deux autres sont précédés du nom du paramètre correspondant (param2:valeur2 et param3:valeur3) :

[objet methode:valeur1 param2:valeur2 param3:valeur3];

Une méthode peut retourner un objet. Dans ce cas, vous pouvez le stocker dans une variable :

variable = [objet methode];

Ou encore :

variable = [objet methode:entree];

Si la méthode retourne un objet, vous pouvez enchaîner plusieurs appels de méthodes (c'est d'ailleurs ce qu'on appelle un chaînage). Dans l'exemple suivant, le paramètre param1 est envoyé à la méthode methode1, et cette dernière est appliquée à l'objet objet1. Le résultat de la méthode est un objet auquel on applique la méthode methode2 avec le paramètre param2 :

[[objet1 methode1:param1] methode2:param2];

Si les choses ne sont pas très claires, examinez la figure suivante.

Pour comprendre ce schéma, il suffit de suivre les flèches, de la gauche vers la droite.

parametre 1 est passé à la methode 1 de l'objet 1. Cette méthode fait un traitement et retourne un résultat sous la forme d'un objet (la deuxième flèche rouge). La methode 2 de cet objet est exécutée, en lui passant le parametre 2 en entrée (la troisième flèche rouge). Le résultat final est représenté par la quatrième flèche rouge.
J'espère que c'est plus clair cette fois-ci. Dans le cas contraire, relisez ce qui vient d'être dit. Il n'y a rien de vraiment sorcier là-dedans… ;-)

Les méthodes ne sont pas l'apanage des objets : elles peuvent également être appliquées à des classes. Par exemple, pour créer une variable de type NSString, vous appliquerez la méthode string de la classe NSString :

NSString* uneChaine [NSString string];

Cette instruction peut être simplifiée comme suit :

NSString* uneChaine;

Je suis sûr que vous préférez la deuxième syntaxe à la première. Je dois bien avouer que moi aussi !

Appel d'une méthode existante

Et maintenant, un peu de pratique. Vous allez utiliser un peu de code Objective-C pour concaténer (coller si vous préférez) deux chaînes NSString et afficher le résultat dans la console du Simulateur iOS.

Définissez un nouveau projet basé sur le modèle Single View Application et donnez-lui le nom « test ».
Cliquez sur ViewController.m dans le volet de navigation et repérez la méthode viewDidLoad. Cette méthode est exécutée dès le démarrage de l'application. Vous allez y ajouter quelques instructions pour tester l'exécution de méthodes.
La méthode viewDidLoad (ainsi que de nombreuses autres méthodes) a été générée par Xcode. Voici à quoi elle doit ressembler :

- (void)viewDidLoad
{
  [super viewDidLoad];
  // Do any additional setup after loading the view, typically from a nib.
}

Le message [super viewDidLoad] exécute la méthode viewDidLoad de la classe parente (super) de la classe en cours d'exécution. Étant donné que notre classe test hérite de la classe UIView, cette instruction va exécuter la méthode viewDidLoad de la classe UIView.

La ligne de commentaire n'a aucune utilité. Vous pouvez la supprimer.
Pour concaténer deux chaînes, vous utiliserez la méthode stringByAppendingString en envoyant un message du type suivant :
[chaine1 stringByAppendingString: chaine2];
où chaine1 et chaine2 sont les deux chaînes à concaténer.

Complétez la méthode viewDidLoad comme suit :

- (void)viewDidLoad
{
  [super viewDidLoad];
  NSString* chaine = @"un ";
  chaine = [chaine stringByAppendingString:@"texte"];
  NSLog(@"%@",chaine);
}

Exécutez l'application en cliquant sur l'icône Run. La figure suivante représente ce que vous devriez obtenir dans la console.

Examinons les instructions utilisées dans la méthode viewDidLoad.

La ligne 4 définit l'objet NSStringchaine et lui affecte la valeur « un » :

NSString* chaine = @"un ";

La ligne 5 applique la méthode stringByAppendingString à l'objet NSStringchaine en lui passant le paramètre « texte ». Le résultat est stocké dans l'objet chaine (chaine =) :

chaine = [chaine stringByAppendingString:@"texte"];

Enfin, la ligne 6 affiche le contenu de l'objet chaine (c'est-à-dire « un texte ») :

NSLog(@"%@",chaine);

Création et appel d'une méthode

Vous venez d'apprendre à appeler la méthode stringByAppendingString. Cette méthode fait partie des méthodes standards de la classe NSString.
Vous allez maintenant aller un peu plus loin en créant une méthode et en l'appelant. Cette méthode :

1. aura pour nom « concat » ;

2. recevra deux paramètres NSString ;

3. renverra leur concaténation dans un objet NSString.

Munis de toutes ces informations, vous devriez pouvoir définir le gabarit (c'est-à-dire l'allure) de la méthode :

-(NSString*) concat:(NSString*)ch1: (NSString*)ch2;

Cliquez sur ViewController.h dans le volet de navigation et ajoutez ce gabarit dans le fichier d'en-têtes, après l'instruction @interface.

Il n'y a rien de bien compliqué dans ce gabarit. Si vous ne comprenez pas comment il est construit, relisez la section « Définir des méthodes ».
Le fichier d'en-têtes doit maintenant ressembler à ceci :

#import <UIKit/UIKit.h>
@interface ViewController : UIViewController

-(NSString*) concat:(NSString*)ch1: (NSString*)ch2;

@end

Maintenant, vous allez écrire quelques lignes de code dans le fichier ViewController.m. Cliquez sur ce fichier dans le volet de navigation et définissez la méthode concat, juste au-dessous de l'instruction @implementation :

-(NSString*) concat:(NSString*)ch1: (NSString*)ch2
{
  return [ch1 stringByAppendingString:ch2];
}

La première ligne reprend le gabarit de la fonction.

La troisième ligne définit l'objet retourné par la méthode (viareturn). Cet objet est le résultat de la concaténation de ch1 et ch2, passés en arguments.

Et maintenant, modifiez la méthode viewDidLoad comme suit pour appeler la méthode concat et afficher le résultat retourné dans la console :

- (void)viewDidLoad
{
  [super viewDidLoad];
  NSString* chaine = [self concat: @"premier ":@"deuxième"];
  NSLog(@"%@",chaine);
}

La ligne 4 définit le NSString chaine (NSString* chaine) et lui affecte la valeur retournée par la méthode concat, en lui passant les NSString « premier » et « deuxième ».

Il signifie que la méthode concat a été définie dans la classe courante, tout simplement.

Enfin, la ligne 5 affiche le résultat retourné par concat dans la console. Exécutez l'application. La figure suivante représente ce que vous devriez obtenir dans la console.

Crochet ou point ?

Deux styles d'écriture peuvent être utilisés pour appeler une méthode : les crochets ou les points. À titre d'exemple, les deux instructions suivantes sont équivalentes :

[voiture setCouleur:@"rouge"];
voiture.couleur = @"rouge";

Ces deux écritures font une seule et même action : elles appliquent la méthode couleur à l'objet voiture en lui passant l'entrée rouge.

Les deux lignes suivantes sont elles aussi équivalentes :

laCouleur = [voiture couleur];
laCouleur = voiture.couleur;

Vous l'aurez compris, elles lisent la couleur de l'objet voiture et la stockent dans la variable laCouleur.

Créer un objet

La gestion mémoire d'un objet peut être automatique ou manuelle. Dans le premier cas, lorsque l'objet n'est plus utilisé, il est automatiquement retiré de la mémoire. Dans le deuxième cas, c'est à vous de le retirer de la mémoire pour éviter qu'elle ne se sature.
À titre d'exemple, pour créer l'objet NSString maChaine avec une gestion automatique de la mémoire, vous utiliserez l'instruction suivante :

NSString* maChaine = [NSString string];

Ou plus simplement :

NSString* maChaine;

Si vous préférez gérer manuellement l'objet NSString maChaine en mémoire, vous utiliserez l'instruction suivante :

NSString* maChaine = [[NSString alloc] init];

Examinons cette deuxième écriture. Dans un premier temps, la méthode alloc est appliquée à la classe NSString. Cette opération réserve un espace mémoire et instancie un objet NSString. Dans un deuxième temps, la méthode init est appliquée à cet objet pour l'initialiser et le rendre utilisable (ce n'est qu'après l'initialisation de l'objet que l'on peut lui appliquer des méthodes).

Si nécessaire, il est possible d'affecter une valeur à un objet NSString.

Voici l'instruction à utiliser si vous optez pour une gestion automatique de la mémoire :

NSString* maChaine = [NSString stringWithString:@"Une chaîne quelconque"];

Ou plus simplement :

NSString* maChaine = @"Une chaîne quelconque";

Et voici les instructions à utiliser si vous optez pour une gestion manuelle de la mémoire :

NSString* maChaine2 = [[NSString alloc] init];
maChaine2 = @"Une chaîne quelconque";

Cycle de vie des objets

Tout comme les êtres vivants, les objets utilisés dans une application iOS ont un cycle de vie.

1. Création.

2. Utilisation.

3. Destruction.

Une très bonne nouvelle : iOS 5 introduit un système nommé ARC (Automatic Reference Counting) qui automatise le cycle de vie des objets. Désormais, c'est le compilateur qui se charge de cette tâche ingrate qui consiste à détruire les objets une fois qu'ils ne sont plus utilisés.

Je ne m'étendrai pas plus sur le sujet, mais sachez que vous échappez à des complications aussi inutiles que dangereuses.

En résumé

• En programmation orientée objet, les programmes sont constitués d'un ensemble de blocs de code indépendants appelés objets. Chaque objet contient sa propre boucle d'attente. Lorsqu'un événement concernant un objet particulier survient, c'est à cet objet de traiter l'événement.

• Via l'instruction #import <UIKit/UIKit.h>, le fichier .h fait référence au framework UIKit. Il définit également l'interface de l'application, les variables d'instance, et leurs accesseurs (getters et setters).

• Le fichier .m implémente les getters et les setters des objets utilisés dans l'application, ainsi qu'une ou plusieurs méthodes complémentaires pour effectuer les traitements demandés par l'application.

• Les variables d'instance sont propres à une instance de classe. Si plusieurs instances sont exécutées, les variables n'entreront donc pas en conflit.

• Les méthodes sont appelées par l'intermédiaire de messages de type [objet methode]; ou [objet methode:entree];. Les méthodes peuvent être chaînées en imbriquant plusieurs messages : [[objet1 methode1: param1] methode2: param2];.

• Pour appeler une méthode d'une variable d'instance, il est possible d'utiliser une syntaxe « à point ». Ainsi, [objet methode] et objet.methode sont équivalents.

• Dans iOS 5, le système ARC (Automatic Reference Counting) automatise le cycle de vie des objets : désormais, c'est le compilateur qui se charge de détruire les objets une fois qu'ils ne sont plus utilisés.

Une chaîne de caractères est une suite de zéro, un ou plusieurs caractères. Voici quelques exemples de chaînes de caractères :

Ceci est une chaîne de caractères
123 est plus petit que 456
@ç/w&!

Dans une application destinée aux iPhone, iPod Touch ou iPad, les chaînes de caractères sont manipulées à travers la classe Cocoa Touch NSString :

NSString *maChaine;

Il se peut qu'un jour vous tombiez sur une variante de cette déclaration :

NSString * maChaine; 
(NSString*) maChaine; 
NSString* maChaine;

Ces trois déclarations sont strictement équivalentes à celle que je viens de vous présenter.

Si nécessaire, il est possible d'affecter une valeur à une chaîne lors de sa définition :

NSString *maChaine = @"Ceci est une chaîne de caractères";

Avez-vous remarqué le signe @ avant le début de la chaîne ? Il est là pour indiquer à Xcode que les caractères suivants sont une chaîne de caractères.

Et maintenant, nous allons voir comment manipuler les chaînes de caractères en étudiant quelques méthodes de la classe NSString.

Tester l'égalité de deux NSString

Il est souvent utile de comparer deux chaînes entre elles. Vous pensez peut-être qu'il suffit d'utiliser une instruction du type suivant :

if (chaine1 == chaine2)
{
  // Traitement
}

Eh bien, ce serait trop simple ! En fait, cette instruction compare non pas le contenu mais l'adresse des deux chaînes. Rappelez-vous, lorsque vous définissez une nouvelle chaîne, vous le faites en créant un pointeur :

NSString *chaine1;

Heureusement, il existe une solution pour comparer simplement deux chaînes. Vous utiliserez pour cela la méthode isEqualToString de la classe NSString :

if ([chaine1 isEqualToString:chaine2])
{
  // Traitement
}

Si cette syntaxe vous laisse perplexes, jetez un œil à la section « Appeler des méthodes » du chapitre précédent et tout deviendra plus clair. Pour ceux qui auraient la mémoire courte, les méthodes de classe sont appelées en utilisant la syntaxe suivante :

[objet methode:entrée];

Dans le cas qui nous occupe, la méthode isEqualToString est appliquée à l'objet chaine1 en lui transmettant l'objet chaine2 en entrée. Cette méthode retourne la valeur TRUE si les deux chaînes sont égales, FALSE dans le cas contraire.

Longueur d'un NSString

La longueur d'une chaîne est obtenue avec la méthode length de la classe NSString. Voici un exemple d'utilisation de cette méthode :

NSString *a = @"ceci est une chaîne";
NSLog(@"Longueur de la chaine : %i", [a length]);

L'instruction NSLog affiche le texte suivant dans le volet de débogage :

Longueur de la chaîne : 19

Concaténer deux NSString

Pour concaténer deux chaînes, c'est-à-dire pour les mettre bout à bout, vous utiliserez la méthode stringWithFormat :

NSString *chaine1=@"première partie";
NSString *chaine2= @" deuxième partie";
NSString *chaine3;
chaine3 = [NSString stringWithFormat:@"%@%@",chaine1,chaine2];
NSLog(@"%@",chaine3);

Les trois premières instructions ne devraient pas vous poser de problème. Pour tous ceux qui pensent que la quatrième ligne est incompréhensible, faisons quelques étapes intermédiaires.
L'objet NSString chaine3 a été défini à la ligne précédente. Pour lui affecter une valeur, il suffit de faire suivre son nom du signe = et de la valeur souhaitée : chaine3 = valeur;.

La valeur est obtenue en utilisant la méthode stringWithFormat de la classe NSString. Le début de l'expression est donc tout à fait clair : [NSString stringWithFormat ...].

La méthode stringWithFormat admet un paramètre de type NSString. Dans cet exemple, ce paramètre a pour valeur @"%@%@",chaine1,chaine2. Le signe @ devant le premier guillemet indique que la suite est une chaîne de caractères. Quant aux %@, ils se réfèrent aux éléments spécifiés juste après le deuxième guillemet. Ainsi, le premier %@ est remplacé par chaine1 et le deuxième par chaine2. Le résultat renvoyé est la concaténation des deux chaînes. L'instruction NSLog affiche donc le texte suivant dans le volet de débogage :

première partie deuxième partie

Définir une chaîne pendant l'exécution d'une l'application

Supposons que l'objet NSString maChaine soit défini et initialisé avec l'instruction suivante :

NSString *maChaine = @"Bonjour";

Pour initialiser un objet NSString à partir d'une chaîne de type char, vous utiliserez les instructions suivantes :

char *chaineC;
NSString *chaineObjC;
...
// Instructions qui initialisent la variable char chaineC
...
chaineObjC = [NSString stringWithString: chaineC];

Inversement, pour initialiser une chaîne de type char à partir d'un objet NSString, vous utiliserez les instructions suivantes :

const char *chaineC;
NSString *chaineObjC = @"Bonjour";
chaineC = [chaineObjC String];

Parcourir un NSString, caractère par caractère

Un jour ou l'autre, vous serez certainement confrontés à ce problème : comment isoler chacun des caractères contenus dans un objet NSString afin d'effectuer des comparaisons ou de leur appliquer un traitement individuel ?
La solution est des plus simples : il suffit d'appliquer de manière répétitive la méthode characterAtIndex à la chaîne.

NSString *chaine;
chaine = @"helloworld";
int i = chaine.length; // La variable i contient le nombre de caractères de la chaîne
int j;
char uneLettre;
for(j=0; j<i; j++)  // Boucle de 0 à i en incrémentant j
{
  uneLettre = [chaine characterAtIndex:j];  // Extraction d'un caractère de la chaîne
  NSLog(@"La lettre en position %i est %c ", j, uneLettre);
}

La figure suivante représente le résultat dans la fenêter de débogage.

Nous allons ici parler des objets de classe NSNumber, qui peuvent laisser perplexe. En effet, pourquoi utiliser une classe dédiée à la manipulation des nombres alors que les types int, float, double, etc. sont déjà disponibles ?

Et pourtant, vous aurez besoin de la classe NSNumber dans plusieurs cas bien précis. Par exemple, pour convertir des types de données. Le type d'un objet NSNumber peut être facilement modifié en utilisant les méthodes floatValue, doubleValue, intValue, longValue, etc. Ici par exemple, un nombre entier est converti en un nombre double avec la méthode doubleValue :

NSNumber *unEntier = [NSNumber numberWithInteger:23];
float unDouble = [unEntier doubleValue];

La première instruction définit l'objet unEntier de type NSNumber et l'initialise avec la valeur entière 23. La deuxième instruction définit la variable unDouble de type float et lui affecte la conversion en un double de l'objet unEntier.

À la vue de ce code, vous vous sentez certainement désorientés. Ne vous en faites pas, tout deviendra plus clair au fur et à mesure de votre apprentissage. Pour l'instant, il vous suffit de savoir que les types numériques cohabitent avec la classe NSNumber, et que cette dernière est utile dans certains cas bien précis.

Plusieurs classes sont associées à la manipulation des objets date et heure dans Objective-C : NSDate, NSCalendar, NSTimeZone, NSDateComponents, NSDateFormatter. Pour mieux appréhender ces différentes classes, rien de tel qu'un peu de code.

Affichage de la date courante

Ces quelques lignes de code affichent la date courante au format américain (en_US) et français (fr_FR) :

/* ---Définition de l'objet date et de sa mise en forme--- */

// Aujourd'hui
NSDate *date = [NSDate date];
NSDateFormatter *miseEnForme = [[NSDateFormatter alloc] init];

// Aucun affichage de l'heure
[miseEnForme setTimeStyle:NSDateFormatterNoStyle];

// Affichage de la date au format semi-abrégé
[miseEnForme setDateStyle:NSDateFormatterMediumStyle]; 

/* ---Affichage de la date au format US--- */
NSLocale *usLocale = [[NSLocale alloc] initWithLocaleIdentifier:@"en_US"];
[miseEnForme setLocale:usLocale];
NSLog(@"Date au format %@: %@", [[miseEnForme locale] localeIdentifier], [miseEnForme stringFromDate:date]);

/* ---Affichage de la date au format FR--- */
NSLocale *frLocale = [[NSLocale alloc] initWithLocaleIdentifier:@"fr_FR"];
[miseEnForme setLocale:frLocale];
NSLog(@"Date au format %@: %@", [[miseEnForme locale] localeIdentifier], [miseEnForme stringFromDate:date]);

Et voici ce que ça donne dans la console :

[...] test[1527:207] Date au format en_US: Jun 7, 2011
[...] test[1527:207] Date for locale fr_FR: 7 juin 2011

Examinons le premier bloc d'instructions. La ligne 4 définit l'objet NSDate date (NSDate *date) et lui affecte la date courante ([NSDate date]).

NSDate *date = [NSDate date];

La ligne 5 définit l'objet miseEnForme de type NSDateFormatter. C'est par l'intermédiaire de cet objet que l'on définira un format d'affichage pour la date.

NSDateFormatter *miseEnForme = [[NSDateFormatter alloc] init];

La ligne 8 indique que l'heure ne doit pas être affichée. La méthode setTimeStyle est donc appliquée à l'objet miseEnForme en lui transmettant un paramètre :

[miseEnForme setTimeStyle:NSDateFormatterNoStyle];

Enfin, la quatrième instruction donne le format d'affichage de la date. Les messages autorisés pour la méthode setDateStyle sont :

• NSDateFormatterNoStyle

• NSDateFormatterShortStyle

• NSDateFormatterMediumStyle

• NSDateFormatterLongStyle

• NSDateFormatterFullStyle

Je vous invite à modifier l'instruction en question afin d'observer les différents comportements de ces méthodes.

[miseEnForme setDateStyle:NSDateFormatterMediumStyle];

Examinons maintenant le deuxième bloc d'instructions.
La ligne 14 définit l'objet NSLocale usLocale et l'initialise au format en_US, c'est-à-dire anglais américain :

NSLocale *usLocale = [[NSLocale alloc] initWithLocaleIdentifier:@"en_US"];

La ligne suivante utilise la classe setLocale pour indiquer à l'objet NSDateFormatter miseEnForme que l'affichage devra se faire au format anglais américain :

[miseEnForme setLocale:usLocale];

Enfin, la ligne 16 affiche la date courante dans ce format. Le premier message entre crochets récupère l'identificateur de langue (en_US) et le deuxième la date au format miseEnForme :

NSLog(@"Date au format %@: %@", [[miseEnForme locale] localeIdentifier], [miseEnForme stringFromDate:date]);

Le troisième bloc d'instructions est très proche du deuxième, à ceci près qu'il demande l'affichage de la date au format français.

Création d'une date relative à la date système

La méthode initWithTimeIntervalSinceNow permet de créer un objet NSDate en lui appliquant un décalage par rapport à la date système. Le décalage peut être positif (pour définir une date postérieure à la date système) ou négatif (pour définir une date antérieure à la date système).
Examinez le code suivant :

NSDate *dateCourante = [NSDate date]; //Aujourd'hui
NSTimeInterval secondesParJour = 24 * 60 * 60;
NSDate *demain = [[NSDate alloc] initWithTimeIntervalSinceNow:secondesParJour];
NSDate *hier = [[NSDate alloc] initWithTimeIntervalSinceNow:-secondesParJour];

La première ligne définit l'objet NSDate dateCourante et y mémorise la date système.
La deuxième ligne définit l'objet NSTimeInterval secondesParJour et y mémorise le nombre de secondes contenues dans une journée.
La troisième ligne définit l'objet NSDate demain et y stocke la date système plus un jour. Pour cela, la méthode initWithTimeIntervalSinceNow lui est appliquée en lui transmettant la valeur secondesParJour. L'objet demain est donc initialisé avec la date qui suit le jour courant.
La quatrième ligne est très proche de la troisième, mais ici, le paramètre passé à la méthode initWithTimeIntervalSinceNow est égal à -secondesParJour. L'objet hier est donc initialisé avec la date qui précède le jour courant.

Définition d'une date autre que la date système

Pour définir une date différente de la date système, vous devez :

1. définir et initialiser un objet NSDateComponents ;

2. l'affecter à un objet NSDatevia un objet NSCalendar.

Tout ceci a l'air bien compliqué, mais vous allez voir qu'il n'en est rien en examinant le code suivant :

// Définition d'un objet NSDateComponents
NSDateComponents *nsDatePerso = [[NSDateComponents alloc] init];
[nsDatePerso setYear:2065];
[nsDatePerso setMonth:8];
[nsDatePerso setDay:12];

// Création d'un objet NSDate et affectation de l'objet nsDatePerso défini précédemment
NSDate *datePerso = [[NSCalendar currentCalendar] dateFromComponents:nsDatePerso];
NSLog(@"Date utilisateur : %@", datePerso);

Voici le résultat affiché dans la console :

[...] test[1680:207] Date utilisateur : 2065-08-11 22:00:00 +0000

Comme vous le voyez, aucune mise en forme NSFormatter n'a été appliquée à l'objet datePerso.

Examinons les instructions qui composent ce code.
La première instruction définit l'objet NSDateComponents nsDatePerso et réserve son emplacement en mémoire :

NSDateComponents *nsDatePerso = [[NSDateComponents alloc] init];

Les trois instructions suivantes initialisent les composants année, mois et jour de cet objet.

[nsDatePerso setYear:2065];
[nsDatePerso setMonth:8];
[nsDatePerso setDay:12];

Le deuxième bloc d'instructions définit un objet NSDate de nom datePerso (NSDate *datePerso). Cet objet est initialisé avec la date définie dans l'objet nsDatePerso (dateFromComponents:nsDatePerso) en passant par un objet NSCalendar ([NSCalendar currentCalendar]) :

NSDate *datePerso = [[NSCalendar currentCalendar] dateFromComponents:nsDatePerso];

Une variante pour définir une date autre que la date système

Pour définir et initialiser un objet NSDate avec une date différente de la date système, il est également possible d'utiliser une chaîne de caractères. Cette technique est plus simple que la précédente. Elle consiste à passer en paramètre la chaîne qui contient la date à la méthode dateFromString, qui elle-même est appliquée à un objet NSDateFormatter :

NSDateFormatter* df = [[NSDateFormatter alloc]init];
[df setDateFormat:@"dd-MM-yyyy"];
NSDate *uneDate = [df dateFromString:@"12-08-2011"];

La première instruction définit l'objet NSDateFormatter df et lui réserve un emplacement en mémoire :

NSDateFormatter* df = [[NSDateFormatter alloc]init];

La deuxième instruction définit le format utilisé dans l'objet NSDateFormatter :

[df setDateFormat:@"dd-MM-yyyy"];

Enfin, la troisième instruction affecte une date à l'objet NSDate uneDate en transmettant une chaîne à la méthode dateFromString de l'objet NSDateFormlatter df :

NSDate *uneDate = [df dateFromString:@"12-08-2011"];

Extraction des composants d'un objet NSDate

Pour accéder aux composants (jour, mois, année, heure, minute et seconde) d'une date au format NSDate, vous devez utiliser la méthode components: fromDate: d'un objet NSCalendar dans lequel vous aurez stocké la date.

À titre d'exemple, le code ci-dessous extrait le jour, le mois, l'année, l'heure, les minutes et les secondes de la date système et les affiche dans la console :

NSDate *date = [NSDate date]; //Aujourd'hui
NSCalendar *calendrier = [NSCalendar currentCalendar];
NSDateComponents *composants = [calendrier components:(NSYearCalendarUnit | NSMonthCalendarUnit | NSDayCalendarUnit | NSHourCalendarUnit | NSMinuteCalendarUnit | NSSecondCalendarUnit) fromDate:date];
NSLog(@"Nous sommes le %i / %i / %i", [composants day], [composants month], [composants year]);
NSLog(@"Il est  %i : %i : %i", [composants hour], [composants minute], [composants second]);

La première instruction crée l'objet NSDate date et y stocke la date système :

NSDate *date = [NSDate date]; //Aujourd'hui

La deuxième instruction crée l'objet NSCalendar calendrier :

NSCalendar *calendrier = [NSCalendar currentCalendar];

La troisième instruction crée l'objet NSDateComponents composants et lui affecte les composants suivants de l'objet NSDate date :

• année : NSYearCalendarUnit

• mois : NSMonthCalendarUnit

• jour : NSDayCalendarUnit

• heure : NSHourCalendarUnit

• minutes : NSMinuteCalendarUnit

• secondes : NSSecondCalendarUnit

Les deux dernières instructions affichent les composants de la date système dans la console, ce qui donne le résultat suivant :

[...] test[1897:207] Nous sommes le 7 / 6 / 2011
[...] test[1897:207] Il est  16 : 39 : 6

Ajouter ou soustraire des dates

Pour ajouter ou soustraire un certain nombre d'années, de mois et de jours à une date, vous devez créer un objet dateComponents, y stocker la valeur à ajouter ou soustraire et ensuite utiliser la méthode dateByAddingComponents:toDate pour ajuster la date d'origine.
À titre d'exemple, nous allons ajouter 1 an, 3 mois et 10 jours à la date système et afficher le résultat dans la console. Voici le code utilisé :

NSDate *date = [NSDate date]; //Aujourd'hui
NSDateComponents *leGap = [[NSDateComponents alloc] init];
[leGap setYear:1];
[leGap setMonth:3];
[leGap setDay:10];

NSDate *nouvelleDate = [[NSCalendar currentCalendar] dateByAddingComponents:leGap toDate:date options:0];

NSLog(@"Date système : %@", date);
NSLog(@"Nouvelle date : %@", nouvelleDate);

La date système puis la nouvelle date sont affichées dans la console :

[...] test[1995:207] Date système : 2011-06-07 14:59:53 +0000
[...] test[1995:207] Nouvelle date : 2012-09-17 14:59:53 +0000

Examinons les instructions utilisées.
La première ligne définit l'objet NSDate date et y stocke la date système :

NSDate *date = [NSDate date];

La deuxième ligne définit l'objet NSDateComponents leGap et réserve son emplacement en mémoire :

NSDateComponents *leGap = [[NSDateComponents alloc] init];

Les trois lignes suivantes initialisent le décalage souhaité dans l'objet leGap :

[leGap setYear:1];
[leGap setMonth:3];
[leGap setDay:10];

La nouvelle date est calculée dans l'objet NSDate nouvelleDate. Les composants définis dans l'objet leGap sont ajoutés (dateByAddingComponents:leGap) à l'objet NSDate date (toDate: date) :

NSDate *nouvelleDate = [[NSCalendar currentCalendar] dateByAddingComponents:leGap toDate:date options:0];

Calculer la différence entre deux dates

Il est parfois nécessaire de calculer la différence entre deux dates. En Objective-C, cela se fait en appliquant les méthodes fromDate et toDate à un objet NSCalendar. Voici le code :

NSDateFormatter* df = [[NSDateFormatter alloc]init];
[df setDateFormat:@"yyyy-MM-dd"];
NSDate *dateA = [NSDate date]; //Aujourd'hui
NSDate* dateB = [df dateFromString:@"2011-01-01"];
NSCalendarUnit calendrier = NSYearCalendarUnit | NSMonthCalendarUnit | NSDayCalendarUnit;
NSDateComponents *difference = [[NSCalendar currentCalendar] components:calendrier fromDate:dateA toDate:dateB options:0];
NSInteger mois = [difference month];
NSInteger jours = [difference day];
NSLog(@"Différence entre les deux dates : %i mois et %i jours.", mois,jours);

Examinons ce code.
Les deux premières instructions définissent et initialisent l'objet NSDateFormatter df :

NSDateFormatter* df = [[NSDateFormatter alloc]init];
[df setDateFormat:@"yyyy-MM-dd"];

Les deux instructions suivantes stockent la date courante ainsi qu'une autre date (celle du 01/01/2011) dans les objets NSDate dateA et dateB :

NSDate *dateA = [NSDate date]; //Aujourd'hui
NSDate* dateB = [df dateFromString:@"2011-01-01"];

L'instruction suivante définit les composants qui seront utilisés pour calculer la différence entre les deux dates (ici les années, les mois et les jours) :

NSCalendarUnit calendrier = NSYearCalendarUnit | NSMonthCalendarUnit | NSDayCalendarUnit;

L'instruction suivante calcule la différence entre les deux dates. L'instruction est assez conséquente, alors prenez le temps de bien la comprendre. Dans la section « Extraction des composants d'un objet NSDate », vous avez appris à utiliser la méthode components: fromDate pour extraire les composants (année, mois, jour, heures, minutes, …) d'une date. Ici, nous allons utiliser la méthode components: fromDate: toDate: pour effectuer une soustraction entre deux dates et en extraire les composants.

Dans un premier temps, un objet NSCalendar est obtenu avec le message [NSCalendar currentCalendar].

La méthode components: fromDate: toDate: est alors exécutée. La différence entre les dates dateA et dateB est calculée (fromDate:dateA toDate:dateB), et seuls les composants définis dans l'objet NSCalendatUnit calendrier sont retournés. Le résultat est stocké dans l'objet NSDateComponents difference :

NSDateComponents *difference = [[NSCalendar currentCalendar] components:calendrier fromDate:dateA toDate:dateB options:0];

Il ne reste plus qu'à extraire les composants ans, mois et jour du résultat et à les stocker dans des objets NSInteger :

NSInteger ans = [difference year];
NSInteger mois = [difference month];
NSInteger jours = [difference day];

Il ne reste plus qu'à les afficher dans la console :

NSLog(@"Différence entre les deux dates : % ans %i mois et %i jours.", ans,mois,jours);

Temps nécessaire pour exécuter un bloc d'instructions

Pendant la mise au point d'une application, il peut être utile de calculer le temps nécessaire à l'exécution d'un bloc de code. Voici comment procéder :

1. définissez un objet NSDate et initialisez-le avec la date courante juste avant le bloc de code dont vous voulez tester le temps d'exécution ;

2. exécutez le bloc de code ;

3. appliquez la méthode timeIntervalSinceNow à l'objet NSDate initialisé à l'étape 1 et mémorisez le résultat dans un objet NSTimeInterval.

Voici un exemple de code qui teste le temps nécessaire à l'affichage de 100 lignes dans la console :

NSDate *debut = [NSDate date]; //Date courante

//On affiche 100 lignes dans la console grâce à une boucle
int compteur;
for (compteur=1; compteur<100; compteur++)
{
  NSLog(@"abc");
}

NSTimeInterval intervalle = [debut timeIntervalSinceNow]; //On calcule le temps d'exécution...
NSLog(@"Temps écoulé : %f", intervalle); //Et on l'affiche

La figure suivante représente les dernières informations affichées dans la console.

La classe NSArray est dédiée à la manipulation de tableaux (un tableau est un assemblage d'objets quelconques : c'est une façon de les ranger, comme dans une armoire). En programmation, on parle aussi d'array (d'où le nom de la classe NSArray).

Définir et initialiser un tableau

Pour créer un tableau contenant une chaîne de caractères, vous utiliserez l'instruction suivante :

NSArray *monTableau = [NSArray arrayWithObject :@"premier"];

Pour créer un tableau contenant un entier, vous utiliserez l'instruction suivante :

NSArray *monTableau = [NSArray arrayWithObject :[NSNumber numberWithInt: 10]];

Pour créer un tableau contenant plusieurs chaînes de caractères, vous utiliserez l'instruction suivante :

NSArray *monTableau = [NSArray arrayWithObjects :@"premier",@"deuxième",@"troisième",@"quatrième", nil];

Enfin, pour créer un tableau à partir d'un autre tableau, vous utiliserez l'instruction suivante :

NSArray *monTableau2 = [NSArray arrayWithArray :monTableau1];

Accéder aux objets contenus dans un tableau

Plusieurs méthodes très pratiques permettent d'accéder aux informations contenues dans un objet NSArray.

• containsObject renvoie la valeur true si le tableau contient au moins un objet. Il renvoie la valeur false dans le cas contraire.

• count retourne le nombre d'objets du tableau.

• objectAtIndex retourne l'objet situé à l'index (c'est-à-dire à la position) spécifié dans le tableau.

• lastObject retourne le dernier objet contenu dans le tableau, c'est-à-dire celui dont l'index est le plus élevé.

Pour clarifier ces méthodes, rien de tel que quelques exemples :

NSArray *monTableau = [NSArray arrayWithObjects :@"premier",@"deuxième",@"troisième",@"quatrième", nil];
NSLog(@"%@",monTableau);
NSLog(@"Objet qui se trouve à l'index 1 : %@", [monTableau objectAtIndex:1]);

if ([monTableau containsObject:@"premier"]) 
  NSLog(@"L'objet premier a été trouvé dans le tableau");
else 
  NSLog(@"L'objet premier n'a pas été trouvé dans le tableau");

if ([monTableau containsObject:@"dixième"]) 
  NSLog(@"L'objet dixième a été trouvé dans le tableau");
else 
  NSLog(@"L'objet dixième n'a pas été trouvé dans le tableau");

NSLog(@"Dernier objet du tableau : %@", [monTableau lastObject]);

Examinons ces instructions.
La première ligne définit l'objet NSArray monTableau et l'initialise avec quatre chaînes de caractères : premier, deuxième, troisième et quatrième :

NSArray *monTableau = [NSArray arrayWithObjects : @"premier",@"deuxième",@"troisième",@"quatrième", nil];

La deuxième instruction (NSLog(@"%@",monTableau);) affiche le contenu du tableau dans la console.

La troisième instruction affiche l'objet qui se trouve en position 1 (le deuxième donc, puisque l'index commence à 0) :

NSLog(@"Objet qui se trouve à l'index 1 : %@", [monTableau objectAtIndex:1]);

Et voici les informations retournées dans la console :

[...] test[1095:207] Objet qui se trouve à l'index 1 : deuxième

Le premier bloc if else utilise la méthode containsObject pour tester la présence de l'objet premier dans le tableau et affiche un message en conséquence :

if ([monTableau containsObject:@"premier"]) 
  NSLog(@"L'objet premier a été trouvé dans le tableau");
else 
  NSLog(@"L'objet premier n'a pas été trouvé dans le tableau");

Ici, l'objet premier faisant partie du tableau, voici ce qu'affiche la console :

[...] test[1095:207] L'objet premier a été trouvé dans le tableau

Le bloc if else suivant utilise la méthode containsObject pour tester la présence de l'objet dixième dans le tableau et afficher un message en conséquence :

if ([monTableau containsObject:@"dixième"]) 
  NSLog(@"L'objet dixième a été trouvé dans le tableau");
else 
  NSLog(@"L'objet dixième n'a pas été trouvé dans le tableau");

L'objet dixième ne faisant pas partie du tableau, voici ce qu'affiche la console :

[...] test[1095:207] L'objet dixième n'a pas été trouvé dans le tableau

Enfin, la dernière instruction affiche le dernier objet du tableau :

NSLog(@"Dernier objet du tableau : %@", [monTableau lastObject]);

Comme prévu, le dernier objet est la chaîne quatrième :

[...] test[1095:207] Dernier objet du tableau : quatrième

Passer en revue les objets contenus dans un tableau

Vous vous en doutez certainement, la lecture successive des différents objets contenus dans un tableau se fera dans une boucle. Les objets peuvent être retrouvés avec la méthode objectAtIndex ou avec la méthode objectEnumerator. Nous allons examiner tour à tour ces deux possibilités.

Avec la méthode objectAtIndex

NSArray *monTableau = [NSArray arrayWithObjects :@"premier",@"deuxième",@"troisième",@"quatrième", nil];
int nombreElements = [monTableau count];
for (int i = 0; i < nombreElements; i++)
{
  NSLog(@"Objet de rang %i : %@", i, [monTableau objectAtIndex: i]);
}

La première instruction définit l'objet NSArray monTableau et y stocke quatre chaînes de caractères. Je ne vous remets pas le code, à ce stade vous devriez avoir compris.

La deuxième instruction définit l'entier nombreElements et y stocke le nombre d'éléments du tableau :

int nombreElements = [monTableau count];

La boucle for exécute l'instruction NSLog() autant de fois que le tableau contient d'objets :

for (int i = 0; i < nombreElements; i++)

L'instruction NSLog de la ligne 5 accède aux éléments du tableau en passant l'index de la boucle à la méthode objectAtIndex et en l'appliquant à l'objet monTableau :

NSLog(@"Objet de rang %i : %@", i, [monTableau objectAtIndex: i]);

Le résultat affiché dans la console est bien celui qu'on attendait :

[...] test2[1417:207] Objet de rang 0 : premier
[...] test2[1417:207] Objet de rang 1 : deuxième
[...] test2[1417:207] Objet de rang 2 : troisième
[...] test2[1417:207] Objet de rang 3 : quatrième

Avec la méthode objectEnumerator

NSArray *monTableau = [NSArray arrayWithObjects :@"premier",@"deuxième",@"troisième",@"quatrième", nil];
NSEnumerator *enumer = [monTableau objectEnumerator];
NSObject *obj;
while ((obj = [enumer nextObject]) != nil)
{
  NSLog(@"Objet : %@", obj);
}

La première instruction définit l'objet NSArray monTableau et y stocke quatre chaînes de caractères.

La deuxième instruction crée l'objet enumer de type NSEnumerator et l'initialise avec un énumérateur basé sur l'objet monTableau :

NSEnumerator *enumer = [monTableau objectEnumerator];

Ce type d'objet permet de décrire très facilement des tableaux. Pour en savoir plus sur ce sujet, consultez l'aide en cliquant sur les mots NSEnumerator (1) et objectEnumerator (2), et si nécessaire en activant les icônes Hide or show the Utilities (3) et Show Quick Help (4), comme indiqué à la figure suivante.

L'instruction suivante définit l'objet obj de type NSObject :

NSObject *obj;

En appliquant la méthode nextObject à l'objet NSEnumerator enumer, on obtient tour à tour tous les objets stockés dans le tableau monTableau. Lorsque tout le tableau a été parcouru, la méthode nextObject renvoie la valeur nil. La façon la plus simple de passer en revue tout le contenu du tableau consiste à utiliser une boucle while :

while ((obj = [enumer nextObject]) != nil)

Si l'objet renvoyé par la méthode nextObject est différent de nil, il est affiché dans la console :

NSLog(@"Objet : %@", obj);

Dans le cas contraire, la boucle while prend fin.
Voici le résultat affiché dans la console :

[...] test2[1507:207] Objet : premier
[...] test2[1507:207] Objet : deuxième
[...] test2[1507:207] Objet : troisième
[...] test2[1507:207] Objet : quatrième

Parfois, l'ordre dans lequel sont mémorisés les éléments importe peu. Ce qui importe plutôt, c'est d'associer chacun des objets mémorisés à un autre objet unique. Par exemple, il pourrait être intéressant de définir des couples nom/définition, ou encore nom/adresse. Les définitions ou adresses pourraient alors être retrouvées en fournissant le nom correspondant.

Les classes NSDictionary et NSMutableDictionary répondent parfaitement à cette problématique. Vous utiliserez un dictionnaire NSDictionary lorsque les objets à mémoriser sont immuables, c'est-à-dire lorsqu'ils ne sont pas modifiés après leur création et leur initialisation. Par contre, vous utiliserez un dictionnaire NSMutableDictionary lorsque les objets à mémoriser peuvent être modifiés après leur création et leur initialisation.

Création et initialisation d'un dictionnaire

Voici les instructions à utiliser :

NSDictionary *leDictionnaire = [NSDictionary dictionary];
NSMutableDictionary * leDictionnaire = [NSMutableDictionary dictionary];

Pour ajouter des éléments dans un dictionnaire, vous appliquerez la méthode setObject à l'objet NSDictionary ou NSMutableDictionary en lui transmettant le couple de valeurs à mémoriser :

[leDictionnaire setObject: @"une définition" forKey: @"une clé d'accès"];
[leDictionnaire setObject: @"une autre définition" forKey: @"une autre clé d'accès"];

Si vous le souhaitez, la méthode dictionaryWithObjectsAndKeys permet de regrouper la définition et l'initialisation d'un dictionnaire dans une seule instruction :

NSDictionary *leDictionnaire = [NSDictionary dictionaryWithObjectsAndKeys: @"Une définition", @"une clé", @"Une autre définition", @"une autre clé", nil];

Comme vous pouvez le voir, les objets stockés dans le dictionnaire sont séparés entre eux par des virgules et la valeur nil identifie la fin du dictionnaire.

Enfin, sachez qu'un dictionnaire peut être créé à partir de deux NSArray. Le premier doit contenir les objets à stocker (définitions ou adresses), le deuxième les clés associées (noms) :

NSArray *lesObjets = [NSArray arrayWithObjects: @"une définition", @"une autre définition", nil];
NSArray *lesCles = [NSArray arrayWithObjects: @"une clé", @"une autre clé", nil];
NSDictionary *leDictionnaire = [[NSDictionary alloc] initWithObjects: lesObjets forKeys: lesCles];

Méthodes relatives aux dictionnaires

Pour connaître le nombre d'entrées stockées dans un dictionnaire, il suffit d'appliquer la méthode count à l'objet dictionnaire :

NSLog (@"Nombre d'entrées mémorisées dans le dictionnaire = %i", [leDictionnaire count]);

Pour obtenir l'objet qui correspond à une clé donnée, vous utiliserez la méthode objectForKey :

NSLog (@"La clé 'une clé' correspond à la chaîne = '%@'", [leDictionnaire objectForKey: @"une clé d'accès"]);

Enfin, vous pouvez utiliser les méthodes removeObjectForKey et removeAllObjects pour supprimer, respectivement, l'entrée dont la clé est spécifiée ou toutes les entrées du dictionnaire :

[leDictionnaire removeObjectForKey: @"une clé"];
[leDictionnaire removeAllObjects];

Un exemple de code

Ce petit exemple de code commenté illustre les instructions dont nous venons de parler :

//On crée un dictionnaire
NSMutableDictionary * leDictionnaire = [NSMutableDictionary dictionary];

//On remplit le dictionnaire avec des couples adresse/nom
[leDictionnaire setObject: @"12 rue Guérin 75013 Paris" forKey: @"Pierre Jaquart"];
[leDictionnaire setObject: @"26 rue de la Place 75002 Paris" forKey: @"Eric Courteau"];
[leDictionnaire setObject: @"115 rue des pêcheurs 75005 Paris" forKey: @"Jean Bertier"];
[leDictionnaire setObject: @"2 place Mayeur 75012 Paris" forKey: @"Placido Perez"];

//On affiche le nombre d'entrées du dictionnaire
NSLog (@"Nombre d'entrées mémorisées dans le dictionnaire : %i", [leDictionnaire count]);

//On affiche une des entrées du dictionnaire
NSLog (@"Le nom 'Eric Courteau' correspond à l'adresse '%@'", [leDictionnaire objectForKey: @"Eric Courteau"]);

//On supprime une entrée du dictionnaire
[leDictionnaire removeObjectForKey: @"Jean Bertier"];

//On affiche le nombre d'entrées du dictionnaire, après la suppression d'une des entrées
NSLog (@"Nombre d'entrées mémorisées dans le dictionnaire : %i", [leDictionnaire count]);

Et voici ce qu'affiche la console :

[...] test[2996:f803] Nombre d'entrées mémorisées dans le dictionnaire : 4
[...] test[2996:f803] Le nom 'Eric Courteau' correspond à l'adresse '26 rue de la Place 75002 Paris'
[...] test[2996:f803] Nombre d'entrées mémorisées dans le dictionnaire : 3

Dans les sections précédentes, vous avez fait connaissance avec les tableaux et les dictionnaires. Les tableaux permettent de stocker des objets dans un certain ordre. Ces derniers peuvent alors être retrouvés par leur index. Les dictionnaires définissent des couples valeurs/clés. Les valeurs sont retrouvées en spécifiant les clés correspondantes.

Il existe une troisième façon de stocker des objets : en utilisant des ensembles, via la classe NSSet, vous pouvez mémoriser un empilement d'objets sans ordre particulier.

Création et initialisation d'un ensemble

Pour créer un ensemble qui contient un seul objet :

NSSet * monEnsemble = [NSSet setWithObject:[NSNumber numberWithInt:2]];

Pour créer un ensemble à partir d'un tableau :

NSSet * monEnsemble = [NSSet setWithArray:monTableau];

Pour créer un ensemble qui contient plusieurs objets :

NSSet * monEnsemble = [[NSSet alloc] initWithObjects:@"un",@"deux",@"trois",nil];

Méthodes relatives aux ensembles

Recherche d'un objet dans un ensemble

La méthode containsObject permet de savoir si un objet fait partie d'un ensemble. Si l'objet est trouvé, la valeur true est renvoyée par la méthode. Dans le cas contraire, c'est la valeur false qui est renvoyée.
Ici, l'objet deux est recherché dans l'ensemble monEnsemble. Un texte est affiché dans la console s'il est trouvé :

if ([monEnsemble containsObject:@"deux"])
{
  NSLog (@"La chaîne deux a été trouvée dans l'ensemble");
}

Récupération d'un objet dans un ensemble

Pour récupérer un objet dans un ensemble, vous utiliserez la méthode member. Si l'objet est présent, il est renvoyé par la méthode. Dans le cas contraire, c'est la valeur nil qui est renvoyée.
Ici, l'objet deux est recherché dans l'ensemble monEnsemble. S'il existe, il est affiché dans la console :

id unMembre = [monEnsemble member:(@"deux")];
if (unMembre!=nil)
{
  NSLog(@"Objet %@",unMembre);
}

Récupération des objets d'un ensemble

La méthode allObjects permet de récupérer tous les objets d'un ensemble sous la forme d'un NSArray :

NSArray *leTableau = [monEnsemble allObjects];

La méthode objectEnumerator permet de récupérer un NSEnumerator sur un ensemble :

NSEnumerator *enumer = [monEnsemble objectEnumerator];

Enfin, la méthode anyObject permet de récupérer un objet quelconque d'un ensemble :

id unObjetQuelconque = [monEnsemble anyObject];

En résumé

• Les chaînes de caractères sont manipulées à travers la classe NSString. Pour définir une chaîne, utilisez l'instruction NSString *maChaine.

• int, float, double, etc. ne sont pas les seuls types de données numériques. Vous pouvez aussi utiliser des objets de classe NSNumber dans certains cas particuliers, par exemple pour effectuer des conversions de données.

• Les classes NSDate, NSCalendar, NSTimeZone, NSDateComponents et NSDateFormatter permettent de manipuler des objets date et heure. Vous pouvez définir une date en rapport (ou non) avec la date système, extraire les composantes d'un objet NSDate, ajouter ou soustraire des dates, calculer la différence entre deux dates, etc.

• La classe NSArray est dédiée à la manipulation de tableaux. Lorsqu'un tableau a été défini, vous pouvez tester son contenu avec la méthode containsObject, et accéder aux objets qui le composent avec les méthodes objectAtIndex et objectEnumerator.

• Les classes NSDictionary et NSMutableDictionary permettent de définir des dictionnaires. Pour initialiser un dictionnaire, vous utiliserez les méthodes setObject, dictionnaryWithObjectAndKeys et initWithObjects.

• Pour mémoriser des objets en les empilant, vous utiliserez un ensemble. Lorsqu'un ensemble a été défini, vous pouvez tester si un objet en fait partie, récupérer un objet donné, un objet quelconque, tous les objets ou un énumérateur.

Dans ce premier programme, votre device va choisir un nombre de quatre chiffres au hasard. Vous devrez le trouver en un minimum d'essais en proposant des nombres de quatre chiffres. Pour chaque proposition, le nombre de chiffres bien placés sera indiqué. Le résultat attendu se trouve à la figure suivante.

Pour parvenir à ce résultat, vous devrez :

1. définir une application basée sur le modèle Single View Application ;

2. créer l'interface de l'application dans Interface Builder ;

3. relier les éléments de l'interface au code Objective-C ;

4. tirer au hasard un nombre de quatre chiffres ;

5. afficher le clavier lorsque le joueur clique dans la zone de saisie et l'effacer lorsqu'il valide sa saisie en appuyant sur Retour ;

6. écrire les instructions nécessaires pour comparer les nombres proposés par le joueur et le nombre à découvrir et afficher un message en conséquence.

Normalement, seule l'étape 4 devrait vous poser un problème. Les autres ont déjà été vues ; si vous avez le moindre problème avec, n'hésitez pas à lire les chapitres précédents correspondants.

Pour tirer un nombre aléatoire, nous utiliserons la fonction arc4random(), qui renvoie un nombre aléatoire compris entre 0 et 4 294 967 295. Sauf que nous voulons un nombre de 4 chiffres, donc compris entre 1000 et 9999. Bref, on en est loin. Nous allons donc devoir ruser, grâce au modulo. Regardez le code suivant :

arc4random() % 9000 + 1000;

arc4random() % 9000 renvoie un nombre compris entre 0 et 8999. En lui ajoutant 1000, le nombre est compris entre 1000 et 9999.

L'affichage du clavier est automatique lorsque le joueur clique dans la zone de saisie. Par contre, ce sera à vous de faire disparaître le clavier lorsque le joueur validera la saisie en appuyant sur la touche Retour. Cette action sera accomplie en appelant la méthode resignFirstResponder de la classe sender.

Je suis sûr que vous êtes pressés de commencer. Imaginez un peu, votre première application ! Alors, n'attendez plus, commencez dès maintenant. Et soyez assurés que je ne serai pas loin de vous. Si vous avez une difficulté quelconque, reportez-vous à la correction qui suit. J'ai détaillé chaque étape de façon à ce qu'aucun blocage ne vous empêche d'arriver au bout du TP. Cependant, il est tout à fait normal de passer un long moment à réfléchir à ce que vous devez faire. Vous pouvez même vous aider d'une feuille blanche et d'un stylo en mettant par écrit vos idées.

J'espère que vous n'avez pas eu trop de problèmes dans ce TP. Voici ma correction, dans laquelle je passe en revue tous les points qui auraient pu « coincer ».

Création de l'application

Dans Xcode, sélectionnez Create a new Xcode project dans la boîte de dialogue affichée au lancement du programme. Si aucune boîte de dialogue n'est affichée, lancez la commande New/New project dans le menu File. Dans la boîte de dialogue Choose a template for your new project, choisissez Single View Application puis cliquez sur Next. Donnez le nom mastermind à l'application, tapez test dans la zone de texte Company Identifier, cochez la case Use Storyboard et cliquez sur Next. Choisissez un dossier pour stocker l'application et validez en cliquant sur Create.
Au bout de quelques instants, le squelette de l'application est créé.

Définition de l'interface

Sous le dossier mastermind, cliquez sur l'entrée mainStoryboard.storyboard dans la barre de navigation (volet gauche de l'application). Une interface désespérément vide est affichée dans la partie droite de la fenêtre (figure suivante). Rassurez-vous, nous allons très vite la remplir.

Dans la partie supérieure droite de la fenêtre (c'est-à-dire dans la barre d'outils), au-dessus du libellé View, cliquez sur l'icône Hide or Show the utilities (1) et cliquez sur l'icône Show the Object Library (2) pour faire apparaître la bibliothèque, comme indiqué à la figure suivante.

Ajoutez deux Label, un Text Field, un Text View et un Round Rect Button à l'interface, puis redimensionnez-les pour obtenir une disposition semblable à la figure suivante.

Double-cliquez tour à tour sur les différents contrôles et insérez le texte spécifié dans le tableau suivant :

Si nécessaire, cliquez sur l'icône Show the Attributes inspector dans la partie supérieure du volet gauche. Si vous cliquez sur le Label, ses caractéristiques apparaissent dans le volet de l'inspecteur, comme sur la figure suivante. Sélectionnez Word Wrap dans la liste déroulante Line Breaks, tapez 2 dans la zone de texte Lines et redimensionnez le contrôle pour obtenir l'effet recherché.

Pour supprimer le texte proposé par défaut dans le contrôle TextView, cliquez dessus dans Interface Builder, sélectionnez le texte dans la zone Text du volet de l'inspecteur, appuyez sur la touche Suppr, puis sur la touche Entrée du clavier.

Liaison des contrôles au code

Cachez la zone d'utilitaires en cliquant sur l'icône Hide or show the Utilities (1) et affichez le code ViewController.h en cliquant sur l'icône Show the Assistant editor (2), comme montré à la figure suivante.

Vous allez maintenant relier les contrôles de l'interface au code.

Contrôle-glissez-déposez tour à tour les contrôles Text Field et Text View de l'interface jusqu'au volet de code. Donnez le nom saisie au Text Field, et le nom resultats au Text View.

Si vous avez suivi mes indications, le fichier ViewController.h doit maintenant ressembler à ceci :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController
@property (weak, nonatomic) IBOutlet UITextField *saisie;
@property (weak, nonatomic) IBOutlet UITextView *resultats;

@end

Pour terminer les liaisons, vous devez définir une action pour le contrôle Round Rect Button. Contrôle-glissez-déposez ce contrôle juste avant l'instruction @end. Au relâchement du bouton gauche de la souris, sélectionnez Action dans la zone Connection, tapez autrenombre dans la zone de texte Name et cliquez sur Connect (figure suivante).

La ligne suivante est ajoutée au code :

- (IBAction)autrenombre:(id)sender;

Sauvegardez votre projet avec la commande Save dans le menu File.
Juste histoire de souffler un peu, vous pouvez cliquer sur l'icône Run dans la barre d'outils et savourer votre travail. Le résultat affiché devrait être semblable à la figure suivante.

Cliquez sur Stop pour revenir à la dure réalité : vous devez maintenant écrire le code qui donnera vie à l'application !

Avant de commencer, cliquez sur ViewController.h dans le volet de navigation et définissez la variable d'instance nombreChoisi de type int pour mémoriser le nombre choisi par le device. Le fichier d'en-têtes doit maintenant ressembler à ceci :

@interface ViewController : UIViewController
{
  int nombreChoisi;
}

@property (weak, nonatomic) IBOutlet UITextField *saisie;
@property (weak, nonatomic) IBOutlet UITextView *resultats;

- (IBAction)autrenombre:(id)sender;
@end

Je vous sens vraiment impatients de faire fonctionner l'application. Alors, passons sans plus attendre à l'écriture du code.

Écriture du code

Si nécessaire, affichez la zone de navigation en cliquant sur l'icône Hide or show the Navigator, dans la partie droite de la barre d'outils, au-dessus du libellé View.
Cliquez sur mastermindViewController.m dans la zone de navigation. Le code généré par Xcode est de taille respectable. Il contient les différentes méthodes utilisées par l'application :

//Pour une meilleure lisibilité, j'ai supprimé les commentaires ajoutés automatiquement au début du fichier par Xcode

#import "ViewController.h"

@implementation ViewController
@synthesize saisie;
@synthesize resultats;

- (void)didReceiveMemoryWarning
{
  [super didReceiveMemoryWarning];
  // Release any cached data, images, etc that aren't in use.
}

#pragma mark - View lifecycle

- (void)viewDidLoad
{
  [super viewDidLoad];
  // Do any additional setup after loading the view, typically from a nib.
}

- (void)viewDidUnload
{
  [self setSaisie:nil];
  [self setResultats:nil];
  [super viewDidUnload];
  // Release any retained subviews of the main view.
  // e.g. self.myOutlet = nil;
}

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

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

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

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

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
{
  // Return YES for supported orientations
  return (interfaceOrientation != UIInterfaceOrientationPortraitUpsideDown);
}

- (IBAction)autrenombre:(id)sender {
}
@end

En examinant les dernières lignes, vous reconnaissez certainement la partie déclarative liée à l'action sur le contrôle Round Rect Button :

- (IBAction)autrenombre:(id)sender {
}

Quelques lignes plus haut, la méthode viewDidLoad va vous permettre d'initialiser l'application :

- (void)viewDidLoad
{
  [super viewDidLoad];
  // Do any additional setup after loading the view, typically from a nib.
}

Mais pourquoi serait-il nécessaire d'initialiser l'application me direz-vous ? Eh bien… pour choisir le nombre à découvrir !

Tirage aléatoire du nombre à découvrir

Ajoutez la ligne que nous avons vue plus haut, après [super viewDidLoad]; :

nombreChoisi = arc4random() % 9000 + 1000;

L'application sait maintenant tirer au hasard un nombre compris entre 1000 et 9999.

Traitement suite à la proposition d'un nombre

Lorsque le joueur a saisi un nombre de quatre chiffres, il appuie sur la touche Return pour valider la saisie. Le clavier doit alors disparaître de l'écran et le nombre entré doit être comparé au nombre à découvrir.
Pour ce faire, il est nécessaire de capturer l'événement « appui sur la touche Return » et de le relier à une méthode afin d'effectuer les traitements nécessaires.
Dans un premier temps, commencez par définir la méthode saisieReturn dans le fichier d'en-têtes. Cliquez sur ViewController.h dans le volet de navigation et entrez cette ligne, juste au-dessus du @end final :

- (IBAction)saisieReturn :(id)sender;

Le fichier d'en-têtes doit maintenant ressembler à ceci :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController
{
  int nombreChoisi;
}

@property (weak, nonatomic) IBOutlet UITextField *saisie;
@property (weak, nonatomic) IBOutlet UITextView *resultats;

- (IBAction)autrenombre:(id)sender;
- (IBAction)saisieReturn :(id)sender;
@end

Pour écrire le code qui efface le clavier de l'écran, cliquez sur ViewController.m dans le volet de navigation et définissez la méthode saisieReturn comme suit :

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

La méthode resignFirstResponder efface le clavier. C'est aussi simple que cela !

N'essayez pas d'exécuter l'application : vous devez auparavant relier l'événement « appui sur la touche Retour » à la méthode saisieReturn.

Pour cela, sélectionnez l'entrée MainStoryboard.storyboard dans la zone de navigation, affichez le volet des utilitaires en cliquant sur Hide or show the Utilities dans la barre d'outils, puis cliquez sur Show the Connections inspector, dans la partie supérieure. Cliquez sur le contrôle Text Field dans la zone d'édition pour le sélectionner. Sous Sent Events, repérez le rond à droite de l'événement Did End On Exit et déplacez-le sur l'icône View Controller, dans la partie inférieure de la zone d'édition. Au relâchement du bouton gauche de la souris, deux choix vous sont proposés : autreNombre et saisieReturn (figure suivante). Cliquez sur saisieReturn. Ainsi, la méthode saisieReturn sera exécutée lorsque l'utilisateur appuiera sur la touche Return du téléphone.

Vous pouvez maintenant exécuter l'application et vérifier que l'appui sur la touche Return dissimule le clavier.

Il est temps maintenant d'écrire le code relatif au traitement du nombre choisi par le joueur.
Cliquez sur ViewController.m dans la zone de navigation et complétez la méthode saisieReturn comme suit :

-(IBAction)saisieReturn:(id)sender
{
  [sender resignFirstResponder];
  int bienPlace = 0;
  int charIndex; //Index de boucle pour parcourir tous les caractères des chaînes à comparer
  unichar testChar1, testChar2; //Les caractères à comparer : testChar1 dans le nombre proposé, testChar2 dans le nombre à trouver
  for (charIndex = 0; charIndex < 4; charIndex++)
  {
    testChar1 = [saisie.text characterAtIndex:charIndex];
    testChar2 = [[NSString stringWithFormat:@"%d", nombreChoisi] characterAtIndex:charIndex];
    if (testChar1 == testChar2)
      bienPlace++;
  }
  resultats.text = [NSString stringWithFormat:@"%@%@%d%@%@", saisie.text, @" : Bien placés : ", bienPlace, @"\r", resultats.text];
  if (bienPlace == 4)
    resultats.text = [NSString stringWithFormat:@"%@%d", @"Bravo, le résultat était ", nombreChoisi];
}

Examinons un peu ce code ensemble.

Comme il a été dit précédemment, la ligne 3 supprime le clavier de l'écran. Jusque-là, tout va bien !

Le bloc d'instructions suivant (lignes 4 à 13) compare le nombre entré par le joueur au nombre à découvrir. Les premières lignes déclarent plusieurs variables :

• la variable entière bienPlace est définie et initialisée à 0 :

int bienPlace = 0;

• la variable entière charIndex est définie mais non initialisée :

int charIndex;

• il en va de même pour les variables unichartestChar1 et testChar2 :

unichar testChar1, testChar2;

La comparaison des quatre chiffres se fait dans une boucle for, en utilisant la variable charIndex comme index de boucle :

for (charIndex = 0; charIndex < 4; charIndex++)

À l'intérieur de la boucle, la première instruction s'intéresse à la saisie du joueur. Elle isole le caractère d'index charIndex et le stocke dans la variable unichar testChar1 :

testChar1 = [saisie.text characterAtIndex:charIndex];

La deuxième instruction fait de même, mais sur le nombre tiré aléatoirement. L'instruction est plus complexe, car le nombre choisi aléatoirement est un int et non un NSString. Il est donc nécessaire de le convertir en NSString avant de procéder à l'extraction :

testChar2 = [[NSString stringWithFormat:@"%d", nombreChoisi] characterAtIndex:charIndex];

Le premier message convertit l'int nombreChoisi en un NSString :

[NSString stringWithFormat:@"%d", nombreChoisi]

On extrait de l'objet ainsi obtenu le caractère qui se trouve à l'emplacement charIndex (characterAtIndex:charIndex) et on mémorise ce caractère dans la variable testChar2 (testChar2 =).

Il ne reste plus qu'à comparer testChar1 à testChar2 et à incrémenter la variable bienPlace si ces deux variables sont égales :

if (testChar1 == testChar2)
  bienPlace++;

Une fois que les quatre chiffres ont été testés, il faut afficher le résultat dans le contrôle TextView. C'est le rôle de l'instruction suivante :

resultats.text = [NSString stringWithFormat:@"%@%@%d%@%@", saisie.text, @" : Bien placés : ", bienPlace, @"\r", resultats.text];

On utilise pour cela une chaîne formatée ([NSString stringWithFormat: …]). Examinons le format de la chaîne affichée :

%@%@%d%@%@

En comptant le nombre de %, vous pouvez facilement déduire que cette chaîne est composée de cinq éléments. De gauche à droite, deux chaînes (%@), un nombre décimal (%d) et deux chaînes (%@). Ces éléments sont les suivants :

• la valeur saisie par le joueur, saisie.text ;

• le texte « Bien placés : » ;

• la valeur décimale bienPlace, convertie en une chaîne de caractères ;

• un saut de ligne \r ;

• les différentes informations précédemment affichées dans le contrôle TextView.

La dernière instruction teste si la partie est terminée :

if (bienPlace == 4)
  resultats.text = [NSString stringWithFormat:@"%@%d", @"Bravo, le résultat était ", nombreChoisi];

Si le nombre de caractères bien placés est égal à 4 (if (bienPlace == 4)), cela signifie que le nombre entré est égal au nombre à découvrir. Dans ce cas, un message est affiché dans le contrôle TextView resultats (resultats.text =). Ici encore, nous utilisons une chaîne formatée ([NSString stringWithFormat: …]). Comme vous pouvez le voir, le texte affiché est composé d'une chaîne et d'un nombre entier : le texte « Bravo, le résultat était », suivi du nombre à découvrir.

Tirage aléatoire d'un autre nombre

Pour terminer ce programme, il reste à écrire le code relatif à l'appui sur le bouton Choisir un autre nombre. Rassurez-vous, cette tâche vous paraîtra on ne peut plus simple après ce que vous venez de vivre !
L'entrée ViewController.m étant sélectionnée dans le volet de navigation, déplacez-vous dans la partie inférieure du code et complétez la méthode autrenombre comme suit :

- (IBAction)autrenombre:(id)sender 
{
  nombreChoisi = arc4random() % 9000 + 1000;
  resultats.text = [NSString stringWithFormat:@"%@", @"J'ai choisi un nouveau nombre\r"];
}

La première instruction est identique à celle qui a déjà été utilisée pour tirer un nombre aléatoire. Elle choisit un nombre compris entre 1000 et 9999 et le stocke dans la composante text de l'objet label nombreChoisi :

nombreChoisi = arc4random() % 9000 + 1000;

La deuxième instruction affiche le message « J'ai choisi un nouveau nombre » dans le contrôle TextView :

resultats.text = [NSString stringWithFormat:@"%@", @"J'ai choisi un nouveau nombre\r"];

L'application est entièrement fonctionnelle. Cliquez sur Run et amusez-vous bien !

Le code complet

Je vous mets ici le code complet de l'application.

ViewController.h

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController
{
  int nombreChoisi;
}

@property (weak, nonatomic) IBOutlet UITextField *saisie;
@property (weak, nonatomic) IBOutlet UITextView *resultats;

- (IBAction)autrenombre:(id)sender;
- (IBAction)saisieReturn :(id)sender;
@end

ViewController.m

#import "ViewController.h"

@implementation ViewController
@synthesize saisie;
@synthesize resultats;

- (void)didReceiveMemoryWarning
{
  [super didReceiveMemoryWarning];
  // Release any cached data, images, etc that aren't in use.
}

#pragma mark - View lifecycle

- (void)viewDidLoad
{
  [super viewDidLoad];
  nombreChoisi = arc4random() % 9000 + 1000;
}

- (void)viewDidUnload
{
  [self setSaisie:nil];
  [self setResultats:nil];
  [super viewDidUnload];
  // Release any retained subviews of the main view.
  // e.g. self.myOutlet = nil;
}

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

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

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

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

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
{
  // Return YES for supported orientations
  return (interfaceOrientation != UIInterfaceOrientationPortraitUpsideDown);
}

- (IBAction)autrenombre:(id)sender 
{
  nombreChoisi = arc4random() % 9000 + 1000;
  resultats.text = [NSString stringWithFormat:@"%@", @"J'ai choisi un nouveau nombre\r"];
}

-(IBAction)saisieReturn:(id)sender
{
  [sender resignFirstResponder];
  int bienPlace = 0;
  int charIndex;
  unichar testChar1, testChar2;
  for (charIndex = 0; charIndex < 4; charIndex++)
  {
    testChar1 = [saisie.text characterAtIndex:charIndex];
    testChar2 = [[NSString stringWithFormat:@"%d", nombreChoisi] characterAtIndex:charIndex];
    if (testChar1 == testChar2)
      bienPlace++;
  }
  resultats.text = [NSString stringWithFormat:@"%@%@%d%@%@", saisie.text, @" : Bien placés : ", bienPlace, @"\r", resultats.text];
  if (bienPlace == 4)
    resultats.text = [NSString stringWithFormat:@"%@%d", @"Bravo, le résultat était ", nombreChoisi];
}

@end

Avant de nous intéresser aux contrôles, nous allons consacrer un peu de temps à l'étude des vues. Cette étape est fondamentale. En effet, si les applications les plus simples comportent une seule vue, il n'est pas rare d'utiliser trois ou quatre vues dans une application traditionnelle.

Une bonne nouvelle : la quasi-totalité du travail se fera dans Interface Builder. Ce sera donc un jeu d'enfant pour vous.

Création de l'application

Commencez par créer une application basée sur le modèle Single View Application et donnez-lui le nom « troisVues ».
Cliquez sur MainStoryboard.storyboard dans le volet de navigation.

Rappelons que nous voulons créer une application qui comporte trois vues. Un contrôleur de vue étant déjà présent dans l'application, vous allez en ajouter deux autres en effectuant des glisser-déposer de la bibliothèque d'objets à la zone d'édition d'Interface Builder. Cliquez sur l'icône Hide or show the Utilities dans la barre d'outils de Xcode (1), sur l'icône Show the Object library dans la partie inférieure du volet des utilitaires (2), puis faites glisser deux View Controller sur la zone d'édition (3), comme indiqué à la figure suivante.

Pour bien repérer chacune des vues, vous allez modifier leur couleur d'arrière-plan. Cliquez sur l'icône Show the Attributes inspector dans le volet des utilitaires et agissez sur la liste déroulante Background. Choisissez alors les couleurs que vous souhaitez. Pour ma part, j'ai respectivement choisi les couleurs bleu, blanc et vert.

Ensuite, faites glisser :

• un contrôle Label sur chacune des vues ;

• un contrôle Round Rect Button sur la première vue et un autre sur la troisième vue;

• deux contrôles Round Rect Button sur la deuxième vue.

Double-cliquez tour à tour sur chacun de ces contrôles et ajoutez le texte suivant :

La figure suivante représente le résultat que j'ai obtenu.

Pour que ces vues puissent se faire référence l'une l'autre, vous allez ajouter un contrôleur de navigation.

Cliquez sur la première vue, déroulez le menu Editor, pointez Embed In et cliquez sur Navigation Controller. Un contrôleur de navigation est ajouté (figure suivante), et il est automatiquement relié à la première vue.

Vous allez maintenant relier les Round Rect Button aux différentes vues. Je vais vous indiquer en détail comment procéder pour relier le bouton de la vue 1 à la vue 2. Vous ferez de même pour relier les autres boutons des autres vues.

Cliquez sur le Round Rect Button de la vue 1 pour le sélectionner. Maintenez la touche Ctrl enfoncée, puis glissez-déposez le Round Rect Button sur la vue 2. Au relâchement du bouton gauche, une bulle intitulée Storyboard Segues est affichée. Dans cette bulle, vous devez choisir le type de transition entre les deux vues :

• Push : transition horizontale ;

• Modal : transition verticale ;

• Custom : transition personnalisée.

Choisissez Push pour obtenir une translation horizontale. Une flèche entre la vue 1 et la vue 2 indique que la liaison a été établie (figure suivante).

Recommencez la manipulation qui vient d'être décrite pour relier :

• les vues 1 et 2 via le bouton Vue précédente de la vue 2 ;

• les vues 2 et 3 via le bouton Vue suivante de la vue 2 ;

• les vues 2 et 3 via le bouton Vue précédente de la vue 3.

Ça y est, vous pouvez exécuter l'application et jouer avec les boutons des trois vues.

Arrivés à ce point, vous savez créer une application multivues, mais vous ne savez pas encore (du moins pas précisément) comment ajouter du contenu dans chacune de ces vues. Il est grand temps de nous intéresser aux contrôles.

Pour insérer un contrôle dans une application, vous devez dans un premier temps afficher la bibliothèque de contrôles. Comme à la figure suivante, sélectionnez le fichier MainStoryboard.storyboard correspondant à la vue dans la zone de navigation (1), cliquez sur l'icône Hide or show the Utilities dans la barre d'outils (2), puis sur Show the Object Library dans la zone des utilitaires (3).
Pointez alors un contrôle dans la bibliothèque, maintenez le bouton gauche de la souris enfoncé et déposez le contrôle sur la fenêtre de l'application (4).

Si vous n'êtes pas certains de la fonction d'un contrôle, cliquez dessus dans la bibliothèque et maintenez le pointeur de la souris immobile pendant quelques instants. Une bulle d'aide sera alors affichée. Si ces informations ne sont pas suffisantes, vous pouvez cliquer sur l'icône Show Quick Help dans la partie supérieure du volet des utilitaires, comme indiqué à la figure suivante.

Si nécessaire, cliquez sur un des liens (affichés en bleu) pour accéder à l'aide correspondante dans la documentation Apple.

La façon la plus naturelle et la plus rapide pour positionner, aligner et redimensionner des contrôles consiste à utiliser la souris.

Positionner un contrôle à vue

Pour déplacer un contrôle dans la vue qui le contient, pointez-le, maintenez le bouton gauche de la souris enfoncé, déplacez la souris jusqu'à ce que l'objet ait la position souhaitée puis relâchez le bouton gauche de la souris.

Aligner un contrôle à vue

Les contrôles d'une application peuvent être alignés à vue. Ainsi par exemple, il est possible de faire correspondre le bord gauche d'un contrôle avec celui d'un autre contrôle, ou encore d'aligner un contrôle au centre ou sur une marge de la vue.
Pointez le contrôle à positionner, maintenez le bouton gauche de la souris enfoncé et déplacez le contrôle dans la vue. Une ou plusieurs lignes pointillées signalent le ou les divers alignements possibles pendant que le contrôle est déplacé, comme le montre la figure suivante. Relâchez le bouton gauche lorsque le contrôle a la position souhaitée.

Redimensionner un contrôle à vue

De nombreux contrôles peuvent être redimensionnés. Pour cela, il suffit d'agir sur leurs poignées de redimensionnement à l'aide de la souris.
Cliquez sur le contrôle pour le sélectionner. Plusieurs poignées de redimensionnement sont affichées. Pointez l'une d'entre elles. Lorsque le pointeur de la souris change de forme, maintenez le bouton gauche enfoncé et déplacez la souris pour obtenir la dimension souhaitée (figure suivante).

Vous trouverez dans cette section les différents contrôles accessibles dans la bibliothèque. Chacun d'eux peut être utilisé dans une application pour iPhone, iPod Touch et iPad.

Icône	Nom du contrôle	Fonction
	Label	Texte non modifiable par l'utilisateur
	Round Rect Button	Bouton de commande touch
	Segmented Control	Onglets permettant d'afficher différentes vues/contrôles
	Text Field	Zone de texte modifiable par l'utilisateur
	Slider	Curseur pour faciliter la saisie d'une valeur
	Switch	Bouton de type ON/OFF
	Activity Indicator View	Indicateur d'activité pour faire patienter l'utilisateur pendant un long traitement
	Progress View	Indicateur de progression utilisé pendant un long traitement
	Page Control	Indique la page en cours de visualisation (dans une application multi-page)
	Table View	Liste hiérarchique d'informations textuelles disposées verticalement
	Table View Cell	Paramètre d'une des cellules affichées dans un Table View
	Image View	Conteneur permettant d'afficher une image ou une animation
	Text View	Zone de texte multiligne éditable
	Web View	Affichage d'un contenu Web
	Map View	Affichage d'une carte, similaire à celle affichée dans l'application Plans
	Scroll View	Contrôle permettant d'afficher un contenu d'une taille supérieure à celle de la fenêtre/du contrôle en faisant glisser l'affichage dans la zone de visualisation
	Date Picker	Sélection d'une date et d'une heure à l'aide de plusieurs contrôles en forme de roues
	Picker View	Sélection d'une valeur dans un contrôle en forme de roue
	Ad BannerView	Vue dédiée à l'affichage de publicités
	GLKit View	Vue OpenGL ES
	Tap Gesture Recognizer	Reconnaissance d'une gestuelle multitouch
	Pinch Gesture Recognizer	Reconnaissance de la gestuelle "rétrécir"
	Rotation Gesture Recognizer	Reconnaissance de la gestuelle "rotation"
	Swipe Gesture Recognizer	Reconnaissance de la gestuelle "glisser"
	Pan Gesture Recognizer	Reconnaissance de la gestuelle "glisser"
	Long Press Gesture Recognizer	Reconnaissance de la gestuelle "long toucher"
	Object	Un objet non disponible dans Interface Builder, tiré d'une instance d'une classe
	View Controller	Contrôle dédiée à la gestion de barres d'outils, barres de navigation et vues d'une application
	Table View Controller	Contrôle dédié à la gestion d'un Table View
	Navigation Controller	Ce contrôle est dédié à la gestion des contrôleurs de vue. Il fournit des informations relatives à la vue active.
	Tab Bar Controller	Gère plusieurs vues au travers d'onglets
	View	Zone rectangulaire de tracé
	Navigation Bar	Barre de navigation, affichée juste en dessous de la barre d'état
	Navigation Item	Elément affiché dans un contrôle Navigation Bar
	Search Bar	Barre de recherche éditable
	Search Bar and Search Display Controller	Barre de recherche et son contrôleur Table View associé
	Toolbar	Barre d'outils contenant un ou plusieurs boutons
	Bar Button Item	Un bouton dans un contrôle Toolbar
	Fixed Space Bar Button Item	Espace ajustable par le programmeur dans un contrôle Toolbar
	Flexible Space Bar Button Item	Espace qui s'ajuste automatiquement en fonction de la place disponible dans un contrôle Toolbar
	Tab Bar	Barre d'onglets
	Tab Bar Item	Une icône représentant un onglet dans un contrôle Tab Bar

Juste avant cette (longue) liste, vous avez vu qu'il était possible de changer la taille d'un contrôle en agissant sur ses poignées de redimensionnement. Rassurez-vous, la personnalisation des contrôles ne se limite pas à leur redimensionnement. De nombreux autres paramètres sont accessibles en utilisant le volet des attributs. Pour accéder à ce volet, cliquez sur l'icône Show the Attributes inspector, dans la partie supérieure du volet des utilitaires, comme indiqué à la figure suivante.

Je ne vais pas décrire en détail tous les paramètres accessibles dans le volet des attributs, d'autant plus qu'ils varient énormément d'un contrôle à l'autre. Ce sera donc à vous de les découvrir. Cependant, je ne peux m'empêcher de vous donner quelques conseils pour que vous soyez encore plus efficaces.

• Le volet des attributs concerne le contrôle actif. Pour sélectionner un contrôle, il vous suffit de cliquer dessus.

• Les caractéristiques de la vue peuvent également être ajustées dans le volet des attributs : il suffit pour cela de cliquer sur un emplacement inoccupé de la vue afin d'accéder aux paramètres correspondants.

• Pour sélectionner facilement un des contrôles de l'application, vous pouvez utiliser la barre d'accès rapide d'Interface Builder (cette barre est située au-dessus de la zone d'édition). Cliquez sur l'icône View puis sur le contrôle que vous voulez sélectionner.

• Pour chaque contrôle, le volet des attributs donne accès à un grand nombre de caractéristiques. Cependant, les informations relatives à la position et à la taille ne sont pas accessibles. Si vous désirez positionner très précisément un contrôle, vous utiliserez le volet Taille. Cliquez sur le contrôle concerné, puis sur l'icône Show the Size inspector dans la partie supérieure du volet des utilitaires.

En résumé

• Les iPhone, iPod Touch et iPad ont une particularité : ils ne sont capables d'afficher qu'une et une seule fenêtre sur l'écran. Cependant, il est possible de définir plusieurs vues dans Interface Builder, en glissant-déposant des contrôles View Controller depuis la bibliothèque d'objets dans le canevas.

• Pour que plusieurs vues puissent se faire référence l'une l'autre, vous devez ajouter un contrôleur de navigation (Navigation Controller). Ce dernier est ajouté avec la commande Embed In/Navigation Controller dans le menu Editor de Xcode.

• Pour définir une transition d'une vue à une autre, contrôle-glissez-déposez un bouton de la vue d'origine sur la vue de destination et choisissez un type de transition : Push, Modal ou Custom.

• Pour ajouter des contrôles dans une application multivue, glissez-déposez le contrôle souhaité depuis la bibliothèque de contrôles dans la vue qui doit l'héberger. Les contrôles ainsi déposés peuvent être déplacés, alignés et redimensionnés à vue. Vous pouvez également utiliser les volets Attributs et Taille pour accéder à des paramètres complémentaires.

• Pour sélectionner facilement un des contrôles de l'application, vous pouvez utiliser la barre d'accès rapide d'Interface Builder, au-dessus du canevas. Cliquez sur l'icône View puis sur le contrôle que vous voulez sélectionner.

Les contrôles Label (figure suivante) sont utilisés pour afficher des textes courts sur une ou plusieurs lignes. Leur contenu ne peut pas être modifié par l'utilisateur. Les caractéristiques d'un Label peuvent être définies dans Interface Builder, comme le montre la figure suivante.

Vous pouvez choisir, entre autres, le texte affiché dans le label, l'alignement du texte dans le contrôle, le nombre de lignes, la police et la couleur des caractères.
En utilisant du code Objective-C, vous pouvez également agir sur le texte, la police, la taille et la couleur des caractères ainsi que la couleur d'arrière-plan d'un label.

monLabel.text = @"Un court texte affiché dans le contrôle Label sur deux lignes";
monLabel.numberOfLines = 2;
monLabel.font = [UIFont fontWithName:@"Courier" size:10.0f];
monLabel.textAlignment = UITextAlignmentCenter;
monLabel.textColor = [UIColor colorWithRed: 1.0f green: 0.0f blue: 0.0f alpha: 1.0f];

• La première ligne définit le texte affiché dans le Label.

• La deuxième ligne indique que le texte sera affiché sur deux lignes.

• La troisième ligne définit la police et la taille des caractères.

• La quatrième ligne définit le mode d'alignement du texte dans le contrôle.

• Enfin, la cinquième ligne définit la couleur du texte via ses composantes rouge (colorWithRed), verte (green) et bleue (blue) et sa transparence (alpha).

D'autres méthodes sont disponibles pour manipuler les contrôles Label. Pour en avoir un aperçu, consultez la documentation relative à la classe UILabel.

La liste des polices disponibles sur un device iOS est accessible sur le site Web iOS Fonts.

Les Text Field (figure suivante) sont des zones de texte monoligne. Ils sont utilisés pour saisir des données textuelles courtes, comme un nom ou un mot de passe par exemple.
Le texte saisi dans un contrôle Text Field est accessible en lecture et en écriture à travers sa propriété text.

Supposons que vous ayez défini le Label monLabel et le Text Field monTextField. Pour afficher dans le Label le contenu du Text Field chaque fois que ce dernier change, procédez comme suit :

1. contrôle-glissez-déposez le Label de la fenêtre d'édition dans le code du fichier d'en-têtes, juste au-dessus du @end final et créez l'outlet monLabel ;

2. contrôle-glissez-déposez le Text Field de la fenêtre d'édition dans le code du fichier d'en-têtes, juste au-dessus du @end final et créez l'outlet monTextField ;

3. contrôle-glissez-déposez le Text Field de la fenêtre d'édition dans le code du fichier d'en-têtes, juste au-dessus du @end final et créez l'action monTextField, de type Editing Changed ;

4. insérez le code suivant dans la méthode monTextFieldChange :

- (IBAction)monTextFieldChange:(id)sender {
  monLabel.text = monTextField.text;
}

Tout comme pour les Label, vous pouvez choisir l'alignement, la police et la couleur du texte, dans Interface Builder ou avec du code Objective-C. Pour inviter l'utilisateur à entrer du texte dans un Text Field, vous pouvez renseigner sa propriété Placeholder, comme indiqué à la figure suivante.

Cette propriété est également utilisable en lecture et en écriture dans le code :

monTextField.placeholder = @"Entrez votre nom";

Les Text View (figure suivante) sont des zones de texte multiligne. Ces contrôles peuvent être affichés en lecture seule ou en lecture/écriture. Dans le deuxième cas, l'utilisateur pourra modifier leur contenu en utilisant le clavier du device. Le texte affiché dans un contrôle Text View utilise une seule police et une seule taille de caractères. Lorsqu'une adresse Web est insérée dans un Text View, elle peut être cliquée par l'utilisateur. La page correspondante s'ouvre alors dans le navigateur Safari.

Enfin, lorsque le contenu d'un Text View est trop long pour être affiché en totalité, l'utilisateur peut utiliser une gestuelle de glisser pour faire défiler le texte dans le contrôle.

Les contrôles Text View relèvent de la classe UITextView. Consultez l'aide de cette classe pour en savoir plus sur ce contrôle.

Le contrôle Image View (figure suivante) permet d'afficher une image ou une animation, définie par l'affichage consécutif de plusieurs images. Les images sont chargées via des objets UIImage. Une fois l'image chargée, il suffit de l'associer à une vue et à une taille pour l'afficher.
Sans entrer dans les détails, sachez cependant que les images affichées dans un contrôle Image View peuvent provenir de l'album photo du device, des ressources de l'application, d'Internet ou être créées par l'application elle-même. Examinons ces quatre cas.

L'image est dans l'album photo du device

Certains devices iOS disposent d'un appareil photo. Lorsqu'une photo est prise, elle est stockée dans l'album photo du device. Ce dernier est accessible par l'icône Photos. Malheureusement, lorsque vous cliquez dessus dans le simulateur iOS, l'album photo est vide, comme à la figure suivante.

Si vous voulez utiliser le simulateur pour vous entraîner à manipuler les photos de l'album, il est donc nécessaire de le remplir avant toute chose. Le simulateur vous propose d'utiliser iTunes pour ajouter des photos dans l'album. Nous allons utiliser une tout autre technique.

1. Trouvez un dossier qui contient des photos sur votre Mac.

2. Glissez-déposez une photo sur l'album photo du simulateur. Quelques instants plus tard, la photo est affichée dans le navigateur Safari (1).

3. Pointez la photo et maintenez le bouton gauche de la souris enfoncé jusqu'à ce qu'un menu apparaisse dans la partie inférieure de l'écran (2).

4. Cliquez sur Save Image (3).

5. Recommencez les étapes 2 à 4 pour ajouter une ou plusieurs autres photos.

Si vous avez du mal à comprendre, reprenez ces instructions en observant la figure suivante.

Maintenant, voyons comment accéder à ces photos.

Toute la magie réside dans l'utilisation d'un objet UIImagePickerController. Ce contrôleur permet entre autres de sélectionner une image dans une liste. C'est exactement ce que nous voulons. La liste sera prise dans l'album photo.

Définissez un nouveau projet de type Single View Application et donnez-lui le nom « imagePicker ». Cliquez sur MainStoryboard.storyboard dans le volet de navigation, puis ajoutez un contrôle Image View et un contrôle Rounded Rect Button dans la zone d'édition. Redimensionnez-les pour obtenir quelque chose ressemblant à la figure suivante.

Reliez les deux contrôles au code en créant :

• l'outlet uneImage pour le contrôle UIImageView ;

• l'action album pour le bouton.

Le fichier ViewController.h devrait maintenant ressembler à ceci :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController
@property (weak, nonatomic) IBOutlet UIImageView *uneImage;

- (IBAction)album:(id)sender;
@end

Étant donné que l'objet UIImagePickerController ne fait pas partie de la librairie d'objets Cocoa Touch, nous allons l'implémenter directement dans le code. Cliquez sur ViewController.h dans le volet de navigation et insérez la ligne suivante dans les variables d'instance :

UIImagePickerController *picker;

Le fichier ViewController.h devrait maintenant ressembler à ceci :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController
{
  UIImagePickerController *picker;
}

@property (weak, nonatomic) IBOutlet UIImageView *uneImage;

- (IBAction)album:(id)sender;
@end

Lorsque l'utilisateur clique sur le bouton, nous voulons afficher la liste des images contenues dans l'album photo. Pour cela, nous allons agir sur la méthode événementielle album. Cliquez sur ViewController.m dans le volet de navigation puis complétez la méthode album comme suit :

- (IBAction)album:(id)sender {
  picker = [[UIImagePickerController alloc] init];
  picker.delegate = self;
  picker.sourceType = UIImagePickerControllerSourceTypePhotoLibrary;
  [self presentModalViewController:picker animated:YES];
}

Si vous trouvez ce code compliqué, ne paniquez pas ; je vais tout vous expliquer !

La ligne 2 initialise l'objet picker en le reliant à la classe UIImagePickerController.

La ligne 3 définit le delegate de l'objet picker. C'est ce delegate qui recevra les notifications lorsque l'utilisateur sélectionnera une image ou fermera l'Image Picker sans rien sélectionner.

La ligne 4 indique à l'Image Picker à quel endroit il doit rechercher la liste d'images. Vous l'aurez compris, le mot UIImagePickerControllerSourceTypePhotoLibrary fait référence à l'album photo.

Enfin, la ligne 5 applique la méthode presentModalViewController à l'Image Picker. Ainsi, les vignettes de l'album seront affichées dans une fenêtre « modale », c'est-à-dire dans une fenêtre située au-dessus de l'application et qui rend l'accès à cette dernière impossible.

Je ne sais pas si vous avez remarqué le point d'exclamation de couleur jaune en face de l'instruction picker.delegate = self;. Il s'agit d'un avertissement. Si vous cliquez sur le point d'exclamation, Xcode affiche des informations complémentaires sur le problème, comme à la figure suivante.

Reprenons l'intitulé du message :

Passing 'ViewController *const\_strong' to parameter of incompatible type 'id<UINavigationControllerDelegate, UIImagePickerControllerDelegate>'

Assigning to 'id<UINavigationControllerDelegate.UIImagePickerControllerDelegate>' from incompatible type 'imagePickerViewController *'

Cela signifie que la gestion des événements liés à l'objet picker ne peut pas être prise en charge dans cette classe (= self dans l'instruction).

En d'autres termes, cela signifie qu'il faut ajouter un delegate dans le fichier d'en-têtes pour traiter ces événements. Et même deux delegate, puisque UIImagePickerController est lié à UINavigationController.

Pour régler ce problème, retournez dans le fichier ViewController.h et modifiez la déclaration de l'interface comme suit :

@interface ViewController : UIViewController <UINavigationControllerDelegate, UIImagePickerControllerDelegate> {
  ...
}

Comme par magie, l'avertissement disparaît. En définissant ces deux delegate, nous avons indiqué au compilateur que les notifications reçues lors des manipulations de l'utilisateur dans l'Image Picker seront prises en compte par… ces delegate et traités dans la classe de l'application.

Vous pouvez lancer l'application. Lorsque vous cliquez sur le bouton Accéder à l'album photo, l'album photo apparaît dans une liste. Cliquez dessus pour afficher les vignettes qui représentent son contenu, comme à la figure suivante.

Consternation ! Lorsque vous cliquez sur une image, elle ne s'affiche pas sur le device !

Si vous réfléchissez un peu, c'est tout à fait normal… puisqu'aucune méthode n'a été écrite pour provoquer cet affichage.
Définissez donc la méthode suivante :

- (void)imagePickerController:(UIImagePickerController *) Picker didFinishPickingMediaWithInfo:(NSDictionary *)info 
{
  uneImage.image = [info objectForKey:UIImagePickerControllerOriginalImage];
  [picker dismissModalViewControllerAnimated:YES];
}

Cette méthode est exécutée lorsque l'utilisateur choisit une vignette dans l'Image Picker. L'image choisie est alors affichée dans le contrôle Image View (ligne 3 du code).

L'instruction suivante ferme la vue modale de l'Image Picker.

Dans tous vos développements d'applications iOS, la documentation Apple vous sera d'une très grande aide. Pour l'utiliser, posez-vous les questions suivantes : « Qu'est-ce que je veux faire ? » et « De quoi dépend l'action que je veux réaliser ? ».

Ici par exemple, vous voulez afficher une image dans le contrôle ImageView lorsque l'utilisateur clique sur une vignette affichée dans l'Image Picker. Vous voulez donc capturer un événement. Et comme vous le savez, les événements sont gérés par… les delegate ! C'est donc dans l'aide Apple sur un delegate que va se trouver la solution.

De quel delegate s'agit-il ? Eh bien, l'utilisateur va cliquer sur une vignette dans le contrôle Image Picker. Il s'agit donc du delegate UIImagePickerControllerDelegate.

Comme indiqué à la figure suivante, cliquez sur l'icône Organizer (1), dans l'angle supérieur droit de la fenêtre Xcode pour afficher la fenêtre d'aide. Tapez « UIImagePickerControllerDelegate » dans la zone de texte Rechercher (2) et appuyez sur la touche Entrée de votre clavier. Plusieurs réponses sont affichées dans le volet gauche. Choisissez celle qui se trouve sous l'intitulé « Reference » (3).
Ça y est, vous avez fait le plus gros du travail. Il ne vous reste plus qu'à parcourir la page d'aide pour trouver la méthode recherchée (4).

Pour finir, vous devez implémenter une autre méthode, qui sera exécutée si l'utilisateur clique sur Cancel pour annuler l'utilisation de l'Image Picker. Dans ce cas, il suffira de fermer la vue modale et de supprimer l'objet Picker. Voici le code à utiliser :

- (void)imagePickerControllerDidCancel:(UIImagePickerController *) Picker 
{
  [picker dismissModalViewControllerAnimated:YES];
  uneImage.image = nil;
}

La ligne 3 ferme la vue modale de l'Image Picker. Quant à la ligne 4, elle efface l'image affichée dans le contrôle Image View.

L'application est entièrement opérationnelle. Il ne vous reste plus qu'à l'exécuter et à choisir l'image à afficher.

L'image est dans les ressources de l'application

Une application iOS peut « embarquer » un ou plusieurs fichiers (images, sons, textes, etc.). Dans ce cas, on dit que ces fichiers font partie des ressources de l'application.

Avant toute chose, il va nous falloir ajouter des ressources à l'application. Pour ce faire, cliquez du bouton droit sur l'icône qui représente l'application dans le volet de navigation et choisissez New group dans le menu contextuel, comme à la figure suivante.

Donnez le nom « Resources » au nouveau groupe (avec un seul « s »). Maintenant, il vous suffit de glisser-déposer une image depuis le Finder dans le dossier « Resources », de cocher la case Copy items into destination group's folder (if needed) et de valider en cliquant sur Finish (figure suivante). L'image est alors intégrée aux ressources de l'application.

Lorsqu'une image se trouve dans les ressources de l'application (1), elle est directement accessible dans la propriété Image d'un contrôle Image View (2), comme le montre la figure suivante.

Vous pouvez également insérer une image dans un contrôle Image View en utilisant du code. Supposons que l'outlet monImage ait été créé pour représenter un contrôle Image View et que l'image chien.jpg se trouve dans les ressources de l'application. Pour afficher cette image dans le contrôle Image View, vous utiliserez l'instruction suivante :

monImage.image = [UIImage imageNamed:@"chien.jpg"];

Simple, non ?

L'image est sur Internet

Supposons que vous vouliez afficher dans un contrôle Image View l'image qui se trouve à l'adresse medias\www.siteduzero.com_uploads_fr_ftp_iphone_zozor.png.

Commencez par créer un nouveau projet de type Single View Application et donnez-lui le nom « imageURL ».
Cliquez sur MainStoryboard.storyboard dans le volet de navigation, insérez un contrôle Image View dans le canevas et faites-lui occuper toute la surface disponible. Affichez le fichier d'en-têtes à côté du canevas en cliquant sur l'icône Show the Assistant editor dans la barre d'outils. Contrôle-glissez-déposez le contrôle Image View juste avant le @end du fichier d'en-têtes et créez l'outlet monImage.

Le fichier imageURLViewController.h doit maintenant ressembler à ceci :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController

@property (weak, nonatomic) IBOutlet UIImageView *monImage;
@end

Pour afficher l'image dès l'ouverture de l'application, vous allez agir sur la méthode viewDidLoad. Cliquez sur ViewController.m dans le volet de navigation et insérez le code suivant dans la méthode viewDidLoad:

- (void)viewDidLoad
{
  [super viewDidLoad];
  NSURL *uneImage = [NSURL URLWithString: @"medias\www.siteduzero.com_uploads_fr_ftp_iphone_zozor.png"];
  monImage.image = [UIImage imageWithData: [NSData dataWithContentsOfURL: uneImage]];
}

Comme vous pouvez le voir, deux instructions ont été ajoutées à cette méthode.

La première définit l'objet uneImage de type NSURL et y stocke l'URL de l'image en utilisant la méthode URLWithString.

La deuxième instruction lit l'image sur le Web et l'affecte à l'objet monImage. Remarquez le chaînage des messages. Dans un premier temps, un objet NSData est initialisé avec l'image lue sur le Web ([NSData dataWithContentsOfURL: uneImage]). Dans un deuxième temps, cet objet est transformé en un objet UIImage ([UIImage imageWithData: …]. Enfin, dans un troisième temps, cet objet UIImage est affecté au UIImageView monImage (monImage.image = …).

Vous pouvez lancer l'application, l'image est immédiatement affichée, comme à la figure suivante.

L'image est stockée dans la sandbox

Sur un device iOS, chaque application s'exécute dans une sandbox (Sandbox signifie « bac à sable » en français.) qui lui est propre. Dans cet espace, il est possible de sauvegarder des informations de tous types : textes, images, URL, etc. Ces informations peuvent être rapidement retrouvées par l'application lorsqu'elle en a besoin. Cette technique est très pratique. Elle est généralement utilisée pour stocker l'état de l'application. Lorsqu'elle est à nouveau exécutée, l'utilisateur la retrouve dans le même état que la dernière fois qu'il l'a utilisée.
Dans cette section, je vais vous montrer comment stocker et lire une image dans la sandbox. À titre d'exemple, l'image sera lue sur le Web, sauvegardée dans la sandbox de l'application, puis affichée dans un Image View en la lisant dans la sandbox.

Définissez un nouveau projet de type Single View Application et donnez-lui le nom « sandbox ». Cliquez sur MainStoryboard.storyboard dans le volet de navigation, insérez un contrôle Image View dans la zone d'édition et faites-lui occuper toute la surface disponible. Affichez le fichier d'en-têtes à côté de la zone d'édition en cliquant sur l'icône Show the Assistant editor dans la barre d'outils. Contrôle-glissez-déposez le contrôle Image View juste avant le @end du fichier d'en-têtes et créez l'outlet monImage.

Le fichier ViewController.h doit maintenant ressembler à ceci :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController

@property (weak, nonatomic) IBOutlet UIImageView *monImage;
@end

Il est temps de s'attaquer au fichier .m. Cliquez sur ViewController.m dans le volet de navigation et complétez la méthode viewDidLoad comme suit :

- (void)viewDidLoad
{
  [super viewDidLoad];

  //Récupération du fichier dans la sandbox et affichage dans le Image View
  NSString *limage = [NSHomeDirectory()stringByAppendingPathComponent: @"Documents/image.png"];
  UIImage *recup = [UIImage imageWithContentsOfFile: limage];
  monImage.image = recup;
  
  //Stockage d'une image Web dans la sandbox sous le nom "image.png"
  NSURL *uneImage = [NSURL URLWithString: @"medias\www.siteduzero.com_uploads_fr_ftp_iphone_zozor.png"];
  UIImage *img = [UIImage imageWithData: [NSData dataWithContentsOfURL: uneImage]];
  NSData* imageData = UIImagePNGRepresentation(img);
  [imageData writeToFile:limage atomically:NO];
}

Toutes ces instructions ont de quoi donner la chair de poule ! Mais rassurez-vous, elles n'ont rien de bien sorcier et d'ici cinq petites minutes, vous les comprendrez parfaitement.
Comme vous pouvez le voir, cette méthode contient deux blocs d'instructions.

1. Le premier retrouve l'image stockée dans la sandbox et l'affiche dans le contrôle Image View.

2. Le deuxième récupère une image sur le Web et la stocke dans la sandbox sous le nom image.png.

Examinons les instructions de ces deux blocs.
Le chemin du dossier dans lequel sont stockés les fichiers de la sandbox est retourné par la méthode NSHomeDirectory(). À ce chemin, on ajoute le sous-dossier Documents et le fichier image.png. La concaténation se fait via la méthode stringByAppendingPathComponent. Le chemin complet du fichier image.png est donc obtenu par l'expression suivante :

[NSHomeDirectory()stringByAppendingPathComponent: @"Documents/image.png"];

Pour faciliter la manipulation de ce chemin, il est stocké dans un objet NSString de nom limage :

NSString *limage = [NSHomeDirectory()stringByAppendingPathComponent: @"Documents/image.png"];

Pour récupérer l'image qui a été stockée à cet emplacement, il suffit d'utiliser la méthode imageWithContentsOfFile. L'image est stockée dans un objet UIImage de nom recup :

UIImage *recup = [UIImage imageWithContentsOfFile: limage];

L'étape finale consiste à affecter l'objet recup à la propriété image du contrôle Image View, ce qui provoque l'affichage de l'image :

monImage.image = recup;

Jusque-là, tout va bien. Attaquons-nous au stockage de l'image dans la sandbox.
La première instruction définit l'objet NSURL uneImage et y stocke l'adresse URL de l'image à rapatrier depuis le Web :

NSURL *uneImage = [NSURL URLWithString: @"medias\www.siteduzero.com_uploads_fr_ftp_iphone_zozor.png"];

La deuxième instruction rapatrie l'image Web et la stocke dans un objet UIImage de nom img :

UIImage *img = [UIImage imageWithData: [NSData dataWithContentsOfURL: uneImage]];

Cette technique a déjà été étudiée dans la section précédente. C'est pourquoi nous ne nous y attarderons pas.
Malheureusement, il est impossible de stocker un objet UIImage dans la sandbox. Il faut au préalable le convertir en un objet NSData. Pour cela, vous utiliserez la méthode :

• UIImagePNGRepresentation si l'image est au format PNG ;

• UIImageJPEGRepresentation si l'image est au format JPEG.

Ici, l'image étant au format PNG, nous utilisons la méthode suivante :

NSData* imageData = UIImagePNGRepresentation(img);

Il ne reste plus qu'à enregistrer l'objet NSData imageData dans la sandbox avec la méthode writeToFile :

[imageData writeToFile:limage atomically:NO];

Lancez l'application.

Lors de la première exécution, l'écran reste désespérément blanc. Quelle en est la raison selon vous ?
Rappelez-vous : le premier bloc d'instructions affiche l'image stockée dans la sandbox et le deuxième stocke l'image de Zozor dans la sandbox. Lors de la première exécution, Zozor n'a pas encore été mémorisé dans la sandbox. Quittez le simulateur avec la commande Quitter Simulateur iOS dans le menu Simulateur iOS et relancez l'application en cliquant sur Run dans Xcode. Cette fois-ci, Zozor est bien affiché dans le contrôle Image View.

Vous trouverez ci-après les codes de cette application.

ViewController.h

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController

@property (weak, nonatomic) IBOutlet UIImageView *monImage;
@end

ViewController.m

#import "ViewController.h"

@implementation ViewController
@synthesize monImage;

- (void)didReceiveMemoryWarning
{
    [super didReceiveMemoryWarning];
    // Release any cached data, images, etc that aren't in use.
}

#pragma mark - View lifecycle

- (void)viewDidLoad
{
    [super viewDidLoad];
    //Récupération du fichier dans la sandbox et affichage dans le Image View
    NSString *limage = [NSHomeDirectory()stringByAppendingPathComponent: @"Documents/image.png"];
    UIImage *recup = [UIImage imageWithContentsOfFile: limage];
    monImage.image = recup;
    
    //Stockage d'une image Web dans la sandbox sous le nom image.png
    NSURL *uneImage = [NSURL URLWithString: @"medias\www.siteduzero.com_uploads_fr_ftp_iphone_zozor.png"];
    UIImage *img = [UIImage imageWithData: [NSData dataWithContentsOfURL: uneImage]];
    NSData* imageData = UIImagePNGRepresentation(img);
    [imageData writeToFile:limage atomically:NO];
}

- (void)viewDidUnload
{
    [self setMonImage:nil];
    [super viewDidUnload];
    // Release any retained subviews of the main view.
    // e.g. self.myOutlet = nil;
}

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

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

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

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

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
{
    // Return YES for supported orientations
    return (interfaceOrientation != UIInterfaceOrientationPortraitUpsideDown);
}

@end

En résumé

• Les contrôles Label sont utilisés pour afficher des textes courts sur une ou plusieurs lignes. Leur contenu ne peut pas être modifié par l'utilisateur. Les caractéristiques d'un Label peuvent être définies dans Interface Builder ou dans le code.

• Les Text Field sont des zones de texte monoligne. Ils sont utilisés pour saisir des données textuelles courtes, telles qu'un nom ou un mot de passe par exemple.

• Le texte saisi dans un contrôle Text Field est accessible en lecture et en écriture à travers sa propriété text.

• Si vous avez besoin d'une zone de texte multilignes, utilisez des contrôles Text View.

• Le contrôle Image View permet d'afficher une image ou une animation. Les images peuvent être chargées à partir de l'album photo, des ressources de l'application, du Web ou encore de la sandbox.

Le contrôle Web View (figure suivante) est utilisé pour intégrer du contenu Web dans une application.

Pour afficher une page Web, vous appliquerez la méthode loadRequest à ce contrôle. Par exemple, pour afficher le moteur de recherche Google dans un contrôle Web View nommé wv, vous utiliserez l'instruction suivante :

[wv loadRequest:[NSURLRequest requestWithURL: [NSURL URLWithString:@"http://www.google.fr"]]];

La syntaxe est un peu surprenante, je vous l'accorde, mais il « suffit » de dire que :

• la méthode loadRequest s'applique sur un objet de type NSURLRequest ;

• un objet NSURLRequest est obtenu en appliquant la méthode requestWithURL sur un objet de type NSURL ;

• un objet NSURL est obtenu en appliquant la méthode URLWithString sur une chaîne de caractères contenant l'adresse URL désirée.

Ainsi, le message le plus interne ([NSURL URLWithString:@"http://www.google.fr"]) définit un objet de type NSURL et l'initialise avec l'URL de Google :

[NSURL URLWithString:@"http://www.google.fr"]

Cet objet est passé à la méthode requestWithURL qui est appliquée sur un objet NSURLRequest :

[NSURLRequest requestWithURL: objet NSURL];

Enfin, l'objet retourné est passé à la méthode loadRequest qui est appliquée à l'objet Web View wv :

[wv loadRequest: objet NSURLRequest];

Cette instruction se place dans le fichier d'en-têtes de votre application, comme ceci :

- (void)viewDidLoad
{
    [super viewDidLoad];
	[wv loadRequest:[NSURLRequest requestWithURL: [NSURL URLWithString:@"http://www.google.fr"]]];
}

Il ne vous reste alors plus qu'à lancer l'application : vous venez de créer un navigateur Web qui démarre automatiquement sur le moteur de recherche Google !

Le contrôle Map View (figure suivante) permet d'afficher une carte, comme dans l'application Maps.

En utilisant les méthodes de la classe MKMapView, vous pouvez, entre autres, centrer la carte sur une coordonnée spécifique, choisir la taille de la zone à afficher ou encore ajouter des informations personnalisées sur la carte.

Dans cette section, je vais vous montrer comment afficher la carte centrée sur Paris. Le but du jeu est d'afficher quelque chose ressemblant à la figure suivante sur votre device.

Définissez un nouveau projet de type Single View Application et donnez-lui le nom « map ». Une fois n'est pas coutume, nous n'allons pas utiliser Interface Builder dans ce projet !

Ajout du framework MapKit à l'application

Pour pouvoir afficher une carte dans la fenêtre de votre application, vous devez ajouter le framework MapKit à l'application. Pour ce faire, rien de plus simple : lisez les instructions suivantes en vous aidant de la figure suivante.

• Sélectionnez la première entrée dans le volet de navigation. Ici, l'entrée map (1).

• Sélectionnez l'onglet Build Phases dans le volet droit (2).

• Développez le dossier Link Binary with Libraries (3).

• Cliquez sur + (4).

• Ajoutez le framework désiré (5).

• Validez en cliquant sur Add (6).

Modification du fichier .h

Cliquez sur ViewController.h dans le volet de navigation et ajoutez une instruction #import pour accéder au framework MapKit :

#import <MapKit/MapKit.h>

Déclarez ensuite un objet de type MKMapView :

MKMapView *mapView;

Si vous avez suivi mes indications, le fichier mapViewController.h devrait maintenant avoir l'allure suivante :

#import <UIKit/UIKit.h>
#import <MapKit/MapKit.h>

@interface ViewController : UIViewController
{
    MKMapView *mapView;
}

@end

Modification du fichier .m

Cliquez sur ViewController.m dans le volet de navigation. Vous allez maintenant initialiser, personnaliser et afficher l'objet mapView. Ce traitement se fera dans la méthode viewDidLoad. Complétez cette méthode comme ceci :

- (void)viewDidLoad
{
  [super viewDidLoad];
 
  // Instancier la carte
  mapView = [[MKMapView alloc] initWithFrame:self.view.bounds];
 
  // Définir le zoom
  MKCoordinateSpan span;
  span.latitudeDelta=0.5;
  span.longitudeDelta=0.5;
 
  // Définir les coordonnées de Paris
  CLLocationCoordinate2D parisCoordinates;
  parisCoordinates.latitude=48.858391;
  parisCoordinates.longitude=2.35279;
 
  MKCoordinateRegion parisRegion;
  parisRegion.span=span;
  parisRegion.center=parisCoordinates;
 
  // Centrer la carte sur Paris
  [mapView setRegion:parisRegion animated:TRUE];
 
  // Ajouter la carte à la vue
  [self.view insertSubview:mapView atIndex:0];
}

Cela fait beaucoup d'instructions n'est-ce pas ?
Examinons-les calmement et vous verrez qu'il n'y a rien d'insurmontable…

L'instruction de la ligne 6 réserve l'espace nécessaire en mémoire pour loger l'objet MKMapView mapView. Il n'y a rien de sorcier là-dedans : c'est juste la syntaxe (un peu lourde je vous l'accorde !) à utiliser :

mapView = [[MKMapView alloc] initWithFrame:self.view.bounds];

Le premier message réserve la mémoire pour un objet MKMapView ([MKMapView alloc]). Le deuxième message utilise la méthode initWithFrame pour définir les dimensions du rectangle dans lequel sera affichée la vue. Ici, self.view.bounds signifie la taille de la vue courante.

Le bloc d'instructions suivant définit la structure span de type MKCoordinateSpan :

MKCoordinateSpan span;

Par son intermédiaire, on définit le nombre de degrés en latitude (c'est-à-dire du nord au sud) et en longitude (c'est-à-dire de l'ouest à l'est) de la zone d'affichage :

span.latitudeDelta=0.5;
span.longitudeDelta=0.5;

À titre d'information :

• 1 degré de latitude correspond environ à 111 kilomètres.

• 1 degré de longitude correspond environ à 111 kilomètres à l'équateur et à 0 kilomètre aux pôles.

Le bloc d'instructions suivant définit les coordonnées de la ville de Paris. Pour cela, la structure parisCoordinates, de type CLLocationCoordinate2D est instanciée :

CLLocationCoordinate2D parisCoordinates;

Puis les coordonnées de la ville de Paris y sont stockées :

parisCoordinates.latitude=48.833;
parisCoordinates.longitude=2.333;

Le bloc d'instructions suivant définit le centre de l'affichage et le niveau de détail. Pour cela, la structure parisRegion de type MKCoordinateRegion est instanciée :

MKCoordinateRegion parisRegion;

Puis le niveau de détail est précisé en faisant référence à la structure map définie précédemment :

parisRegion.span=span;

Le centre de l'affichage est défini en faisant référence à la structure parisCoordinates définie précédemment :

parisRegion.center=parisCoordinates;

Il ne reste plus qu'à envoyer un message à l'objet mapView pour lui demander d'afficher la région définie dans la structure parisRegion définie précédemment. Ici, le paramètre animated étant initialisé à TRUE, l'affichage se fera avec une animation :

[mapView setRegion:parisRegion animated:TRUE];

Pour terminer, la vue mapView est ajoutée à l'application, ce qui provoque son affichage :

[self.view insertSubview:mapView atIndex:0];

Et comme vous avez été sages, je vous donne les codes de l'application. :-)

ViewController.h

#import <UIKit/UIKit.h>
#import <MapKit/MapKit.h>

@interface ViewController : UIViewController
{
    MKMapView *mapView;
}

@end

ViewController.m

#import "ViewController.h"

@implementation ViewController

- (void)didReceiveMemoryWarning
{
  [super didReceiveMemoryWarning];
  // Release any cached data, images, etc that aren't in use.
}

#pragma mark - View lifecycle

- (void)viewDidLoad
{
  [super viewDidLoad];
  // instancier la carte
  mapView = [[MKMapView alloc] initWithFrame:self.view.bounds];
  
  //définir le zoom
  MKCoordinateSpan span;
  span.latitudeDelta=0.5;
  span.longitudeDelta=0.5;
  
  //définir les coordonnées de Paris
  CLLocationCoordinate2D parisCoordinates;
  parisCoordinates.latitude=48.858391;
  parisCoordinates.longitude=2.35279;
  
  MKCoordinateRegion parisRegion;
  parisRegion.span=span;
  parisRegion.center=parisCoordinates;
  
  // centrer la carte sur Paris
  [mapView setRegion:parisRegion animated:TRUE];
  
  // ajouter la carte à la vue
  [self.view insertSubview:mapView atIndex:0];
}

- (void)viewDidUnload
{
  [super viewDidUnload];
  // Release any retained subviews of the main view.
  // e.g. self.myOutlet = nil;
}

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

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

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

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

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
{
  // Return YES for supported orientations
  return (interfaceOrientation != UIInterfaceOrientationPortraitUpsideDown);
}

@end

Vous utiliserez un contrôle Scroll View (figure suivante) pour afficher un contenu qui est plus grand que la fenêtre de l'application. Les utilisateurs pourront alors faire glisser la fenêtre de visualisation sur le contenu, mais aussi zoomer vers l'avant et vers l'arrière en pinçant/étirant l'écran avec deux doigts.

Pour illustrer le fonctionnement de ce contrôle, nous allons y insérer un contrôle Image View de taille supérieure à celle du Scroll View. L'utilisateur pourra alors se déplacer dans l'image en utilisant des gestuelles de glisser.

Définissez un projet de type Single View Application et donnez-lui le nom « usv ».
Dans le volet de navigation, cliquez sur MainStoryboard.storyboard, puis ajoutez un contrôle Scroll View au canevas de l'application.

Cliquez sur l'icône Show the Assistant editor dans la barre d'outils de Xcode, contrôle-glissez-déposez le contrôle Scroll View du canevas sur le fichier d'en-têtes, juste au-dessus de l'instruction @end et définissez l'outlet scrollView.

Le fichier d'en-têtes doit maintenant avoir l'allure suivante :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController
@property (weak, nonatomic) IBOutlet UIScrollView *scrollView;

@end

Comme à la figure suivante, vous allez maintenant superposer une image au contrôle Scroll View :

• déposez un contrôle Image View sur le contrôle Scroll View (1) ;

• choisissez une image de grande taille et insérez-la dans les ressources de l'application (2) ;

• affectez-la au contrôle Image View en agissant sur sa propriété Image (3) ;

• visualisez la partie supérieure gauche de l'image en choisissant Top Left dans la liste déroulante Mode (4).

Sélectionnez le fichier ViewController.m dans le volet de navigation et complétez la méthode viewDidLoad comme suit :

- (void)viewDidLoad
{
  [super viewDidLoad];
  [scrollView setScrollEnabled:YES];
  [scrollView setContentSize:CGSizeMake(819,1024)];
}

Le premier message destiné à l'objet scrollView autorise les scrollings :

[scrollView setScrollEnabled:YES];

Le deuxième définit la taille du scrolling. Ici, elle a été arbitrairement fixée à 819x1024 pixels :

[scrollView setContentSize:CGSizeMake(819,1024)];

Pour que la zone d'affichage du contrôle Scroll View s'adapte exactement à celle de l'image, vous pouvez utiliser l'instruction suivante :

[scrollView setContentSize:CGSizeMake(imageView.image.size.width, imageView.image.size.height)];

Voici le code complet, que vous pouvez télécharger grâce à un code web.

ViewController.h

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController
@property (weak, nonatomic) IBOutlet UIScrollView *scrollView;
@property (weak, nonatomic) IBOutlet UIImageView *imageView;

@end

ViewController.m

#import "ViewController.h"

@implementation ViewController
@synthesize scrollView;
@synthesize imageView;

- (void)didReceiveMemoryWarning
{
  [super didReceiveMemoryWarning];
  // Release any cached data, images, etc that aren't in use.
}

#pragma mark - View lifecycle

- (void)viewDidLoad
{
  [super viewDidLoad];
  [scrollView setScrollEnabled:YES];
  //[scrollView setContentSize:CGSizeMake(819,1024)];
  [scrollView setContentSize:CGSizeMake(imageView.image.size.width, imageView.image.size.height)];
}

- (void)viewDidUnload
{
  [self setScrollView:nil];
  [self setImageView:nil];
  [super viewDidUnload];
  // Release any retained subviews of the main view.
  // e.g. self.myOutlet = nil;
}

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

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

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

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

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
{
  // Return YES for supported orientations
  return (interfaceOrientation != UIInterfaceOrientationPortraitUpsideDown);
}

@end

Il est parfois utile d'afficher une boîte de dialogue modale (c'est-à-dire qui se superpose à la fenêtre de l'application et qui y interdit toute action) pour demander à l'utilisateur de prendre une décision. Par exemple, pour confirmer l'arrêt de l'application ou l'écrasement d'un fichier. Deux classes peuvent être utilisées à cet effet : UIAlertView et UIActionSheet.

Une boîte de dialogue modale avec un contrôle UIAlertView

Définissez un projet basé sur le modèle Single View Application et donnez-lui le nom « alerte ».
Dans le volet de navigation, cliquez sur MainStoryboard.storyboard et ajoutez un contrôle Label à la vue. Double-cliquez dans le Label et tapez « Cliquez sur un bouton ».
Définissez un outlet pour le Label et donnez-lui le nom status.

Vous allez maintenant ajouter quelques lignes de code dans la méthode viewDidLoad pour provoquer l'affichage de la boîte de dialogue modale.
Cliquez sur ViewController.m dans le volet de navigation et complétez la méthode viewDidLoad comme suit :

- (void)viewDidLoad
{
  [super viewDidLoad];
  UIAlertView *alert = [[UIAlertView alloc]
  initWithTitle:@"Voulez-vous arrêter ?" 
  message:@"Confirmez que vous voulez quitter l'application" delegate:self 
  cancelButtonTitle:@"Annuler" otherButtonTitles:nil];
  [alert addButtonWithTitle:@"Confirmer"];
  [alert show];
}

Les lignes 4 à 7 définissent l'objet alert de type UIAlertView.

Cet objet est initialisé avec :

• un titre : initWithTitle:@"Voulez-vous arrêter ?" ;

• un message : message:@"Confirmez que vous voulez quitter l'application" ;

• un bouton Annuler : cancelButtonTitle:@"Annuler".

Les événements qui lui sont liés sont traités dans la classe alertViewController elle-même (delegate:self).

L'instruction suivante ajoute le bouton Confirmer à la boîte de dialogue :

[alert addButtonWithTitle:@"Confirmer"];

Enfin, la dernière instruction affiche la boîte de dialogue :

[alert show];

Vous pouvez lancer l'application et voir qu'elle fonctionne à la perfection (figure suivante), si ce n'est que les boutons ne produisent aucun effet.

Nous allons régler ce problème en définissant une méthode action. Ajoutez le code suivant au fichier alertViewController.m :

- (void)alertView:(UIAlertView *)alertView didDismissWithButtonIndex:(NSInteger)buttonIndex {
    if (buttonIndex == 0)
        status.text = @"Vous avez cliqué sur Annuler";
    else
        status.text = @"Vous avez cliqué sur Confirmer";
}

La méthode alertView:didDismissWithButtonIndex est exécutée lorsque l'utilisateur clique sur un des boutons de la boîte de dialogue modale. L'entier buttonIndex représente l'index du bouton cliqué. Il vaut :

• 0 si le bouton Annuler a été cliqué ;

• 1 si le bouton Confirmer a été cliqué.

En fonction du bouton cliqué, un message ou un autre est affiché dans le contrôle Label.

Voici le code de l'application.

ViewController.h

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController
@property (weak, nonatomic) IBOutlet UILabel *status;

@end

ViewController.m

#import "ViewController.h"

@implementation ViewController
@synthesize status;

- (void)didReceiveMemoryWarning
{
  [super didReceiveMemoryWarning];
  // Release any cached data, images, etc that aren't in use.
}

#pragma mark - View lifecycle

- (void)viewDidLoad
{
  [super viewDidLoad];
  UIAlertView *alert = [[UIAlertView alloc]
  initWithTitle:@"Voulez-vous arrêter ?" 
  message:@"Confirmez que vous voulez quitter l'application" delegate:self 
  cancelButtonTitle:@"Annuler" otherButtonTitles:nil];
  [alert addButtonWithTitle:@"Confirmer"];
  [alert show];
}

- (void)alertView:(UIAlertView *)alertView didDismissWithButtonIndex:(NSInteger)buttonIndex {
  if (buttonIndex == 0)
    status.text = @"Vous avez cliqué sur Annuler";
  else
    status.text = @"Vous avez cliqué sur Confirmer";
}

- (void)viewDidUnload
{
  [self setStatus:nil];
  [super viewDidUnload];
  // Release any retained subviews of the main view.
  // e.g. self.myOutlet = nil;
}

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

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

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

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

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
{
  // Return YES for supported orientations
  return (interfaceOrientation != UIInterfaceOrientationPortraitUpsideDown);
}

@end

Une boîte de dialogue modale avec un contrôle UIActionSheet

Une variante du contrôle UIAlertView consiste à utiliser le contrôle UIActionSheet. Ce dernier affiche une vue modale qui se superpose à la vue actuelle dans la partie inférieure de la fenêtre.

Définissez un projet basé sur le modèle Single View Application et donnez-lui le nom « actionSheet ».
Dans le volet de navigation, cliquez sur MainStoryboard.storyboard et ajoutez un contrôle Label à la vue. Double-cliquez sur le Label et tapez « Appuyez sur un bouton ».
Enfin, définissez un outlet pour ce Label et donnez-lui le nom status.

Vous allez maintenant ajouter quelques lignes de code dans la méthode viewDidLoad pour provoquer l'affichage de la vue modale.
Cliquez sur ViewController.m dans le volet de navigation, et complétez la méthode viewDidLoad comme suit :

- (void)viewDidLoad
{
  [super viewDidLoad];
  UIActionSheet *actionSheet = [[UIActionSheet alloc] initWithTitle:@"Voulez-vous arrêter l'application ?"
  delegate:self cancelButtonTitle:nil destructiveButtonTitle:nil
  otherButtonTitles:@"Oui", @"Non",@"Je ne sais pas", nil];
  actionSheet.actionSheetStyle = UIActionSheetStyleBlackOpaque;
  actionSheet.destructiveButtonIndex = 1;
  [actionSheet showInView:self.view];
}

La première instruction définit l'objet actionSheet de type UIActionSheet.

Cet objet est initialisé avec :

• un titre : initWithTitle:@"Voulez-vous arrêter l'application ?" ;

• trois boutons : otherButtonTitles:@"Oui", @"Non",@"Je ne sais pas", nil).

Le traitement du contrôle se fait dans la classe actionSheetViewController elle-même : delegate:self.

L'instruction suivante définit le style du contrôle :

actionSheet.actionSheetStyle = UIActionSheetStyleBlackOpaque;

Les valeurs possibles pour la propriété actionSheetStyle sont les suivantes (N'hésitez pas à les tester !) :

• UIActionSheetStyleAutomatic ;

• UIActionSheetStyleDefault ;

• UIActionSheetStyleBlackTranslucent ;

• UIActionSheetStyleBlackOpaque.

L'instruction suivante indique que le bouton d'index 1 (le deuxième en d'autres termes) doit être différencié des autres, car il présente un caractère particulier. Ce bouton apparaît en rouge.

actionSheet.destructiveButtonIndex = 1;

L'instruction suivante ajoute la vue modale dans la vue courante :

[actionSheet showInView:self.view];

Lancez l'application dans le simulateur. Vous devriez obtenir quelque chose ressemblant à la figure suivante.

Observez d'un peu plus près le message d'erreur. Xcode nous indique que la classe ViewController n'implémente pas le protocole UIActionSheetDelegate et ne peut donc pas répondre aux événements générés par l'objet actionSheet. Qu'à cela ne tienne : cliquez sur ViewController.h dans le volet de navigation et ajoutez le protocole demandé dans la déclaration de l'interface :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController <UIActionSheetDelegate>
@property (weak, nonatomic) IBOutlet UILabel *status;

@end

Le problème a disparu, comme par magie.

Maintenant, il ne reste plus qu'à définir le code qui réagit aux clics sur les boutons de la boîte de dialogue modale. Cliquez sur ViewController.m dans le volet de navigation et ajoutez la méthode actionSheet:clickedButtonAtIndex dans le code :

- (void)actionSheet:(UIActionSheet *)actionSheet clickedButtonAtIndex:(NSInteger)buttonIndex
{
  if (buttonIndex == 0)
    status.text = @"Vous avez cliqué sur Oui";
  if (buttonIndex == 1)
    status.text = @"Vous avez cliqué sur Non";
  if (buttonIndex == 2)
    status.text = @"Vous avez cliqué sur Je ne sais pas";
}

Cette méthode est appelée lorsqu'un bouton de la boîte de dialogue modale est pressé. Le NSInteger buttonIndex représente l'index du bouton pressé par l'utilisateur (0 si le premier bouton est pressé, 1 si le deuxième bouton est pressé, etc.).

La méthode clickedButtonAtIndex se contente d'afficher un texte en rapport avec le bouton cliqué dans le contrôle Label.

Vous trouverez à la suite le code de l'application.

ViewController.h

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController <UIActionSheetDelegate>
@property (weak, nonatomic) IBOutlet UILabel *status;

@end

ViewController.m

#import "ViewController.h"

@implementation ViewController
@synthesize status;

- (void)didReceiveMemoryWarning
{
  [super didReceiveMemoryWarning];
  // Release any cached data, images, etc that aren't in use.
}

#pragma mark - View lifecycle

- (void)viewDidLoad
{
  [super viewDidLoad];
  UIActionSheet *actionSheet = [[UIActionSheet alloc] 
  initWithTitle:@"Voulez-vous arrêter l'application ?"
  delegate:self cancelButtonTitle:nil destructiveButtonTitle:nil
  otherButtonTitles:@"Oui", @"Non",@"Je ne sais pas", nil];
  actionSheet.actionSheetStyle = UIActionSheetStyleBlackOpaque;
  actionSheet.destructiveButtonIndex = 1;
  [actionSheet showInView:self.view];
}

- (void)actionSheet:(UIActionSheet *)actionSheet clickedButtonAtIndex:(NSInteger)buttonIndex
{
  if (buttonIndex == 0)
    status.text = @"Vous avez cliqué sur Oui";
  if (buttonIndex == 1)
    status.text = @"Vous avez cliqué sur Non";
  if (buttonIndex == 2)
    status.text = @"Vous avez cliqué sur Je ne sais pas";
}

- (void)viewDidUnload
{
  [self setStatus:nil];
  [super viewDidUnload];
  // Release any retained subviews of the main view.
  // e.g. self.myOutlet = nil;
}

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

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

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

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

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
{
  // Return YES for supported orientations
  return (interfaceOrientation != UIInterfaceOrientationPortraitUpsideDown);
}

@end

En résumé

• Le contrôle Map View permet d'afficher une carte, comme dans l'application Maps d'Apple. En utilisant les méthodes de la classe MKMapView, vous pouvez, entre autres, centrer la carte sur une coordonnée spécifique, choisir la taille de la zone à afficher ou encore ajouter des informations personnalisées sur la carte.

• Vous utiliserez un contrôle Scroll View pour afficher un contenu qui est plus grand que la fenêtre de l'application. Les utilisateurs pourront alors faire glisser la fenêtre de visualisation sur le contenu, mais aussi zoomer vers l'avant et vers l'arrière en pinçant/étirant l'écran avec deux doigts.

• Il est parfois utile d'afficher une boîte de dialogue modale (c'est-à-dire qui se superpose à la fenêtre de l'application et qui y interdit toute action) pour demander à l'utilisateur de prendre une décision. Par exemple, pour confirmer l'arrêt de l'application ou l'écrasement d'un fichier. Deux classes peuvent être utilisées à cet effet : UIAlertView et UIActionSheet.

Les contrôles Table View sont utilisés pour afficher des listes d'informations sur une colonne. Plusieurs applications fournies avec votre device utilisent un contrôle Table View (figure suivante).

Les contrôles Table View peuvent être composés de zéro (même si cela n'offre pas beaucoup d'intérêt), une ou plusieurs sections. Chaque section peut :

• comporter zéro, une ou plusieurs lignes ;

• être précédée d'un en-tête de section ;

• être suivie d'un pied de section.

Les sections sont identifiées par leur numéro d'index dans le tableau : première section, deuxième section, etc. Les lignes sont identifiées par leur numéro d'index dans une section : première ligne de la première section, deuxième ligne de la première section, etc.

L'utilisateur peut se déplacer verticalement dans un contrôle Table View en utilisant une gestuelle de glisser. Lorsqu'il clique sur un des éléments listés, une vue détaillée de cet élément est affichée. La communication entre le contrôle Table View et les différentes vues détaillées se fait via un contrôle Table View Controller.

Première approche

Pour faciliter l'écriture d'une application basée sur l'utilisation d'un Table View et des vues détaillées correspondantes, le plus simple consiste à utiliser le modèle Master-Detail Application.

Créez un nouveau projet basé sur le modèle Master-Detail Application, cliquez sur Next, donnez le nom « tableView » à l'application, choisissez le dossier de sauvegarde et validez en cliquant sur Create. Une fois l'application créée, cliquez sur MainStoryboard.storyboard dans le volet de navigation. Comme vous pouvez le voir à la figure suivante, un contrôleur de navigation, un contrôle Table View et une vue détaillée ont été insérés dans l'application.

Exécutez l'application en cliquant sur Run. Le contrôle Table View est bien visible, mais il ne contient aucune donnée. Nous allons remédier à cette situation en définissant quelques données textuelles et en les reliant au contrôle Table View.

La source de données peut provenir d'à peu près n'importe où : d'un tableau, d'un fichier XML ou d'une base de données par exemple. Pour que les choses soient aussi simples que possible, nous allons utiliser un tableau comme source de données. Cliquez sur MasterViewController.h dans le volet de navigation et définissez l'objet NSMutableArray *maListe :

#import <UIKit/UIKit.h>

@interface MasterViewController : UITableViewController
{
    NSMutableArray *maListe;
}

@end

Maintenant, cliquez sur MasterViewController.m dans le volet de navigation. Pour que le tableau soit rempli dès le démarrage de l'application, nous allons ajouter quelques instructions dans la méthode viewDidLoad :

- (void)viewDidLoad
{
  [super viewDidLoad];
  maListe = [NSMutableArray array];
  [maListe addObject:@"Paris"];
  [maListe addObject:@"Lyon"];
  [maListe addObject:@"Marseille"];
  [maListe addObject:@"Toulouse"];
  [maListe addObject:@"Nantes"];
  [maListe addObject:@"Nice"];
  [maListe addObject:@"Bordeaux"];
  [maListe addObject:@"Montpellier"];
  [maListe addObject:@"Rennes"];
  [maListe addObject:@"Lille"];
  [maListe addObject:@"Le Havre"];
  [maListe addObject:@"Reims"];
  [maListe addObject:@"Le Mans"];
  [maListe addObject:@"Dijon"];
  [maListe addObject:@"Grenoble"];
  [maListe addObject:@"Brest"];
  self.navigationItem.title = @"Grandes villes";
}

L'instruction de la ligne 4 initialise l'objet maListe :

maListe = [NSMutableArray array];

Les instructions suivantes ajoutent des éléments dans maListe en appliquant la méthode addObject à l'objet maListe. Par exemple :

[maListe addObject:@"Paris"];

Enfin, la ligne 21 définit le titre qui sera affiché sur la première ligne du contrôle Table View :

self.navigationItem.title = @"Grandes villes";

Je sens que vous brûlez d'impatience de voir ces données affichées dans le Table View. Allez, cliquez sur Run.

…

Oh consternation ! Le contrôle Table View est toujours vide !
Réfléchissez un peu. Tout ce qui a été fait jusqu'ici, c'est de créer un objet NSMutableArray. Comment le contrôle Table View pourrait-il supposer qu'il doit l'utiliser comme source de données ?

Pour cela, deux actions doivent être accomplies. Vous devez :

1. indiquer au contrôle Table View combien de données il doit afficher ;

2. relier les objets Table View et maListe.

Pour connaître le nombre d'éléments du tableau maListe, vous utiliserez l'instruction suivante :

[maListe count];

La méthode prédéfinie numberOfRowsInSection retourne un entier qui correspond au nombre d'éléments à afficher dans le Table View. Par défaut, la valeur retournée est égale à 0 : aucune information n'est donc affichée. En remplaçant le 0 à la suite de l'instruction return par le message [maListe count], le contrôle Table View sait combien d'éléments il doit afficher. Définissez la méthode suivante dans le fichier MasterViewController.m :

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
  return [maListe count];
}

Il ne reste plus qu'à relier le Table View au contrôle maListe. Cette étape se fera grâce à la méthode cellForRowAtIndexPath. Consultez la documentation Apple pour avoir une idée du contenu de cette méthode (figure suivante).

Les premières lignes (1) définissent un objet cell de classe UITableViewCell et le relient à une cellule du Table View. Nous les reprendrons telles quelles.

Les dernières lignes (2) sont propres à l'exemple pris par Apple, nous allons donc les modifier. Dans le cas qui nous préoccupe, les cellules (cell.textLabel.text) doivent être reliées aux éléments du Table View ([maListe objectAtIndex: …]) dont l'index correspond au numéro de ligne du Table View (indexPath.row). Voici le code complet de la méthode cellForRowAtIndexPath :

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
  static NSString *MyIdentifier = @"MyIdentifier";
    
  UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:MyIdentifier];
    
  if (cell == nil)
    cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:MyIdentifier];

  // Configuration de la cellule
  NSString *cellValue = [maListe objectAtIndex:indexPath.row];
  cell.textLabel.text = cellValue;
  return cell;
}

Les lignes 1 à 8 ainsi que la ligne 13 sont issues de l'aide Apple.
La ligne 11 définit l'objet cellValue de classe NSString (NSString *cellValue) et y stocke l'élément du tableau maListe ([maListe …) qui se trouve à la ligne (objectAtIndex) courante (indexPath.row]).

NSString *cellValue = [maListe objectAtIndex:indexPath.row];

La ligne 12 affecte la valeur obtenue à la ligne précédente à la cellule :

cell.textLabel.text = cellValue;

Avant de cliquer sur Run, vous devez encore dire à Xcode que les données à afficher dans le Table View seront définies dans l'application. Comme à la figure suivante, cliquez sur MainStoryboard.storyboard dans le volet de navigation (1), cliquez sur Table View dans la zone d'édition (2), sur l'icône Hide or show the Utilities (3) puis sur l'icône Show the Attributes inspector (4). Choisissez enfin Dynamic Prototypes dans la liste déroulante Content (5).

Maintenant, vous pouvez cliquer sur Run. La fenêtre du simulateur iOS devrait afficher quelque chose ressemblant à la figure suivante.

Une dernière petite chose. Avez-vous remarqué le point d'exclamation dans la partie supérieure de la fenêtre de Xcode ? Si vous cliquez dessus, un message d'erreur vous indique ce qui ne va pas. Ce dernier indique « Prototype table cells must have reuse identifiers », soit en bon français « Le prototype des cellules du tableau doit avoir un identifiant ».

Comme indiqué à la figure suivante, cliquez sur le prototype des cellules dans la vue Master (1), sur l'icône Show the Attributes inspector dans le volet des utilitaires (2), puis définissez un identifiant dans la zone de texte Identifier (3).

Utilisation de la vue détaillée

Les contrôles Table View sont généralement utilisés avec une vue secondaire qui donne des détails sur l'élément sélectionné par l'utilisateur dans la liste. Nous allons voir comment utiliser cette vue dans l'application précédente. Rappelez-vous : lors de la création de l'application tableView, une vue détaillée a été ajoutée au canevas (figure suivante). Reste donc à voir comment l'utiliser.

Effectivement, ces deux vues étaient reliées, mais lorsque vous avez sélectionné Dynamic Prototypes dans la propriété Content de la vue Master, le lien a été brisé.
Qu'à cela ne tienne, nous allons le recréer !

Si ce n'est pas déjà fait, affichez le canevas en cliquant sur MainStoryboard.storyboard dans le volet de navigation. Ensuite, comme indiqué à la figure suivante, cliquez sur l'élément qui représente une cellule dans la vue Master (1) puis contrôle-glissez-déposez cet élément sur la vue Detail (2). Au relâchement du bouton gauche de la souris, sélectionnez Push dans le menu (3).

La liaison entre les vues Master et Detail est maintenant rétablie (figure suivante).

Pour pouvoir y faire référence dans le code, vous allez lui donner un nom. Comme indiqué sur la figure suivante, cliquez sur le symbole qui identifie la liaison dans le canevas (1), sur l'icône Hide or show the Utilities dans la barre d'outils (2), sur Show the Attributes inspector dans le volet des utilitaires (3) puis donnez le nom « detailSegue » à la liaison (4).

Vous allez maintenant insérer un contrôle Label dans la vue Detail. Ce contrôle sera utilisé pour afficher des informations en relation avec l'élément sélectionné par l'utilisateur dans la vue Master.

Une fois le contrôle Label inséré dans la vue Detail, associez-lui l'outlet donneeRecue pour qu'il soit accessible dans le code.

Je pense que cette opération doit maintenant être habituelle pour vous, mais à tout hasard, je vais faire un rappel. Pour définir l'outlet unMessage pour le contrôle Label :

1. dans la barre d'outils de Xcode, au-dessus du libellé Editor, cliquez sur l'icône Show the Assistant editor ;

2. contrôle-glissez-déposez le contrôle Label dans le fichier d'en-têtes, juste au-dessus du @end final ;

3. au relâchement du bouton gauche de la souris, donnez le nom « donneeRecue » à l'outlet et validez en cliquant sur Connect.

Le code du fichier d'en-têtes doit maintenant ressembler à ceci :

#import <UIKit/UIKit.h>

@interface DetailViewController : UIViewController

@property (strong, nonatomic) id detailItem;
@property (strong, nonatomic) IBOutlet UILabel *detailDescriptionLabel;
@property (weak, nonatomic) IBOutlet UILabel *donneeRecue;

@end

Lorsque l'utilisateur sélectionne un élément dans le contrôle Table View, la vue Detail remplace la vue Master. Pour passer des informations de la vue Master à la vue Detail, Apple préconise d'utiliser la méthode prepareForSegue. Malheureusement, il n'est pas possible d'atteindre directement le label donneeRecue, vous devez passer par une variable intermédiaire. Cliquez sur DetailViewController.h dans le volet de navigation et définissez la propriété texteAAfficher comme suit :

@property (strong, nonatomic) id texteAAfficher;

Le fichier DetailViewController.h doit maintenant contenir les instructions suivantes :

#import <UIKit/UIKit.h>

@interface DetailViewController : UIViewController

@property (strong, nonatomic) id texteAAfficher;
@property (strong, nonatomic) id detailItem;
@property (strong, nonatomic) IBOutlet UILabel *detailDescriptionLabel;
@property (weak, nonatomic) IBOutlet UILabel *donneeRecue;
@end

Cliquez sur DetailViewController.m dans le volet de navigation et ajoutez une instruction synthesize pour pouvoir accéder à la propriété texteAAfficher :

@synthesize texteAAfficher = _texteAAfficher;

Ça y est, tout est en place pour insérer la méthode prepareForSegue. Cliquez sur MasterViewController.m dans le volet de navigation et insérez les instructions suivantes dans le code (peu importe l'endroit) :

-(void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender{
  if([[segue identifier] isEqualToString:@"detailSegue"])
  {
    NSInteger selectedIndex = [[self.tableView indexPathForSelectedRow] row];
    DetailViewController *dvc = [segue destinationViewController];
    dvc.texteAAfficher = [NSString stringWithFormat:@"%@", [maListe objectAtIndex:selectedIndex]];
  }
}

Ne soyez pas impressionnés par l'apparente complexité du code : l'autocomplétion est votre amie. Ainsi par exemple, lorsque vous commencez à écrire les premières lettres de la méthode prepareForSegue, une bulle s'affiche sur l'écran, comme à la figure suivante. Appuyez simplement sur la touche Entrée pour recopier le texte proposé par l'autocomplétion.

La ligne 2 teste si l'identifiant de la transition entre la vue Master et la vue Detail a bien pour nom « detailSegue » :

if([[segue identifier] isEqualToString:@"detailSegue"])

La ligne 4 définit le NSInteger selectedIndex et l'initialise avec l'index de la cellule choisie par l'utilisateur (indexPathForSelectedRow) du contrôle TableView de la vue Master (self.tableView) :

NSInteger selectedIndex = [[self.tableView indexPathForSelectedRow] row];

selectedIndex vaudra 0 si l'utilisateur a choisi le premier élément. Il vaudra 1 s'il a choisi le deuxième élément. Ainsi de suite…

Maintenant, nous connaissons l'index de la cellule choisie par l'utilisateur. Encore faut-il accéder au Label de la vue Detail.
Pour cela, la ligne 5 définit l'objet dvc de classe DetailViewController (DetailViewController *dvc) et l'initialise avec la vue qui va être affichée ([segue destinationViewController]) :

DetailViewController *dvc = [segue destinationViewController];

Il ne reste plus qu'à affecter le contenu de la cellule à la propriété texteAAfficher. C'est précisément ce que fait la ligne 6. La propriété texteAAfficher est initialisée avec l'élément du tableau maListe d'index selectedIndex. Cet objet est converti en un NSString avant d'être stocké dans la propriété texteAAfficher :

dvc.texteAAfficher = [NSString stringWithFormat:@"%@", [maListe objectAtIndex:selectedIndex]];

Vous devez ajouter une instruction import au début du fichier MasterViewController.m, sans quoi Master n'arrivera pas à « dialoguer » avec Detail et plusieurs erreurs apparaîtront dans le code :

#import "DetailViewController.h"

Après tous ces efforts, vous devez certainement être impatients de lancer l'application. Vous pouvez toujours le faire, mais je suis assez pessimiste quant au résultat obtenu : il est vrai que la vue Master a indiqué à la vue Detail quelle était la cellule sélectionnée par l'utilisateur. Mais rappelez-vous, cette indication a été fournie dans la propriété texteAAfficher et non dans le Label donneeRecue. Vous allez donc devoir agir sur le code de la vue Detail. Cliquez sur DetailViewController.m et ajoutez la ligne 6 à la méthode viewDidLoad :

- (void)viewDidLoad
{
  [super viewDidLoad];
  // Do any additional setup after loading the view, typically from a nib.
  [self configureView];
  _donneeRecue.text = _texteAAfficher;
}

Cette ligne recopie simplement le contenu de la propriété texteAAfficher dans le Label.

Ça y est, vous pouvez lancer l'application et profiter du passage de données entre les vues Master et Detail. La figure suivante représente par exemple ce que vous devriez obtenir si vous choisissez « Toulouse » dans la vue Master.

Les fichiers de cette application se trouvent dans le dossier tableView2.

MasterViewController.h

#import <UIKit/UIKit.h>


@interface MasterViewController : UITableViewController
{
    NSMutableArray *maListe;
}
@end

MasterViewController.m

#import "MasterViewController.h"
#import "DetailViewController.h"


@implementation MasterViewController


- (void)awakeFromNib
{
    [super awakeFromNib];
}

- (void)didReceiveMemoryWarning
{
    [super didReceiveMemoryWarning];
    // Release any cached data, images, etc that aren't in use.
}

#pragma mark - View lifecycle

- (void)viewDidLoad
{
    [super viewDidLoad];
	// Do any additional setup after loading the view, typically from a nib.
    maListe = [NSMutableArray array];
    [maListe addObject:@"Paris"];
    [maListe addObject:@"Lyon"];
    [maListe addObject:@"Marseille"];
    [maListe addObject:@"Toulouse"];
    [maListe addObject:@"Nantes"];
    [maListe addObject:@"Nice"];
    [maListe addObject:@"Bordeaux"];
    [maListe addObject:@"Montpellier"];
    [maListe addObject:@"Rennes"];
    [maListe addObject:@"Lille"];
    [maListe addObject:@"Le Havre"];
    [maListe addObject:@"Reims"];
    [maListe addObject:@"Le Mans"];
    [maListe addObject:@"Dijon"];
    [maListe addObject:@"Grenoble"];
    [maListe addObject:@"Brest"];
    self.navigationItem.title = @"Grandes villes";
}

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
    return [maListe count];
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    //même que paramètre Identifier du Prototype Cells dans MainStoryboard.storyboard
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"MyIdentifier"]; 
    
    // Configuration de la cellule
    NSString *cellValue = [maListe objectAtIndex:indexPath.row];
    cell.textLabel.text = cellValue;
    return cell;
}


-(void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender{
    if([[segue identifier] isEqualToString:@"detailSegue"])
    {
        NSInteger selectedIndex = [[self.tableView indexPathForSelectedRow] row];
        DetailViewController *dvc = [segue destinationViewController];
        dvc.texteAAfficher = [NSString stringWithFormat:@"%@", [maListe objectAtIndex:selectedIndex]];
    }
}

- (void)viewDidUnload
{
    [super viewDidUnload];
    // Release any retained subviews of the main view.
    // e.g. self.myOutlet = nil;
}

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

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

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

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

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
{
    // Return YES for supported orientations
    return (interfaceOrientation != UIInterfaceOrientationPortraitUpsideDown);
}

/*
// Override to support conditional editing of the table view.
- (BOOL)tableView:(UITableView *)tableView canEditRowAtIndexPath:(NSIndexPath *)indexPath
{
    // Return NO if you do not want the specified item to be editable.
    return YES;
}
*/

/*
// Override to support editing the table view.
- (void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath
{
    if (editingStyle == UITableViewCellEditingStyleDelete) {
        // Delete the row from the data source.
        [tableView deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath] withRowAnimation:UITableViewRowAnimationFade];
    } else if (editingStyle == UITableViewCellEditingStyleInsert) {
        // Create a new instance of the appropriate class, insert it into the array, and add a new row to the table view.
    }   
}
*/

/*
// Override to support rearranging the table view.
- (void)tableView:(UITableView *)tableView moveRowAtIndexPath:(NSIndexPath *)fromIndexPath toIndexPath:(NSIndexPath *)toIndexPath
{
}
*/

/*
// Override to support conditional rearranging of the table view.
- (BOOL)tableView:(UITableView *)tableView canMoveRowAtIndexPath:(NSIndexPath *)indexPath
{
    // Return NO if you do not want the item to be re-orderable.
    return YES;
}
*/

@end

DetailViewController.h

#import <UIKit/UIKit.h>

@interface DetailViewController : UIViewController

@property (strong, nonatomic) id texteAAfficher;

@property (strong, nonatomic) id detailItem;
@property (strong, nonatomic) IBOutlet UILabel *detailDescriptionLabel;
@property (weak, nonatomic) IBOutlet UILabel *donneeRecue;

@end

DetailViewController.m

#import "DetailViewController.h"

@interface DetailViewController ()
- (void)configureView;
@end

@implementation DetailViewController
@synthesize texteAAfficher = _texteAAfficher;
@synthesize detailItem = _detailItem;
@synthesize detailDescriptionLabel = _detailDescriptionLabel;
@synthesize donneeRecue = _donneeRecue;

#pragma mark - Managing the detail item

- (void)setDetailItem:(id)newDetailItem
{
    if (_detailItem != newDetailItem) {
        _detailItem = newDetailItem;
        
        // Update the view.
        [self configureView];
    }
}

- (void)configureView
{
    // Update the user interface for the detail item.

    if (self.detailItem) {
        self.detailDescriptionLabel.text = [self.detailItem description];
    }
}

- (void)didReceiveMemoryWarning
{
    [super didReceiveMemoryWarning];
    // Release any cached data, images, etc that aren't in use.
}

#pragma mark - View lifecycle

- (void)viewDidLoad
{
    [super viewDidLoad];
	// Do any additional setup after loading the view, typically from a nib.
    [self configureView];
    _donneeRecue.text = _texteAAfficher;

}

- (void)viewDidUnload
{
    [self setDonneeRecue:nil];
    [super viewDidUnload];
    // Release any retained subviews of the main view.
    // e.g. self.myOutlet = nil;
}

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

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

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

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

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
{
    // Return YES for supported orientations
    return (interfaceOrientation != UIInterfaceOrientationPortraitUpsideDown);
}
@end

Les contrôles Table View ont une variante : les Picker View. Outre leur aspect « roulette 3D », ces contrôles peuvent afficher des informations sur une ou plusieurs colonnes, et chaque colonne peut comporter un nombre d'informations différent.

Pour effectuer une sélection, l'utilisateur tourne la ou les roues (figure suivante) jusqu'à ce que la ou les valeurs affichées se trouvent sous la marque de sélection. Les valeurs sélectionnées sont obtenues avec la méthode pickerView:didSelectRow:inComponent.

Ces contrôles relèvent de la classe UIPickerView. Pour illustrer leur fonctionnement, nous allons définir une application dans laquelle l'utilisateur pourra sélectionner une entrée dans un contrôle Picker View. Cette dernière sera alors affichée dans un contrôle Label.

Définissez une nouvelle application basée sur le modèle Single View Application et donnez-lui le nom « picker ». En utilisant Interface Builder, ajoutez un contrôle Picker View et un contrôle Label au fichier MainStoryboard.storyboard. Double-cliquez sur le contrôle Label et tapez « Choisissez une ville ». L'interface de l'application doit maintenant ressembler à la figure suivante.

Reliez les deux contrôles de l'interface au code en les contrôle-glissant-déposant depuis la zone d'édition dans le fichier ViewController.h. Définissez un outlet pour le contrôle Picker View et donnez-lui le nom pv. Définissez un outlet pour le contrôle Label et donnez-lui le nom status. Le fichier ViewController.h doit maintenant ressembler à ceci :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController
@property (weak, nonatomic) IBOutlet UIView *pv;
@property (weak, nonatomic) IBOutlet UILabel *status;

@end

Pour utiliser un contrôle Picker View, il est nécessaire d'implémenter les protocoles UIPickerViewDelegate (traitement des actions de l'utilisateur dans le Picker View) et UIPickerViewDataSource (données utilisées dans le Picker View).

Dans le jargon Objective-C, un protocole consiste en une liste de déclarations de méthodes. Lorsqu'une classe implémente un protocole, cela signifie qu'elle peut appeler les méthodes qui sont définies dans ce protocole.
Supposons par exemple que la classe Voiture, sous-classe de Vehicule, implémente le protocole Moteur. Pour le signifier à Xcode, vous devrez modifier l'instruction @interface.

@interface Voiture : Vehicule {
  ...
}

Comme ceci :

@interface Voiture : Vehicule <Moteur>{
  ...
}

Ici, la classe ViewController, sous-classe de UIViewController, doit implémenter les protocoles UIPickerViewDelegate et UIPickerViewDataSource. La déclaration de l'interface :

@interface ViewController : UIViewController {
  ...
}

doit donc être modifiée comme suit :

@interface ViewController : UIViewController <UIPickerViewDelegate, UIPickerViewDataSource> {
  ...
}

Si ceci n'est pas clair, relisez calmement les quelques phrases qui précèdent. Vous verrez, il n'y a rien de sorcier !

Les données affichées dans le contrôle Picker View vont être stockées dans un tableau que nous appellerons maListe. Vous devez définir ce tableau dans le fichier d'en-têtes, qui devrait maintenant ressembler à ceci :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController <UIPickerViewDelegate, UIPickerViewDataSource>
{
    NSMutableArray *maListe;
}

@property (weak, nonatomic) IBOutlet UIView *pv;
@property (weak, nonatomic) IBOutlet UILabel *status;

@end

L'alimentation et la gestion du contrôle Picker View seront réalisées dans le code de l'application (ViewController.m). Pour l'indiquer à Xcode, il suffit de relier les outlets dataSource et delegate du Picker View au File's Owner (figure suivante).

1. Cliquez sur MainStoryboard.storyboard dans le volet de navigation (1).

2. Cliquez sur le contrôle Picker View dans le volet de navigation (2).

3. Affichez le volet des utilitaires en cliquant sur l'icône Hide or show the Utilities (3).

4. Cliquez sur Show the Connections inspector dans le volet des utilitaires (4).

5. Sous Outlets, reliez le cercle qui se trouve à droite de dataSource à l'icône View Controller (5).

6. Toujours sous Outlets, reliez le cercle qui se trouve à droite de delegate à l'icône View Controller (6).

Il est temps de modifier le fichier .m. Cliquez sur ViewController.m dans le volet de navigation.

Le tableau sera initialisé dans la méthode viewDidLoad :

- (void)viewDidLoad
{
  [super viewDidLoad];
  maListe = [[NSMutableArray alloc] init];
  [maListe addObject:@"Paris"];
  [maListe addObject:@"Lyon"];
  [maListe addObject:@"Marseille"];
  [maListe addObject:@"Toulouse"];
  [maListe addObject:@"Nantes"];
  [maListe addObject:@"Nice"];
  [maListe addObject:@"Bordeaux"];
  [maListe addObject:@"Montpellier"];
  [maListe addObject:@"Rennes"];
  [maListe addObject:@"Lille"];
  [maListe addObject:@"Le Havre"];
  [maListe addObject:@"Reims"];
  [maListe addObject:@"Le Mans"];
  [maListe addObject:@"Dijon"];
  [maListe addObject:@"Grenoble"];
  [maListe addObject:@"Brest"];
}

Il n'y a rien de bien compliqué dans ces instructions. L'objet maListe est instancié :

maListe = [[NSMutableArray alloc] init];

Puis plusieurs valeurs sont mémorisées dans le tableau à l'aide de la méthode addObject :

[maListe addObject:@"Paris"];

Nous allons maintenant mettre en place les méthodes qui vont « alimenter » le contrôle Picker View :

- (NSInteger)numberOfComponentsInPickerView:(UIPickerView *)pickerView {
  return 1;
}
- (NSInteger)pickerView:(UIPickerView *)pickerView numberOfRowsInComponent:(NSInteger)component {
  return [maListe count];
}
- (NSString *)pickerView:(UIPickerView *)pickerView titleForRow:(NSInteger)row forComponent:(NSInteger)component {
  return [maListe objectAtIndex:row];
}

La valeur retournée par la méthode numberOfComponentsInPickerView définit le nombre de colonnes dans le Picker View. Ici, une seule colonne :

return 1;

La valeur retournée par la méthode numberOfRowsInComponent définit le nombre d'éléments affichés dans le Picker View. En ce qui nous concerne, ce nombre est égal au nombre d'éléments stockés dans le tableau maListe :

return [maListe count];

Enfin, la valeur retournée par la méthode titleForRow est affectée à l'élément d'index row. Il suffit de l'extraire du tableau maListevia la méthode objectAtIndex :

return [maListe objectAtIndex:row];

Pour terminer, nous allons définir la méthode qui va mettre à jour le Label lorsqu'un élément du Picker View sera sélectionné :

-(void)pickerView:(UIPickerView *)pickerView didSelectRow:(NSInteger)row
  inComponent:(NSInteger)component{
    status.text = [maListe objectAtIndex:row];
  }

Lorsque l'utilisateur clique sur une entrée, le NSInteger row contient l'index de cette entrée. Pour retrouver la valeur correspondante, il suffit donc de la lire dans le tableau maListe ([maListe objectAtIndex:row]). Cette valeur est alors copiée dans la composante text du Label (status.text =). En d'autres termes, elle est affichée dans le Label.

Le code de cette application se trouve dans le dossier picker.

ViewController.h

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController <UIPickerViewDelegate, UIPickerViewDataSource>
{
  NSMutableArray *maListe;
}

@property (weak, nonatomic) IBOutlet UIView *pv;
@property (weak, nonatomic) IBOutlet UILabel *status;

@end

ViewController.m

#import "ViewController.h"

@implementation ViewController 
@synthesize pv;
@synthesize status;

- (void)didReceiveMemoryWarning
{
  [super didReceiveMemoryWarning];
  // Release any cached data, images, etc that aren't in use.
}

#pragma mark - View lifecycle

- (void)viewDidLoad
{
  [super viewDidLoad];
  maListe = [[NSMutableArray alloc] init];
  [maListe addObject:@"Paris"];
  [maListe addObject:@"Lyon"];
  [maListe addObject:@"Marseille"];
  [maListe addObject:@"Toulouse"];
  [maListe addObject:@"Nantes"];
  [maListe addObject:@"Nice"];
  [maListe addObject:@"Bordeaux"];
  [maListe addObject:@"Montpellier"];
  [maListe addObject:@"Rennes"];
  [maListe addObject:@"Lille"];
  [maListe addObject:@"Le Havre"];
  [maListe addObject:@"Reims"];
  [maListe addObject:@"Le Mans"];
  [maListe addObject:@"Dijon"];
  [maListe addObject:@"Grenoble"];
  [maListe addObject:@"Brest"];
}

- (NSInteger)numberOfComponentsInPickerView:(UIPickerView *)pickerView {
  return 1;
}

- (NSInteger)pickerView:(UIPickerView *)pickerView numberOfRowsInComponent:(NSInteger)component {
  return [maListe count];
}
- (NSString *)pickerView:(UIPickerView *)pickerView titleForRow:(NSInteger)row forComponent:(NSInteger)component {
  return [maListe objectAtIndex:row];
}

-(void)pickerView:(UIPickerView *)pickerView didSelectRow:(NSInteger)row
  inComponent:(NSInteger)component{
    status.text = [maListe objectAtIndex:row];
}

- (void)viewDidUnload
{
  [self setPv:nil];
  [self setStatus:nil];
  [super viewDidUnload];
  // Release any retained subviews of the main view.
  // e.g. self.myOutlet = nil;
}

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

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

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

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

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
{
  // Return YES for supported orientations
  return (interfaceOrientation != UIInterfaceOrientationPortraitUpsideDown);
}

@end

Le contrôle Date Picker est très proche du contrôle Picker View, à ceci près qu'il est spécialisé dans la sélection de dates et d'heures. Sa mise en œuvre est également plus simple que celle d'un Picker View.

À titre d'exemple, nous allons définir une application qui permettra à l'utilisateur de sélectionner une date et une heure dans un contrôle Date Picker. Un clic sur le bouton Sélectionner provoquera l'affichage de la sélection dans un contrôle Label, comme à la figure suivante.

Rien de très original me direz-vous ! Cependant, cette petite application va aborder les points essentiels concernant le contrôle Date Picker. Allez, retroussez vos manches !

Définissez une nouvelle application basée sur le modèle Single View Application et donnez-lui le nom « datePicker ». Sélectionnez le fichier MainStoryboard.storyboard et ajoutez-y un contrôle Date Picker, un contrôle Round Rect Button et un contrôle Label en utilisant Interface Builder. Double-cliquez sur le bouton et tapez « Sélectionner ». Double-cliquez sur le Label et tapez « Choisissez une date » puis appuyez sur Sélectionner. Enfin, positionnez ces trois contrôles pour obtenir quelque chose s'approchant de la figure suivante.

Cliquez sur l'icône Show the Assistant editor dans la barre d'outils de Xcode et définissez les outlets et actions suivants :

Le fichier ViewController.h doit maintenant ressembler à ceci :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController

@property (weak, nonatomic) IBOutlet UIDatePicker *dp;
@property (weak, nonatomic) IBOutlet UILabel *status;
- (IBAction)selectionner:(id)sender;
@end

Rien de bien méchant là-dedans. Maintenant, vous devez être habitués à définir des interfaces avec Interface Builder et à référencer les contrôles dans le code en les contrôle-glissant-déposant depuis la zone d'édition sur le fichier d'en-têtes.

Si vous le souhaitez, vous pouvez dès à présent lancer l'application en cliquant sur Run. Le contrôle Date Picker est opérationnel, même si aucune instruction n'a encore été écrite dans le fichier .m.

Pour terminer l'application, nous allons donner vie au bouton en écrivant quelques lignes de code. Cliquez sur datePickerViewController.m dans le volet de navigation et complétez la méthode selectionner comme suit :

- (IBAction)selectionner:(id)sender {
  NSLocale *frLocale = [[NSLocale alloc] initWithLocaleIdentifier:@"fr_FR"];
  NSDate *pickerDate = [dp date];
  NSString *select = [[NSString alloc] initWithFormat:@"%@", [pickerDate descriptionWithLocale:frLocale]];
  status.text = select;
}

Examinons ces instructions.
Dans un premier temps, l'objet frLocale de type NSLocale est défini (NSLocale *frLocale = [[[NSLocale alloc] …) puis initialisé avec les paramètres régionaux fr_FR (initWithLocaleIdentifier:@"fr_FR") :

NSLocale *frLocale = [[NSLocale alloc] initWithLocaleIdentifier:@"fr_FR"];

Cet objet sera utilisé par la suite pour définir le format de la date et de l'heure à afficher dans le Label. Ici, nous avons utilisé le format fr_FR pour que les dates et heures soient affichées « à la française ».

Pour faciliter l'écriture, l'objet NSDate pickerDate est défini et initialisé avec la date sélectionnée par l'utilisateur dans le contrôle Date Picker :

NSDate *pickerDate = [dp date];

L'instruction suivante définit l'objet select de classe NSString et l'initialise avec la date sélectionnée par l'utilisateur (pickerDate) mise en forme selon les conventions françaises (descriptionWithLocale:frLocale) :

NSString *select = [[NSString alloc] initWithFormat:@"%@", [pickerDate descriptionWithLocale:frLocale]];

Enfin, la date et l'heure mémorisées dans l'objet select sont affectées à la composante text du Label, et donc, affichées dans le Label :

status.text = select;

Il faut bien l'avouer, la mise en œuvre d'un contrôle Date Picker est vraiment simple !

En résumé

• Les contrôles Table View sont utilisés pour afficher des listes d'informations sur une colonne. Pour faciliter l'écriture d'une application basée sur l'utilisation d'un Table View et des vues détaillées correspondantes, le plus simple consiste à utiliser le modèle Master-Detail Application.

• Pour relier les éléments de la vue Master à la vue Detail, il suffit de créer un Segue (Push, Modal ou Custom) en contrôle-glissant-déposant une cellule de la vue Master sur la vue Detail dans le canevas.

• Les contrôles Table View ont une variante : les Picker View. Outre leur aspect « roulette 3D », ces contrôles peuvent afficher des informations sur une ou plusieurs colonnes, et chaque colonne peut comporter un nombre d'informations différent.

• Le contrôle Date Picker est très proche du contrôle Picker View, à ceci près qu'il est spécialisé dans la sélection de dates et d'heures. Sa mise en œuvre est également plus simple que celle d'un Picker View.

Les boutons sont les contrôles d'action de base. Leur apparence peut être personnalisée en utilisant Interface Builder ou des instructions Objective-C. Vous pouvez par exemple choisir la forme, le texte, l'image, la couleur d'arrière-plan et encore beaucoup d'autres caractéristiques.
Interface Builder donne accès à cinq types de boutons prédéfinis, comme le montre la figure suivante.

Pour transformer un bouton par défaut (Rounded Rect) en un bouton prédéfini, il suffit de faire votre choix dans la liste déroulante Type, comme indiqué à la figure suivante.

Il est également possible d'ajouter une image à un bouton Rounded Rect : insérez une image de petite taille dans les ressources de l'application et sélectionnez-la dans la propriété Image du bouton. Si nécessaire, complétez cette image avec un texte, comme à la figure suivante.

Enfin, il est également possible de créer un bouton en utilisant du code Objective-C :

UIButton *monBouton = [UIButton buttonWithType:UIButtonTypeInfoDark ];
[monBouton setCenter:CGPointMake(100.0f, 100.0f)];
[self.view addSubview: monBouton];

La première instruction définit l'objet monBouton, le rattache à la classe UIButton et définit son type UIButtonTypeInfoDark.
La deuxième instruction définit les coordonnées du centre du bouton. Le premier nombre correspond à l'abscisse et le deuxième à l'ordonnée, par rapport au coin supérieur gauche de l'écran.
Enfin, la troisième instruction ajoute le bouton à la vue courante.

Si le bouton est de type Rounded Rect, vous pouvez également définir sa taille et le texte qui y est affiché :

UIButton *monBouton = [UIButton buttonWithType:UIButtonTypeRoundedRect ];
[monBouton setFrame:CGRectMake(100.0f, 100.0f, 100.0f, 20.0f)];
[monBouton setTitle: @"Mon bouton" forState: UIControlStateNormal];
[self.view addSubview: monBouton];

La première instruction définit l'objet monBouton, le rattache à la classe UIButton et définit son type UIButtonTypeInfoDark.
La deuxième instruction définit la position (les deux premiers paramètres) et les dimensions (les deux derniers paramètres) du bouton.
La troisième instruction définit le texte affiché dans le bouton.
Enfin, la quatrième instruction ajoute le bouton à la vue courante.

Les boutons relèvent de la classe UIButton. L'événement déclencheur par défaut est Touch Up Inside ; en d'autres termes, lorsqu'un doigt est enlevé du bouton. Si nécessaire, il est possible d'utiliser plusieurs autres déclencheurs. Par exemple Touch Down (lorsqu'un doigt est posé sur le bouton), Value Changed (modification du texte du bouton) ou encore Touch Drag Inside (appui sur le bouton et déplacement du doigt).

Il y a de grandes chances pour que vous n'ayez pas relié le bouton et le code.
Contrôle-glissez-déposez le bouton de la zone d'édition sur le fichier d'en-têtes, juste au-dessus du @end. Au relâchement du bouton gauche de la souris, sélectionnez Action dans la liste Connection, donnez un nom à l'action et cliquez sur Connect.

Les contrôles Segmented Control sont comparables à des onglets. Ils sont utilisés pour afficher ou cacher certains éléments en fonction de l'onglet (ou plutôt du « segment » dans le jargon Xcode) sélectionné. Ils sont attachés à la classe UISegmentedControl.
Supposons par exemple que vous ayez attaché plusieurs images à votre projet. En utilisant un Segmented Control, vous pouvez afficher une image pour chaque onglet. Nous allons mettre cela en pratique.

Définissez une nouvelle application basée sur le modèle Single View Application et donnez-lui le nom « onglets ». En utilisant Interface Builder, ajoutez au fichier MainStoryboard.storyboard un contrôle Segmented Control, un contrôle Image View et un contrôle Label. Positionnez et redimensionnez ces contrôles pour obtenir quelque chose comme la figure suivante.

Contrôle-glissez-déposez les contrôles de la zone d'édition sur le code du fichier d'en-têtes ViewController.h et définissez les connexions suivantes :

Le fichier ViewController.h doit maintenant contenir les instructions suivantes :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController
@property (weak, nonatomic) IBOutlet UISegmentedControl *onglets;
- (IBAction)ongletChange:(id)sender;
@property (weak, nonatomic) IBOutlet UIImageView *image;
@property (weak, nonatomic) IBOutlet UILabel *sousTitre;

@end

Cette première étape effectuée, vous allez ajouter un onglet au Segmented Control et redéfinir le nom des trois onglets. Commencez par sélectionner le Segmented Control dans le canevas, cliquez sur l'icône Show the Attributes inspector dans la partie supérieure du volet des utilitaires. Inscrivez « 3 » dans la propriété Segments et appuyez sur la touche Entrée de votre clavier. Le contrôle comporte maintenant trois onglets.

Double-cliquez successivement sur chaque onglet dans la zone d'édition et renommez-les « Premier », « Deuxième » et « Troisième ». Si les onglets se recouvrent l'un l'autre, redimensionnez le Segmented Control pour arranger les choses. L'interface doit maintenant ressembler à la figure suivante.

Définissez un dossier « Resources » et ajoutez trois images de 320x480 pixels dans ce dossier. Si cette manipulation vous échappe, reportez-vous à la section "Afficher une image" du chapitre 2 de la partie III. À la figure suivante se trouvent les trois images que j'ai utilisées. Elles proviennent de la bibliothèque de cliparts de Microsoft Office.

Il est temps d'écrire quelques lignes de code. Aucune image n'ayant été affectée au contrôle Image View, ni aucun texte au contrôle Label, nous allons le faire via la méthode viewDidLoad.

Cliquez sur ViewController.m dans le volet de navigation et modifiez la méthode viewDidLoad comme suit :

- (void)viewDidLoad
{
  [super viewDidLoad];
  UIImage *imageCourante = [UIImage imageNamed: @"cheval.jpg"];
  [image setImage: imageCourante];
  sousTitre.text = @"Un cheval et sa cavalière";
}

La ligne 4 définit l'objet UIImage imageCourante (UIImage *imageCourante) et lui affecte l'image « cheval.jpg » qui se trouve dans les ressources de l'application (= [UIImage imageNamed: @"cheval.jpg"]):

UIImage *imageCourante = [UIImage imageNamed: @"cheval.jpg"];

La ligne 5 affecte l'objet imageCourante au contrôle imageView image, et provoque son affichage :

[image setImage: imageCourante];

Enfin, la ligne 6 affiche un texte dans le Label :

sousTitre.text = @"Un cheval et sa cavalière";

Pour terminer l'application, il ne reste plus qu'à réagir aux changements d'onglets en affichant les images et le texte correspondants. Déplacez-vous dans la partie inférieure du code et complétez la méthode ongletChange comme suit :

- (IBAction)ongletChange:(id)sender {
  if (onglets.selectedSegmentIndex == 0)
  {
    UIImage *imageCourante = [UIImage imageNamed: @"cheval.jpg"];
    [image setImage: imageCourante];
    sousTitre.text = @"Un cheval et sa cavalière";
  }
  if (onglets.selectedSegmentIndex == 1)
  {
    UIImage *imageCourante = [UIImage imageNamed: @"chien.jpg"];
    [image setImage: imageCourante];
    sousTitre.text = @"Un chien";
  }
  if (onglets.selectedSegmentIndex == 2)
  {
    UIImage *imageCourante = [UIImage imageNamed: @"chat.jpg"];
    [image setImage: imageCourante];
    sousTitre.text = @"Un chat";
  }
}

Cette méthode est appelée chaque fois que l'utilisateur change d'onglet. Pour savoir quel onglet a été sélectionné, il suffit de lire la valeur stockée dans la propriété selectedSegmentIndex du contrôle Segmented Index (ici onglets). Cette propriété vaut 0 lorsque le premier onglet a été sélectionné, 1 lorsque le deuxième onglet a été sélectionné, 2 lorsque le troisième onglet a été sélectionné, et ainsi de suite.
Comme vous pouvez le remarquer, la méthode ongletChange est composée de trois blocs d'instructions à peu près similaires. Vous pouvez exécuter le projet.

À la figure suivante se trouve le résultat que j'ai obtenu.

Les contrôles Text Field sont des zones de texte monolignes librement éditables par l'utilisateur. Lorsque l'utilisateur clique dans une zone de texte, le clavier intégré s'affiche dans la partie inférieure de l'écran, comme à la figure suivante.

Lorsque l'utilisateur a terminé la saisie, il appuie sur la touche Return du clavier intégré. Ce dernier doit alors disparaître. Pour cela, plusieurs actions sont nécessaires.

Dans le fichier .h

Supposons que votre application soit basée sur le modèle Single View Application, qu'elle ait pour nom tf (comme Text Field) et que son canevas contienne un contrôle Text Field. Vous allez ajouter la déclaration qui apparaît ligne 5 dans le fichier ViewController.h :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController

- (IBAction)saisieReturn :(id)sender;

@end

Dans le fichier .m

Définissez le code relatif à la méthode saisieReturn dans le fichier ViewController.m :

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

Le message [sender resignFirstResponder]; indique à son destinataire qu'il n'est plus le premier répondant. Si cette méthode est reliée à l'événement Did End on Exit de la zone de texte, le clavier disparaîtra, puisque la zone de texte n'aura plus le focus. Dans la prochaine étape, nous allons donc relier l'événement Did End on Exit et la méthode saisieReturn.

Dans Interface Builder

Comme à la figure suivante :

• cliquez sur MainStoryboard.storyboard dans le volet de navigation (1) ;

• cliquez sur la zone de texte dans la vue (2) ;

• affichez le volet des utilitaires en cliquant sur Hide or Show the Utilities (3) ;

• affichez les connexions en cliquant sur Show the Connections Inspector (4) ;

• repérez le bouton radio à droite de Did End On Exit, pointez-le, maintenez le bouton gauche de la souris enfoncé et déplacez la souris sur l'icône View Controller (5) ;

• au relâchement du bouton gauche de la souris, sélectionnez saisieReturn dans le menu (6).

Pour récupérer le contenu d'une zone de texte, il suffit d'utiliser sa propriété text. Nous allons illustrer cette propriété en définissant une mini-application composée d'une zone de texte et d'un label, comme à la figure suivante.

Pour obtenir ce résultat, commencez par définir une application basée sur le modèle Single View Application, ajoutez un contrôle Text Field et un contrôle Label au canevas.

L'application n'a pas encore l'apparence souhaitée. Vous devez modifier deux paramètres dans l'inspecteur des attributs :

• cliquez sur le contrôle Text Field et écrivez « --- Entrez du texte ici --- » dans le paramètre Placeholder ;

• cliquez sur le contrôle Label et tapez « Aucun texte n'a été entré » dans le paramètre Text.

Pour les étourdis, je rappelle que l'inspecteur des attributs est affiché en cliquant respectivement sur l'icône Hide or show the Utilities et Show the Attributes inspector. Il suffit alors de modifier l'attribut souhaité .

Vous allez maintenant relier ces deux contrôles au code de l'application :

• Cliquez sur l'icône Show the Assistant editor dans la barre d'outils de Xcode.

• Contrôle-glissez-déposez le contrôle Text Field du canevas dans le code source du fichier ViewController.h et créez l'outlet saisie.

• Contrôle-glissez-déposez le contrôle Label du canevas dans le code source du fichier ViewController.h et créez l'outlet status.

Après ces manipulations, le fichier ViewController.h devrait contenir les instructions suivantes :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController

- (IBAction)saisieReturn :(id)sender;
@property (weak, nonatomic) IBOutlet UITextField *saisie;
@property (weak, nonatomic) IBOutlet UILabel *status;

@end

Nous allons supposer que l'effacement du clavier a été mis en place lorsque l'utilisateur appuie sur la touche Return, comme indiqué précédemment. Une ligne supplémentaire dans la méthode saisieReturn va suffire pour afficher le contenu de la zone de texte dans le Label (ici la ligne 3) :

- (IBAction)saisieReturn :(id)sender
{
  status.text = [NSString stringWithFormat: @"%@%@", @"Vous avez tapé : ",saisie.text];
  [sender resignFirstResponder];
}

La propriété text du contrôle Label (status.text) est initialisée avec l'objet NSString retourné par le message qui suit le signe « = ». Cet objet est constitué par la concaténation (c'est-à-dire l'ajout) de deux textes (stringWithFormat: @"%@%@") : la chaîne « Vous avez tapé » (@"Vous avez tapé : ") et le contenu du contrôle Text Field (saisie.text).

Les contrôles Slider (figure suivante) sont des curseurs horizontaux dont la position est ajustable par l'utilisateur. Vous les utiliserez pour faciliter la sélection de valeurs dans des plages.

Ces contrôles relèvent de la classe UISlider. Il est possible de les personnaliser dans Interface Builder en définissant :

• une image pour représenter la valeur minimale et une autre pour représenter la valeur maximale ;

• les valeurs minimales et maximales ;

• la valeur par défaut au lancement de l'application.

La position du curseur est accessible à tout moment dans la propriété value.

Pour illustrer le fonctionnement de ce contrôle, nous allons créer une mini-application qui affiche dans un Label la position d'un Slider, et ce à chaque modification du curseur par l'utilisateur.

Définissez un nouveau projet en utilisant le modèle Single View Application et donnez-lui le nom « slider ». Ajoutez un Slider et un Label au canevas. Reliez le Label au fichier .h ; pour cela, effectuez un contrôle-glisser-déposer du Label dans le fichier .h et donnez le nom status à l'outlet ainsi créé.

Reliez le Slider au fichier .h. Pour cela, effectuez un contrôle-glisser-déposer du Slider dans le fichier .h. Au relâchement du bouton gauche de la souris, sélectionnez Action dans la liste Connection, choisissez Value Changed dans la liste Event et tapez « sl » dans la zone de texte Name.

Le fichier .h doit maintenant ressembler à ceci :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController
@property (weak, nonatomic) IBOutlet UILabel *status;
- (IBAction)sl:(id)sender;

@end

Pour compléter ces définitions, vous devez définir quelques lignes de code dans la méthode sl qui, rappelons-le, réagit à l'événement Value Changed du Slider :

- (IBAction)sl:(id)sender {
  UISlider *slider = (UISlider *)sender; 
  status.text = [NSString stringWithFormat:@"%1.2f", slider.value]; 

}

La ligne 2 définit l'objet slider de type UISlider et le relie au Slider qui est à l'origine de l'événement.
La ligne 3 convertit la propriété value du Slider (slider.value) en un objet NSString (NSString stringWithFormat:@"%1.2f", …). L'objet ainsi obtenu est placé dans la propriété text du Label status (status.text = …), ce qui provoque l'affichage de la valeur du curseur dans le label.

Vous utiliserez un contrôle Switch chaque fois qu'il est nécessaire de mettre en place un interrupteur marche/arrêt, comme celui utilisé dans les réglages du device pour le mode avion (figure suivante).

Le contrôle Switch relève de la classe UISwitch. La propriété booléenne on permet de connaître son état et la méthode setOn de le modifier. Voici la syntaxe de cette méthode :

- (void)setOn:(BOOL)on animated:(BOOL)animated

Donnez la valeur :

• YES ou NO au paramètre on selon que vous vouliez mettre l'interrupteur sur ON ou sur OFF.

• YES ou NO au paramètre animated selon que vous vouliez changer l'état de l'interrupteur ; c'est-à-dire avec ou sans animation.

Pour illustrer l'utilisation de ce contrôle, nous allons définir une mini-application qui affiche l'état d'un interrupteur marche/arrêt chaque fois que celui-ci change.

Définissez un nouveau projet en utilisant le modèle Single View Application et donnez-lui le nom « switch ». Ajoutez un Switch et un Label au canevas.

Reliez le Label au fichier .h en effectuant un contrôle-glisser-déposer du Label dans le fichier .h et donnez le nom « status » à l'outlet ainsi créé.

Reliez le Switch au fichier .h en effectuant un contrôle-glisser-déposer du Switch dans le fichier .h. Au relâchement du bouton gauche de la souris, sélectionnez Action dans la liste Connection, choisissez Value Changed dans la liste Event et tapez « sw » dans la zone de texte Name.

Le fichier .h doit maintenant ressembler à ceci :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController
@property (weak, nonatomic) IBOutlet UILabel *status;
- (IBAction)sw:(id)sender;

@end

Pour compléter ces définitions, vous devez définir quelques lignes de code dans la méthode sw qui, rappelons-le, réagit à l'événement Value Changed du Switch. Cliquez sur ViewController.m dans le volet de navigation puis modifiez la méthode sw comme suit :

- (IBAction)sw:(id)sender {
  UISwitch *uis = (UISwitch *) sender;
  if (uis.on == TRUE)
    status.text = @"Le switch est sur ON";
  else
    status.text = @"Le switch est sur OFF";
}

La deuxième ligne définit l'objet uis de classe UISwitch et le relie au switch qui est à l'origine de l'événement.
La ligne suivante teste la valeur de la propriété on du switch. Si cette propriété vaut TRUE, cela signifie que l'interrupteur vient d'être initialisé à ON. Le texte « Le switch est sur ON » est alors affiché dans le label :

status.text = @"Le switch est sur ON";

Dans le cas contraire, cela signifie que l'interrupteur vient d'être initialisé à OFF. Le texte « Le switch est sur OFF » est alors affiché dans le label :

else
  status.text = @"Le switch est sur OFF";

Les contrôles Page Control sont utilisés dans une vue qui comporte plusieurs pages. Ils permettent à l'utilisateur :

1. de savoir où se situe la page courante dans l'ensemble des pages ;

2. de se déplacer dans l'ensemble des pages.

Ces contrôles relèvent de la classe UIPageControl. Pour vous montrer comment les utiliser, nous allons développer une application dans laquelle un contrôle Scroll View contient des zones colorées mises bout à bout. Comme vous pouvez le voir sur l'image suivante, le Scroll View est bien plus large que l'écran de l'iPhone : il comporte cinq zones colorées de la même taille que l'écran.

Définissez une nouvelle application basée sur le modèle Single View Application et donnez-lui le nom « page ». En utilisant Interface Builder, ajoutez un contrôle Scroll View au fichier MainStoryboard.storyboard, et redimensionnez-le pour qu'il occupe la quasi-totalité de l'écran.

Contrôle-glissez-déposez le contrôle Scroll View de la zone d'édition dans le code du fichier d'en-têtes ViewController.m et définissez l'outlet sv. Le fichier d'en-têtes doit maintenant ressembler à ceci :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController
@property (weak, nonatomic) IBOutlet UIScrollView *sv;

@end

Nous allons maintenant définir les rectangles colorés qui seront affichés dans le contrôle Scroll View.

Pour qu'un rectangle représente une page dans le Scroll View, il suffit de lui donner la même taille que le Scroll View. Pour cela, nous allons utiliser la méthode viewDidLoad.
Cliquez sur ViewController.m dans le volet de navigation et complétez la méthode viewDidLoad comme ceci :

- (void)viewDidLoad
{
  [super viewDidLoad];
  NSArray *couleurs = [NSArray arrayWithObjects:[UIColor redColor], [UIColor greenColor], [UIColor blueColor], [UIColor cyanColor], [UIColor yellowColor],nil];
  for (int i = 0; i < couleurs.count; i++) 
  {
    // Définition d'un rectangle
    CGRect rectangle;
    rectangle.origin.x = sv.frame.size.width * i;
    rectangle.origin.y = 0;
    rectangle.size = sv.frame.size; //Le rectangle a la même dimension que le UIScrollView
        
    // Ajout de la vue correspondante
    UIView *subview = [[UIView alloc] initWithFrame:rectangle];
    subview.backgroundColor = [couleurs objectAtIndex:i];
    [sv addSubview:subview];
  }
    
  sv.contentSize = CGSizeMake(sv.frame.size.width * couleurs.count, sv.frame.size.height);
}

La ligne 4 définit un objet NSArray nommé couleurs (NSArray *couleurs) et l'initialise avec cinq couleurs prédéfinies.

Le bloc d'instructions suivant (lignes 5 à 17) définit les cinq rectangles et les transforme en vues du contrôle Scroll View. Pour bien faire les choses, la boucle for utilise le nombre de couleurs définies dans le tableau couleurs (couleurs.count) comme borne supérieure. Ainsi, si vous voulez définir plus ou moins de couleurs, l'application fonctionnera tout aussi bien :

for (int i = 0; i < couleurs.count; i++) 
{
  ...
}

Les rectangles sont des objets CGRect. La première instruction de la boucle (ligne 8) commence par définir un objet rectangle de type CGRect :

CGRect rectangle;

Les trois instructions suivantes définissent l'origine et la taille du rectangle :

rectangle.origin.x = sv.frame.size.width * i;
rectangle.origin.y = 0;
rectangle.size = sv.frame.size;

Remarquez la façon dont est définie l'abscisse (rectangle.origin.x) du rectangle :

rectangle.origin.x = sv.frame.size.width * i;

La propriété frame.size.width de l'objet UIScrollView sv donne la largeur de ce contrôle. En la multipliant par l'index de la boucle, qui vaut consécutivement 0, 1, 2, 3 puis 4, on obtient les valeurs suivantes :

Les cinq rectangles colorés seront donc placés côte à côte horizontalement.

Les instructions suivantes (lignes 14 à 16) définissent les différentes vues qui composent l'objet Scroll View. Pour cela, un objet subview de classe UIView est défini (UIView *subview) et initialisé avec le rectangle créé quelques lignes plus haut (initWithFrame:rectangle) :

UIView *subview = [[UIView alloc] initWithFrame:rectangle];

La couleur de cet objet est alors initialisée avec la couleur définie dans l'élément d'index i du tableau :

subview.backgroundColor = [couleurs objectAtIndex:i];

La sous-vue est enfin définie en utilisant l'objet subview :

[sv addSubview:subview];

Vous pouvez lancer l'application et constater (oh merveille !) qu'il est possible de scroller horizontalement dans le Scroll View.
Vous allez maintenant ajouter un contrôle Page Control au fichier ViewController.xib. Par défaut, le nombre de pages accessibles via un Page Control est égal à trois. Dans notre cas, nous devons scroller à travers cinq pages. Il faut donc modifier le nombre de pages par défaut. Cliquez sur le Page Control dans la zone d'édition, affichez le volet des attributs (si nécessaire en cliquant sur Hide or show the Utilities puis sur Show the Attributes inspector) et modifiez la valeur de l'attribut Pages, comme indiqué à la figure suivante.

Définissez un outlet et une action pour le contrôle Page Control et nommez-les (respectivement) « laPage » et « changePage ». Le fichier d'en-têtes doit maintenant ressembler à ceci :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController
@property (weak, nonatomic) IBOutlet UIScrollView *sv;

@property (weak, nonatomic) IBOutlet UIPageControl *laPage;
- (IBAction)changePage:(id)sender;
@end

Pour que le Page Control puisse être mis à jour lorsque l'utilisateur change de page en utilisant une gestuelle de glisser, il est nécessaire d'être informé de cette gestuelle. Pour cela, nous déléguerons cette tâche au Scroll View. Il est donc nécessaire :

1. d'ajouter le protocole UIScrollViewDelegate dans le contrôleur de vue, c'est-à-dire dans le fichier ViewController.h ;

2. de connecter le delegate du Scroll View au contrôleur de vue.

Elles vont permettre d'écrire dans le code du contrôleur de vue (ViewController.m) les méthodes événementielles en rapport avec le contrôle Scroll View. En effet, en ajoutant le delegate UIScrollViewDelegate au contrôleur de vue et en le reliant au contrôleur de vue, ce dernier sera capable de traiter les événements du contrôle Scroll View.

La première étape se fait en spécifiant le protocole dans la déclaration de l'interface :

@interface ViewController : UIViewController <UIScrollViewDelegate> 
{
  ...
}

La deuxième étape se fait en cliquant sur le contrôle Scroll View dans le canevas (1), puis en glissant-déposant le cercle à droite de delegate sur l'icône View Controller (2), comme à la figure suivante.

Retournons au code.
Cliquez sur ViewController.m dans le volet de navigation.

Le contrôleur de vue étant le délégué du Scroll View, nous allons utiliser une méthode de ce dernier pour mettre à jour le Page Control. Insérez la méthode suivante à un endroit quelconque dans le code. Par exemple juste avant la méthode viewDidLoad :

- (void)scrollViewDidScroll:(UIScrollView *)sender {
  CGFloat largeurPage = sv.frame.size.width;
  int page = floor((sv.contentOffset.x - largeurPage / 2) / largeurPage) + 1;
  laPage.currentPage = page;
}

Cette méthode est exécutée lorsque l'utilisateur déplace horizontalement le Scroll View.
La ligne 2 stocke la largeur d'une page (c'est-à-dire celle du Scroll View) dans la variable CGFloat largeurPage :

CGFloat largeurPage = sv.frame.size.width;

La ligne 3 calcule le numéro de la page affichée dans le Scroll View. Ce numéro change lorsque la vue est décalée de plus de la moitié de l'écran (figure suivante).

Le calcul paraît complexe, mais il n'en est rien. La propriété sv.ContentOffset.x représente le décalage de l'élément affiché dans le Scroll View. Si on lui soustrait la moitié de la largeur de la page, et qu'on divise le résultat par la largeur de la page, on obtient :

• 0 lors du scroll de la page 1 à la page 2

• 1 lors du scroll de la page 2 à la page 3

• etc.

En ajoutant 1 à cette valeur, on obtient exactement ce qui est recherché, à savoir le numéro de la page vers laquelle l'utilisateur se déplace.

Toujours dans le flou ? Passons à une application numérique. Nous allons supposer que le device utilisé est un iPhone 3G. Bien sûr, ce raisonnement fonctionne sur tous les autres devices, mais il fallait bien en choisir un pour passer à l'application numérique.

La résolution d'un iPhone 3G est de 320x480 pixels. Supposons que l'utilisateur soit en train d'effectuer une gestuelle pour passer du premier écran au deuxième (comme sur la figure précédente).
Examinons les valeurs des différents éléments contenus dans la formule floor((sv.contentOffset.x - largeurPage / 2) / largeurPage) + 1.

Libre à vous de décomposer les calculs pour le passage du deuxième au troisième écran, du troisième au quatrième et du quatrième au cinquième. Vous verrez, cela fonctionne.

Si vous vous demandez comment j'ai pu trouver cette formule, eh bien, je me suis demandé quel résultat je voulais obtenir et après deux ou trois essais infructueux, je suis arrivé à définir la bonne formule. Cette approche fonctionne bien pour toutes sortes de formules, qu'elles soient plus simples ou plus complexes…

Retournons au code de l'application. Pour mettre à jour en conséquence le Page Control, il suffit d'affecter la valeur que l'on vient de calculer à sa propriété currentPage :

laPage.currentPage = page;

Pour terminer, nous allons compléter la méthode action changePage pour réagir aux actions de l'utilisateur sur le Page Control. En effet, pour le moment, ce contrôle est juste utilisé pour afficher la page active, mais pas pour changer de page. Rassurez-vous : le code sera bien plus simple que le précédent.

Localisez la méthode changePage et complétez-la comme suit :

- (IBAction)changePage:(id)sender {
  CGRect frame;
  frame.origin.x = sv.frame.size.width * laPage.currentPage;
  frame.origin.y = 0;
  frame.size = sv.frame.size;
  [sv scrollRectToVisible:frame animated:YES];
}

La ligne 2 définit la variable frame de type CGRect. Le code se poursuit en définissant l'abscisse et l'ordonnée de l'affichage. Si vous n'avez qu'une vague idée de ce que représentent ces termes mathématiques, la figure suivante va vous rappeler de vieux souvenirs.

La ligne 3 définit le décalage en abscisse (frame.origin.x) de l'affichage :

frame.origin.x = sv.frame.size.width * laPage.currentPage;

Ce décalage est calculé en multipliant le numéro de la page courante par la largeur d'une page.

L'ordonnée de l'affichage est toujours égale à zéro :

frame.origin.y = 0;

Et la propriété size du rectangle est mise à jour avec les composantes x et y qui viennent d'être calculées :

frame.size = sv.frame.size;

Il ne reste plus qu'à mettre à jour l'affichage dans le Scroll View en définissant le rectangle visible (scrollRectToVisible:frame) et en demandant une animation (animated:YES) :

[sv scrollRectToVisible:frame animated:YES];

Vous pouvez (enfin) exécuter l'application et profiter du résultat !

En résumé

• Les boutons sont les contrôles d'action de base. Leur apparence peut être personnalisée en utilisant Interface Builder ou des instructions Objective-C. Vous pouvez par exemple choisir la forme, le texte, l'image, la couleur d'arrière-plan et encore beaucoup d'autres caractéristiques.

• Les contrôles Segmented Control sont comparables à des onglets. Ils sont utilisés pour afficher ou cacher certains éléments en fonction de l'onglet (ou plutôt du « segment » dans le jargon Xcode) sélectionné. Ils sont attachés à la classe UISegmentedControl.

• Les contrôles Text Field sont des zones de texte monolignes librement éditables par l'utilisateur. Lorsque l'utilisateur clique dans un Text Field, le clavier intégré s'affiche dans la partie inférieure de l'écran.

• Les contrôles Slider sont des curseurs horizontaux dont la position est ajustable par l'utilisateur. Vous les utiliserez pour faciliter la sélection de valeurs dans des plages.

• Vous utiliserez un contrôle Switch chaque fois qu'il est nécessaire de mettre en place un interrupteur marche/arrêt, comme celui utilisé dans les réglages du device pour le mode avion.

• Les contrôles Page Control sont utilisés dans une vue qui comporte plusieurs pages. Ils permettent à l'utilisateur de savoir où se situe la page courante dans l'ensemble des pages et de se déplacer dans l'ensemble des pages.

Les contrôles Tab Bar permettent de créer facilement des applications multivues. L'utilisateur passe d'une vue à l'autre en cliquant sur les icônes du contrôle Tab Bar.