ListViewHelper

using System.Collections.Generic;
using System.Data;
using System.Reflection;


namespace System.Windows.Forms {
    public class ListViewHelper {
        public event ListViewSortEvent ItemSorted;
        public event EventHandler AfterItemsSorted;

        readonly ListView _listView;
        readonly ListView listView1;
        Dictionary<ColumnHeader,SortOrder> _sortedColumns = new Dictionary<ColumnHeader,SortOrder>();

        public int RemoveSelectedListViewItems() {
            List<ListViewItem> selectedItems = GetSelectedListViewItems();
            foreach(ListViewItem li in selectedItems)
                listView1.Items.Remove(li);
            return selectedItems.Count;
        }
        public List<ListViewItem> GetSelectedListViewItems() {
            List<ListViewItem> list = new List<ListViewItem>();
            foreach(ListViewItem li in listView1.SelectedItems)
                list.Add(li);
            return list;
        }
        public T GetSelectedListViewItemTag<T>() {
            ListViewItem li = GetSelectedListViewItem();
            if(li == null)
                return default(T);
            return (T)li.Tag;
        }


        public ListViewItem GetSelectedListViewItem() {
            return GetSelectedListViewItem(false);
        }
        public ListViewItem GetSelectedListViewItem(bool createIfNotFound) {
            if(listView1.SelectedItems.Count == 0) {
                if(!createIfNotFound)
                    return null;
                return new ListViewItem();
            }
            return listView1.SelectedItems[0];
        }


        public ListViewItem[] AddListViewItems(DataTable table) {
            List<ListViewItem> list = new List<ListViewItem>();
            for(int i = 0;i < table.Rows.Count;i++)
                list.Add(AddListViewItem(table.Rows[i]));
            return list.ToArray();
        }
        public ListViewItem[] AddListViewItems(object[][] data) {
            List<ListViewItem> list = new List<ListViewItem>();
            for(int i = 0;i < data.Length;i++)
                list.Add(AddListViewItem(data[i]));
            return list.ToArray();
        }
        public ListViewItem AddListViewItem(DataRow row) {
            List<string> tableColNames = new List<string>();
            DataTable table = row.Table;

            if(table.Rows.Count == listView1.Columns.Count)
                return AddListViewItem(row.ItemArray);

            for(int i = 0;i < table.Columns.Count;i++) {
                tableColNames.Add(table.Columns[i].ToString());
            }
            return AddListViewItem(row.ItemArray,tableColNames.ToArray());
        }

        public ListViewItem AddListViewItem(object[] data,string[] columnNames) {
            ListView.ColumnHeaderCollection lvcolumns = listView1.Columns;
            if(lvcolumns.Count != columnNames.Length)
                lvcolumns.Clear();
            foreach(string colName in columnNames)
                lvcolumns.Add(colName,colName);

            List<string> dataAsString = new List<string>(data.Length);
            if(data.Length != lvcolumns.Count) {
                for(int i = 0;i < lvcolumns.Count;i++) {
                    object fldData = data[i];
                    if(fldData == null)
                        fldData = "";
                    else if(fldData == DBNull.Value)
                        fldData = "";
                    dataAsString.Add(fldData.ToString());
                }
                return AddListViewItem(dataAsString.ToArray());
            }
            else
                return AddListViewItem(data);
        }
        public ListViewItem AddListViewItem(string text) {
            return AddListViewItem(new string[] { text });
        }

        public ListViewItem AddListViewItem(object obj) {
            if(ListView.Columns.Count == 0)
                CreateColumnHeaders(obj.GetType());

            Dictionary<string,string> properties = GetProperties(obj);
            if(properties.Count == 0)
                return null;
            ListViewItem li = new ListViewItem();

            for(int i = 0;i < ListView.Columns.Count;i++) {
                ColumnHeader colHeader = ListView.Columns[i];

                if(!properties.ContainsKey(colHeader.Name))
                    continue;
                if(i == 0)
                    li.Text = properties[colHeader.Name];
                else
                    li.SubItems.Add(properties[colHeader.Name]);
            }
            //foreach (string key in properties.Keys)
            //{
            //    string objPropVal = properties[key];

            //}
            //ListViewItem li = new ListViewItem(new StringList().ToArray());
            //StringList list = new StringList(properties.Keys);
            li.Tag = obj;
            ListView.Items.Add(li);
            return li;
        }
        public ListViewItem AddListViewItem(object[] fields) {
            List<string> dataAsString = new List<string>(fields.Length);
            for(int i = 0;i < ListView.Columns.Count;i++) {
                object fldData = fields[i];
                if(fldData == null)
                    fldData = "";
                else if(fldData == DBNull.Value)
                    fldData = "";
                dataAsString.Add(fldData.ToString());
            }
            return AddListViewItem(dataAsString.ToArray());
        }
        public ListViewItem AddListViewItem(string[] fields) {
            ListViewItem li = new ListViewItem(fields);
            li.EnsureVisible();
            listView1.Items.Add(li);
            return li;
        }
        //public ColumnHeader[] GetColumnHeaders(Type t, params string[] includeOnlyColumns)
        //{
        //    List<ColumnHeader> list = new List<ColumnHeader>();
        //    Dictionary<string, string> properties = GetProperties(t);

        //    if (includeOnlyColumns.Length == 0)
        //    {
        //        foreach (string propName in properties.Keys)
        //        {
        //            int propIndex = properties[propName];
        //            ColumnHeader col = new ColumnHeader();
        //            col.Text = propName;
        //            col.Name = propName;
        //            list.Insert(propIndex, col);
        //        }
        //        return list.ToArray();
        //    }
        //    foreach (string propName in properties.Keys)
        //    {
        //        for (int j = 0; j < includeOnlyColumns.Length; j++)
        //        {
        //            if(propName == includeOnlyColumns[j])
        //            {
        //                int propIndex = properties[propName];
        //                ColumnHeader col = new ColumnHeader();
        //                col.Text = propName;
        //                col.Name = propName;
        //                list.Insert(propIndex, col);
        //            }
        //        }
        //    }
        //    return list.ToArray();
        //}

        private static Dictionary<string,string> GetProperties(object obj) {
            Type t = obj.GetType();
            Dictionary<string,string> properties = new Dictionary<string,string>();
            PropertyInfo[] propInfos = t.GetProperties();
            for(int i = 0;i < propInfos.Length;i++) {
                object ret = propInfos[i].GetValue(obj,null);
                if(ret == null)
                    ret = "";
                properties.Add(propInfos[i].Name,ret.ToString());
            }
            return properties;
        }
        public ColumnHeader[] CreateColumnHeaders(Type t) {
            return CreateColumnHeaders(t.GetType(),null);
        }
        public ColumnHeader[] CreateColumnHeaders(Type t,params string[] includeOnlyColumns) {
            this.ListView.Columns.Clear();
            List<ColumnHeader> list = new List<ColumnHeader>();
            PropertyInfo[] properties = t.GetProperties();
            if(includeOnlyColumns == null)
                includeOnlyColumns = new string[] { };

            if(includeOnlyColumns.Length > 0) {
                foreach(string include in includeOnlyColumns) {
                    for(int i = 0;i < properties.Length;i++) {
                        PropertyInfo prop = properties[i];
                        if(!prop.CanRead)
                            continue;
                        if(!include.Equals(prop.Name))
                            continue;
                        ColumnHeader col = new ColumnHeader();
                        col.Text = prop.Name;
                        col.Name = prop.Name;
                        list.Add(col);
                        ListView.Columns.Add(col);
                    }
                }
            }
            else {
                for(int i = 0;i < properties.Length;i++) {
                    PropertyInfo prop = properties[i];
                    if(!prop.CanRead)
                        continue;
                    ColumnHeader col = new ColumnHeader();
                    col.Text = prop.Name;
                    col.Name = prop.Name;
                    list.Add(col);
                    ListView.Columns.Add(col);
                }
                //foreach (ColumnHeader co in list)
                //    for (int i = 0; i < includeOnlyColumns.Length; i++)
                //        if (co.Text == includeOnlyColumns[i])
                //            ListView.Columns.Insert(ListView.Columns.Count, co);
            }
            return list.ToArray();
        }
        //private bool DoColumnHeadersMatch(PropertyInfo[] infos, string[] includeOnlyColumns)
        //{
        //    if (includeOnlyColumns != null)
        //        if (includeOnlyColumns.Length > 0)
        //            return DoColumnHeadersMatch(includeOnlyColumns);

        //    List<string> list = new List<string>();
        //    foreach (PropertyInfo p in infos)
        //        list.Add(p.Name);
        //    return DoColumnHeadersMatch(list.ToArray());
        //}
        //private bool DoColumnHeadersMatch(string[] headerText)
        //{
        //    foreach (ColumnHeader col in ListView.Columns)
        //    {
        //        bool foundIt = false;
        //        foreach (string s in headerText)
        //        {
        //            if (s == col.Text)
        //            {
        //                foundIt = true;
        //                break;
        //            }
        //        }
        //        if (!foundIt)
        //            return false;
        //    }
        //    return false;
        //}


        public ListView ListView {
            get { return _listView; }

        }

        public ListViewHelper(ListView p_ListView) {
            _listView = p_ListView;
            listView1 = p_ListView;

            _listView.ColumnClick += new ColumnClickEventHandler(ListView_ColumnClick);
        }

        private void ListView_ColumnClick(object sender,ColumnClickEventArgs e) {
            ColumnHeader column = ListView.Columns[e.Column];
            SortByColumn(column);
        }
        public void SortByColumn(int columnIndex) {
            SortByColumn(ListView.Columns[columnIndex]);
        }
        public void SortByColumn(int columnIndex,SortOrder order) {
            SortByColumn(ListView.Columns[columnIndex],order);
        }
        public void SortByColumn(ColumnHeader column) {
            SortByColumn(column,SortOrder.None);
        }

        public SortOrder GetSortOrder(ColumnHeader column,SortOrder order = SortOrder.None) {

            if(!_sortedColumns.ContainsKey(column))
                _sortedColumns.Add(column,SortOrder.Ascending);

            if(order == SortOrder.None) {
                if(_sortedColumns[column] == SortOrder.Ascending)
                    _sortedColumns[column] = SortOrder.Descending;
                else
                    _sortedColumns[column] = SortOrder.Ascending;
            }
            else
                _sortedColumns[column] = order;

            return _sortedColumns[column];
        }

        public void SortByColumn(ColumnHeader column,SortOrder order) {
            if(ListView.VirtualMode) {
                return;
            }

            ListView.Sort();

            List<ListViewItem> items = new List<ListViewItem>();
            Dictionary<ListViewItem,ListViewGroup> groups = new Dictionary<ListViewItem,ListViewGroup>();
            foreach(ListViewItem li in ListView.Items) {
                items.Add(li);
                groups.Add(li,li.Group);
            }

            ListView.Items.Clear();

            if(!_sortedColumns.ContainsKey(column))
                _sortedColumns.Add(column,SortOrder.Ascending);

            if(order == SortOrder.None) {
                if(_sortedColumns[column] == SortOrder.Ascending)
                    _sortedColumns[column] = SortOrder.Descending;
                else
                    _sortedColumns[column] = SortOrder.Ascending;
            }
            else
                _sortedColumns[column] = order;


            ListViewItemSort liSort = new ListViewItemSort(column.Index,_sortedColumns[column]);
            liSort.ItemSorted += new ListViewSortEvent(liSort_ItemSorted);
            items.Sort(liSort);
            ListView.Sorting = SortOrder.None;

            foreach(ListViewItem li in items)
                li.Group = groups[li];

            ListView.Items.AddRange(items.ToArray());

            if(AfterItemsSorted != null)
                AfterItemsSorted(this,new EventArgs());

        }

        void liSort_ItemSorted(object sender,ListViewSortEventArgs e) {
            if(ItemSorted != null)
                ItemSorted(this,e);
        }
        public class ListViewItemSort:Comparer<ListViewItem> {
            private int m_ColumnToSortBy;
            private Type m_ColumnDataType;
            private SortOrder m_SortOrder;

            public event ListViewSortEvent ItemSorted;

            public Type ColumnDataType {
                get { return m_ColumnDataType; }
                set { m_ColumnDataType = value; }
            }


            public SortOrder SortOrder {
                get { return m_SortOrder; }
                set { m_SortOrder = value; }
            }

            public int ColumnToSortBy {
                get { return m_ColumnToSortBy; }
                set { m_ColumnToSortBy = value; }
            }
            public ListViewItemSort() { }
            public ListViewItemSort(int p_ColumnToSortBy) : this(p_ColumnToSortBy,SortOrder.Ascending) { }
            public ListViewItemSort(int p_ColumnToSortBy,SortOrder order)
                : this(p_ColumnToSortBy,order,null) {
            }
            public ListViewItemSort(int p_ColumnToSortBy,SortOrder order,Type p_ColumnDataType) {
                m_SortOrder = order;
                m_ColumnToSortBy = p_ColumnToSortBy;
                m_ColumnDataType = p_ColumnDataType;
            }
            private string GetValueForItem(ListViewItem li) {
                if(ItemSorted != null) {
                    ListViewSortEventArgs args = new ListViewSortEventArgs(li,li.SubItems[m_ColumnToSortBy].Text,m_ColumnToSortBy);
                    ItemSorted(this,args);
                    if(args.DataToSort == null)
                        return li.Text;
                    return args.DataToSort.ToString();
                }
                return li.SubItems[m_ColumnToSortBy].Text;
            }
            public override int Compare(ListViewItem x,ListViewItem y) {
                //Dictionary<ListViewItem,List<ColumnHeader>>

                string Xvalue = GetValueForItem(x);
                string Yvalue = GetValueForItem(y);

                int int_x = 0,int_y = 0;
                DateTime dt_x = DateTime.MinValue,dt_y = DateTime.MinValue;

                if(int.TryParse(Xvalue,out int_x) && int.TryParse(Yvalue,out int_y)) {
                    if(SortOrder == SortOrder.Ascending)
                        return Comparer<int>.Default.Compare(int_x,int_y);
                    return Comparer<int>.Default.Compare(int_y,int_x);
                }
                else if(DateTime.TryParse(Xvalue,out dt_x) && DateTime.TryParse(Yvalue,out dt_y)) {
                    if(SortOrder == SortOrder.Ascending)
                        return Comparer<DateTime>.Default.Compare(dt_x,dt_y);
                    return Comparer<DateTime>.Default.Compare(dt_y,dt_x);
                }
                else {
                    if(SortOrder == SortOrder.Ascending)
                        return StringComparer.Create(System.Globalization.CultureInfo.CurrentCulture,false).Compare(Xvalue,Yvalue);
                    return StringComparer.Create(System.Globalization.CultureInfo.CurrentCulture,false).Compare(Yvalue,Xvalue);
                }
            }
        }
    }
    public delegate void ListViewSortEvent(object sender,ListViewSortEventArgs e);
    public class ListViewSortEventArgs:EventArgs {
        private ListViewItem m_Item;
        private object m_DataToSort;
        private int m_ColumnToSortBy;


        public ListViewItem Item {
            get { return m_Item; }
            set { m_Item = value; }
        }

        public object DataToSort {
            get { return m_DataToSort; }
            set { m_DataToSort = value; }
        }

        public int ColumnToSortBy {
            get { return m_ColumnToSortBy; }
            set { m_ColumnToSortBy = value; }
        }

        public ListViewSortEventArgs() {

        }

        public ListViewSortEventArgs(ListViewItem p_Item,
            object p_DataToSort,
            int p_ColumnToSortBy) {
            this.m_Item = p_Item;
            this.m_DataToSort = p_DataToSort;
            this.m_ColumnToSortBy = p_ColumnToSortBy;

        }
    }

}