Content Child Windows

Bonjour,

Je n'arrive pas à faire une child windows personnalisée.

Je m'explique je voudrai hérité de la childwindow et explosé plusieurs propriétés content de celle ci.

Mais je vois pas trop comment faire.
Code:

1 2 3 4 5 6 7 8 9 <control:childwindow ... > <stackPanel> <Content x:Name="content1"/> <Content x:Name="content2"> </stackPanel> </control:childwindow>
Et l'utiliser à peut près ainsi:
Code:

1 2 3 4 5 6 7 8 9 10 11 <mycontrol:MyChildwindow ... > <Content1> <TextBlock="1"/> </Content1> <Content2> <TextBlock="1"/> </Content2> </stackPanel> </control:childwindow>
Voila, j'ai jamais su faire des contrôles avec plusieurs contenue en Silverlight. Si quelqu'un avait un exemple ça m'aiderai pas mal. ^^

EDIT:

Bon, bah stackoverflow avait ma réponse :

http://stackoverflow.com/questions/2...-that-would-be

Je l'implémenter/tester/comprendre et faire une petite explication dans ce thread.

Berk le code de ton lien est horrible.

Mais si tu regardes bien le code du ChildWindow tu as bien 2 contents. Le content principal et le titre de la fenêtre.

Pour en rajouter il suffit simplement de rajouter un dependency property de type object (snippet propdp) dans ta custom class qui hérite de ChildWindow.

Ensuite dans le template de ton custom child window il faut rajouter autant de ContentPresenters que tu as ajouté de propriétés (il faut les placer là où tu veux que tes contents s'affichent) et il suffit juste de faire

Code:

Content="{TemplateBinding TaNouvellePropriete}"

Et hop maintenant quand tu définis un CustomChildWindow tu peux utiliser tes customs propriétés et mettre ce que tu veux dedans (Button, TextBox...)

Pourquoi crééer une ChildWindows custom ? Tu ne pourrais pas simplement rajouter ton code dans le "corp" de la ChildWindow de Silverlight ?

Bon j'ai résolut mon pb.

En faite je me suis créer une ChildWindow prêt à l'emploie avec une série de bouton que je répétais, et des contenues informatifs en plus.

C'est pour ça que je voulais pouvoir mettre mes content au milieu de tout ça. :)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
<XAML:MedialogMainWindow 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
 
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400">
 
    <XAML:MedialogMainWindow.MainContent>
     ....
    </XAML:MedialogMainWindow.MainContent>
 
    <XAML:MedialogMainWindow.LegendContent>
     ...
    </XAML:MedialogMainWindow.LegendContent>
</XAML:MedialogMainWindow>

Associé à son model ça fait tout tout seul, le bonheur.

Code:

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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
 
public class MedialogMainWindowModel : ViewModelBase
    {
        #region Fields
        DelegateCommand _yesCommand;
        DelegateCommand _noCommand;
        DelegateCommand _validateCommand;
        DelegateCommand _cancelCommand;
        DelegateCommand _closeCommand;
        private string _title;
        #endregion
 
        public MedialogMainWindowModel(DelegateCommand yesCommand, DelegateCommand noCommand, DelegateCommand cancelCommand = null, string title = null)
        {
            YesCommand = yesCommand;
            NoCommand = noCommand;
            CancelCommand = cancelCommand;
            Title = title;
        }
 
        public MedialogMainWindowModel(DelegateCommand validateCommand, DelegateCommand cancelCommand = null, string title = null)
        {
            ValidateCommand = validateCommand;
            CancelCommand = cancelCommand;
            Title = title;
        }
 
        public MedialogMainWindowModel(DelegateCommand closeCommand, string title = null)
        {
            CloseCommand = closeCommand;
            Title = title;
        }
 
 
        public string Title
        {
            get { return _title; }
            set
            {
                if (value != _title)
                {
                    _title = value;
                    NotifyPropertyChanged("Title");
                }
            }
        }
 
        public bool IsYesVisible
        {
            get
            {
                if (YesCommand == null)
                    return false;
                return true;
            }
        }
 
        public bool IsNoVisible
        {
            get
            {
                if (NoCommand == null)
                    return false;
                return true;
            }
        }
 
        public bool IsValidateVisible
        {
            get
            {
                if (ValidateCommand == null)
                    return false;
                return true;
            }
        }
 
        public bool IsCancelVisible
        {
            get
            {
                if (CancelCommand == null)
                    return false;
                return true;
            }
        }
        public bool IsCloseVisible
        {
            get
            {
                if (CloseCommand == null)
                    return false;
                return true;
            }
        }
 
        public DelegateCommand YesCommand
        {
            get
            {
                return _yesCommand;
            }
            protected set
            {
                if (_yesCommand != value)
                {
                    _yesCommand = value;
                    NotifyPropertyChanged("YesCommand");
                    NotifyPropertyChanged("IsYesVisible");
                }
            }
        }
 
        public DelegateCommand NoCommand
        {
            get
            {
                return _noCommand;
            }
            protected set
            {
                if (_noCommand != value)
                {
                    _noCommand = value;
                    NotifyPropertyChanged("NoCommand");
                    NotifyPropertyChanged("IsNoVisible");
                }
            }
        }
 
        public DelegateCommand ValidateCommand
        {
            get
            {
                return _validateCommand;
            }
            protected set
            {
                if (_validateCommand != value)
                {
                    _validateCommand = value;
                    NotifyPropertyChanged("ValidateCommand");
                    NotifyPropertyChanged("IsValidateVisible");
                }
            }
        }
 
        public DelegateCommand CancelCommand
        {
            get
            {
                return _cancelCommand;
            }
            protected set
            {
                if (_cancelCommand != value)
                {
                    _cancelCommand = value;
                    NotifyPropertyChanged("CancelCommand");
                    NotifyPropertyChanged("IsCancelVisible");
                }
            }
        }
 
        public DelegateCommand CloseCommand
        {
            get
            {
                return _closeCommand;
            }
            protected set
            {
                if (_closeCommand != value)
                {
                    _closeCommand = value;
                    NotifyPropertyChanged("CloseCommand");
                    NotifyPropertyChanged("IsCloseVisible");
                }
            }
        }
    }