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

Version imprimable

15/12/2010, 17h05
Xxbz3

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

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,

Salut,

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

J'ai créé un objet X :

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
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:

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:

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:

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.

17/12/2010, 10h57
Xxbz3
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:

<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:

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,
17/12/2010, 11h42
Nathanael Marchand

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.
17/12/2010, 11h46
Xxbz3
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:

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,
17/12/2010, 13h22
Xxbz3
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,
17/12/2010, 13h49
Nathanael Marchand

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

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

App.xaml

Code:

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:

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:

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:

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:

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:

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
	}
}

17/12/2010, 15h42
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 ?
17/12/2010, 15h45
Nathanael Marchand

Citation:

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
17/12/2010, 15h51
Xxbz3
J'ai essayé de faire comme cela :
Code:

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 ?
17/12/2010, 16h10
Nathanael Marchand

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.
18/12/2010, 16h42
Nathanael Marchand

http://www.thesmilies.com/smilie-gen...olu%5E_%5E.gif