WPF - Keyboard shortcuts

Ignazio Catanzaro — Thu, 12 Jul 2012 12:45:24 +0100

Salve a tutti, dopo una lunga assenza scrivo questo piccolo post :)

Molte volte si ha bisogno di gestire i famosi quanto indispensabili shortcut da tastiera, vediamo come fare utilizzando C# e WPF :

Creiamo in una classe una variabile statica di tipo RoutedCommand :

public static RoutedCommand MioCommand = new RoutedCommand();

Inoltre, sulla variabile MioCommand bisogna necessariamente aggiungere una KeyGesture :

MioCommand.InputGestures.Add( new KeyGesture( Key.P , ModifierKeys.Control )); //Lo shortcut è CTRL+P

Successivamente nello xaml della nostra/o window/usercontrol andiamo ad aggiungere un oggetto di tipo CommandBinding all'interno della proprietà CommandBindings e ne impostiamo la proprietà command assegnando ad essa la variabile statica di tipo RoutedCommand :

<Window.CommandBindings>
<CommandBinding Command="{x:Static local:MiaClasse.MioCommand }" Executed="MioCommandExecuted"/>
</Window.CommandBindings>

Possiamo notare la presenza dell'evento "Executed" , tramite l'editor xaml generate l'event handler e all'interno di tale metodo eseguite le operazioni da effettuare alla pressione dello shortcut :

private void MioCommandExecuted( object sender, ExecutedRoutedEventArgs e )

{

//Operazioni varie

}

Per approfondire di piu l'argomento vi consiglio di dare una bella lettura ai seguenti articoli :

http://msdn.microsoft.com/it-it/library/system.windows.uielement.commandbindings.aspx

http://msdn.microsoft.com/it-it/library/system.windows.input.commandbinding.aspx

http://msdn.microsoft.com/it-it/library/system.windows.input.routedcommand.aspx

http://msdn.microsoft.com/it-it/library/system.windows.input.keygesture.aspx

Stay tuned ;)

Entity framework, metodo Last() non riconosciuto!

Ignazio Catanzaro — Mon, 09 Jan 2012 18:32:19 +0100

Salve a tutti!

Nella lista dei metodi delle entità generate da Entity Framework ci sono alcuni metodi che non vengono letteralmente riconosciuti dall'EF come metodi validi.

Uno tra tutti è il metodo Last() o LastOrDefault().

Se si vuole raggirare il problema si puo eseguire il metodo Last() su una lista generata a partire dall'Entity :

MiaEntità.Last() (Errore, EF non riconosce il metodo Last() come valido)

MiaEntità.ToList().Last() (Il metodo viene eseguito su una lista generica e pertanto il listato produce il risultato voluto).

Qui c'è una lista di tutti i metodi non supportati da EF : http://msdn.microsoft.com/en-us/library/bb738550.aspx

Stay tuned! ;)

Gestione Handly Printer

Ignazio Catanzaro — Fri, 17 Jun 2011 18:02:26 +0100

Salve a tutti!

Chi ha a che fare con il Mobile a livello aziendale, prima o poi si ritroverà ad armeggiare con le famose Handly Printers, ovvero, stampanti termiche di piccole dimensioni utilizzate ad esempio nell'ambito della tentata vendita.

Ogni stampante termica ha un suo SDK e nel migliore dei casi un linguaggio proprietario (come ad esempio le stampanti Zebra).

Ma se volessimo semplicemente stampare del testo (ad esempio una bolla, una fattura, etc) e la nostra applicazione potrebbe usufruire potenzialmente di N diversi tipi di stampanti? Implementare nel software N SDK risulterebbe tedioso.

Come fare quindi? Semplice, utilizzando la porta seriale impostata alla connessione del dispositivo (le stampanti vengono associate al terminale Mobile tramite Bluetooth).

In basso, il listato della classe PrintEngine che permette la stampa tramite connessione seriale.

Il suo utilizzo è molto semplice :

1) Creare un nuovo oggetto di tipo PrintEngine dando al costruttore come parametro il nome della porta seriale su cui è connessa la stampante

PrintEngine PE = new PrintEngine("COM1");

2) Aggiungere righe al documento da stampare tramite il metodo AddLine();

PE.AddLine("Ciao io sono la prima Linea di testo");

3) Lanciare la stampa tramite Print();

PE.Print();

4) Visualizzare un'anteprima (Opzionale) in una textbox con il metoto Preview();

//*******************************
//Ignazio Catanzaro - 2011      *
//                              * 
//For Compact Framework (CE-WM) *
//                              * 
//*******************************

using System;

using System.Linq;
using System.Collections.Generic;
using System.Text;
using System.IO.Ports;

namespace MPPrint
{
    public class PrintEngine
    {
	private SerialPort SerialConn;
	private List<string> Lines;
	private StringBuilder PreviewBuffer;

	public PrintEngine()
	{
		this.Lines = new List<string>();

		this.SerialConn = new SerialPort();
		this.SerialConn.BaudRate = 9600;
		this.SerialConn.Parity = 0;
            	this.SerialConn.StopBits = StopBits.One;
		this.SerialConn.DataBits = 8;
	}

        ~PrintEngine()
        {
            try
            {
                if (this.SerialConn.IsOpen)
                {
                    this.SerialConn.Close();
                }
            }
            catch
            {
            }
        }

	public void AddLine(string Line)
	{
            this.Lines.Add(Line);
	}

	public void AddLine(List<string> Lines)
	{
            this.Lines.AddRange(Lines);
	}

	public void ClearLines()
	{
	    this.Lines.Clear();
	}

	public void FormFeed()
	{
	    if (this.SerialConn.IsOpen)
	    {
		this.SerialConn.Write("\f");
	    }
	}

	public void Print()
	{
		int num = 1;
		if (this.SerialConn.IsOpen)
		{
			using (List<string>.Enumerator enumerator = this.Lines.GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					string current = enumerator.Current;
					if (current == "&&FF" | current == "&&0")
					{
						if (current == "&&FF")
						{
							this.FormFeed();
						}
					}
					else
					{
						byte[] bytes = Encoding.Default.GetBytes(current);
						this.SerialConn.Write(bytes, 0, bytes.Length);
						this.SerialConn.WriteLine("\r");
						num++;
					}
				}
			}
		}
	}

	public void PrintSpace()
	{
		if (this.SerialConn.IsOpen)
		{
			short num = 1;
			do
			{
				this.SerialConn.Write(" ");
				num += 1;
			}
			while (num <= 7);
		}
	}

	public string Preview()
	{
		this.PreviewBuffer = new StringBuilder();
		using (List<string>.Enumerator enumerator = this.Lines.GetEnumerator())
		{
			while (enumerator.MoveNext())
			{
				string current = enumerator.Current;
				if (!(current == "&&1" | current == "&&0"))
				{
					this.PreviewBuffer.Append(current);
					this.PreviewBuffer.Append("\r\n");
				}
			}
		}
		return this.PreviewBuffer.ToString();
	}
    }
}

Potete ottenere risultati come questo :

Potete, ad esempio, creare un piccolo linguaggio di markup e gestire formati di stampa diversi come ho fatto io per il mio software di gestione logistica/contabilità :

Come potete notare attraverso alcuni tag speciali : <Header></Header> , <Body></Body>, <Footer></Footer>, <Compress></Compress>, etc...

posso identificare le varie "zone" del formato ed operare sulla PrintEngine in modo tale da ottenere il risultato voluto.

Altra cosa "sfiziosa" è quella di creare dei "posizionatori", ovvero, delle variabili (in celeste nel formato) che a runtime vengono

letteralmente sostituite con i valori correnti, ad esempio : @DOMAG è il magazzino del documento che a runtime verra sostituito con (1) - Centrale (vedi foto stampa).

Spero di esservi stato d'aiuto! Alla prossima!

Stay Tuned!

Auguri di buona Pasqua!

Ignazio Catanzaro — Tue, 26 Apr 2011 10:15:07 +0100

Anche se un po in ritardo, auguri a tutti di buona Pasqua (passata ).

Spero l'abbiate trascorsa nel migliore dei modi :)

AUGURIIII!!!!

Enumeratori e Binding

Ignazio Catanzaro — Mon, 11 Apr 2011 17:14:31 +0100

Salve a Tutti! Oggi, effettuando il refactoring di un progetto ho avuto la necessita di gestire diverse enumerazioni e i relativi Binding ai controlli, in pratica l'interfaccia gestisce N combobox cui Items non sono altro che i valori di un dato Enumeratore. La questione relativamente al full framework è molto semplice ovvero basta utilizzare il metodo GetValues() della classe statica Enum per impostare come DataSource di un controllo i relativi valori dell'enumeratore :

tuaComboBox.DataSource = Enum.GetValues( typeof ( TuoEnumeratore ) );

Per quanto concerne il Compact Framework invece, la questione è leggermente più complessa in quanto il metodo GetValues non è implementato.

Abbiamo bisogno quindi di un metodo che dato come parametro l'istanza di un Enumeratore ci ritorni una lista o un'interfaccia IEnumerable :

    public static class Utilies
    {
        public static IEnumerable<Enum> EnumToList(Enum Enumeratore)
        {
            List<Enum> _enumerazioni = new List<Enum>();
            foreach (FieldInfo InfoValori in Enumeratore.GetType().GetFields(BindingFlags.Public))
            {
                _enumerazioni.Add((Enum)InfoValori.GetValue(Enumeratore));
            }
            return _enumerazioni;
        }
    }

Il metodo si utilizza molto semplicemente in questa maniera :

tuaComboBox.DataSource = EnumToList(new TuoEnumeratore());

Stay Tuned ;)