Comment adapter un ListView en fonction de l'objet appelant ?

**Xxbz3** · 15/12/2010, 17h05

Bonjour,

Voilà la situation :

J'ai un treeview comme ceci :

Objet X1
___Objet Y1
___Objet Y2
Objet X2
___ObjetY1
___ObjetY2
___ObjetY3

Et une liste affichant les données des objets du treeview

Ma question est : peut-on modifier la vue de la liste en fonction de l'objet sur lequel on se trouve ?

Les objets Y contiennent une liste d'objets à afficher
Les objets X affichent l'ensemble des listes des objets Y qu'il possède.

J'aimerais dans le cas où je sélectionne un objet X, afficher une colonne en plus dans la liste pour afficher à quel objet Y l'élément de la liste appartient et ne pas l'afficher si on sélectionne un objet Y

Aussi:Est-ce qu'il serait possible de changer le DataContext de la liste en fonction de l'objet sur lequel on se trouve ?

Merci d'avance,

**Cecile5** · 16/12/2010, 15h28

Salut,

Voici un petit test que j'ai réalisé.

J'ai créé un objet X :

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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using System.Collections.ObjectModel;
 
namespace ListTemplateTest
{
    public class X : INotifyPropertyChanged
    {
        #region INotifyPropertyChanged Membres
 
        public event PropertyChangedEventHandler PropertyChanged;
        private void NotifyPropertyChanged(String info)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(info));
            }
        }
 
        #endregion
 
        private string _xA;
        public string XA
        {
            get { return _xA; }
            set
            {
                _xA = value;
                NotifyPropertyChanged("XA");
            }
        }
 
        private string _xB;
        public string XB
        {
            get { return _xB; }
            set
            {
                _xB = value;
                NotifyPropertyChanged("XB");
            }
        }
    }
}

et un objet Y :

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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
 
namespace ListTemplateTest
{
    public class Y : INotifyPropertyChanged
    {
        #region INotifyPropertyChanged Membres
 
        public event PropertyChangedEventHandler PropertyChanged;
        private void NotifyPropertyChanged(String info)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(info));
            }
        }
 
        #endregion
 
        private string _yA;
        public string YA
        {
            get { return _yA; }
            set
            {
                _yA = value;
                NotifyPropertyChanged("YA");
            }
        }
 
        private string _yB;
        public string YB
        {
            get { return _yB; }
            set
            {
                _yB = value;
                NotifyPropertyChanged("YB");
            }
        }
    }
}

J'ai une vue modèle avec :

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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections.ObjectModel;
using System.ComponentModel;
 
namespace ListTemplateTest
{
    public class MainViewModel : INotifyPropertyChanged
    {
        #region INotifyPropertyChanged Membres
 
        public event PropertyChangedEventHandler PropertyChanged;
        private void NotifyPropertyChanged(String info)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(info));
            }
        }
 
        #endregion
 
        public ObservableCollection<object> ItemsList { get; set; }
 
        private string _dataType;
        public string DataType
        {
            get { return _dataType; }
            set
            {
                _dataType = value;
                NotifyPropertyChanged("DataType");
            }
        }
 
        public MainViewModel()
        {
            ItemsList = new ObservableCollection<object>();
 
            ShowTheX();
            //ShowTheY();   
        }
 
        private void ShowTheX()
        {
            DataType = "X";
 
            X x1 = new X();
            x1.XA = "x1 value a";
            x1.XB = "x1 value b";
 
            X x2 = new X();
            x2.XA = "x2 value a";
            x2.XB = "x2 value b";
 
            ItemsList.Add(x1);
            ItemsList.Add(x2);
        }
 
        private void ShowTheY()
        {
            DataType = "Y";
 
            Y y1 = new Y();
            y1.YA = "y1 value a";
            y1.YB = "y1 value b";
 
            Y y2 = new Y();
            y2.YA = "y2 value a";
            y2.YB = "y2 value b";
 
            ItemsList.Add(y1);
            ItemsList.Add(y2);
        }
    }
}

Et enfin ma vue :

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
<Window x:Class="ListTemplateTest.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
 
    <Window.Resources>
 
        <Style TargetType="ListView">
            <Setter Property="View">
                <Setter.Value>
                    <GridView>
                        <GridViewColumn Header="XA" DisplayMemberBinding="{Binding XA}" Width="Auto" />
                        <GridViewColumn Header="XB" DisplayMemberBinding="{Binding XB}" Width="Auto" />
                    </GridView>
                </Setter.Value>
            </Setter>
            <Style.Triggers>
                <DataTrigger Binding="{Binding DataType}" Value="Y">
                    <Setter Property="View">
                        <Setter.Value>
                            <GridView>
                                <GridViewColumn Header="YA" DisplayMemberBinding="{Binding YA}" Width="Auto" />
                                <GridViewColumn Header="YB" DisplayMemberBinding="{Binding YB}" Width="Auto" />
                            </GridView>
                        </Setter.Value>
                    </Setter>
                </DataTrigger>
            </Style.Triggers>
        </Style>
 
    </Window.Resources>
    <Grid>
        <ListView x:Name="theList" ItemsSource="{Binding ItemsList}" />
    </Grid>
</Window>

Dans ma vue modèle :
- si je décommente ShowTheX(); et que je commente ShowTheY();, ce sont les colonnes pour les objets X qui sont affichées dans la ListView
- si je commente ShowTheX(); et que je décommente ShowTheY();, ce sont les colonnes pour les objets Y qui sont affichées dans la ListView

Bye.

**Xxbz3** · 17/12/2010, 10h57

Merci mais c'est pas tout à fait ce dont j'ai besoin

J'aimerais changer le template de ma liste en fonction du type d'objet qu'elle contient

J'aimerais savoir si il serait possible de le faire avec des DataTemplate ?

Code xml :

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

<DataTemplate DataType="{x:Type local:TypeA}">

Dans ce template,j'aimerais afficher un grid view avec x colonnes mais je n'y arrive pas

Code xml :

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

1
2
3
4
5
6
7
</DataTemplate>
 
<DataTemplate DataType="{x:Type local:TypeB}">
 
Dans ce template,j'aimerais afficher un grid view avec y colonnes 
 
</DataTemplate>

Merci d'avance,

**Nathanael Marchand** · 17/12/2010, 11h42

La question a été abordée il y'a un peu plus d'une semaine il me semble. J'avais répondu qu'il était possible de binder le template et d'utiliser un converter qui en fonction du type de l'objet retourne le template.

**Xxbz3** · 17/12/2010, 11h46

Merci pour la réponse, j'avais déjà compris ca

Ce qui me pose problème c'est que je ne sais pas comment déclarer un GridView dans mon DataTemplate

J'aimerais créer 2 grilles différentes pour les 2 objets en question mais si je sais fais ca :

Code :

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

1
2
3
4
5
6
 
<DataTemplate DataType={x:Type local:TypeA}>
     <GridView>
         ....
     </GridView>
<DataTemplate>

Cela ne fonctionne pas, peut-être que je m'y prends mal

Merci,

**Xxbz3** · 17/12/2010, 13h22

Re, je vais un peu plus détailler mon problème parce que je tourne en rond

Imaginons 3 types d'objets : Pays, Province, Ville :

Un Pays possède une collection de provinces et une collection de toutes les villes que ses Provinces possèdent
Une Province possède une collection de Villes

Mon écran est composé d'un treeview et d'une listview :

Le treeview est structuré comme ci :
Pays
___Province

Il permet de filtrer les résultats de la listview qui affiche les Villes.

Si on se trouve sur un noeud Pays du treeview, on affiche toutes les Villes de toutes les Provinces de ce Pays. Si on se trouve sur un noeud Province du treeview, on affiche toutes les Villes de cette Province

Ma listview recoit comme datacontext la collection de Villes qu'il doit afficher en récupérant la propriété de l'objet sélectionné dans le treeview

Ce que j'aimerais faire c est afficher une colonne en plus dans le listview quand on se trouve sur un noeud Pays pour afficher à quelle Province appartient la Ville. Et bien sur, ne pas l'afficher si on se trouve sur un noeud Province

Doit-on utiliser les datatemplate pour changer de vue ?
Sur quoi se baser pour changer de datatemplate ? Les objets dans la liste sont de même type, seul le parent change
Peux-t-on utiliser des gridview dans les DataTemplate?

Merci d'avance,

**Nathanael Marchand** · 17/12/2010, 13h49

Je bidouille un truc avec ton exemple et vois ce que je peux faire!

**Nathanael Marchand** · 17/12/2010, 15h32

Bon c'est pas super méga propre mais ca a le mérite de répondre à la question!

App.xaml

Code :

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

1
2
3
4
5
6
7
8
9
10
 
<Application x:Class="WpfApplication1.App"
			 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
			 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
			 xmlns:WpfApplication1="clr-namespace:WpfApplication1"
			 StartupUri="MainWindow.xaml">
	<Application.Resources>
		<WpfApplication1:World x:Key="World" />
	</Application.Resources>
</Application>

App.xaml.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
 
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Windows;
 
namespace WpfApplication1
{
	/// <summary>
	/// Interaction logic for App.xaml
	/// </summary>
	public partial class App : Application
	{
	}
}

MainWindow.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
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
 
<Window x:Class="WpfApplication1.MainWindow"
		xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
		xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
		xmlns:app="clr-namespace:WpfApplication1"
		Title="MainWindow"
		Height="350"
		Width="525"
		DataContext="{StaticResource World}">
	<Grid>
		<Grid.ColumnDefinitions>
			<ColumnDefinition Width="200" />
			<ColumnDefinition Width="*" />
		</Grid.ColumnDefinitions>
		<TreeView ItemsSource="{Binding Path=Countries}" x:Name="tree" SelectedItemChanged="OnSelectedItemChanged">
			<TreeView.ItemTemplate>
				<HierarchicalDataTemplate DataType="{x:Type app:Country}" ItemsSource="{Binding Path=Regions}">
					<HierarchicalDataTemplate.ItemTemplate>
						<DataTemplate DataType="{x:Type app:Region}">
							<TextBlock Text="{Binding Path=Name}" />
						</DataTemplate>
					</HierarchicalDataTemplate.ItemTemplate>
					<TextBlock Text="{Binding Path=Name}" />
				</HierarchicalDataTemplate>
			</TreeView.ItemTemplate>
		</TreeView>
		<ListBox x:Name="list" Grid.Column="1"
				 ItemsSource="{Binding Path=Cities}">
			<ListBox.ItemTemplate>
				<Binding>
					<Binding.Converter>
						<app:TypeConverter>
							<app:TypeConverter.CountryTemplate>
								<DataTemplate>
									<StackPanel Orientation="Horizontal">
										<TextBlock Text="{Binding Name}" />
										<TextBlock Text="{Binding Path=DataContext.Name, RelativeSource={RelativeSource AncestorType=ListBox,Mode=FindAncestor}, StringFormat={}\({0}\)}" />
									</StackPanel>
								</DataTemplate>
							</app:TypeConverter.CountryTemplate>
							<app:TypeConverter.RegionTemplate>
								<DataTemplate>
									<TextBlock Text="{Binding Name}" />
								</DataTemplate>
							</app:TypeConverter.RegionTemplate>
						</app:TypeConverter>
					</Binding.Converter>
				</Binding>
			</ListBox.ItemTemplate>
		</ListBox>
	</Grid>
</Window>

Mainwindow.xaml.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
 
using System;
using System.Windows;
 
namespace WpfApplication1
{
	/// <summary>
	/// Interaction logic for MainWindow.xaml
	/// </summary>
	public partial class MainWindow
	{
		public MainWindow()
		{
			InitializeComponent();
		}
 
		private void OnSelectedItemChanged(object sender, RoutedPropertyChangedEventArgs<object> e)
		{
			list.DataContext = e.NewValue;
		}
	}
}

objects.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
 
using System;
using System.Collections.Generic;
using System.Linq;
 
namespace WpfApplication1
{
	public class World
	{
		public List<Country> Countries { get; set; }
 
		public World()
		{
			Countries = new List<Country>
			            	{
			            		new Country("France")
			            			{
			            				Regions = new List<Region>
			            				          	{
			            				          		new Region("Ile de France")
			            				          			{
			            				          				Cities = new List<City>
			            				          				         	{
			            				          				         		new City("Paris"),
			            				          				         		new City("Versailles")
			            				          				         	}
			            				          			},
			            				          		new Region("PACA")
			            				          			{
			            				          				Cities = new List<City>
			            				          				         	{
			            				          				         		new City("Marseille"),
			            				          				         		new City("Toulon")
			            				          				         	}
			            				          			}
			            				          	},
			            			},
			            		new Country("USA")
			            			{
			            				Regions = new List<Region>
			            				          	{
			            				          		new Region("Californie")
			            				          			{
			            				          				Cities = new List<City>
			            				          				         	{
			            				          				         		new City("San Diego"),
			            				          				         		new City("Los Angeles")
			            				          				         	}
			            				          			},
			            				          		new Region("Floride")
			            				          			{
			            				          				Cities = new List<City>
			            				          				         	{
			            				          				         		new City("Miami"),
			            				          				         		new City("Orlando")
			            				          				         	}
			            				          			}
			            				          	},
			            			}
			            	};
			foreach (var country in Countries)
			{
				country.Cities = country.Regions.SelectMany(r => r.Cities).ToList();
			}
		}
	}
 
	public class Country
	{
		public String Name { get; set; }
		public List<Region> Regions { get; set; }
		public List<City> Cities { get; set; }
 
		public Country(String name)
		{
			Name = name;
		}
	}
 
	public class Region
	{
		public string Name { get; set; }
		public List<City> Cities { get; set; }
 
		public Region(String name)
		{
			Name = name;
		}
	}
 
	public class City
	{
		public string Name { get; set; }
 
		public City(String name)
		{
			Name = name;
		}
	}
 
}

typeconverter.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
 
using System;
using System.Globalization;
using System.Windows;
using System.Windows.Data;
 
namespace WpfApplication1
{
	public class TypeConverter : IValueConverter
	{
		public DataTemplate CountryTemplate { get; set; }
		public DataTemplate RegionTemplate { get; set; }
 
		#region Implementation of IValueConverter
 
		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
		{
			if (value is Country)
				return CountryTemplate;
			if (value is Region)
				return RegionTemplate;
			else
				return null;
		}
 
		public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
		{
			throw new NotImplementedException();
		}
 
		#endregion
	}
}

**Xxbz3** · 17/12/2010, 15h42

Merci beaucoup je regarde à cela tout de suite, néanmoins j'aurais une dernière question. Est-il possible de créer un DataTemplate qui contient un GridView ? Ou dois-je utiliser un DataGrid ?

**Nathanael Marchand** · 17/12/2010, 15h45

Envoyé par Xxbz3

Merci beaucoup je regarde à cela tout de suite, néanmoins j'aurais une dernière question. Est-il possible de créer un DataTemplate qui contient un GridView ? Ou dois-je utiliser un DataGrid ?

Y'a pas de raisons que ca ne marche pas

**Xxbz3** · 17/12/2010, 15h51

J'ai essayé de faire comme cela :

Code :

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

1
2
3
4
5
6
 
<DataTemplate DataType="{x:Type local:TypeA}">
     <GridView>
     ...
     </GridView>
</DataTemplate>

Mais il me met une erreur comme quoi l'objet VisualTree du DataTemplate ne connait pas l'objet GridView.
Il faut peut-être mettre l'objet GridView dans un autre contrôle ?

**Nathanael Marchand** · 17/12/2010, 16h10

Bon effectivement ca a pas l'air! Tu peux ruser en mettant un contentpresenter dans ton datatemplate et definissant le content de ce contentpresenter comme un gridview.

**Nathanael Marchand** · 18/12/2010, 16h42

Comment adapter un ListView en fonction de l'objet appelant ?

Windows Presentation Foundation

Discussions similaires

Partager

Partager