WPF DataGrid में सिंगल क्लिक एडिट

Question 1

मैं चाहता हूं कि उपयोगकर्ता सेल को संपादन मोड में डालने में सक्षम हो और पंक्ति को एक सिंगल क्लिक के साथ सम्‍मिलित करें। डिफ़ॉल्ट रूप से, यह डबल क्लिक है।

मैं इसे ओवरराइड या कार्यान्वित कैसे करूं?

Question 2

यहाँ मैंने इस मुद्दे को हल किया है:

<DataGrid DataGridCell.Selected="DataGridCell_Selected" 
          ItemsSource="{Binding Source={StaticResource itemView}}">
    <DataGrid.Columns>
        <DataGridTextColumn Header="Nom" Binding="{Binding Path=Name}"/>
        <DataGridTextColumn Header="Age" Binding="{Binding Path=Age}"/>
    </DataGrid.Columns>
</DataGrid>

यह DataGrid एक CollectionViewSource (डमी व्यक्ति ऑब्जेक्ट्स युक्त ) के लिए बाध्य है ।

जादू वहाँ होता है: DataGridCell.Selected = "DataGridCell_Selected" ।

मैं केवल DataGrid सेल के चयनित ईवेंट को हुक करता हूं, और DataGrid पर BeginEdit () को कॉल करता हूं।

यहाँ घटना हैंडलर के लिए कोड है:

private void DataGridCell_Selected(object sender, RoutedEventArgs e)
{
    // Lookup for the source to be DataGridCell
    if (e.OriginalSource.GetType() == typeof(DataGridCell))
    {
        // Starts the Edit on the row;
        DataGrid grd = (DataGrid)sender;
        grd.BeginEdit(e);
    }
}

Question 3

माइकेल बर्जरॉन का जवाब मेरे लिए एक अच्छी शुरुआत थी जो मेरे लिए काम करने वाले समाधान को खोजने के लिए थी। एकल-पंक्ति संपादन के लिए भी एक ही पंक्ति में सेल के लिए पहले से ही संपादन मोड में अनुमति देने के लिए मुझे इसे थोड़ा समायोजित करना पड़ा। SelectionUnit सेल का उपयोग करना मेरे लिए कोई विकल्प नहीं था।

DataGridCell.Selected Event का उपयोग करने के बजाय जो पहली बार किसी पंक्ति के सेल पर क्लिक किया जाता है, मैंने DataGridCell.GotFocus Event का उपयोग किया।

<DataGrid DataGridCell.GotFocus="DataGrid_CellGotFocus" />

यदि आप ऐसा करते हैं, तो आपके पास हमेशा सही सेल केंद्रित और संपादन मोड में होगा, लेकिन सेल में कोई नियंत्रण केंद्रित नहीं होगा, इस तरह मैंने इसे हल किया

private void DataGrid_CellGotFocus(object sender, RoutedEventArgs e)
{
    // Lookup for the source to be DataGridCell
    if (e.OriginalSource.GetType() == typeof(DataGridCell))
    {
        // Starts the Edit on the row;
        DataGrid grd = (DataGrid)sender;
        grd.BeginEdit(e);

        Control control = GetFirstChildByType<Control>(e.OriginalSource as DataGridCell);
        if (control != null)
        {
            control.Focus();
        }
    }
}

private T GetFirstChildByType<T>(DependencyObject prop) where T : DependencyObject
{
    for (int i = 0; i < VisualTreeHelper.GetChildrenCount(prop); i++)
    {
        DependencyObject child = VisualTreeHelper.GetChild((prop), i) as DependencyObject;
        if (child == null)
            continue;

        T castedProp = child as T;
        if (castedProp != null)
            return castedProp;

        castedProp = GetFirstChildByType<T>(child);

        if (castedProp != null)
            return castedProp;
    }
    return null;
}

Question 4

प्रेषक: http://wpf.codeplex.com/wikipage?title=Single-Click%20Editing

XAML:

<!-- SINGLE CLICK EDITING -->
<Style TargetType="{x:Type dg:DataGridCell}">
    <EventSetter Event="PreviewMouseLeftButtonDown" Handler="DataGridCell_PreviewMouseLeftButtonDown"></EventSetter>
</Style>

कोड के पीछे:

//
// SINGLE CLICK EDITING
//
private void DataGridCell_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
    DataGridCell cell = sender as DataGridCell;
    if (cell != null && !cell.IsEditing && !cell.IsReadOnly)
    {
        if (!cell.IsFocused)
        {
            cell.Focus();
        }
        DataGrid dataGrid = FindVisualParent<DataGrid>(cell);
        if (dataGrid != null)
        {
            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;
                }
            }
        }
    }
}

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

Question 5

Http://wpf.codeplex.com/wikipage?title=Single-Click%20Editing से समाधान ने मेरे लिए बहुत अच्छा काम किया, लेकिन मैंने रिसोर्सबेड में परिभाषित स्टाइल का उपयोग करके इसे हर डेटाग्रिड के लिए सक्षम किया। संसाधन शब्दकोशों में हैंडलर का उपयोग करने के लिए आपको इसमें एक कोड-पीछे फ़ाइल जोड़ने की आवश्यकता है। यहाँ आप इसे कैसे करते हैं:

यह एक DataGridStyles.xaml संसाधन शब्दकोश है:

    <ResourceDictionary x:Class="YourNamespace.DataGridStyles"
                x:ClassModifier="public"
                xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
        <Style TargetType="DataGrid">
            <!-- Your DataGrid style definition goes here -->

            <!-- Cell style -->
            <Setter Property="CellStyle">
                <Setter.Value>
                    <Style TargetType="DataGridCell">                    
                        <!-- Your DataGrid Cell style definition goes here -->
                        <!-- Single Click Editing -->
                        <EventSetter Event="PreviewMouseLeftButtonDown"
                                 Handler="DataGridCell_PreviewMouseLeftButtonDown" />
                    </Style>
                </Setter.Value>
            </Setter>
        </Style>
    </ResourceDictionary>

X नोट करें: मूल तत्व में वर्ग विशेषता। एक वर्ग फ़ाइल बनाएँ। इस उदाहरण में यह DataGridStyles.xaml.cs होगा । इस कोड को अंदर डालें:

using System.Windows.Controls;
using System.Windows;
using System.Windows.Input;

namespace YourNamespace
{
    partial class DataGridStyles : ResourceDictionary
    {

        public DataGridStyles()
        {
          InitializeComponent();
        }

     // The code from the myermian's answer goes here.
}

Question 6

मैं Dušan Knežević सुझाव के आधार पर इस तरह से पसंद करता हूं। आप एक क्लिक करें यह है))

<DataGrid.Resources>

    <Style TargetType="DataGridCell" BasedOn="{StaticResource {x:Type DataGridCell}}">
        <Style.Triggers>
                <MultiTrigger>
                    <MultiTrigger.Conditions>
                        <Condition Property="IsMouseOver"
                                   Value="True" />
                        <Condition Property="IsReadOnly"
                                   Value="False" />
                    </MultiTrigger.Conditions>
                    <MultiTrigger.Setters>
                        <Setter Property="IsEditing"
                                Value="True" />
                    </MultiTrigger.Setters>
                </MultiTrigger>
        </Style.Triggers>
    </Style>

</DataGrid.Resources>

Question 7

मैंने इसे एक ट्रिगर जोड़कर हल किया, जो कि माउस के ऊपर होने पर DataGridCell की IsEditing True पर सेट करता है। इसने मेरी अधिकांश समस्याओं को हल कर दिया। यह कॉम्बोक्स के साथ भी काम करता है।

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

Question 8

मुझे MVVM में सिंगल क्लिक पर एडिटिंग सेल की तलाश है और यह इसे करने का एक और तरीका है।

Xaml में व्यवहार जोड़ना

<UserControl xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
             xmlns:myBehavior="clr-namespace:My.Namespace.To.Behavior">

    <DataGrid>
        <i:Interaction.Behaviors>
            <myBehavior:EditCellOnSingleClickBehavior/>
        </i:Interaction.Behaviors>
    </DataGrid>
</UserControl>

EditCellOnSingleClickBehavior वर्ग System.Windows.Interactivity.Behavior का विस्तार करता है;

public class EditCellOnSingleClick : Behavior<DataGrid>
{
    protected override void OnAttached()
    {
        base.OnAttached();
        this.AssociatedObject.LoadingRow += this.OnLoadingRow;
        this.AssociatedObject.UnloadingRow += this.OnUnloading;
    }

    protected override void OnDetaching()
    {
        base.OnDetaching();
        this.AssociatedObject.LoadingRow -= this.OnLoadingRow;
        this.AssociatedObject.UnloadingRow -= this.OnUnloading;
    }

    private void OnLoadingRow(object sender, DataGridRowEventArgs e)
    {
        e.Row.GotFocus += this.OnGotFocus;
    }

    private void OnUnloading(object sender, DataGridRowEventArgs e)
    {
        e.Row.GotFocus -= this.OnGotFocus;
    }

    private void OnGotFocus(object sender, RoutedEventArgs e)
    {
        this.AssociatedObject.BeginEdit(e);
    }
}

वोइला!

Question 9

User2134678 के उत्तर के साथ दो मुद्दे हैं। एक बहुत मामूली है और कोई कार्यात्मक प्रभाव नहीं है। अन्य काफी महत्वपूर्ण है।

पहला मुद्दा यह है कि गॉटफोकस वास्तव में डेटाग्रिड के खिलाफ कहा जा रहा है, व्यवहार में डेटाग्रिडेल नहीं। XAML में DataGridCell क्वालिफायर बेमानी है।

उत्तर के साथ मुझे जो मुख्य समस्या मिली, वह यह है कि Enter कुंजी व्यवहार टूट गया है। दर्ज करें आपको सामान्य डेटाग्रिड व्यवहार में वर्तमान सेल के नीचे अगले सेल में जाना चाहिए। हालाँकि, वास्तव में पर्दे के पीछे क्या होता है गोटफोकस घटना को दो बार कहा जाएगा। एक बार वर्तमान सेल फोकस को खो देता है, और एक बार नए सेल को फोकस करने पर। लेकिन जब तक BeginEdit को उस पहली सेल पर बुलाया जाता है, तब तक अगली सेल कभी भी सक्रिय नहीं होगी। अपशॉट यह है कि आपके पास एक-क्लिक का संपादन है, लेकिन जो कोई भी सचमुच ग्रिड पर क्लिक नहीं कर रहा है, वह असुविधाजनक होने वाला है, और एक उपयोगकर्ता-इंटरफ़ेस डिजाइनर को यह नहीं मानना चाहिए कि सभी उपयोगकर्ता पति या पत्नी का उपयोग कर रहे हैं। (कीबोर्ड उपयोगकर्ता टैब का उपयोग करके इसके चारों ओर प्राप्त कर सकते हैं, लेकिन इसका मतलब यह है कि वे हुप्स के माध्यम से कूद रहे हैं कि उन्हें आवश्यकता नहीं होनी चाहिए)।

तो इस समस्या का हल? सेल के लिए ईवेंट कीडाउन संभालें और यदि कुंजी एंटर है, तो एक ध्वज सेट करें, जो पहले सेल पर फायरिंग से BeginEdit को रोकता है। अब Enter कुंजी उसी तरह व्यवहार करती है जैसे उसे करना चाहिए।

आरंभ करने के लिए, अपने DataGrid में निम्न शैली जोड़ें:

<DataGrid.Resources>
    <Style TargetType="{x:Type DataGridCell}" x:Key="SingleClickEditingCellStyle">
        <EventSetter Event="KeyDown" Handler="DataGridCell_KeyDown" />
    </Style>
</DataGrid.Resources>

उस शैली को "सेलशेल" पर लागू करें, कॉलम जिसके लिए आप एक-क्लिक सक्षम करना चाहते हैं।

फिर आपके पीछे के कोड में आपके गॉटफोकस हैंडलर में ध्यान दें (ध्यान दें कि मैं यहां VB का उपयोग कर रहा हूं क्योंकि यही हमारा "वन-क्लिक डेटा ग्रिड रिक्वेस्ट" क्लाइंट विकास भाषा के रूप में चाहता था):

Private _endEditing As Boolean = False

Private Sub DataGrid_GotFocus(ByVal sender As Object, ByVal e As RoutedEventArgs)
    If Me._endEditing Then
        Me._endEditing = False
        Return
    End If

    Dim cell = TryCast(e.OriginalSource, DataGridCell)

    If cell Is Nothing Then
        Return
    End If

    If cell.IsReadOnly Then
        Return
    End If

    DirectCast(sender, DataGrid).BeginEdit(e)
    .
    .
    .

फिर आप KeyDown इवेंट के लिए अपना हैंडलर जोड़ें:

Private Sub DataGridCell_KeyDown(ByVal sender As Object, ByVal e As KeyEventArgs)
    If e.Key = Key.Enter Then
        Me._endEditing = True
    End If
End Sub

अब आपके पास एक डेटाग्रिड है जिसने आउट-ऑफ-द-बॉक्स कार्यान्वयन के किसी भी मौलिक व्यवहार को नहीं बदला है और अभी तक एकल-क्लिक संपादन का समर्थन करता है।

Question 10

मुझे पता है कि मुझे पार्टी में थोड़ी देर हो गई है, लेकिन मुझे एक ही समस्या थी और एक अलग समाधान के साथ आया:

     public class DataGridTextBoxColumn : DataGridBoundColumn
 {
  public DataGridTextBoxColumn():base()
  {
  }

  protected override FrameworkElement GenerateEditingElement(DataGridCell cell, object dataItem)
  {
   throw new NotImplementedException("Should not be used.");
  }

  protected override FrameworkElement GenerateElement(DataGridCell cell, object dataItem)
  {
   var control = new TextBox();
   control.Style = (Style)Application.Current.TryFindResource("textBoxStyle");
   control.FontSize = 14;
   control.VerticalContentAlignment = VerticalAlignment.Center;
   BindingOperations.SetBinding(control, TextBox.TextProperty, Binding);
    control.IsReadOnly = IsReadOnly;
   return control;
  }
 }

        <DataGrid Grid.Row="1" x:Name="exportData" Margin="15" VerticalAlignment="Stretch" ItemsSource="{Binding CSVExportData}" Style="{StaticResource dataGridStyle}">
        <DataGrid.Columns >
            <local:DataGridTextBoxColumn Header="Sample ID" Binding="{Binding SampleID}" IsReadOnly="True"></local:DataGridTextBoxColumn>
            <local:DataGridTextBoxColumn Header="Analysis Date" Binding="{Binding Date}" IsReadOnly="True"></local:DataGridTextBoxColumn>
            <local:DataGridTextBoxColumn Header="Test" Binding="{Binding Test}" IsReadOnly="True"></local:DataGridTextBoxColumn>
            <local:DataGridTextBoxColumn Header="Comment" Binding="{Binding Comment}"></local:DataGridTextBoxColumn>
        </DataGrid.Columns>
    </DataGrid>

जैसा कि आप देख सकते हैं मैंने अपना खुद का DataGridTextColumn लिखा है, जो कि DataGridBoundColumn की उल्टी सब कुछ विरासत में मिला है। GenerateElement Method को ओवरराइड करके और एक Textbox कंट्रोल को वहीं पर वापस करने से एडिटिंग एलिमेंट जेनरेट करने का तरीका कभी नहीं कहलाता। एक अलग परियोजना में मैंने एक डेटपिकर कॉलम को लागू करने के लिए इसका इस्तेमाल किया, इसलिए यह चेकबॉक्स और कॉम्बोक्स के लिए भी काम करना चाहिए।

ऐसा नहीं लगता है कि बाकी डिटैग्रिड्स व्यवहारों को प्रभावित करता है..इसलिए कम से कम मैंने कोई दुष्प्रभाव नहीं देखा है और न ही मुझे अब तक कोई नकारात्मक प्रतिक्रिया मिली है।

Question 11

अपडेट करें

एक सरल समाधान यदि आप इस बात से ठीक हैं कि आपका सेल एक टेक्स्टबॉक्स (एडिट और नॉन-एडिट मोड के बीच कोई भेद नहीं करता है) रहता है। इस तरह एकल क्लिक संपादन बॉक्स से बाहर काम करता है। यह कंबोबॉक्स और बटन जैसे अन्य तत्वों के साथ भी काम करता है। अन्यथा अद्यतन के नीचे समाधान का उपयोग करें।

<DataGridTemplateColumn Header="My Column header">
   <DataGridTemplateColumn.CellTemplate>
      <DataTemplate>
         <TextBox Text="{Binding MyProperty } />
      </DataTemplate>
   </DataGridTemplateColumn.CellTemplate>
</DataGridTemplateColumn>

अपडेट अंत

शेख़ी

मैंने यहाँ और Google पर मिलने वाली हर चीज़ को आज़माया और अपना संस्करण बनाने की भी कोशिश की। लेकिन हर उत्तर / समाधान ने मुख्य रूप से टेक्स्टबॉक्स कॉलम के लिए काम किया, लेकिन अन्य सभी तत्वों (चेकबॉक्स, कॉम्बोक्स, बटन कॉलम) के साथ काम नहीं किया, या उन अन्य तत्व कॉलमों को भी तोड़ दिया या उनके कुछ अन्य दुष्प्रभाव भी थे। डेटाग्रिड बनाने के लिए धन्यवाद microsoft उस बदसूरत तरीके से व्यवहार करता है और हमें उन हैक्स को बनाने के लिए मजबूर करता है। उसकी वजह से मैंने एक ऐसा संस्करण बनाने का फैसला किया, जिसे स्टाइल के साथ सीधे टेक्स्टबॉक्स कॉलम पर लागू किया जा सकता है, अन्य कॉलम को प्रभावित किए बिना।

विशेषताएं

पीछे कोई कोड नहीं। MVVM के अनुकूल।
यह एक ही या अलग-अलग पंक्तियों में विभिन्न टेक्स्टबॉक्स कोशिकाओं पर क्लिक करते समय काम करता है।
TAB और ENTER कुंजियाँ काम करती हैं।
यह अन्य स्तंभों को प्रभावित नहीं करता है।

सूत्रों का कहना है

मैंने इस समाधान और @ के उत्तर का उपयोग किया और उन्हें एक संलग्न व्यवहार होने के लिए संशोधित किया। http://wpf-tutorial-net.blogspot.com/2016/05/wpf-datagrid-edit-cell-on-single-click.html

इसे कैसे उपयोग करे

इस शैली को जोड़ें। यह BasedOnमहत्वपूर्ण है जब आप अपने डाटाग्रिड के लिए कुछ फैंसी शैलियों का उपयोग करते हैं और आप उन्हें खोना नहीं चाहते हैं।

<Window.Resources>
    <Style x:Key="SingleClickEditStyle" TargetType="{x:Type DataGridCell}" BasedOn="{StaticResource {x:Type DataGridCell}}">
        <Setter Property="local:DataGridTextBoxSingleClickEditBehavior.Enable" Value="True" />
    </Style>
</Window.Resources>

इस तरह CellStyleसे अपने प्रत्येक के साथ शैली लागू करें DataGridTextColumns:

<DataGrid ItemsSource="{Binding MyData}" AutoGenerateColumns="False">
    <DataGrid.Columns>
        <DataGridTextColumn Header="My Header" Binding="{Binding Comment}" CellStyle="{StaticResource SingleClickEditStyle}" />         
    </DataGrid.Columns>
</DataGrid>

और अब इस क्लास को अपने MainViewModel (या एक अलग Namespace) के समान नामस्थान में जोड़ें। लेकिन तब आपको अन्य नामस्थान उपसर्ग का उपयोग करने की आवश्यकता होगी local)। संलग्न व्यवहारों के बदसूरत बॉयलरप्लेट कोड की दुनिया में आपका स्वागत है।

using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;

namespace YourMainViewModelNameSpace
{
    public static class DataGridTextBoxSingleClickEditBehavior
    {
        public static readonly DependencyProperty EnableProperty = DependencyProperty.RegisterAttached(
            "Enable",
            typeof(bool),
            typeof(DataGridTextBoxSingleClickEditBehavior),
            new FrameworkPropertyMetadata(false, OnEnableChanged));


        public static bool GetEnable(FrameworkElement frameworkElement)
        {
            return (bool) frameworkElement.GetValue(EnableProperty);
        }


        public static void SetEnable(FrameworkElement frameworkElement, bool value)
        {
            frameworkElement.SetValue(EnableProperty, value);
        }


        private static void OnEnableChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is DataGridCell dataGridCell)
                dataGridCell.PreviewMouseLeftButtonDown += DataGridCell_PreviewMouseLeftButtonDown;
        }


        private static void DataGridCell_PreviewMouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
        {
            EditCell(sender as DataGridCell, e);
        }

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

            if (dataGridCell.IsFocused == false)
                dataGridCell.Focus();

            var dataGrid = FindVisualParent<DataGrid>(dataGridCell);
            dataGrid?.BeginEdit(e);
        }


        private static T FindVisualParent<T>(UIElement element) where T : UIElement
        {
            var parent = VisualTreeHelper.GetParent(element) as UIElement;

            while (parent != null)
            {
                if (parent is T parentWithCorrectType)
                    return parentWithCorrectType;

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

            return null;
        }
    }
}

Question 12

 <DataGridComboBoxColumn.CellStyle>
                        <Style TargetType="DataGridCell">
                            <Setter Property="cal:Message.Attach" 
                            Value="[Event MouseLeftButtonUp] = [Action ReachThisMethod($source)]"/>
                        </Style>
                    </DataGridComboBoxColumn.CellStyle>

 public void ReachThisMethod(object sender)
 {
     ((System.Windows.Controls.DataGridCell)(sender)).IsEditing = true;

 }