(piccolo sfogo! ^_^)

L’alba del 25 luglio, all’età di 47 anni, si è spento Randy Pausch, informatico statunitense e padre di tre bambini. Scusate il manifesto lugubre, ma ci sono persone che vanno ricordate per l’amore e l’impegno che mettono nel loro vivere quotidiano ed io, nel mio piccolo spazio, ci tengo a ricordarlo.

Questa è la sua ultima lezione di vita sottotitolata in italiano, prendete 10 minuti e guardatevela, penso che non ci sia persona che possa rimanerne delusa.

Se avete altre curiosità c’è il video integrale della sua ultima lezione, l’articolo del Chicago Tribune e la trascrizione della sua ultima lezione.

Se utilizzate xubuntu di default le anteprime dei file non vengono visualizzate, vediamo dunque come attivarle!

Apriamo un’istanza di Thunar e poi dal menu Modifica apriamo Preferenze.

Nella scheda Display (la prima) abilitiamo la spunta su Mostra miniature. Finito! Questo è lo screenshot:

Appunto importante soprattutto per i possessori di Eee PC: le anteprime vengono salvate in ~/.thumbnail/, tenete sempre d’occhio questa cartella perché può facilmente arrivare ad occupare 200MB e passa! La cartella .thumbnail è utilizzata sia per le anteprime di Gnome che di Xfce, quindi il consiglio vale anche per gli utenti di Gnome!

Quest’ultimo periodo non sto apportando nessuna modifica al mio pc, ho sedato la curiosità di provare software/linguaggi nuovi perché non avrei il tempo di stare ad imparare (nonostante l’interesse ci sia sempre) e lo studio sta avendo la meglio.

Parlare di come sia “bello” far dialogare (solo in teoria) un DLX/R4000 con un 8086 tramite dispositivi 8255 et similia penso non interessi a nessuno e di argomenti informatici di cui parlare ne avrei pochi altri, quindi al momento non ho nulla da scrivere, al massimo completerò qualche bozza e la pubblicherò.

Triste conclusione: il blog va in pausa a tempo indeterminato. (Nella peggiore delle ipotesi fino a quest’estate. )

WPF (Windows Presentation Foundation) è un framework davvero potente (oltreché pesante) e permette di creare componenti grafici dalle caratteristiche avanzate con pochissimo sforzo! Ma se volessimo estendere qualcosa di già esistente e non creare nulla da zero?

(Nonostante non si noti, quest’albero è in WPF)

Intanto perché WPF? Perché Vista ed i suoi successori lo integrano attraverso il .Net Framework 3.5, perché con poco sforzo ci permette interfacce grafiche futuristiche ma, soprattutto, perché me lo dice il mio prof!

Il concetto che sta dietro WPF è molto semplice: tutto può contenere tutto! Quindi possiamo creare una ComboBox con all’interno, invece delle solite stringhe, una serie di video con una descrizione accanto (stile youtube), e poi magari inserire questa ComboBox come nodo in un albero di preferenze! Pensate di riuscire a farlo in altri linguaggi di programmazione? Solo Flash permette, con un notevole sforzo in ActionScript, di arrivare a tanto, ma poi si è ostacolati dal limite di non poter interfacciarsi con l’esterno!

Il piccolo anello mancante però è: e se io invece volessi qualcosa di semplice? Tipo, il vecchio albero in Windows Form permetteva l’uso delle CheckBox, come potrei fare a creare una mia classe che estenda l’albero di WPF con questa funzionalità? Leggendo su internet o sui libri l’unica alternativa sembra crearsi un UserControl, un HeaderedItemsControl, un ItemsControl e chi più ne ha più ne metta!

Invece, utilizzando in coppia XAML e C#, il risultato è facilmente ottenibile! Come prima cosa andiamo ad aggiungere al progetto un nuovo elemento UserControl e, chiamiamolo, ad esempio, MyTreeNode. Questo inserirà nel progetto gli elementi MyTreeNode.xaml e MyTreeNode.xaml.cs: il primo è l’interfaccia scritta in XAML, il secondo è il codice sottostante, scritto in C#.

Partiamo con il modificare l’interfaccia in XAML, che è più leggibile al programmatore e meno criptica (una volta giunti alla soluzione)! Vi posto direttamente la soluzione finale:

<TreeViewItem x:Class=”WPFApplication.MyTreeNode”

xmlns=”http://schemas.microsoft.com/winfx/2006/xaml/presentation”

xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml”

xmlns:my=”clr-namespace:WPFApplication”

>

<TreeViewItem.Header>

<StackPanel Orientation=”Horizontal”>

<CheckBox

x:Name=”UICheckBox”

IsChecked=”{Binding Checked}”

Visibility=”{Binding TreeView.CheckBoxes}” />

<ContentControl

x:Name=”UITitle”

Content=”{Binding Title}” />

</StackPanel>

</TreeViewItem.Header>

</TreeViewItem>

Come potete vedere ho sostituito UserControl con TreeViewItem (l’elemento nodo in WPF) e successivamente ho ridefinito l’Header inserendoci al suo posto uno pannello con una CheckBox ed un Titolo (in qualche modo bisogna accedere all’intestazione, considerato che ora Header non è più disponibile. Per i curiosi Title sarebbe l’equivalente di Text nelle Windows Form).
Il Binding utilizzato per Visibility serve per creare la stessa identica struttura delle Windows Form e si basa su un’Attached Property nel codice C# che cambia al cambiare dell’elemento grafico padre, ma questa è un’altra storia! L’ho lasciato per completezza! ^_^

Passiamo ora ad analizzare porzioni di codice C# (scrivere tutta la classe sarebbe spropositato!), intanto come prima cosa modifichiamo la classe da cui ereditare tutto, che non sarà più UserControl ma TreeViewItem:

public partial class MyTreeNode : TreeViewItem

Poi andiamo a modificare il costruttore inserendo queste linee di codice:

UICheckBox.DataContext = this;
UITitle.DataContext = this;

Quello che faccio è definire la sorgente per i vari binding , farlo da XAML è molto meno immediato e facilmente soggetto a malfunzionamenti!

Considerato che l’Header è stato sostituito dal pannello rendiamolo di sola lettura:

public new object Header

{
get { return base.Header; }
//set { Title = value; }
}

Come vedete dal commento è possibile anche prevedere che tutto quello che viene inserito nell’Header passi direttamente nel Title, avendo così un comportamento molto simile sia a WPF che a Windows Form. Nonostante sia comodo (e allettante) come approccio questo implicherebbe avere in lettura oggetti diversi da quelli appena scritti, cosa che potrebbe dare inutili grattacapi a programmatori che in futuro volessero utilizzare il vostro codice! Quindi consiglio di lasciare la sola lettura all’Header!

Ora non rimane che crearci le Dependency Property appropriate:

• Title: questa DP andrà a sostuiture l’Header, quindi deve essere di tipo object. Per un utilizzo vicino alle Windows Form si può prevedere di inserire un CoerceValueCallback che in caso di elementi non grafici converti in stringa l’oggetto (WPF ha un suo casting particolare, quindi è bene non affidarsi troppo a questo!), il controllo da inserire è davvero semplice:

  object result = value is UIElement ? value : value.ToString();
  return result;

• Checked: questa DP indica se una CheckBox è selezionata o meno, quindi è di tipo booleano.
• TreeView.CheckBoxes: è collegata alla DP TreeView (un’altra classe dedicata non trattata in questo articolo) ed è di tipo Visibility. TreeView (di tipo MyTreeView, per rispettare la convenzione utilizzata) cambia al cambiare dell’elemento grafico padre, notificando tutti i nodi figli ed aggiornando la visibilità delle CheckBox. Essendo una classe lunga evito di inserirla in questo articolo che si focalizza su altri aspetti.

Bene, direi che con poco sforzo abbiamo ottenuto il vecchio comportamento delle Windows Form e ci siamo lasciati lo spazio per inserire facilmente altre funzionalità nell’Header!

PS: nel caso ve lo chiediate, ricordatevi che i Nodes di Windows Form sono gli Items di WPF, il metodo EnsureVisible() diventa BringIntoView(), l’elemento TreeView non esiste e dovete crearlo voi, gli eventi sono stati sostituiti dalle DP, non esiste il LabelEdit, i menu contestuali sono cambiati (anche se son facili da adattare), se non erro il Drag & Drop è cambiato ma comunque è compatibile con Windows Form, non si pone più il problema dei refresh, ecc …

Ogni linguaggio di programmazione ha una sua gestione intrinseca degli eventi, per gli sviluppatori C# con .NET 3.5 e l’utilizzo delle Dependency Property il lavoro si è semplificato, ma i concetti alla base prima o poi riemergono, ed ecco quindi un breve ripasso per un loro utilizzo molto base!

Supporrò che siate già in possesso dei concetti base (come per esempio dei delegati, una delle varie comodità del C# e fondamento degli eventi), quindi inserirò direttamente le classi con i commenti sul perché del codice! La fonte non sono io, ma il guru Herbert Schildt (lo consiglio per imparare anche Java e C++, oltre a C#), le classi create sono due: MyEvent, che è la proprietaria dell’evento, e Window1, che in pratica, con Window_Loaded, ha l’equivalente del Main (oramai ho preso l’abitudine di creare direttamente progetti WPF per tutto! ^_^)

Ah, considerato che leggere il codice con questo layout del blog è davvero ostico, in questo documento Word ci sono le classi con il testo formattato ed indentato come si deve! Per approfondire l’argomento ci sono queste slides del corso di Laboratorio di Ingegneria del Software L-A (troverete molto materiale utile su C# e .NET 2.0), mentre il libro da cui ho preso l’esempio sottostante è C#, La guida completa di Herbert Schildt.

namespace SimpleEvent

{

/// <summary>

/// Dichiara un delegato per un evento.

/// Tutti gli eventi vengono attivati attraverso un delegato. Pertanto il

/// delegato dell’evento ne definisce la firma. In questo caso non ci sono

/// parametri, tuttavia i parametri dell’evento sono ammessi.

/// Dato che gli eventi vengono in genere sotooposti a multicasting, un

/// evento dovrebbe restituire void.

/// Successivamente verrà creata una classe di eventi.

/// </summary>

delegate void MyEventHandler();

class MyEvent

{

/// <summary>

/// Dichiarazione di un oggetto dell’evento.

/// All’interno di MyEvent viene dichiarato anche il metodo OnSomeEvent(),

/// ossia il metodo che un programma chiamerà per segnalare (o “attivare”)

/// un evento (in altre parole, questo è il metodo chiamato quando si

/// verifica l’evento).

/// Infatti chiama un gestore di eventi tramite il delegato SomeEvent, nel

/// modo:

/// if (SomeEvent != null ) SomeEvent();

/// </summary>

public event MyEventHandler SomeEvent;

/// <summary>

/// Questo viene chiamato per attivare l’evento.

/// </summary>

public void OnSomeEvent()

{

// Un gestore viene chiamato solo nel caso in cui SomeEvent

// non sia null. Dato che altre parti del programma devono

// registrare un certo interesse per un evento per ricevere

// le notifiche dell’evento, può accadere che OnSomeEvent()

// venga chiamato quando non è stato ancora registrato alcun

// gestore di eventi. Per evitare di chiamare un oggetto null,

// dovrete verificare il delegato dell’evento per assicurarvi

// che non sia null.

if (SomeEvent != null)

SomeEvent();

}

}

}

namespace SimpleEvent

{

/// <summary>

/// Interaction logic for Window1.xaml

/// </summary>

public partial class Window1 : Window

{

public Window1()

{

InitializeComponent();

}

/// <summary>

/// Un gestore di eventi.

/// In questo esempio, il gestore di eventi visualizza semplicemente

/// un messaggio, tuttavia altri gestori potrebbero eseguire azioni

/// più importanti.

/// </summary>

static void handler()

{

Console.WriteLine(“L’evento si è verificato.”);

}

private void Window_Loaded(object sender, RoutedEventArgs e)

{

// Viene creato un oggetto MyEvent:

MyEvent evt = new MyEvent();

// Aggiunge handler() alla lista di eventi, ovvero handler() viene

// registrato come gestore per questo evento.

// Notare che il gestore è stato aggiunto usando l’operatore +=. Gli

// eventi supportano solamente += e -=. In questo caso handler() è

// static, tuttavia i gestori di eventi possono essere anche dei metodi

// di istanza.

evt.SomeEvent += new MyEventHandler(handler);

// Nota: se volessi registrare più oggetti ad un evento ecco la bozza

// di soluzione:

//      OggettoX xObj = new OggettoX();

//      OggettoY yObj = new OggettoY();

//      evt.SomeEvent += new MyEventHandler(xObj.Xhandler);

//      evt.SomeEvent += new MyEventHandler(yObj.Yhandler);

// Attiva l’evento.

// La chiamata OnSomeEvent() comporta la chiamata di tutti i gestori

// di eventi registrati. In questo caso c’è un solo gestore registrato,

// ma ce ne potrebbero essere di più.

evt.OnSomeEvent();

// Se avessi registrato più handler verrebbero chiamati tutti.

}

}

}

Come può scoppiare in tragedia un semplice Copia & Incolla! Terminare explorer non è stato sufficiente, ma (fortunatamente) è bastato un riavvio della sola sessione!

PS: Lo sfondo era nero!

PPS: E nel frattempo il Windows XP del fisso ha deciso che è giunto il momento di disinstallare i driver della scheda ehernet! -.-

Sicuramente avrete notato che ad ogni aggiornamento del kernel Ubuntu mantiene le 2 configurazioni precedenti per sicurezza! (Nell’ultima versione anche più, mi sa)!

Questo comportamento può tornare utile in (raro) caso di computer con hardware particolarmente problematico, ma in genere le configurazioni precedenti possono essere omesse dal menu (per poi accedervi, al massimo, attraverso la linea di comando di grub)!

Configuriamo Ubuntu affinché ci mostri solo il kernel più recente (con la sua relativa opzione di recovery)!

Apriamo menu.lst da root con:

sudo gedit /boot/grub/menu.lst

Nella Automagic Kernel List cerchiamo la linea:

# howmany=all

e sostituiamola con:

# howmany=1

Ora lanciamo il comando

$ sudo update-grub

per avere il grub aggiornato da subito!

Finito!

Vedere per credere! o_O

(Video copiato palesemente da questo post di sissina! ^_^)

Questo è solo un appunto veloce: in Windows Vista è possibile avviare l’effetto scorrimento finestre per poi muoversi con i soli tasti freccia (similmente a molti effetti di compiz) tenendo premuto anche il tasto Ctrl.

In pratica:

• Ctrl + Alt + Tab: avvia il task switcher, con i tasti destra e sinistra ci si sposta tra le applicazioni
• Ctrl + Win + Tab: avvia l’effetto wow (non conosco il nome), come nel caso precedente, con i tasti destra e sinistra ci si muove tra le applicazioni