1. Scaricate l’archivio dal sito del progetto
2. Estraetelo
3. Da Terminal navigate fino alla cartella appena estratta
4. Eseguite il comando sudo python setup.py install

A questo punto l’installazione dovrebbe essere terminata. Per testare il funzionamento del framework sempre da Terminal:

1. Aprite la console interattiva di Python digitando python
2. Importate Django tramite il comando import django
3. Eseguite django.VERSION
4. Se l’installazione è andata a buon fine dovreste ottenere qualcosa di simile a (1, 1, 1, 'final', 0) in base alla versione scaricata

• Mac OS X 10.5.4 o superiore
• Xcode 3.0 installato^[1]
• 5 GB di spazio su disco
• Almeno 1 GB di RAM

Per installare Oracle è necessario creare un nuovo utente ed un gruppo dedicati. Supponendo di voler utilizzare GUI e UID 4200, assicuriamoci che siano disponibili digitando dal terminale:

dscl . -list /groups gid | grep 4200
dscl . -list /users uid | grep 4200

A questo punto creiamo gruppo ed utente digitando:

sudo dscl . -create /groups/dba
sudo dscl . -append /groups/dba gid 4200
sudo dscl . -append /groups/dba passwd "*"
sudo dscl . -create /users/oracle
sudo dscl . -append /users/oracle uid 4200
sudo dscl . -append /users/oracle gid 4200
sudo dscl . -append /users/oracle shell /bin/bash
sudo dscl . -append /users/oracle home /Users/oracle
sudo dscl . -append /users/oracle realname "Oracle software owner"
sudo mkdir /Users/oracle
sudo chown oracle:dba /Users/oracle
sudo defaults write /Library/Preferences/com.apple.loginwindow HiddenUsersList -array-add oracle
sudo passwd oracle

Ora è necessario modificare alcuni parametri del kernel aggiungendo al file /etc/sysctl.conf queste righe:

kern.sysv.shmall=2097152
kern.sysv.shmmni=4096
kern.maxproc=1024
kern.maxprocperuid=512

Riavviamo e controlliamo che i parametri siano impostati correttamente:

sysctl kern.sysv.shmall # 2097152
sysctl kern.sysv.shmmni # 4096
sysctl kern.maxproc # 1024
sysctl kern.maxprocperuid # 512

Ora creiamo il file ~/.bash_profile nella home dell’utente oracle con il seguente contenuto:

# Deve corrispondere a kern.maxprocperuid
ulimit -Hu 512
ulimit -Su 512
# Deve corrispondere a kern.maxfilesperproc
ulimit -Hn 10240
ulimit -Sn 10240
 
export ORACLE_BASE=/Users/oracle
export ORACLE_HOME=$ORACLE_BASE/product/10.2.0/db_1
export DYLD_LIBRARY_PATH=$ORACLE_HOME/lib
export ORACLE_SID=mac10g
PATH=$PATH:/$ORACLE_HOME/bin

A questo punto ci autentichiamo come utente “oracle” tramite il comando “su – oracle” e digitiamo:

export DISPLAY=localhost:0
export ORACLE_HOSTNAME=localhost

Abbiamo terminato la configurazione del sistema. Ora non ci resta che eseguire l’installer. Supponendo di aver scaricato Oracle 10G e di aver scompattato l’archivio nella home dell’utente “oracle”, basterà digitare il comando:

/Users/oracle/db/Disk1/runInstaller

Dopo aver seguito i semplici passi dell’Oracle Universal Installer, Oracle 10G sarà correttamente installato sul nostro mac!

1. Potete trovarlo nel DVD di installazione di Mac OS X

Le lezioni sono tenute da ingegneri Apple e sono disponibili in formato video della durata di circa un’ora ciascuna. E’ possibile scaricare anche le slide delle lezioni in formato PDF.

Per chi fosse interessato a seguire il corso ci sono due link fondamentali:

• Il podcast su iTunes U
• Il sito del corso

1. iTunes U è una sezione dell’iTunes Store interamente dedicata agli studenti nella quale è possibile trovare lezioni gratuite su diversi argomenti sotto forma di podcast.

AsyncSocket è un framework che consente l’utilizzo asincrono delle socket tramite l’uso dei delegati. Ecco le sue caratteristiche:

• Protocolli supportati: TCP
• Buffered I/O: Si
• I/O Asincrono: Si, tramite i delegati (opzionali)
• Documentazione: Si

Dalla versione 4.3 AsyncSocket non è più stato aggiornato da Dustin Voss, in compenso però i programmatori di Deusty stanno portando avanti lo sviluppo del framework.

Il progetto è disponibile su Google Code sotto licenza MIT ed ora supporta anche il protocollo UDP.

Link utili

• AsyncSocket homepage
• AsyncSocket su Google Code

Innanizitutto è necessario installare xCode dal DVD di Leopard. A questo punto possiamo passare al download dell’ultima versione di sviluppo di Django tramite Subversion. Creiamo quindi la directory che la conterrà:

sudo mkdir /usr/local/
sudo mkdir /usr/local/django
cd /usr/local/django

E scarichiamo Django:

sudo svn co http://code.djangoproject.com/svn/django/trunk/

Ora dobbiamo far sapere a Python dove si trova Django:

ln -s /usr/local/django/trunk/django /Library/Python/2.5/site-packages/django

e copiare lo script django-admin.py nel nostro path di sistema:

sudo mkdir /usr/local/bin/
sudo ln -s /usr/local/django/trunk/django/bin/django-admin.py /usr/local/bin/

A questo punto l’installazione è terminata e Django dovrebbe essere pronto all’uso. Per testarlo creiamo un nuovo progetto ed eseguiamolo in locale:

django-admin.py startproject nome
cd nome
python manage.py runserver

Ora verifichiamo se tutto funziona correttamente all’indirizzo localhost:8000.

Objective-C è il linguaggio maggiormente usato per scrivere software in ambiente Mac. Se avete già delle conoscenze sulla programmazione orientata ad oggetti e sulla sintassi del linguaggio C allora imparare Objective-C sarà un passo semplice per voi. Altrimenti sarebbe meglio approfondire prima i concetti riguardanti la OOP e il linguaggio C.

Invocare i metodi

Per cominciare più in fretta possibile, guardiamo alcuni esempi di codice. La sintassi di base per richiamare un metodo appartenente ad un oggetto è la seguente:

[object method];
[object methodWithInput:input];

Ovviamente i metodi possono restituire dei valori nel seguente modo:

output = [object methodWithOutput];
output = [object methodWithInputAndOutput:input];

E’ possibile richiamare anche dei metodi appartenenti alle classi, che tra l’altro è il modo in cui queste vengono istanziate. Nell’esempio di seguito invochiamo un metodo della classe NSString che ci restituisce una istanza della classe stessa:

id myObject = [NSString string];

Il tipo id può contenere un oggetto di qualsiasi tipo. Questo rende possibile scrivere codice in modo dinamico senza sapere a priori cosa una determinata variabile conterrà in runtime.

In questo esempio la variabile conterrà una stringa quindi possiamo anche modificare il suo tipo in NSString:

NSString* myString = [NSString string];

In questo modo ora il compilatore potrà avvisarci se cercheremo di usare un metodo su questo oggetto che non supporta la classe NSString.

Da notare che di seguito al tipo dell’oggetto c’è un asterico. Tutti gli oggetti in Objective-C sono di tipo puntatore. Per il tipo id invece, che è di default un tipo puntatore, non va specificato l’asterisco.

Messaggi annidati

Nella maggior parte dei linguaggi la chiamata di metodi o funzioni annidati appare in questo modo:

function1 (function2());

Il risultato di function2 viene passato in input a function1. In Objective-C i messaggi annidati funzionano in questo modo:

[NSString stringWithFormat:[prefs format]];

Annidare più di due messaggi in una singola istruzione va evitato perchè riduce la leggibilità del codice stesso.

Metodi con input multiplo

Alcuni metodi prendono in input più di un valore. In Objective-C, il nome di un metodo può essere scomposto in più parti. L’intestazione di un metodo con più valori in input quindi apparirà così:

- (BOOL)writeToFile:(NSString *)path atomically:(BOOL)useAuxiliaryFile;

Il metodo verrà poi chiamato in questo modo:

BOOL result = [myData writeToFile:@"/tmp/log.txt" atomically:NO];

Il nome del metodo sarà quindi writeToFile:atomically.

Variabili private

Tutte le variabili di istanza sono private per default in Objective-C, quindi è necessario utilizzare gli accessor per prelevare il loro valore.

Ecco la sintassi per Objective-C 1.x:

[photo setCaption:@"Day at the Beach"];
output = [photo caption];

Da notare che nella seconda riga non si sta accedendo direttamente alla variabile caption, ma si sta chiamando un metodo get con quel nome. In molti casi infatti non viene aggiunto il prefisso get per i getter in Objective-C.

Con Mac OS X 10.5 e Objective-C 2.0 è stata introdotta la sintassi puntata per i getter e i setter. Ad esempio:

photo.caption = @"Day at the Beach";
output = photo.caption;

E’ possibile utilizzare entrambi gli stili ma è preferibile sceglierne uno. Inoltre la notazione puntata dovrebbe essere utilizzata solamente per i metodi setter e getter e non per tutti gli altri metodi.

Creare gli oggetti

Ci sono due modi per creare un oggetto. Il primo è quello visto in precedenza:

NSString* myString = [NSString string];

L’altro invece, che vedremo in dettaglio più tardi, è questo:

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

Questa è una chiamata annidata di metodi. Il primo è alloc che appartiene a NSString ed è un metodo di basso livello che riserva la memoria e istanzia l’oggetto.

Il secondo metodo invece, init, inizializza il nuovo oggetto. Di solito questo metodo è utilizzato per creare le variabili istanza della classe.

In alcuni casi è necessario utilizzare una versione con input del metodo init:

NSNumber* value = [[NSNumber alloc] initWithFloat:1.0];

Gestione della memoria

Quando si sviluppano applicazioni per OS X si può attivare il garbage collector. Questo vuol dire che non è necessario pensare alla gestione della memoria tranne in alcuni casi particolari.

Comunque non è detto che ci si troverà sempre a sviluppare applicazioni in un ambiente che supporta il garbage collector e in questi casi sarà fondamentale conoscere alcuni concetti di base.

Quando creiamo un oggetto attraverso l’allocazione manuale sarà anche necessario rilasciare l’oggetto. E’ inoltre necessario stare attenti a non cercare di rilasciare un oggetto già rilasciato in automatico perchè causeremmo il crash dell’applicazione.

Di seguito due esempi:

// string1 verrà rilasciata automaticamente
NSString* string1 = [NSString string];
 
// string2 viene incece rilasciata manualmente
NSString* string2 = [[NSString alloc] init];
[string2 release];

Ci sono ovviamente altre cose da sapere sulla gestione della memoria ma le vedremo dopo aver spiegato altri concetti.

Creare una Class Interface

La sintassi dell’Objective-C per creare delle nuove classi è molto semplice e si divide in due parti.

L’interfaccia della classe è situata nel file NomeDellaClasse.h e definisce le variabili d’istanza e i metodi pubblici della stessa.

L’implementazione invece viene scritta nel file NomeDellaClasse.m che contiene il codice per i metodi. Inoltre in questo file vengono definiti metodi privati che non saranno visibili all’esterno della classe.

Ecco un esempio di interfaccia di una classe. La classe si chiama Photo quindi l’interfaccia si troverà nel file Photo.h:

#import
 
@interface Photo : NSObject {
    NSString* caption;
    NSString* photographer;
}
@end

Prima di tutto importiamo Cocoa.h per avere a disposizione le classi base del framework Cocoa. La direttiva #import garantisce che uno stesso file non venga importato più volte.

@interface serve invece ad indicare che si sta dichiarando una classe. I due punti invece specificano la superclasse che in questo caso è NSObject.

All’interno delle parentesi graffe abbiamo poi due variabili d’istanza: caption e photographer. Entrambe sono di tipo NSString ma potrebbero essere di qualsiasi altro tipo incluso id.

Infine abbiamo @end che chiude la dichiarazione della classe.

Aggiungere metodi

Ora andiamo ad aggiungere due metodi getter per le variabili.

#import
 
@interface Photo : NSObject {
    NSString* caption;
    NSString* photographer;
}
 
- caption;
- photographer;
@end

Ricordatevi che in Objective-C i metodi non includono il prefisso get. Il simbolo “-” prima del metodo indica che si tratta di metodi d’istanza. Il segno “+” invece è usato per i metodi di classe.

Per default il compilatore assume che il metodo ritorni un oggetto di tipo id e che tutti i valori in input siano di tipo id. Il codice visto sopra è quindi corretto ma è sicuramente inusuale. Aggiungiamo quindi un tipo specifico come valore di ritorno dei nostri metodi.

#import
 
@interface Photo : NSObject {
    NSString* caption;
    NSString* photographer;
}
 
- (NSString*) caption;
- (NSString*) photographer;
@end

Ora aggiungiamo invece i metodi setter.

#import
 
@interface Photo : NSObject {
    NSString* caption;
    NSString* photographer;
}
 
- (NSString*) caption;
- (NSString*) photographer;
- (void) setCaption: (NSString*)input;
- (void) setPhotographer: (NSString*)input;
@end

Questi metodi non neccessitano di restituire un valore quindi li dichiareremo di tipo void.

Implementare l’interfaccia di una classe

Vediamo ora la parte implementativa della classe a partire dai metodi getter.

#import "Photo.h"
 
@implementation Photo
 
- (NSString*) caption {
    return caption;
}
 
- (NSString*) photographer {
    return photographer;
}
 
@end

Questa parte di codice inizia con @implementation seguito dal nome della classe e finisce con @end come per l’interfaccia. Tutti i metodi dovranno apparire tra queste due righe.

I metodi getter presenti nel codice dell’esempio saranno molto familiari a chiunque abbia mai scritto del codice. Possiamo quindi passare ai setter che necessitano di qualche spiegazione in più.

- (void) setCaption: (NSString*)input {
    [caption autorelease];
    caption = [input retain];
}
 
- (void) setPhotographer: (NSString*)input {
    [photographer autorelease];
    photographer = [input retain];
}

Ognuno dei due metodi lavora su due variabili. La prima è un rigerimento all’oggetto esistente mentre la seconda è un oggetto passato in input.

In un ambiente che supporti il garbage collector potremmo semplicemente assegnare il nuovo valore:

- (void) setCaption: (NSString*)input {
    caption = input;
}

Se però non disponiamo di un garbage collector dobbiamo rilasciare l’oggetto e possiamo farlo in due modi: con release e con autorelease. Con release l’oggetto verrà rilasciato immediatamente mentre con autorelease l’oggetto verrà rilasciato non appena il metodo corrente termina.

Il metodo autorelease è più sicuro nei metodi setter. Potremmo infatti accidentalmente rilasciare un oggetto che avremmo poi dovuto restituire.

Probabilmente ora sarete un po confusi ma andando avanti tutto sarà più chiaro. Non è necessario aver capito tutto sino ad ora.

Il metodo init

Per la nostra classe potremmo prevedere un metodo init che imposti i valori iniziali alle variabili d’istanza:

- (id) init {
    if ( self = [super init] ) {
        [self setCaption:@"Default Caption"];
        [self setPhotographer:@"Default Photographer"];
    }
 
    return self;
}

L’unica istruzione che potrebbe richiedere delle spiegazioni in questo codice è la seconda nella quale viene assegnato a self il risultato di [super init].

Questo serve solamente a chiedere alla superclasse di effettuare le inizializzazioni necessarie. L’if è necessario per controllare che l’inizializzazione sia avvenuta con successo.

Il metodo dealloc

Il metodo dealloc è chiamato quando un oggetto è rimosso dalla memoria. Questo è sicuramente il momento migliore per rilasciare tutte le variabili d’istanza presenti nella classe:

- (void) dealloc {
    [caption release];
    [photographer release];
    [super dealloc];
}

Nelle prime due istruzioni richiamiamo i metodi release delle due variabili. In questo caso possiamo utilizzare release invece che autorelease per quadagnare un po di velocità.

L’ultima riga è invece molto importante. Questa infatti chiede alla superclasse di effettuare le deallocazioni del caso. Se non chiamiamo questo metodo l’oggetto non potrà essere rilasciato.

Se è attivo il garbage collector non sarà richiamato il metodo dealloc ma il metodo finalize.

Ulteriori cenni alla gestione della memoria

Il sistema di gestione della memoria di Objective-C è basato sul conteggio dei riferimenti agli oggetti.

In parole semplici effettuiamo una alloc su un oggetto, poi probabilmente effettueremo una retain e successivamente una release per ogni chiamata ad alloc o retain effettuata. Quindi se abbiamo effettuato una sola alloc e una sola retain dovremo effettuare due release.

Probabilmente una immagine potrà chiarire il concetto:

Questa è la teoria alla base del reference counting. Nella pratica però ci sono solamente due ragioni per le quali creare un oggetto:

1. Per conservarlo in una variabile d’istanza
2. Per usarlo temporaneamente all’interno di una funzione

Nella maggior parte dei casi i setter per una variabile d’istanza dovrebbero effettuare una release del vecchio oggetto e ritornarne uno nuovo. Bisogna quindi assicurarsi di rilasciarlo in dealloc.

Quindi in conclusione l’unica cosa che il programmatore deve fare è gestire i riferimenti locali all’interno delle funzioni. E la regola è questa: se abbiamo creato un oggetto con alloc o copy allora dobbiamo effettuare una release o una autorelease alla fine della funzione, altrimento non c’è nient’altro da fare.

Questo è il primo caso:

- (void) setTotalAmount: (NSNumber*)input {
    [totalAmount autorelease];
    totalAmount = [input retain];
}
 
- (void) dealloc {
    [totalAmount release];
    [super dealloc];
}

Questo è invece il secondo caso:

NSNumber* value1 = [[NSNumber alloc] initWithFloat:8.75];
NSNumber* value2 = [NSNumber numberWithFloat:14.78];
 
// rilasciamo solamente value1 e non value2
[value1 release];

Ed ecco invece una combinazione dei due casi precedenti:

NSNumber* value1 = [[NSNumber alloc] initWithFloat:8.75];
[self setTotal:value1];
 
NSNumber* value2 = [NSNumber numberWithFloat:14.78];
[self setTotal:value2];
 
[value1 release];

Se avete capito questi concetti, avete chiaro il 90% di quello che c’è da sapere sulla gestione della memoria in Objective-C.

NSLog

Loggare messaggi in console con Objective-C è molto semplice. Abbiamo infatti a disposizione la funzione NSLog() che è molto simile alla printf() del c eccetto per il token %@ che permette di stampare oggetti.

NSLog(@"The current date and time is: %@", [NSDate date]);

Come accennato prima è possibile stampare degli oggetti. NSLog chiama il metodo description dell’oggetto e stampa l’NSString ritornata. Questo metodo può essere anche sovrascritto nelle nostre classi per restituire una stringa personalizzata.

Le proprietà

Quando abbiamo scritto i metodi per accedere a caption e author avrete sicuramente notato che il codice usato è ripetitivo e può essere generalizzato.

Le proprietà sono una caratteristica di Objective-C che permette di generare automaticamente i metodi per l’accesso alle variabili e che forniscono anche altri benefici. Modifichiamo quindi la classe Photo per l’utilizzo delle proprietà.

Ecco come appariva il codice in precedenza:

#import
 
@interface Photo : NSObject {
    NSString* caption;
    NSString* photographer;
}
 
- (NSString*) caption;
- (NSString*) photographer;
- (void) setCaption: (NSString*)input;
- (void) setPhotographer: (NSString*)input;
@end

Ed ecco come appare ora:

#import
 
@interface Photo : NSObject {
    NSString* caption;
    NSString* photographer;
}
 
@property (retain) NSString* caption;
@property (retain) NSString* photographer;
 
@end

La direttiva @property dichiara le proprietà. Il retain racchiuso nelle parentesi invece indica che i setter devono restituire il valore in input. Il resto della dichiarazione delle proprietà invece indica il nome e il tipo delle proprietà.

Vediamo invece come dorvà essere scritto il file di implementazione:

#import "Photo.h"
 
@implementation Photo
 
@synthesize caption;
@synthesize photographer;
 
- (void) dealloc {
    [caption release];
    [photographer release];
    [super dealloc];
}
 
@end

La direttiva @synthesize genera automaticamente getter e setter per noi quindi dovremo solamente implementare il metodo dealloc.

I metodi per l’accesso alle variabili vengono generati solamente se non sono già esistenti, quindi possiamo anche specificare la direttiva @synthesize per una proprietà, per poi implementarla a mano. Il compilatore completerà l’implementazione con i soli metodi mancanti.

Ci sono altre opzioni nell’uso delle proprietà ma non fanno parte dello scopo di questo tutorial.

L’oggetto nil

In Objective-C l’oggetto nil è l’ecquivalente di NULL per gli altri linguaggi. La differenza sta nel fatto che su possono chiamare metodi su oggetti nil senza causare crash o sollevare eccezioni.

Questa tecnica è usta nei frameworks in diverse occasioni.

Possiamo anche utilizzarla per migliorare il nostro metodo dealloc:

- (void) dealloc {
    self.caption = nil;
    self.photographer = nil;
    [super dealloc];
}

Questo è possibile perchè quando impostiamo una variabile a nil il setter ritorna come valore nil e rilascia il vecchio valore. Questo approccio a volte è preferibile perchè non c’è possibilità per la variabile rilasciata di puntare ad un indirizzo casuale che appartiene ad un altro oggetto.

Notate che nel codice precedente viene usato self il che vuol dire che il setter sarà chiamato automaticamente.

Se avessimo scritto il codice in questo modo invece avremmo avuto un errore:

// sbagliato. provoca una violazione di memoria
// usate self.caption per passare attraverso il setter
caption = nil;

Le categorie

Le categorie sono una delle funzioni di Objective-C più utili. Essenzialmente una categoria permette di aggiungere metodi ad una classe preesistente senza ereditarla.

Questo è particolarmente utile perchè offre la possibilità di aggiungere metodi ad oggetti compilati. Se ad esempio volessimo aggiungere un metodo ad una istanza della classe NSString possiamo farlo aggiungendo una categoria.

Per esempio supponiamo di voler aggiungere un metodo ad NSString per determinare se contiene un URL. Ecco il codice:

#import
 
@interface NSString (Utilities)
- (BOOL) isURL;
@end

Come potete vedere è molto simile alla dichiarazione di una classe. Le differenze sono nel fatto che non c’è una superclasse e al suo posto c’è il nome della categoria tra parentesi.

Ecco invece l’implementazione. Tenete presente però che questo non è il modo migliore per riconoscere un URL! Quello che importa è spiegare il concetto di categoria:

#import "NSString-Utilities.h"
 
@implementation NSString (Utilities)
 
- (BOOL) isURL {
    if ([self hasPrefix:@"http://"])
        return YES;
    else
        return NO;
}
 
@end

Ora potremo usare questo metodo su una qualsiasi NSString. Il codice seguente stamperà “string1 è una stringa” in console:

NSString* string1 = @"http://pixar.com/";
NSString* string2 = @"Pixar";
 
if ([string1 isURL])
    NSLog (@"string1 is a URL");
 
if ( [string2 isURL] )
    NSLog (@"string2 is a URL");

A differenza delle sottoclassi, le categorie non possono aggiungere variabili d’istanza. E’ invece possibile sovrascrivere metodi già esistenti nella classe, anche se questo deve essere fatto con molta attenzione.

Ricordate quando fate delle modifiche ad una classe usando una categoria che queste saranno applicate a tutte le istanze di quella classe nell’applicazione.

Conclusioni

Questa guida è una mia traduzione dell’articolo originale in lingua inglese.

Le toolbar sono ormai presenti nella maggior parte delle applicazioni e offrono la possibilità di effettuare rapidamente le funzioni più utilizzate in una applicazione. In Cocoa la loro implementazione è relativamente facile.

Creiamo l’interfaccia

Dopo aver creato un progetto di tipo Cocoa Application apriamo il file MainMenu.nib per editarlo. L’unica modifica da effettuare sull’interfaccia grafica consiste nell’aggiungere due voci di menu che permetteranno di mostrare o nascondere la toolbar e di modificarne i suoi elementi.

Fatto ciò creiamo una classe controller che conterrà un solo IBOutlet per la finestra principale dell’applicazione. Creiamo quindi l’IBOutlet che può essere dichiarato staticamente di tipo NSWindow e connettiamolo alla finestra. Ora dovranno essere create due IBAction: una per ognuna delle due voci di menu aggiunte. Una volta create connettiamole alle corrispondenti voci di menu.

L’ultimo passo da effettuare in Interface Builder è quella di impostare il delegato di File’s Owner. Per fare ciò, connettiamo File’s Owner alla classe controller da noi creata.

Questo è tutto quello che va fatto in Interface Builder. A questo punto possiamo esportare la classe controller e tornare ad XCode.

I delegati

Quando si aggiunge una toolbar ad un progetto, è necessario implementare dei metodi delegati di NSToolbar. Ci sono tre metodi obbligatori e due opzionali.

I delegati da implementare obbligatoriamente sono:

- (NSToolbarItem *)toolbar:(NSToolbar *)toolbar itemForItemIdentifier:(NSString *)itemIdentifier willBeInsertedIntoToolbar:(BOOL)flag
- (NSArray *)toolbarAllowedItemIdentifiers:(NSToolbar*)toolbar
- (NSArray *)toolbarDefaultItemIdentifiers:(NSToolbar*)toolbar

Mentre i delegati opzionali sono:

- (void)toolbarWillAddItem:(NSNotification *)notification
- (void)toolbarDidRemoveItem:(NSNotification *)notification

Ma analizziamoli separatamente assieme ad un esempio di implementazione.

- (NSToolbarItem *)toolbar:(NSToolbar *)toolbar itemForItemIdentifier:(NSString *)itemIdentifier willBeInsertedIntoToolbar:(BOOL)flag
{
    return [items objectForKey:itemIdentifier];
}

Questo metodo restituisce un NSToolbarItem per l’identificatore passato in input. L’item può essere creato nel metodo o come nell’esempio riportato può essere prelevato da una struttura dati. Questo delegato viene richiamato quando la toolbar viene costruita o quando le viene aggiunto un item.

Dato che gli item della nostra toolbar sono contenuti in un NSDictionary dobbiamo semplicemente restituire l’item nel dizionario corrispondente all’identificatore dato in input.

- (NSArray *)toolbarAllowedItemIdentifiers:(NSToolbar*)toolbar
{
    return [items allKeys];
}

Questo metodo restituisce un array che contiene l’identificatore di ciascun item che è impostato come visibile nella toolbar inclusi i separatori o gli spazi.

Restituiamo un array di chiavi che corrisponde all’insieme degli item contenuti nel dizionario.

- (NSArray *)toolbarDefaultItemIdentifiers:(NSToolbar*)toolbar
{
    return [[items allKeys] subarrayWithRange:NSMakeRange(0,6)];
}

Questo metodo restituisce un array di identificatori per gli item che faranno parte del set di default della toolbar. Nel codice di esempio impostiamo i primi sei elementi dell’array come il set di default.

- (void) toolbarWillAddItem: (NSNotification *) notification
{
    NSToolbarItem *addedItem = [[notification userInfo] objectForKey:@"item"];
 
    // effettuare le operazioni necessarie sull'item
}

Questo delegato è chiamato prima che un item venga aggiunto alla toolbar. Dobbiamo quindi usarlo se abbiamo la necessità di effettuare una inizializzazione specifica dell’item.

- (void)toolbarDidRemoveItem:(NSNotification *)notification
{
    NSToolbarItem *addedItem = [[notification userInfo] objectForKey:@"item"];
 
    // pulire le informazioni correlate all'item
}

Questo delegato è chiamato subito dopo che un item è stato rimosso dalla toolbar. Va quindi usato per rimuovere qualsiasi dato riguardante l’item e che quindi non è più necessario.

Mostrare la toolbar

Ora che abbiamo implementato i delegati dobbiamo creare una istanza della classe NSToolbar. Questo può essere fatto nell’evento awakeFromNin o in windowControllerDidLoadNib nel caso di una applicazione document based. Siccome però ci troviamo in una applicazione Cocoa dobbiamo collegare l’istanza della toolbar nel metodo awakeFromNib.

La prima cosa da fare è creare una istanza di NSToolbar. L’identificatore della toolbar dovrà essere unico perchè tutte le toolbar con uno stesso identificatore saranno sincronizzate nel nostro programma. Quindi quando una toolbar viene personalizzate in una finestra tutte le altre che ne condividono l’identificatore subiranno le stesse modifiche.

toolbar = [[NSToolbar alloc] initWithIdentifier:@"tooltest"];

Dopodichè impostiamo alcune proprietà della toolbar:

[toolbar setDelegate:self];
[toolbar setAllowsUserCustomization:YES];
[toolbar setAutosavesConfiguration:YES];

La prima proprietà imposta il delegato della toolbar ed indica che i metodi delegati si trovano nella classe controller. Successivamente la toolbar viene impostata come personalizzabile e viene impostato il salvataggio automatico delle modifiche.

Ora dobbiamo collegate la toolbar alla finestra della nostra applicazione:

[window setToolbar:toolbar];

Un’altra proprietà che avremmo potuto impostare è:

- (void)setDisplayMode:(NSToolbarDisplayMode)displayMode

che può essere impostata ad uno di questi valori:

NSToolbarDisplayModeIconAndLabel
NSToolbarDisplayModeIconOnly
NSToolbarDisplayModeLabelOnly

Mostrare e personalizzare la toolbar

Ci resta da implementare le IBAction che avevamo creato tramite Interface Builder per mostrare o nascondere la toolbar e per poterla personalizzare.

Per visualizzare il pannello di personalizzazione non dobbiamo far altro che chiamare il metodo runCustomizationPalette. Tutto il resto verrà gestito dal framework Cocoa.

- (IBAction)customize:(id)sender
{
    [toolbar runCustomizationPalette:sender];
}

Per l’IBAction showhide dobbiamo usare il metodo setVisible:(BOOL)shown che prende in input un booleano che indica se la toolbar dovrà essere mostrata o nascosta. Per passare il giusto valore non dobbiamo far altro che negare il valore restituito dal metodo isVisible.

- (IBAction)showhide:(id)sender
{
    [toolbar setVisible:![toolbar isVisible]];
}

Conclusioni

Come potete vedere aggiungere una toolbar alla nostra applicazione è molto semplice.

Questa guida è una mia traduzione dell’articolo originale in lingua inglese.

Versioni

05/05/2008 – Effettuate alcune correzioni grammaticali
05/05/2008 – Pubblicata la versione iniziale

Non avendo affatto esperienza in questo ambiente ho prima fatto qualche ricerca sul web, poi ho partecipato a qualche discussione su dei forum e alla fine mi sono trovato davanti ad una scelta: utilizzare le API delle BSD sockets oppure utilizzare dei framework che mi semplificassero il lavoro.

Per ora ho scelto la strada più breve utilizzando un wrapper, NetSocket, che a sua volta si appoggia alla classe CFSocket. In questo modo potrò tralasciare alcuni aspetti della programmazione in rete e concentrarmi sugli altri aspetti dell’applicazione.

NetSocket ha le seguenti caratteristiche:

• Protocolli supportati: TCP
• Buffered I/O: Si, gestito direttamente dalla classe
• I/O Asincrono: Si, attraverso l’utilizzo di delegati
• Licenza: BSD

Download NetSocket 0.9