// This method returns the StatFunction properties as defined by the "parent" // DataGridCollectionView as well as the other "standard" properties for this class. // The StatFunction properties are NOT filtered by the specified attributes. PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes) { if (attributes == null) { // We only cache the full property list. if (m_classProperties == null) { DataGridCollectionView view = this.GetCollectionView(); Debug.Assert(view != null, "A group should always have a parent CollectionView for the StatFunctions to work."); if (view == null) { return(TypeDescriptor.GetProperties(typeof(DataGridCollectionViewGroup))); } PropertyDescriptorCollection classProperties = TypeDescriptor.GetProperties(typeof(DataGridCollectionViewGroup)); PropertyDescriptor[] properties = new PropertyDescriptor[classProperties.Count]; classProperties.CopyTo(properties, 0); m_classProperties = new PropertyDescriptorCollection(properties); } return(m_classProperties); } else { PropertyDescriptorCollection props = TypeDescriptor.GetProperties(this, attributes); DataGridCollectionView view = this.GetCollectionView(); return(props); } }
//This method will add the additional properties to the object. //It helps to think of the various PropertyDescriptors are columns in a database table public override PropertyDescriptorCollection GetProperties(Attribute[] attributes) { PropertyDescriptorCollection cols = base.GetProperties(attributes); string propName = ""; //empty string to be populated later //find the matching property in the type being called. foreach (PropertyDescriptor col in cols) { if (col.PropertyType.Name == typeProp.Name) { propName = col.Name; } } PropertyDescriptor pd = cols[propName]; PropertyDescriptorCollection children = pd.GetChildProperties(); //expand the child object PropertyDescriptor[] propDescripts = new PropertyDescriptor[cols.Count + children.Count]; int count = cols.Count; //start adding at the last index of the array cols.CopyTo(propDescripts, 0); //creation of the 'descriptor strings' foreach (PropertyDescriptor cpd in children) { propDescripts[count] = new SubPropertyDescriptor(pd, cpd, pd.Name + "_" + cpd.Name); count++; } PropertyDescriptorCollection newCols = new PropertyDescriptorCollection(propDescripts); return(newCols); }
public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes) { PropertyDescriptorCollection props = base.GetProperties(context, value, attributes); PSParamType parm = value as PSParamType; List <PSParameter> psprops = null; int propcnt = props.Count; if (null != parm) { psprops = parm.Properties; propcnt += psprops.Count; } PropertyDescriptor[] psdescs = new PropertyDescriptor[propcnt]; props.CopyTo(psdescs, 0); if (null != psprops) { int idx = props.Count; foreach (PSParameter psparam in psprops) { psdescs[idx++] = new PSParamDescriptor(psparam); } } return(new PropertyDescriptorCollection(psdescs)); }
static PropertyDescriptor[] ToArray(PropertyDescriptorCollection properties) { var result = new PropertyDescriptor[properties.Count]; properties.CopyTo(result, 0); return(result); }
/// <summary> /// This is overridden to return a property descriptors for the object represented by this type /// descriptor along with extra property descriptors for its child properties. /// </summary> /// <param name="attributes">An array of attributes to use as a filter or null for no filter</param> /// <returns>Returns a <see cref="PropertyDescriptorCollection"/> that contains property descriptors for /// the object and its child properties.</returns> public override PropertyDescriptorCollection GetProperties(Attribute[] attributes) { // This seems to ignore the filter so GetChildProperties() will get rid of all non-browsable // properties. PropertyDescriptorCollection props = base.GetProperties(attributes); List <PropertyDescriptor> newProps = new List <PropertyDescriptor>(); this.GetChildProperties(null, String.Empty, attributes, props, newProps); if (newProps.Count != 0) { // The collection is read-only so we'll need to create a new one PropertyDescriptor[] tempProps = new PropertyDescriptor[props.Count + newProps.Count]; props.CopyTo(tempProps, 0); newProps.CopyTo(tempProps, props.Count); props = new PropertyDescriptorCollection(tempProps); // Now we'll remove hidden top-level properties for (int idx = 0; idx < props.Count; idx++) { if (props[idx].Attributes[typeof(HidePropertyAttribute)] != null) { props.RemoveAt(idx); idx--; } } } return(props); }
private PropertyDescriptorCollection FilterProperties(PropertyDescriptorCollection props) { // create a new property array, PropertyDescriptorCollection is read-only here. PropertyDescriptor[] propArray = new PropertyDescriptor[props.Count]; props.CopyTo(propArray, 0); bool changed = false; // run through the list, replacing as necessary // for (int i = 0; i < propArray.Length; i++) { PropertyDescriptor newProp = ProcessProperty(propArray[i]); if (newProp != propArray[i]) { changed = true; propArray[i] = newProp; } } // build the new collection if we made a change. // if (changed) { props = new PropertyDescriptorCollection(propArray); } return(props); }
public override PropertyDescriptorCollection GetProperties(Attribute[] attributes) { PropertyDescriptorCollection cols = base.GetProperties(attributes); string propertyName = ""; foreach (PropertyDescriptor col in cols) { if (col.PropertyType.Name == typeProperty.Name) { propertyName = col.Name; } } PropertyDescriptor pd = cols[propertyName]; PropertyDescriptorCollection children = pd.GetChildProperties(); PropertyDescriptor[] array = new PropertyDescriptor[cols.Count + children.Count]; int count = cols.Count; cols.CopyTo(array, 0); foreach (PropertyDescriptor cpd in children) { array[count] = new SubPropertyDescriptor(pd, cpd, pd.Name + "_" + cpd.Name); count++; } PropertyDescriptorCollection newcols = new PropertyDescriptorCollection(array); return(newcols); }
public override PropertyDescriptorCollection GetProperties() { var properties = new PropertyDescriptor[m_MergedProperties.Count]; m_MergedProperties.CopyTo(properties, 0); return(new PropertyDescriptorCollection(properties)); }
static ProviderBase() { PropertyDescriptorCollection propertyCollection = TypeDescriptor.GetProperties(typeof(ProviderBase)); PropertyDescriptor[] properties = new PropertyDescriptor[propertyCollection.Count]; propertyCollection.CopyTo(properties, 0); _providerBaseTypeProperties = new PropertyDescriptorCollection(properties, false); }
private void CreateProperties() { PropertyDescriptor[] descArray = new PropertyDescriptor[thisProperties.Count + controlProperties.Count]; thisProperties.CopyTo(descArray, 0); controlProperties.CopyTo(descArray, thisProperties.Count); properties = new PropertyDescriptorCollection(descArray); }
/// <summary> /// Obtains the default properties for an object</summary> /// <param name="owner">Object whose properties are obtained</param> /// <returns>Default properties for an object, as an array</returns> public static PropertyDescriptor[] GetDefaultProperties2(object owner) { PropertyDescriptorCollection propertyCollection = GetDefaultProperties(owner); PropertyDescriptor[] result = new PropertyDescriptor[propertyCollection.Count]; propertyCollection.CopyTo(result, 0); return(result); }
static LayerCollection() { PropertyDescriptorCollection props = TypeDescriptor.GetProperties(typeof(ILayer)); PropertyDescriptor[] propsArray = new PropertyDescriptor[props.Count]; props.CopyTo(propsArray, 0); _layerProperties = new PropertyDescriptorCollection(propsArray, true); }
PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes) { PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(this, attributes, true); PropertyDescriptor[] proparray = new PropertyDescriptor[properties.Count]; properties.CopyTo(proparray, 0); // Wrap the properties in our custom collection. return(new CustomProperties(proparray)); }
private void ensureInstanceProperties() { if (_instanceProperties != null) { return; } PropertyDescriptor[] propArray = new PropertyDescriptor[_layerTypeProperties.Count]; _layerTypeProperties.CopyTo(propArray, 0); _instanceProperties = new PropertyDescriptorCollection(propArray, false); }
public PropertyDescriptorCollection GetProperties(Attribute[] attributes) { PropertyDescriptorCollection orig = TypeDescriptor.GetProperties(GetType(), attributes); PropertyDescriptor[] arr = new PropertyDescriptor[orig.Count]; orig.CopyTo(arr, 0); PropertyDescriptorCollection col = new PropertyDescriptorCollection(arr); ModifyProperties(col); return(col); }
public static void AddProperty(string name, Type type, params Attribute[] attributes) { lock (syncLock) { // append the new prop, into a *new* collection, so that downstream // callers don't have to worry about the complexities PropertyDescriptor[] newProps = new PropertyDescriptor[props.Count + 1]; props.CopyTo(newProps, 0); newProps[newProps.Length - 1] = new PropertyBagPropertyDescriptor(name, type, attributes); props = new PropertyDescriptorCollection(newProps, true); } }
private static PropertyDescriptorCollection AddItems(PropertyDescriptorCollection cols, params PropertyDescriptor[] items) { PropertyDescriptor[] array = new PropertyDescriptor[cols.Count + items.Length]; cols.CopyTo(array, 0); for (int i = 0; i < items.Length; i++) { array[cols.Count + i] = items[i]; } PropertyDescriptorCollection newcols = new PropertyDescriptorCollection(array); return(newcols); }
protected ReadOnlyCollection <PropertyDescriptor> GetPropertiesROCollection() { PropertyDescriptorCollection properties = GetProperties(); PropertyDescriptor[] pds = new PropertyDescriptor[PropertyDescriptorCount]; properties.CopyTo(pds, 0); ReadOnlyCollection <PropertyDescriptor> result = new ReadOnlyCollection <PropertyDescriptor>(pds); return(result); }
private void ensureInstanceProperties() { if (_instanceProperties != null) { return; } PropertyDescriptorCollection classProperties = GetClassProperties(); PropertyDescriptor[] propArray = new PropertyDescriptor[classProperties.Count]; classProperties.CopyTo(propArray, 0); _instanceProperties = new PropertyDescriptorCollection(propArray, false); }
public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes) { PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(value, attributes); if ((properties != null) && (properties.Count > 0)) { properties = properties.Sort(); PropertyDescriptor[] array = new PropertyDescriptor[properties.Count]; properties.CopyTo(array, 0); properties = new PropertyDescriptorCollection(array, true); } return(properties); }
public void GetListNameAccessors() { List <SimpleClass> list = new List <SimpleClass>(); ObjectListView view = new ObjectListView(list); // Get some random property descriptors. PropertyDescriptorCollection accessors = TypeDescriptor.GetProperties(typeof(ISite)); PropertyDescriptor[] listAccessors = new PropertyDescriptor[accessors.Count]; accessors.CopyTo(listAccessors, 0); Assert.AreEqual("", ((ITypedList)view).GetListName(listAccessors)); }
public void GetListNameAccessors() { ViewFactory <SimpleClass> factory = ViewFactory <SimpleClass> .IList(); ObjectListView <SimpleClass> view = factory.View; // Get some random property descriptors. PropertyDescriptorCollection accessors = TypeDescriptor.GetProperties(typeof(ISite)); PropertyDescriptor[] listAccessors = new PropertyDescriptor[accessors.Count]; accessors.CopyTo(listAccessors, 0); Assert.AreEqual("", ((ITypedList)view).GetListName(listAccessors)); }
public override PropertyDescriptorCollection GetProperties(Attribute[] attributes) { PropertyDescriptorCollection cols = base.GetProperties(); PropertyDescriptor prncpl = cols["Principal"]; PropertyDescriptorCollection prncpl_child = prncpl.GetChildProperties(); PropertyDescriptor[] arr = new PropertyDescriptor[cols.Count + 4]; cols.CopyTo(arr, 0); arr[cols.Count] = new SubPropertyDescriptor(prncpl, prncpl_child["ID"], "Principal_ID"); arr[cols.Count + 1] = new SubPropertyDescriptor(prncpl, prncpl_child["Name"], "Principal_Name"); arr[cols.Count + 2] = new SubPropertyDescriptor(prncpl, prncpl_child["Status"], "Principal_Status"); arr[cols.Count + 3] = new SubPropertyDescriptor(prncpl, prncpl_child["Members"], "Principal_Members"); PropertyDescriptorCollection newcols = new PropertyDescriptorCollection(arr); return(newcols); }
private void InitializeInheritedProperties(bool rootComponent) { Hashtable props = new Hashtable(); bool readOnlyInherit = (InheritanceAttribute.Equals(InheritanceAttribute.InheritedReadOnly)); if (!readOnlyInherit) { PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(Component); // Now loop through all the properties. For each one, try to match a pre-created property. // If that fails, then create a new property. // PropertyDescriptor[] values = new PropertyDescriptor[properties.Count]; properties.CopyTo(values, 0); for (int i = 0; i < values.Length; i++) { PropertyDescriptor prop = values[i]; // Skip some properties // if (object.Equals(prop.Attributes[typeof(DesignOnlyAttribute)], DesignOnlyAttribute.Yes)) { continue; } if (prop.SerializationVisibility == DesignerSerializationVisibility.Hidden && !prop.IsBrowsable) { continue; } PropertyDescriptor inheritedProp = (PropertyDescriptor)props[prop.Name]; if (inheritedProp == null) { // This ia a publicly inherited component. We replace all component properties with // inherited versions that reset the default property values to those that are // currently on the component. // props[prop.Name] = new InheritedPropertyDescriptor(prop, component, rootComponent); } } } inheritedProps = props; }
protected override PropertyDescriptorCollection GetProperties(Attribute[] attributes) { PropertyDescriptorCollection descriptors = base.GetProperties(attributes); PropertyDescriptor dataSourceDescriptor = descriptors.Find("DataSource", true); if (dataSourceDescriptor != null) { int index = descriptors.IndexOf(dataSourceDescriptor); PropertyDescriptor[] descriptorArray = new PropertyDescriptor[descriptors.Count]; descriptors.CopyTo(descriptorArray, 0); descriptorArray[index] = new DynamicPropertyDescriptor(dataSourceDescriptor, new TypeConverterAttribute(typeof(DataSourceConverter))); (descriptorArray[index] as DynamicPropertyDescriptor).CanResetValueHandler = new CanResetValueHandler(CanResetDataSource); (descriptorArray[index] as DynamicPropertyDescriptor).ResetValueHandler = new ResetValueHandler(ResetDataSource); descriptors = new PropertyDescriptorCollection(descriptorArray, true); } return(descriptors); }
public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object component, Attribute[] attributes) { //IEventBindingService eventPropertyService = this.GetEventPropertyService(component, context); //if (eventPropertyService == null) //{ // return new PropertyDescriptorCollection(null); //} EventDescriptorCollection events = TypeDescriptor.GetEvents(component, attributes); // PropertyDescriptorCollection eventProperties = eventPropertyService.GetEventProperties(events); PropertyDescriptorCollection eventProperties = GetEventProperties(events); Attribute[] destinationArray = new Attribute[attributes.Length + 1]; Array.Copy(attributes, 0, destinationArray, 0, attributes.Length); destinationArray[attributes.Length] = DesignerSerializationVisibilityAttribute.Content; PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(component, destinationArray); if (properties.Count > 0) { ArrayList list = null; for (int i = 0; i < properties.Count; i++) { PropertyDescriptor oldPropertyDescriptor = properties[i]; if (oldPropertyDescriptor.Converter.GetPropertiesSupported() && (TypeDescriptor.GetEvents(oldPropertyDescriptor.GetValue(component), attributes).Count > 0)) { if (list == null) { list = new ArrayList(); } oldPropertyDescriptor = TypeDescriptor.CreateProperty(oldPropertyDescriptor.ComponentType, oldPropertyDescriptor, new Attribute[] { MergablePropertyAttribute.No }); list.Add(oldPropertyDescriptor); } } if (list != null) { PropertyDescriptor[] array = new PropertyDescriptor[list.Count]; list.CopyTo(array, 0); PropertyDescriptor[] descriptorArray2 = new PropertyDescriptor[eventProperties.Count + array.Length]; eventProperties.CopyTo(descriptorArray2, 0); Array.Copy(array, 0, descriptorArray2, eventProperties.Count, array.Length); eventProperties = new PropertyDescriptorCollection(descriptorArray2); } } return(eventProperties); }
public PropertyDescriptorCollection GetProperties(Attribute[] attributes) { PropertyDescriptorCollection ps = TypeDescriptor.GetProperties(this, attributes, true); List <PropertyDescriptor> list = new List <PropertyDescriptor>(); bool isString = typeof(string).Equals(_type); if (IsDataOnly) { foreach (PropertyDescriptor p in ps) { if ((string.CompareOrdinal(p.Name, "DefaultData") == 0) || (string.CompareOrdinal(p.Name, "DataType") == 0)) { PropertyDescriptorForDisplay p0 = new PropertyDescriptorForDisplay(this.GetType(), p.Name, VPLUtil.ObjectToString(p.GetValue(this)), attributes); list.Add(p0); } } } else { if (isString) { PropertyDescriptor[] a = new PropertyDescriptor[ps.Count]; ps.CopyTo(a, 0); list.AddRange(a); } else { //remove Encrypted if not a string value foreach (PropertyDescriptor p in ps) { if (string.CompareOrdinal(p.Name, "Encrypted") != 0) { list.Add(p); } } } } PropertyInfo pif = typeof(ConfigProperty).GetProperty("DefaultData"); PropertyDescriptorValue pv = new PropertyDescriptorValue("Data", attributes, pif, _type, typeof(ConfigProperty)); list.Add(pv); ps = new PropertyDescriptorCollection(list.ToArray()); return(ps); }
public override PropertyDescriptorCollection GetProperties(Attribute[] attributes) { if (_pdcFiltered == null) { PropertyDescriptorCollection pdc = base.GetProperties(attributes); // this gives us a readonly collection, no good Array arr = Array.CreateInstance(typeof(PropertyDescriptor), pdc.Count); pdc.CopyTo(arr, 0); _pdcFiltered = new PropertyDescriptorCollection((PropertyDescriptor[])arr); } if (_methodInfo != null) { // invoke the method Object[] arrObj = { _pdcFiltered }; object obj = _methodInfo.Invoke(_instance, arrObj); } return(_pdcFiltered); }
public PropertyDescriptorCollection GetProperties(Attribute[] attributes) { PropertyDescriptorCollection ps = TypeDescriptor.GetProperties(this, attributes, true); // List <PropertyDescriptor> list = new List <PropertyDescriptor>(); PropertyDescriptor[] a = new PropertyDescriptor[ps.Count]; ps.CopyTo(a, 0); list.AddRange(a); // foreach (ConfigProperty cp in _cat.Properties.Properties) { PropertyDescriptorConfig pc = new PropertyDescriptorConfig(cp.DataName, attributes, cp, _owner); list.Add(pc); } ps = new PropertyDescriptorCollection(list.ToArray()); // return(ps); }
public override PropertyDescriptorCollection GetProperties(Attribute[] attributes) { if ((this.instance != null) && (this.collection == null)) { PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(this.instance); PropertyDescriptor[] array = new PropertyDescriptor[properties.Count]; properties.CopyTo(array, 0); this.collection = new PropertyDescriptorCollection(array, false); } if (this.collection.Count > 0) { this.propItems = this.collection["Items"]; if (this.propItems != null) { this.collection.Remove(this.propItems); } } return(this.collection); }