예제 #1
0
        /// <summary>
        /// Метод заполняющий контрол типа TreeView
        /// </summary>
        /// <param name="treeview">Контролс, в котором мы будем работать</param>
        /// <param name="DataSource">Коллекция или объект из которого мы будем строить дерево.
        /// Точнее даже это и есть само дерево, только не построенное в тривью</param>
        /// <param name="TreeLeafsInfo">Описание структуры дерева.
        /// Можно делать несколько веток парента, но только один уровень вложенности, паернт.парент не продуман пока</param>
        public static void FillTreeViewControl(TreeView treeview, object DataSource, TypedTreeViewDisplayMemberList TreeLeafsInfo)
        {
            TreeNode tr = new TreeNode();

            tr = CreateLeafs(tr, DataSource, TreeLeafsInfo);
            foreach (TreeNode item in tr.Nodes)
            {
                treeview.Nodes.Add(item);
            }
        }
        public TypedTreeViewDisplayMemberList Clone()
        {
            TypedTreeViewDisplayMemberList res = new TypedTreeViewDisplayMemberList();

            res                = new TypedTreeViewDisplayMemberList();
            res.Parent         = this.Parent;
            res.AssembliesList = this.AssembliesList;

            foreach (var item in this.Items)
            {
                res.Add(item.Clone());
            }

            return(res);
        }
        //--максимум 2 вложенности для всего!
        public static TypedTreeViewDisplayMemberList GenerateTreeDescriptionFromObject(object obj, object parent)
        {
            TypedTreeViewDisplayMemberList res = new TypedTreeViewDisplayMemberList();

#warning Надо сделать правильную проверку и работу с коллецкиями!!!

            /*Type tp = anvlib.Utilities.TypeSystem.GetElementType(obj.GetType());
             * if (tp != obj.GetType())
             *  obj = Activator.CreateInstance(tp);*/
            if (parent == null)
            {
                _nodescount = 0;
            }
            //--пока работает только по свойствам
            foreach (var item in obj.GetType().GetProperties())
            {
                bool standard = false;
                bool generic  = false;
                bool array    = false;

                //--Standard type
                if (TypesHelper.IsStandardType(item.PropertyType))
                {
                    if (parent == null)
                    {
                        res.Add(GetStandardTypeDescription(item.Name));
                    }
                    else
                    {
                        var tvdm = GetStandardTypeDescription(item.Name);
                        tvdm.DataSourceName = parent.ToString();
                        res.Add(tvdm);
                    }
                    standard = true;
                }

                #region Generic type
                if (item.PropertyType.IsGenericType)
                {
                    TypedTreeViewDisplayMember tvdm2 = GetStandardTypeDescription("");
                    tvdm2.DisplayСaption = item.Name;
                    TypedTreeViewDisplayMember tvdm = GetGenericChild(tvdm2, item, item.PropertyType);
                    res.Add(tvdm);
                    generic = true;
                }
                #endregion

                #region Array Type
                if (item.PropertyType.IsArray)
                {
                    Type eltype = item.PropertyType.GetElementType();
                    if (TypesHelper.IsStandardType(eltype))
                    {
                        var ntvdm = GetStandardTypeDescription("");
                        ntvdm.DisplayСaption      = item.Name;
                        ntvdm.ChildDisplayMembers = new TypedTreeViewDisplayMemberList();
                        var child = new TypedTreeViewDisplayMember("", item.Name);
                        child.NodeName = string.Format("Node{0}", _nodescount);
                        _nodescount++;
                        ntvdm.ChildDisplayMembers.Add(child);
                        res.Add(ntvdm);
                    }

                    if (eltype.IsGenericType)
                    {
                        TypedTreeViewDisplayMember tvdm2 = GetStandardTypeDescription("");
                        tvdm2.DisplayСaption = item.Name;
                        TypedTreeViewDisplayMember tvdm3 = new TypedTreeViewDisplayMember("", item.Name);
                        tvdm3.DisplayСaption = "Collection";
                        tvdm3.NodeName       = string.Format("Node{0}", _nodescount);
                        _nodescount++;
                        tvdm2.ChildDisplayMembers.Add(tvdm3);
                        TypedTreeViewDisplayMember tvdm = GetGenericChild(tvdm3, item, eltype);
                        res.Add(tvdm2);
                    }

                    array = true;
                }
                #endregion

                #region Class type
                if (!standard && !generic && !array)
                {
                    TypedTreeViewDisplayMember tvdm = GetStandardTypeDescription("");
                    tvdm.DisplayСaption = item.Name;
                    try
                    {
                        var obj_instance = item.GetValue(obj, null);
                        tvdm.ChildDisplayMembers = GenerateTreeDescriptionFromObject(obj_instance, item.Name);
                        res.Add(tvdm);
                    }
                    catch
                    {
                    }
                }
                #endregion
            }

            return(res);
        }
 public TypedTreeViewDisplayMember()
 {
     ChildDisplayMembers = new TypedTreeViewDisplayMemberList();
 }
 /// <summary>
 /// Базовый конструктор 2
 /// </summary>
 /// <param name="type">Тип класса паррента в котором будем искать нашего дисплей мембера</param>
 /// <param name="DispMember">Какое поля класса выводить на экран</param>
 /// <param name="dsource_name">Источник данных</param>
 /// <param name="childs">Описание дочерних веток дерева</param>
 public TypedTreeViewDisplayMember(string DispMember, string dsource_name, TypedTreeViewDisplayMemberList childs)
 {
     DisplayMember       = DispMember;
     DataSourceName      = dsource_name;
     ChildDisplayMembers = childs;
 }
 /// <summary>
 /// Базовый конструктор
 /// </summary>
 /// <param name="type">Тип класса паррента в котором будем искать нашего дисплей мембера</param>
 /// <param name="DispMember">Какое поля класса выводить на экран</param>
 /// <param name="dsource_name">Источник данных</param>
 public TypedTreeViewDisplayMember(string DispMember, string dsource_name)
 {
     DisplayMember       = DispMember;
     DataSourceName      = dsource_name;
     ChildDisplayMembers = new TypedTreeViewDisplayMemberList();
 }
예제 #7
0
        /// <summary>
        /// Добавочный метод к FillTreeViewControl, рекурсивно заполняющий TreeView
        /// </summary>
        /// <param name="tr">TreeView контролс</param>
        /// <param name="DataSource">Источник данных</param>
        /// <param name="TreeLeafsInfo">Описание дерева</param>
        /// <returns></returns>
        private static TreeNode CreateLeafs(TreeNode tr, object DataSource, TypedTreeViewDisplayMemberList TreeLeafsInfo)
        {
            //--Сделать разбор атрибутов типа DisplayName!!!
            foreach (var Leaf in TreeLeafsInfo)
            {
                //--Если датасорц - Коллекция. Не понимаю зачем я сделал проверку на строку...поизучай этот вопрос на досуге
                if ((DataSource is System.Collections.IEnumerable) && DataSource.GetType() != typeof(string))
                {
                    #region Цикл по коллекции
                    var collection = (DataSource as System.Collections.IEnumerable);
                    foreach (var item in collection)
                    {
                        bool   to_be_continue = false;
                        object text;

                        //--если строка, то идем к следующему элементу коллекции
                        if (item.GetType() == typeof(string))
                        {
                            to_be_continue = true;
                        }

                        #region Если есть только DataSource
                        if (item.GetType().GetProperty(Leaf.DisplayMember) == null && !string.IsNullOrEmpty(Leaf.DataSourceName) /* && !to_be_continue*/)
                        {
                            //--если это примитивное значение
                            if (!item.GetType().IsClass)
                            {
                                text = item;
                            }
                            else//--иначе это Класс
                            {
                                //--переделать на DisplayCaption
                                if (!string.IsNullOrEmpty(Leaf.DisplayСaption))
                                {
                                    text = Leaf.DisplayСaption;
                                }
                                else
                                {
                                    text = "";//--проверить нужен ли вообще этот участок кода!!!
                                    if (!(item is System.Collections.IEnumerable))
                                    {
                                        var val = item.GetType().GetProperty(Leaf.DataSourceName).GetValue(item, null);
                                        text = val.GetType().GetProperty(Leaf.DisplayMember).GetValue(val, null);
                                    }
                                }
                            }
                        }
                        else
                        {
                            if (string.IsNullOrEmpty(Leaf.DisplayMember))
                            {
                                to_be_continue = true;
                            }
                            //--если элемент не строка и DisplayMember != null
                            if (!to_be_continue)
                            {
                                if (item is System.Collections.IEnumerable)
                                {
                                    text = "";
                                    if (!string.IsNullOrEmpty(Leaf.DisplayСaption))
                                    {
                                        text = Leaf.DisplayСaption;
                                    }
                                }
                                else
                                {
                                    text = item.GetType().GetProperty(Leaf.DisplayMember).GetValue(item, null);
                                }
                            }
                            else
                            {
                                if (!string.IsNullOrEmpty(Leaf.DisplayСaption))
                                {
                                    text = Leaf.DisplayСaption;
                                }
                                else
                                {
                                    text = item;
                                }
                            }
                        }
                        #endregion

                        #region Если мы считали какоето значение в переменную text
                        if (text != null)
                        {
                            TreeNode mnode = new TreeNode(text.ToString());
                            if (!Leaf.WithoutTag)
                            {
                                mnode.Tag = item;
                            }
                            //--если индекс картинки мы берем из какого то поля в классе
                            if (string.IsNullOrEmpty(Leaf.ImageIndexByFieldName))
                            {
                                mnode.ImageIndex         = Leaf.ImageIndex;
                                mnode.SelectedImageIndex = Leaf.SelectedImageIndex;
                                mnode.StateImageIndex    = Leaf.StateImageIndex;
                            }
                            else
                            {
                                object im_idx = null;
                                if (Leaf.ImageIndexByFieldName.IndexOf('.') == -1)
                                {
                                    im_idx = item.GetType().GetProperty(Leaf.ImageIndexByFieldName).GetValue(item, null);
                                }
                                else
                                {
                                    im_idx = anvlib.Utilities.ObjectInspector.GetObjectPropertyValueRecursive(item, Leaf.ImageIndexByFieldName);
                                }
                                if (im_idx != null && im_idx.GetType() == typeof(int))
                                {
                                    mnode.ImageIndex         = (int)im_idx;
                                    mnode.SelectedImageIndex = (int)im_idx;
                                    mnode.StateImageIndex    = (int)im_idx;
                                }
                            }
                            tr.Nodes.Add(mnode);

                            #region Если есть дочерние ветки
                            if (Leaf.ChildDisplayMembers != null)
                            {
                                foreach (var SubLeaf in Leaf.ChildDisplayMembers)
                                {
                                    if (SubLeaf.DataSourceName != null)
                                    {
                                        if (Leaf.DataSourceName != SubLeaf.DataSourceName || SubLeaf.IsRecusiveCollection)
                                        {
                                            //--переделать на DisplayCaption
                                            if (!string.IsNullOrEmpty(SubLeaf.DisplayMember) && !string.IsNullOrEmpty(SubLeaf.DisplayСaption))
                                            {
                                                TypedTreeViewDisplayMemberList tdml = new TypedTreeViewDisplayMemberList();
                                                tdml.Add(SubLeaf);
                                                CreateLeafs(mnode, item, tdml);
                                            }
                                            else
                                            {
                                                var innercol = item.GetType().GetProperty(SubLeaf.DataSourceName).GetValue(item, null);
                                                TypedTreeViewDisplayMemberList tdml = new TypedTreeViewDisplayMemberList();
                                                tdml.Add(SubLeaf);
                                                CreateLeafs(mnode, innercol, tdml);
                                            }
                                        }
                                        else
                                        {
                                            TypedTreeViewDisplayMemberList tdml = new TypedTreeViewDisplayMemberList();
                                            tdml.Add(SubLeaf);
                                            CreateLeafs(mnode, item, tdml);
                                        }
                                    }
                                    else
                                    {
                                        TypedTreeViewDisplayMemberList tdml = new TypedTreeViewDisplayMemberList();
                                        tdml.Add(SubLeaf);
                                        CreateLeafs(mnode, SubLeaf.DisplayMember, tdml);
                                    }
                                }
                            }
                            #endregion
                        }
                        #endregion
                    }
                    #endregion
                }
                else
                {
                    //--если DataSource = null, но является не коллекцией
                    if (DataSource != null)
                    {
                        object text;
                        if (!string.IsNullOrEmpty(Leaf.DisplayMember) && !string.IsNullOrEmpty(Leaf.DisplayСaption))
                        {
                            text = Leaf.DisplayMember.Remove(0, 7);
                        }
                        else
                        {
                            text = "";
                            if (!(DataSource is ValueType) && DataSource.GetType() != typeof(string))
                            {
                                if (!string.IsNullOrEmpty(Leaf.DisplayMember))
                                {
                                    text = DataSource.GetType().GetProperty(Leaf.DisplayMember).GetValue(DataSource, null);
                                }
                                else if (!string.IsNullOrEmpty(Leaf.DisplayСaption))
                                {
                                    text = Leaf.DisplayСaption;
                                }
                                else
                                {
                                    text = DataSource;
                                }
                            }
                        }
                        if (text != null)
                        {
                            TreeNode mnode = new TreeNode(text.ToString());
                            if (!Leaf.WithoutTag)
                            {
                                mnode.Tag = DataSource;
                            }
                            if (string.IsNullOrEmpty(Leaf.ImageIndexByFieldName))
                            {
                                mnode.ImageIndex         = Leaf.ImageIndex;
                                mnode.SelectedImageIndex = Leaf.SelectedImageIndex;
                                mnode.StateImageIndex    = Leaf.StateImageIndex;
                            }
                            else
                            {
                                var im_idx = DataSource.GetType().GetProperty(Leaf.ImageIndexByFieldName).GetValue(DataSource, null);
                                if (im_idx != null && im_idx.GetType() == typeof(int))
                                {
                                    mnode.ImageIndex         = (int)im_idx;
                                    mnode.SelectedImageIndex = (int)im_idx;
                                    mnode.StateImageIndex    = (int)im_idx;
                                }
                            }

                            tr.Nodes.Add(mnode);
                            if (Leaf.ChildDisplayMembers != null)
                            {
                                foreach (var SubLeaf in Leaf.ChildDisplayMembers)
                                {
                                    if (DataSource.GetType() != typeof(string))
                                    {
                                        var innercol = DataSource.GetType().GetProperty(SubLeaf.DataSourceName).GetValue(DataSource, null);
                                        TypedTreeViewDisplayMemberList tdml = new TypedTreeViewDisplayMemberList();
                                        tdml.Add(SubLeaf);
                                        CreateLeafs(mnode, innercol, tdml);
                                    }
                                    else
                                    {
                                        TypedTreeViewDisplayMemberList tdml = new TypedTreeViewDisplayMemberList();
                                        tdml.Add(SubLeaf);
                                        CreateLeafs(mnode, SubLeaf.DataSourceName, tdml);
                                    }
                                }
                            }
                        }
                    }
                }
            }

            return(tr);
        }