Big .net Blog

Associare la pressione di un tasto a un Command (Binding KeyDown To Command)

Rudes Luca — Wed, 24 Nov 2010 17:27:00 GMT

Spero si rivela utile associare determinate operazioni alla semplice pressione di un tasto, l’esempio più banale è quello della pressione del tasto invio in mentre si ha il focus su una textBox per avviare la ricerca. Per risolvere questo basta semplicemente crearsi un trigger che verifica che tasto è stato premuto e passargli il command da eseguire.

namespace Fm.Silverlight.Controls
{
    using System.Windows;
    using System.Windows.Input;
    using System.Windows.Interactivity;

    /// <summary>
    /// Behavior per la gestione della pressione dell'invio
    /// </summary>
    public class KeyDownCommandAction : TriggerBase<UIElement>
    {
        #region Fields
        public static readonly DependencyProperty CommandParameterProperty;
        public static readonly DependencyProperty CommandProperty;
        #endregion

        #region Construct
        static KeyDownCommandAction()
        {
            CommandParameterProperty = DependencyProperty.Register("CommandParameter", typeof(object), typeof(KeyDownCommandAction), null);
            CommandProperty = DependencyProperty.Register("Command", typeof(object), typeof(KeyDownCommandAction), null);
        }
        #endregion

        #region Property
        /// <summary>
        /// Key da premere per richiamare l'evento
        /// </summary>
        public Key KeyPress
        {
            get;
            set;
        }

        /// <summary>
        /// Parameter per il command
        /// </summary>
        public object CommandParameter
        {
            get
            {
                return this.GetValue(KeyDownCommandAction.CommandParameterProperty);
            }

            set
            {
                this.SetValue(KeyDownCommandAction.CommandParameterProperty, value);
            }
        }

        /// <summary>
        /// Nome del command da richiamare
        /// </summary>
        public object Command
        {
            get
            {
                return this.GetValue(KeyDownCommandAction.CommandProperty);
            }

            set
            {
                this.SetValue(KeyDownCommandAction.CommandProperty, value);
            }
        }
        #endregion

        #region Methods
        protected override void OnAttached()
        {
            this.AssociatedObject.KeyDown += this.OnKeyDown;

            base.OnAttached();
        }

        protected override void OnDetaching()
        {
            this.AssociatedObject.KeyDown -= this.OnKeyDown;

            base.OnDetaching();
        }

        /// <summary>
        /// Verifica se il tasto premuto è quello desiderato /// </summary>
        /// <param name="s">Controllo che ha generato l'evento</param>
        /// <param name="e">Parametri dell'evento</param>
        private void OnKeyDown(object s, KeyEventArgs e)
        {
            if (e.Key == this.KeyPress)
            {
                ICommand cmd = (ICommand)this.Command;

                if (cmd.CanExecute(this.CommandParameter))
                {
                    cmd.Execute(this.CommandParameter);
                }
            }
        }
        #endregion
    }
}

Molto semplice, cosa abbiamo scritto :

Dichiariamo 2 DependencyCommand, per poter eseguire il Binding al nostro command (CommandProperty, Esposto solitamente da una ViewModel) e per poter eseguire il Binding di un parametro opzionale da passare al Command (CommandParametryProperty)
Diachiaramo una property di tipo Key di nome KeyPress, che è la proprietà tramite la quale setteremo il tasto che desideriamo sia premuto per invocare il command
Eseguiamo l’override del metodo OnAttach, per poter sottoscrivere l’evento KeyDown del controllo che ci interessa tenere sotto controllo
Eseguiamo l’override del metodo OnDetaching, per eliminazione la sottoscrizione all’evento
Con il metodo OnKeyDown, invocato a ogni pressione di tasto che avviene quando il nostro controllo ha il focus, verifichiamo che il tasto premuto sia quello desiderato e in caso positivo invochiamo il command desiderato

Per Utilizzare questo trigger ora ci basta aggiungere i seguenti namespace nello xaml :

xmlns:Fm_Silverlight_Controls="clr-namespace:Fm.Silverlight.Controls;assembly=Fm.Silverlight.Controls"
xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"

Ora Attacchiamo il trigger alla textBox che ci interessa :

In Questo esempio, assegno il trigger a una textBox specificando che alla pressione del tasto “Enter” deve esser chiamato il comando Cerca passando come parametro il testo contenuto nella textBox TxtSearch.

Technorati Tags: WP7,Silverlight,WPF,Trigger,Behavior

Selezione Completa della textbox (Select All Text Into TextBox, Trigger–Behavior)

Rudes Luca — Tue, 23 Nov 2010 09:25:00 GMT

Spesso è comodo che durante l’immissione di dati quando si mette a focus una textbox venga selezionato tutto il testo completo, ad esempio durante la compilazione di un ordine di magazzino quando si seleziona il numero di pezzi da spedire è comodo sovrascrivere l’intera informazione senza bisogna di selezionare manualmente il testo da modificare.

Per risolvere questo, ho creato un trigger:

namespace Fm.Silverlight.Controls
{
    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Interactivity;

    /// <summary>
    /// Behavior per la selezione del testo completo
    /// </summary>
    public class SelectAllCommandAction : TriggerBase<TextBox>
    {
        #region Methods
        protected override void OnAttached()
        {
            this.AssociatedObject.GotFocus += this.SelectAllText;

            base.OnAttached();
        }

        protected override void OnDetaching()
        {
            this.AssociatedObject.GotFocus -= this.SelectAllText;

            base.OnDetaching();
        }

        /// <summary>
        /// Seleziona interamente il testo
        /// </summary>
        /// <param name="sender">TextBox che ha lanciato l'evento</param>
        /// <param name="e">Argomenti dell'evento</param>
        private void SelectAllText(object sender, RoutedEventArgs e)
        {
            this.AssociatedObject.SelectionStart = 0;
            this.AssociatedObject.SelectionLength = this.AssociatedObject.Text.Length;
        }
        #endregion
    }
}

Questo trigger è di una semplicità disarmante. Non facciamo altro che eseguire l’override dell’evento OnAttached così da sottoscrivere l’evento Focus del controllo textBox a cui è associato il trigger, al generarsi dell’evento impostiamo SelectionLength pari alla lunghezza totale del contenuto della textBox.

Per Utilizzare questo trigger ora ci basta aggiungere i seguenti namespace nello xaml :

xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
xmlns:Fm_Silverlight_Controls="clr-namespace:Fm.Silverlight.Controls;assembly=Fm.Silverlight.Controls"

Ora Attacchiamo il trigger alla textBox che ci interessa :

Technorati Tags: WP7,Silverlight,WPF,Trigger,Behavior

DataAnnotation WP7, Input Validation (Copiando System.ComponentModel.DataAnnotations)

Rudes Luca — Thu, 18 Nov 2010 11:06:00 GMT

WP7 non può referenziare System.ComponentModel.DataAnnotations, però piacerebbe a tutti quanti noi utilizzare lo stesso sistema di valutazione dell’input che usiamo con il fratellone SL4 .

Come fare ???

Semplice, andiamo a scopiazzare qualche idea qua e là da System.ComponentModel.DataAnnotations grazie al fidato “Reflector” e creiamoci la personali library per la validazione dei dati. Procederemo nel seguente modo :

Creazione nuova dll per WP7
Scrittura di attributi di validazione
Creazione del sistema di validazione (Il sistema completo anche di Required, StringLength, RegularExpression, Range e CustomValidator sono disponibili nel codice sorgente a fine post)
Assegnazione dei attributi alle property che “bindiamo” nello xaml

Come base di partenza usiamo il progetto creato qui : Input Validation WP7

Creazione dll (Nel mio caso utilizzo Fm.Phone, disponibile nel file compresso in fondo al post)

Scrittura attribute di validazione. Io ad esempio adoro utilizzare le interfacce, quindi : dichiaro un’interfaccia con il metodo di validazione (IsValid), creo la classe ValidationAttribute che eredita da Attribute e dalla mia interfaccia. ValidationAttribute è la classe base che utilizzerò per creare tutti gli attributi di validazione specifici, questa classe conterà solo il messaggio di errore personalizzato da utilizzare in caso la validazione non vada a buon fine.

Interfaccia

namespace Fm.Phone.DataValidation
{
    public interface IValidationAttribute
    {
        void IsValid(object value);
    }
}

Classe Validation Attribute

namespace Fm.Phone.DataValidation
{
    using System;

    /// <summary>
    /// Attribute per la validazione delle property
    /// </summary>
    [AttributeUsage(AttributeTargets.Property)]
    public class ValidationAttribute : Attribute, IValidationAttribute
    {
        #region Construct
        /// <summary>
        /// Istanzia un nuovo attribute per la validazione
        /// </summary>
        internal ValidationAttribute()
            : this(string.Empty)
        {
        }

        /// <summary>
        /// Istanzia un nuovo attribute con testo errore personalizzato
        /// </summary>
        /// <param name="errore">Testo da usare in caso di errore</param>
        internal ValidationAttribute(string errore)
        {
            if (!string.IsNullOrEmpty(errore))
            {
                this.Errore = errore;
                this.UseCustomError = true;
            }
        }
        #endregion

        #region Property
        internal string Errore { get; private set; }

        internal bool UseCustomError { get; private set; }
        #endregion

        #region Method
        /// <summary>
        /// Inalza l'errore di validazione
        /// </summary>
        /// <param name="errore">Testo dell'errore</param>
        internal void Error(string errore)
        {
            throw new Exception(this.UseCustomError ? this.Errore : errore);
        }
        #endregion

        #region IValidationAttribute Members
        public virtual void IsValid(object value)
        {
            throw new NotImplementedException();
        }
        #endregion
    }
}

A questo punto abbiamo la nostra classe base, che vediamo accetta nel costruttore il possibile testo di errore personalizzato da utilizzare in caso di mancata validazione. La classe contiene per comodità anche un metodo che accetta un testo di errore, verifica se è stato settato un testo personalizzato e innalza l’eccezione.

Adesso procediamo alla creazione del primo validator (in questo post illustrerò la creazione di un solo validator, gli altri sono inclusi nel codice sorgente). Partiamo con il più utilizzato “Required”, questo validator verificherà che sono stati inseriti dei dati e non è stata lasciata vuota la property :

namespace Fm.Phone.DataValidation
{
    using System;

    /// <summary>
    /// Validazione per campo obbligatorio
    /// </summary>
    [AttributeUsage(AttributeTargets.Property, AllowMultiple=false)]
    public class RequiredAttribute : ValidationAttribute
    {
        #region Construct
        public RequiredAttribute()
            : this(string.Empty)
        {
        }

        public RequiredAttribute(string errore)
            : base(errore)
        {
        }
        #endregion

        #region Property
        public bool AllowEmptyStrings { get; private set; }
        #endregion

        #region Methods
        public override void IsValid(object value)
        {
            bool isNull = value == null;

            if (!isNull)
            {
                string str = value as string;

                if (str != null && !this.AllowEmptyStrings) { isNull = str.Trim().Length == 0;
                }
            }

            if (isNull)
            {
                this.Error("Campo Obbligatorio");
            }
        }
        #endregion
    }
}

Come possiamo vedere, ereditiamo da ValidationAttribute, eseguiamo l’override del Method IsValid, dove eseguiremo la verifica del valore della property per convalidarlo; in caso il valore sia null controlleremo se è una stringa vuota e se tale valore è possibile accettartlo (AllowEmptyString) in caso non sia valorizzata la property innalzeremo l’eccezione.

Adesso dobbiamo creare un metodo, che ci permetta di validare una property in base ai propri attribute :

namespace Fm.Phone.DataValidation
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Reflection;

    /// <summary>
    /// Classe per la gestione della validazione delle property
    /// </summary>
    public static class Validator
    {
        /// <summary>
        /// Valida la property
        /// </summary>
        /// <param name="context">Context di validazione</param>
        /// <param name="nameProperty">Nome della property da convalidare</param>
        public static void ValidateProperty(object context, string nameProperty)
        {
            PropertyInfo property = context.GetType().GetProperty(nameProperty);
            object value = property.GetValue(context, null);
            IEnumerable<IValidationAttribute> attrs = property.GetCustomAttributes(typeof(ValidationAttribute), true).Cast<IValidationAttribute>();

            foreach (IValidationAttribute att in attrs)
            {
                att.IsValid(value);
            }
        }
    }
}

Nel Metodo ValidateProperty della classe statica Validator, non facciamo altro che caricare la property, caricare i relativi ValidatorAttribute e tramite la loro interfaccia richiamare ogni metodo IsValid passando il valore della property. (Per comodità nel codice vedrete che ho fatto overload del method dove al posto di nameProperty passo un’expression così da rendere possibile il refactor del codice senza problemi e per togliermi dalle scatole stringhe di testo)

Quindi Vediamo come è la tipica property che vogliamo validare a questo punto :

        private string _property;
        [Required]
        public string TextProperty
        {
            get { return _property; }
            set
            {
                if (_property != value)
                {
                    _property = value;
                    OnPropertyChanged("TextProperty");
                    Validator.ValidateProperty<string>(this, () => this.TextProperty);
                }
            }
        }
Ora andiamo a Bindarla nel codice a una textBox e verifichiamone il funzionamento :

Il codice di esempio contiene anche altri validator : StringLength, RegularExpression, Range, Custom (Esegue la chiamata a un metodo).

Codice Sorgente Completo : ProvaErrorBinding_Validation.rar

Technorati Tags: WP7

Input Validation WP7

Rudes Luca — Wed, 17 Nov 2010 14:10:00 GMT

Per la validazione dei dati inseriti dall’utente in WP7 (Windows Phone 7), io utilizzo la seguente tecnica :

Creo uno style contenente anche il template per la validazione (in questo caso, ad esempio non faccio altro che ricopiare lo Style di una classica TextBox di SL4 (SilverLight 4), con anche il controlTemplate usato nel tooltip e il border per la validazione).
Nella Property quando viene modificato il valore, verifico che siano stati rispettati i criteri richiesti … in caso non siano stati rispettati, innalzo un’eccezione.

Vediamo in pratica di cosa sto parlando :

Apriamo Blend e inseriamo una textBox –> Dopo di che editiamone lo style

Modifichiamo lo Style, inserendo con attenzione il border per la segnalazione dell’errore, il tooltip che segnalerà che errore si è verificato e modifichiamo “InvalidUnfocused” “Invalidfocused” che rispettivamente gli stati che assume il nostro controllo in caso di “Errore controllo senza focus” “Errore controllo con focus”.

Border

TooTip

VisualState

A questo punto scriviamo la property a cui vogliamo legare la nostra textBox :

        private string _property;
        public string TextProperty
        {
            get { return _property; }
            set
            {
                if (_property != value)
                {
                    if (!string.IsNullOrEmpty(value))
                    {
                        if (value.Length < 5)
                        {
                            throw new Exception("Lunghezza minima 5 caratteri");
                        }
                    }
                    else
                    {
                        throw new Exception("Campo Obbligatorio");
                    }

                    _property = value;
                    OnPropertyChanged("TextProperty");
                }
            }
        }

Modifichiamo lo xaml per il binding della textBox :

<TextBox Margin="8" Text="{Binding TextProperty, Mode=TwoWay, NotifyOnValidationError=True, ValidatesOnExceptions=True}" Style="{StaticResource TextBoxStyle1}"/>

Avviamo il debug dell’app e vediamo il risultato :

Ecco fatto la nostra validazione in salsa WP7 uguale a quella del fratellone SL4

Download : ProvaErrorBinding.rar

Technorati Tags: WP7