Wie führe ich die Auswahl eines Kontrollkästchens mit einem Klick in WPF DataGrid durch?

Ich habe ein DataGrid mit der ersten Spalte als Textspalte und der zweiten Spalte als CheckBox-Spalte. Was ich will ist, wenn ich das Kontrollkästchen anklicke. Es sollte überprüft werden.

Die Auswahl dauert jedoch zwei Klicks. Beim ersten Klick wird die Zelle ausgewählt, beim zweiten Klick wird das Kontrollkästchen aktiviert. So aktivieren Sie das Kontrollkästchen, um mit einem einzigen Klick aktiviert / deaktiviert zu werden.

Ich benutze WPF 4.0. Spalten im DataGrid werden automatisch generiert.

Für das Single-Click-Kontrollkästchen DataGrid können Sie einfach das reguläre Kontrollkästchen steuern DataGridTemplateColumnund festlegen UpdateSourceTrigger=PropertyChanged.

<DataGridTemplateColumn.CellTemplate>
    <DataTemplate>
        <CheckBox IsChecked="{Binding Path=IsSelected, UpdateSourceTrigger=PropertyChanged}" />
    </DataTemplate>
</DataGridTemplateColumn.CellTemplate>

Ich habe dies mit folgendem Stil gelöst:

<Style TargetType="DataGridCell">
     <Style.Triggers>
         <Trigger Property="IsMouseOver" Value="True">
             <Setter Property="IsEditing" Value="True" />
         </Trigger>
     </Style.Triggers>
 </Style>

Es ist natürlich möglich, dies für bestimmte Spalten weiter anzupassen ...

Zunächst weiß ich, dass dies eine ziemlich alte Frage ist, aber ich dachte immer noch, ich würde versuchen, sie zu beantworten.

Ich hatte vor ein paar Tagen das gleiche Problem und fand eine überraschend kurze Lösung dafür (siehe diesen Blog ). Grundsätzlich müssen Sie lediglich die DataGridCheckBoxColumnDefinition in Ihrer XAML durch Folgendes ersetzen :

<DataGridTemplateColumn Header="MyCheckBoxColumnHeader">
    <DataGridTemplateColumn.CellTemplate>
        <DataTemplate>
            <CheckBox HorizontalAlignment="Center" VerticalAlignment="Center" IsChecked="{Binding Path=MyViewModelProperty, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
        </DataTemplate>
    </DataGridTemplateColumn.CellTemplate>
</DataGridTemplateColumn>

Der Vorteil dieser Lösung liegt auf der Hand - sie ist nur für XAML verfügbar. Auf diese Weise wird verhindert, dass Sie Ihren Code-Back mit zusätzlicher UI-Logik belasten, und Sie können Ihren Status in den Augen von MVVM-Eiferern beibehalten;).

Um Konstantin Salavatov Antwort mit der Arbeit AutoGenerateColumns, fügen Sie einen Event - Handler auf den DataGrid‚s AutoGeneratingColumnmit dem folgenden Code:

if (e.Column is DataGridCheckBoxColumn && !e.Column.IsReadOnly)
{
    var checkboxFactory = new FrameworkElementFactory(typeof(CheckBox));
    checkboxFactory.SetValue(FrameworkElement.HorizontalAlignmentProperty, HorizontalAlignment.Center);
    checkboxFactory.SetValue(FrameworkElement.VerticalAlignmentProperty, VerticalAlignment.Center);
    checkboxFactory.SetBinding(ToggleButton.IsCheckedProperty, new Binding(e.PropertyName) { UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged });

    e.Column = new DataGridTemplateColumn
        {
            Header = e.Column.Header,
            CellTemplate = new DataTemplate { VisualTree = checkboxFactory },
            SortMemberPath = e.Column.SortMemberPath
        };
}

Dadurch können alle DataGridautomatisch generierten Kontrollkästchenspalten mit einem Klick bearbeitet werden.

Basierend auf einem Blog, auf das in Goblins Antwort verwiesen wird, das jedoch so geändert wurde, dass es in .NET 4.0 und im Zeilenauswahlmodus funktioniert.

Beachten Sie, dass es auch die Bearbeitung von DataGridComboBoxColumn beschleunigt - indem Sie in den Bearbeitungsmodus wechseln und Dropdown-Listen bei Einzelklick oder Texteingabe anzeigen.

XAML:

        <Style TargetType="{x:Type DataGridCell}">
            <EventSetter Event="PreviewMouseLeftButtonDown" Handler="DataGridCell_PreviewMouseLeftButtonDown" />
            <EventSetter Event="PreviewTextInput" Handler="DataGridCell_PreviewTextInput" />
        </Style>

Code-Behind:

    private void DataGridCell_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
    {
        DataGridCell cell = sender as DataGridCell;
        GridColumnFastEdit(cell, e);
    }

    private void DataGridCell_PreviewTextInput(object sender, TextCompositionEventArgs e)
    {
        DataGridCell cell = sender as DataGridCell;
        GridColumnFastEdit(cell, e);
    }

    private static void GridColumnFastEdit(DataGridCell cell, RoutedEventArgs e)
    {
        if (cell == null || cell.IsEditing || cell.IsReadOnly)
            return;

        DataGrid dataGrid = FindVisualParent<DataGrid>(cell);
        if (dataGrid == null)
            return;

        if (!cell.IsFocused)
        {
            cell.Focus();
        }

        if (cell.Content is CheckBox)
        {
            if (dataGrid.SelectionUnit != DataGridSelectionUnit.FullRow)
            {
                if (!cell.IsSelected)
                    cell.IsSelected = true;
            }
            else
            {
                DataGridRow row = FindVisualParent<DataGridRow>(cell);
                if (row != null && !row.IsSelected)
                {
                    row.IsSelected = true;
                }
            }
        }
        else
        {
            ComboBox cb = cell.Content as ComboBox;
            if (cb != null)
            {
                //DataGrid dataGrid = FindVisualParent<DataGrid>(cell);
                dataGrid.BeginEdit(e);
                cell.Dispatcher.Invoke(
                 DispatcherPriority.Background,
                 new Action(delegate { }));
                cb.IsDropDownOpen = true;
            }
        }
    }


    private static T FindVisualParent<T>(UIElement element) where T : UIElement
    {
        UIElement parent = element;
        while (parent != null)
        {
            T correctlyTyped = parent as T;
            if (correctlyTyped != null)
            {
                return correctlyTyped;
            }

            parent = VisualTreeHelper.GetParent(parent) as UIElement;
        }
        return null;
    }

Ich habe diese Vorschläge ausprobiert und viele andere, die ich auf anderen Websites gefunden habe, aber keiner von ihnen hat für mich ganz funktioniert. Am Ende habe ich die folgende Lösung erstellt.

Ich habe mein eigenes DataGrid-geerbtes Steuerelement erstellt und einfach diesen Code hinzugefügt:

public class DataGridWithNavigation : Microsoft.Windows.Controls.DataGrid
{
    public DataGridWithNavigation()
    {
        EventManager.RegisterClassHandler(typeof(DataGridCell), 
            DataGridCell.PreviewMouseLeftButtonDownEvent,
            new RoutedEventHandler(this.OnPreviewMouseLeftButtonDown));
    }


    private void OnPreviewMouseLeftButtonDown(object sender, RoutedEventArgs e)
    {
        DataGridCell cell = sender as DataGridCell;
        if (cell != null && !cell.IsEditing && !cell.IsReadOnly)
        {
          DependencyObject obj = FindFirstControlInChildren(cell, "CheckBox");
            if (obj != null)
            {
                System.Windows.Controls.CheckBox cb = (System.Windows.Controls.CheckBox)obj;
                cb.Focus();
                cb.IsChecked = !cb.IsChecked;
            }
        }
    }

    public DependencyObject FindFirstControlInChildren(DependencyObject obj, string controlType)
    {
        if (obj == null)
            return null;

        // Get a list of all occurrences of a particular type of control (eg "CheckBox") 
        IEnumerable<DependencyObject> ctrls = FindInVisualTreeDown(obj, controlType);
        if (ctrls.Count() == 0)
            return null;

        return ctrls.First();
    }

    public IEnumerable<DependencyObject> FindInVisualTreeDown(DependencyObject obj, string type)
    {
        if (obj != null)
        {
            if (obj.GetType().ToString().EndsWith(type))
            {
                yield return obj;
            }

            for (var i = 0; i < VisualTreeHelper.GetChildrenCount(obj); i++)
            {
                foreach (var child in FindInVisualTreeDown(VisualTreeHelper.GetChild(obj, i), type))
                {
                    if (child != null)
                    {
                        yield return child;
                    }
                }
            }
        }
        yield break;
    }
}

Was macht das alles?

Nun, jedes Mal, wenn wir auf eine Zelle in unserem DataGrid klicken, sehen wir, ob die Zelle ein CheckBox-Steuerelement enthält. Wenn dies der Fall ist , setzen wir den Fokus auf diese CheckBox und schalten ihren Wert um .

Dies scheint für mich zu funktionieren und ist eine schöne, leicht wiederverwendbare Lösung.

Es ist enttäuschend , dass wir brauchen , um Code schreiben dies aber zu tun. Die Erklärung, dass der erste Mausklick (auf das Kontrollkästchen eines DataGrid) "ignoriert" wird, da WPF die Zeile damit in den Bearbeitungsmodus versetzt, mag logisch klingen, aber in der realen Welt widerspricht dies der Funktionsweise jeder realen Anwendung.

Wenn ein Benutzer ein Kontrollkästchen auf seinem Bildschirm sieht, sollte er einmal darauf klicken können, um es anzukreuzen / zu deaktivieren. Ende der Geschichte.

Hier gibt es eine viel einfachere Lösung.

          <DataGridTemplateColumn MinWidth="20" >
                <DataGridTemplateColumn.CellTemplate>
                    <DataTemplate>
                        <Grid>
                            <CheckBox VerticalAlignment="Center" HorizontalAlignment="Center"/>
                        </Grid>
                    </DataTemplate>
                </DataGridTemplateColumn.CellTemplate>
            </DataGridTemplateColumn>

Wenn Sie DataGridCheckBoxColumnzum Implementieren verwenden, dient der erste Klick zum Fokussieren und der zweite Klick zum Überprüfen.

Für die DataGridTemplateColumnImplementierung ist jedoch nur ein Klick erforderlich.

Der Unterschied zwischen Verwendung DataGridComboboxBoxColumnund Implementierung durch DataGridTemplateColumnist ebenfalls ähnlich.

Ich habe damit gelöst:

<DataGridTemplateColumn>
    <DataGridTemplateColumn.CellTemplate>
        <DataTemplate>
            <Viewbox Height="25">
                <CheckBox IsChecked="{Binding TheProperty, UpdateSourceTrigger=PropertyChanged, Mode=TwoWay}"/>
            </Viewbox>
        </DataTemplate>
    </DataGridTemplateColumn.CellTemplate>
</DataGridTemplateColumn>

Das Kontrollkästchen ist mit einem Klick aktiv!

Basierend auf Jim Adornos Antwort und Kommentaren zu seinem Beitrag ist dies eine Lösung mit MultiTrigger:

<Style TargetType="DataGridCell">
  <Style.Triggers>
    <MultiTrigger>
      <MultiTrigger.Conditions>
    <Condition Property="IsReadOnly" Value="False" />
    <Condition Property="IsMouseOver" Value="True" />
      </MultiTrigger.Conditions>
      <Setter Property="IsEditing" Value="True" />
    </MultiTrigger>
  </Style.Triggers>
</Style>

Eine weitere einfache Lösung besteht darin, diesen Stil zu Ihrer DataGridColumn hinzuzufügen. Der Textkörper Ihres Stils kann leer sein.

<DataGridCheckBoxColumn>
     <DataGridCheckBoxColumn.ElementStyle>
          <Style TargetType="CheckBox">
           </Style>
     </DataGridCheckBoxColumn.ElementStyle>
</DataGridCheckBoxColumn>

<Style x:Key="StilCelula" TargetType="DataGridCell"> 
<Style.Triggers>
 <Trigger Property="IsMouseOver" Value="True">
   <Setter Property="IsEditing" 
     Value="{Binding RelativeSource={x:Static RelativeSource.Self}, 
     Converter={StaticResource CheckBoxColumnToEditingConvertor}}" />
 </Trigger>
</Style.Triggers>
<Style>

Imports System.Globalization
Public Class CheckBoxColumnToEditingConvertor
    Implements IValueConverter
    Public Function Convert(ByVal value As Object, ByVal targetType As Type, ByVal parameter As Object, ByVal culture As CultureInfo) As Object Implements IValueConverter.Convert
        Try

            Return TypeOf TryCast(value, DataGridCell).Column Is DataGridCheckBoxColumn
        Catch ex As Exception
            Return Visibility.Collapsed
        End Try
    End Function

    Public Function ConvertBack(ByVal value As Object, ByVal targetType As Type, ByVal parameter As Object, ByVal culture As CultureInfo) As Object Implements IValueConverter.ConvertBack
        Throw New NotImplementedException()
    End Function
End Class