Tukukkk

I have a 2-dimensional array of objects and I basically want to databind each one to a cell in a WPF grid. Currently I have this working but I am doing most of it procedurally. I create the correct number of row and column definitions, then I loop through the cells and create the controls and set up the correct bindings for each one.

At a minimum I would like to be able to use a template to specify the controls and bindings in xaml. Ideally I would like to get rid of the procedural code and just do it all with databinding, but I'm not sure that's possible.

Here is the code I am currently using:

public void BindGrid()

{

    m_Grid.Children.Clear();

    m_Grid.ColumnDefinitions.Clear();

    m_Grid.RowDefinitions.Clear();



    for (int x = 0; x < MefGrid.Width; x++)

    {

        m_Grid.ColumnDefinitions.Add(new ColumnDefinition() { Width = new GridLength(1, GridUnitType.Star), });

    }



    for (int y = 0; y < MefGrid.Height; y++)

    {

        m_Grid.RowDefinitions.Add(new RowDefinition() { Height = new GridLength(1, GridUnitType.Star), });

    }



    for (int x = 0; x < MefGrid.Width; x++)

    {

        for (int y = 0; y < MefGrid.Height; y++)

        {

            Cell cell = (Cell)MefGrid[x, y];                    



            SolidColorBrush brush = new SolidColorBrush();



            var binding = new Binding("On");

            binding.Converter = new BoolColorConverter();

            binding.Mode = BindingMode.OneWay;



            BindingOperations.SetBinding(brush, SolidColorBrush.ColorProperty, binding);



            var rect = new Rectangle();

            rect.DataContext = cell;

            rect.Fill = brush;

            rect.SetValue(Grid.RowProperty, y);

            rect.SetValue(Grid.ColumnProperty, x);

            m_Grid.Children.Add(rect);

        }

    }



}

The purpose of the Grid is not for real databinding, it is just a panel. I am listing down the easiest way to accomplish the visualization of a two dimensional list

<Window.Resources>

    <DataTemplate x:Key="DataTemplate_Level2">

            <Button Content="{Binding}" Height="40" Width="50" Margin="4,4,4,4"/>

    </DataTemplate>



    <DataTemplate x:Key="DataTemplate_Level1">

        <ItemsControl ItemsSource="{Binding}" ItemTemplate="{DynamicResource DataTemplate_Level2}">

            <ItemsControl.ItemsPanel>

                <ItemsPanelTemplate>

                    <StackPanel Orientation="Horizontal"/>

                </ItemsPanelTemplate>

            </ItemsControl.ItemsPanel>

        </ItemsControl>

    </DataTemplate>



</Window.Resources>

<Grid>

    <ItemsControl x:Name="lst" ItemTemplate="{DynamicResource DataTemplate_Level1}"/>

</Grid>

And in the code behind set the ItemsSource of lst with a TwoDimentional data structure.

  public Window1()

    {

        List<List<int>> lsts = new List<List<int>>();



        for (int i = 0; i < 5; i++)

        {

            lsts.Add(new List<int>());



            for (int j = 0; j < 5; j++)

            {

                lsts[i].Add(i * 10 + j);

            }

        }



        InitializeComponent();



        lst.ItemsSource = lsts;

    }

This gives you the following screen as output. You can edit the DataTemplate_Level2 to add more specific data of your object.

Here is a Control called DataGrid2D that can be populated based on a 2D or

1D array (or anything that implements the IList interface). It subclasses DataGrid and adds a property called ItemsSource2D which is used for binding against 2D or 1D sources. Library can be downloaded here and source code can be downloaded here.

To use it just add a reference to DataGrid2DLibrary.dll, add this namespace

xmlns:dg2d="clr-namespace:DataGrid2DLibrary;assembly=DataGrid2DLibrary"

and then create a DataGrid2D and bind it to your IList, 2D array or 1D array like this

<dg2d:DataGrid2D Name="dataGrid2D"

                 ItemsSource2D="{Binding Int2DList}"/>

OLD POST

Here is an implementation that can bind a 2D array to the WPF datagrid.

Say we have this 2D array

private int[,] m_intArray = new int[5, 5];

...

for (int i = 0; i < 5; i++)

{

    for (int j = 0; j < 5; j++)

    {

        m_intArray[i,j] = (i * 10 + j);

    }

}

And then we want to bind this 2D array to the WPF DataGrid and the changes we make shall be reflected in the array. To do this I used Eric Lippert's Ref class from this thread.

public class Ref<T>  

{ 

    private readonly Func<T> getter;  

    private readonly Action<T> setter; 

    public Ref(Func<T> getter, Action<T> setter)  

    {  

        this.getter = getter;  

        this.setter = setter;  

    } 

    public T Value { get { return getter(); } set { setter(value); } }  

} 

Then I made a static helper class with a method that could take a 2D array and return a DataView using the Ref class above.

public static DataView GetBindable2DArray<T>(T[,] array)

{

    DataTable dataTable = new DataTable();

    for (int i = 0; i < array.GetLength(1); i++)

    {

        dataTable.Columns.Add(i.ToString(), typeof(Ref<T>));

    }

    for (int i = 0; i < array.GetLength(0); i++)

    {

        DataRow dataRow = dataTable.NewRow();

        dataTable.Rows.Add(dataRow);

    }

    DataView dataView = new DataView(dataTable);

    for (int i = 0; i < array.GetLength(0); i++)

    {

        for (int j = 0; j < array.GetLength(1); j++)

        {

            int a = i;

            int b = j;

            Ref<T> refT = new Ref<T>(() => array[a, b], z => { array[a, b] = z; });

            dataView[i][j] = refT;

        }

    }

    return dataView;

}

This would almost be enough to bind to but the Path in the Binding will point to the Ref object instead of the Ref.Value which we need so we have to change this when the Columns get generated.

<DataGrid Name="c_dataGrid"

          RowHeaderWidth="0"

          ColumnHeaderHeight="0"

          AutoGenerateColumns="True"

          AutoGeneratingColumn="c_dataGrid_AutoGeneratingColumn"/>



private void c_dataGrid_AutoGeneratingColumn(object sender, DataGridAutoGeneratingColumnEventArgs e)

{

    DataGridTextColumn column = e.Column as DataGridTextColumn;

    Binding binding = column.Binding as Binding;

    binding.Path = new PropertyPath(binding.Path.Path + ".Value");

}

And after this we can use

c_dataGrid.ItemsSource = BindingHelper.GetBindable2DArray<int>(m_intArray);

And the output will look like this

Any changes made in the DataGrid will be reflected in the m_intArray.

I wrote a small library of attached properties for the DataGrid.
Here is the source

Sample, where Data2D is int[,]:

<DataGrid HeadersVisibility="None"

          dataGrid2D:Source2D.ItemsSource2D="{Binding Data2D}" />

Renders:

You may want to check out this link: http://www.thinkbottomup.com.au/site/blog/Game_of_Life_in_XAML_WPF_using_embedded_Python

If you use a List within a List you can use myList[x][y] to access a cell.