La Couche Contrôleur de Cocoa
Quand nous commençons à apprendre Cocoa (ou Java, ou Qt ou n’importe quel framework applicatif), une des premières choses que l’on aborde est le design pattern Modèle-Vue-Contrôleur.
Le design pattern Modèle-Vue-Contrôleur (MVC) prescrit que pour qu’une application soit bien conçue, elle doit séparer le code manipulant les données (la couche modèle) du code spécifique à l’interface utilisateur (la couche Vue), et que ces deux couches communiqueront entre elles au travers de la couche contrôleur.
Partant de cette définition, Cocoa fournit un excellent support pour les objets des couches modèle et vue.
Les classes fondation telles que NSMutableString, NSDictionary et NSNumber fournissent une bonne base pour les classes modèles, et NSView de l’AppKit et sa myriade de sous-classes fournit une solide implémentation pour les classes de la couche vue.
Quand il faut faire communiquer ces deux domaines, il en a toujours été de la responsabilité du développeur d’écrire le code pour le contrôleur.
Et regardons les choses en face : si vous avez déjà développé une application modérément complexe, vous savez qu’écrire cette partie de code est fastidieux.
Apple a identifié ce problème et a mis en place une solution qui a vue le jour dans la version 10.3 de Mac OS X. Leur solution est la Couche Contrôleur, qui est constituée de nombreuses classes et protocoles qui implémentent une architecture cohérente pour faciliter la communication entre les couches modèle et vue d’une application.
La couche contrôleur est le confluent de plusieurs technologies Cocoa, nouvelles ou déjà existantes, incluant key-value coding (codage par clé-valeur), key-value observing (observation clé-valeur) et key-value binding (connexion clé-valeur).
D’après Apple, la couche contrôleur permet de remplacer dans 90 pour cent des applications Cocoa le code spécifiquement développé par le développeur par des composants de cette couche contrôleur.
Dans la grande tradition Cocoa, l’utilisation de la couche contrôleur s’effectue pratiquement complètement depuis Interface Builder, minimisant ainsi le code à écrire.
Le bénéfice pour nous est clair : nous pouvons réduire, voire éliminer les heures que nous passons à implémenter et maintenir le code qui connecte notre modèle de données à l’outlet et aux actions pour tous nos contrôles d’interface.
Qu’est-ce-que la Couche Contrôleur
La couche contrôleur est constituée de nombreuses classes et protocoles.
Les classes contrôleur essentielles définies dans l’AppKit sont :
NSControllerNSObjectControllerNSArrayControllerNSUserDefaultsController
NSController est une classe abstraite de base qui définit l’interface générale pour toutes les classes contrôleur.
NSObjectController est une sous-classe concrète de NSController qui permet aux objets de l’interface utilisateur d’être liés à un seul objet ; NSArrayController –lui-même une sous-classe de NSObjectController– gère une collection d’objets.
NSUserDefaultsController est une autre sous-classe concrète de NSController qui offre une interface entre la base de données des préférences utilisateur par défaut, et les propriétés et valeurs des contrôles de votre interface utilisateur.
Que font exactement les contrôleurs ?
En gros, ils connectent les propriétés des objets modèles aux éléments de l’interface utilisateur qui peut afficher et manipuler les valeurs des propriétés associées.
Considérez un moment que notre modèle est une classe qui représente un livre.
Certaines propriétés de ce modèle sont le titre du livre et l’auteur, qui sont stockés dans une variable d’instance de type NSString de la classe Book.
En utilisant un NSObjectController, nous pouvons associer un NSTextField à chacune de ces propriétés. Les mécanismes implémentés dans la couche contrôleur s’occupent de l’affichage de la valeur de la propriété, en stockant les modifications faites dans les champs texte du modèle, et en avisant les éléments de l’interface intéressés des changements sur les données.
En utilisant un NSArrayController, nous pouvons créer une collection d’objets Book, et afficher cette collection dans NSTableView. C’est exactement ce que nous ferons aujourd’hui dans cet article.
Tout ce que nous avons à faire c’est d’établir une connexion dans Interface Builder entre vue, contrôleur et modèle.
Mécanismes de la Couche Contrôleur
Avant de commencer notre application du jour, concentrons-nous sur les mécanismes qui forment les bases de la couche contrôleur.
Ces mécanismes sont Key-Value Coding, qui est un protocole du framework Fondation et Key-Value Observing, qui est implémenté par de nombreuses méthodes NSObject.
La couche contrôr?unit ces deux mécanismes en Key-Value Binding, qui constitue le composant fondamental de la couche contrôleur.
Key-Value Coding
Key-Value Coding (KVC) est une des technologies centrales Cocoa qui existe depuis quelques temps.
Le but de KVC est d’offrir un mécanisme pour accéder indirectement aux valeurs des propriétés de l’objet (c.à.d les variables d’instance) par nom en utilisant des chaînes de caractères clés, plutôt que d’invoquer directement les méthodes d’accès.
Les méthodes utilisées pour accéder aux propriétés d’objets sont définies dans le protocole de fondation NSKeyValueCoding.
Comme illustration de l’utilisation de KVC, prenez la classe Book, qui pourrait avoir l’interface suivante :
@interface Book : NSObject
{
NSString *_title;
NSString *_author;
}
- (NSString *)title;
- (NSString *)author;
- (void)setTitle:(NSString *)title;
- (void)setAuthor:(NSString *)author;
@end
Nous voyons que la classe book a deux variables d’instance de type NSString, _title et _author, ainsi que des méthodes d’accès pour initialiser ou récupérer les valeurs de ces variables d’instance.
D’ordinaire, nous accèderions à ces propriétés par leur méthode d’accès respective.
Si nous voulions initialiser le titre de l’objet livre, nous ferions ce qui suit :
[aBook setTitle:@"The Illiad"];
Récupérer le titre du livre se fait par simple invocation de title:
NSString *title = [aBook title];
Maintenant, avec KVC nous utilisons les chaînes de caractères clés pour initialiser et retrouver les valeurs des propriétés en utilisant les méthodes valueForKey: et setValue:forKey: comme suit :
[aBook setValue:@"The Illiad" forKey:@"title"]; NSString *title = [aBook valueForKey:@"title"];
Il existe un nombre de règles que KVC suit pour identifier les méthodes d’accès ou les variables d’instance auxquelles font référence les clés.
Dans le cas de [aBook valueForKey:@"title"] KVC recherche d’abord une méthode d’accès publique nommée setTitle:, et s’il ne la trouve pas, un accesseur privé nommé _setTitle:.
Si ni la méthode d’accès publique, ni la méthode d’accès privée ne sont trouvées, KVC tentera alors de changer directement la valeur de la variable d’instance nommée title ou _title.
KVC préfère utiliser les méthodes d’accès, mais il accédera directement aux variables d’instance si les accesseurs ne sont pas implémentés.
Il est généralement recommandé d’implémenter les méthodes d’accès pour contrôler l’accès des variables d’instance de votre classe.
Pour une discussion détaillée de Key-Value Coding, lisez Introduction to Key-Value Coding d’Apple.
Key-Value Observing
Key-Value Observing (KVO) est une nouvelle technologie incluse dans Panther de laquelle la couche contrôleur dépend fortement.
KVO offre un mécanisme qui permet aux objets d’être avertis des changements des propriétés de l’objet observ?.La technologie du contrôleur s’appuie sur KVO pour faciliter la communication entre les couches modèle, contrôleur et vue de l’application.
Ainsi, en utilisant KVO, un objet contrôleur sera toujours au courant des modifications des objets qu’il gère, et l’interface utilisateur sera toujours mise à jour pour refléter tout changement dans la couche contrôleur.
Nous n’irons pas dans les détails de Key-Value Observing aujourd’hui, car ils n’ajouteront rien à notre discussion.
Il est important de retenir que Cocoa a maintenant dans sa classe racine, NSObject, les moyens d’offrir aux objets la possibilité d’observer les changements effectués sur d’autres objets.
KVC + KVO = KVB
Nous venons d’apprendre que Key-Value Coding permet aux objets d’accéder indirectement aux propriétés d’autres objets au moyen de clés.
Nous avons également appris que Key-Value Observing offre un mécanisme qui permet aux objets d’observer les modifications survenues sur les propriétés d’autres objets.
La couche contrôleur fusionne KVC et KVO pour former le tissu fondamental de la communication de la couche contrôleur, formant le design pattern appelé Key-Value Binding.
Key-Value Binding permet aux propriétés d’un objet d’être connectées aux propriétés d’un autre objet.
KVC donne les moyens à un objet de découvrir et changer la valeur d’une propriété d’un autre objet, tandis que KVO permet à un objet de suivre les changements effectués sur les propriétés d”un autre objet.
L’image suivante montre comment KVC et KVO facilitent la communication et la synchronisation suivant le modèle MVC :
Dans cette image nous voyons comment la combinaison de KVC et KVO crée un lien.
Ici, si l’utilisateur effectue des changements sur le tableur, les modifications sont transmises au modèle de données, tandis que KVO notifie au contrôleur et au graphe que des modifications ont été effectuées et que la vue a besoin d’être mise à jour pour refléter le changement.
En utilisant les liens, nous pouvons lier la valeur affichée dans un champ texte à une propriété d’un objet géré par un contrôleur.
Souvenez-vous que le contrôleur joue le rôle d’un intermédiaire.
Nous ne devrions jamais lier directement les vues aux données.
Notre travail est, en utilisant la technologie de la couche contrôleur, de spécifier et établir les liens entre un contrôleur et les objets de l’interface utilisateur.
Dans Interface Builder nous pouvons voir tous les liens disponibles pour tous les éléments de l’interface utilisateur dans l’inspecteur de liens d’objets (Bindings, Command-4).
Nous devons d’abord définir le modèle de données pour notre application de telle façon qu’un contrôleur sache quelles propriétés du modèle sont disponibles pour être connectées.
Créer un Modèle de Données
Etablir un design solide pour le modèle de données est la première étape qui peut prendre avantage de la technologie de la couche contrôleur.
L’application que nous allons créer aujourd’hui est un simple catalogue de livres, et nous avons donc besoin de créer une classe Book qui nous servira de modèle de données.
Avant de continuer, nous allons créer un nouveau projet Xcode de n’importe quel nom (le mien s’appelle Bibliotheca) basé sur l’application de document (document-based).
Rappelez-vous que la couche contrôleur fut livrée avec Mac OS X 10.3, et que vous devez donc utiliser ce dernier pour cet article.
La classe Book sera une simple représentation de livre avec des propriétés telles que le titre et l’auteur.
Une représentation plus complète et exacte d’un livre devrait inclure des propriétés pour l’éditeur, l’ISBN, la date de publication et plus.
Par mesure de simplicité, nous nous contenterons du titre et de l’auteur.
Créez une nouvelle classe Objective-C nommée Book et définissez l’interface de classe suivante dans Book.h
@interface Book : NSObject
{
NSString *_title;
NSString *_author;
}
- (NSString *)title;
- (NSString *)author;
- (void)setTitle:(NSString *)title;
- (void)setAuthor:(NSString *)author;
@end
Notre classe de modèle de données est assez simple : les variables d’instance NSString sont utilisées pour stocker le titre et l’auteur du livre.
Nous avons des méthodes d’accès pour initialiser et récupérer ces instances de variables.
L’implémentation de ces quatre méthodes est facile :
@implementation Book
- (NSString *)title { return _title; }
- (NSString *)author { return _author; }
- (void)setTitle:(NSString *)title
{
[_title autorelease];
_title = [title retain];
}
- (void)setAuthor:(NSString *)author
{
[_author autorelease];
_author = [author retain];
}
@end
Pour chaque méthode “get”, nous retournons simplement la valeur de la variable d’instance en question.
Dans les méthodes “set”, nous effectuons un autorelease de la valeur existante, et nous initialisons la variable d’instance avec le nouvel objet après avoir fait un “retain” dessus.
Pour un modèle de données simple, c’est tout ce que nous avons besoin de faire.
Un modèle de données plus complexe pourrait avoir des propriétés calculées, ou les propriétés pourraient être de type plus complexe.
Par exemple, pour représenter le fait que de nombreux livres peuvent avoir plusieurs auteurs, la propriété auteur pourrait être un NSArray d’objets Author avec des propriétés pour prénom et nom.
Nous avons établi un modèle de données simple mais suffisant pour Bibliothecha.
Maintenant il est temps de passer à la vitesse supérieure et passer à Interface Builder, où nous allons effectuer la plupart du travail pour créer notre interface, et connecter l’interface au modèle de données au travers d’objets contrôleur appropriés.
Alors double-cliquons sur le fichier MyDocument.nib pour ouvrir Interface Builder et y travailler.
Dans Interface Builder
Notre interface sera assez simple : suffisante pour démontrer comment fonctionne la couche contrôleur.
Elle consistera en deux fenêtres.
La première fenêtre consiste en un tableau contenant la liste de tous les livres du catalogue.
En plus de ce tableau, il y a trois boutons pour ajouter et supprimer les éléments de ce tableau, ainsi que pour ouvrir la fenêtre de l’inspecteur.
La seconde fenêtre est une fenêtre comme celle d’un inspecteur qui permet à l’utilisateur d’éditer les informations détaillées concernant le livre en cours de sélection.
Dans cette configuration, la vue du tableau est appelée la vue maîtresse, parce qu’elle affiche tous les livres du catalogue, et l’inspecteur est appelé la vue détaillée parce qu’elle peut afficher des informations plus précises concernant un seul livre.
L’Interface Maître
Dans notre vue maîtresse, le tableau contient deux colonnes : une pour le titre du livre, et une pour l’auteur.
L’interface pour la fenêtre principale est montrée ici :
Ici, nous avons une vue avec un tableau pour afficher le contenu de notre catalogue de livres.
Le bouton Add ajoutera une nouvelle ligne à votre tableau, et le bouton supprimera la ligne sélectionnée.
Le bouton Get Info… est utilisé pour ouvrir la fenêtre de l’inspecteur qui affiche une vue détaillée de l’élément sélectionné.
La fenêtre de l’inspecteur est également très simple.
Elle consiste simplement en deux champs texte qui affichent les deux propriétés d’une instance de Book :
Si la classe Book avaient plus de propriétés que nous ne lui en avons données, alors nous aurions pu arranger les choses de telle sorte que le tableau affiche un sous ensemble des propriétés (c.à.d. les propriétés les plus importantes telles que le titre et l’auteur), tandis que la vue détaillée de l’inspecteur fournirait les champs pour afficher toutes les propriétés de notre modèle de données.
Maintenant que nous avons mis au point nos deux fenêtres, nous pouvons câbler quelques contrôleurs.
Configurer notre NSArrayController
Les objets contrôleur de Cocoa existent dans leur propre palette dans Interface Builder, comme montré ci-dessous :
Ces trois objets représentent les trois contrôleurs disponibles dans Cocoa.
Sur la gauche nous avons une instance de NSUserDefaultsController, au milieu une instance de NSObjectController, et sur la droite, l’instance de NSArrayController.
Comme nous voulons utiliser un contrôleur pour remplir et gérer le contenu d’une NSTableView nous utiliserons un NSArrayController ; glissez une instance de NSArrayController dans la fenêtre Instances de votre nib.
Nous lui donnons un nom unique qui permettra de l’identifier en cas de besoin.
Pour cela, double-cliquez sur le label de l’objet et changez le nom de NSArrayController en quelque chose comme BookController.
Ensuite, nous avons besoin d’indiquer au contrôleur quel type d’objet il va gérer.
Un NSArrayController a besoin de connaître la classe du modèle de données qu’il va gérer pour savoir comment instancier les nouveaux objets.
Pour cela, ouvrez l’inspecteur Attributes, et modifiez l’Object Class Name de NSMutableDictionary en Book.
Maintenant, nous devons indiquer à Book Controller quelles clés sont disponibles pour accéder aux propriétés des objets Book.
Ceci peut se voir dans la liste Keys dans la même vue Attributes de l’inspecteur.
Les clés que vous entrez ici sont les mêmes que celles que vous utiliserez pour accéder aux propriétés des objets en utilisant key-value coding : author et title.
Là, votre NSArraycontroller devrait être configuré de la façon suivante :
Voici maintenant une rapide récapitulation de ce que vous venez de faire : nous avons créé une instance de NSArrayController dans notre nib que nous avons nommée Book controller.
Il sera le contrôleur qui gère le contenu du tableau de notre vue maîtresse.
Le NSArrayController est configuré pour travailler avec des instances de la classe Book, comme nous l’avons indiqué dans l’inspecteur Attributes.
Nous avons également défini les clés que NSArrayController utilisera pour accéder à chaque propriété de chaque instance de Book gérée par le contrôleur du tableau.
Ce sont les mêmes clés que l’on utiliserait avec le key-value coding pour accéder indirectement aux variables d’instance des objets Book.
En gros, nous avons maintenant défini le lien entre le modèle de données et la couche contrôleur de l’application.
Maintenant nous devons établir les connexions entre le contrôleur et les vues.
Connecter les Colonnes du Tableau
Les connexions entre le contrôleur et l’interface sont établies individuellement pour chaque élément de l’interface.
Pour notre application, chaque colonne du tableau est considérée en tant qu’élément de l’interface, et nous devons donc établir une connexion entre la colonne title du tableau et la propriété title du modèle.
Nous devons également créer une connexion entre la colonne author du tableau et la propriété author de Book.
Pour l’instant, sélectionnez la NSTableColumn Title (par n’importe quelle combinaison de click ou double-click nécessaire à la sélection d’un élément imbriqué), et ouvrez l’inspecteur Bindings pour la NSTableColumn.
L’inspecteur Bindings liste tous les attributs de l’élément de l’interface sélectionnée tels que les attributs de police de caractère et la couleur de texte, aussi bien que les états de disponibilité, par exemple si le contrôle est éditable ou non, caché ou non.
Mais plus important pour nous aujourd’hui, nous avons une connexion avec la valeur (value) de la colonne du tableau, qui sera affichée dans chaque ligne de la colonne du tableau.
Pour mettre en évidence les options pour les valeurs à lier, cliquez sur le triangle sur la gauche.
Ceci laisse apparaître de nombreuses options ; concentrez-vous sur les trois premières.
Ici, nous avons trois paramètres qui sont utilisés pour indiquer à NSTableColumn où il peut récupérer les données.
Bind to est là où nous spécifions quel contrôleur nous utiliserons pour obtenir la valeur du modèle de données.
Dans ce popup vous devriez voir Book Controller, qui est le contrôleur que nous voulons sélectionner.
Ensuite, nous avons le paramètre Controller Key.
Comme tout objet, les instances de NSArrayController ont des propriétés accessibles par key-value coding.
Vous remarquerez que chaque clé dans la liste de Controller Key correspond à la méthode de NSArrayController qui retourne le NSArray d’objets du modèle de données géré par le contrôleur. Dans notre cas, ce sera un tableau d’objets Book.
Enfin, nous devons spécifier le Model Key Path, qui est simplement la clé utilisée pour accéder à la propriété du modèle de données dont nous souhaitons afficher la valeur.
L’ouverture de cette combo box révélera toutes les clés que nous avons spécifiées quand nous avons configuré Book Controller.
Pour les valeurs de la colonne Title, nous voudrions naturellement afficher le titre du livre, nous sélectionnons donc la clé title pour ce paramètre.
Avec cela, nous avons créé une liaison complète entre le modèle de données, le contrôleur et un composant de l’interface utilisateur.
La création d’une connexion pour la colonne Author suit exactement le même principe, sauf que nous utilisons author pour le Model Key Path plutôt que title.
Une fois que vous avez correctement configuré les connexions, l’inspecteur devrait ressembler à cela :
Soyons attentifs aux trois boutons en bas de la fenêtre principale.
Encore une fois, le bouton Add est utilisé pour ajouter un nouvel élément à la table, le bouton Remove pour supprimer l’élément sélectionné dans la table, et le bouton Get Info… pour faire apparaître les détails de l’élément sélectionné.
NSArrayController défini de nombreuses méthodes qui peuvent être une action du contrôle de l’interface.
Deux de ces actions sont add: et remove:.
L’action add: indiquera au contrôleur du tableau de créer une nouvelle instance de sa classe de modèle de données, et l’ajoutera au tableau des objets gérés.
L’action remove: supprimera l’objet sélectionné du contenu du tableau du tableau contrôleur.
Ce que nous devons faire c’est glisser une connexion depuis les boutons Add et Remove vers Book Controller et créer leur action respective add: et remove: :
Remarquez également que le NSArrayController a une action pour insérer de nouveaux éléments, ainsi que pour modifier la sélection en cours vers l’objet suivant ou précédent du tableau.
Vous pourriez créer des contrôles pour ces actions.
Nous sommes prêts à tester la version 1 de notre interface.
Faites le maintenant dans Interface Builder en sélectionnant Test Interface depuis le menu File.
La fenêtre principale apparaîtra, et vous devriez pouvoir cliquer sur le bouton Add pour créer un nouvel élément dans la table, et éditer les champs de la nouvelle ligne.
Ceci, chers lecteurs, est une démonstration du fonctionnement de la couche contrôleur de Cocoa.
Assez sympa n’est-ce-pas ?
Si vous voulez voir d’autres trucs aussi sympas, ajouter plusieurs lignes d’information, et cliquez sur l’en-tête de la colonne du tableau…
C’est trié !
Comme cela, sans avoir rien fait !
Retournons à Interface Builder pour créer les connexions pour l’inspecteur, et ajouter quelques petits rafinements.
Mise en Place des Connexions de l’Inspecteur
Le bouton Get info… doit pouvoir ouvrir le fenêtre de l’inspecteur.
Pour cela nous faisons en sorte que l’action de ce bouton soit associé à la méthode makeKeyAndOrderFront: de la fenêtre de l’inspecteur.
Mettre en place les connexions des champs texte de l’inspecteur est similaire à ce que nous avons fait pour les colonnes du tableau.
Sélectionnez le NSTextField Title, et ouvrez son inspecteur Bindings.
Sélectionnez la section value pour faire apparaître les options de connexion.
Tout comme pour la colonne Title du tableau, nous associons le champ texte à Book Controller, et le Model Key Path est la clé title pour la classe Book.
Ce qui diffère, c’est le Controller Key que nous positionnons à selection.
Cette clé du contrôleur correspond à la méthode selection de NSObjectController qui, pour NSArrayController, retourne l’objet du tableau en cours de sélection.
En positionnant la clé du contrôleur à selection, le champs texte affichera en permanence la propriété title de la ligne du tableau sélectionnée.
Faites de même avec le champ texte Author, en connectant sa valeur à la propriété author de classe modèle, et en mettant la clé du contrôleur à selection.
En effectuant des tests de l’interface, vous verrez comment vos champs texte se mettent à jour en fonction de la sélection courante.
Remarquez que les champs texte indiquent “No Selection” quand aucune ligne du tableau n’est sélectionnée.
Ce message peut être modifié dans l’inspecteur Bindings.
Il existe quatre types de placeholder que vous pouvez paramétrer : aucune sélection, valeurs multiples, non applicable et nul.
Si vous avez paramétré NSTableView pour autoriser les sélections multiples, vous remarquerez que les champs texte affichent “Multiple Values” lorsque vous sélectionnez plus d’une ligne.
Ce comportement est intelligent.
Considérez le scénario dans lequel nous sélectionnons deux livres dans le tableau : l’Odyssée et l’Iliade, tous deux écrits par Homère.
Dans l’inspecteur, le champ titre affichera “Multiple Values”, cependant, le champ auteur affichera simplement “Homère” puisque toutes les lignes sélectionnées ont le même auteur.
On fait donc ressortir le fait qu’il y a plusieurs valeurs pour une seule propriété plutôt que quand il y a plusieurs éléments sélectionnés.
Conclusion
Vous avez probablement remarqué maintenant qu’il existe de nombreux attritbuts de contrôle que nous pouvons connecter à un contrôleur.
Un exemple est NSWindow.
Si vous ouvrez l’inspecteur Bindings pour la fenêtre elle-même, un des paramètres que vous pouvez connecter est le titre de la fenêtre.
Sélectionnez title dans la liste des paramètres, et connectez le à la clé selection de Book Controller, et au title du Model Key Path.
C’est exactement ce que nous avons fait pour paramétrer la connexion à value du champ texte title.
Maintenant, le titre de la fenêtre inspecteur correspond au titre du livre sélectionné dans la table.
Encore une fois, c’est un mécanisme plutôt sympa.
Un autre point que nous pourrions améliorer est de faire en sorte que le bouton Remove ne soit actif que lorsqu’une sélection est faite.
C’est très simple à faire en utilisant la technologie controller bindings.
Dans l’inspecteur Bindings du bouton Remove, ouvrez les paramètres pour la connexion enabled (sous Availability).
Choisissez une connexion à Book Controller, et sous Controller sélectionnez canRemove.
Il s’agit d’une des nombreuses clés qui correspond aux méthodes de NSArrayController qui retournent des valeurs booléennes, adaptées pour connecter des propriétés booléennes des contrôles de l’interface utilisateur, comme celle indiquant si le contrôle est actif.
Vous pourriez également paramétrer la propriété enabled du bouton Add en la connectant à canAdd de Book Controller.
En ajoutant la couche contrôleur, Cocoa va encore plus loin en atteignant le but essentiel de tout framework applicatif : éliminer le plus possible les tâches répétitives pour que le développeur puisse se concenter sur le développement de fonctionnalités innovantes qui pourraient, potentiellement, mettre son application au-dessus du lot.
J’espère que cet article vous a donné un bon aperçu de ce qu’il est possible de faire avec la couche contrôleur, ainsi qu’une bonne compréhension de ce qui se passe en arrière plan, de telle sorte que vous puissiez explorer d’autres possibilités de connexions.
Vous pouvez récupérer le projet XCode de cet article ici.
Textes originaux en anglais sur O’Reilly : The Cocoa Controller Layer par Mike Beam
Chargement
Commentaires récents