3- Les commandes

Une commande est une action que l’application exécute à la demande de l’utilisateur. La manière dont la commande est invoquée importe peu: Que l’utilisateur appuie sur Ctrl+C ou sélectionne Copier dans me menu Edition, il faut que la réponse soit la même: copier le contenu sélectionné. Le système de commande permet à un élément UI ( user interface = interface d’utilisateur ) de posséder un gestionnaire de commande. Les commandes se définissent de la manière suivante :

<Menu>
            <MenuItem Header=” Fichier “>
                <MenuItem Header=”Nouveau” Command=”New”/>
                <MenuItem Header=”Ouvrir” Command=”Open”/>
                <MenuItem Header=”Enregistrer” Command=”Save”/>

            </MenuItem>
</Menu>

Chaque objet dans le menu est associé à une commande, c’est tout ce qu’on a besoin.

Il y a cinq concepts sur qui se base le système des commandes :

• Command Object ( Objet de la commande ) : C’est un objet qui identifie un commande particulière comme le Copier ou le Coller.
• Input Binding ( Liaison d’entrée ) : Une association entre une entrée particulière ( comme Ctrl+C ) est une commande ( copie dans notre cas )
• Command Source ( Source de la commande ) : L’objet qui a invoquée la commande comme un bouton ou un Input binding.
• Command Target ( Cible de la commande ) :C’est l’élément de l’interface qui exécutera la commande.
• Command Binding ( Liaison de commande ) : C’est un objet sait comment gérer une commande particulière.

 

• Command Object :

Un objet de commande identifie une commande particulière. Il ne sait pas comment gérer cette commande, c’est la fonction des Command Binding.

WPF fournit un ensemble de classes qui définissent les commandes Standards. Ce la ne fait épargner la définition des commandes les plus utilisées. Ces classes sont :

• ApplicationsCommands : Ce sont les commandes communes à toutes les applications comme open, close, print …
• ComponentCommands : Ils permettent la navigation à travers l’information comme la sélection de texte…
• EditingCommands : Les commandes d’édition de texte comme l’italic, bold, center…
• MediaCommands : Commandes d’opértions multimédia comme play, pause, resume …
• NavigationCommands : Les commandes de navigation des explorateurs comme le Back, forward , refresh …

Il se trouve que parfois on veut créer des commandes personnalisées, WPF utilise pour cela une instanciation d’objets pour établir l’identité des commands. L’exemple suivant montre les étapes à suivre pour définir une commande personnalisée :

namespace commandscustomisé
{
    public class MyAppCommands
    {
        public static RoutedUICommand DiviseCommand;
        static MyAppCommands(){
            DiviseCommand = new RoutedUICommand(“Divise”, “Divise”, typeof(MyAppCommands) );
        }

    }
}

On a vu comment utiliser une commande strandard, mais l’utilisation d’une commande personnalisée est un peu différente. Pour notre exemple, il faut ajouter en XAML d’abord la syntaxe suivante au début du programme.:

<Window xmlns:m=”clr-namespace:commandscustomisé;assembly=MyLib” ….. /> 

puis :

<Grid>
        <Button Command=”m:MyAppCommands.DiviseCommand”>Divise</Button>
</Grid>

Cette expression signifie que la commande en question est défini dans la classe MyAppCommands.DiviseCommand.

• Input Binding :

Un input binding associe une forme particulière d’un input gesture comme un raccourci de clavier avec une commande. Deux input gesture sont disponibles : le MouseGestue qui est une entrée de souris particulière comme le double clic droit ou le Shift+clic gauche; et le KeyGesture qui correspond aux raccourcis clavier.

Pour comprendre comment créer des input bindings, on effectue des modifications sur l’exemple précédent ( les modifications sont marqué en gras ) :

namespace commandscustomisé
{
    public class MyAppCommands
    {
        public static RoutedUICommand DiviseCommand;
        static MyAppCommands(){
            InputGestureCollection DiviseInputs = new InputGestureCollection();
            DiviseInputs.Add(new KeyGesture(Key.D, ModifierKeys.Alt));
            DiviseCommand = new RoutedUICommand(“Divise”, “Divise”, typeof(MyAppCommands), DiviseInputs);
        }

    }
}

InputGestureCollection : C’est une collection ordonnée d’objet InputGesture.

• Command Source :

Un objet du type Command Source ( Source de la commande ) est un objet qui est utilisé pour invoquer une commande. Cela peut être un élément de l’interface d’utilisateur ( un bouton, un lien ) ou un Input Gesture ( raccourci clavier par exemple ). Ces Command Sourc implémentent l’interface ICommandSource  qui possède trois propriétés: Command, CommandTarget et CommandParameter. La propriété Command est la commande à invoquer, CommandTarget est l’objet sur lequelle la commande sera appliquée, et CommandParameter est un type de donnée qui fait passer des informations a gestionnaire de la Commande.

• Command Target :

La Command Target ( cible de la commande ) est l’élément sur lequel la commande sera exécutée. La source de la commande peut être définie explicitement. Pour comprendre l’utilité de ceci, prenons l’exemple d’une application qui dispose d’un TextBox et d’un PasswordBox, et prenons la commande coller. Cette commande peut être lancée par diverse manière: par une combinaison clavier Ctrl+C, un clic sur un bouton ou clic sur un objet appartenant à un menu ( MenuItem). Quand la commande coller est invoquée, elle visera deux cibles, le TextBox et PasswordBox. Or l’intéret d’un PasswordBox est justement de cacher le texte tapé et empêcher la copie de ce texte, d’ou la nécessité de désactiver cette commande pour les PasswordBox, en effet, la commande copier est automatiquement désactivée, donc on n’a pas à le faire.Reste à savoir maintenant comme indiquer la cible à la commande, cela peut se faire au niveau du code C# ou XAML, dans notre cas on va le faire en XAML :

<Window x:Class=”commandtarget.Window1″
    xmlns=”http://schemas.microsoft.com/winfx/2006/xaml/presentation”
    xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml”
    Title=”Window1″ Height=”300″ Width=”300″>
    <Grid >
        <TextBox Height=”23″ Margin=”110,68,48,0″ Name=”textBox1″ VerticalAlignment=”Top” />
        <Button Height=”23″ HorizontalAlignment=”Left” Margin=”14,102,0,0″ Name=”button1″ VerticalAlignment=”Top” Width=”75″  Command=”Paste” CommandTarget=”{Binding ElementName=textBox1}”>Coller</Button>

    </Grid>
</Window>

Vous l’avez compris, dans cet exemple on précise à la commande Paste (coller ) déclenché par le bouton Coller sa cible qui le TextBox1.

• Command Binding :

Certaines contrôles lance automatiquement certaines commandes, le TextBox par exemple gère la commane copy( copie ) et la commande paste ( coller ) . Mais que faire si on créer notre propre logique de gestion d’une commande particulière ?

Pour être plus clair, prenons la commande copy, cette commande se lance à tout moment et n’importe ou du moment que la commande est invoquée par un élément d’une application. Mais si on veut que cette commande soit lancée que par une fenêtre particulière ou un contrôle particulier, que doit-on faire ?

La classe CommandBinding résolvent ce problème. Un objet du type CommndBinding associe un objet de commande ( Command Object ) spécifique avec une fonction de gestion pour un élément particulier ou une fenêtre particulière.

La classe commandBinding possède la propriété Command ainsi que les événements PreviewExecuted, Executed, PreviewCanExecute, et CanExecute.

Une Command Binding à la racine Window se définit de la manière suivante :

public class maFenetre :Window {

public maFenetre(){

InitializeComponent;

CommandBinding OpenBinding = new CommandBinding( ApplicationCommnds.Open, OpenExecuted, OpenCanExecute);         

CommandBindings.Add(OpenBinding);

}

}

On crée ensuite deux gestionnaires, ExecutedRoutedEventHandler et un CanExecuteRoutedEventHandler, le premier affiche un texte qui indique que la commande a été exécutée:

void OpenExecuted(object target, ExecutedRoutedEventArgs e)
{
    String commande, cible;
    commande = ((RoutedCommand)e.Command).Name;
    cible = ((FrameworkElement)target).Name;
    MessageBox.Show(“La ” + commande +  ” commande a été invoqué sur la cible ” + cible);

et le deuxième affecte la valeur True à la propriété CanExecute , ce gestionnaire active la commande :

void OpenCmdCanExecute(object sender, CanExecuteRoutedEventArgs e)
{
    e.CanExecute = true;

}

La commande sur laquelle est définie la Command Binding définit la portée de la de cette liaison, dans notre exemple, la liaison a été définie sur la fenetre maFenetre, alors cette liaison est aussi défini pour tous les éléments descendants de cette fenêtre comme un boutons ou TextBox.