venerdì 29 gennaio 2010

Briciole di WPF: Ma quanti colori vuoi?!?!?

Questa briciola è dedicata alla structure Color presente nel namespace System.Windows.Media.

Di fatto si tratta della nuova struttura di colore introdotta da WPF che viene utilizzata dal presentation framework al posto della vecchia Color del namespace System.Drawing.

Ci sono due grandi differenze “esteriori” tra le due strutture.

La prima differenza è che la vecchia struttura può rappresentare 16.777.216 di colori essendo le sue componenti RGB rappresentate da 1 Byte ciascuno (256 possibili valori). Ogni terna di valori RGB ha, inoltre, 256 possibili valori di trasparenza.

La nuova struttura, invece, ha anche la possibilità di esprimere le componenti RGB (e Alfa) con dei valori di tipo Single (solo positivi o nulli) e, quindi, in linea teorica con un range di colori molto più ampio. La nuova struttura nasce con lo scopo di supportare lo standard scRGB (wiki docet).

La struttura Color di WPF mette ancora a disposizione dello sviluppatore le proprietà (A, R, G, B) che riportano il singolo canale espresso con un byte, ma forniscono anche delle proprietà (ScA, ScR, ScG, ScB) che esprimono le componenti del colore con dei valori di tipo Single.

I due insiemi di proprietà sono tra loro sincronizzati nel senso che se impostiamo uno dei canali “vecchi” otteniamo che il corrispondente canale “nuovo” ha il proprio valore aggiornato (con un valore tra 0 e 1. La conversione in questo verso avviene con una funzione di normalizzazione che possiamo ricavare utilizzando Reflector:

  1. Private Shared Function sRgbToScRgb(ByVal bval As Byte) As Single
  2.     Dim num As Single = (CSng(bval) / 255.0!)
  3.     If (num <= 0) Then
  4.         Return 0.0!
  5.     End If
  6.     If (num <= 0.04045) Then
  7.         Return (num / 12.92!)
  8.     End If
  9.     If (num < 1.0!) Then
  10.         Return CSng(Math.Pow(((num + 0.055) / 1.055), 2.4))
  11.     End If
  12.     Return 1.0!
  13. End Function

dove bval è il valore del canale “vecchio” e il ritorno della funzione è il valore del canale “nuovo”.

Quando impostiamo, invece, una delle proprietà dei nuovi canali, anche le corrispettive proprietà dei vecchi canali vengono aggiornate. Stavolta la funzione utilizzata per l’aggiornamento è la seguente:

  1. Private Shared Function ScRgbTosRgb(ByVal val As Single) As Byte
  2.     If (val <= 0) Then
  3.         Return 0
  4.     End If
  5.     If (val <= 0.0031308) Then
  6.         Return CByte((((255.0! * val) * 12.92!) + 0.5!))
  7.     End If
  8.     If (val < 1) Then
  9.         Return CByte(((255.0! * ((1.055! * CSng(Math.Pow(CDbl(val), 0.41666666666666669))) - 0.055!)) + 0.5!))
  10.     End If
  11.     Return 255
  12. End Function

In questo caso val è il valore del “nuovo” canale, mentre il ritorno della funzione è il valore del “vecchio” canale.

Altra differenza tra la nuova Color e la vecchia è che nella prima sono state rimosse le proprietà statiche che definivano i cosiddetti “colori noti” (ad esempio Color.Red). E’ stata, in questo senso, creata una nuova classe (interamente costituita da proprietà statiche ) Colors che contiene queste definizioni.

Se apriamo con Reflector la nuova structure Color osserviamo che anche il modo con cui internamente sono memorizzati i canali è cambiato.

Nella Color del namespace Drawing i canali sono memorizzati in un unico oggetto di tipo In64, mentre nella nuova structure abbiamo due strutture private ognuna delle quali ha 4 attributi (single o byte) che identificano i canali.

lunedì 25 gennaio 2010

Briciole di WPF : InkCanvas e gesture

In questo post vorrei farvi vedere come poter riconoscere le gesture (cioè i movimenti) che l’utente può fare con il mouse, con le dita o con un eventuale stilo utilizzando il contenitore InkCanvas.

Il controllo InkCanvas, in realtà, si può utilizzare per intercettare i “gesti” dell’utente, per disegnare, per selezionare una porzione di interfaccia o per tutte queste funzionalità contemporaneamente.

Cominciamo col dire che per poter utilizzare l’InkCanvas solo per intercettare le gesture dell’utente è necessario impostare la proprietà EditingMode con il valore InkCanvasEditingMode.GestureOnly.

L’enumerazione InkCanvasEditingMode contiene tutti i possibili comportamenti dell’InkCanvas:

  • GestureOnly : il controllo rileva le gesture. In questo caso l’utente lascia un segno sulla superficie del controllo ma questo sparisce al termine della singola gesture;
  • EraseByPoint : permette di cancellare una parte di un precedente disegno passando il pennino come una gomma;
  • EraseByStroke : permette di cancellare un’intera curva precedentemente disegnata passando il pennino come una gomma;
  • Ink : l’utente può disegnare con il pennino;
  • InkAndGesture : l’utente può disegnare ma il controllo rileva anche le gesture;
  • None : il controllo non permette di disegnare e non rileva le gesture;
  • Select : il controllo permette di selezionare una porzione della superficie del controllo.

Concentriamoci, ora su come possiamo intercettare le gesture dell’utente.

Per poter far si che il controllo InkCanvas sia in grado di intercettare le gesture dobbiamo, inizialmente impostare la sopra citata proprietà, quindi istruire il controllo stesso su quali gesture siamo intenzionati ad intercettare.

Per fare questa ultima operazione dobbiamo utilizzare il metodo SetEnabledGestures che si aspetta come argomento un oggetto IEnumerable(of ApplicationGesture).

Ad esempio potremmo scrivere:

  1. Dim gestures = {ApplicationGesture.Circle,
  2.                 ApplicationGesture.Square,
  3.                 ApplicationGesture.Triangle}
  4. inkCanvas.SetEnabledGestures(gestures)

per istruire il controllo a rilevare i cerchi, i quadrati e i triangoli descritti dall’utente. Attenzione che, se non eseguiamo il metodo SetEnabledGestures

Istruito il controllo dobbiamo preoccuparci di gestire l’evento Gesture che è l’evento scatenato dal controllo ogni qual volta l’utente appoggia, muove e rilascia il pennino sulla superficie del controllo.
Dobbiamo subito precisare che tale evento viene scatenato sempre, per qualsiasi gesture dell’utente (anche se non è una di quelle per cui abbiamo istruito il controllo).

L’evento Gesture mette a disposizione, come argomento un oggetto di tipo InkCanvasGestureEventArgs, derivato da RoutedEventArgs, dal quale possiamo ricavare o l’insiame delle linee disegnate dall’utente (tramite la proprietà Strokes) oppure far riconoscere al framework quali sono state le gesture che l’utente ha tentato di eseguire.

Il primo caso è da utilizzare quando vogliamo interpretare, con un nostro algoritmo, le gesture dell’utente; il secondo caso, invece, delega al framework il riconoscimento rendendoci la vita più semplice.

Per recuperare l’elenco delle gesture interpretate dal framework possiamo utilizzare il metodo GetGestureRecognitionResults() della classe InkCanvasGestureEventArgs.
Questo metodo restituisce una collezione (sola lettura) di oggetti GestureRecognitionResult.

La classe GestureRecognitionResult contiene le informazioni relative alle gesture, ed in particolare possiamo utilizzare le due proprietà RecognitionConfidence e ApplicationGesture per capire esattamente quale gesture sono state eseguite dall’utente.

RecognitionConfidence è un enumerazione che può assumere i seguenti valori Poor, Intermediate e Strong ed indica la “precisione” con cui il framework ha interpretato la gesture.

ApplicationGesture, infine, contiene la gesture riconosciuta (se è una di quelle per cui il controllo è stato istruito) oppure NoGesture se la gesture non è riconosciuta.

Per testare il meccanismo di riconoscimento delle gesture ho preparato una semplice applicazione WPF che contiene un InkCanvas, un elenco di checkbox per selezionare le gesture da riconoscere, un livello minimo di riconoscimento delle gesture e un’area (costituita da un TextBlock) in cui verrà scritta la gesture eventualmente riconosciuta.

Il layout dell’applicazione è il seguente:

Layout_Applicazione_GestureIn questa window possiamo selezionare per quali gesture “istruire” l’InkCanvas e quale è il livello minimo desiderato di precisione della gesture.

In particolare, nel momento in cui selezioniamo (o deselezioniamo) una delle gesture mostrate nella lista di destra, viene richiamato il seguente codice:

  1. Private Sub AddApplicationGestures()
  2.     Me.inkCanvas.EditingMode = InkCanvasEditingMode.GestureOnly
  3.  
  4.     Dim gestures = (From c In Me.pnlGestureOptions.Children.OfType(Of Control)()
  5.                     Where TypeOf (c) Is CheckBox AndAlso CType(c, CheckBox).IsChecked
  6.                     Select CType(c.Tag, ApplicationGesture)).ToList()
  7.  
  8.     If gestures.Count = 0 Then
  9.         gestures.Add(ApplicationGesture.NoGesture)
  10.     End If
  11.     Me.inkCanvas.SetEnabledGestures(gestures)
  12.  
  13. End Sub

Il precedente metodo ricava i valori delle gestures dei CheckBox selezionati nel pannello di destra tramite una query LINQ e utilizza il metodo SetEnableGestures() per impostarli sul controllo InkCanvas. Se nessun CheckBox è selezionato (nessuna gesture) allora viene impostato il valore “NoGesture”.

Quando l’utente disegna una linea nell’InkCanvas, il controllo genera l’evento Gesture nel quale andiamo a verificare che l’utente abbia disegnato una delle gesture da noi selezionate:

  1. Private Sub inkCanvas_Gesture(ByVal sender As System.Object, ByVal e As System.Windows.Controls.InkCanvasGestureEventArgs)
  2.     Dim gestureResults As ReadOnlyCollection(Of GestureRecognitionResult)
  3.     gestureResults = e.GetGestureRecognitionResults()
  4.  
  5.     For Each gesture In gestureResults
  6.         If gesture.ApplicationGesture <> ApplicationGesture.NoGesture Then
  7.             If optPoor.IsChecked And gesture.RecognitionConfidence = RecognitionConfidence.Poor Then
  8.                 Me.txtResult.Background = New SolidColorBrush(Color.FromRgb(0, 255, 255))
  9.                 Me.txtResult.Text = gesture.ApplicationGesture.ToString()
  10.                 Exit For
  11.             End If
  12.             If optIntermediate.IsChecked And gesture.RecognitionConfidence = RecognitionConfidence.Intermediate Then
  13.                 Me.txtResult.Background = New SolidColorBrush(Color.FromRgb(255, 255, 255))
  14.                 Me.txtResult.Text = gesture.ApplicationGesture.ToString()
  15.                 Exit For
  16.             End If
  17.             If optStrong.IsChecked And gesture.RecognitionConfidence = RecognitionConfidence.Strong Then
  18.                 Me.txtResult.Background = New SolidColorBrush(Color.FromRgb(0, 255, 0))
  19.                 Me.txtResult.Text = gesture.ApplicationGesture.ToString()
  20.                 Exit For
  21.             End If
  22.         Else
  23.             Me.txtResult.Background = New SolidColorBrush(Color.FromRgb(255, 0, 0))
  24.             Me.txtResult.Text = gesture.ApplicationGesture.ToString()
  25.         End If
  26.     Next
  27. End Sub

Se la gesture è riconosciuta (ed ha, al minimo, il livello di precisione da noi selezionato) viene visualizzato il relativo valore con un opportuno colore (in base alla precisione), altrimenti viene visualizzato NoGesture.

L’applicazione mostrata è molto semplice ed inutile, ma può mostrare come interagire con l’InkCanvas per eseguire operazioni quando l’utente esegue particolari gesture.

Per scaricare i sorgenti della soluzione di prova (Visual Studio 2010) cliccare sull’icona seguente:

giovedì 21 gennaio 2010

Briciole di WPF : Single instance application (soluzione 2).

Nel precedente post abbiamo visto una soluzione al problema della mancanza della possibilità di avviare un’applicazione WPF come singola istanza.

In questo post vorrei proporvi un’altra soluzione al problema che si basa sull’utilizzo della classe Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase che espone dei metodi per la gestione di un’applicazione Windows Form.

Il concetto di fondo è quello di sostituire, per la gestione del ciclo di vita dell’applicazione WPF, la classe Application con la classe WindowsFormsApplicationBase, o per meglio dire con una sua derivata.

Creiamo la classe:

  1. Public Class SingleInstanceApplication
  2.     Inherits Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase
  3.  
  4.     Friend Sub New()
  5.         Me.IsSingleInstance = True
  6.     End Sub
  7.  
  8.     Private _app As WPFApplication.Application
  9.  
  10.     Protected Overrides Function OnStartup(ByVal eventArgs As Microsoft.VisualBasic.ApplicationServices.StartupEventArgs) As Boolean
  11.         _app = New WPFApplication.Application()
  12.         _app.StartupUri = New Uri("MainWindow.xaml", UriKind.Relative)
  13.         _app.Run()
  14.         Return False
  15.     End Function
  16.  
  17.     Protected Overrides Sub OnStartupNextInstance(ByVal eventArgs As Microsoft.VisualBasic.ApplicationServices.StartupNextInstanceEventArgs)
  18.         Me.OnShutdown()
  19.     End Sub
  20.  
  21. End Class

Dove WPFApplication.Application è la nostra classe applicazione WPF (il code behind del file Application.xaml) e MainWindow.xaml è la finestra principale dell’applicazione.

Se riusciamo a far partire la classe SingleInstanceApplication all’avvio dell’applicazione WPF, allora siamo in grado di gestire lo Startup e lo StartupNextInstance e gestire, in questo modo l’avvio di più istanze della nostra applicazione.

Per risolvere questo ultimo problema costruiamo una classe di Startup:

  1. Public Class Startup
  2.     Public Shared Sub Main(ByVal args As String())
  3.         Dim singleInstance = New SingleInstanceApplication()
  4.         singleInstance.Run(args)
  5.     End Sub
  6. End Class

e modifichiamo le proprietà dell’applicazione WPF per far eseguire la classe Startup all’avvio. Per fare questo è sufficiente:

  1. Aprire la pagina delle proprietà dell’applicazione WPF cliccando con il tasto destro del mouse sul progetto e scegliendo il menù Proprietà;
  2. Disattivare il checkbox per l’attivazione dell’application framework;
  3. Selezionare la classe Startup come oggetto di avvio.

WPF_Application_Property In questo modo, nel momento in cui l’applicazione viene avviata la prima volta, viene eseguito il metodo OnStartup della classe SingleInstanceApplication e, tutte le volte che viene eseguita un’ulteriore istanza dell’applicazione (senza aver chiuso la prima) il metodo OnStartupNextInstance.

Questi due metodi, in particolare il secondo, ci consentono di decidere cosa fare dalla seconda istanza in poi. Inoltre, la classe SingleInstanceApplication è unica, possiamo gestire quei scenari in cui il lancio di una successiva istanza dell’applicazione deve far aprire una finestra figlia dell’applicazione principale (ad esempio un nuovo documento di word).

Tramite l’attributo _app della classe SingleInstanceApplication possiamo, infatti, interagire con l’applicazione in esecuzione.

Nell’esempio che trovate allegato ho realizzato un’applicazione che conta il numero di istanze che l’utente tenta di avviare successivamente alla prima.

Download sorgenti :

mercoledì 20 gennaio 2010

Quanti PC nel mondo hanno “a bordo” il framework?

Vi vorrei citare un post di Scott Hanselman in cui vengono dati dei numeri riguardo la diffusione nel mondo del framework .NET:

Scott Hanselman's Computer Zen - How many PCs in the world have the .NET Framework installed?

I numeri sono decisamente interessanti ma c’è da dire, però, che su Vista e Windows 7, c’è già la versione del framework “di serie”.

Technorati Tag:

lunedì 18 gennaio 2010

Briciole di WPF : Single instance application (soluzione 1).

Coloro che sviluppano in Windows Forms hanno la possibilità di definire, nelle proprietà dell’applicazione, se l’utente può eseguire più istanze della stessa.

WindowsFormSingleInstance Nelle applicazioni WPF non esiste questa proprietà:

WPFPropertiesPer poter controllare che la nostra applicazione WPF venga eseguita, al massimo, una sola volta, dobbiamo implementare del codice.

La soluzione che propongo in questo post si basa sull’utilizzo di un Mutex di sistema, cioè un oggetto di sincronizzazione che esiste a livello di sistema e che può essere controllato da processi diversi.

Quando un’applicazione WPF verrà eseguita, verificheremo la presenza di un Mutex di sistema con un ben determinato nome (quello dell’applicazione che si sta eseguendo):

  • se il mutex non esiste ne creeremo uno e procederemo all’esecuzione dell’applicazione;
  • se il mutex esiste (cioè un’altra applicazione è già in esecuzione) allora chiuderemo l’istanza dell’applicazione.

Cominciamo con il definire una function che si occupa di controllare l’esistenza del mutex:

  1. Protected Function MutexExists(ByVal mutexName As String) As Boolean
  2.     Dim _mutexExists As Boolean = False
  3.     Try
  4.         Dim _mutex = Mutex.OpenExisting(mutexName)
  5.         If _mutex IsNot Nothing Then
  6.             _mutexExists = True
  7.         End If
  8.     Catch ex As WaitHandleCannotBeOpenedException
  9.         _mutexExists = False
  10.     Catch ex As UnauthorizedAccessException
  11.         _mutexExists = True
  12.     End Try
  13.     Return _mutexExists
  14. End Function

Utilizziamo il metodo statico OpenExisting() della classe Mutex per cercare di aprire il Mutex. Nel caso in cui il mutex esista, il metodo non provocherà eccezioni mentre nel caso in cui il mutex non esiste (cioè non è possibile aprirlo) verrà sollevata l’eccezione WaitHandleCannotOpenedException.

Definita questa function possiamo utilizzarla all’interno dell’evento Statup della classe Application:

  1. Private Sub Application_Startup(ByVal sender As Object, ByVal e As System.Windows.StartupEventArgs) _
  2.             Handles Me.Startup
  3.     Dim mutexName = Me.Info.AssemblyName
  4.     If Not MutexExists(mutexName) Then
  5.         _instanceMutex = New Mutex(True, mutexName)
  6.     Else
  7.         MessageBox.Show("Esiste già un'applicazione attiva")
  8.         Me.Shutdown(1)
  9.     End If
  10. End Sub

L’attributo _instanceMutex è di tipo Mutex (namespace System.Threading):

  1. Private _instanceMutex As Mutex = Nothing

Se il mutex esiste, chiudiamo anticipatamente l’applicazione dopo aver visualizzato un messaggio.

Per pulizia gestiamo anche l’evento di chiusura dell’applicazione rilasciando il mutex:

  1. Private Sub Application_Exit(ByVal sender As Object, ByVal e As System.Windows.ExitEventArgs) _
  2.             Handles Me.Exit
  3.     If _instanceMutex IsNot Nothing Then
  4.         _instanceMutex.ReleaseMutex()
  5.     End If
  6. End Sub

Download Sorgenti:

giovedì 14 gennaio 2010

Data ufficiale del lancio di Visual Studio 2010?

Sembrerebbe pubblica la data di lancio di Visual Studio 2010.

Secondo il blog di Rob Caron (http://blogs.msdn.com/robcaron/archive/2010/01/13/9948172.aspx) sarebbe il 12 Aprile 2010.

Laconico il post, sarà vero?

Technorati Tag:

Briciole di WPF : Attached Properties

Le attached properties sono state introdotte con WPF e rappresentano un particolare tipo di proprietà/non proprietà di oggetti WPF.

Prendiamo un pezzo di XAML:

  1. <Window x:Class="MainWindow"
  2.     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  3.     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  4.     Title="MainWindow" Height="350" Width="525">
  5.     <Grid>
  6.         <Grid.RowDefinitions>
  7.             <RowDefinition Height="30"></RowDefinition>
  8.             <RowDefinition Height="*"></RowDefinition>
  9.             <RowDefinition Height="30"></RowDefinition>
  10.         </Grid.RowDefinitions>
  11.         <Button Grid.Row="2" x:Name="btnPremi">Premi</Button>
  12.     </Grid>
  13. </Window>

Abbiamo definito una griglia con tre righe e abbiamo posizionato un bottone nella terza riga.

Per posizionare il bottone abbiamo impostato la proprietà Grid.Row del bottone stesso. In realtà questa proprietà non è una proprietà della classe Button ma è un’attached property, cioè una proprietà che fa riferimento al contenitore immediatamente superiore.

In realtà, un’attached property non è neanche una proprietà nel modo canonico in cui le conosciamo ma si traduce nella chiamata di un metodo. Il parser dello XAML, quando incontra una attached property, richiama il metodo statico SetNomeProprietà() della classe contenitore.

Nell’esempio precedente, quando il parser XAML incontra l’assegnazione Grid.Row=”2”, effettua la chiamata al metodo statico Grid.SetRow().

Se verifichiamo (utilizzando Reflector) come è realizzato il metodo statico SetRow(), otteniamo:

Il_metodo_Grid_SetRowAlla fine dei conti, il valore dell’attached property non viene memorizzato nel contenitore ma all’interno del controllo stesso.
In pratica, nell’esempio precedente, viene eseguita la seguente istruzione:

  1. btnPremi.SetValue(Grid.RowProperty, 2)

Il metodo SetValue è un metodo definito nella classe DependencyObject da cui la classe Button deriva indirettamente.

L’attributo statico Grid.RowProperty è di tipo DependencyProperty:

Definizione_Grid_RowPropertySe andiamo ad indagare come funziona il metodo SetValue() della classe DependencyObject scopriamo che il valore dell’attached property viene memorizzato nell’array privato

  1. Private _effectiveValues As EffectiveValueEntry()

della classe DependencyObject.

Le attached properties ci consentono di poter introdurre properietà in nuovi controlli che possono essere utilizzate anche da controlli pre-esistenti, garantendo in questo modo un’ottima estendibilità del framework.

lunedì 11 gennaio 2010

Briciole di WPF : Proprietà e TypeConverter

Il modo più semplice per assegnare il valore ad una proprietà di un controllo XAML, è quello di valorizzare il corrispondente attributo del tag XML:

  1. <TextBlock Background="Yellow" FontSize="14">
  2. </TextBlock>

In questo caso impostiamo a giallo il colore di sfondo del TextBlock e il FontSize a 14.

Se analizziamo la classe TextBlock possiamo osservare che la proprietà Background è di tipo Brush mentre la proprietà FontSize è di tipo Double.

Come fa il parser XAML ad assegnare correttamente gli oggetti alle rispettive proprietà visto che il valore degli attributi è stringa?
Per queste operazioni intervengono i TypeConverter la cui classe di base (TypeConverter) esiste fin dalla prima versione del framework ma che trovano larghissimo impiego in WPF.

Un Type Converter mette a disposizione dei metodi che consentono di convertire un oggetto in un altro e viceversa. In questo caso, essendo i valori delle proprietà indicati con delle stringhe, i metodi trasformano la stringa in un opportuni oggetti.

Quando il parser XAML incontra l’assegnazione di proprietà attraverso un attributo, esegue i seguenti passi:

  1. Esamina la dichiarazione della proprietà per verificare se è presente l’attributo TypeConverter che indica, se presente, quale classe si occupa della conversione. Se tale attributo è presente, il framework utilizza l’opportuno TypeConverter per effettuare la conversione ed assegnare la proprietà;
  2. Se la proprietà non ha l’attributo TypeConverter, il framework verifica l’eventuale attributo TypeConverter presente nella definizione della classe tipo della proprietà. Se presente, il framework utilizza la classe definita in questo attributo per la conversione e la relativa assegnazione;
  3. Se non sono verificati i primi due passi, si ottiene un errore.

Vediamo come ragiona il parser nelle due proprietà precedenti.

Nel caso della proprietà Background, questa non è decorata con l’attributo TypeConverter, come possiamo vedere utilizzando Reflector:

TextBlock_Backgroundquindi il parser XAML analizza la classe Brush per vedere quale TypeConverter utilizzare per la conversione della stringa “Yellow”:

Classe_BrushLa classe Brush è decorata con l’attributo TypeConverter che comunica al framework di utilizzare BrushConverter per la conversione dal tipo String.

Nel caso dell’attributo FontSize=”14”, invece, il framework recupera il converter da utilizzare direttamente dalla proprietà FontSize del TextBlock:

TextBlock_FontSize In particolare, il framework utilizzerà il FontSizeConverter per convertire il valore da stringa a Double.

I TypeConverter possono essere utilizzati anche a livello di codice. Per esempio, per convertire una stringa in un FontSize possiamo scrivere:

  1. Dim fontSizeConv = New FontSizeConverter
  2. Dim fontSize = fontSizeConv.ConvertFrom("14")

Technorati Tag: ,,,

giovedì 7 gennaio 2010

Briciole di WPF: Gerarchia delle classi di WPF

In questo post voglio esaminare la gerarchia delle classi presenti nel framework WPF (almeno per quel che riguarda l’aspetto grafico).

La seguente figura mostra il diagramma delle classi delle classi di base:

ClassDiagram

Vediamo le caratteristiche di ogni classe:

  • DispatcherObject : Analogamente a quanto accade per le Windows Forma, anche le applicazioni WPF utilizzano il modello Single-Thread Affinity (STA). Questo significa che i controlli dell’interfaccia utente sono “posseduti” da un solo thread e non è possibile accedere a tali controlli da un altro thread. La gestione di questo modello di threading è demandata ad un oggetto Dispatcher che si occupa di gestire i messaggi di sistema (pressione dei tasti, movimento del mouse, etc., etc.). Gli elementi che derivano da DispatcherObject hanno la capacità di verificare se il codice sta “girando” nel thread corretto o no e di utilizzare il Dispatcher per permette al codice di gestire i controlli nel thrad corretto;
  • DependencyObject : In WPF le proprietà degli oggetti giocano un ruolo fondamentale perchè sono i membri delle classi che possono subire il binding dei dati, interagire con le animazioni nell’onterfaccia grazfica e molto altro. Tra le funzionalità più importanti abbiamo la possibilità di utilizre le Dependency Properties (di cui parleremo approfonditamente in un altro tutorial) la cui gestione viene implementata in questa classe;
  • Visual : Ogni elemento che compare in una interfaccia grafica WPF è un oggetto che deriva da Visual. La classe Visual rappresenta la classe astratta di una qualsiasi entità disegnabile, incapsula le funzionalità di disegno, ulteriori dettagli su come il disegno deve essere eseguito e altre funzionalità di base. La classe Visual fornisce il punto di giunzione tra la libreria in codice Managed di WPF e le primitive presenti all’interno della libreria milcore.dll;
  • UIElement : La classe UIElement fornisce le funzionalità di base per il layout, input, il focus e gli eventi. In questa classe viene gestito lo spostamento del mouse, la pressione dei tasti e così via. In questa classe viene gestito anche il supporto ai comandi;
  • FrameworkElement : La classe FrameworkElement implementa effettivamente dei membri che sono definiti in UIElement;
  • Shape : E’ la classe base per le figure geometriche;
  • Panel : E’ la classe base di tutti i contenitori di oggetti di WPF;
  • Control : La classe Control rappresenta un qualsiasi controllo che può interagire con l’utente in termini di eventi del mouse, della tastiera, etc., etc. Questa classe fornisce il supporto ai Template.
  • ContentControl : E’ la classe base dei controlli che hanno contenuto composto da un singolo elemento (bottoni, textbox, etc., etc). Questo singolo contenuto può essere un qualsiasi oggetto, anche complesso, realizzato componendo elementi di interfaccia.
  • ItemsControl : E’ la classe base di tutti i controlli che contengono una collezione di elementi.

mercoledì 6 gennaio 2010

DotNetRomacesta - Due free pass per Basta Italia 2010

BASTA!Italia in cooperazione con DotNetRomaCestà mette in palio 2 free pass per l’evento 2010 che si svolgerà a Roma nei giorni 15 e 16 aprile, tra tutti coloro che entro il 20 gennaio manderanno un’e-mail a info@bastaitalia.it con oggetto “Dotnetromacestà” inserendo nel corpo della email il nome, cognome e azienda. L’estrazione avverrà in data 21 gennaio e i fortunati vincitori saranno resi noti sul portale dello User Group romano.

 

lunedì 4 gennaio 2010

Briciole di WPF: quanto è potente la scheda grafica?

WPF utilizza a pieno le funzionalità delle schede video di nuova generazione. Per fare questo, il framework di WPF assegna un livello di rendering alla scheda grafica che sta utilizzando. Tale valore può assumere tre differenti valori:

  • Livello 0 : la scheda video non dispone di accelerazione grafica. Corrisponde alla versione 7.0 delle API Directx;
  • Livello 1 : La scheda video dispone di accelerazione video parziale. Corrisponde ad una versione delle DirectX tra la 7.0 e la 9.0 (esclusa quest’ultima);
  • Livello 2 : La scheda grafica fornisce piena accelerazione video. Corrisponde alle versioni di DirectX maggiori o uguali a 9.0.

E’ possibile recuperare da codice tale valore interrogando il valore della proprietà Tier della classe RenderCapability.

  1. Dim renderTier = RenderCapability.Tier >> 16
  2. Select Case renderTier
  3.     Case 0
  4.         Me.TextBox1.Text = "Nessuna accelerazione grafica"
  5.     Case 1
  6.         Me.TextBox1.Text = "Parziale accelerazione grafica"
  7.     Case 2
  8.         Me.TextBox1.Text = "Completa accelerazione grafica"
  9. End Select

Il valore del livello di rendering si ottiene eseguendo lo shift dei primi 16 bit del valore della proprietà Tier. Questo perché la proprietà Tier è pensata per accogliere, in futuro nuove informazioni riguardo i livelli di rendering (ad esempio sotto livelli).

Per maggiori informazioni riguardo i livelli di rendering e la classe RenderCapability consultare il seguente link http://msdn.microsoft.com/it-it/library/ms742196.aspx.

venerdì 1 gennaio 2010

Complimenti a Matteo per l’MVP!!!

Ero quasi sicuro di scrivere questo post ma, per scaramanzia, non lo avevo detto neanche all’interessato (sia mai avessi portato sfiga).

Ora posso complimentarmi alla grande con il mitico Matteo!!!

L’MVP te lo meriti senza ombra di dubbio e sono onorato di poter lavorare con te!

Quando torni al lavoro, però ti tocca pagare da bere!! :-)

Technorati Tag: ,

Buon Anno Nuovo

Un mega augurio di un grandissimo 2010 a tutti i lettori del blog.

Speriamo che il nuovo anno sia ricco di soddisfazioni!!

buonanno2010