Discussion :

[hirochirak]

Bonjour à tous.

Pour les besoins d'un projet je fais une petite interface Silverlight sous Visual Studio 2008.

Si je ne dis pas de bêtise je dois donc utiliser Silverlight 3.

Enfin bref j'essaie d'utiliser la propriété Command d'un objet button pour la binder à une fonction.

Le compilateur m'envoie boulet en m'insultant avec cette phrase :

The property 'Command' does not exist on the type 'Button' in the XML namespace 'http://schemas.microsoft.com/winfx/2006/xaml/presentation'.

Dois je créer moi même la DependencyProperty Command à l'objet Button ou me manque t'il quelquechose (Tools, namespace ou autres ...)

Cordialement

[tomlev]

La propriété Command des boutons n'existe que depuis SL 4

Mais tu dois pouvoir implémenter un CommandButton qui expose cette propriété...

Regarde cette réponse sur StackOverflow, il y a un exemple
http://stackoverflow.com/questions/3...502479#3502479

(par contre l'exemple est pour WPF, en SL il n'y a pas d'interface ICommandSource, ni de propriété CommandTarget ; il faudra donc adapter un peu)

[hirochirak]

Merci de la réponse.

Je vais tenter de créer moi même mon composant.

Si certains d'entre vous ont des pistes (a tout hasard)

[hirochirak]

Voici le résultat de mon button :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class ExtendedButton : Button
    {
        public static readonly DependencyProperty CommandProperty =
            DependencyProperty.Register("Command", typeof(ICommand), typeof(ExtendedButton), null);
 
        public ICommand Command
        {
            get { return (ICommand)GetValue(CommandProperty); }
            set { SetValue(CommandProperty, value); }
        }
 
        public static readonly DependencyProperty CommandParameterProperty =
            DependencyProperty.Register("CommandParameter", typeof(object), typeof(ExtendedButton), null);
 
        public object CommandParameter
        {
            get { return (object)GetValue(CommandParameterProperty); }
            set { SetValue(CommandParameterProperty, value); }
        }
 
        protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e)
        {
            base.OnMouseLeftButtonUp(e);
 
            ICommand command = this.Command;
            object parameter = this.CommandParameter;
 
            if (command != null && command.CanExecute(parameter))
                command.Execute(parameter);
        }
    }

Par contre pour lier mon bouton à une command je fais ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
public ICommand NextQuestionCommand { get; private set; }
this.NextQuestionCommand = new RelayCommand(NextQuestion, CanNextQuestion);
public void NextQuestion()
        {
            ...
        }
public bool  CanNextQuestion()
        {
            return ...
 
        }

Le bouton fonctionne bien si les conditions de CanNextQuestion ne sont pas remplis alors le bouton ne fait rien sauf que dans SL4, le bouton est directement grisé selon le résultat de la condition.

Comment puis remettre en place ce système, car pour le coup c'est beaucoup plus simple à gérer après

[tomlev]

Abonne-toi à l'évènement CanExecuteChanged de la commande. Quand cet évènement se produit, mets juste la valeur de CanExecute dans IsEnabled:

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
        public static readonly DependencyProperty CommandProperty =
            DependencyProperty.Register("Command", typeof(ICommand), typeof(ExtendedButton), new PropertyMetadata(null, OnCommandChanged));
 
        public ICommand Command
        {
            get { return (ICommand)GetValue(CommandProperty); }
            set { SetValue(CommandProperty, value); }
        }
 
        private static void OnCommandChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
        {
            ExtendedButton button = o as ExtendedButton;
            if (button == null)
                return;
 
            ICommand oldCommand = (ICommand)e.OldValue;
            ICommand newCommand = (ICommand)e.NewValue;
 
            // Désabonnement de l'ancienne commande
            if (oldCommand != null)
                oldCommand.CanExecuteChanged -= button.command_CanExecuteChanged;
 
            // Abonnement de la nouvelle commande
            if (newCommand != null)
                newCommand.CanExecuteChanged += button.command_CanExecuteChanged;
        }
 
 
        private void command_CanExecuteChanged(object sender, EventArgs e)
        {
            this.IsEnabled = this.Command == null || Command.CanExecute(CommandParameter);
        }