WPF Bound dynamically to DataGridTemplateColumn

Question

Writing my first project in WPF and cannot wrap my mind around fallowing problem.

I have a DataGrid that uses ItemSource from DataSet Table (local DB in XML) User must be able to add columns to DataSet/DataGrid and set column DataTemplate, like text, image, date, ...

So I must use single DataTemplate for multiple columns, and change binding path based on column name, like:

I understand that this approach is not correct, but I failed to find solution that:

-Is not XAML serialization / cloning based - does not work because loses parent references.

-Able to write value to row unlike "Path=." using inherited DataGridBoundColumn instead of DataGridTemplateColumn.

DataGridTextColumn does this is some way, and it works:

 Dim fGridCol = New DataGridTextColumn() With {.Header = fColumn.ColumnName}
 fGridCol.Binding = New Binding(fColumn.ColumnName) With {.Mode = BindingMode.TwoWay}

But DataGridTemplateColumn has no bind, and DataGridBoundColumn does not write value if inherited.

How can you do make this work?

EDIT

Allow me to put my question in different context:

The best I have got so far:

And

    Class MainWindow

        Protected Overrides Sub OnInitialized(e As EventArgs)
            LocalGrid.ItemsSource = Base.Tables("Local").DefaultView
            CreateColumns()
        End Sub

        Private WithEvents Base As New Base
        Private WithEvents LocalTable As DataView = Base.Tables("Local").DefaultView

        Private Sub CreateColumns()
            Dim LocalTable = Base.Tables("Local")
            Dim TypesTable = Base.Tables("ColumnTypes")

            For Each fColumn As DataColumn In LocalTable.Columns

                Dim ColumnType As String = (From fRow As DataRowView In TypesTable.DefaultView Where fRow.Item("Name") = String.Format("Local." & fColumn.ColumnName) Select fRow.Item("Template") Take 1).FirstOrDefault()

                If ColumnType = "Image" Then 'THIS IS IMAGE COLUMN
                    Dim ImageColumn As New DataGridTemplateColumn With {.Header = fColumn.ColumnName}
                    ImageColumn.CellTemplate = Me.FindResource("ImageColumnTemplate")
                    ImageColumn.CellEditingTemplate = Me.FindResource("ImageColumnTemplate")
                    LocalGrid.Columns.Add(ImageColumn)
                Else 'THIS IS REGILAR COLUMN
                    Dim fGridCol = New DataGridTextColumn() With {.Header = fColumn.ColumnName}
                    fGridCol.Binding = New Binding(fColumn.ColumnName) With {.Mode = BindingMode.TwoWay, .UpdateSourceTrigger = UpdateSourceTrigger.LostFocus}
                    LocalGrid.Columns.Add(fGridCol)
                End If

            Next
        End Sub

        Private Sub SelectImageFile(ByVal sender As Object, ByVal e As RoutedEventArgs)
            'This creates OpenFileDialog on button click
        End Sub

    End Class

    Public Class CellStringReader : Implements IValueConverter
        Private EditingCell As DataGridCell

        Public Overridable Function Convert(value As Object, targetType As Type, parameter As Object, culture As CultureInfo) As Object Implements IValueConverter.Convert
            Dim Cell As DataGridCell = value
            Dim Row As DataRowView = Cell.DataContext
            Dim Column As DataGridColumn = Cell.Column

            If Cell.IsEditing Then
                EditingCell = Cell
            Else
                EditingCell = Nothing
            End If

            Return Row.Item(Column.Header)
        End Function

        Public Overridable Function ConvertBack(value As Object, targetType As Type, parameter As Object, culture As CultureInfo) As Object Implements IValueConverter.ConvertBack
            If EditingCell Is Nothing Then 'This is not callded, ever.
                Throw New Exception("No cell editing")
            End If
            Return EditingCell
        End Function
    End Class

    Public Class CellImageReader : Inherits CellStringReader

        Public Overrides Function Convert(value As Object, targetType As Type, parameter As Object, culture As CultureInfo) As Object
            value = MyBase.Convert(value, targetType, parameter, culture)

            If IsDBNull(value) OrElse String.IsNullOrWhiteSpace(value) Then
                Return Nothing
            ElseIf IO.File.Exists(value) Then
                Return New BitmapImage(New Uri(value))
            End If
        End Function

        Public Overrides Function ConvertBack(value As Object, targetType As Type, parameter As Object, culture As CultureInfo) As Object
            Throw New NotSupportedException
        End Function

    End Class

The problem is, that editing TextBox in generated Image column does not call CellStringReader.ConvertBack() and does not write changed value of underlying DataRow.

I understand that this is because "Path=." in TextBox Binding, but I don't know any alternatives.

Parsing XAML in string breaks Button PreviewMouseDown, because of missing context, and it does not write value anyway.

My question is how to make TextBox write new value in DataRow.?

Hope it makes more seance now & sorry for long post.

Dreigo Undead · Accepted Answer

Bloody victory!

So to summary, required functionality is:

Using single DataTemlate to multiple columns in DataGrid
DataTemplate requires TwoWay binding and must be able to write in underlying DataRow object
Secondary edit row with OpenFileDialog

XAML:

XAML DataTemplate code is read by XmlWriter, modified bindings and created new instance of DataTemplate using XDocument.Parse():

For Each fColumn As DataColumn In LocalTable.Columns
    Dim ImageColumn As New DataGridTemplateColumn With {.Header = fColumn.ColumnName}
    ImageColumn.CellTemplate = CreateTemplate("ImageColumnReadTemplate", fColumn.ColumnName)
    ImageColumn.CellEditingTemplate = CreateTemplate("ImageColumnWriteTemplate", fColumn.ColumnName)
    LocalGrid.Columns.Add(ImageColumn)
Next

...

Private Function CreateTemplate(TemplateName As String, ColumnName As String) As DataTemplate
    Dim Template As DataTemplate = Me.FindResource(TemplateName)

    Dim StrBuilder = New StringBuilder()
    Dim Settings = New XmlWriterSettings() With {.Indent = True, .OmitXmlDeclaration = True}
    Dim dsm = New XamlDesignerSerializationManager(XmlWriter.Create(StrBuilder, Settings)) With {.XamlWriterMode = XamlWriterMode.Expression}
    XamlWriter.Save(Template, dsm)

    StrBuilder = StrBuilder.Replace("COLUMN_NAME", ColumnName)

    Dim xmlDoc = XDocument.Parse(StrBuilder.ToString())
    'IO.File.WriteAllLines("D:\xml.txt", xmlDoc.ToString.Split(vbNewLine)) 'Debug

    Dim NewTemplate As DataTemplate = XamlReader.Parse(xmlDoc.ToString())

    Return NewTemplate
End Function

XamlWriter has multiple limitations, one of them is writing/exporting bindings, that are ignored. This is how to make it write bindings: [source] (https://www.codeproject.com/Articles/27158/XamlWriter-and-Bindings-Serialization)

Imports System.ComponentModel
Imports System.Windows.Markup

Class BindingConvertor
    Inherits ExpressionConverter

    Public Overrides Function CanConvertTo(ByVal context As ITypeDescriptorContext, ByVal destinationType As Type) As Boolean
        If destinationType = GetType(MarkupExtension) Then
            Return True
        Else
            Return False
        End If
    End Function

    Public Overrides Function ConvertTo(ByVal context As ITypeDescriptorContext, ByVal culture As System.Globalization.CultureInfo, ByVal value As Object, ByVal destinationType As Type) As Object
        If destinationType = GetType(MarkupExtension) Then
            Dim bindingExpression As BindingExpression = TryCast(value, BindingExpression)
            If bindingExpression Is Nothing Then Throw New Exception()
            Return bindingExpression.ParentBinding
        End If

        Return MyBase.ConvertTo(context, culture, value, destinationType)
    End Function
End Class

Module EditorHelper

    Sub RegisterBindingConvertor
        EditorHelper.Register(Of BindingExpression, BindingConvertor)()
    End Sub

    Sub Register(Of T, TC)()
        Dim attr As Attribute() = New Attribute(0) {}
        Dim vConv As TypeConverterAttribute = New TypeConverterAttribute(GetType(TC))
        attr(0) = vConv
        TypeDescriptor.AddAttributes(GetType(T), attr)
    End Sub
End Module

...

Class MainWindow
    Public Sub New()
        EditorHelper.RegisterBindingConvertor()
        '...
    End Sub
    '...
End Class

For the button handle PreviewMouseClick does not work because of another XmlWriter limitation. Binding to Buttom.Command did work:

Public ReadOnly Property ClickCommand As ICommand = New CommandHandler(AddressOf SelectImageFile, True)

Public Class CommandHandler
    Implements ICommand

    Private _action As Action
    Private _canExecute As Boolean

    Public Sub New(ByVal action As Action, ByVal canExecute As Boolean)
        _action = action
        _canExecute = canExecute
    End Sub

    Public Sub Execute(ByVal parameter As Object) Implements ICommand.Execute
        _action()
    End Sub
    Public Function CanExecute(ByVal parameter As Object) As Boolean Implements ICommand.CanExecute
        Return _canExecute
    End Function

    Public Event CanExecuteChanged As EventHandler Implements ICommand.CanExecuteChanged
End Class

Public Sub SelectImageFile()
    If LocalGrid.CurrentColumn Is Nothing Then Exit Sub

    Dim fd As OpenFileDialog = New OpenFileDialog()
    fd.ShowDialog()
    Dim Row As DataRowView = LocalGrid.CurrentItem
    Row.Item(LocalGrid.CurrentColumn.Header) = fd.FileName

    LocalGrid.CommitEdit()
    BaseGrid_RowEditEnding()
End Sub

This works, but any recommendations how to make this shorter are welcome.

WPF Bound dynamically to DataGridTemplateColumn

Answers (2)

Related Questions