Un déclencheur sur la base de la valeur d'un DataGridCell

Question

J'ai quelques cellules dans un DataGrid et je voudrais mettre en évidence les cellules dans certaines colonnes rouges lorsque leur valeur est égale à 0. Je ne suis pas sûr de savoir comment aborder ce sujet.

J'ai regardé cette question: WPF:. Comment mettre en évidence toutes les cellules d'une DataGrid réunion une condition mais aucune des solutions ont fonctionné pour moi

Avec l'aide de déclencheurs de style, il semble que les déclencheurs sont destinés à être appliqués sur les propriétés. Quand je fais quelque chose comme rien ne se passe (je suppose parce qu'il ya plus au contenu qu'une simple valeur).

Avec la dernière solution proposée, je recevais un problème de compilation qui semblait être une manifestation d'un bug qui a été dans VS pendant un certain temps maintenant: classe personnalisée de liaison ne fonctionne pas correctement

Toutes les idées comment je peux y parvenir?

Quelqu'un a des idées?

Answer 1

La meilleure façon de changer la couleur de fond d'une cellule en fonction de la valeur d'un DataGridCell est de définir un DataTemplate pour le DataGridTemplateColumn avec un convertisseur pour modifier la couleur de fond de la cellule. L'échantillon fourni ici utilise MVVM.

Les pièces clés pour rechercher dans l'exemple suivant comprennent:

1: XAML qui convertit un nombre entier (Factor) dans le modèle à une couleur:

<TextBlock Text="{Binding Path=FirstName}" 
           Background="{Binding Path=Factor, 
             Converter={StaticResource objectConvter}}" />

2: Convertisseur qui renvoie un SolidColorBrush basé sur une propriété d'entier dans le modèle:

public class ObjectToBackgroundConverter : IValueConverter

3: ViewModel qui change la valeur entière dans le modèle entre 0 et 1 d'un clic de bouton pour déclencher un événement qui change la couleur dans le convertisseur

.

private void OnChangeFactor(object obj)
{
  foreach (var customer in Customers)
  {
    if ( customer.Factor != 0 )
    {
      customer.Factor = 0;
    }
    else
    {
      customer.Factor = 1;
    }
  }
}

4: outils Modèle INotifyPropertyChanged utilisé pour déclencher l'événement pour modifier la couleur d'arrière-plan en appelant OnPropertyChanged

private int _factor = 0;
public int Factor
{
  get { return _factor; }
  set
  {
    _factor = value;
    OnPropertyChanged("Factor");
  }
}

J'ai fourni tous les bits nécessaires ici dans ma réponse à l'exception des parties de base utilisées comme la base du motif MVVM qui comprend ViewModelBase (INotifyPropertyChanged) et DelegateCommand que vous pouvez trouver via Google. Notez que je lie le DataContext de la vue du ViewModel dans le constructeur du code-behind. Je peux envoyer ces bits supplémentaires si nécessaire.

Voici le XAML:

<Window x:Class="DatagridCellsChangeColor.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:Helpers="clr-namespace:DatagridCellsChangeColor.Converter" 
    Title="MainWindow" 
    Height="350" Width="525">
  <Window.Resources>
    <Helpers:ObjectToBackgroundConverter x:Key="objectConvter"/>
   /Window.Resources>
 <Grid>
  <Grid.RowDefinitions>
   <RowDefinition Height="Auto"/>
   <RowDefinition/>
  </Grid.RowDefinitions>
  <Button Content="Change Factor" Command="{Binding Path=ChangeFactor}"/>
  <DataGrid
   Grid.Row="1"
   Grid.Column="0"
   Background="Transparent" 
   ItemsSource="{Binding Customers}" 
   IsReadOnly="True"
   AutoGenerateColumns="False">
   <DataGrid.Columns>
    <DataGridTemplateColumn
      Header="First Name" 
      Width="SizeToHeader">
      <DataGridTemplateColumn.CellTemplate>
        <DataTemplate>
          <TextBlock Text="{Binding Path=FirstName}" 
                      Background="{Binding Path=Factor, 
                      Converter={StaticResource objectConvter}}" />
        </DataTemplate>
      </DataGridTemplateColumn.CellTemplate>
    </DataGridTemplateColumn>
    <DataGridTemplateColumn
      Header="Last Name" 
      Width="SizeToHeader">
      <DataGridTemplateColumn.CellTemplate>
        <DataTemplate>
          <TextBox Text="{Binding Path=LastName}" />
        </DataTemplate>
      </DataGridTemplateColumn.CellTemplate>
    </DataGridTemplateColumn>
   </DataGrid.Columns>
  </DataGrid>
 </Grid>
</Window>

Voici le convertisseur:

using System;
using System.Drawing;
using System.Globalization;
using System.Windows.Data;
using System.Windows.Media;
using Brushes = System.Windows.Media.Brushes;

namespace DatagridCellsChangeColor.Converter
{
  [ValueConversion(typeof(object), typeof(SolidBrush))]
  public class ObjectToBackgroundConverter : IValueConverter
  {
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
      int c = (int)value;

      SolidColorBrush b;
      if (c == 0)
      {
        b = Brushes.Gold;
      }
      else
      {
        b = Brushes.Green;
      }
      return b;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
      throw new NotImplementedException();
    }
  }
}

Voici le ViewModel:

using System.Collections.ObjectModel;
using System.Windows.Input;
using DatagridCellsChangeColor.Commands;
using DatagridCellsChangeColor.Model;

namespace DatagridCellsChangeColor.ViewModel
{
  public class MainViewModel : ViewModelBase
  {
    public MainViewModel()
    {
      ChangeFactor = new DelegateCommand<object>(OnChangeFactor, CanChangeFactor);
    }

    private ObservableCollection<Customer> _customers = Customer.GetSampleCustomerList();
    public ObservableCollection<Customer> Customers
    {
      get
      {
         return _customers;
      }
    }

    public ICommand ChangeFactor { get; set; }
    private void OnChangeFactor(object obj)
    {
      foreach (var customer in Customers)
      {
        if ( customer.Factor != 0 )
        {
          customer.Factor = 0;
        }
        else
        {
          customer.Factor = 1;
        }
      }
    }

    private bool CanChangeFactor(object obj)
    {
      return true;
    }
  }
}

Voici le modèle:

using System;
using System.Collections.ObjectModel;
using DatagridCellsChangeColor.ViewModel;

namespace DatagridCellsChangeColor.Model
{
  public class Customer : ViewModelBase
  {
    public Customer(String first, string middle, String last, int factor)
    {
      this.FirstName = first;
      this.MiddleName = last;
      this.LastName = last;
      this.Factor = factor;
    }

    public String FirstName { get; set; }
    public String MiddleName { get; set; }
    public String LastName { get; set; }

    private int _factor = 0;
    public int Factor
    {
      get { return _factor; }
      set
      {
        _factor = value;
        OnPropertyChanged("Factor");
      }
    }

    public static ObservableCollection<Customer> GetSampleCustomerList()
    {
      return new ObservableCollection<Customer>(new Customer[4]
                               {
                                 new Customer("Larry", "A", "Zero", 0),
                                 new Customer("Bob", "B", "One", 1),
                                 new Customer("Jenny", "C", "Two", 0),
                                 new Customer("Lucy", "D", "THree", 2)
                               });
    }
  }
}