PropertyGrid控件 分类（Category）及属性（Property）排序

最新推荐文章于 2024-07-16 13:41:39 发布
最新推荐文章于 2024-07-16 13:41:39 发布
阅读量942 收藏 3
点赞数 1
文章标签： ui
原文链接：https://yq.aliyun.com/articles/54885
版权

最近在做表单设计器，设计器上的控件都是我们自己封装的，但每个属性类别里的属性是按照属性的拼音排序的，现在想按照PropertyIndex标识进行排序（PropertyIndex的后三位是用来标识编辑器的）。

具体实现如下：

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.ComponentModel;
using HC.Test.ComponentModel;
using HC.Test.Common;
using System.Data;
using HC.Test.Common.ComponentModel;
using System.Xml.Serialization;
using System.Windows.Forms;
using HC.Test.Forms.ControlConfig;
using System.Collections;

namespace HC.Test.Designer.UI
{
    public class ControlEditorTypeDescriptionProvider : TypeDescriptionProvider
    {
        protected TypeDescriptionProvider _baseProvider;
        private PropertyDescriptorCollection _propCache;
        protected Dictionary<Type, Type> dictEdtor;
        /// <summary>
        ///  属性Editor字典
        ///  Key:Attribute Value:Editor
        /// </summary>
        public Dictionary<Type, Type> EdtorDictionary
        {
            get
            {
                return dictEdtor;
            }
        }
        public ControlEditorTypeDescriptionProvider()
            : base()
        {
            dictEdtor = new Dictionary<Type, Type>();
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="t">要修改属性的基类</param>
        public ControlEditorTypeDescriptionProvider(Type t)
            : this()
        {
            _baseProvider = TypeDescriptor.GetProvider(t);
        }


        public override ICustomTypeDescriptor GetTypeDescriptor(Type objectType, object instance)
        {
            PropertiesTypeDescriptor typeDes = new PropertiesTypeDescriptor(_baseProvider.GetTypeDescriptor(objectType, instance), this, objectType);
            return typeDes;
        }


    }
    /// <summary>
    /// 属性集合的描述
    /// </summary>
    public class PropertiesTypeDescriptor : CustomTypeDescriptor
    {
        private Type objType;
        private DataTable dtConfig = new DataTable();
        private ControlEditorTypeDescriptionProvider provider;
        public PropertiesTypeDescriptor(ICustomTypeDescriptor descriptor, ControlEditorTypeDescriptionProvider provider, Type objType)
            : base(descriptor)
        {
            if (provider == null)
            {
                throw new ArgumentNullException("provider");
            }
            if (descriptor == null)
            {
                throw new ArgumentNullException("descriptor");
            }
            if (objType == null)
            {
                throw new ArgumentNullException("objectType");
            }

            this.objType = objType;
            this.provider = provider;
        }
        /// <summary>
        /// 获取属性列表
        /// </summary>
        /// <param name="attributes"></param>
        /// <returns></returns>
        public override PropertyDescriptorCollection GetProperties(Attribute[] attributes)
        {
            try
            {
                string nowIndexCode = "";
                Type editor;
                Type editorControl;
                Attribute abEvent;
                EventPropertyDescriptor des;
                bool showPageSize = true;

                //从dll中读取配置
                Dictionary<string, ControlEditorType> dictConfig = PubFunc.GetPropertyEditor();
                ArrayList orderedProperties = new ArrayList();
                foreach (PropertyDescriptor prop in base.GetProperties(attributes))
                {                   
                    #region  控件、表单部分属性屏蔽
                    //屏蔽所有控件数据Category 数据 属性
                    if (((System.ComponentModel.MemberDescriptor)(prop)).Category == "数据" || ((System.ComponentModel.MemberDescriptor)(prop)).Category == "Data")
                    {
                        continue;
                    }

                    //屏蔽所有控件数据Category 杂项 属性
                    if (((System.ComponentModel.MemberDescriptor)(prop)).Category == "杂项" || ((System.ComponentModel.MemberDescriptor)(prop)).Category == "Misc")
                    {
                        continue;
                    }

                    #endregion

                    #region 屏蔽不需要显示的属性
                    switch (((System.ComponentModel.MemberDescriptor)(prop)).Name)
                    {
                        case "DisplayStyleEnum":
                            CommonHelpDisplayStyleEnum displayType = (CommonHelpDisplayStyleEnum)prop.GetValue(this);
                            if (displayType == CommonHelpDisplayStyleEnum.TreeStyle)
                            {
                                showPageSize = false;
                            }
                            break;
                        case "PageSize":
                            if (!showPageSize)
                            {
                                continue;
                            }
                            break;
                    }
                    #endregion

                    abEvent = prop.Attributes[typeof(PropertyIndexAttribute)];
                    if (abEvent != null && abEvent is PropertyIndexAttribute)
                    {
                        nowIndexCode = ((PropertyIndexAttribute)abEvent).IndexCode;

                        #region 事件编辑器处理
                       
                        if (nowIndexCode.Length > 6)
                        {
                            //最后三位000标识 不带编辑器
                            if (nowIndexCode.Substring(6, 3) == "000")
                            {
                                orderedProperties.Add(new PropertyOrderPair(prop.DisplayName, int.Parse(nowIndexCode), prop));
                                continue;
                            }
                            foreach (var cet in dictConfig)
                            {
                                if (cet.Key == nowIndexCode.Substring(6, 3))
                                {
                                    //根据配置文件的序列号，获取出全名HC.Test.Designer.UI.EventActionEditorControl，放入下面的函数中                          
                                    editorControl = ReflectionActivator.GetType("HC.Test.Designer.UI", cet.Value.EditorName);
                                    if (editorControl == null)
                                    {
                                        orderedProperties.Add(new PropertyOrderPair(prop.DisplayName, int.Parse(nowIndexCode), prop));
                                        break;
                                    }
                                    if (cet.Value.EditorType == "CommonTypeDropDownEditor")
                                    {
                                        editor = ReflectionActivator.GetGenericType("HC.Test.Common.Design", "HC.Test.Common.Design.GenericDropDownControlEditor`1", new Type[] { editorControl });
                                    }
                                    else
                                    {
                                        editor = ReflectionActivator.GetGenericType("HC.Test.Common.Design", "HC.Test.Common.Design.ModalFormEditor`1", new Type[] { editorControl });
                                    }
                                    des = new EventPropertyDescriptor(prop, editor);
                                    orderedProperties.Add(new PropertyOrderPair(prop.DisplayName, int.Parse(nowIndexCode), des));
                                    break;
                                }
                            }
                        }
                        #endregion

                        else
                        {
                            orderedProperties.Add(new PropertyOrderPair(prop.DisplayName, 0, prop));
                            continue;
                        }
                    }
                    else
                    {
                        orderedProperties.Add(new PropertyOrderPair(prop.DisplayName, 0, prop));
                    }
                }
                //属性集合按照PropertyIndexAttribute及DisplayName排序
                orderedProperties.Sort();
                PropertyDescriptorCollection propsTemp = new PropertyDescriptorCollection(null);
                foreach (PropertyOrderPair pop in orderedProperties)
                {
                    propsTemp.Add(pop.Property);
                }
                return propsTemp;

                //ArrayList propertyNames = new ArrayList();
                //foreach (PropertyOrderPair pop in orderedProperties)
                //{
                //    propertyNames.Add(pop.Name);
                //}
                //return pdc.Sort((string[])propertyNames.ToArray(typeof(string)));
            }
            catch
            {
                throw;
            }
        }
    }
    /// <summary>
    /// 属性 描述（属性的属性）
    /// </summary>
    public class EventPropertyDescriptor : PropertyDescriptor
    {
        Type editor = null;
        PropertyDescriptor prop;
        public EventPropertyDescriptor(PropertyDescriptor descr, Type editor)
            : base(descr)
        {
            this.prop = descr;
            this.editor = editor;          
        }
        /// <summary>
        /// 获取Editor;
        /// </summary>
        /// <param name="editorBaseType"></param>
        /// <returns></returns>
        public override object GetEditor(Type editorBaseType)
        {
            object obj = base.GetEditor(editorBaseType);
            if (obj == null)
            {
                obj = ReflectionActivator.CreateInstace(editor);
            }
            return obj;
        }

        public override bool CanResetValue(object component)
        {
            return prop.CanResetValue(component);
        }

        public override Type ComponentType
        {
            get { return prop.ComponentType; }
        }

        public override object GetValue(object component)
        {
            return prop.GetValue(component);
        }

        public override bool IsReadOnly
        {
            get { return prop.IsReadOnly; }
        }

        public override Type PropertyType
        {
            get { return prop.PropertyType; }
        }
        public override void ResetValue(object component)
        {
            prop.ResetValue(component);
        }
        public override void SetValue(object component, object value)
        {
            prop.SetValue(component, value);
        }
        public override bool ShouldSerializeValue(object component)
        {
            return prop.ShouldSerializeValue(component);
        }
    }

}
PropertyIndexAttribute类： 

    /// <summary>
    /// 属性信息的顺序分类等信息
    /// 字段或者属性等 可序列化的信息上
    /// 现在是一共9位，最后3位用来标识编辑器 最后三位000 默认不会识别编辑器
    /// 中间三位用来属性排序
    /// </summary>
    [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
    public class PropertyIndexAttribute : Attribute
    {
        private string indexCode;
        /// <summary>
        /// 标识
        /// </summary>
        public string IndexCode
        {
            get
            {
                return indexCode;
            }
            set
            {
                indexCode = value;
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="indexCode"></param>
        public PropertyIndexAttribute(string indexCode)
        {
            this.indexCode = indexCode;
        }
    }
排序部分： 

  #region Helper Class - PropertyOrderPair
    public class PropertyOrderPair : IComparable
    {
        private int _order;
        private string _name;
        public string Name
        {
            get
            {
                return _name;
            }
        }

        private PropertyDescriptor _property;
        public PropertyDescriptor Property
        {
            get
            {
                return _property;
            }
        }

        public PropertyOrderPair(string name, int order, PropertyDescriptor property)
        {
            _order = order;
            _name = name;
            _property = property;
        }

        public int CompareTo(object obj)
        {
            //
            // Sort the pair objects by ordering by order value
            // Equal values get the same rank
            //
            int otherOrder = ((PropertyOrderPair)obj)._order;
            if (otherOrder == _order)
            {
                //
                // If order not specified, sort by name
                //
                string otherName = ((PropertyOrderPair)obj)._name;
                return string.Compare(_name, otherName);
            }
            else if (otherOrder > _order)
            {
                return -1;
            }
            return 1;
        }
    }
    #endregion

    #region Helper Class - PropertyOrderAttribute 未用
    //[AttributeUsage(AttributeTargets.Property)]
    //public class PropertyOrderAttribute : Attribute
    //{
    //    //
    //    // Simple attribute to allow the order of a property to be specified
    //    //
    //    private int _order;
    //    public PropertyOrderAttribute(int order)
    //    {
    //        _order = order;
    //    }

    //    public int Order
    //    {
    //        get
    //        {
    //            return _order;
    //        }
    //    }
    //}
    #endregion
设置PropertyGrid控件的属性：


用法：

为每个属性添加属性：[PropertyIndex("103001000")]

比如：

		[Category("掩码")]
        [Browsable(true)]
        [DisplayName("掩码类型")]
        //[Description("设置执行单击事件的快捷键")]
        [PropertyIndex("103001000")]
        public DevExpress.XtraEditors.Mask.MaskType MaskType
        {
            get
            {
                return this.BaseTextEdit.Properties.Mask.MaskType;
            }
            set
            {
                this.BaseTextEdit.Properties.Mask.MaskType = value;
            }
        }


        [Category("掩码")]
        [Browsable(true)]
        [DisplayName("忽略空白")]
        [Description("对于 Simple、Regular 和 RegEx 掩码类型，MaskProperties.IgnoreMaskBlank 属性是有效的。 如果此属性值设置为 true，那么空白编辑器会失去焦点。 如果编辑器的取值仅部分完成，那么焦点不能被移出此编辑器，直至最终用户输入了完整的取值或者通过清除编辑器框而清除了取值。 如果此属性值设置为 false，那么焦点不能移出此编辑器，直至完整输入取值。 ")]
        [PropertyIndex("103006000")]
        public bool IgnoreMaskBlank
        {
            get
            {
                return this.BaseTextEdit.Properties.Mask.IgnoreMaskBlank;
            }
            set
            {
                this.BaseTextEdit.Properties.Mask.IgnoreMaskBlank = value;
            }
        }

        [Category("掩码")]
        [Browsable(true)]
        [DisplayName("格式占位符")]
        [Description("对于 Simple、Regular 和 RegEx 掩码类型，使用由 MaskProperties.PlaceHolder 属性确定的特殊字符来呈现编辑框中的占位符。 可以使用该属性来改变默认的占位符 (“_”符)。 对于 RegEx 掩码类型，通过把 MaskProperties.ShowPlaceHolders 属性设置为 false，可以隐藏占位符。 ")]
        [PropertyIndex("103007000")]
        public char PlaceHolder
        {
            get
            {
                return this.BaseTextEdit.Properties.Mask.PlaceHolder;
            }
            set
            {
                this.BaseTextEdit.Properties.Mask.PlaceHolder = value;
            }
        }

        [Category("掩码")]
        [Browsable(true)]
        [DisplayName("错误提示音")]
        [Description("对于所有类型的掩码，Boolean 型的 MaskProperties.BeepOnError 属性都是可用的。 把此属性设置为 true，当最终用户试图键入一个无效字符串时允许响铃。 假定使用了 Numeric 类型的掩码。 在这种情况下，最终用户每次试图键入非数字字符时，编辑器都将发出一段提示声音。")]
        [PropertyIndex("103005000")]
        public bool BeepOnError
        {
            get
            {
                return this.BaseTextEdit.Properties.Mask.BeepOnError;
            }
            set
            {
                this.BaseTextEdit.Properties.Mask.BeepOnError = value;
            }
        }


        [Category("掩码")]
        [Browsable(true)]
        [DisplayName("自动填充")]
        [Description("对于 RegEx 掩码类型，可以启用自动完成功能。 在这种模式中，编辑器将尝试完成已经由最终用户部分输入的取值。")]
        [PropertyIndex("103004000")]
        public DevExpress.XtraEditors.Mask.AutoCompleteType AutoComplete
        {
            get
            {
                return this.BaseTextEdit.Properties.Mask.AutoComplete;
            }
            set
            {
                this.BaseTextEdit.Properties.Mask.AutoComplete = value;
            }
        }

        [Category("掩码")]
        [Browsable(true)]
        [DisplayName("保存格式字符串")]
        [Description("对于 Simple 和 Regular 掩码类型，可以指定是否总是把显示的掩码字符 (原义字符) 包括在编辑器的取值内。 换句话说，你可以控制那些字符是否出现在由 BaseEdit.EditValue 属性返回的取值中。 要使这些字符无法被访问，则必须把 MaskProperties.SaveLiteral 属性设置为 false。 在这种情况下，如果显示的取值是“(555)123-76-34”，那么由 BaseEdit.EditValue 属性返回的取值就是“5551237634”。 ")]
        [PropertyIndex("103008000")]
        public bool SaveLiteral
        {
            get
            {
                return this.BaseTextEdit.Properties.Mask.SaveLiteral;
            }
            set
            {
                this.BaseTextEdit.Properties.Mask.SaveLiteral = value;
            }
        }

        [Category("掩码")]
        [Browsable(true)]
        [DisplayName("掩码字符串")]
        [Description("掩码字符串标识了数据输入模板。 可以使用预定义的掩码字符串，或者构建自己的掩码表达式, 应该根据掩码类型来设置掩码字符串。")]
        [PropertyIndex("103002000")]
        public string EditMask
        {
            get
            {
                return this.BaseTextEdit.Properties.Mask.EditMask;
            }
            set
            {
                this.BaseTextEdit.Properties.Mask.EditMask = value;
            }
        }

        [Category("掩码")]
        [Browsable(true)]
        [DisplayName("显示格式占位符")]
        [Description("对于 Simple、Regular 和 RegEx 掩码类型，使用由 MaskProperties.PlaceHolder 属性确定的特殊字符来呈现编辑框中的占位符。 可以使用该属性来改变默认的占位符 (“_”符)。 对于 RegEx 掩码类型，通过把 MaskProperties.ShowPlaceHolders 属性设置为 false，可以隐藏占位符。 ")]
        [PropertyIndex("103003000")]
        public bool ShowPlaceHolders
        {
            get
            {
                return this.BaseTextEdit.Properties.Mask.ShowPlaceHolders;
            }
            set
            {
                this.BaseTextEdit.Properties.Mask.ShowPlaceHolders = value;
            }
        }
效果：


如果使用网络上的sort排序代码（感觉不对，于是没有采用）：

  //ArrayList propertyNames = new ArrayList();
                //foreach (PropertyOrderPair pop in orderedProperties)
                //{
                //    propertyNames.Add(pop.Name);
                //}
                //return pdc.Sort((string[])propertyNames.ToArray(typeof(string)));
效果如下：



本文参考：

PropertyGrid排序

Ordering Items in the Property Grid

PropertyGrid类别排序实现，可以参考：

点击打开链接 

具体实现如下：

属性控件PropertyGrid事件：

 #region  属性分组排序部分
        private void propertyGrid_SelectedObjectsChanged(object sender, EventArgs e)
        {
            propertyGrid.Tag = propertyGrid.PropertySort;
            propertyGrid.PropertySort = PropertySort.CategorizedAlphabetical;
            propertyGrid.Paint += new PaintEventHandler(propertyGrid_Paint);    
        }

        private void propertyGrid_Paint(object sender, PaintEventArgs e)
        {
            var categorysinfo = propertyGrid.SelectedObject.GetType().GetField("categorys", BindingFlags.NonPublic | BindingFlags.Instance);
            if (categorysinfo != null)
            {
                var categorys = categorysinfo.GetValue(propertyGrid.SelectedObject) as List<String>;
                propertyGrid.CollapseAllGridItems();
                GridItemCollection currentPropEntries = typeof(PropertyGrid).GetField("currentPropEntries", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(propertyGrid) as GridItemCollection;
                var newarray = currentPropEntries.Cast<GridItem>().OrderBy((t) => categorys.IndexOf(t.Label)).ToArray();
                currentPropEntries.GetType().GetField("entries", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(currentPropEntries, newarray);
                propertyGrid.ExpandAllGridItems();
                propertyGrid.PropertySort = (PropertySort)propertyGrid.Tag;
            }
            propertyGrid.Paint -= new PaintEventHandler(propertyGrid_Paint);
        }
由于我用的是：


所以在反射的时候，用的是：

GridItemCollection currentPropEntries = typeof(PropertyGrid).GetField("currentPropEntries", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(propertyGrid) as GridItemCollection;
而非参考文章中的： 

GridItemCollection currentPropEntries = propertyGrid1.GetType().GetField("currentPropEntries", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(propertyGrid1) as GridItemCollection;


控件中的使用：



效果：


完成！


weixin_33966365
关注
C#propertygrid
04-02
使用C#自定义propertygrid，能够自定义属性和显示顺序
C# PropertyGrid控件的分成 多层 折叠 和绑定自定义控件
08-01
在.NET Framework中，C#的PropertyGrid控件是一个强大的工具，用于显示和编辑对象的属性。这个控件能够自动生成用户界面，使开发者能够快速创建属性编辑器，类似于Visual Studio中的对象浏览器。在这个主题中，我们...
PropertyGrid排序
weixin_34067980的博客
02-08 263
这个工具类可以把每个属性类别里的属性排序，但是不能把属性类别排序。为属性类添加属性：[TypeConverter(typeof(PropertySorter))]为每个属性添加属性：[PropertyOrder(10)]private void Form_Load(object sender, EventArgs e){    propertyGrid1.SelectedObject = new ...
PropertyGrid类别排序
weixin_33672400的博客
02-20 523
前面写过一篇博客：PropertyGrid排序http://greatverve.cnblogs.com/archive/2012/02/08/propergrid-order.html这里没有解决类别排序的问题，所以到csdn提问了，结果半天没人回复，就忘了。今天偶尔看到有人回复了，并且解决了类别排序的问题，真是太感谢了。现分享给大家。PropertySorter 类请查看上一篇博客。using...
C# Winform PropertyGrid中文排序
最新发布
精通搬砖，资深技术砖家，在软件开发，人工智能，设备开发等领域都有研究。商业合作&交流学习可私信联系。
07-16 850
C# Winform Property有两种方式，一使用TAB制表符，二定制类按照自定义中文排序规则排序。
C# Winform之propertyGrid控件分组后排序功能
精通搬砖，资深技术砖家，在软件开发，人工智能，设备开发等领域都有研究。商业合作&交流学习可私信联系。
07-11 730
控件中，你可以通过多种方式对属性进行排序，包括按类别（Category）排序以及按属性名称排序。如果你想要在类别内部对属性进行排序，需要创建一个自定义的。方法中，你可以读取这个装饰器并按其顺序对属性进行排序。类，并在其中实现排序逻辑。来强制属性按字母顺序排序，或者设置为。方法，然后返回一个根据你的需求排序的。属性装饰器对属性进行分组和排序。来按照类别排序（这是默认行为）。，然后对其进行排序，再重新应用到。下面是一个使用自定义属性装饰器和。方法来控制属性的显示顺序。你还可以在代码中手动获取。
HandyControl的属性编辑器如何绑定自定义控件，并集成到自定义编辑器
06-06
HandyControl是一个强大的UI库，为WPF开发者提供了丰富的预设控件和样式，而PropertyGrid控件则常用于展示和编辑对象的属性。 首先，我们需要理解`PropertyGrid`的基本概念。`PropertyGrid`通常用于显示对象的所有...
propertyGrid动态加载自定义属性
08-24
在.NET框架中，`PropertyGrid`控件是一个强大的工具，用于显示和编辑对象的属性。它通常用于创建用户界面，使用户能够查看和修改对象的属性。本篇将深入探讨如何在C#中使用`PropertyGrid`动态加载自定义属性，以实现...
PropertyGrid控件使用教程
06-04
PropertyGrid控件支持自定义属性分类，通过使用`CategoryAttribute`特性，可以在控件中为属性分组，提高可读性。 4. **属性描述** 可以使用`DescriptionAttribute`特性为属性添加描述信息，当鼠标悬停在属性上时...
PropertyGrid控件实现多国语言
08-29
`PropertyGrid`控件实现多国语言切换，主要是通过处理`Category`、`DisplayName`和`Description`这三个关键属性来完成的。 `Category`属性用于将相关的属性分组，提供更好的视觉组织；`DisplayName`是属性在用户...
propertyGrid 属性处理演示demo
11-21
propertyGrid 属性处理演示demo 动态
如何让C#的PropertyGrid的Category按照类的定义顺序进行排序？
keepsilence55的博客
03-04 2359
如何让C#的PropertyGrid的Category按照类的定义顺序进行排序？
c# PropertyGrid 自定义属性排序
chulijun3107的博客
11-25 4588
PropertyGrid属性如果不自定义顺序的话，属性会按照字母顺序排序。实际中这并不是想要的结果。可以通过增加一个PropertyOrder的方法，自定义属性的属性。这样就可以根据自己的意愿进行排序了。我先上一个Winform版本的PropertyGrid。过几天再上一个WPF版本的PropertyGrid排序。Wpf版本的排序将采用开源控件库HandyControl作为基础。它可以带来更好的展示。话不多说，先看下排序前后的效果： 还是排序后的效果看着舒服。 工程如下： 源码非常的...
关于PropertyGrid控件的排序问题
weixin_30580943的博客
04-08 635
前些天，由于在项目中需要用到PropertyGrid这个控件，展现其所在控件的某些属性，由于有些控件的属性较多，不易浏览，而且PropertyGrid的排序默认的按照字母的顺序排列的，这样导致在在某些属性想要排在第一位非常不方便，于是我总结了网友们的一些思路，自己便解决呢！现在来说说解决思路： 1.首先为PropertyGrid添加SelectedObjectsChange...
ExtJS至propertyGrid 自动排序及设置editor
jwl_yifeng的专栏
10-18 2585
找了好久没有合适的例子，只能自己写一个，更多的可以参照api，例子在最后边，下面先说一下怎么解决自动排序问题。propertygrid自动排序是因为源码中有这句：store.store.sort('name', 'ASC'); 他是按名字英文字母排序的，我们只需要把里面的：if (me.sortableColumns) {             me.store.sort('name', '
Extjs中PropertyGrid默认排序问题
chenyiya的专栏
01-07 1240
PropertyGrid自作主张地一定要把所有的属性按字母升序排列，不管怎么弄就是调不过来，原来源代码里是写死的排序！唯一的办法是，把Ext.grid.PropertyGrid.initComponent()函数替换成下面这样： initComponent: function() { this.customEditors = this.customEditors || {};
PropertyGrid 去除列排序
chun521的专栏
08-19 480
只为自用方便！     Ext.grid.PropertyGrid.prototype.setSource = function(source) {  delete this.propStore.store.sortInfo;  this.propStore.setSource(source);};      
C# PropertyGrid 简单使用
Thomas会写字
03-01 5648
2. 通过Enum.ToString()实现，将String[] 变为 Enum，通过 Enum 实现下拉框。常用属性 PropertyGrid 中已经封装了下拉框属性。1. 通过继承重写 StringConverter 函数。2. 根据字段封装顺序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值