Discussion :

[Fellerson]

Bonjour

Je souhaite cocher avec un bouton toutes les checkboxes de ma form.

Je ne connais pas les checkboxes à l'avance, elles sont le résultat d'une requête SQL.

Tous les contenus des checkboxes sont dans cette liste :

Code :

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

public ObservableCollection<CL_Lignes> lstLignes = new ObservableCollection<CL_Lignes>();

Ce résultat est envoyé dans ma form avec le binding :

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
<ItemsControl x:Name="lvDataBinding" HorizontalContentAlignment="Stretch" BorderThickness="0" Margin="10" Grid.Row="1" Background="{x:Null}" ItemsSource="{Binding}" Grid.ColumnSpan="4" Foreground="White">
           <ItemsControl.ItemTemplate>
               <DataTemplate>
                   <Border BorderBrush="White" BorderThickness="1" CornerRadius="3" Margin="0,3" Grid.ColumnSpan="0" Background="Transparent" HorizontalAlignment="Left" VerticalAlignment="Top">
                       <StackPanel Orientation="Vertical" >
                           <CheckBox x:Name="cbxLignes" Tag="{Binding strCodeLigne}" Style="{StaticResource {x:Type ToggleButton}}" Content="{Binding strCodeLigne}" FontSize="22" Margin="25,15,25,15" Width="100" Height="45" IsChecked="{Binding IsChecked}" Checked="cbxLignes_Checked" Unchecked="cbxLignes_Unchecked" />
                       </StackPanel>
                   </Border>
               </DataTemplate>
           </ItemsControl.ItemTemplate>
           <ItemsControl.ItemsPanel>
               <ItemsPanelTemplate>
                   <WrapPanel />
               </ItemsPanelTemplate>
           </ItemsControl.ItemsPanel>
       </ItemsControl>

Je souhaite avec un bouton bouler sur toutes les checkbox qui ont été crées pour les cocher

J'essaie de boucler sur ma liste pour récupérer les contenus et réussir à les cocher mais apparemment en vain, mauvaise méthode.

Merci.

[Ganeshiva]

bonjour

je vais tenter de répondre à ta question sachant que je suis débutant aussi

je vais te montrer un exemple ca sera peut etre plus parlant pour toi :

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
 
   <ListView  ItemsSource="{Binding lstLignes, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" IsSynchronizedWithCurrentItem="True" Background="{x:Null}"> 
                           <ListView.View>
                             <GridView>
                            <GridViewColumn Width="30">
                                <GridViewColumn.CellTemplate>
                                    <DataTemplate>
                                                <CheckBox HorizontalAlignment="Center" IsChecked="{Binding check , UpdateSourceTrigger=PropertyChanged}" />
 
                                    </DataTemplate>
                                </GridViewColumn.CellTemplate>
                            </GridViewColumn>
 
                            </GridView>
                    </ListView.View>
                    </ListView>

Comme tu peux le constater, j'ai une listview avec un item source blinder sur un observablecollection à la différence de toi, je lui est mis un mode twoway et un UpdateSourceTrigger=PropertyChanged, ce qui permet de mettre la source à jour s'il y a des changements dans les 2 sens.
Ensuite sur mon modèle

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
 
using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Xml.Serialization;
 
namespace Model
{
 
    [XmlRoot]
    public class CL_Lignes : INotifyPropertyChanged
    {
        public static Action OnChanged;
 
        private bool _check;
 
 
 
 
        [XmlAttribute]
        public bool check
        {
            get { return __check; }
            set
            {
                __check = value;
 
                OnChanged?.Invoke();
 
            }
        }
 
 
 
        [Conditional("DEBUG")]
        [DebuggerStepThrough]
        public void VerifyPropertyName(string propertyName)
        {
            // Verify that the property name matches a real,  
            // public, instance property on this object.
            if (TypeDescriptor.GetProperties(this)[propertyName] == null)
            {
                string msg = "Invalid property name: " + propertyName;
 
                if (this.ThrowOnInvalidPropertyName)
                    throw new Exception(msg);
                else
                    Debug.Fail(msg);
            }
        }
 
        /// <summary>
        /// Returns whether an exception is thrown, or if a Debug.Fail() is used
        /// when an invalid property name is passed to the VerifyPropertyName method.
        /// The default value is false, but subclasses used by unit tests might 
        /// override this property's getter to return true.
        /// </summary>
        protected virtual bool ThrowOnInvalidPropertyName { get; private set; }
 
 
 
 
        /// <summary>
        /// Raised when a property on this object has a new value.
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;
 
        /// <summary>
        /// Raises this object's PropertyChanged event.
        /// </summary>
        /// <param name="propertyName">The property that has a new value.</param>
        protected virtual void OnPropertyChanged(string propertyName)
        {
            this.VerifyPropertyName(propertyName);
 
            PropertyChangedEventHandler handler = this.PropertyChanged;
            if (handler != null)
            {
                var e = new PropertyChangedEventArgs(propertyName);
                handler(this, e);
            }
        }
    }

Je bosse sur du xml mais le principe doit être le même, Le INotifyPropertyChanged est important car il permet à ta classe de recevoir les modifications.

pour ton button dans ton view model il suffit de faire un Icommand :

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
 
RelayCommand _CocherToutesLesCheckBoxCommand;
public ICommand CocherToutesLesCheckBoxCommand
 
 
        {
            get
            {
                if (_CocherToutesLesCheckBoxCommand == null)
                    _CocherToutesLesCheckBoxCommand = new RelayCommand(param => this.CocherToutesLesCheckBox());
 
                return _CocherToutesLesCheckBoxCommand;
            }
        }
 
public void CocherToutesLesCheckBox()
{
  if ( lstLignes != null)
            {
                foreach (var item in  lstLignes)
                {
                    item.check = true;
                }
 
            }
}

ensuite ton button en xaml :

Code :

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

1
2
 
<Button ToolTip="Coche toutes les checkbox" Command="{Binding CocherToutesLesCheckBoxCommand}">

Voila à peut près le principe, j'espère avoir été assez clair dans ma réponse. Si des gens plus calé que moi veulent rajouter quelque chose qu'ils n'hésitent pas

Ps : j'ai séparé model, viewmodel et view, pas de code behind, j'ai eut du mal avec cela au début mais après c'est vraiment pratique de faire la séparation du code et de la vue. c'est beaucoup plus lisible et facile à faire.

Ps bis : je suis autodidacte et j'ai fait aucune étude de programmation du coup excusez moi si je me trompe.

[_champy_]

Bonne réponse quelques petites précisions :

je lui est mis un mode twoway et un UpdateSourceTrigger=PropertyChanged, ce qui permet de mettre la source à jour s'il y a des changements dans les 2 sens.

La source du binding c'est ton composant, la target du binding la propriétée de ton DataContext. (si tu trouve sa illogique comme moi il faut le graver dans ton cerveau c'est comme ça )

UpdateSourceTrigger=PropertyChanged écoute les changements de valeur de la propriétée de ton DataContext à condition qu'elle implémente INotifyPropertyChanged afin de les reporter sur le composant.

Mode oneway autorise uniquement la mise à jour de ton composant à partir de la propriétée de ton DataContext.

Mode twoway autorise la mise à jour de ton composant à partir de la propriétée de ton DataContext mais aussi la mise à jour de la propriétée de ton DataContext à partie du composant.

Implémenter soit même INotifyPropertyChanged dans chacune des classes cela peut être un peu lourd mais surtout redondant, en général on utilise une classe qui le fait dont on hérite.

Ou on utilise une classe d'un FrameWork , par exemple Prism MVVM (tu peut trouver beaucoup plus léger), qui possèdent un classe BindableBase qui implémente INotifyPropertyChanged.
L'avantage de cette classe est qu'elle ne s’appuie pas sur une chaîne texte pour notifié le changement du coup pas besoin de la partie VerifyPropertyName.

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
 
using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Xml.Serialization;
using Prism.Mvvm;
namespace Model
{
 
 
    public class CL_Lignes : BindableBase
    {       
 
        private bool _check;
 
        public bool check
        {
            get { return __check; }
            set
            {
                __check = value; 
                this.OnPropertyChanged(() => this.check); 
            }
        }
 
    }
}