WPF—PropertyGrid使用ListView开发

【核心代码】

颜色控件：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Media;
using System.Windows.Data;
using System.Windows;
using System.Reflection;

namespace PropertyGridDemo
{
    // This is the wrapper (ViewModel) that we use to edit a ColorItem.  It exposes
    // the RGB components as a Color struct, for the purposes of binding to the controls.
    public class ColorItemViewModel : FrameworkElement
    {
        public static readonly DependencyProperty ItemProperty =
            DependencyProperty.Register("Item", typeof(ColorItem), typeof(ColorItemViewModel));

        // The original data source.  This is a dependency property because
        // we set a binding on it in the xaml.
        public ColorItem Item
        {
            get
            {
                return (ColorItem)GetValue(ItemProperty);
            }
            set
            {
                SetValue(ItemProperty, value);
            }
        }

        // Transform the RGB properties of the original item into a Color struct and back.
        public ColorSelection Color
        {
            get
            {
                if (Item == null)
                    return null;
                Color itemColor = System.Windows.Media.Color.FromScRgb(1.0f, Item.Red, Item.Green, Item.Blue);
                foreach (var ac in availableColors)
                    if (ac.Color == itemColor)
                        return ac;
                return null;
            }
            set
            {
                if (Item != null)
                {
                    Item.Red = value.Color.ScR;
                    Item.Green = value.Color.ScG;
                    Item.Blue = value.Color.ScB;
                }
            }
        }

        // List of available colors, provided as a convenience for the xaml.
        public ColorSelection[] AvailableColors
        {
            get
            {
                return availableColors;
            }
        }

        ColorSelection[] availableColors = GetAvailableColors();

        private static ColorSelection[] GetAvailableColors()
        {
            List<ColorSelection> colors = new List<ColorSelection>();
            foreach (var pi in typeof(Colors).GetProperties())
                colors.Add(new ColorSelection { 
                    Color = (Color)pi.GetValue(null, null),
                    Name = AddSpaces(pi.Name) });
            return colors.ToArray();
        }

        // Convert from PascalCasing to human-readable.
        private static string AddSpaces(string name)
        {
            StringBuilder sb = new StringBuilder(name.Length);
            bool wasLower = false;
            for (int i = 0; i < name.Length; i)
            {
                if (wasLower && char.IsUpper(name[i]))
                {
                    sb.Append(' ');
                    sb.Append(char.ToLower(name[i]));
                }
                else
                {
                    sb.Append(name[i]);
                    wasLower = true;
                }
            }
            return sb.ToString();
        }

        // Proxy for a color selection
        public class ColorSelection
        {
            public Color Color { get; set; }
            public string Name { get; set; }
        }
    }
}

样式：

<Window x:Class="PropertyGridDemo.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:clr="clr-namespace:PropertyGridDemo"
        Title="PropertyGrid Sample" Height="200" Width="320">
    <ListView ItemsSource="{Binding}">
        <ListView.Resources>
            <!-- The following are the data templates for the Value column of the ListView. -->
            
            <DataTemplate DataType="{x:Type clr:TextItem}">
                <TextBox Text="{Binding Text}"/>
            </DataTemplate>
            
            <DataTemplate DataType="{x:Type clr:ColorItem}">
                <Grid>
                    <clr:ColorItemViewModel x:Name="Persona" Item="{Binding}"/>
                    <!-- Now bind our content to the viewmodel rather than to the original data. -->
                    <ComboBox DataContext="{Binding ElementName=Persona}"
                              ItemsSource="{Binding AvailableColors}"
                              SelectedItem="{Binding Color}">
                        <!-- The ComboBox will contain rectangles showing the color, and the name of the
                             color to the right of the rectangle. -->
                        <ComboBox.ItemTemplate>
                            <!-- Don't confuse the DataTemplate of the ComboBox with the DataTemplate that
                                 *contains* the ComboBox. -->
                            <DataTemplate> 
                                <StackPanel Orientation="Horizontal">
                                    <Rectangle Width="16" Margin="3">
                                        <Rectangle.Fill>
                                            <SolidColorBrush Color="{Binding Color}"/>
                                        </Rectangle.Fill>
                                    </Rectangle>
                                    <TextBlock Text="{Binding Name}" Margin="3"/>
                                </StackPanel>
                            </DataTemplate>
                        </ComboBox.ItemTemplate>
                    </ComboBox>
                </Grid>
            </DataTemplate>
            
        </ListView.Resources>
        
        <ListView.View>
            <GridView> <!-- ListView is multicolumn. -->
                <GridViewColumn Header="Name" DisplayMemberBinding="{Binding Name}"/>
                
                <!-- The Value column needs to display different sorts of controls,
                     depending on the type of the data row.  For this we need a 
                     CellTemplate... -->
                <GridViewColumn Header="Value" Width="200">
                    <GridViewColumn.CellTemplate>
                        <DataTemplate>
                            <!-- The cell template contains a ContentPresenter, hence the *actual*
                                 data template used will be selected by the type of the data row. -->
                            <ContentPresenter Content="{Binding}"/>
                        </DataTemplate>
                    </GridViewColumn.CellTemplate>
                </GridViewColumn>
            </GridView>
        </ListView.View>

        <!-- Stretch the content of the columns.  It's annoying that the default
             alignment is left. -->
        <ListView.ItemContainerStyle>
            <Style TargetType="ListViewItem">
                <Setter Property="HorizontalContentAlignment"
                Value="Stretch" />
            </Style>
        </ListView.ItemContainerStyle>
    </ListView>
</Window>