Pagine

Visualizzazione post con etichetta NSSplitView. Mostra tutti i post
Visualizzazione post con etichetta NSSplitView. Mostra tutti i post

2012-12-14

I segreti degli NSSplitView - III

Nella prima puntata abbiamo visto come comunicare allo SplitView le dimensioni massime e minime delle proprie viste, mentre nella seconda puntata abbiamo implementato un metodo per associare il cambio delle dimensioni solo alla vista centrale (nell'ipotesi di tre viste).
In questa breve ultima puntata vediamo qualche finezza, che può far pensare all'utente che ci siamo sbattuti molto per farlo lavorare bene.

La vista che scompare sul serio

Abbiamo visto che con il metodo del delegate splitView:canCollapseSubview possiamo lasciare all'utente la possibilità di far scomparire la vista sulla destra, pur avendo il vincolo sulla sua dimensione minima. Se però non vogliamo lasciare questa libertà, potremmo pensare che non implementando questo metodo (oppure fornendo in ritorno sempre false), scopriremo presto che passando con il mouse sul bordo destro a vista collassata riusciamo ancora a prendere la vista invisibile e trascinarla, scoprendo gli altarini: cioè, se non facciamo nulla, si apre uno spazio vuoto: ricordiamo infatti che per evitare il caos abbiamo deciso di togliere letteralmente la vista da dentro lo SplitView.
Dobbiamo quindi convincere l'utente a non fare quella operazione e l'unico modo è... di impedirglielo.
Infatti, con il metodo SplitView:shouldHideDividerAtIndex: possiamo far scomparire definitivamente il divisore e senza quello l'utente non potrà più fare nulla di dannoso. È sufficiente verificare che il divisore sia quello incriminato e poi ritornare un risultato true:
- (BOOL)splitView:(NSSplitView *)splitView shouldHideDividerAtIndex:(NSInteger)dividerIndex
{
 NSInteger dividerToHide = 1;
 return (dividerIndex == dividerToHide);
}
Dato che parliamo della vista di destra, il divisore da far scomparire è quello indicato con il numero 1 (i divisori partono dal numero 0).

Azione finale

A questo punto abbiamo fatto in modo che l'utente non possa chiudere la vista e nemmeno riaprirla se è chiusa: ma allora... cosa può fare? Gli veniamo in soccorso e stabiliamo che l'apertura e la chiusura può essere fatta da un controllo esterno: un pulsante nella Toolbar della finestra è un buon candidato.
Per prima cosa colleghiamo il pulsante ad una IBAction del tipo:
- (IBAction)toggleInspectorPane:(id)sender
{
    if (collapsed) [self uncollapseView];  
    else [self collapseView];
}
In pratica, se la vista non c'è, la mettiamo noi, mentre se c'è la togliamo! Ed ora dedichiamoci al compito semplice ma piuttosto noioso di inserire o togliere la vista e di modificare la dimensione della sotto-vista dello SplitView.
Il nocciolo sta nel giocare con i frame, cambiando le dimensioni ed il punto di partenza di ogni view (ricordiamo che per default in Cocoa le view hanno la coordinata Y=0 nell'angolo in basso, mentre le X sono come ce le aspettiamo: crescono verso destra).
Supponendo che theSplit sia un IBOutlet legato allo NSSplitView che ci interessa:
- (void)collapseEditorView
{
 NSView *centerView = [[_theSplit subviews] objectAtIndex:1];
 NSRect centerFrame = [centerView frame];
 NSRect leftFrame = [[[_theSplit subviews] objectAtIndex:0] frame];
 NSView *rightView = [[_theSplit subviews] objectAtIndex:2];
 NSArray *viste = [rightView subviews];
  
 centerFrame.size.width = [_theSplit frame].size.width - leftFrame.size.width - [self.theSplit dividerThickness];
 centerFrame.origin = NSMakePoint(leftFrame.size.width + [self.theSplit dividerThickness], 0);
    [centerView setFrame:centerFrame];
    NSRect newCollapseRect = NSMakeRect([_theSplit frame].size.width, 0, 0, [_theSplit frame].size.height);
    [rightView setFrame:newCollapseRect];
    if ([viste count] != 0)
 {
  [(NSView*)[viste objectAtIndex:0] removeFromSuperview];
 }
 _editorViewController = nil;
 [_theSplit display];
}
In pratica andiamo ad impostare il frame della vista centrale in modo che copra tutto il restante splitView, togliendo dalla larghezza totale di questi la vista sinistra e lo spessore del divisore (righe 9-11). Per la vista destra, invece, impostiamo un frame con larghezza 0 e con origine nell'estremo destro dello splitView (righe 12-13).
Le ultime righe servono solamente a togliere la vista di mezzo, impostare il corrispondente NSViewController a nil e a rinfrescare lo splitView.

Le cose sono molto simili per il metodo che fa apparire la vista destra:
- (void)uncollapseEditorView
{
 NSView *leftView = [[_theSplit subviews] objectAtIndex:0];
 NSView *centerView = [[_theSplit subviews] objectAtIndex:1];
 NSView *rightView = [[_theSplit subviews] objectAtIndex:2];
 NSRect leftFrame = [leftView frame];
 NSRect centerFrame = [centerView frame];
 NSRect editorFrame;
 NSRect splitFrame = [_theSplit frame];
 CGFloat dividerThickness = [_theSplit dividerThickness];
 
 _editorViewController = [[editorViewCtrl alloc] initWithNibName:@"editorView" bundle:nil];
 editorFrame = [[_editorViewController view] frame];
 if ((splitFrame.size.width - editorFrame.size.width) < (leftFrame.size.width + 250))
 {
  NSRect windowFrame = [self.window frame];
  windowFrame.size.width += editorFrame.size.width;
  [self.window setFrame:windowFrame];
  splitFrame = [_theSplit frame];
  leftFrame = [leftView frame];
 }
 [rightView setHidden:NO];
 
 centerFrame.size.width = splitFrame.size.width - leftFrame.size.width - editorFrame.size.width - 2*dividerThickness;
 centerFrame.origin.x = leftFrame.size.width + dividerThickness;
 editorFrame.origin = NSMakePoint(leftFrame.size.width + centerFrame.size.width + 2*dividerThickness, 0);
 
 [centerView setFrame:centerFrame];
 [rightView setFrame:editorFrame];
}
Prima carichiamo il viewController con il nib che contiene la vista da inserire (riga 12), da cui otteniamo lo spazio necessario da riservare (13). L'idea è di rubare lo spazio necessario alla vista centrale, ma... dobbiamo fare attenzione che questa non scenda sotto la dimensione minima che abbiamo impostato (la vista lo farebbe, poiché i limiti non entrano in gioco da modifiche via codice, ma siamo noi a non volerlo!). Per cui, se la vista centrale dovesse diventare troppo piccola, la lasciamo come è e allarghiamo al suo posto la finestra, splitView compreso (in IB avremo fatto in modo che le sue dimensioni siano legate a quelle della finestra): questo è ciò che avviene nelle righe 14-20. Facciamo comparire la vista (22) e posizioniamo in modo corretto dimensioni e origine della vista centrale (24-25); poi imponiamo che la posizione della terza vista sia proprio dopo il divisore, come ci si attende (26).
Non ci resta che assegnare i nuovi frame a chi di dovere... e siamo a posto!
Volendo, potremmo animare il movimento del divider, in modo che la vista compaia scivolando da destra e scompaia chiudendosi dolcemente; ma questo è un compito abbastanza semplice con le possibilità di animazione di Cocoa!

2012-11-18

I segreti degli NSSplitView - II

Nella scorsa puntata abbiamo esaminato come sia possibile limitare le dimensioni delle viste di uno NSSplitView ed anche come fare in modo che l'utente possa far scomparire una vista, senza che questa si offenda e distribuisca a caso gli oggetti contenuti.
Ora continuiamo nel nostro viaggio per scoprire altre cose interessanti.

Ridimensionare educatamente

Il comportamento di uno SplitView quando la finestra in cui è contenuto si ridimensiona è generico e spesso irritante: non fa altro che mantenere le proporzioni tra le viste. Così, se a schermo pieno abbiamo ridotto una delle viste a 30 pixel, quando usciamo dal full screen potremmo trovare che la stessa vista è ora di 5 pixel o meno! Non c'è differenza se le dimensioni della finestra sono cambiate da codice o a mano dall'utente: il signor SplitView non ne vuol sapere di controllare il suo delegate per sapere se può stringere una vista.
Considerando l'esempio della prima parte, con uno SplitView fatto di 3 viste, noi vorremmo che la prima (di solito una SourceList) e l'ultima (di solito un Inspector) mantenessero costanti le proprie dimensioni, variando solamente la vista centrale.
Con MountainLion, Apple ha introdotto la priorità delle viste, con cui si può risolvere il problema, ma al momento non ce la sentiamo di tagliar fuori tutti gli utenti che stanno utilizzando Lion e SnowLeopard, per cui dobbiamo di nuovo rimboccarci le maniche e cominciare a battere sulla tastiera.
Il metodo che ci viene in aiuto è sempre del delegate:
- (void)splitView:(NSSplitView *)sender resizeSubviewsWithOldSize:(NSSize)oldSize
Questo viene continuamente chiamato durante il ridimensionamento dello SplitView (conseguente a quello della finestra) e propone una nuova dimensione (oldSize) che il delegate può accettare o meno; dobbiamo fare in modo che la prima e la terza vista restino costanti, modificando solo quella centrale.
Cominciamo col registrarci alcuni dati che ci torneranno utili nel metodo:
- (void)splitView:(NSSplitView *)sender resizeSubviewsWithOldSize:(NSSize)oldSize
{
    NSView *leftView = [[sender subviews] objectAtIndex:0];
    NSView *centerView = [[sender subviews] objectAtIndex:1];
    NSView *rightView = [[sender subviews] objectAtIndex:2];
    float dividerThickness = [sender dividerThickness];
    NSRect splitFrame = [sender frame];
    NSRect leftFrame = [leftView frame];
    NSRect centerFrame = [centerView frame];
    NSRect rightFrame = [rightView frame];
    BOOL collapsed = [sender isSubviewCollapsed:rightView];
Notiamo che alla riga 11 teniamo conto se la vista di destra è collassata o meno.
Ora impostiamo le cose più semplici: per ogni sotto-view impostiamo che l'altezza sia sempre quella dello SplitView e che la view a sinistra resti sempre incollata all'angolo sinistro:
. leftFrame.size.height = splitFrame.size.height;
 centerFrame.size.height = splitFrame.size.height;
 rightFrame.size.height = splitFrame.size.height;
 leftFrame.origin = NSMakePoint(0, 0);
Ora arriva la parte importante: modifichiamo la larghezza della view centrale, calcolando quanto deve essere grande se le altre viste restano costanti, ma tenendo anche conto della condizione di collapsed (e ricordiamoci della larghezza dei divider!):
. centerFrame.size.width = !collapsed ? (splitFrame.size.width - leftFrame.size.width - rightFrame.size.width - 2*dividerThickness) : (splitFrame.size.width - leftFrame.size.width - dividerThickness);
 centerFrame.origin = NSMakePoint(leftFrame.size.width + dividerThickness, 0);
Ora osserviamo che in questo modo la vista centrale potrebbe diventare più piccola di quanto abbiamo impostato: non viene impedito dal delegate, per cui lo dobbiamo impedire noi! Se succede, impostiamo la view centrale al valore minimo ammesso e passiamo a cambiare la dimensione della view di sinistra, sempre tenendo conto se la terza view è collassata o meno:
. if (centerFrame.size.width <= kMinWidthTable)
 {
  centerFrame.size.width = kMinWidthTable;
  leftFrame.size.width = !collapsed ? (splitFrame.size.width - 2*dividerThickness - kMinWidthTable - rightFrame.size.width) : (splitFrame.size.width - kMinWidthTable - dividerThickness);
  centerFrame.origin = NSMakePoint(leftFrame.size.width + dividerThickness, 0);
 }
Ricordiamoci di impostare la posizione della vista destra (se non collassata):
. if ( ! collapsed )
 {
  rightFrame.origin = NSMakePoint(splitFrame.size.width - rightFrame.size.width, 0);
 }
e concludiamo dando i nuovi frame alle viste:
. [leftView setFrame:leftFrame];
 [centerView setFrame:centerFrame];
 if (! collapsed) [rightView setFrame:rightFrame];
}
Compiliamo e divertiamoci con uno splitView ora beneducato!

2012-11-04

I segreti degli NSSplitView - I

È difficile trovare un'applicazione per MacOS X che non faccia uso degli oggetti NSSplitView: in questo modo si lascia all'utente la scelta di quanto mostrare delle varie viste necessarie per le attività.
Come al solito, quando una cosa è semplice per l'utente, aumentano le difficoltà per il programmatore! A questo si aggiunge che Cocoa fornisce tutti i mezzi necessari ad un funzionamento di base, ma se stiamo cercando di costruire un'interfaccia all'altezza delle aspettative, allora dobbiamo rimboccarci le maniche e cominciare a scrivere del codice aggiuntivo.

Creazione dello split

La cosa più semplice è, nell'IB, di creare le le view che saranno contenuti nello split, selezionarli tutti e scegliere il menu Editor > Embed In > splitView. Oppure si può inserire prima lo split e poi riempire le view che questo si porta dietro, eventualmente aggiungendone di nuove. Il numero di NSView al primo livello dello split determina quanti saranno i divisori e quindi le view gestite.
Nel seguito supporremo sempre di avere uno split view con viste affiancate: nel caso in cui le volessimo sovrapposte basterà scambiare le larghezze con le altezze.

Dimensioni massime - minime

Diciamo subito che un NSSplitView, proprio perché usato per suddividere una finestra, di solito la riempie tutta; allora le dimensioni dello split seguono allegramente quelle della finestra (posto di aver messo i giusti vincoli nell'inspector dell'XCode per il dimensionamento automatico), per cui basta impostare il massimo ed il minimo per la finestra, tramite l'inspector di XCode.
Il problema invece riguarda le view contenute nello split: di default un divisore può essere spostato fino a che non arriva ad un altro divisore, azzerando la dimensione della vista che contiene; in questo modo scopriamo subito che le viste non amano essere ridotte a zero: quando vengono riaperte gli oggetti contenuti vagano senza ritegno in posti impensati. Purtroppo la classe NSSplitView non possiede metodi per impostare l'ampiezza massima e minima di una view e di conseguenza non possono nemmeno essere inseriti da Interface Builder. È il momento di scrivere codice!
Tutte i metodi interessanti si trovano nel protocollo del delegate. Quindi, per prima cosa dobbiamo informare lo splitView che da ora possiede un delegate: questo può essere fatto da XCode (collegando il suo outlet delegate all'oggetto delegate) oppure direttamente da codice con il metodo -setDelegate: seguito dall'oggetto eletto a questo rango.
Personalmente, preferisco dedicare un oggetto apposito per queste cose, per cui creiamo una nuova classe, sottoclasse di NSObject e dichiariamo che seguirà le leggi previste per il delegate di uno splitView. In termini semplici, il nostro header si presenterà come:
interface mySplitDelegate : NSObject <NSSplitViewDelegate>
end
e non dichiariamo alcun metodo, poiché l'essere un delegate ne prevede già una serie, tra cui quelli che servono a noi. In particolare, quelli preposti alla sorveglianza delle dimensioni sono:
- splitView:constrainMinCoordinate:ofSubviewAt:
- splitView:constrainMaxCoordinate:ofSubviewAt:
dove la prima gestisce il minimo, la seconda il massimo.
Questi metodi sono chiamati dallo split quando vuole sapere se permettere uno spostamento di un divisore e per saperlo passa al delegate lo split in questione (primo parametro), la proposta di valore minimo nelle coordinate dello splitView (secondo parametro, è quello che userebbe se questi metodi non fossero implementati), il divisore che si sta muovendo (i divisori sono numerati da 0, come se si riferissero alla vista alla loro sinistra).
Come esempio, consideriamo il caso di uno split a 3 viste (2 divisori) in cui vogliamo che ciascuna di esse non possa essere azzerata; definiamo con delle macro queste dimensioni:
#define kMinWidthView1   100   //minimo vista 1, a sinistra
#define kMinWidthView2   200   //minimo vista 2, centrale
#define kMinWidthView3    50   //minimo vista 3, a destra
Supponiamo di muovere il divisore 0 (tra la prima e la seconda vista). La proposta che arriva al delegate è per un valore minimo di 0 (divisore tutto a sinistra, collassando la prima vista); noi invece ritorneremo un valore di 100 pixel. Se invece muoviamo il secondo divisore, la proposta non sarà 0 ma sarà uguale alla larghezza della prima vista a cui viene aggiunta la larghezza del divisore. Ma noi siamo inflessibili e gli rispondiamo che a questa posizione dovrà aggiungere 100. Sotto forma di codice:
- (CGFloat)splitView:(NSSplitView *)splitView constrainMinCoordinate:(CGFloat)proposedMinimumPosition ofSubviewAt:(NSInteger)dividerIndex
{
  CGFloat constrained = proposedMinimumPosition;
  float dividerThickness = [splitView dividerThickness];
  switch (dividerIndex) {
    case 0:
      constrained = proposedMinimumPosition + kMinWidthView1;
      break;
    case 1:
      constrained = proposedMinimumPosition + dividerThickness + kMinWidthView2;
      break;
  }
  return constrained;
}
I casi sono tutti quelli possibili, dato che abbiamo solo 2 divisori. Ma come controllo la larghezza della terza view? Ovvio: inserendo un limite sulla dimensione massima della seconda view! Perciò implementiamo anche il secondo metodo (in effetti, devono sempre andare in coppia). La trovata infatti è che la dimensione massima di una vista è quella che non costringe la vista vicina a scendere sotto la sua dimensione minima. In pratica:
- (CGFloat)splitView:(NSSplitView *)splitView constrainMaxCoordinate:(CGFloat)proposedMaximumPosition ofSubviewAt:(NSInteger)dividerIndex
{
  CGFloat constrained = proposedMaximumPosition;
  float dividerThickness = [splitView dividerThickness]; 
  switch (dividerIndex) {
    case 0:
      constrained = proposedMaximumPosition - 200 - dividerThickness;
      break;
    case 1:
      constrained = proposedMaximumPosition - 50;
      break;
  }
  return constrained;
}
Ora lanciamo l'applicazione e scopriremo che in effetti lo split si comporta come previsto, qualunque cosa facciamo con i divisori!
Notiamo che non abbiamo avuto bisogno di utilizzare la dimensione dello splitView: è lui stesso che ne tiene conto, passandoci la sua proposta di dimensione massima (che infatti non può andare oltre il collasso della vista vicina oppure oltre la dimensione della finestra che lo contiene).

La vista che scompare

Abbiamo ancora un problema: se l'utente decidesse che la terza vista è troppo noiosa, potrebbe volerla togliere di mezzo, ma non potrebbe perché il delegate lo impedisce! Ma è lo stesso delegate che si riscatta, mettendo a disposizione un altro metodo, che può coesistere con i due precedenti: si tratta di -splitView:canCollapseSubview:. Se si tratta della vista che vogliamo lasciar chiudere, ritorniamo TRUE altrimenti FALSE:
#define kViewToCollapse  2
- (BOOL)splitView:(NSSplitView *)splitView canCollapseSubview:(NSView *)subview
{
  NSView *rightView = [[splitView subviews] objectAtIndex:kViewToCollapse];
  return [subview isEqual:rightView];
}
dove abbiamo approfittato del fatto che la proprietà -subviews ritorna un NSArray contenente le viste dello split.
Ora l'utente può far collassare la terza vista continuando a trascinare il divisore oltre il limite minimo: se mantiene la pressione sul mouse, quando arriva a circa la metà dell'ampiezza della vista, la vista stessa collassa e scompare! Per tornare indietro, basta andare col mouse sul bordo e spostare il divisore verso sinistra: la vista comparirà nuovamente, prendendo la dimensione minima prevista.
Notiamo che questo non crea problemi agli oggetti all'interno della vista: in effetti il collasso della vista non riduce la sua dimensione a 0, ma semplicemente la fa scomparire; quando la riapriamo, la ritroviamo con la stessa dimensione di prima, con gli oggetti ordinatamente al loro posto.