public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object container) { return innerTypeDescriptor.GetProperties(type, container) .Where(p => p.GetCustomAttribute<YamlIgnoreAttribute>() == null) .Select(p => { var descriptor = new PropertyDescriptor(p); var alias = p.GetCustomAttribute<YamlAliasAttribute>(); if (alias != null) { descriptor.Name = alias.Alias; } var member = p.GetCustomAttribute<YamlMemberAttribute>(); if (member != null) { if (member.SerializeAs != null) { descriptor.TypeOverride = member.SerializeAs; } } return (IPropertyDescriptor)descriptor; }); }
public void Initialize (PropertyDescriptor prop) { if (prop.PropertyType != typeof(int)) throw new ApplicationException ("OptIntRange editor does not support editing values of type " + prop.PropertyType); double min = (double) Int32.MinValue; double max = (double) Int32.MaxValue; if (omin == null) omin = prop.Minimum; if (omax == null) omax = prop.Maximum; if (omin != null) min = (double) Convert.ChangeType (omin, typeof(double)); if (omax != null) max = (double) Convert.ChangeType (omax, typeof(double)); check = new Gtk.CheckButton (); check.Show (); check.Toggled += check_Toggled; PackStart (check, false, false, 0); spin = new Gtk.SpinButton (min, max, 1.0); spin.Show (); spin.HasFrame = false; spin.ValueChanged += spin_ValueChanged; PackStart (spin, true, true, 0); }
protected override void GeneratePropertySet (GeneratorContext ctx, CodeExpression var, PropertyDescriptor prop) { if (prop.Name == "Alpha" && Alpha == -1) return; else base.GeneratePropertySet (ctx, var, prop); }
/// <summary> /// Initializes a new instance of the <see cref="PropertyDescriptor"/> class /// with an existing property descriptor. /// </summary> /// <param name="other">The other descriptor.</param> public PropertyDescriptor(PropertyDescriptor other) { property = other.property; AddKeyBuilders(other.keyBuilders); AddGetters(other.getters); AddSetters(other.setters); }
/// <summary> /// Creates a new ExtenderProvidedPropertyAttribute. /// </summary> internal static ExtenderProvidedPropertyAttribute Create(PropertyDescriptor extenderProperty, Type receiverType, IExtenderProvider provider) { ExtenderProvidedPropertyAttribute e = new ExtenderProvidedPropertyAttribute(); e._extenderProperty = extenderProperty; e._receiverType = receiverType; e._provider = provider; return e; }
public override bool DefineOwnProperty(string propertyName, PropertyDescriptor desc, bool throwOnError) { if (throwOnError) { throw new JavaScriptException(Engine.TypeError, "Can't define a property of a NamespaceReference"); } return false; }
public PropertyDescriptor(PropertyDescriptor descriptor) { Get = descriptor.Get; Set = descriptor.Set; Value = descriptor.Value; Enumerable = descriptor.Enumerable; Configurable = descriptor.Configurable; Writable = descriptor.Writable; }
bool IDictionaryPropertySetter.SetPropertyValue( IDictionaryAdapterFactory factory, IDictionary dictionary, string key, ref object value, PropertyDescriptor property) { if (value != null) { value = GetPropertyAsString(property, value); } return true; }
public override void Initialize (PropertyDescriptor prop) { base.Initialize (prop); entry = new Gtk.Entry (); entry.HasFrame = false; entry.Show (); entry.Changed += EntryChanged; Add (entry); }
private void ApplyValidationRules(IDictionaryAdapter dictionaryAdapter, IEnumerable<IValidationRule> rules, PropertyDescriptor property, object propertyValue, IList<String> errors) { if (rules != null) { foreach (var rule in rules) { rule.Apply(dictionaryAdapter, property, propertyValue, errors); } } }
protected void NotifyPropertyChanged(PropertyDescriptor property, object oldValue, object newValue) { if (property.SuppressNotifications) return; var propertyChanged = PropertyChanged; if (propertyChanged == null) return; propertyChanged(this, new PropertyChangedEventArgsEx(property.PropertyName, oldValue, newValue)); }
private List<Expression> BuildColumnConstraints(PropertyDescriptor propertyDescriptor, PropertyDescriptor foreignKeyReferencingProperty) { var retval = new List<Expression>(); if (foreignKeyReferencingProperty != null) { var valueRequiredAttribute = foreignKeyReferencingProperty.ValueRequiredAttribute; if (foreignKeyReferencingProperty.HasUniqueAttribute && foreignKeyReferencingProperty.UniqueAttribute.Unique) { retval.Add(new SqlSimpleConstraintExpression(SqlSimpleConstraint.Unique)); } if (valueRequiredAttribute != null && valueRequiredAttribute.Required) { retval.Add(new SqlSimpleConstraintExpression(SqlSimpleConstraint.NotNull)); } } else { if (propertyDescriptor.PropertyType.IsNullableType() || !propertyDescriptor.PropertyType.IsValueType) { var valueRequiredAttribute = propertyDescriptor.ValueRequiredAttribute; if (valueRequiredAttribute != null && valueRequiredAttribute.Required) { retval.Add(new SqlSimpleConstraintExpression(SqlSimpleConstraint.NotNull)); } } else { retval.Add(new SqlSimpleConstraintExpression(SqlSimpleConstraint.NotNull)); } if (propertyDescriptor.IsAutoIncrement && propertyDescriptor.PropertyType.IsIntegerType(true)) { retval.Add(new SqlSimpleConstraintExpression(SqlSimpleConstraint.AutoIncrement, value: new object[] { propertyDescriptor.AutoIncrementAttribute.Seed, propertyDescriptor.AutoIncrementAttribute.Step })); } if (propertyDescriptor.HasUniqueAttribute && propertyDescriptor.UniqueAttribute.Unique) { retval.Add(new SqlSimpleConstraintExpression(SqlSimpleConstraint.Unique)); } var defaultValueAttribute = propertyDescriptor.DefaultValueAttribute; if (defaultValueAttribute != null) { retval.Add(new SqlSimpleConstraintExpression(SqlSimpleConstraint.DefaultValue, null, defaultValueAttribute.Value)); } } return retval; }
public string Validate(IDictionaryAdapter dictionaryAdapter, PropertyDescriptor property) { List<String> errors = new List<string>(); var globalRules = AttributesUtil.GetTypeAttributes<IValidationRule>(dictionaryAdapter.Meta.Type); var propertyRules = AttributesUtil.GetAttributes<IValidationRule>(property.Property); var propertyValue = dictionaryAdapter.GetProperty(property.PropertyName, true); ApplyValidationRules(dictionaryAdapter, propertyRules, property, propertyValue, errors); ApplyValidationRules(dictionaryAdapter, globalRules, property, propertyValue, errors); return String.Join(Environment.NewLine, errors.ToArray()); }
public void Initialize (PropertyDescriptor prop) { if (!prop.PropertyType.IsEnum) throw new ApplicationException ("Flags editor does not support editing values of type " + prop.PropertyType); property = prop.Label; Spacing = 3; // For small enums, the editor is a list of checkboxes inside a frame // For large enums (>5), use a selector dialog. enm = Registry.LookupEnum (prop.PropertyType.FullName); if (enm.Values.Length < 6) { Gtk.VBox vbox = new Gtk.VBox (true, 3); flags = new Hashtable (); foreach (Enum value in enm.Values) { EnumValue eval = enm[value]; if (eval.Label == "") continue; Gtk.CheckButton check = new Gtk.CheckButton (eval.Label); check.TooltipText = eval.Description; uint uintVal = (uint) Convert.ToInt32 (eval.Value); flags[check] = uintVal; flags[uintVal] = check; check.Toggled += FlagToggled; vbox.PackStart (check, false, false, 0); } Gtk.Frame frame = new Gtk.Frame (); frame.Add (vbox); frame.ShowAll (); PackStart (frame, true, true, 0); } else { flagsLabel = new Gtk.Entry (); flagsLabel.IsEditable = false; flagsLabel.HasFrame = false; flagsLabel.ShowAll (); PackStart (flagsLabel, true, true, 0); Gtk.Button but = new Gtk.Button ("..."); but.Clicked += OnSelectFlags; but.ShowAll (); PackStart (but, false, false, 0); } }
public void Initialize (PropertyDescriptor descriptor) { store = new ListStore (typeof(Pixbuf), typeof(string)); Model = store; store.SetSortColumnId (1, SortType.Ascending); CellRendererPixbuf crp = new CellRendererPixbuf (); CellRendererText crt = new CellRendererText (); PackStart (crp, false); PackStart (crt, true); SetAttributes (crp, "pixbuf", 0); SetAttributes (crt, "text", 1); }
protected override void GeneratePropertySet (GeneratorContext ctx, CodeExpression var, PropertyDescriptor prop) { if (prop.Name == "Group") { CodeExpression groupExp = GroupManager.GenerateGroupExpression (ctx, (Gtk.Widget) Wrapped); ctx.Statements.Add ( new CodeAssignStatement ( new CodePropertyReferenceExpression (var, "Group"), groupExp) ); } else base.GeneratePropertySet (ctx, var, prop); }
protected bool NotifyPropertyChanging(PropertyDescriptor property, object oldValue, object newValue) { if (property.SuppressNotifications) return true; var propertyChanging = PropertyChanging; if (propertyChanging == null) return true; var args = new PropertyChangingEventArgsEx(property.PropertyName, oldValue, newValue); propertyChanging(this, args); return !args.Cancel; }
private IEnumerable<Attribute> GetFieldMetadata(PropertyDescriptor fieldProperty) { if (AssociatedMetadataType != null) { MemberTypes allowedMemberTypes = MemberTypes.Property | MemberTypes.Field; foreach (MemberInfo buddyMember in AssociatedMetadataType.GetMembers()) { if ((buddyMember.MemberType & allowedMemberTypes) != 0 && PropertyMatches(fieldProperty, buddyMember)) { foreach (Attribute attribute in buddyMember.GetCustomAttributes(false)) { yield return attribute; } yield break; } } } }
public void Initialize (PropertyDescriptor prop) { propType = prop.PropertyType; double min, max; switch (Type.GetTypeCode (propType)) { case TypeCode.Int16: min = (double) Int16.MinValue; max = (double) Int16.MaxValue; break; case TypeCode.UInt16: min = (double) UInt16.MinValue; max = (double) UInt16.MaxValue; break; case TypeCode.Int32: min = (double) Int32.MinValue; max = (double) Int32.MaxValue; break; case TypeCode.UInt32: min = (double) UInt32.MinValue; max = (double) UInt32.MaxValue; break; case TypeCode.Int64: min = (double) Int64.MinValue; max = (double) Int64.MaxValue; break; case TypeCode.UInt64: min = (double) UInt64.MinValue; max = (double) UInt64.MaxValue; break; case TypeCode.Byte: min = (double) Byte.MinValue; max = (double) Byte.MaxValue; break; case TypeCode.SByte: min = (double) SByte.MinValue; max = (double) SByte.MaxValue; break; default: throw new ApplicationException ("IntRange editor does not support editing values of type " + prop.PropertyType); } if (prop.Minimum != null) min = (double) Convert.ChangeType (prop.Minimum, typeof(double)); if (prop.Maximum != null) max = (double) Convert.ChangeType (prop.Maximum, typeof(double)); SetRange (min, max); }
protected void NotifyPropertyChanged(PropertyDescriptor property, object oldValue, object newValue) { if (!property.SuppressNotifications) { var propertyChanged = PropertyChanged; ComposeChildNotifications(property, oldValue, newValue); if (propertyChanged != null) { propertyChanged(this, new PropertyModifiedEventArgs(property.PropertyName, oldValue, newValue)); } } }
protected bool NotifyPropertyChanging(PropertyDescriptor property, object oldValue, object newValue) { if (!property.SuppressNotifications) { var propertyChanging = PropertyChanging; if (propertyChanging != null) { var eventArgs = new PropertyModifyingEventArgs(property.PropertyName, oldValue, newValue); propertyChanging(this, eventArgs); return !eventArgs.Cancel; } } return true; }
public void Initialize (PropertyDescriptor descriptor) { if (descriptor.PropertyType != typeof(string)) throw new InvalidOperationException ("TextEditor only can edit string properties"); try { if (descriptor.Minimum != null) min = Convert.ToInt32 (descriptor.Minimum); } catch {} try { if (descriptor.Maximum != null) max = Convert.ToInt32 (descriptor.Maximum); } catch {} }
/// <summary> /// Gets the effective dictionary value. /// </summary> /// <param name="dictionaryAdapter">The dictionary adapter.</param> /// <param name="key">The key.</param> /// <param name="storedValue">The stored value.</param> /// <param name="property">The property.</param> /// <param name="ifExists">true if return only existing.</param> /// <returns>The effective property value.</returns> public object GetPropertyValue(IDictionaryAdapter dictionaryAdapter, string key, object storedValue, PropertyDescriptor property, bool ifExists) { var propertyType = property.PropertyType; if (storedValue != null && propertyType.IsInstanceOfType(storedValue) == false) { if (converter != null && converter.CanConvertFrom(storedValue.GetType())) { return converter.ConvertFrom(storedValue); } } return storedValue; }
/// <summary> /// Gets the effective dictionary value. /// </summary> /// <param name="factory">The dictionary factory.</param> /// <param name="dictionary">The dictionary.</param> /// <param name="key">The key.</param> /// <param name="storedValue">The stored value.</param> /// <param name="property">The property.</param> /// <returns>The effective property value.</returns> public object GetPropertyValue(IDictionaryAdapterFactory factory, IDictionary dictionary, string key, object storedValue, PropertyDescriptor property) { Type propertyType = property.PropertyType; if (storedValue != null && !propertyType.IsInstanceOfType(storedValue)) { if (converter != null && converter.CanConvertFrom(storedValue.GetType())) { return converter.ConvertFrom(storedValue); } } return storedValue; }
private string GetPropertyAsString(PropertyDescriptor property, object value) { if (!string.IsNullOrEmpty(format)) { return String.Format(format, value); } TypeConverter converter = property.TypeConverter; if (converter != null && converter.CanConvertTo(typeof(string))) { return (string) converter.ConvertTo(value, typeof(string)); } return value.ToString(); }
/// <summary> /// Copies an existinginstance of the <see cref="PropertyDescriptor"/> class. /// </summary> /// <param name="source"></param> /// <param name="copyBehaviors"></param> public PropertyDescriptor(PropertyDescriptor source, bool copyBehaviors) { Property = source.Property; Behaviors = source.Behaviors; IsDynamicProperty = source.IsDynamicProperty; TypeConverter = source.TypeConverter; SuppressNotifications = source.SuppressNotifications; state = source.state; Fetch = source.Fetch; if (copyBehaviors) { keyBuilders = source.keyBuilders; getters = source.getters; setters = source.setters; } }
public void ConstructorReadOnlyTests() { var descriptors = new PropertyDescriptor[] { new MockPropertyDescriptor("descriptor1") }; var collection = new PropertyDescriptorCollection(descriptors, true); Assert.Equal(descriptors.Cast<PropertyDescriptor>(), collection.Cast<PropertyDescriptor>()); // These methods are implemented as explicit properties so we need to ensure they are what we expect Assert.True(((IDictionary)collection).IsReadOnly); Assert.True(((IDictionary)collection).IsFixedSize); Assert.True(((IList)collection).IsReadOnly); Assert.True(((IList)collection).IsFixedSize); }
public override PropertyDescriptor GetOwnProperty(string propertyName) { PropertyDescriptor x; if (Properties.TryGetValue(propertyName, out x)) return x; var library = (Library) Target; var method = library.GetFunction(propertyName); if (method != null) { var descriptor = new PropertyDescriptor(new MethodInfoFunctionInstance(Engine, new[] { method }), false, true, false); Properties.Add(propertyName, descriptor); return descriptor; } return PropertyDescriptor.Undefined; }
public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object container) { return innerTypeDescriptor.GetProperties(type, container) .Where(p => p.GetCustomAttribute<YamlIgnoreAttribute>() == null) .Select(p => { var descriptor = new PropertyDescriptor(p); #pragma warning disable 0618 // 'YamlDotNet.Serialization.YamlAliasAttribute' is obsolete: 'Please use YamlMember instead' var alias = p.GetCustomAttribute<YamlAliasAttribute>(); if (alias != null) { descriptor.Name = alias.Alias; } #pragma warning restore 0618 // 'YamlDotNet.Serialization.YamlAliasAttribute' is obsolete: 'Please use YamlMember instead' var member = p.GetCustomAttribute<YamlMemberAttribute>(); if (member != null) { if (member.SerializeAs != null) { descriptor.TypeOverride = member.SerializeAs; } descriptor.Order = member.Order; descriptor.ScalarStyle = member.ScalarStyle; if (member.Alias != null) { if (alias != null) { throw new InvalidOperationException("Mixing YamlAlias(...) with YamlMember(Alias = ...) is an error. The YamlAlias attribute is obsolete and should be removed."); } descriptor.Name = member.Alias; } } return (IPropertyDescriptor)descriptor; }) .OrderBy(p => p.Order); }
public void Initialize (PropertyDescriptor prop) { if (!prop.PropertyType.IsEnum) throw new ApplicationException ("Enumeration editor does not support editing values of type " + prop.PropertyType); ebox = new Gtk.EventBox (); ebox.Show (); PackStart (ebox, true, true, 0); combo = Gtk.ComboBoxEntry.NewText (); combo.Changed += combo_Changed; combo.Entry.IsEditable = false; combo.Entry.HasFrame = false; combo.Entry.HeightRequest = combo.SizeRequest ().Height; // The combo does not set the entry to the correct size when it does not have a frame combo.Show (); ebox.Add (combo); enm = Registry.LookupEnum (prop.PropertyType.FullName); foreach (Enum value in enm.Values) combo.AppendText (enm[value].Label); }
private void SetNextTabIndex(Control ctl) { if (this.tabControls != null) { int num; Control sitedParent = this.GetSitedParent(ctl); object obj2 = this.tabNext[sitedParent]; if (this.tabComplete.IndexOf(ctl) == -1) { this.tabComplete.Add(ctl); } if (obj2 != null) { num = (int)obj2; } else { num = 0; } try { PropertyDescriptor descriptor = (PropertyDescriptor)this.tabProperties[ctl]; if (descriptor != null) { int num3 = num + 1; if (descriptor.IsReadOnly) { num3 = ((int)descriptor.GetValue(ctl)) + 1; } int maxControlCount = this.GetMaxControlCount(sitedParent); if (num3 >= maxControlCount) { num3 = 0; } this.tabNext[sitedParent] = num3; if (this.tabComplete.Count == this.tabControls.Count) { this.tabComplete.Clear(); } if (!descriptor.IsReadOnly) { try { descriptor.SetValue(ctl, num); } catch (Exception) { } } else { base.Invalidate(); } } } catch (Exception exception) { if (System.Windows.Forms.ClientUtils.IsCriticalException(exception)) { throw; } } } }
public Type GetEditorType(PropertyDescriptor pd) { //try to find a custom editor //TODO: Find a way to provide a IWindowsFormsEditorService so this can work directly //for now, substitute GTK#-based editors /* * UITypeEditor UITypeEd = (UITypeEditor) pd.GetEditor(typeof (System.Drawing.Design.UITypeEditor));//first, does it have custom editors? * if (UITypeEd != null) * if (surrogates.Contains(UITypeEd.GetType ())) * return instantiateEditor((Type) surrogates[UITypeEd.GetType()], parentRow); */ //does a registered GTK# editor support this natively? Type editType = pd.PropertyType; if (editors.Contains(editType)) { return((Type)editors [editType]); } //editors that edit derived types foreach (DictionaryEntry de in inheritingEditors) { if (editType.IsSubclassOf((Type)de.Key)) { return((Type)de.Value); } } if (pd.PropertyType.IsEnum) { if (pd.PropertyType.IsDefined(typeof(FlagsAttribute), true)) { return(typeof(PropertyEditors.FlagsEditorCell)); } else { return(typeof(PropertyEditors.EnumerationEditorCell)); } } //collections with items of single type that aren't just objects if (typeof(IList).IsAssignableFrom(editType)) { // Iterate through all properties since there may be more than one indexer. if (GetCollectionItemType(editType) != null) { return(typeof(CollectionEditor)); } } //TODO: support simple SWF collection editor derivatives that just override Types available // and reflect protected Type[] NewItemTypes {get;} to get types //if (UITypeEd is System.ComponentModel.Design.CollectionEditor) // ((System.ComponentModel.Design.CollectionEditor)UITypeEd). //can we use a type converter with a built-in editor? TypeConverter tc = pd.Converter; if (typeof(ExpandableObjectConverter).IsAssignableFrom(tc.GetType())) { return(typeof(ExpandableObjectEditor)); } //This is a temporary workaround *and* and optimisation //First, most unknown types will be most likely to convert to/from strings //Second, System.Web.UI.WebControls/UnitConverter.cs dies on non-strings if (tc.CanConvertFrom(typeof(string)) && tc.CanConvertTo(typeof(string))) { return(typeof(TextEditor)); } foreach (DictionaryEntry editor in editors) { if (tc.CanConvertFrom((Type)editor.Key) && tc.CanConvertTo((Type)editor.Key)) { return((Type)editor.Value); } } foreach (DictionaryEntry de in inheritingEditors) { if (tc.CanConvertFrom((Type)de.Key) && tc.CanConvertTo((Type)de.Key)) { return((Type)de.Value); } } //nothing found - just display type return(null); }
/// <summary> /// Returns an object that contains the property described by the specified property descriptor. /// </summary> /// <param name="pd">A PropertyDescriptor that represents the property whose owner is to be found. </param> /// <returns>Handle object</returns> public object GetPropertyOwner(PropertyDescriptor pd) { return(m_handle); }
/// <summary> /// /// </summary> /// <param name="prop"></param> /// <param name="direction"></param> /// <exception cref="NotSupportedException">If cannot sort by .</exception> protected override void ApplySortCore(PropertyDescriptor prop, ListSortDirection direction) { var sortedList = new List <SortIndex <T> >(); // Check to see if the property type we are sorting by implements // the IComparable interface. var interfaceType = prop.PropertyType.GetInterface("IComparable"); if (interfaceType != null) { RaiseListChangedEvents = false; // If so, set the SortPropertyValue and SortDirectionValue. _sortPropertyValue = prop; _sortDirectionValue = direction; _unsortedItems = new ArrayList(Count); // Loop through each item, adding it the the sortedItems ArrayList. foreach (var item in Items) { sortedList.Add(new SortIndex <T>((IComparable)prop.GetValue(item), item)); _unsortedItems.Add(item); } // Call Sort on the ArrayList. sortedList.Sort(); // Check the sort direction and then copy the sorted items // back into the list. if (direction == ListSortDirection.Descending) { sortedList.Reverse(); } for (var i = 0; i < sortedList.Count; i++) { try { var position = IndexOf(sortedList[i].Item); if (position == i) { continue; } var temp = this[i]; this[i] = this[position]; this[position] = temp; } catch (Exception e) { Console.WriteLine(e); throw; } } _isSortedValue = true; // Raise the ListChanged event so bound controls refresh their // values. RaiseListChangedEvents = true; OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1)); } else { // If the property type does not implement IComparable, let the user // know. throw new NotSupportedException($"Cannot sort by {prop.Name}. This{prop.PropertyType} does not implement IComparable"); } }
public WidgetOption(PropertyDescriptor propertyDescriptor) { PropertyDescriptor = propertyDescriptor; }
public void RemoveIndex(PropertyDescriptor property) { }
public object GetPropertyOwner(PropertyDescriptor pd) { return(this.owner); }
/// <summary> /// Returns an object that contains the property described by the specified property descriptor. /// </summary> /// <param name="pd">A <see cref="T:System.ComponentModel.PropertyDescriptor"/> that represents the property whose owner is to be found.</param> /// <returns> /// An <see cref="T:System.Object"/> that represents the owner of the specified property. /// </returns> object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd) { return(null); }
object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd) { throw new NotImplementedException(); }
/// <include file='doc\MenuDesigner.uex' path='docs/doc[@for="MenuDesigner.IMISetProp"]/*' /> /// <devdoc> /// This method is called by the IVsMenuEditor when properties of a particular menu /// item need to be set. /// </devdoc> public int IMISetProp(int propId, object obj) { //make sure we can get a component that is a menuitem //so we can adjust its' properties... IComponent c = Component; if (!(c is MenuItem)) { return(NativeMethods.S_OK); } PropertyDescriptor prop = null; object value = null; try { //if this is the first call to setProp since we've been created //then we need to be sure to ignore any name change from the //menu editor if (justCreated) { if (propId == __VSMEPROPID.VSMEPROPID_NAME) { return(NativeMethods.S_OK); } } switch (propId) { case __VSMEPROPID.VSMEPROPID_NAME: prop = TypeDescriptor.GetProperties(c)["Name"]; value = Convert.ToString(obj); break; case __VSMEPROPID.VSMEPROPID_CAPTION: if (obj == null) { textCache = ""; } else { textCache = obj.ToString(); } break; case __VSMEPROPID.VSMEPROPID_CHECKED: prop = TypeDescriptor.GetProperties(c)["Checked"]; value = (bool)obj; break; case __VSMEPROPID.VSMEPROPID_ENABLED: prop = TypeDescriptor.GetProperties(c)["Enabled"]; value = (bool)obj; break; case __VSMEPROPID.VSMEPROPID_VISIBLE: prop = TypeDescriptor.GetProperties(c)["Visible"]; value = (bool)obj; break; case __VSMEPROPID.VSMEPROPID_RADIOCHECK: prop = TypeDescriptor.GetProperties(c)["RadioCheck"]; value = (bool)obj; break; } } catch (Exception e) { //try to get the iuiservice and show the error that we encountered IUIService uiService = (IUIService)GetService(typeof(IUIService)); if (uiService != null) { uiService.ShowError(e, SR.GetString(SR.MenuDesignerInvalidPropertyValue)); } return(NativeMethods.S_FALSE); } //This will call prop.SetValue and push the info onto the undo stack // if (propId != __VSMEPROPID.VSMEPROPID_CAPTION) { try { CommitPropertyChange(c, prop, value); } catch (Exception e) { //try to get the iuiservice and show the error that we encountered IUIService uiService = (IUIService)GetService(typeof(IUIService)); if (uiService != null) { uiService.ShowError(e.InnerException); } return(NativeMethods.S_FALSE); } } return(NativeMethods.S_OK); }
/// <include file='doc\MenuDesigner.uex' path='docs/doc[@for="MenuDesigner.IMIGetProp"]/*' /> /// <devdoc> /// This method is called by the IVsMenuEditor when properties of a particular menu /// item need to be retrieved. /// </devdoc> public int IMIGetProp(int propId, out object pObj) { //make sure we can get a component that is a menuitem //so we can get its' properties... IComponent c = Component; if (!(c is MenuItem)) { pObj = null; return(NativeMethods.S_OK); } MenuItem menuItem = (MenuItem)c; switch (propId) { case __VSMEPROPID.VSMEPROPID_NAME: String name = null; PropertyDescriptor pd = TypeDescriptor.GetProperties(menuItem)["Name"]; if (pd != null) { name = pd.GetValue(menuItem).ToString(); } pObj = name; break; case __VSMEPROPID.VSMEPROPID_CAPTION: pObj = TypeDescriptor.GetProperties(menuItem)["Text"].GetValue(menuItem).ToString(); //passing a 0 length string back into the menu editor if it's not //active will not redraw... so here, we force a repaint, by setting the appropriate item. //This case only surfaces if you "undo" a menu item's text and the menu editor is not active. // if (pObj != null && pObj.ToString().Length == 0) { MenuEditorService menuEdSvc = GetService(typeof(IMenuEditorService)) as MenuEditorService; if (menuEdSvc != null && !menuEdSvc.IsActive()) { menuEdSvc.SetSelection(menuItem); } } break; case __VSMEPROPID.VSMEPROPID_CHECKED: pObj = TypeDescriptor.GetProperties(menuItem)["Checked"].GetValue(menuItem); break; case __VSMEPROPID.VSMEPROPID_ENABLED: pObj = TypeDescriptor.GetProperties(menuItem)["Enabled"].GetValue(menuItem); break; case __VSMEPROPID.VSMEPROPID_VISIBLE: pObj = TypeDescriptor.GetProperties(menuItem)["Visible"].GetValue(menuItem); break; case __VSMEPROPID.VSMEPROPID_RADIOCHECK: pObj = TypeDescriptor.GetProperties(menuItem)["RadioCheck"].GetValue(menuItem); break; default: pObj = null; break; } return(NativeMethods.S_OK); }
public void RemoveIndex(PropertyDescriptor property) { BindingListImpl.RemoveIndex(property); }
// this returns an array list of the propertydescriptor arrays, one for each // component // private static ArrayList GetCommonProperties(object[] objs, bool presort, PropertyTab tab, GridEntry parentEntry) { PropertyDescriptorCollection[] propCollections = new PropertyDescriptorCollection[objs.Length]; Attribute[] attrs = new Attribute[parentEntry.BrowsableAttributes.Count]; parentEntry.BrowsableAttributes.CopyTo(attrs, 0); for (int i = 0; i < objs.Length; i++) { PropertyDescriptorCollection pdc = tab.GetProperties(parentEntry, objs[i], attrs); if (presort) { pdc = pdc.Sort(PropertyComparer); } propCollections[i] = pdc; } ArrayList mergedList = new ArrayList(); PropertyDescriptor[] matchArray = new PropertyDescriptor[objs.Length]; // // Merge the property descriptors // int[] posArray = new int[propCollections.Length]; for (int i = 0; i < propCollections[0].Count; i++) { PropertyDescriptor pivotDesc = propCollections[0][i]; bool match = pivotDesc.Attributes[typeof(MergablePropertyAttribute)].IsDefaultAttribute(); for (int j = 1; match && j < propCollections.Length; j++) { if (posArray[j] >= propCollections[j].Count) { match = false; break; } // check to see if we're on a match // PropertyDescriptor jProp = propCollections[j][posArray[j]]; if (pivotDesc.Equals(jProp)) { posArray[j] += 1; if (!jProp.Attributes[typeof(MergablePropertyAttribute)].IsDefaultAttribute()) { match = false; break; } matchArray[j] = jProp; continue; } int jPos = posArray[j]; jProp = propCollections[j][jPos]; match = false; // if we aren't on a match, check all the items until we're past // where the matching item would be while (PropertyComparer.Compare(jProp, pivotDesc) <= 0) { // got a match! if (pivotDesc.Equals(jProp)) { if (!jProp.Attributes[typeof(MergablePropertyAttribute)].IsDefaultAttribute()) { match = false; jPos++; } else { match = true; matchArray[j] = jProp; posArray[j] = jPos + 1; } break; } // try again jPos++; if (jPos < propCollections[j].Count) { jProp = propCollections[j][jPos]; } else { break; } } // if we got here, there is no match, quit for this guy if (!match) { posArray[j] = jPos; break; } } // do we have a match? if (match) { matchArray[0] = pivotDesc; mergedList.Add(matchArray.Clone()); } } return(mergedList); }
public void ApplySort(PropertyDescriptor property, ListSortDirection direction) { BindingListImpl.ApplySort(property, direction); }
public void AddIndex(PropertyDescriptor property) { }
// Reminder: We set control.Parent so that it gets serialized for Undo/Redo // private void Paste(object sender, EventArgs args) { IDesignerSerializationService stateSerializer = GetService(typeof(IDesignerSerializationService)) as IDesignerSerializationService; ISelectionService selection = GetService(typeof(ISelectionService)) as ISelectionService; IDesignerHost host = GetService(typeof(IDesignerHost)) as IDesignerHost; IComponentChangeService changeService = GetService(typeof(IComponentChangeService)) as IComponentChangeService; if (host == null || stateSerializer == null) { return; } // // TODO: MWF X11 doesn't seem to support custom clipboard formats - bug #357642 // // IDataObject dataObject = Clipboard.GetDataObject (); // byte[] data = dataObject == null ? null : dataObject.GetData (DT_DATA_FORMAT) as byte[]; // if (data != null) { // MemoryStream stream = new MemoryStream (data); // stateSerializer.Deserialize (new BinaryFormatter().Deserialize (stream)); // ..... // } // if (_clipboard == null) { return; } DesignerTransaction transaction = host.CreateTransaction("Paste"); ICollection components = stateSerializer.Deserialize(_clipboard); // Console.WriteLine ("Pasted components: "); // foreach (object c in components) // Console.WriteLine (((IComponent)c).Site.Name); foreach (object component in components) { Control control = component as Control; if (control == null) { continue; // pure Components are added to the ComponentTray by the DocumentDesigner } PropertyDescriptor parentProperty = TypeDescriptor.GetProperties(control)["Parent"]; if (control.Parent != null) { // Already parented during deserialization? // In that case explicitly raise component changing/ed for the Parent property, // so it get's cought by the UndoEngine if (changeService != null) { changeService.OnComponentChanging(control, parentProperty); changeService.OnComponentChanged(control, parentProperty, null, control.Parent); } } else { ParentControlDesigner parentDesigner = null; if (selection != null && selection.PrimarySelection != null) { parentDesigner = host.GetDesigner((IComponent)selection.PrimarySelection) as ParentControlDesigner; } if (parentDesigner == null) { parentDesigner = host.GetDesigner(host.RootComponent) as DocumentDesigner; } if (parentDesigner != null && parentDesigner.CanParent(control)) { parentProperty.SetValue(control, parentDesigner.Control); } } } _clipboard = null; transaction.Commit(); ((IDisposable)transaction).Dispose(); }
protected override async Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken) { PropertyDescriptor ftpSessionProperty = context.DataContext.GetProperties()[WithFtpSession.FtpSessionPropertyName]; IFtpSession ftpSession = ftpSessionProperty?.GetValue(context.DataContext) as IFtpSession; if (ftpSession == null) { throw new InvalidOperationException(Resources.FTPSessionNotFoundException); } string remotePath = RemotePath.Get(context); string localPath = LocalPath.Get(context); FtpObjectType objectType = await ftpSession.GetObjectTypeAsync(remotePath, cancellationToken); if (objectType == FtpObjectType.Directory) { if (string.IsNullOrWhiteSpace(Path.GetExtension(localPath))) { if (!Directory.Exists(localPath)) { if (Create) { Directory.CreateDirectory(localPath); } else { throw new ArgumentException(string.Format(Resources.PathNotFoundException, localPath)); } } } else { throw new InvalidOperationException(Resources.IncompatiblePathsException); } } else { if (objectType == FtpObjectType.File) { if (string.IsNullOrWhiteSpace(Path.GetExtension(localPath))) { localPath = Path.Combine(localPath, Path.GetFileName(remotePath)); } string directoryPath = Path.GetDirectoryName(localPath); if (!Directory.Exists(directoryPath)) { if (Create) { Directory.CreateDirectory(directoryPath); } else { throw new InvalidOperationException(string.Format(Resources.PathNotFoundException, directoryPath)); } } } else { throw new NotImplementedException(Resources.UnsupportedObjectTypeException); } } await ftpSession.DownloadAsync(remotePath, localPath, Overwrite, Recursive, cancellationToken); return((asyncCodeActivityContext) => { }); }
private JsValue ConstructGrouping(List <BlittableJsonReaderObject> values) { var jsValues = ConstructValues(); var jsKey = ConstructKey(); var result = new ObjectInstance(Engine); result.Set("values", jsValues, false); result.Set("key", jsKey, false); return(result); JsValue ConstructKey() { if (_singleField) { var index = values[0].GetPropertyIndex(_groupByFields[0].Name); if (index != -1) { BlittableJsonReaderObject.PropertyDetails prop = default; values[0].GetPropertyByIndex(index, ref prop); return(JsValue.FromObject(Engine, prop.Value)); } return(JsValue.Null); } var key = new ObjectInstance(Engine); foreach (var groupByField in _groupByFields) { var index = values[0].GetPropertyIndex(groupByField.Name); if (index != -1) { BlittableJsonReaderObject.PropertyDetails prop = default; values[0].GetPropertyByIndex(index, ref prop); var propertyName = groupByField.Name; if (groupByField is JsNestedField jsnf) { propertyName = jsnf.PropertyName; } var value = groupByField.GetValue(null, prop.Value); key.Set(propertyName, JsValue.FromObject(Engine, value), throwOnError: false); } } return(key); } ArrayInstance ConstructValues() { var items = new PropertyDescriptor[values.Count]; for (var i = 0; i < values.Count; i++) { var val = values[i]; if (JavaScriptIndexUtils.GetValue(Engine, val, out var jsValue, isMapReduce: true) == false) { continue; } items[i] = new PropertyDescriptor(jsValue, true, true, true); } var jsArray = new ArrayInstance(Engine, items); jsArray.SetPrototypeOf(Engine.Array.PrototypeObject); jsArray.PreventExtensions(); return(jsArray); } }
public PropertyCompare(PropertyDescriptor property, ListSortDirection direction) { this._property = property; this._direction = direction; }
public ValueSerializer GetValueSerializerFor(PropertyDescriptor descriptor) { return(null); }
/// <summary> /// Returns the property owner</summary> /// <param name="propertyDescriptor">PropertyDescriptor</param> /// <returns>Property owner</returns> public override object GetPropertyOwner(PropertyDescriptor propertyDescriptor) { return(m_propertyOwner); }
/// <summary> /// Make a column from the given PropertyDescriptor /// </summary> /// <param name="pd"></param> /// <returns></returns> public virtual OLVColumn MakeColumnFromPropertyDescriptor(PropertyDescriptor pd) { OLVColumnAttribute attr = pd.Attributes[typeof(OLVColumnAttribute)] as OLVColumnAttribute; return(MakeColumn(pd.Name, DisplayNameToColumnTitle(pd.DisplayName), !pd.IsReadOnly, pd.PropertyType, attr)); }
/// <summary> /// Removes any sort applied with ApplySortCore if sorting is implemented /// </summary> protected override void RemoveSortCore() { _sortDirection = ListSortDirection.Ascending; _sortProperty = null; _isSorted = false; //thanks Luca }
internal void WithField(string name, string jsonPath = null, Type fieldType = null, ChoFieldValueTrimOption fieldValueTrimOption = ChoFieldValueTrimOption.Trim, string fieldName = null, Func <object, object> valueConverter = null, Func <object, object> itemConverter = null, Func <object, object> customSerializer = null, object defaultValue = null, object fallbackValue = null, string fullyQualifiedMemberName = null, string formatText = null, bool?isArray = null, string nullValue = null, Type recordType = null, Type subRecordType = null, Func <JObject, Type> fieldTypeSelector = null) { ChoGuard.ArgumentNotNull(recordType, nameof(recordType)); if (!name.IsNullOrEmpty()) { if (subRecordType != null) { MapRecordFieldsForType(subRecordType); } string fnTrim = fieldName.IsNullOrWhiteSpace() ? name.NTrim() : fieldName; ChoJSONRecordFieldConfiguration fc = null; PropertyDescriptor pd = null; if (JSONRecordFieldConfigurations.Any(o => o.FieldName == fnTrim)) { fc = JSONRecordFieldConfigurations.Where(o => o.FieldName == fnTrim).First(); JSONRecordFieldConfigurations.Remove(fc); pd = ChoTypeDescriptor.GetNestedProperty(recordType, fullyQualifiedMemberName.IsNullOrWhiteSpace() ? name : fullyQualifiedMemberName); } else if (subRecordType != null) { pd = ChoTypeDescriptor.GetNestedProperty(subRecordType, fullyQualifiedMemberName.IsNullOrWhiteSpace() ? name : fullyQualifiedMemberName); } else { pd = ChoTypeDescriptor.GetNestedProperty(recordType, fullyQualifiedMemberName.IsNullOrWhiteSpace() ? name : fullyQualifiedMemberName); } var nfc = new ChoJSONRecordFieldConfiguration(fnTrim, pd != null ? ChoTypeDescriptor.GetPropetyAttribute <ChoJSONRecordFieldAttribute>(pd) : null, pd != null ? pd.Attributes.OfType <Attribute>().ToArray() : null) { }; nfc.JSONPath = !jsonPath.IsNullOrWhiteSpace() ? jsonPath : nfc.JSONPath; nfc.FieldType = fieldType != null ? fieldType : nfc.FieldType; nfc.FieldValueTrimOption = fieldValueTrimOption; nfc.FieldName = fieldName.IsNullOrWhiteSpace() ? (name.IsNullOrWhiteSpace() ? nfc.FieldName : name) : fieldName; nfc.ValueConverter = valueConverter != null ? valueConverter : nfc.ValueConverter; nfc.CustomSerializer = customSerializer != null ? customSerializer : nfc.CustomSerializer; nfc.DefaultValue = defaultValue != null ? defaultValue : nfc.DefaultValue; nfc.FallbackValue = fallbackValue != null ? fallbackValue : nfc.FallbackValue; nfc.FormatText = !formatText.IsNullOrWhiteSpace() ? formatText : nfc.FormatText; nfc.ItemConverter = itemConverter != null ? itemConverter : nfc.ItemConverter; nfc.IsArray = isArray != null ? isArray : nfc.IsArray; nfc.NullValue = !nullValue.IsNullOrWhiteSpace() ? nullValue : nfc.NullValue; nfc.FieldTypeSelector = fieldTypeSelector != null ? fieldTypeSelector : nfc.FieldTypeSelector; if (fullyQualifiedMemberName.IsNullOrWhiteSpace()) { nfc.PropertyDescriptor = fc != null ? fc.PropertyDescriptor : pd; nfc.DeclaringMember = fc != null ? fc.DeclaringMember : fullyQualifiedMemberName; } else { if (subRecordType == null) { pd = ChoTypeDescriptor.GetNestedProperty(recordType, fullyQualifiedMemberName); } else { pd = ChoTypeDescriptor.GetNestedProperty(subRecordType, fullyQualifiedMemberName); } nfc.PropertyDescriptor = pd; nfc.DeclaringMember = fullyQualifiedMemberName; } if (pd != null) { if (nfc.FieldType == null) { nfc.FieldType = pd.PropertyType; } } if (subRecordType == null) { JSONRecordFieldConfigurations.Add(nfc); } else { AddFieldForType(subRecordType, nfc); } } }
private static object GetViaCustomTypeDescriptor(object obj, PropertyDescriptor descriptor) { var customTypeDescriptor = obj as ICustomTypeDescriptor; return(customTypeDescriptor != null?customTypeDescriptor.GetPropertyOwner(descriptor) : obj); }
public object GetPropertyOwner(PropertyDescriptor pd) { return(null); }
public virtual object?GetPropertyOwner(PropertyDescriptor pd) => null;
public void ChangeParent() { Cursor current = Cursor.Current; // create a transaction so this happens as an atomic unit. DesignerTransaction changeParent = _host.CreateTransaction("Add ToolStripContainer Transaction"); try { Cursor.Current = Cursors.WaitCursor; //Add a New ToolStripContainer to the RootComponent ... Control root = _host.RootComponent as Control; if (_host.GetDesigner(root) is ParentControlDesigner rootDesigner) { // close the DAP first - this is so that the autoshown panel on drag drop here is not conflicting with the currently opened panel // if the verb was called from the panel ToolStrip toolStrip = _designer.Component as ToolStrip; if (toolStrip != null && _designer != null && _designer.Component != null && _provider != null) { DesignerActionUIService dapuisvc = _provider.GetService(typeof(DesignerActionUIService)) as DesignerActionUIService; dapuisvc.HideUI(toolStrip); } // Get OleDragHandler ... ToolboxItem tbi = new ToolboxItem(typeof(System.Windows.Forms.ToolStripContainer)); OleDragDropHandler ddh = rootDesigner.GetOleDragHandler(); if (ddh != null) { IComponent[] newComp = ddh.CreateTool(tbi, root, 0, 0, 0, 0, false, false); if (newComp[0] is ToolStripContainer tsc) { if (toolStrip != null) { IComponentChangeService changeSvc = _provider.GetService(typeof(IComponentChangeService)) as IComponentChangeService; Control newParent = GetParent(tsc, toolStrip); PropertyDescriptor controlsProp = TypeDescriptor.GetProperties(newParent)["Controls"]; Control oldParent = toolStrip.Parent; if (oldParent != null) { changeSvc.OnComponentChanging(oldParent, controlsProp); //remove control from the old parent oldParent.Controls.Remove(toolStrip); } if (newParent != null) { changeSvc.OnComponentChanging(newParent, controlsProp); //finally add & relocate the control with the new parent newParent.Controls.Add(toolStrip); } //fire our comp changed events if (changeSvc != null && oldParent != null && newParent != null) { changeSvc.OnComponentChanged(oldParent, controlsProp, null, null); changeSvc.OnComponentChanged(newParent, controlsProp, null, null); } //Set the Selection on the new Parent ... so that the selection is restored to the new item, if (_provider.GetService(typeof(ISelectionService)) is ISelectionService selSvc) { selSvc.SetSelectedComponents(new IComponent[] { tsc }); } } } } } } catch (Exception e) { if (e is System.InvalidOperationException) { IUIService uiService = (IUIService)_provider.GetService(typeof(IUIService)); uiService.ShowError(e.Message); } if (changeParent != null) { changeParent.Cancel(); changeParent = null; } } finally { if (changeParent != null) { changeParent.Commit(); changeParent = null; } Cursor.Current = current; } }
public int Find(PropertyDescriptor property, object key) { return(BindingListImpl.Find(property, key)); }
public void AddIndex(PropertyDescriptor property) { BindingListImpl.AddIndex(property); }