Masquer un élément en fonction de la valeur d'une propriété

**Pragmateek** · 04/08/2009, 12h03

Bonjour,

pour masquer un élément si une propriété est "null" il est possible d'utiliser le "Style" :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
<local:ControlTest>
	<local:ControlTest.Style>
		<Style TargetType="local:ControlTest">
			<Style.Triggers>
				<DataTrigger Binding="{Binding Path=PropertyTest}" Value="{x:Null}">
					<Setter Property="Visibility" Value="Collapsed" />
				</DataTrigger>
			</Style.Triggers>
		</Style>
	</local:ControlTest.Style>
</local:ControlTest>

Maintenant supposons qu'il existe un deuxième control du même type ou d'un autre qui doit aussi avoir un comportement similaire, on fait alors :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
<local:OtherControlTest>
	<local:OtherControlTest.Style>
		<Style TargetType="local:OtherControlTest">
			<Style.Triggers>
				<DataTrigger Binding="{Binding Path=OtherPropertyTest}" Value="{x:Null}">
					<Setter Property="Visibility" Value="Collapsed" />
				</DataTrigger>
			</Style.Triggers>
		</Style>
	</local:OtherControlTest.Style>
</local:OtherControlTest>

Et ainsi de suite, le code est dupliqué partout où le comportement "masqué si une propriété est null" est utilisé.

Comment factoriser ce comportement ?

Une possibilité semble être les propriétés attachées, mais est-il possible de les utiliser sans faire apparaitre d'élément supplémentaire dans le XAML, autre que la propriété sur les éléments cibles ?
Ce qui donnerait :

Code :

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

<local:ControlTest HideOnNull.Object="{Binding Path=PropertyTest}" >...

Ou bien une solution plus lourde serait la création d'un conteneur :

Code :

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

1
2
3
4
5
<local:HideOnNull Object="{Binding Path=PropertyTest}">
	<local:ControlTest>
	...
	</local:ControlTest>
</local:HideOnNull>

Quelles sont les solutions possibles, et laquelle vous parait la plus pertinente ?

Merci.

**NotANumber** · 04/08/2009, 14h15

Bonjour,

Si j'ai bien compris ce que vous cherchez, la solution qui me parait être la plus pertinente est l'utilisation d'un dictionnaire de ressource global, contenant un style comme vous l'avez déjà écrit :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
...
<Style TargetType="local:OtherControlTest">
			<Style.Triggers>
				<DataTrigger Binding="{Binding Path=OtherPropertyTest}" Value="{x:Null}">
					<Setter Property="Visibility" Value="Collapsed" />
				</DataTrigger>
			</Style.Triggers>
		</Style>
</ResourceDictionary>

Ainsi dans les fichier les xaml référençant le dictionnaire de ressources partagé tout les composant du type "local:OtherControlTest" auront le comportement souhaité sans rien écrire de plus.

**tomlev** · 04/08/2009, 14h16

La propriété attachée me semble une bonne solution, qui pourrait s'utiliser comme tu l'indiques.

Le code devrait être un truc dans ce style :

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
33
34
35
36
37
38
39
40
41
42
43
    public class HideOnNull
    {
 
        public static object GetObject(DependencyObject obj)
        {
            return (object)obj.GetValue(ObjectProperty);
        }
 
        public static void SetObject(DependencyObject obj, object value)
        {
            obj.SetValue(ObjectProperty, value);
        }
 
        // Using a DependencyProperty as the backing store for Object.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ObjectProperty =
            DependencyProperty.RegisterAttached(
                "Object",
                typeof(object),
                typeof(HideOnNull),
                new UIPropertyMetadata(
                    null,
                    (obj, e) => 
                    {
                        UIElement uiElement = obj as UIElement;
                        if (uiElement != null)
                        {
                            if (e.NewValue == DependencyProperty.UnsetValue)
                            {
                                // Si on efface la valeur de HideOnNull.Object, on remet la Visibility par défaut
                                uiElement.ClearValue(UIElement.VisibilityProperty);
                            }
                            else if (e.NewValue == null)
                            {
                                uiElement.Visibility = Visibility.Hidden;
                            }
                            else
                            {
                                uiElement.Visibility = Visibility.Visible;
                            }
                        }
                    }));
 
    }

**Pragmateek** · 04/08/2009, 16h24

Merci de vos réponses.

Tomlev ton implémentation fonctionne parfaitement, merci beaucoup.

**Pragmateek** · 04/08/2009, 17h55

Oups, en fait ça fonctionne parfaitement pour des valeur non "null" : le callback est bien invoqué et fait ce qu'il faut :

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
public static readonly DependencyProperty ObjectProperty =
            DependencyProperty.RegisterAttached("Object", typeof(object), typeof(CollapseIfNull), new UIPropertyMetadata(
                    null,
                    (obj, e) => 
                    {
                        UIElement uiElement = obj as UIElement;
                        if (uiElement != null)
                        {
                            if (e.NewValue == DependencyProperty.UnsetValue)
                            {
                                uiElement.ClearValue(UIElement.VisibilityProperty);
                            }
                            else if (e.NewValue.Equals("123"))
                            {
                                uiElement.Visibility = Visibility.Collapsed;
                            }
                            else
                            {
                                uiElement.Visibility = Visibility.Visible;
                            }
                        }
                    }));

et :

Code :

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

<local:UserControl1 local:CollapseIfNull.Object="123" />

Mais dès que "Object" est "null" le callback n'est en fait pas invoqué du tout !
Par exemple avec :

Code :

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

<local:UserControl1 local:CollapseIfNull.Object="{x:Null}" />

**tomlev** · 04/08/2009, 19h09

Ah ok... en fait c'est parce que null est la valeur initiale, donc quand tu affectes null ça ne provoque pas de DependencyPropertyChanged. Essaie d'enlever la valeur par défaut "null" dans le constructeur UIPropertyMetadata (laisse juste le callback). Ca devrait mettre comme valeur par défaut DependencyProperty.UnsetValue (soit pas de valeur), donc quand tu affecteras null le callback sera bien appelé

**Pragmateek** · 04/08/2009, 19h53

Merci encore c'est exactement le problème.

Toutefois, sauf erreur, il ne semble pas possible de faire ignorer "null", même en utilisant le constructeur à un paramètre.

En revanche spécifier "" comme valeur par défaut fait l'affaire puisqu'ici cette valeur n'a pas de sens si elle est spécifiée directement dans le XAML.
De plus, et là c'est plus inattendu, si la valeur à laquelle est bindé "Object" est la chaine "", tout marche quand même comme il faut : il ne la considère pas comme la valeur par défaut.
Il semble donc que cette notion de valeur par défaut soit spécifique au traitement du XAML.

Est-ce plausible ?

Quoiqu'il en soit encore un grand merci pour ton aide précieuse.

**tomlev** · 05/08/2009, 01h13

Envoyé par seriousme

Est-ce plausible ?

Euh... je sais pas

Sinon, tu peux essayer de spécifier DependencyProperty.UnsetValue comme valeur par défaut, ce serait plus propre que ""

**Pragmateek** · 05/08/2009, 10h04

Cela provoque la levée d'une exception.

Et ça semble confirmé par MSDN :

Setting a DefaultValue of UnsetValue is specifically disallowed.

http://msdn.microsoft.com/en-us/libr...nsetvalue.aspx

**tomlev** · 05/08/2009, 10h36

arf...
ben faut mettre une valeur bidon alors... éventuellement d'une classe privée spécifiquement créée pour ça, histoire de pas interférer avec d'autres valeurs "réelles" possibles

**Pragmateek** · 05/08/2009, 11h26

Excellente astuce, ça semble fonctionner avec un "enum" "private" :

Code :

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

1
2
3
4
private enum DefaultValues
{
    DefaultValue
}

Merci pour tout.

Masquer un élément en fonction de la valeur d'une propriété

Windows Presentation Foundation

Discussions similaires

Partager

Partager