Come eseguire la selezione della casella di controllo Clic singolo in WPF DataGrid?

Ho un DataGrid con prima colonna come colonna di testo e seconda colonna come colonna CheckBox. Quello che voglio è, se faccio clic sulla casella di controllo. Dovrebbe essere controllato.

Tuttavia, bastano due clic per essere selezionati, per il primo clic viene selezionata la cella, per i secondi clic viene selezionata la casella di controllo. Come fare la casella di controllo per essere selezionato / deselezionato con un solo clic.

Sto usando WPF 4.0. Le colonne in DataGrid sono generate automaticamente.

Per singolo clic DataGrid checkbox che si può semplicemente mettere regolare all'interno di controllo casella di controllo DataGridTemplateColumne set UpdateSourceTrigger=PropertyChanged.

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

Ho risolto questo con il seguente stile:

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

È ovviamente possibile adattarlo ulteriormente per colonne specifiche ...

Prima di tutto, so che questa è una domanda piuttosto vecchia, ma ho ancora pensato di provare a rispondere.

Ho avuto lo stesso problema un paio di giorni fa e ho trovato una soluzione sorprendentemente breve (vedi questo blog ). Fondamentalmente, tutto ciò che devi fare è sostituire la DataGridCheckBoxColumndefinizione nel tuo XAML con il seguente:

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

Il vantaggio di questa soluzione è ovvio: è solo XAML; quindi ti impedisce efficacemente di gravare sul code-back con una logica dell'interfaccia utente aggiuntiva e ti aiuta a mantenere il tuo stato agli occhi dei fanatici di MVVM;).

Per rendere la risposta di Konstantin Salavatov lavoro con AutoGenerateColumns, aggiungere un gestore di eventi per le DataGrid's AutoGeneratingColumncon il seguente codice:

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

Ciò renderà modificabili tutte le DataGridcolonne della casella di controllo generate automaticamente "clic singolo".

Basato sul blog a cui fa riferimento la risposta di Goblin, ma modificato per funzionare in .NET 4.0 e con la modalità di selezione riga.

Si noti che accelera anche la modifica di DataGridComboBoxColumn - accedendo alla modalità di modifica e visualizzando il menu a discesa con un singolo clic o input di testo.

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

Ho provato questi suggerimenti e molti altri ho trovato su altri siti, ma nessuno di questi ha funzionato abbastanza per me. Alla fine, ho creato la seguente soluzione.

Ho creato il mio controllo ereditato da DataGrid e ho semplicemente aggiunto questo codice:

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

Cosa fa tutto questo?

Bene, ogni volta che facciamo clic su qualsiasi cella nel nostro DataGrid, vediamo se la cella contiene un controllo CheckBox al suo interno. Se lo fa , allora ci concentreremo su quel CheckBox e commuteremo il suo valore .

Questo sembra funzionare per me ed è una soluzione piacevole e facilmente riutilizzabile.

E 'deludente che abbiamo bisogno per scrivere il codice per fare questo però. La spiegazione che il primo clic del mouse (su CheckBox di un DataGrid) viene "ignorata" quando WPF lo usa per mettere la riga in modalità Modifica potrebbe sembrare logica, ma nel mondo reale, questo va contro il modo in cui funziona ogni vera applicazione.

Se un utente vede una casella sullo schermo, dovrebbe essere in grado di fare clic su di essa una volta per spuntarla / deselezionarla. Fine della storia.

C'è una soluzione molto più semplice qui.

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

Se si utilizza DataGridCheckBoxColumnper implementare, il primo clic è quello di mettere a fuoco, il secondo clic è quello di verificare.

Ma l'utilizzo DataGridTemplateColumnper implementare richiede solo un clic.

Anche la differenza tra l'utilizzo DataGridComboboxBoxColumne l'implementazione DataGridTemplateColumnè simile.

Ho risolto con questo:

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

La casella di controllo attiva con un solo clic!

Basati sulla risposta di Jim Adorno e sui commenti sul suo post, questa è la soluzione con 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>

Un'altra soluzione semplice è quella di aggiungere questo stile a DataGridColumn. Il corpo del tuo stile può essere vuoto.

<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