Brian Harry (
) ha annunciato (qui il post) il rilascio della versione RC di Visual Studio 2010 per gli abbonati MSDN. Da mercoledì prossimo dovrebbe essere disponibile per tutti.
Vi segnalo una notizia apparsa sul sito di DotNetRomaCestà:
http://www.dotnetromacesta.org/Notizie.aspx?IdNews=106
Si tratta della nuova versione di Vivo 3 portatile, un programma unico ed in italiano che far parlare il computer, molto utile per le persone che hanno difficoltà di lettura.
Si tratta di un programma che non necessita di installazione. E, poi, è italiano!!!
Vorrei segnalarvi il seguente accessorio per SnagIT che permette di catturare un’immagine dallo schermo (come fa normalmente SnagIT) e di inserirla all’interno di Visual Studio Team System.
Maggiori indicazioni sulla pagina di download dell’accessorio:
http://www.techsmith.com/snagit/accessories/teamsystem.asp
o nella guida PDF scaricabile dalla stessa pagina.
Vorrei segnalarvi un interessante post di Lorenzo Barbieri sul Blog MSDN relativo allo stato dell’arte dell’ALM:
Decisamente interessante.
In WPF, come accade in Windows Form, possiamo incorporare delle risorse (immagini, file sonori, video, etc, etc.) all’interno di un assembly.
La modalità con cui eseguiamo questa operazione è però più vicina al mondo web che non al mondo delle Windows Forms. Per poter inserire un file di risorse all’interno di un nostro assembly è sufficiente creare una o più cartelle all’interno del progetto e, quindi, inserirvi i file da includere come risorse. Per finire è sufficiente che tali file abbiamo la proprietà Build Action impostata su Resource.
Ad esempio, nel seguente progetto abbiamo incorporato 6 immagini e un file audio:
Nelle Windows Forms, invece, incorporiamo le risorse aggiungendole al file Resources.resx.
Nel caso precedente, nel momento in cui compiliamo, le risorse vengono inserite nell’assembly come stream di byte. Per verificare questo, possiamo aprire l’assembly con le risorse tramite Reflector:
Osserviamo la presenza di un oggetto memory stream per ogni file di risorsa incorporato.
Per poter estrarre ed utilizzare le risorse all’interno del nostro codice abbiamo due strade.
La più complessa è quella di creare degli oggetti di classe UnmanagedMemoryStream come nel seguente pezzo di codice in cui estraiamo lo stream relativo alla risorsa “smile.png”:
Questa modalità è simile a quella che si ottiene utilizzando il metodo GetManifestResourceStream() e, come questa, nasconde la difficoltà di utilizzare uno stream di dati.
Fortunatamente WPF ci mette a disposizione un metodo molto più semplice per referenziare delle risorse incorporate, un metodo che sa molto di web.
A livello di XAML basta scrivere:
Quindi la nostra risorsa è recuperabile con un URI (di tipo relativo) sullo stile delle immagini dei siti web.
Il meccanismo precedente è utilizzabile anche per le risorse presenti in un assembly esterno. In questo caso la sintassi è del tipo:
Anche dal punto di vista del code behind di WPF, possiamo impostare la proprietà Source di un controllo image tramite un URI:
In download potete trovare una semplice solution di Visual Studio 2010 in cui mostro come effettuare il caricamento di un’immagine da una serie di risorse utilizzando l’uri:
Questa briciola vuole mettere in evidenza il completo supporto alla trasparenza presente in WPF.
Nel fare questo effettueremo un confronto con il supporto fornito nelle Windows Forms nella creazione di finestre non rettangolari.
Partiamo da WPF. Creare finestre non rettangolari in WPF è assolutamente banale. Prendiamo ad esempio il seguente XAML:
L’immagine utilizzata come sfondo per il canvas principale è un’immagine con la trasparenza (nel nostro caso un png).
Per fare in modo che la Window supporti completamente la trasparenza è necessario:
In particolare, se impostiamo la proprietà AllowsTransparency a true, è fondamentale impostare la proprietà WindowStyle a None, altrimenti otteniamo un errore in fase di esecuzione.
In questo modo, otteniamo una finestra con una forma non rettangolare, ma non abbiamo la possibilità di spostare la finestra, in quanto non è presente la caption.
Per poter attivare lo spostamento della finestra cliccando su qualsiasi punto della finestra e trascinando la stessa è sufficiente scrivere il seguente codice come gestore dell’evento MouseLeftButtonDown:
Grazie ai routed events di WPF, la finestra viene spostata anche se ci posizioniamo con il mouse su qualsiasi controllo della nostra interfaccia che non gestisce il MouseLeftButtonDown. Nella solution che riporto nel download in fondo al post abbiamo un textblock e un button: possiamo spostare la finestra se clicchiamo sul textblock ma non sul bottone (quest’ultimo ha il gestore dell’evento click).
Vediamo, ora, come realizzare la stessa interfaccia con una windows forms. Le tecniche che si possono utilizzare per realizzare una form non rettangolare con Windows Forms sono sostanzialmente due: disegnando tramite le classi Drawing la region dell’interfaccia grafica nel metodo OnPaint della finestra oppure, più semplicemente, impostando nel seguente modo le proprietà della finestra:
In questo caso la nostra immagine è presente nelle risorse del progetto (ma potrebbe essere letta anche da file) ed ha un colore scelto da noi (celeste (0,255,255) in questo caso) per indicare la parte di finestra trasparente.
Il risultato è una finestra di questo tipo:
Il problema nasce quando vogliamo abilitare il trascinamento della finestra da parte dell’utente. In questo caso dobbiamo simulare ciò che accade quando è presente la caption e l’utente è in grado di cliccare con il mouse al di sopra della stessa e trascinare l’intera finestra tenendo premuto il tasto sinistro del mouse.
Per fare questo dobbiamo utilizzare P/Invoke ed importare le seguenti funzioni:
Potete trovare maggiori riferimenti alle API utilizzate ai seguenti link: SendMessage e ReleaseCapture.
Utilizziamo queste API contenute nella user32.dll per simulare le azioni che esegue l’utente al di sopra della caption della finestra nel momento in cui decide di spostarla:
Utilizziamo questa funzione all’interno del gestore di evento mousemove della form e di tutti i controlli che non hanno interazione diretta con l’utente (nel nostro caso la label).
In definitiva possiamo osservare che, per sua natura intrinseca WPF ci consente di realizzare la form non rettangolare agendo semplicemente nello XAML e sfruttando le caratteristiche di trasparenza dei formati grafici, inoltre ci semplifica la vita nella gestione del drag and drop della finestra non costringendoci all’utilizzo di P/Invoke (che tra le altre cose rende l’applicazione poco portabile).
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:
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:
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.
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:
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:
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:
In 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:
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:
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:
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:
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:
e modifichiamo le proprietà dell’applicazione WPF per far eseguire la classe Startup all’avvio. Per fare questo è sufficiente:
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 :
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”.
Post
Tutti i commenti
