Stefano e Lori Blog

Nelle precedenti parti abbiamo creato l’applicazione Currency Converter, in questa lezione cercheremo di completare ed apportare alcune migliorie.

Mostriamo bene il risultato del calcolo

Avrete sicuramente notato che il risultato della conversione è un numero float con tanti decimali per lo più ininfluenti. Voglio mostrare questa cifra con soli due decimali. Non sapendo come fare esattamente ho dato una spulciata alle classi NSNumber e NSNumberFormatter ed ho trovato una soluzione che funziona, forse non sarà elegante ma funziona. In questo momento non cerco soluzioni eleganti ma semplicemente risposte alle mie curiosità.

Dunque ho modificato ConverterControlle.m  per utilizzare queste due classi così:

- (IBAction)convert:(id)sender
{
//dichiaro una variabile per contenere un oggetto NSString
//che conterrà il valore della conversione sottoforma di una
//stringa opportunamente formattata.
NSString *amount;
//Creo un'istanza di converter
converter = [[Converter alloc]init];
//chiamo il metodo setSourceCurrencyAmount passandogli il valore del TextFiled
//euroField
[converter setSourceCurrencyAmount:[euroField floatValue]];
//chiamo il metodo setRate passandogli il valore di rateField
[converter setRate:[rateField floatValue]];
//creo un oggetto NSNumberFormatter
NSNumberFormatter *myNumberFormatter = [[NSNumberFormatter alloc] init];
//setto i parametri per la formattazione
[myNumberFormatter setMaximumFractionDigits:2];
[myNumberFormatter setMinimumFractionDigits:2];
//creo la stringa formattata, è necessario passare un NSNumber che creo a partire dal float che
//mi torna convertCurrency
amount = [myNumberFormatter stringFromNumber: [NSNumber numberWithFloat:[converter convertCurrency]]];
//imposto il valore del campo amountField con il valore della variabile di metodo
[amountField setStringValue:amount];
//torno al campo di testo degli euro da convertire
[euroField selectText:self];
}

Come possiamo notare ho tolto la dichiarazione della variabile float e l’ho sostituita con una dichiarazione per una variabile adatta a contenere un oggetto NSString. Ho poi creato ed istanziato un oggetto NSNumberFormatter che si occupera della formattazione e della conversione in una stringa.

NSNumberFormatter *myNumberFormatter = [[NSNumberFormatter alloc] init];

Setto poi il comportamento di NSNumberFormatter con i decimali.

[myNumberFormatter setMaximumFractionDigits:2];
[myNumberFormatter setMinimumFractionDigits:2];

Poi chiamo il metodo stringFrom Number che pretende come parametro un NSNumber e torna come risultato una NSString. Memorizzo l’oggetto NSString nella variabile amount e utilizzo il metodo di classe numberWithFloat per creare un oggetto NSNumber partendo da un numero float, che è quello tornato dal metodo convertCurrency.

mount = [myNumberFormatter stringFromNumber: [NSNumber numberWithFloat:[converter convertCurrency]]];

Infine assegno la variabile amount al campo di testo con il metodo setStringValue.

[amountField setStringValue:amount];

In questo modo l’importo convertito si vede sempre con 2 cifre decimali. NSNumberFormatter comunque fa molte altre cose è opportuno dargli uno sguardo, poichè contiene molti metodi per le valute e l’internazionalizzazione dei numeri.

Ottimizziamo il menu

Come avete notato il menu della nostra applicazione contiene molte più cose di quante ne servano effettivamente, questo perchè Xcode mette le cose più comuni dentro.

Togliete pure il menu relativo ai font, quello window tanto currency converter a una sola finestra, nel menu file togliete tutto e lasciate solo close, nel menu edit lasciate soltanto quelli relativi a la copia incolla, annulla e redo. Togliete pure l’istanza della classe che controlla il menu font nella finestra MainMenu.xib

Un’altra piccola cosa è quella di impostare l’allineamento a destra dei campi, a me piacciono i più i numeri allineati a destra stile calcolatrice.

Salviamo e chiudiamo IB

Localizziamo in italiano

Per localizzare in italiano la nostra applicazione occorre sostanzialmente tradurre soltanto l’interfaccia. Per far questo selezionate MainMenu.xib nella finestra di Xcode e premete Cmd + i nel tab general premete su Add localization e scrivete Italian come nome della localizzazione, premete add.

Ora fate doppio clic su MainMenu.xib (Italian) e in IB traducete tutto compreso il menu. Non tentate di tradurre il menu col nome dell’Applicazione non funzionerà quindi non traducetelo.

Salvate, date un clean e ricompilate la vostra applicazione. Adesso apparirà in italiano. Un consiglio guradate i nomi in italiano che usa Apple per tradurre i comandi comuni, come file->archivio, edit->modifica etc.

Bene salvate tutto e chiudete IB. In Xcode date un bel clean e ricompilate tutto. Ecco a voi Currency Converter in italiano.

L’icona

Icon Composer

Per impostare l’icona dell’applicazione occorre prima disegnarne una e poi con il tool Icon Composer creare il file .icns. Potete disegnare la vostra icona con qualsiasi programma di grafica vettoriale come Illustrator o Fireworks, salvarla in formato jpeg o meglio png e importarla in Icon Composer. Icon Composer si trova dentro la cartella Developer > Applications > Utilities, non vi spiego come si fa è talmente banale che vi divertite da soli. Tenete presente che per Leopard occorre disegnare l’icona di ben 512×512 pixel, poichè le icone grandi vengono mostrate nella visuale coverflow del finder.

Una volta che avete creato l’icona salvate il file con il nome APPL.icns all’interno della cartella del progetto. Per concludere in Xcode editate il file:

• Currency_Converter-info.plist

che trovate nella cartellina Resources e nella proprietà icon file inserite APPL.icns. Clean e compilate di nuovo, adesso la vostra applicazione ha anche un’icona.

Bene e con questo si conclude il progetto Currency Converter, certo manca il file dell’aiuto, ho dato una sbirciata e ho capito che non è difficile ma piuttosto laborioso creare un help Book pertanto ci rinuncio per questo tutorial e ci dedicherò tempo per la mia prima vera e propria applicazione cocoa.

Ciao

Bene ora che abbiamo creato sia l’oggetto “Model” che l’oggetto “View” non rimane che collegare il tutto per mezzo dell’oggetto “Controller” ma prima di cominciare vediamo cosa sono: Outlets, Targets e Actions.

Outlets

Un Outlet è una speciale variabile che identifica un’oggetto.

Outlet

Come facilmente si capisce dalla immagine è un’oggetto particolare perché può fare riferimento a qualsiasi altro oggetto dell’applicazione come  ad esempio un campo di testo, oppure un’istanza di una nostra classe. Gli Outlets posso essere configurati in IB e questo li rende ancora più speciali. Un outlet si dichiara così:

IBOutlet id nomeVariabile;

Gli oggetti che hanno id come tipo sono oggetti tipicizzati dinamicamente, durante il run-time verrà usato dinamicamente un tipo di dato idoneo. Benché questa funzionalità sia davvero potente e comoda perché ci permette di non preoccuparci dei tipi di dato durante lo sviluppo dell’applicazione, può essere però molto più difficile trovare e correggere alcuni bug. Quindi, quando non è strettamente necessario utilizzare un tipo dinamico e nella maggior parte dei casi non lo è, possiamo dichiarare gli Outlets come puntatori a classi di specifici oggetti. Ad esempio:

IBOutlet NSButton* myButton;

Gli Outlets vengono generalmente impostati in IB semplicemente disegnando una connessione fra due oggetti, esisto altri modi per impostare un Outlet ma questo è sicuramente il più conveniente.

Target/Action in IB

Le relazioni Target/Action vengono impostate nel pannello “Connections” nell’ispector di IB. Quando si chiede all’applicazione di eseguire una certa azione in pratica si manda un Action ad uno specifico Target che in IB è rappresentato da un Outlet di un certo oggetto. Alcuni oggetti, come ad esempio gli oggetti che ereditano da NSControl tipo NSButton, sono in grado di pilotare un metodo Action, in questi oggetti gli Outlets per Target e Action sono già definiti. Nei oggetti che invece creiamo noi come ad esempio un appController (quello che creeremo in questo articolo) possiamo definire le Action nel seguente modo:

- (IBAction)myAction:(id)sender;

Grazie a questa sintassi IB sarà capace di identificare le Action nei nostri oggetti e ci permetterà di collegarli agli altri oggetti dell’interfaccia.

In quale direzione collegare

Molto semplicemente possiamo definire due direzioni principali:

• Per creare una connessione Action dobbiamo disegnare un collegamento fra l’oggetto dell’interfaccia grafica che genera l’azione e il nostro appController che la riceve.
• Per creare una connessione Outlet dobbiamo disegnare un collegamento fra un nostro oggetto e un’altro oggetto sia che appartenga ad una classe da noi creata sia che sia un elemento dell’interfaccia grafica.

Ovviamente queste sono le connessioni più usate, ce ne sono dell’altre che a tempo debito verrano approfondite.

Il controller ConverterController

Bene è ora  di aggiungere il Controller alla nostra applicazione quindi similmente al Model aggiungiamo una classe al nostro progetto.

• In Xcode selezioniamo il gruppo Classes nella finestra del proggetto
• Scegliamo File >New File
• Nella finestra di dialogo selezioniamo a sinistra Cocoa Class e a destra Objective-C Class scegliendo come Subclass of NSObject e clicchiamo su next.
• Chiamiamo la nostra Classe ConverterController.m, assicuriamoci che sia selezionato also create ConverterController.h e clicchiamo su Finish.

ConverterController si occuperà quindi di comunicare sia con l’interfaccia sia con la classe Converter che esegue il calcolo. Apriamo ConverterController.h per definire l’interfaccia del nostro Controller. Dichiariamo 3 Outlets per i tre campi di testo:

IBOutlet NSTextField *ammountField;
IBOutlet NSTextField *euroField;
IBOutlet NSTextField *rateField;

Si tratta di dichiarazioni di variabili quindi vanno all’interno delle parentesi graffe, come vedete abbiamo dichiarato gli Outlets in modo statico perché sappiamo benissimo che si tratta di NSTextField.

Dobbiamo poi dichiarare il metodo Convert per eseguire il calcolo.

- (IBAction)convert:(id)sender;

Certamente in questa piccola Applicazione avremo potuto eseguire i calcoli all’interno del Controller senza scomodare la classe Converter, tuttavia abbiamo deciso di eseguire l’applicazione secondo lo schema MVC. Lo schema MVC offre i suoi benefici in applicazioni molto complesse perché rende il codice più riusabile e più ordinato, in questa piccola applicazione sembra quasi complicare le cose inutilmente.

Salviamo il nostro ConverterController.h

Colleghiamo ConverterController con l’interfaccia

Siamo pronti per collegare l’interfaccia al nostro Controller, apriamo MainMenu.xib in IB

• Scegliamo menu File > Read Class File e selezioniamo ConverterController.h
• Dal pannello Library prendiamo un Object (Il cubo Blu) e trasciniamolo nella finestra delle istanze MainMenu.xib
• Selezioniamo l’Object e andiamo nell’ispector sull’ultima iconcina quella dell’identity.
• Nel menu a tendina Class selezioniamo ConverterController
• Ora se andiamo sempre nell’ispector sulla penultima iconcina, quella delle connection vedremo i tre Outlets e l’Action che abbiamo definito precedentemente in ControllerConverter.h.

Bene ora dobbiamo collegare gli Outlet di ConverterController con i relativi TextField nella finestra dell’applicazione.

• Selezioniamo l’oggetto ConvertContorller e tenendo premuto il tasto Ctrl  disegnamo una connessione  fino al primo TexField (Exchange Rate x 1€)
• Nel piccolo BlackBox che compare con la lista degli Outlets disponibili selezioniamo rateField.
• Ripetiamo l’operazione per gli altri due TextField selezionando gli opportuni Outlets

Dobbiamo ora collegare il pulsante all’unica azione del nostro Controller

• Selezioniamo nella finestra il Pulsante Convert e  tenendo premuto il tasto Ctrl disegnamo una connessione verso l’oggetto ConverterController.
• Nel BlackBox selezioniamo l’unica azione disponibile convert:

Bene abbiamo creato tutte le connessioni necessaria fra il Controller e la View, salviamo MainMenu.xib. Per controllare se avete eseguito le connessioni correttamente basta che selezionate ConvertCotroller e nell’ispector delle connessioni cliccatte e poi passate il mouse sulle connessioni, i campi collegati si evidenzieranno.

Colleghiamo il Model al Controller

Per collegare il Model al Controller dobbiamo creare un’istanza di questo nel controller. Apriamo quindi di nuovo ConverterController.h e dichiariamo un puntatore alla classe Converter. Come abbiamo gia visto una variabile che deve contenere un’oggetto deve essere per forza un puntatore. Aggiungiamo quindi la seguente variabile tra le parentesi graffe:

Converter *converter;

Dobbiamo inoltre importare il file Converter.h per permettere a ConverterController di creare un’istanza di Converter. Aggiungiamo quindi la direttiva subito sotto l’ultima direttiva #import

#import "converter.h"

Salviamo ConverterController.h e apriamo ConverterController.m per implementare il metodo convert: utilizzando l’oggetto Converter.

Aggiungiamo la definizione del metodo convert: come di seguito:

- (IBAction)convert:(id)sender {
//dichiaro una variabile float interna al metodo
float amount;
//Creo un'istanza di converter
converter = [[Converter alloc]init];
//chiamo il metodo setSourceCurrencyAmount passandogli il valore del TextFiled
//euroField
[converter setSourceCurrencyAmount:[euroField floatValue]];
//chiamo il metodo setRate passandogli il valore di rateField
[converter setRate:[rateField floatValue]];
//utilizzo la variabile di metodo per ottenere la conversione chiamando il
//metodo convertCurrency
amount =   [converter convertCurrency];
//imposto il valore del campo amountField con il valore della variabile di metodo
[amountField setFloatValue:amount];
//torno al primo campo di testo
[rateField selectText:self];
}

Bene la nostra applicazione è in uno stadio finale prima di compilare dobbiamo fare un’ultima cosa.

Garbage Collection

Come avrete notato ogni volta che chiamiamo il metodo convert: attraverso l’istruzione:

converter = [[Converter alloc]init];

creiamo un’istanza di converter riservando nella memoria del mac uno spazio idoneo a contenere l’istanza. Dovremo quindi preoccuparci cancellare questo spazio una volta che l’oggetto ha finito il suo compito, dobbiamo deallocare la memoria. Tuttavia se la vostra applicazione è sviluppata per Mac Os X 10.5 o superiore, possiamo utilizzare una comoda nuova funzionalita di Objective-C 2.0 cioè: Garbage Collection. Utilizzando Garbage Collection non dobbiamo preoccuparci di deallocare gli oggetti che abbiamo istanziato.

Tuttavia Garbage Collection attualmente non è abilitato di default, dobbiamo abilitarlo manualmente.

• In Xcode cliccate sul menu Project > Edit Project Settings
• Cliccate sul tab build
• Nei settings andate nel gruppo GCC 4.2 – Code Generation ed impostate Objective-C Garbage Collection su supported

Sarebbe opportuno studiare meglio questa cosa!

Bene ora siete pronti per compilare e testare Currency Converter cliccando su Build & Run.

Il prossimo appuntamento cercheremo di perfezionare l ‘applicazione e di tradurla in italiano.

Seguendo il tutorial di Apple costruiamo questo piccolo software che permette di convertire il valore di una moneta in un altra attraverso il suo tasso di cambio. Ovviamente trovate il tutorial nella documentazione di xcode in inglese, io qui non faccio una mera traduzione ma seguo il percorso e faccio le mi belle osservazioni. Vi consiglio nel seguire il tutorial di non copiare ed incollare il codice Obj-C ma di scriverlo così da capirlo e memorizzarlo meglio.

Per prima cosa bisogna aprire xcode e creare un nuovo progetto partendo dal menu File > New Project.

Nella finestra che contiene alcuni tipi di progetto pre-impostati scegliete  Cocoa Application, non selezionate alcuna opzione e cliccate sul pulsante choose…

Vi verrà chiesto di salvare il progetto, inserite il nome Currency converter, scegliete una posizione idonea e salvate. Dovreste ora visualizzare una finestra simile a questa in figura.

Schermata - xcode

Il passo successivo e creare l’oggetto Model della nostra applicazione. Come abbiamo visto nell’articolo su MVC, l’oggetto Model rappresenta i dati e le azioni che si posso fare su di essi. Nella programmazione ad oggetti, l’oggetto non è  altro che una istanza di una classe. Dobbiamo quindi creare una nuova classe nel nostro progetto. Per far ciò selezioniamo la cartellina Classes nella colonna di destra della finestra principale di xcode e poi menu File > New file… o semplicemente mela N. Si apre ancora un wizzard che ci permette di scegliere che tipo di file vogliamo aggiungere al nostro progetto.  Scegliamo il modello Objective-C Class nel gruppo cocoa class e scegliamo NSObject nel menu a tendina subclass of. Prossimamente vedremo bene che cosa significa sottoclasse, per ora ci basta sapere che cocoa mette a disposizione una classe padre, NSObject appunto, che fornisce tutto quello che serve per creare e gestire un oggetto nell’ambiente cocoa. Derivando la nostra classe da NSObject, essa erediterà tutte le caratteristiche di NSObject. In Obj-c, nella gerarchia delle classi, può esistere una sola classe padre genitrice di tutte le altre. Benché sia possibile in Cocoa creare una classe padre, di fatto esiste appunto NSObject che svolge questo compito egregiamente rendendo superfluo lo sviluppo di un’altra classe padre. Questo concetto è comunque alla base della programmazione ad oggetti, se non lo conoscete occorre una pausa per capirlo bene legendo un pò di documentazione al riguardo.

Bene clicchiamo su next e nella successiva schermata specifichiamo il nome della nostra classe: Converter. Clicchiamo su Finish, xcode aggiungerà due file nel gruppo Classes: l’interfaccia converter.h e l’implemtazione converter.m . Perché due file? Vediamolo!

In Objective C una classe  è composta da 2 elementi principali:

• Una interfaccia dove vengono dichiarate le variabili, le proprietà e i metodi della classe cioè le funzioni che operano sui dati. L’interfaccia della classe si scrive nel file .h.
• Un’ implementazione, cioè il codice vero e proprio che esegue le azioni sui dati. L’implementazione  della classe si scrive nel file .m

La programmazione ad oggetti ha svariati vantaggi fra questi la possibilità di creare e riutilizzare i singoli oggetti sapendo soltanto cosa essi fanno e non come lo fanno. L’interfaccia serve a proprio a questo, a dirci cosa fa una certa classe! L’implementazione invece ci dice come fa una certa cosa quella classe ma questo nell’utilizzo dell’oggetto è ininfluente. Infatti nel normale utilizzo di un oggetto il suo contenuto rimane incapsulato al suo interno e noi accediamo ai suoi dati attraverso i metodi e le proprietà. Di fatto possiamo utilizzare oggetti implementati da altri senza conoscerne l’implementazione ma soltanto l’interfaccia. Ad esempio, in Cocoa, useremo spesso la Classe NSString che, istanziata, crea un oggetto adatto a manipolare una stringa  senza conoscerne affatto  l’implementazione. Dunque, benché sia possibile scrivere interfaccia e implementazione nello stesso file, è opportuno separarli in due file, .h e. m appunto, per separare i due concetti perché è appunto sufficiente l’interfaccia per conoscere ed usare la classe. Ci sono anche altri vantaggi ma per questi vi rimando a studi più approfonditi sulle classi.

Tornando al nostro tutorial apriamo il file converter.h e iniziamo a scrivere l’interfaccia del nostro oggetto model.

Notiamo che Xcode ha già fatto qualcosa per noi infatti troviamo già il seguente codice:

#import <Cocoa/Cocoa.h>
@interface Converter : NSObject {
}
@end

Come possiamo vedere, poiché abbiamo dichiarato che la nostra classe è figlia di NSObject, xcode ha prontamente inserito la direttiva necessaria per includere le classi Cocoa:

#import <Cocoa/Cocoa.h>

Da notare che la direttiva #import dell’ Ojective-C a differenza di quella #include nel C include il file solo se non è stato già incluso, forte no!

Xcode ha poi dichiarato già la nostra interfaccia attraverso la direttiva @interface, ogni dichiarazione di interfaccia in Objective-C inizia con @interface e finisce con @end

La dichiarazione come vediamo ha  la seguente sintassi:

@interface NomeClasse : ClasseGenitrice { dichiarazione delle variabili }

Il nostro oggetto Model è piuttosto semplice poiché è costituito da un una classe “Converter” da due variabili, una con la cifra da convertire e una con il tasso di cambio, entrambe di tipo float e da un solo metodo convertCurrency che moltiplica la cifra da convertire per il tasso di cambio e torna il risultato.

Per prima cosa dichiariamo le due variabili, tale dichiarazione va fatta all’interno delle parentesi graffe!

float sourceCurrencyAmmount, rate;

Come vedete uso gli stessi nomi del tutorial sulla documentazione Apple, così da poter confrontare e approfondire con la documentazione originale. Il nostro Converter.h si presenta così ora:

#import <Cocoa/Cocoa.h>
@interface Converter : NSObject {
float sourceCurrencyAmount, rate;
}
@end

Le variabili dichiarate all’interno di una classe sono private, cioè sono utilizzabili solo dal codice all’interno della stessa. E’ necessario quindi definire dei metodi per poter accedere a queste variabili dall’esterno. Questi metodi sono i così detti getter e setter. In Obj-c 2.0 esiste una scorciatoia per definire tali metodi: dichiarare delle Property. Dichiarando una proprietà il compilatore creerà automaticamente il metodi getter e setter per quella proprietà. Una proprietà si dichiara così:

@property(attributi) Tipo listaNomiVariabili;

Gli attributi definisco il modo in cui si può accedere alla proprietà, essi possono essere readwrite, readonly, copy etc, vi consiglio di vedere la guida The Objective-C 2.0 Programming Language. Per ora ci basti sapere che senza specificare gli attributi, o specificando soltanto l’attributo readwrite il compilatore creerà soltanto i metodi getter e setter utilizzando i nomi nomeProperty per il getter e setNomeProperty per il setter.

Poiché vogliamo accedere alle nostre variabili dichiariamo due property, tale dichiarazione va fatta subito dopo la chiusura delle parentesi graffe.

@property(readwrite) float sourceCurrencyAmount, rate;

Con questa dichiarazione abbiamo di fatto dichiarato anche metodi

- (float)sourceCurrencyAmount;
- (void)setSourceCurrencyAmount:(float)newSourceCurrencyAmount;
- (float)rate;
- (void)setRate:(float)newRate;

Bel risparmio no! con una riga s’è scritto l’equivalente di 4!

Se vi state chiedendo come si dichiara un metodo vi accontento subito dichiarando l’unico metodo della nostra classe

- (float) convertCurrency;

Tale dichiarazione va inserita subito dopo quella delle proprietà, come vedete la dichiarazione dei metodi deve iniziare con un segno – seguita dal tipo restituito tra parentesi tonde e dal nome del metodo.

- (tipoRestituito) nomeMetodo

Il segno meno è obbligatorio ed indica che il metodo è un metodo di istanza, cioè un metodo che può essere chiamato su una istanza (oggetto) della classe. I metodi di classe invece vengono dichiarati con il segno +, questi sono metodi che vengono eseguiti dalla classe prima che questa venga istanziata. Un esempio di metodo di classe potrebbe essere il metodo che si occupa di riservare la porzione di memoria idonea a contenere il nostro oggetto. Se vi state chiedendo se la nostra classe ha bisogno di questi metodi la risposta è certamente si tuttavia non abbiamo bisogno di dichiarali a quanto pare. Non ne sono ancora sicuro al momento ma secondo me c’entra NSObject!!!

La dichiarazione del metodo prosegue con il tipo restituito messo tra parentesi tonde e il nome del metodo. Se un metodo non restituisce nulla occorre specificare void come tipo restituito.

Con la dichiarazione del metodo la nostra interfaccia è completa e dovrebbe mostrarsi così:

#import <Cocoa/Cocoa.h>

@interface Converter : NSObject {
//dichiarazione delle variabili
float sourceCurrencyAmount, rate;
}

//dichiarazione delle proprietà
@property(readwrite) float sourceCurrencyAmount, rate;

//dichiarazione dei metodi
- (float) convertCurrency;
@end

possiamo salvare il file Converter.h e passare all’implementazione della classe nel file Converter.m

Anche in questo caso Xcode ha già fatto qualcosa per noi come vedete il file converter.m si presenta così:

#import "Converter.h"
@implementation Converter

@end

Questo ci fa capire subito alcune cose, nel file .m è necessario importare il relativo file .h (mi sembra ovvio ma è meglio ripeterlo), similmente all’interfaccia anche l’implementazione incomincia con la direttiva

@implementation NomeClasse

e termina con la direttiva

@end

Tutto il codice di implementazione va inserito fra queste due direttive.

La prima cosa da fare è istruire il compilatore sulle due property che abbiamo dichiarato. L’ istruzione:

@synthesize listaNomiPorpertys

dice al compilatore di creare i metodi getter and setter per le proprietà specificate quindi:

@synthesize sourceCurrencyAmount, rate;

Anche in questo caso il risparmio di codice è notevole non dovendo implementare ben 4 metodi. L’istruzione @synthesize creerà questi metodi soltanto se non sono stati implementati, questo significa che se abbiamo esigenze d’ implementazione particolari per uno dei metodi getter e setter possiamo sempre farlo manualmente anche se abbiamo dichiarato la variabile come property!

Dobbiamo ora implementare il metodo convertCurrency che abbiamo dichiarato:

- (float) convertCurrency {
//il metodo ritorna la moltiplicazione delle due variabili
return self.sourceCurrencyAmount * self.rate;
}

Come vedete il metodo è semplicissimo, notiamo l’uso di self che in sostanza indica di utilizzare il valore della variabile interna all’oggetto. L’istruzione return ritorna il valore della moltiplicazione alla sua destra.

Il mio converter.m si mostra esattamente così:

#import "Converter.h"

@implementation Converter

//implemento le property
@synthesize sourceCurrencyAmmount, rate;

//implemento currencyConvert
- (void) currencyConvert {
return self.sourceCurrencyAmmount * self.rate;
}

@end

Ok si conclude qui la prima parte del tutorial, nella seconda ci occuperemo di creare l’interfaccia grafica con interface builder e di collegarla alla nostra classe. Chiedo scusa per le eventuali imprecisioni e/o omissioni, accetto ben volentieri correzioni, critiche e consigli e tenete presente che questi sono perlopiù appunti che sto prendendo io nello studio di cocoa che non hanno la pretesa di insegnare qualcosa a qualcuno.

Ciao

Con questo articolo parte una mini serie dedicata allo studio dell’ambiente di sviluppo per Mac Os X e iPhone os che sto iniziando ad intraprendere in questi giorni. Man mano che vado avanti farò il resoconto di quello che ho studiato. Anche perché questo è uno dei metodi migliori per imparare. Fermo restando che non sono completamente a digiuno di objective-c, in questo articolo vedremo il tutorial proposto dalla Apple: The Essence of Cocoa. Ovviamente man mano che andrò avanti cercherò di approfondire e capire i vari aspetti anche del linguaggio Obj-c.

MVC o Model View Controller è lo schema di progettazione principale dell’ambiente di sviluppo cocoa, esso deriva da smalltalk-80. Questo schema propone tre tipi di oggetti in una applicazione, separati da limiti astratti e allo stesso tempo collegati fra loro proprio attraverso questi limiti. La figura chiarisce meglio il concetto.

Fig. 01 - Schema Model-View-Controller

L’oggetto Model

Gli oggetti di tipo Model contengono i dati e le operazioni che si possono svolgere su questi. Ad esempio in una applicazione gestionale supponiamo di avere un oggetto “Clienti” che contiene i dati relativi ai clienti come ad esempio il loro nome. Ecco questo è uno oggetto Model perchè contiene i dati di ciò che rappresenta e i metodi per accedere agli stessi.

L’oggetto View

L’oggetto View rappresenta l’interfaccia grafica con cui vengono presentati i dai all’utente. Normalmente l’oggetto View non conosce la fonte dei dati che rappresenta sullo schermo. L’Application Kit che è uno dei framework che compongono l’ambiente cocoa contiene numerosi oggetti comuni per le viste come finestre, pulsanti, barre di progressione etc. E’ comunque sempre possibile costruirne di personalizzati.

L’oggetto  Controller

Questo oggetto esplica una mediazione fra l’oggetto Model e l’oggetto View, praticamente mette in comunicazione gli altri due trasferendo le informazioni. Ad esempio può mostrare il nome di un cliente  in uno specifico campo di testo nella finestra dell’applicazione.

Lo schema MVC, se bene possa essere alla base di molte applicazioni non deve essere necessariamente seguito alla lettera. In alcuni casi particolari come  per esempio applicazioni molto semplici e possibile inserire il controller nel model.

Ho trattato prima di tutto questo argomento perché seguendo i tutorial proposti da Apple vi troverete difronte a questo schema quasi sempre. In effetti solo dopo aver letto la documentazione su MVC ho capito meglio alcuni passaggi.

Il prossimo articolo vedremo il tutorial sul currency converter.