Discussion :

[BenoitM]

Bonjour,
Je souhaiterai changer la propriété background de certains de mes controles et dans certaines conditions

Exemple, j'ai les controles suivant:
textbox: txtNom, txtPrenom, txtNomConjoint
checkbox: cbConjoint:

j'aimerai mettre la txtNomConjoint en rouge si cbConjoint est checker

Vous avez des idées à me proposer?

ps: la validation rule ne marche pas car je souhaite que le backgroud reste en rouge même si le champ est rempli

[yonpo]

Salut,

Voici un exemple en passant par une propriété :

Code xaml :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
<CheckBox Name="cbConjoint" IsChecked="{Binding Checked}"/>
        <TextBox Name="txtNomConjoint">
            <TextBox.Style>
                <Style TargetType="{x:Type TextBox}">
                    <Setter Property="Background"  Value="White"/>
                    <Style.Triggers>
                        <DataTrigger Binding="{Binding Checked}" Value="True">
                            <Setter Property="Background"  Value="Red"/>
                        </DataTrigger>
                    </Style.Triggers>
                </Style>
            </TextBox.Style>
        </TextBox>

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
public partial class MainWindow : Window, INotifyPropertyChanged
    {
        private bool _checked;
        public bool Checked
        {
            get { return _checked; }
            set { _checked = value; RaisePropertyChanged("Checked"); }
 
        }
 
        public MainWindow()
        {
            InitializeComponent();
            Checked = true;
            this.DataContext = this;
        }
 
        public event PropertyChangedEventHandler PropertyChanged;
 
        protected void RaisePropertyChanged(string propertyName)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null)
                handler(this, new PropertyChangedEventArgs(propertyName));
 
        }
    }

Le code n'est qu'un exemple simple pour comprendre facilement. Pour faire proprement, la propriété serait déclaré dans un ViewModel et le ViewModel lié à la vue.

[BenoitM]

Le problème d'une telle technique ce que je vais avoir besoin de plusieurs propriétés et pour chaque couleurs.

J'aurai bien voulu passer par une méthode qui recoit le nom du controle et j'aurai renvoyer la couleur de fond à appliquer

[yonpo]

J'aurai bien voulu passer par une méthode qui recoit le nom du controle et j'aurai renvoyer la couleur de fond à appliquer

En passant par un converter :

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
public class BoolToBrushConverter : IValueConverter
    {
 
        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            if (value == null || parameter == null)
                return value;
 
            Brush brush = Brushes.White;
            if ((bool)value)
            {
                switch (parameter.ToString())
                {
                    case "txtNomConjoint":
                        brush = Brushes.Red;
                        break;
                    default:
                        break;
                }
            }
            return brush;
        }
 
        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }

Code xaml :

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

1
2
3
4
5
6
7
8
9
<Window.Resources>
        <conv:BoolToBrushConverter x:Key="BoolToBrushConverter"/>
    </Window.Resources>
    <StackPanel>
        <CheckBox Name="cbConjoint"/>
        <TextBox Name="txtNomConjoint" Background="{Binding ElementName=cbConjoint, Path=IsChecked, 
            Converter={StaticResource BoolToBrushConverter}, ConverterParameter=txtNomConjoint}">
        </TextBox>
    </StackPanel>

[sisqo60]

Bonjour,

Je passerai par une attachedProperty si j'étais toi. Bien plus générique.

Bon dév.

[Lordinaire]

Salut,

Tu peux aussi regarder du côté de l'interface

Code :

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

IDataErrorInfo

qui permet de gérer les règles métiers à part. Il suffit juste de créer le style que tu désires, dans ton cas un Background rouge, quand une erreur est détectée.

http://msdn.microsoft.com/fr-fr/libr...errorinfo.aspx
http://codeblitz.wordpress.com/2009/...dataerrorinfo/

[BenoitM]

Merci à tous,

Finalement j'ai opté pour :
creer un enum avec mes états :

Code :

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

1
2
3
4
5
6
7
 
public enum FieldState
    {
        Default =0,
        Mandatory = 1,
        Optional = 2,        
    }

creer un control dérivé de TextBox au quel j'ai ajouté une propriété :

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
 
public partial class myTextBox : TextBox
    {
        public static readonly DependencyProperty FieldStateProperty = DependencyProperty.Register(
          "FieldState", typeof(Tools.FieldState), typeof(myTextBox), new PropertyMetadata(Tools.FieldState.Default));
 
        public Tools.FieldState FieldState
        {
            get { return (Tools.FieldState)this.GetValue(FieldStateProperty); }
            set { this.SetValue(FieldStateProperty, value); }
        }
 
         public myTextBox()
            : base()  { }
    }

ensuite j'ai crée un style

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
 
<Style TargetType="{x:Type myControls:myTextBox}" BasedOn="{StaticResource ValidationErrorStyle}">
        <Setter Property="FontSize" Value="11" />
        <Setter Property="FontFamily" Value= "Microsoft Sans Serif"/>
        <Style.Triggers>
            <Trigger Property="myControls:myTextBox.IsReadOnly" Value="True">
                <Setter Property="myControls:myTextBox.Background" Value="#FFECE9D8" />
                <Setter Property="myControls:myTextBox.Foreground" Value="Black" />
                <Setter Property="TextBox.IsTabStop" Value="False" />
            </Trigger>
            <Trigger Property="myControls:myTextBox.FieldState" Value="1"  >
                <Setter Property="myControls:myTextBox.Background" Value="{StaticResource MandatotyColor}" />
           <Trigger Property="myControls:myTextBox.FieldState" Value="2"  >
                <Setter Property="myControls:myTextBox.Background" Value="{StaticResource OptionalColor}" />
            </Trigger>
        </Style.Triggers>
    </Style>

Ca marche plutot bien part contre vous savez comment je peux remplacer Value="1" par l'enum "FieldState.Mandatory"?

[BenoitM]

Code :

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

Value="{x:Static myTools:FieldState.Mandatory}"

Bon part contre il trouve pas l'autocomplete mais bon ca marche :p

[sisqo60]

Bonjour,

Si tu veux le même fonctionnement pour un combobox et éventuellement plein d'autres composants, tu vas tous les deriver?

Je persiste avec mon attached property sur le type Control. A toi de voir

Bon dév.

[BenoitM]

Je persiste avec mon attached property sur le type Control. A toi de voir

Je vais relire une 2eme fois (plus attentivement et en anglais) parce que j''ai vu comment ca pouvait m'aider.

[sisqo60]

Bon ben un exemple alors :

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
public static bool GetMandatory(DependencyObject obj)
{
    return (bool)obj.GetValue(MandatoryProperty);
}
 
public static void SetMandatory(DependencyObject obj, bool value)
{
    obj.SetValue(MandatoryProperty, value);
}
 
// Using a DependencyProperty as the backing store for Mandatory.  This enables animation, styling, binding, etc...
public static readonly DependencyProperty MandatoryProperty =
    DependencyProperty.RegisterAttached("Mandatory", typeof(bool), typeof(Control), new UIPropertyMetadata(false, OnMandatoryPropertyChanged));
 
public static void OnMandatoryPropertyChanged(object sender, DependencyPropertyChangedEventArgs args)
{
    //Tu peux aussi jouer avec des styles, mais là je met les couleurs en dur
    Control c = (Control)sender;
    if (Convert.ToBoolean(args.NewValue))
        c.SetValue(Control.BackgroundProperty, Brushes.Salmon);
    else
        c.SetValue(Control.BackgroundProperty, SystemColors.ControlLightLightBrush);
}

et en xaml

Code :

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

1
2
3
4
        <CheckBox Name="cb" />
        <Slider Minimum="0" Maximum="10000"  self:MaClasse.Mandatory="{Binding IsChecked, ElementName=cb}"/>
        <TextBox Name="toto"  Text="Toto" self:MaClasse.Mandatory="{Binding IsChecked, ElementName=cb}"/>
        <ComboBox self:MaClasse.Mandatory="{Binding IsChecked, ElementName=cb}"/>

Et le tour est joué et c'est valable pour tous les controles ...

[BenoitM]

Merci
le

Code :

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

self:MaClasse.Mandatory

m'a bien aidé car je trouvais pas ma propriété

Je vais continuer mes tests

[Nathanael Marchand]

Tu peux faire un behavior qui, quand il est utilisé va chercher, grâce à la reflexion si la propriété possède un attribut Required

[Nathanael Marchand]

Voici ma solution:

Le behavior:

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
public class ColorIfRequiredBehavior : Behavior<TextBox>
{
	public static readonly DependencyProperty RequiredBrushProperty =
			DependencyProperty.Register("RequiredBrush", typeof(Brush), typeof(ColorIfRequiredBehavior), new PropertyMetadata(default(Brush)));
 
	public static readonly DependencyProperty NotRequiredBrushProperty =
			DependencyProperty.Register("NotRequiredBrush", typeof(Brush), typeof(ColorIfRequiredBehavior), new PropertyMetadata(default(Brush)));
 
	public Brush NotRequiredBrush
	{
		get { return (Brush)GetValue(NotRequiredBrushProperty); }
		set { SetValue(NotRequiredBrushProperty, value); }
	}
 
	public Brush RequiredBrush
	{
		get { return (Brush)GetValue(RequiredBrushProperty); }
		set { SetValue(RequiredBrushProperty, value); }
	}
 
	protected override void OnAttached()
	{
		base.OnAttached();
		var be = AssociatedObject.GetBindingExpression(TextBox.TextProperty);
		var pi = be.ResolvedSource.GetType().GetProperty(be.ResolvedSourcePropertyName);
		AssociatedObject.Background = pi.GetCustomAttributes(typeof(RequiredAttribute), true).Length > 0 ? RequiredBrush : NotRequiredBrush;
	}
}

Les propriétés:

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
[Required]
public String MyRequiredField
{
	get { return _myRequiredField; }
	set
	{
		_myRequiredField = value;
		OnPropertyChanged("MyRequiredField");
	}
}
 
public String MyNotRequiredField
{
	get { return _myNotRequiredField; }
	set
	{
		_myNotRequiredField = value;
		OnPropertyChanged("MyNotRequiredField");
	}
}

L'utilisation:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<TextBox Grid.Row="0"
	Text="{Binding Path=MyRequiredField}"
	Margin="5">
	<i:Interaction.Behaviors>
		<WpfApplication1:ColorIfRequiredBehavior NotRequiredBrush="PaleGreen" RequiredBrush="PaleGoldenrod" />
	</i:Interaction.Behaviors>
</TextBox>
<TextBox Grid.Row="1"
	Text="{Binding Path=MyNotRequiredField}"
	Margin="5">
	<i:Interaction.Behaviors>
		<WpfApplication1:ColorIfRequiredBehavior NotRequiredBrush="PaleGreen" RequiredBrush="PaleGoldenrod" />
	</i:Interaction.Behaviors>
</TextBox>

[BenoitM]

sisqo60 j'ai une une erreur "A 'Binding' can only be set on a DependencyProperty of a DependencyObject." au run

Le probleme venait du fait que MaClasse ne dérivait pas de Control

Nathanael , ca va faire complexe quand je dois changer dynamiquement la valeur de l'attribut non?

[BenoitM]

Petit question avec IValueConverter
On ne peut passer qu'un string en "ConverterParameter" ?

[sisqo60]

Non, parameter c'est un object... Donc tu peux envoyer ce que tu souhaites... A toi de le récupérer dans la fonction.

voici la signature de la méthode :

Code :

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

Object Convert(Object value, Type targetType, Object parameter,	CultureInfo culture)

PS: MaClasse n'était pas définie dans le code que je t'ai envoyé mais oui il faut que ta classe hérite au minimum de DependencyObject

Bon dév.

[BenoitM]

Ah oki se serait plus logique de la faire dérivé de la plutot que de control :p
J'ai vu que c'était un objet part contre en Xaml j'ai pas l'impression qu'on puisse passer un objet du model


et autre question les converter on est obliger de les mettre en resources?

Code :

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

1
2
3
<Window.Resources>
        <conv:BoolToBrushConverter x:Key="BoolToBrushConverter"/>
    </Window.Resources>

[sisqo60]

oui à ma connaissance je ne connais pas d'autre moyen que les ressources...

Je crois que pour passer un objet en paramètre il faut utiliser un IMultiValueConverter

[Nathanael Marchand]

En effet, si la chose est dynamique, l'attribut n'est pas le bon candidat.

Pour les Converters, tu peux les utiliser comme ceci:

Code :

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

1
2
3
4
5
6
7
8
9
<TextBox>
  <TextBox.Text>
    <Binding Path="MaPropriete">
       <Binding.Converter>
         <monConverter/>
       </Binding.Converter>
    </Binding>
  </TextBox.Text>
</TextBox>

Plus d'infos: http://nathanaelmarchand.developpez..../?page=III#LVI