GridView, colorization and read-only?

[philstopford]

Currently, I have a prototype that shoves labels into a TableLayout, to allow me to pick up the text and color from the class instance corresponding to the TableCell.

` tl = new TableLayout();

                for (int r = 0; r < rowCount; r++)
                {
                    TableRow tr = new TableRow();

                    for (int c = 0; c < colCount; c++)
                    {
                        TableCell tc = new TableCell();
                        tr.Cells.Add(tc);
                        Label l = new Label
                        {
                            Text = myTable.rows[r].data[c].Text, BackgroundColor = myTable.rows[r].data[c].C
                        };
                        tc.Control = l;
                    }

                    tl.Rows.Add(tr);

`

This falls over with larger datasets as there is no way to background the UI build and so the main thread gets bogged down. All of my other processing is done off the main thread, but this set-up really hurts.

I assume there's a better way using some form of Grid view component, but the documentation has me uncertain how to reproduce the above, coloring the cells and assigning the text.

[philstopford]

I'm looking at the example code and wondered about using a DataTable, but don't see how to reference the color for the first DataCell; ideally I'd like to be able to define the color for each cell.

`

		var table = new DataTable();
		table.Columns.Add("TextColumn");
		table.Columns.Add("Color1", typeof(Color));
		table.Columns.Add("CheckColumn", typeof(bool));
		table.Columns.Add("TextColumn2");

		table.Rows.Add("Row 1", new Color(1.0f, 0.0f, 0.0f), true, "Bob");
		table.Rows.Add("Row 2", new Color(1.0f, 1.0f, 0.0f), false, "Jeff");
		table.Rows.Add("Row 3", new Color(1.0f, 0.0f, 1.0f), true, "Bosley");

		var collection = table.Rows.Cast<DataRow>()
			.Select(x => new { Text = x[0], Check = x[2], Text2 = x[3] })
			.ToList();

		var grid = new GridView { DataStore = collection };

		grid.Columns.Add(new GridColumn
		{
			DataCell = new TextBoxCell("Text"),
			HeaderText = "Text"
		});
		grid.Columns.Add(new GridColumn
		{
			DataCell = new CheckBoxCell("Check"),
			HeaderText = "Check"
		});
		grid.Columns.Add(new GridColumn
		{
			DataCell = new TextBoxCell("Text2"),
			HeaderText = "Text2"
		});

`

[cwensley]

@philstopford hm, your second example doesn't really match what you are explaining. From what I gather you want each cell to define the text and the color. I'm not sure why using a DataTable vs. using whatever other mechanism you are using to store the data matters in this case.

At any rate, try something like this. The key here is you need a way to get to the particular cell of each row, which I do via Binding.Property((List<MyCellData> r) => r[col]);, then chain off of that. I also use that as a property of a custom column so we can use it again in the CellFormatting event.

Hope this helps.

using System;
using Eto.Forms;
using Eto.Drawing;
using System.Collections.Generic;
using System.Collections.ObjectModel;

namespace TestDynamicGrid
{

    public class MyCellData
    {
        public string Text { get; set; }
        public Color Color { get; set; }
    }

    public class MyGridColumn : GridColumn
    {
        public IndirectBinding<MyCellData> CellBinding { get; set; }
    }

    public partial class MyPanel : Panel
    {
        public MyPanel()
        {
            var grid = new GridView();


            var data = PopulateData(1000, 10);
            for (int i = 0; i < 10; i++)
            {
                var col = i;
                var cellBinding = Binding.Property((List<MyCellData> r) => r[col]);
                var column = new MyGridColumn
                {
                    HeaderText = $"Col: {i}",
                    CellBinding = cellBinding,
                    DataCell = new TextBoxCell
                    {
                        Binding = cellBinding.Child((MyCellData m) => m.Text)
                    }
                };
                grid.Columns.Add(column);
            }

            grid.CellFormatting += grid_CellFormatting;


            grid.DataStore = data;


            Content = grid;

        }

        private void grid_CellFormatting(object sender, GridCellFormatEventArgs e)
        {
            var col = (MyGridColumn)e.Column;
            var cellData = col.CellBinding.GetValue(e.Item);
            e.BackgroundColor = cellData.Color;
        }

        private IList<List<MyCellData>> PopulateData(int rows, int columns)
        {
            var data = new ObservableCollection<List<MyCellData>>();
            int colorId = 0;
            for (int row = 0; row < rows; row++)
            {
                var rowItem = new List<MyCellData>();
                for (int col = 0; col < columns; col++)
                {
                    var item = new MyCellData();
                    item.Text = $"R:{row},C:{col}";
                    item.Color = Color.FromElementId(colorId++);
                    rowItem.Add(item);
                }
                data.Add(rowItem);
            }
            return data;
        }
    }
}

[philstopford]

Thanks - will take this for a spin shortly; the way of accessing things in this particular set-up was escaping me so I really appreciate the example.