On souhaite réaliser un diaporama avec effets graphiques. L’effet de base est illustré dans la vidéo suivante : exemple. La réalisation est en deux parties :

1. réaliser une composition Quartz permettant d’animer l’affichage d’un ensemble d’images
2. intégrer et piloter cette composition depuis une application MacOSX

Première partie : Quartz

Une animation d’image simple comme dans cette vidéo.

1. Lancer Quartz Composer et créer une composition vierge. Modifier la couleur du fond de la composition en modifiant les paramètres du patch Clear.
2. Dans un premier temps on essaie d’afficher une simple image. Pour cela dans la bibliothèque rechercher « image » et retrouver un patch adéquat permettant de charger une image.
3. Dans les patchs de type Render trouver un patch permettant de prendre en entrée une image affin de l’afficher. Connecter vos patchs de sorte que l’image chargée soit affichée.
4. Modifier les paramètres du patch de visualisation afin d’observer l’usage de chacun d’entre eux. Si le patch ne permet pas de faire tourner l’image autour d’un axe vertical, c’est que ce n’est pas le bon patch…
5. À l’aide d’un patch Interpolation animer l’image de sorte qu’elle tourne autour de son axe vertical sans discontinuer (le tout avec une vitesse raisonnable).
6. Rechercher le patch Gradient l’ajouter à la composition. Normalement les affichages précédents disparaissent… Dans chaque patch de rendering (patchs bleus) modifier le numéro d’ordre situé en haut à droite qui permet d’indiquer l’ordre d’affichage des patchs… Trouver un ordre correct permettant d’afficher votre image qui tourne sur un fond dégradé (peut importe les couleurs du dégradé).
7. Sauver la composition pour la garder bien au chaud.

Seconde partie : Quartz — le retour

Une animation contrôlée par le temps voir : vidéo

1. Reprendre la composition précédente. Remplacer le patch Interpolation par un Patch Time et utiliser un patch Mathematical Expression de sorte que l’image tourne sur elle-même à la fréquence d’un tour par seconde.
2. Dupliquer ce qui est nécessaire de sorte que l’on fasse tourner une seconde image en même temps que la première.
3. Ajouter les patchs mathématiques nécessaires de sorte que pour les tours paris la première image soit affichée et l’autre pour les tours impairs. Pour cela utiliser l’entrée Enable…
4. Ajouter un paramètre (une expression mathématique) permettant de régler la vitesse de rotation. 1 – un tour/sec., 2 – un tour/2sec., etc.

Troisième partie : Quartz — le retour de la vengeance qui tue

Cette fois on cherche à charger une image différente en fonction du temps. Trois images sont disponibles i0.png, i1.png, i2.png.

1. Modifier le chargeur d’image (en trouver un autre) permettant de charger une image depuis un URL.
2. Introduire des patchs de sorte que l’un d’entre eux soit le numéro d’une des trois images, la composition devant simplement charger l’image de numéro donné.

Quatrième partie : Arnold Quartzenegger is back

Optimiser afin d’éviter le chargement incessant d’images… Utiliser les itérations…

Écrire à l’aide de SpriteKit un jeu dans lequel :

• le joueur se déplace verticalement mais sur une verticale située à gauche de l’écran
• les aliens apparaissent au fur et à mesure par intervalles tirés au hasard, à droite à une position tirée au hasard et avec une vitesse variable selon les cas…
• si le joueur touche un alien, son score est incrémenté de 1

On pourra y ajouter ce qu’il plaira selon les envies… Par exemple d’autres «aliens» qu’il faut éviter sous peine de mort immédiate, d’autres «aliens» qui lancent des balles qui peuvent détruire le joueur…

Pour vous aider :

• l’appel à intervalles réguliers d’une méthode sur un objet peut-être obtenu à l’aide de la classe Timer (du framework Foundation) et en particulier de la factory init(timeInterval: TimerInterval, target: Any, selector: Selector, userInfo: Any?, repeats: Bool)

En partant du template pour iOS Master/Detail, écrire une application permettant d’exploiter les données du fichier XML : images.xml.

Le fichier XML devra être chargé dynamiquement par l’application (il ne devra pas être contenu dans le déploiement).

La vue principale devra faire apparaître le nom des rubriques (niveau <category>) et dans chaque catégorie les items via leur titre (<title>) et leur icône (<thumbnail>) s’il elle existe.

En sélectionnant un item l’application ouvrira une vue de détail faisant apparaître :

• le titre (<title>),
• l’image grand format (dont l’url est donnée dans <image>) et,
• un éventuel lien qui permettra d’accéder à la page web indiquée (si le lien existe sous le nom <weblink>).

Indications : le parsing du XML s’effectuera à l’aide de NSXMLParser, qui est un parser SAX.

• commencer par créer un type de données pour représenter les items,
• créer «en dur dans le code» quelques items avec les bonnes valeurs,
• faire en sorte que le Master-Detail fonctionne avec ces données (on peut oublier la gestion de l’icône),
• ensuite rajouter la fonctionnalité, dans la vue de détail, permettant en cliquant d’aller sur le la page web indiquée,
• ensuite rajouter le parsing du XML,
• ensuite rajouter la présentation de l’icône dans la vue maître.

Voilà à quoi cela pourrait ressembler :

On souhaite réaliser une application iOS permettant de visualiser des données et de naviguer en leur sein. Ces données décriront les attributs associés aux cours dispensés à l’UFR d’Informatique et à leurs enseignants affectés mais aussi les relations entre ces différentes entités. L’application sera réalisée par étapes successives, au final on devra pouvoir naviguer et obtenir différents effets (envoyer un mail à un enseignant, obtenir sa photo, naviguer sur sa page web, etc, tout cela depuis la page d’un cours ou d’un diplôme. Ce TP débouchera (au final) sur un rendu de la réalisation qui pourra être faite par groupe de 2.

XML

1. Dans un premier temps il est nécessaire de structurer les données. Il est donc demandé de spécifier un format de données XML (pas besoin de DTD on ne fera pas de validation), balises, attributs permettant de décrire l’ensemble du cursus d’informatique de l’UFR, licence, master, avec pour chaque diplôme les années, L1, L2, L3, M1, M2, pour chaque année la liste des UE/cours (intitulé, horaires, salles, etc), et pour chaque cours les chargés de cours et TD et TP. Pour chaque enseignant sa page web, son mail, sa photo, une présentation audio, vidéo, etc. Il peut (doit?) s’agir de fichier XML distincts (cours.xml? enseignants.xml? horaires.xml?).
2. Dans un second temps, il faut créer quelques données utilisables (inutile de décrire vraiment l’ensemble des cours et cursus) en quantité suffisantes.
3. Déposer ses fichiers sur un serveur web (vous devez normalement avoir accès à votre propre page web de l’UFR en créant un dossier personnel de nom public_html, si ce n’est pas le cas trouvez une solution (avec les enseignants, etc).

iOS

1. Créez une application iOS de base (choisissez par exemple la version la plus élémentaire), compilez, excutez afin de vérfier que tout fonctionne bien.
2. Créez des structures de données (des classes?) permettant de représenter facilement dans votre application les données extraites du fichier XML
3. Modifiez le délégué d’application de sorte que le fichier XML soit chargé et parsé de façon à remplir votre structure de donnée (via NSXMLParser?)
4. L’interface dont vous aurez besoin ne devra pour l’instant contenir rien d’autre que des informations relatives au chargement :
   • nombre de cours
   • nombre d’enseignants
   • etc.

Présentation de données

Attention le travail suivant est (très) conséquent et nécessitera probablement plusieurs séances… Ce sera l’objet des séances suivantes…

1. Présentez les données de façon à rendre ergonomique au possible votre application, nous vous suggérons d’utiliser des mélanges subtils de
   • webviews pour présenter des données HTML (page web des enseignants?)
   • tableviews pour présenter des listes longues/variables d’items (cours?)
   • tabbars pour présenter des collections restreintes et fixes de catégories (diplômes?)
   • pickerviews (diplômes/cours/années?)
   • imageviews (photos?)
   • objets du framework AVFoundation pour présenter de l’audio/vidéo

But : réaliser un diaporama pour MacOSX…

Technologies : Compositions Quartz, KVC

Première partie : Une composition Quartz

1. Lancer Quartz Composer et créer une composition vierge (de type Basic Composition).
2. Ajouter à cette composition un Billboard, à l’aide de l’inspecteur, modifier sa largeur de sorte quelle soit égale à 2.
3. Déclarer l’Input de nom image du Billboard comme étant une entrée publique (à l’aide du menu contextuel, Publish Inputs) et choisir un nom adéquat pour cette entrée (disons image1). Sauver la composition.

Seconde partie : Intégration d’une composition Quartz dans une application, Application Delegate, Outlets

1. Lancer xcode et créer un projet OSX/Cocoa Application.
2. Éditer l’interface pour y ajouter un objet de type QCView.
3. À l’aide de l’inspecteur des propriétés, éditer l’objet QCView pour qu’il charge la composition Quartz créée, penser à le paramétrer.
4. Modifier le code AppDelegate.hpour y ajouter @property (weak) IBOutlet QCView *renderer; (un Outlet est une propriété visible de l’éditeur d’interface à laquelle on peut associer un objet, c’est une propriété représentant une association au sens UML). Sauver le fichier.
5. Revenir à l’édition de l’interface et tirer un lien entre l’objet App Delegate et la QCView, choisir l’outlet renderer. Désormais l’objet App Delegate connaît la QCView de l’interface via la propriété renderer (ils sont associés).
6. Observer les Connections de l’objet App Delegate et constater que cet objet est connu d’un autre de nom File's Owner via un Outlet à l’intérieur de celui-ci. Observer l’objet File's Owner et constater que sa classe est NSApplication. Utiliser la documentation pour comprendre à quoi ces objets sont utiles. Pour le mécanisme de délégation, vous pouvez interroger les enseignants (ou rechercher sur le web).
7. Dans l’interface rajouter un bouton et lui associer le déclenchement de l’action play: de la QCView.
8. Ajouter une image quelconque au projet (supposons qu’elle s’appelle toto.jpg).
9. Dans l’implémentation AppDelegate.m modifier le code de la méthode applicationDidFinishLaunching: (en profiter pour consulter la documentation de cette méthode) en lui rajoutant le code suivant :NSImage *image = [NSImage imageNamed:@"toto"];

[self.renderer setValue:image forKeyPath:@ »patch.image1.value »]

; On en profitera pour lire la documentation relative à la classe `NSImage`. La seconde instruction correspond à l’association de l’image chargée à l’entrée de la composition Quartz (il peut donc être nécessaire de la modifier en conséquence). Compiler (sans oublier de rajouter le framework Quartz.framework au projet). Et Tester.

Troisième partie : Une composition Quartz plus complexe

1. Modifier la composition Quartz (ou en créer une autre) avec deux Billboards dont les entrées seront toutes deux publiées sous le nom image1 et image2 par exemple.
2. Utiliser, Interpolation, Mathematical Expression et deux RGB Color afin de contrôler l’entrée Color des deux Billboards. Paramétrer l’interpolateur pour passer de la valeur 0 à la valeur 1 en trois secondes. Utiliser la sortie de l’inerpolateur pour modifier le canal Alpha (qui représente la transparence dans les couleurs) des deux RGB Color, lorsque l’un sera à la valeur x, l’autre sera à la la valeur 1-_x_. Les couleurs de sortie des RGB Color seront branchés en entrée des Billboards.
3. Tester et mettre au point la compositionen utilisant le visionneur de paramètres (Parameters) afin d’y placer des entrées en test.
4. Sauver cette composition.

Quatrième partie : Un diaporama plus complet (awakeFromNib, subclassing, …)

1. Ajouter à l’application précédente une sous-classe de QCView de votre cru (MyQCView). Modifier la classe du QCView de l’interface pour qu’elle soit positionnée à la nouvelle classe créé.
2. Ajouter une seconde image à l’application.
3. Modifier la nouvelle classe créé en surchargeant la méthode startRendering afin d’y positionner les deux entrées de la composition Quartz.
4. Compiler. Tester

Cinquième partie : Encore plus complet

1. Modifier la sous-classe de QCView de sorte qu’à son extraction du fichier d’interface, un tableau d’images soit initialisé, avec un ensemble d’images contenues dans le bundle de l’application (surcharger la méthode awakeFromNib).
2. Surcharger la méthode renderAtTime:arguments: de sorte que les images d’entrée de la composition soient modifiées lorsque nécessaire afin d’obtenir un diaporama de l’ensemble des images chargées (consulter attentivement la documentation de cette méthode).
3. Modifier la composition, l’interface et le code de sorte que le temps de défilement entre les images soit un paramètre qui vaut 3 secondes par défaut et soit modifiable en temps réél via un slider et que les délais puissent varier de 1 à 10 secondes.

But : Un diaporama iOS vachement plus mieux que tout ce qui a été fait jusqu’à présent

Technologies : quelques possibilités supplémentaires de l’UIKit, storyboarding, segue, etc.

Segue…

But : reprendre le code du TP n°3 et le modifier de sorte qu’une fenêtre dédiée à la configuration de l’application soit utilisée

1. revenir à l’édition du storyboard, rajouter un Navigation Controller (consulter la documentation des UINavigationController). a. supprimer immédiatement le Root View Controller (de type Table View Controller) qui lui est associé.
   1. éditer les propriétés du Navigation Controller pour en faire le Initial View Controller, c’est-à-dire le controleur présent au démarrage de l’application.
   2. connecter, en tirant un lien, le contrôleur de navigation à votre controleur de vue et choisissez le type de relation Root View Controller.
   3. modifier le code du délégué de l’application qui recherchait le controleur afin d’y récupérer des informations… Un intermédiaire a été ajouté!
   4. compiler et tester que tout fonctionne à l’identique.
2. ajouter un View Controller supplémentaire dans votre storyboard.
3. ajouter un bouton dans le View Controller principal et le placer dans le coin inférieur droit (en respectant les règles de placement). Modifier le type du bouton en choisissant Info Light.
4. établir un lien de navigation entre le bouton et le second contrôleur. Choisir le type modal. Sélectionner le lien et configurer l’action de transition.
5. compiler et tester qu’une touche sur le bouton provoque l’apparition (via une animation) de la seconde vue.
6. créer une nouvelle classe de nom ConfigViewController sous-classe de UIViewController, et utiliser cette classe comme classe pour le second contrôleur de vue.
7. ajouter dans la seconde vue un bouton de titre approprié comme « Terminé ».
8. établir un lien de type action entre le bouton et le contrôleur qui pilote la vue (nommer cette action donepar exemple).
9. dans le code de cette action ajouter [self dismissViewControllerAnimated:YES completion:nil];. Consulter la documentation de cette méthode et de sa classe associée…
10. Compiler et tester que la navigation entre écrans est correcte.
11. Déplacer le slider et sa gestion dans l’écran de configuration… Modifier le code en conséquence. (Attention le travail n’est pas trivial, il faut lire la documentation… La première piste est la méthode prepareForSegue).
12. capturer les glissements sur la surface (UIGestureRecognizer) pour permettre à l’utilisateur de passer d’une image à l’autre manuellement, en avant ou an arrière…
13. modifier l’écran de configuration de sorte que l’on puisse choisir un mode manuel ou automatique. Le choix doit s’opérer via un élément de type UISwitch.
14. Compiler, tester.

But : Un diaporama iOS vachement plus mieux que tout ce qui a été fait jusqu’à présent puisqu’il va faire apparaître des composants chouettes…

Technologies : quelques objets particuliers de l’UIKit, (Woody Wood) PickerView,

Des données de Diaporama organisées autrement.

1. Modifier le code de sorte que des diaporamas puissent être affichés. Pour cela, Utiliser une structure à trois dimensions (type, sous-type, image) via des NSArrays, et dans laquelle :
   1. le type est le type générique d’un ensemble de Diaporamas : Montagne, Mer, …
   2. le sous-type raffine le type en proposant diverses déclinaisons, exemple pour Montagne : Alpes, Rocheuses, etc
   3. image est une image appartenant au diaporama de type et sous-type correspondant.
2. Idem pour la musique mais avec une simple liste de musiques/sons… La liste devra être une liste de couples (nom,fichier), le nom servira à l’affichage, et le fichier désignera le nom du fichier contenant la musique.
3. Si l’interface est trop chargée : réfléchir à son allègement (écran secondaire, un seul PickerView additionné de Labels, autres composants, etc.).
4. Les structures de données peuvent éventuellement être reconstruites par analyse de la structure de répertoires contenus dans l’application (attention à la distinction entre répertoires et groupes…)

Une configuration plus complexe

1. Modifier la partie configuration de l’application de sorte que deux UIPickerView soient utilisés afin de présenter : pour l’un les choix de type/sous-type des diaporamas, pour l’autre les musiques/sons possibles. Consulter la documentation de UIPIckerView et observer que deux délégués sont utilisés :
   1. le dataSource de type UIPickerViewDataSource et dont le rôle est de fournir des informations sur la composition structurelle du composant (nombre de colonnes, nombre d’éléments par colonne)
   2. le delegate de type UIPickerViewDelegate chargé de fournir les données à afficher dans la PickerView (pickerView:titleForRow:forComponent:) et de répondre à la sélection par l’utilisateur (pickerView:didSelectRow:inComponent:)

But : Un diaporama pour iOS

Technologies : découverte de l’environnement de programmation pour iPhone/iOS

Première partie : AppDelegate, UIKit

1. créer un projet iOS de type Single View Application. Le disséquer.
2. analyser le cycle de vie d’une application iOS et l’usage du protocole UIApplicationDelegate. Modifier les différentes méthodes de l’objet AppDelegate de sorte que des données soient rechargées/sauvegardées entre différentes incarnations de l’application en utilisant une instance de NSUserDefaults.
3. Compiler, tester.
4. En profiter pour observer les possibilités offertes par le simulateur d’iPhone/iPad.

Seconde partie : UIView

1. consulter la documentation de l’objet UIViewController et en particulier la gestion de la vue (Managing the view) et de ses événements (Responding to view events).
2. ajouter dans la vue principale un objet de type UIImageView contenant une image.
3. Compiler, tester.
4. Modifier le code de sorte que l’image chargée soit tirée au hasard au démarrage de l’application (faut-il une Outlet, capturer un événement particulier, etc).

Troisième partie : Asynchronisme

1. consulter la documentation de la classe NSTimer.
2. utiliser un timer pour obtenir la modification de l’image à intervalles réguliers (les images seront embarquées dans l’application).
3. compiler, tester.
4. ajouter un UISlider permettant de modifier le temps d’exposition de chaque image.
5. compiler, tester.

Quatrième partie : Defaults

1. faire en sorte que le temps d’exposition soit sauvegardé, ainsi que l’image courante entre différentes incarnations de l’application.
2. compiler, tester.

Cinquième partie : Guetta’s death…

1. consulter la documentation de la classe AVAudioPlayer.
2. rajouter un bouton play/pause, permettant de déclencher le jeu d’un fichier de musique (avec répétition en boucle).
3. compiler/tester
4. faire en sorte que l’état (play/pause, position courante dans la musique) soit sauvegardée entre les incarnations de l’application.
5. compiler, tester.

But : Terminer le diaporama pour MacOSX…

Technologies : Bindings, FileSystem

Note : le projet sera à rendre par binôme…

Première partie : File System

1. Modifier le projet du TP n°2 de sorte que les images visualisées dans le diaporama puissent être choisies via l’option File > Open.... Pour cela il faudra utiliser un NSOpenPanel (consulter sa documentation)

Seconde partie : Bindings

1. On souhaite permettre la modification du délai pour le fondu via un NSSlider. Pour cela il faut :
   1. Modifier la composition Quartz de sorte que le délai soit une entrée publique.
   2. Établir un lien (bindings) entre le potentiomètre et le délai. Attention car ce lien ne peut être direct car on ne peut généralement pas établir de lien vers des objets GUI. par conséquent il est nécessaire de passer par un NSObjectController qui devra être instancié dans le .xib, attaché par son outlet content à la QCView. Ensuite le bindings pourra s’effectuer sur le controller avec comme paramètre Controller Key égal à selection et Model Key Path à patch.ce_qui_va_bien_pour_que_ca_fonctionne....

Troisième partie : Enable/Disable bindings

1. On souhaite que les boutons qui servent à démarrer et arrêter le diaporama soient actifs ou inactifs lorsque nécessaire. Pour cela il est nécessaire de les lier (via bindings) à un booléen qui représente l’état courant de l’exécution du diaporama :
   1. Rajouter une propriété booléenne à votre QCView qui sera correctement mise à jour lorsque le diaporama est en cours d’exécution ou non (pensez à startRendering et autres méthodes du même acabi – consulter la documentation!)
   2. Effectuer le bindings du bouton d’arrêt à ce booléen ainsi que celui du bouton de démarrage à ce même booléen via de controlleur de la QCView.
   3. Pour l’un de ces deux boutons, il faudra utiliser un Value Transformer dans le binding (un NSNegateBoolean) afin d’obtenir la négation de la condition sur l’exécution.

Quatrième partie : Menu pour les sportifs assoiffés de MacOSX…

1. Ajouter un menu Style avec deux options mutuellement exclusives permettant de sélectionner une fonction de transition parmi deux possibles (celle déjà développée et une autre composition avec les mêmes paramètres – deux images et un délai). Attention : la manipulation des menus est parfois délicate, car de nombreuses choses peuvent être automatisées mais il faut lire très attentivement la documentation…

Cinquième partie : Livraison

1. RESPECTEZ IMPÉRATIVEMENT LES CONSIGNES DE LIVRAISON, EN PARTICULIER POUR LES NOMS DES RÉPERTOIRES, ETC., sous peine d’énerver le correcteur qui se retrouvera irremédiablement emberlificoté avec des répertoires et fichiers partout éparpillés… Note : L’énervement du correcteur ne l’aide pas à devenir clément lorsque nécessaire… Attention aussi, les instructions suivantes concernent la version 4.5.2 de xcode, mais l’esprit reste le même pour les versions antérieures (il faut peut-être fouiller un peu).
2. Fignoler l’application avant de la livrer (la franciser entièrement, lui adjoindre une icône, etc).
3. Pour livrer l’exécutable (qu’on prendra soin de tester indépendamment de xcode!!!!) il suffit de demander son archivage via Product > Archive. Ensuite sélectionner l’archive correrspondante dans l’organiseur, cliquer sur Distribute..., Export as Application…
4. Pour livrer le code source il faut :
   1. Faire un nettoyage via Product > Clean
   2. Puis créer un cliché (snapshot) du projet, celui-ci ne contiendra que les dernières versions des sources et pas tout l’historique, pour cela File > Create Snapshot.
   3. Aller dans Window > Organizer, choisir l’onglet Projects, sélectionnez le cliché puis cliquer sur le bouton Export Snapshot en bas à gauche…
5. Préparer un répertoire de nom TPOSX-votre_nom_et_celui_de_vôtre_binome_séparés_par_un- et contenant : le cliché du projet xcode (nettoyé correctement via Clean), l’application obtenue après archivage et un fichier README.txt contenant les noms et prénoms des binômes!
6. Livrer le tout via UPS, La Poste ou http://www.firstpizzapp.biz/. Attention à respecter la date limite… Bien vérifier que ce qui est livré est correct…
7. Ne pas oublier de rédiger une décharge stipulant : (1) l’abandon de vos droits et (2) autorisant explicitement vos enseignants à faire fortune avec votre merveilleuse application.

Première partie : une prise en main

1. Lancer xcode (qui se trouve normalement dans le répertoire /Applications) et créer une application de type Cocoa Application. Compiler et tester le modèle par défaut afin de vérifier que l’environnement de développement est correctement installé et configuré.
2. Explorer le projet afin d’en anaylser la structure (fichiers sources, ressources, frameworks, etc).
3. Revenir à la sélection du premier élément représentant le projet et observer les différentes options de configuration du projet et de la cible (métadonnées, options de compilation, etc). Attention à ne rien changer que vous ne sauriez remettre en l’état…
4. Sélectionner le fichier MainMenu.xib et éditer l’interface de sorte que lui soit rajoutée un objet permettant de visualiser une image (piste : NSImageView).
5. Configurer ce visualiseur d’image de sorte qu’une image de votre choix y soit présente au lancement de l’application. Attention, cela nécessitera sans doute d’ajouter cette image dans le projet lui-même… Tester.
6. Modifier les caractéristiques de cet objet visualiseur d’image de sorte qu’il soit autorisé de déposer une image quelconque depuis l’extérieur de l’application. Tester.

Seconde partie : un peu de code…

1. Créer un nouveau projet vierge de type Cocoa Application. Le configurer.
2. Y ajouter une nouvelle classe à l’aide du menu File > New > File.... Observer l’instanciation d’un modèle de source de classe Objective-C.
3. Ajouter, dans l’interface de l’objet une action de nom click:. Pour se faire, la signature devra en être - (IBAction)click:(id)sender;.
4. Ajouter, dans l’implémentation de la classe, le code de la méthode click: de sorte qu’un message soit affiché (via NSLog). Pour avoir des informations plus précises sur NSLog, ouvrir la documentation viaWindow > Organizer, onglet Documentation puis NSLog dans le champ de recherche (prendre patience).
5. Éditer MainMenu.xib afin d’ajouter à l’interface un simple bouton.
6. Dans la partie Objects de l’interface, rajouter une instance d’objet (NSObject). Modifier la classe de cet objet en choisissant la classe précédemment créée.
7. En tenant le bouton droit de la souris, tirer un trait du bouton vers l’objet instancié. Dans le menu contextuel qui apparaît choisir l’action adéquate… Observer le lien créé via l’inspecteur du bouton et/ou de l’objet : onglet Connections inspector en partie droite de la fenêtre principale.
8. Compiler et tester votre première application Mac.

Troisième partie : le monde est vaste… (internationalisation)

1. Reprendre l’application précédente et y ajouter un fichier de ressources de type Strings File de nom Localizable.
2. Modifier le projet de sorte que la localisation dans une autre langue que l’anglais soit disponible. Revenir sur le fichier de localisation créé précédemment et le rendre localisable (via l’inspecteur) en choisissant une langue parmi celles offertes.
3. Une entrée d’un tel fichier est toujour au format "clé" = "valeur";. Modifier les fichiers de localisation de sorte qu’à la clé "clic" soit associé un texte particulier pour chaque langue.
4. Modifier le source de la classe de sorte que NSLog affiche un message localisée selon l’environnement. Pour cela, on peut utiliser la méthode NSLocalizedString (consulter la documentation pour en connaître les détails).
5. Compiler et tester que le message s’affiche correctement.
6. Modifier la langue de l’environnement (via les Préférences Systèmes…) et relancer l’application pour constater que la localisation fonctionne.
7. Par glisser-déposer, faites apparaître l’application sur votre Bureau en sélectionnant le Product adéquat à l’aide de la souris et de la touche alt.
8. Observer le contenu du Bundle.

Quatrième partie : une bonne livraison…

1. Explorer les options du projet et des fichiers de méta-données de sorte que l’application possède une icône, etc. Bref, qu’elle ressemble à une vraie application Mac…