prs/prs.mobile/comal.timesheets/DataGrid/MobileDataGrid.xaml.cs

using comal.timesheets.Data_Classes;
using comal.timesheets.Deliveries;
using InABox.Clients;
using InABox.Core;
using Syncfusion.XForms.PopupLayout;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.IO;
using System.Linq;
using System.Reflection;
using Xamarin.Forms;
using Xamarin.Forms.Xaml;

namespace comal.timesheets
{
    public enum DataGridSaveType
    {
        None,
        Single,
        Multiple
    }

    public delegate void DataGridOptionsSet(string title, DataGridSaveType savetype = DataGridSaveType.None);
    public delegate object DataGridItemSelected(DataGridViewModelItem item);
    public delegate object DataGridImageSelected(DataGridViewModelItem item);
    [XamlCompilation(XamlCompilationOptions.Compile)]

    public partial class MobileDataGrid : ContentView
    {
        public event DataGridOptionsSet OnOptionsSet;
        public event DataGridItemSelected OnItemSelected;
        public event DataGridImageSelected OnImageSelected;
        public List<DataGridViewModelItem> Items { get; set; }
        DataGridSaveType SaveType { get; set; }

        bool bSearching = false;
        ObservableCollection<DataGridFilter> Filters = new ObservableCollection<DataGridFilter>();
        List<DataGridViewModelItem> CurrentItems = new List<DataGridViewModelItem>();
        PropertyInfo[] info = typeof(DataGridViewModelItem).GetProperties();
        Dictionary<string, List<string>> FilterOptions = new Dictionary<string, List<string>>();
        Type Type;
        SfPopupLayout popupLayout;

        /// <summary>
        /// To create a grid of a new kind, add a new class to the shared code and inherit from MobileDataGrid
        /// - Create a new DataGridHost (page) and pass the grid as a parameter
        /// - Within the new grid, pass the required data into the "Setup" method (max of 4 columns - defined in each item's Data (List of Tuples<string, string> )
        /// - See ProductsGrid or an existing grid for examples
        /// - Grid custom behaviour can be defined using events 
        /// - Custom behaviour can be defined for all grids of that kind (defined on the grid itself), or from the host page (different behaviour for the same grid, based on where it is called from)
        /// </summary>
        public MobileDataGrid()
        {
            InitializeComponent();
            Items = new List<DataGridViewModelItem>();
            Filters.CollectionChanged += Filters_CollectionChanged;
            SetupPopupLayout();
        }
        private void SetupPopupLayout()
        {
            popupLayout = new SfPopupLayout();
            popupLayout.PopupView.WidthRequest = 600;
            popupLayout.PopupView.HeightRequest = 600;
            popupLayout.PopupView.HeaderTitle = "Detail";
            popupLayout.PopupView.AcceptButtonText = "Close";
        }

        #region Grid Setup
        public void Setup(List<DataGridViewModelItem> items, Type type, DataGridSaveType savetype = DataGridSaveType.None)
        {
            if (items == null || items.Count == 0)
                return;
            Type = type;
            Items = items;
            Device.BeginInvokeOnMainThread(() =>
            {
                SetupHeaders(items.First());
                Refresh(Items);
            });
            OnOptionsSet?.Invoke(type.Name, savetype);
            SaveType = savetype;
        }

        /// <summary>
        /// Never pass CurrentItems into this function 
        /// - Create an intermediate list first
        /// - CurrentItems gets cleared in order to be reset properly
        /// </summary>
        /// <param name="items"></param>
        public void Refresh(List<DataGridViewModelItem> items)
        {
            itemsListView.ItemsSource = items;
            countLbl.Text = items.Count + " Records";
            CurrentItems.Clear();
            foreach (var item in items)
            {
                CurrentItems.Add(item);
            }
            if (Filters.Any())
                filterBtnRow.Height = 80;
            else
                filterBtnRow.Height = 0;


            int count = 0;
            foreach (var column in Items.First().Data)
            {
                var filter = Filters.FirstOrDefault(x => x.ColNumber == "Col" + count);
                if (filter != null)
                    ChangeHeaderColour(true, count);
                else
                    ChangeHeaderColour(false, count);
                count++;
            }
        }

        public void SetupHeaders(DataGridViewModelItem item)
        {
            var count = GenerateHeaders(item);
            GenerateImageHeader(item, count);
            SelectListViewTemplate(item);
        }

        //only way to reliably get the desired layout/correct bindings dynamically - viewcells are predefined in DataGrid/View/Templates folder.
        //Mobiles will only ever want 4 columns maximum, so the predefined templates are a small tradeoff
        private void SelectListViewTemplate(DataGridViewModelItem item)
        {
            var template = new DataTemplate();
            if (item.Image == null)
            {
                switch (item.Data.Count)
                {
                    case 2:
                        template = new DataTemplate(() =>
                        {
                            var cell = new ViewCell2Columns();
                            cell.OnCellTapped += Row_Tapped;
                            return cell;
                        });
                        break;
                    case 3:
                        template = new DataTemplate(() =>
                        {
                            var cell = new ViewCell3Columns();
                            cell.OnCellTapped += Row_Tapped;
                            return cell;
                        });
                        break;
                    case 4:
                        template = new DataTemplate(() =>
                        {
                            var cell = new ViewCell4Columns();
                            cell.OnCellTapped += Row_Tapped;
                            return cell;
                        });
                        break;
                }
            }
            else
            {
                switch (item.Data.Count)
                {
                    case 2:
                        template = new DataTemplate(() =>
                        {
                            var cell = new ViewCell2ColumnsWithImage();
                            cell.OnCellTapped += Row_Tapped;
                            cell.OnImageTapped += Image_Tapped;
                            return cell;
                        });
                        break;
                    case 3:
                        template = new DataTemplate(() =>
                        {
                            var cell = new ViewCell3ColumnsWithImage();
                            cell.OnCellTapped += Row_Tapped;
                            cell.OnImageTapped += Image_Tapped;
                            return cell;
                        });
                        break;
                    case 4:
                        template = new DataTemplate(() =>
                        {
                            var cell = new ViewCell4ColumnsWithImage();
                            cell.OnCellTapped += Row_Tapped;
                            cell.OnImageTapped += Image_Tapped;
                            return cell;
                        });
                        break;
                }
            }
            itemsListView.ItemTemplate = template;
        }

        public int GenerateHeaders(DataGridViewModelItem item)
        {
            int count = 0;
            foreach (var tuple in item.Data)
            {
                CreateNewHeader(tuple.Item1, count);
                CreateFilterOption(count);
                count++;
            }
            return count;
        }

        private void GenerateImageHeader(DataGridViewModelItem item, int count)
        {
            if (item.Image != null)
            {
                headerGrid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
                DataGridHeaderRow header = new DataGridHeaderRow { ColumnName = "Img", ColumnNumber = count };
                header.Setup();
                headerGrid.Children.Add(SetGridValues(header, 0, count));
                CreateSearchEntry("Img", count);
            }
        }

        private void CreateNewHeader(string name, int count)
        {
            headerGrid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
            DataGridHeaderRow header = new DataGridHeaderRow { ColumnName = name, ColumnNumber = count };
            header.Setup();
            header.OnDataGridHeaderFilterTapped += Header_OnDataGridHeaderFilterTapped;
            header.OnDataGridHeaderTapped += Header_OnDataGridHeaderTapped;
            headerGrid.Children.Add(SetGridValues(header, 0, count));
            CreateSearchEntry(name, count);
        }
        private void CreateFilterOption(int column)
        {
            List<string> options = new List<string>();
            foreach (var property in info)
            {
                if (property.Name == "Col" + column)
                    foreach (var item in Items)
                    {
                        string value = GetStringValue(property, item);
                        if (!options.Contains(value) && !string.IsNullOrWhiteSpace(value))
                            options.Add(value);
                    }
            }
            options.Sort();
            FilterOptions.Add("Col" + column, options);
        }

        private void CreateSearchEntry(string name, int count)
        {
            var searchEnt = new DataGridSearchEntry(name, count);
            searchEnt.OnDataGridSearchEntryChanged += SearchEnt_OnDataGridSearchEntryChanged;
            searchEnt.IsEnabled = name == "Img" ? false : true;
            headerGrid.Children.Add(SetGridValues(searchEnt, 1, count));
        }

        private View SetGridValues(View view, int row, int column)
        {
            view.SetValue(Grid.RowProperty, row);
            view.SetValue(Grid.ColumnProperty, column);
            return view;
        }
        #endregion

        #region Events
        /// <summary>
        /// Depending on the selection mode of the supplied entity grid, tap will do different things
        /// - Does not apply to images
        /// - Multi select mode adds to selection (or removes it if already selected)
        /// - Single select mode adds to selection (or removes it if already selected), removes any other selected items
        /// - None does not select or deselect
        /// 
        /// - NOTE that Item Selected event can return an object - e.g. a view to be displayed in a popup (since grids don't have access to popups)
        /// - This allows different selection reactions to be defined at the grid level, or even different reactions for the same grid depending on where it is called from
        /// - Add to the ProcessReturnObj() method to define specific reactions to each object
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Row_Tapped(object sender, EventArgs e)
        {
            var item = itemsListView.SelectedItem as DataGridViewModelItem;
            if (item == null)
                return;

            if (SaveType == DataGridSaveType.Single || SaveType == DataGridSaveType.Multiple)
            {
                switch (SaveType)
                {
                    case DataGridSaveType.Single:
                        AddSelectionToLists(item);
                        UnselectOthers(item);
                        break;
                    case DataGridSaveType.Multiple:
                        AddSelectionToLists(item);
                        break;

                }
                List<DataGridViewModelItem> list = new List<DataGridViewModelItem>();
                foreach (var i in CurrentItems)
                    list.Add(i);
                Refresh(list);
            }

            var obj = OnItemSelected?.Invoke(item);
            ProcessReturnObj(obj, item);
        }

        private void ProcessReturnObj(object obj, DataGridViewModelItem item)
        {
            if (obj == null)
                return;

            if (obj is View)
            {
                popupLayout.PopupView.ContentTemplate = new DataTemplate(() =>
                {
                    return obj;
                });
                Device.BeginInvokeOnMainThread(() => { popupLayout.Show(); });
            }
        }

        private void UnselectOthers(DataGridViewModelItem item)
        {
            UnselectItems(item, Items);
            UnselectItems(item, CurrentItems);
        }

        private void Image_Tapped(object sender, EventArgs e)
        {
            var item = ((TappedEventArgs)e).Parameter as DataGridViewModelItem;
            if (item == null)
                return;

            if (item.ImageID != Guid.Empty)
            {
                CoreTable table = new Client<Document>().Query(new Filter<Document>(x => x.ID).IsEqualTo(item.ImageID),
                new Columns<Document>(x => x.Data));
                CoreRow docrow = table.Rows.FirstOrDefault();
                if (docrow != null)
                {
                    byte[] data = docrow.Get<Document, byte[]>(x => x.Data);
                    ImageSource src = ImageSource.FromStream(() => new MemoryStream(data));
                    if (src != null)
                    {
                        Image popupContent = new Image();
                        popupContent.HorizontalOptions = LayoutOptions.FillAndExpand;
                        popupContent.VerticalOptions = LayoutOptions.FillAndExpand;
                        popupContent.Aspect = Aspect.AspectFit;
                        popupContent.Source = src;
                        popupLayout.PopupView.ContentTemplate = new DataTemplate(() =>
                        {
                            return popupContent;
                        });
                        Device.BeginInvokeOnMainThread(() => { popupLayout.Show(); });

                    }
                }
            }
            else
            {
                var obj = OnImageSelected?.Invoke(item);
                ProcessReturnObj(obj, item);
            }
        }

        private void UnselectItems(DataGridViewModelItem item, List<DataGridViewModelItem> selectedlist)
        {
            var list = selectedlist.Where(x => x.IsSelected == true);
            foreach (var foundItem in list)
            {
                if (foundItem.ID != item.ID)
                    foundItem.IsSelected = false;
            }
        }

        private void AddSelectionToLists(DataGridViewModelItem item)
        {
            bool selected = item.IsSelected;

            AddSelectionToList(selected, Items, item.ID);
            AddSelectionToList(selected, CurrentItems, item.ID);
        }

        private void AddSelectionToList(bool selected, List<DataGridViewModelItem> list, Guid ID)
        {
            var foundItem = list.FirstOrDefault(x => x.ID == ID);
            if (foundItem != null)
                foundItem.IsSelected = selected ? false : true;
        }

        private void SearchEnt_OnDataGridSearchEntryChanged(int columnnumber, string value, string colname)
        {
            if (string.IsNullOrWhiteSpace(value))
                Filters.Remove(Filters.FirstOrDefault(x => x.ColNumber == "Col" + columnnumber && x.FilterType == FilterType.Typed));
            else
            {
                if (Filters.FirstOrDefault(x => x.ColNumber == "Col" + columnnumber) != null)
                    Filters.Remove(Filters.FirstOrDefault(x => x.ColNumber == "Col" + columnnumber && x.FilterType == FilterType.Typed));
                Filters.Add(new DataGridFilter(colname, "Col" + columnnumber, value, FindNumber(columnnumber), FilterType.Typed));
            }
        }

        private void Filters_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            UpdateScreenOnFilter();
        }

        public void UpdateScreenOnFilter()
        {
            if (bSearching)
                return;

            CheckFilterDisplay();

            bSearching = true;

            List<DataGridViewModelItem> finalList = new List<DataGridViewModelItem>();

            if (Filters.FirstOrDefault(x => x.FilterNumber == FilterNumber.Zero) != null)
            {
                var foundfilters = Filters.Where(x => x.FilterNumber == FilterNumber.Zero);
                foreach (var foundfilter in foundfilters)
                {
                    foreach (DataGridViewModelItem item in RunSearch(Items, foundfilter.Value, "Col0"))
                        finalList.Add(item);
                }
            }
            else
            {
                foreach (DataGridViewModelItem item in Items)
                    finalList.Add(item);
            }

            if (Filters.FirstOrDefault(x => x.FilterNumber == FilterNumber.One) != null)
            {
                var foundfilters = Filters.Where(x => x.FilterNumber == FilterNumber.One);
                List<DataGridViewModelItem> intermediatelist = new List<DataGridViewModelItem>();
                foreach (var foundfilter in foundfilters)
                {
                    foreach (DataGridViewModelItem item in RunSearch(finalList, foundfilter.Value, "Col1"))
                        intermediatelist.Add(item);
                }
                finalList.Clear();
                foreach (DataGridViewModelItem item in intermediatelist)
                    finalList.Add(item);
            }
            else if (finalList.Count == 0)
            {
                foreach (DataGridViewModelItem item in Items)
                    finalList.Add(item);
            }

            if (Filters.FirstOrDefault(x => x.FilterNumber == FilterNumber.Two) != null)
            {
                var foundfilters = Filters.Where(x => x.FilterNumber == FilterNumber.Two);
                List<DataGridViewModelItem> intermediatelist = new List<DataGridViewModelItem>();
                foreach (var foundfilter in foundfilters)
                {
                    foreach (DataGridViewModelItem item in RunSearch(finalList, foundfilter.Value, "Col2"))
                        intermediatelist.Add(item);
                }
                finalList.Clear();
                foreach (DataGridViewModelItem item in intermediatelist)
                    finalList.Add(item);
            }
            else if (finalList.Count == 0)
            {
                foreach (DataGridViewModelItem item in Items)
                    finalList.Add(item);
            }

            if (Filters.FirstOrDefault(x => x.FilterNumber == FilterNumber.Three) != null)
            {
                var foundfilters = Filters.Where(x => x.FilterNumber == FilterNumber.Three);
                List<DataGridViewModelItem> intermediatelist = new List<DataGridViewModelItem>();
                foreach (var foundfilter in foundfilters)
                {
                    foreach (DataGridViewModelItem item in RunSearch(finalList, foundfilter.Value, "Col3"))
                        intermediatelist.Add(item);
                }
                finalList.Clear();
                foreach (DataGridViewModelItem item in intermediatelist)
                    finalList.Add(item);
            }

            if (finalList.Count == 0 && Filters.Count == 0)
            {
                foreach (DataGridViewModelItem item in Items)
                    finalList.Add(item);
            }
            else if (finalList.Count == Items.Count && Filters.Count > 0)
                finalList.Clear();

            Refresh(finalList);

            bSearching = false;
        }

        private void CheckFilterDisplay()
        {
            filterLayout.Children.Clear();
            foreach (var filter in Filters)
            {
                DataGridFilterView filterview = new DataGridFilterView(filter.DisplayValue, filter.FilterType, filter.ColNumber);
                filterview.OnFilterClosed += Filterview_OnFilterClosed;
                filterLayout.Children.Add(filterview);
            }
        }

        private void Filterview_OnFilterClosed(string value, FilterType type, string colnumber)
        {
            List<DataGridFilter> toRemove = new List<DataGridFilter>();
            foreach (var child in filterLayout.Children)
            {
                if (child.GetType() == typeof(DataGridFilterView))
                {
                    if ((child as DataGridFilterView).Value == value && (child as DataGridFilterView).FilterType == type)
                    {
                        var filter = Filters.FirstOrDefault(x => x.DisplayValue == value && x.FilterType == type);
                        if (filter != null)
                            toRemove.Add(filter);
                    }

                }
            }
            if (toRemove.First().FilterType == FilterType.Typed)
            {
                foreach (var child in headerGrid.Children)
                {
                    if (child.GetType() == typeof(DataGridSearchEntry))
                    {
                        if ((child as DataGridSearchEntry).ColumnNumber == int.Parse(colnumber.Substring(3, 1)))
                            (child as DataGridSearchEntry).Text = "";
                    }
                }
            }
            Filters.Remove(toRemove.First());
        }

        private void Header_OnDataGridHeaderTapped(int columnnumber, SearchUtils.SortDirection sortdirection)
        {
            var intermediatelist = new List<DataGridViewModelItem>();
            foreach (var property in info)
            {
                if (property.Name == "Col" + columnnumber)
                {
                    foreach (var item in SearchUtils.OrderByPropertyName(CurrentItems, "Col" + columnnumber, sortdirection))
                    {
                        intermediatelist.Add(item);
                    }
                    Refresh(intermediatelist);
                }
            }
        }

        private void Header_OnDataGridHeaderFilterTapped(int columnnumber, string columnname)
        {
            List<string> options = FilterOptions["Col" + columnnumber];
            List<DataGridFilter> filters = new List<DataGridFilter>();
            var selectedFilters = Filters.Where(x => x.FilterType == FilterType.Selected && x.ColNumber == "Col" + columnnumber);
            foreach (var list in selectedFilters)
            {
                filters.Add(list);
            }
            MultiSelectPage filterpage = new MultiSelectPage(options, filters, columnnumber, columnname);
            filterpage.OnPageSaved += FilterPage_OnPageSaved;
            Navigation.PushAsync(filterpage);
        }

        private void FilterPage_OnPageSaved(IEnumerable<MultiSelectPageViewItem> items, int columnnumber, string columnname)
        {
            var intermediateList = new List<DataGridFilter>();
            var list = Filters.Where(x => x.ColNumber == "Col" + columnnumber && x.FilterType == FilterType.Selected);
            foreach (var item in list)
            {
                intermediateList.Add(item);
            }
            foreach (var filter in intermediateList)
                Filters.Remove(filter);

            foreach (var item in items)
                Filters.Add(new DataGridFilter(columnname, "Col" + columnnumber, item.Value, FindNumber(columnnumber), FilterType.Selected));

            var newlist = Filters.Where(x => x.ColNumber == "Col" + columnnumber);
        }
        #endregion

        #region Utils
        private IEnumerable<DataGridViewModelItem> RunSearch(IEnumerable<DataGridViewModelItem> list, string value, string propertyname)
        {
            var intermediatelist = new List<DataGridViewModelItem>();
            foreach (var property in info)
            {
                if (property.Name == propertyname)
                {
                    foreach (var item in list)
                    {
                        if (GetStringValue(property, item).Contains(value)
                            || GetStringValue(property, item).Contains(value.ToUpper())
                            || GetStringValue(property, item).Contains(value.ToLower())
                            || GetStringValue(property, item).Contains(SearchUtils.LowerCaseFirst(value))
                            || GetStringValue(property, item).Contains(SearchUtils.UpperCaseFirst(value))
                            || GetStringValue(property, item).Contains(SearchUtils.UpperCaseSecond(value))
                            )
                        {
                            if (!intermediatelist.Contains(item))
                                intermediatelist.Add(item);
                        }
                    }
                }
            }
            return intermediatelist;
        }
        private void ChangeHeaderColour(bool filterpresent, int colnumber)
        {
            foreach (var header in headerGrid.Children)
            {
                if (header.GetType() == typeof(DataGridHeaderRow))
                {
                    if ((header as DataGridHeaderRow).ColumnNumber == colnumber)
                        (header as DataGridHeaderRow).ChangeFilterColour(filterpresent);
                }
            }
        }
        private string GetStringValue(PropertyInfo property, object item)
        {
            if (property.PropertyType == typeof(string))
                return (string)property.GetValue(item);
            else
                return "";
        }

        private FilterNumber FindNumber(int columnnumber)
        {
            switch (columnnumber)
            {
                case 0:
                    return FilterNumber.Zero;
                case 1:
                    return FilterNumber.One;
                case 2:
                    return FilterNumber.Two;
                case 3:
                    return FilterNumber.Three;
                default:
                    return FilterNumber.Zero;
            }
        }
        #endregion
    }

    public enum FilterNumber
    {
        Zero,
        One,
        Two,
        Three
    }
    public enum FilterType
    {
        Typed,
        Selected
    }

    public class DataGridFilter
    {
        public string ColNumber { get; set; }
        public string ColName { get; set; }
        public string Value { get; set; }
        public FilterNumber FilterNumber { get; set; }
        public FilterType FilterType { get; set; }
        public string DisplayValue
        {
            get => ColName + " = " + Value;
        }
        public DataGridFilter(string colname, string colNumber, string value, FilterNumber filterNumber, FilterType filterType)
        {
            ColName = colname;
            ColNumber = colNumber;
            Value = value;
            FilterNumber = filterNumber;
            FilterType = filterType;
        }
    }
    public class DataGridViewModelItem
    {
        public Guid ID { get; set; }
        public Guid ImageID { get; set; }

        private bool isSelected;
        public bool IsSelected
        {
            get
            {
                return isSelected;
            }
            set
            {
                isSelected = value;
                Color = isSelected == true ? Color.FromHex("#91a3b0") /*Cadet Gray*/ : Color.Default;
            }
        }
        public Color Color { get; set; }

        public List<Tuple<string, string>> Data { get; set; }
        public string Col0 { get; set; }
        public string Col1 { get; set; }
        public string Col2 { get; set; }
        public string Col3 { get; set; }
        public Image Image { get; set; }
        public ImageSource Source
        {
            get
            {
                return Image == null ? null : Image.Source;
            }
        }
        public Dictionary<string, string> ImagePopupDetail { get; set; }
        public GridLength ColWidth0 { get; set; }
        public GridLength ColWidth1 { get; set; }
        public GridLength ColWidth2 { get; set; }
        public GridLength ColWidth3 { get; set; }
        public GridLength ImageColWidth { get; set; }
        public string PopUpDetail { get; set; }
        public DateTime SortDate { get; set; }
        public int SortInt { get; set; }
        public double SortDouble { get; set; }

        public DataGridViewModelItem(Guid id, List<Tuple<string, string>> data, Image image = null, Guid imageid = new Guid(), string popupdetail = "", Dictionary<string, string> imagePopupDetail = null)
        {
            ID = id;
            ImageID = imageid;
            Data = data;
            Image = image;
            Col0 = data.Count > 0 ? data[0].Item2 : "";
            Col1 = data.Count > 1 ? data[1].Item2 : "";
            Col2 = data.Count > 2 ? data[2].Item2 : "";
            Col3 = data.Count > 3 ? data[3].Item2 : "";
            ImageColWidth = image != null ? new GridLength(0.5, GridUnitType.Star) : new GridLength(0, GridUnitType.Auto);
            ColWidth0 = data.Count > 0 ? new GridLength(1, GridUnitType.Star) : new GridLength(0, GridUnitType.Auto);
            ColWidth1 = data.Count > 1 ? new GridLength(1, GridUnitType.Star) : new GridLength(0, GridUnitType.Auto);
            ColWidth2 = data.Count > 2 ? new GridLength(1, GridUnitType.Star) : new GridLength(0, GridUnitType.Auto);
            ColWidth3 = data.Count > 3 ? new GridLength(1, GridUnitType.Star) : new GridLength(0, GridUnitType.Auto);
            IsSelected = false;
            PopUpDetail = popupdetail;
            SortDate = DateTime.MinValue;
            SortInt = 0;
            ImagePopupDetail = imagePopupDetail != null? imagePopupDetail : new Dictionary<string, string>();
        }
    }
}