Discussion :

[micka132]

Bonjour
j'essaye de realiser un control avec plusieurs mode ( edition, visualisation, recherche...).
Le principe est le même que le dataform, c'est a dire que l'on peut définir un template pour chaque mode.

Je définis dans le généric.xaml de mon control le template de cette manière

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
 
<Style TargetType="custom:FormulaireEtat">
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="custom:FormulaireEtat">
                <Grid> 
                <ContentControl x:Name="TemplateVisualisation" Visibility="Visible">
                   <!-- mon template -->
                </ContentControl>
 
                <ContentControl x:Name="TemplateVisualisation" Visibility="Collapsed">
                      <!--mon template -->
                </ContentControl>
                </Grid>
.....

Je définis ensuite un evenement qui appel cette fonction

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
 
 void ButtonEdit_Click(object sender, RoutedEventArgs e)
 {
  ContentControl visualisation = this.GetTemplateChild(FormulaireEtat.CONST_TemplateVisualisation) as ContentControl;
  ContentControl edition = this.GetTemplateChild(FormulaireEtat.CONST_TemplateEdition) as ContentControl;
 
      if (visualisation != null)
      {
          if (edition != null)
          {
             visualisation.Visibility = Visibility.Collapsed;
             edition.Visibility = Visibility.Visible;
 
          }
       }
}

Le probème c'est que ca ne fonctionne pas:

Erreur*: Unhandled Error in Silverlight Application
Code: 2210
Category: RuntimeError
Message: AG_E_INVALID_ARGUMENT
MethodName:
Fichier Source*: http://localhost:1262/SL_FormulaireTestPage.aspx
Ligne*: 56
(Erreur interprété par le navigateur, visual studio ne bronche pas)

J'ai regardé le code du dataform, mais il est malheuresement beaucoup trop concequent et j'arrive pas a comprendre à quel moment ils font le changement de vue pour les divers mode.
Je ne sais pas donc comment faire, et ma methode ne semble pas marcher.
Avez vous des pistes?
Merci!

[Samuel Blanchard]

On peut faire comme ça.

Tout d'abord créer un Templated Control. Je l'ai appelé ici EditorControl

Dans le cs :

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
    /// <summary>
    /// Control d'edition
    /// </summary>
 
    public class EditorControl : Control
    {
        private const string EditContentControlName = "EditContentControl";
        private ContentControl EditContentControl = null;
 
        private const string VisualizeContentControlName = "VisualizeContentControl";
        private ContentControl VisualizeContentControl = null;
 
        /// <summary>
        /// Constructeur
        /// </summary>
 
        public EditorControl()
        {
            this.DefaultStyleKey = typeof(EditorControl);
        }
 
        /// <summary>
        /// Mode
        /// </summary>
 
        public enum EditorModes
        {
            Visualization,
            Editor
        }
 
        /// <summary>
        /// On applique le template
        /// </summary>
 
        public override void OnApplyTemplate()
        {
            base.OnApplyTemplate();
 
            this.EditContentControl = this.GetTemplateChild(EditContentControlName) as ContentControl;
            this.VisualizeContentControl = this.GetTemplateChild(VisualizeContentControlName) as ContentControl;
 
            // on réapplique si il y a eu modification avant que le template ait été appelé
            this.EditorModeChange(this.EditorMode);
        }
 
        /// <summary>
        /// Editor Mode
        /// </summary>
 
        public EditorModes EditorMode
        {
            get { return (EditorModes)GetValue(EditorModeProperty); }
            set { SetValue(EditorModeProperty, value); }
        }
 
        // Using a DependencyProperty as the backing store for EditorMode.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty EditorModeProperty =
            DependencyProperty.Register("EditorMode", typeof(EditorModes), typeof(EditorControl), new PropertyMetadata(EditorModes.Visualization));
 
        /// <summary>
        /// Changement de l'editeur
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
 
        protected static void OnEditorModeChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            EditorControl editorControl = sender as EditorControl;
            // on applique le changement
            editorControl.EditorModeChange((EditorModes)e.NewValue);
        }
 
        /// <summary>
        /// Contenu de l'edition
        /// </summary>
 
        public object EditContent
        {
            get { return (object)GetValue(EditContentProperty); }
            set { SetValue(EditContentProperty, value); }
        }
 
        // Using a DependencyProperty as the backing store for EditContent.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty EditContentProperty =
            DependencyProperty.Register("EditContent", typeof(object), typeof(EditorControl), null);
 
 
        /// <summary>
        /// Contenu de visualisation
        /// </summary>
 
        public object VisualizeContent
        {
            get { return (object)GetValue(VisualizeContentProperty); }
            set { SetValue(VisualizeContentProperty, value); }
        }
 
        // Using a DependencyProperty as the backing store for VisualizeContent.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty VisualizeContentProperty =
            DependencyProperty.Register("VisualizeContent", typeof(object), typeof(EditorControl), null );
 
 
 
 
 
        /// <summary>
        /// Changement de l'editor Mode
        /// </summary>
        /// <param name="editorMode"></param>
 
        private void EditorModeChange(EditorModes editorMode)
        {
            // on change ici la visibilité
            if( this.EditContentControl == null || this.VisualizeContentControl == null ) return;
 
            switch (editorMode)
            {
                case EditorModes.Editor :
 
                    this.EditContentControl.Visibility = Visibility.Visible;
                    this.VisualizeContentControl.Visibility = Visibility.Collapsed;
 
                    break;
 
                case EditorModes.Visualization:
 
                    this.EditContentControl.Visibility = Visibility.Collapsed;
                    this.VisualizeContentControl.Visibility = Visibility.Visible;
 
                    break;
            }
        }
    }

Dans le Generic.xaml :

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
 
    <Style TargetType="local:EditorControl">
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="local:EditorControl">
                    <Border Background="{TemplateBinding Background}"
                            BorderBrush="{TemplateBinding BorderBrush}"
                            BorderThickness="{TemplateBinding BorderThickness}">
 
                        <Grid>
                            <ContentControl x:Name="EditContentControl" Content="{TemplateBinding EditContent}"></ContentControl>
                            <ContentControl x:Name="VisualizeContentControl" Content="{TemplateBinding VisualizeContent}"></ContentControl>
                        </Grid>
                    </Border>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>

A utiliser dans le MainPage.xaml de la manière suivante :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
        <my:EditorControl EditorMode="Visualization">
 
            <my:EditorControl.EditContent>
                <TextBox Text="Le Resultat"></TextBox>
            </my:EditorControl.EditContent>
 
            <my:EditorControl.VisualizeContent>
                <TextBlock Text="Le resultat"></TextBlock>
            </my:EditorControl.VisualizeContent>
 
        </my:EditorControl>

On peut noter que je n'utilise que le contenu et pas de ContentTemplate car je trouve ça plus souple à utiliser (mais rien n'empêche de l'implémenter aussi de la même façon que EditContent).

[Thomas Lebrun]

Une autre possibilité est d'utiliser le VisualStateManager: c'est justement fait pour gérer des états

[micka132]

wouah merci bien!J'espere que tout ce code n'a pas était tapé pour mes beaux yeux.

C'est pas plutot :

Code :

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

1
2
   public static readonly DependencyProperty EditorModeProperty =
            DependencyProperty.Register("EditorMode", typeof(EditorModes), typeof(FormulaireEtat), new PropertyMetadata(new PropertyChangedCallback(OnEditorModeChanged)));

a la place de

Code :

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

1
2
 public static readonly DependencyProperty EditorModeProperty =
            DependencyProperty.Register("EditorMode", typeof(EditorModes), typeof(EditorControl), new PropertyMetadata(EditorModes.Visualization));

Par contre, là il n'y a pas de template "pré-etabli".
Est-il possible d'allier template par défaut, et template entierement personnalisable?

Thomas,
pour le vsm, j'ai pas compris comment on pouvait mettre du xaml, tout les exemples que je vois changent des propriétés du genre opacité, enabled...mais jamais ils ne changent de template .

[Samuel Blanchard]

wouah merci bien!J'espere que tout ce code n'a pas était tapé pour mes beaux yeux.

Un peu de code c'est souvent plus rapide qu'une longue explication

C'est pas plutot

En fait c'est les deux. J'oublie tout le temps de rajouter la méthode de changement

Code :

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

1
2
3
 
public static readonly DependencyProperty EditorModeProperty =
            DependencyProperty.Register("EditorMode", typeof(EditorModes), typeof(FormulaireEtat), new PropertyMetadata(new PropertyChangedCallback(EditorModes.Visualization,OnEditorModeChanged)));

Par contre, là il n'y a pas de template "pré-etabli".
Est-il possible d'allier template par défaut, et template entierement personnalisable?

Oui c'est possible.
Il suffit juste dans ton Style de generic.xaml de rajouter un Setter pour la propriété EditContent et VisualizeContent contenant tes contenus pas défaut.

[micka132]

Ah ouai pas bête!
C'est drolement puissant et complexe ce xaml.
On en apprend tout les jours .

Merci!

[Thomas Lebrun]

wouah merci bien!J'espere que tout ce code n'a pas était tapé pour mes pour le vsm, j'ai pas compris comment on pouvait mettre du xaml, tout les exemples que je vois changent des propriétés du genre opacité, enabled...mais jamais ils ne changent de template .

Le VSM permet de changer les propriétés d'un contrôle. Template étant une propriété, elle peut-être changée via la VSM. C'est une technique que l'on ne rencontre pas assez souvent mais très pratique pourtant

[micka132]

Hum d'accord, mais pour le moment je vais rester avec mes trucs basiques.

sinon pour mon problème je pense qu'il faut faire une autre DP, qui sera le template de mon contentControl, en fait exactement comme le "Content" du contentControl, qui a un "ContentTemplate".
Puis ensuite faire comme ici :
http://blogs.msdn.com/b/wpfsdk/archi...ntcontrol.aspx

Merci de vos aides!