public override MemberInfo MapEditorToMember(PropertyEditor editor) { if (this.jointEditors.Contains(editor)) return ReflectionInfo.Property_RigidBody_Joints; else return base.MapEditorToMember(editor); }
public override MemberInfo MapEditorToMember(PropertyEditor editor) { if (editor is SoundEmitterSourcePropertyEditor) return ReflectionInfo.Property_SoundEmitter_Sources; else return base.MapEditorToMember(editor); }
public void ApplyTo(PropertyEditor mainEditor, bool dontCollapse = true) { if (mainEditor == null) return; foreach (GroupedPropertyEditor child in mainEditor.ChildrenDeep.OfType<GroupedPropertyEditor>()) { if (child.Expanded && dontCollapse) continue; child.Expanded = this.IsEditorExpanded(child); } }
public override MemberInfo MapEditorToMember(PropertyEditor editor) { if (editor == this.editorPos) return ReflectionInfo.Property_Transform_RelativePos; else if (editor == this.editorVel) return ReflectionInfo.Property_Transform_RelativeVel; else if (editor == this.editorScale) return ReflectionInfo.Property_Transform_RelativeScale; else if (editor == this.editorAngle) return ReflectionInfo.Property_Transform_RelativeAngle; else if (editor == this.editorAngleVel) return ReflectionInfo.Property_Transform_RelativeAngleVel; else return base.MapEditorToMember(editor); }
public void UpdatePrefabModifiedState(PropertyEditor specificEditor = null) { if (specificEditor == null) { foreach (PropertyEditor editor in this.ChildEditors) { MemberInfo member = this.MapEditorToMember(editor); editor.ValueModified = this.IsMemberInPrefabLinkChanges(member); } } else { MemberInfo member = this.MapEditorToMember(specificEditor); specificEditor.ValueModified = this.IsMemberInPrefabLinkChanges(member); } }
protected override void OnKeyDown(KeyEventArgs e) { base.OnKeyDown(e); if (this.focusEditor != null) { PropertyEditor current = this.focusEditor; while (current != null) { current.OnKeyDown(e); if (e.Handled) { break; } current = current.ParentEditor; } } if (!e.Handled) { if (this.focusEditor != null) { if (e.KeyCode == Keys.Down) { PropertyEditor current = this.focusEditor; PropertyEditor next = this.GetNextFocusEditor(current); if (next == null) { next = current.VisibleChildEditors.FirstOrDefault(); } if (next == null && current.ParentEditor != null) { next = this.GetNextFocusEditor(current.ParentEditor); } next = this.GetFocusReciever(next, true); if (next != null) { next.Focus(); } e.Handled = true; } else if (e.KeyCode == Keys.Up) { PropertyEditor current = this.focusEditor; PropertyEditor prev = this.GetPrevFocusEditor(current); if (prev == null) { prev = current.ParentEditor; } prev = this.GetFocusReciever(prev, false); if (prev != null) { prev.Focus(); } e.Handled = true; } else if (e.KeyCode == Keys.Left) { PropertyEditor current = this.focusEditor; while (current != null) { current = current.ParentEditor; while (current != null && !current.CanGetFocus) { current = current.ParentEditor; } if (current != null) { current.Focus(); break; } } e.Handled = true; } else if (e.KeyCode == Keys.Right) { if (this.focusEditor != null) { if (this.focusEditor is GroupedPropertyEditor) { (this.focusEditor as GroupedPropertyEditor).Expanded = true; } PropertyEditor current = null; current = this.focusEditor.VisibleChildEditors.FirstOrDefault(editor => editor.CanGetFocus); if (current == null) { current = this.focusEditor.GetChildEditorsDeep(true).FirstOrDefault(editor => editor.CanGetFocus); } if (current != null) { current.Focus(); } } e.Handled = true; } else if (e.KeyCode == Keys.PageUp || e.KeyCode == Keys.Home) { if (this.focusEditor.ParentEditor != null) { PropertyEditor current = this.focusEditor.ParentEditor; current = current.VisibleChildEditors.FirstOrDefault(editor => editor.CanGetFocus); if (current != null) { current.Focus(); } } e.Handled = true; } else if (e.KeyCode == Keys.PageDown || e.KeyCode == Keys.End) { if (this.focusEditor.ParentEditor != null) { PropertyEditor current = this.focusEditor.ParentEditor; current = current.VisibleChildEditors.LastOrDefault(editor => editor.CanGetFocus); if (current != null) { current.Focus(); } } e.Handled = true; } } } }
private static string GetEditorId(PropertyEditor editor) { if (editor == null) return ""; return editor.PropertyName + editor.EditedType; }
public PropertyEditingFinishedEventArgs(PropertyEditor editor, object value, FinishReason reason) : base(editor, value) { this.reason = reason; }
public override void ClearContent() { base.ClearContent(); this.otherColEditor = null; }
private void DisposeResourceEditor() { if (this.resourceEditor == null) return; this.RemovePropertyEditor(this.resourceEditor); this.resourceEditor.Dispose(); this.resourceEditor = null; this.resourceType = null; }
protected internal override void OnDragLeave(EventArgs e) { base.OnDragLeave(e); if (this.hoverEditor != null) { this.hoverEditor.OnDragLeave(e); this.hoverEditor = null; } }
protected void UpdateHoverEditor(MouseEventArgs e) { PropertyEditor lastHoverEditor = this.hoverEditor; this.hoverEditor = this.PickEditorAt(e.X, e.Y, true); if (this.hoverEditor == this) this.hoverEditor = null; if (lastHoverEditor != this.hoverEditor && lastHoverEditor != null) lastHoverEditor.OnMouseLeave(EventArgs.Empty); if (lastHoverEditor != this.hoverEditor && this.hoverEditor != null) { // Indent expand button if (this.UseIndentChildExpand) { foreach (PropertyEditor child in this.propertyEditors) { this.IndentChildExpandOnMouseLeave(EventArgs.Empty, child as GroupedPropertyEditor); } } this.hoverEditor.OnMouseEnter(EventArgs.Empty); } }
protected internal override void OnDragEnter(DragEventArgs e) { base.OnDragEnter(e); if (this.hoverEditorLock) { this.hoverEditorLock = false; this.hoverEditor = null; } e.Effect = e.AllowedEffect; // Accept anything to pass it on to children }
public virtual void ConfigureEditor(PropertyEditor editor, object configureData = null) { editor.ConfigureEditor(configureData); }
public ProviderContext(PropertyGrid grid, PropertyEditor editor = null) { this.parentEditor = editor; this.parentGrid = editor != null ? editor.ParentGrid : grid; }
public PropertyEditor CreateEditor(Type baseType, ProviderContext context) { PropertyEditor e = null; // Basic numeric data types if (baseType == typeof(sbyte) || baseType == typeof(byte) || baseType == typeof(short) || baseType == typeof(ushort) || baseType == typeof(int) || baseType == typeof(uint) || baseType == typeof(long) || baseType == typeof(ulong) || baseType == typeof(float) || baseType == typeof(double) || baseType == typeof(decimal)) { e = new NumericPropertyEditor(); } // Basic data type: Boolean else if (baseType == typeof(bool)) { e = new BoolPropertyEditor(); } // Basic data type: Flagged Enum else if (baseType.IsEnum && baseType.GetCustomAttributes(typeof(FlagsAttribute), true).Any()) { e = new FlaggedEnumPropertyEditor(); } // Basic data type: Other Enums else if (baseType.IsEnum) { e = new EnumPropertyEditor(); } // Basic data type: String else if (baseType == typeof(string)) { e = new StringPropertyEditor(); } // IList else if (typeof(System.Collections.IList).IsAssignableFrom(baseType)) { e = new IListPropertyEditor(); } // IList else if (typeof(System.Collections.IDictionary).IsAssignableFrom(baseType)) { e = new IDictionaryPropertyEditor(); } // Unknown data type else { // Ask around if any sub-editor can handle it and choose the most specialized var availSubProviders = from p in this.subProviders where p.IsResponsibleFor(baseType, context) != EditorPriority_None orderby p.IsResponsibleFor(baseType, context) descending select p; IPropertyEditorProvider subProvider = availSubProviders.FirstOrDefault(); if (subProvider != null) { e = subProvider.CreateEditor(baseType, context); e.EditedType = baseType; return(e); } // If not, default to reflection-driven MemberwisePropertyEditor. // Except for MemberInfo types, since we can't edit them in any // meaningful anyway, and they clutter up the grid. if (typeof(MemberInfo).IsAssignableFrom(baseType)) { e = new LabelPropertyEditor(); } else { e = new MemberwisePropertyEditor(); } } e.EditedType = baseType; return(e); }
protected internal override void OnDragOver(DragEventArgs e) { base.OnDragOver(e); PropertyEditor lastHoverEditor = this.hoverEditor; this.hoverEditor = this.PickEditorAt(e.X, e.Y, true); if (this.hoverEditor == this) this.hoverEditor = null; if (lastHoverEditor != this.hoverEditor && lastHoverEditor != null) lastHoverEditor.OnDragLeave(EventArgs.Empty); if (lastHoverEditor != this.hoverEditor && this.hoverEditor != null) { e.Effect = DragDropEffects.None; this.hoverEditor.OnDragEnter(e); } if (this.hoverEditor != null) { this.hoverEditor.OnDragOver(e); } else { e.Effect = DragDropEffects.None; } }
public PropertyEditorValueEventArgs(PropertyEditor editor, object value) { this.editor = editor; this.value = value; }
protected internal override void OnMouseLeave(EventArgs e) { base.OnMouseLeave(e); if (this.hoverEditor != null) { PropertyEditor lastHoverEditor = this.hoverEditor; this.hoverEditor = null; if (lastHoverEditor != this.hoverEditor && lastHoverEditor != null) lastHoverEditor.OnMouseLeave(EventArgs.Empty); } if (this.expandCheckHovered) this.Invalidate(); if (this.activeCheckHovered) this.Invalidate(); this.expandCheckHovered = false; this.expandCheckPressed = false; this.activeCheckHovered = false; this.activeCheckPressed = false; // Indent expand button if (this.UseIndentChildExpand) { foreach (PropertyEditor child in this.propertyEditors) { this.IndentChildExpandOnMouseLeave(e, child as GroupedPropertyEditor); } } }
protected override void BeforeAutoCreateEditors() { base.BeforeAutoCreateEditors(); this.editorPos = this.ParentGrid.CreateEditor((typeof(Vector3)), this); if (this.editorPos != null) { this.editorPos.BeginUpdate(); this.editorPos.Getter = this.PosGetter; this.editorPos.Setter = this.PosSetter; this.editorPos.PropertyName = "Pos"; this.ParentGrid.ConfigureEditor(this.editorPos, new EditorHintAttribute[] { new EditorHintDecimalPlacesAttribute(0), new EditorHintIncrementAttribute(1) }); this.AddPropertyEditor(this.editorPos); this.editorPos.EndUpdate(); } this.editorVel = this.ParentGrid.CreateEditor(typeof(Vector3), this); if (this.editorVel != null) { this.editorVel.BeginUpdate(); this.editorVel.Getter = this.VelGetter; this.editorVel.PropertyName = "Vel"; this.ParentGrid.ConfigureEditor(this.editorVel); this.AddPropertyEditor(this.editorVel); this.editorVel.EndUpdate(); } this.editorScale = this.ParentGrid.CreateEditor(typeof(float), this); if (this.editorScale != null) { this.editorScale.BeginUpdate(); this.editorScale.Getter = this.ScaleGetter; this.editorScale.Setter = this.ScaleSetter; this.editorScale.PropertyName = "Scale"; this.ParentGrid.ConfigureEditor(this.editorScale); this.AddPropertyEditor(this.editorScale); this.editorScale.EndUpdate(); } this.editorAngle = this.ParentGrid.CreateEditor(typeof(float), this); if (this.editorAngle != null) { this.editorAngle.BeginUpdate(); this.editorAngle.Getter = this.AngleGetter; this.editorAngle.Setter = this.AngleSetter; this.editorAngle.PropertyName = "Angle"; this.ParentGrid.ConfigureEditor(this.editorAngle, new EditorHintAttribute[] { new EditorHintDecimalPlacesAttribute(1), new EditorHintIncrementAttribute(1), new EditorHintRangeAttribute(float.MinValue, float.MaxValue, 0.0f, 359.999f) }); this.AddPropertyEditor(this.editorAngle); this.editorAngle.EndUpdate(); } this.editorAngleVel = this.ParentGrid.CreateEditor(typeof(float), this); if (this.editorAngleVel != null) { this.editorAngleVel.BeginUpdate(); this.editorAngleVel.Getter = this.AngleVelGetter; this.editorAngleVel.PropertyName = "AngleVel"; this.ParentGrid.ConfigureEditor(this.editorAngleVel, new[] { new EditorHintIncrementAttribute(0.1f) }); this.AddPropertyEditor(this.editorAngleVel); this.editorAngleVel.EndUpdate(); } this.AddEditorForMember(ReflectionInfo.Property_Transform_DeriveAngle); this.AddEditorForMember(ReflectionInfo.Property_Transform_IgnoreParent); this.editorShowRelative = this.ParentGrid.CreateEditor(typeof(bool), this); if (editorShowRelative != null) { this.editorShowRelative.BeginUpdate(); this.editorShowRelative.Getter = this.ShowRelativeGetter; this.editorShowRelative.Setter = this.ShowRelativeSetter; this.editorShowRelative.PropertyName = "[ Relative values ]"; this.ParentGrid.ConfigureEditor(this.editorShowRelative); this.AddPropertyEditor(this.editorShowRelative); this.editorShowRelative.EndUpdate(); } }
protected void AddPropertyEditor(PropertyEditor editor, PropertyEditor before) { int atIndex = -1; if (before != null && before.ParentEditor == this) { int index = 0; foreach (PropertyEditor child in this.ChildEditors) { if (child == before) { atIndex = index; break; } ++index; } } this.AddPropertyEditor(editor, atIndex); }
private void SetupChildEditors() { this.BeginUpdate(); // Remove the old Resource editor if it doesn't match if (this.resourceEditor != null && this.resourceType != this.EditedType) this.DisposeResourceEditor(); // Add a new Resource editor if we don't have one yet if (this.resourceEditor == null) { this.resourceType = this.EditedType; this.resourceEditor = this.ParentGrid.CreateEditor(this.EditedType, this); this.resourceEditor.Getter = this.GetValue; this.resourceEditor.Setter = v => {}; this.ParentGrid.ConfigureEditor(this.resourceEditor); this.AddPropertyEditor(this.resourceEditor); // If the child editor is a grouped one, expand it immediately after adding // and hide the expand / collapse checkbox. We don't want to expose our wrapper // structure after all. GroupedPropertyEditor group = this.resourceEditor as GroupedPropertyEditor; if (group != null) { group.Expanded = true; group.Hints &= ~HintFlags.HasExpandCheck; } } // Set up a shared Asset editor that will be added or removed on demand if (this.assetEditor == null) { this.assetEditor = new ResourceAssetPropertyEditor(); this.assetEditor.EditedType = this.EditedType; // Needs to match so the forwarded getter's safety check passes this.assetEditor.Getter = this.GetValue; this.assetEditor.Setter = v => {}; this.ParentGrid.ConfigureEditor(this.assetEditor); } this.EndUpdate(); }
protected void AddPropertyEditor(PropertyEditor editor, int atIndex = -1) { if (this.propertyEditors.Contains(editor)) this.propertyEditors.Remove(editor); editor.ParentEditor = this; if (atIndex == -1) this.propertyEditors.Add(editor); else this.propertyEditors.Insert(atIndex, editor); GroupedPropertyEditor groupedEditor = editor as GroupedPropertyEditor; if (groupedEditor != null && groupedEditor.Expanded && !groupedEditor.ContentInitialized) groupedEditor.InitContent(); this.OnEditorAdded(editor); this.UpdateChildGeometry(); editor.ValueChanged += this.OnValueChanged; editor.EditingFinished += this.OnEditingFinished; editor.SizeChanged += this.child_SizeChanged; }
protected override void BeforeAutoCreateEditors() { base.BeforeAutoCreateEditors(); JointInfo joint = this.GetValue().Cast<JointInfo>().FirstOrDefault(); if (joint != null && joint.DualJoint) { if (this.otherColEditor == null) { this.otherColEditor = this.ParentGrid.CreateEditor(typeof(RigidBody), this); this.otherColEditor.Getter = this.CreateOtherColValueGetter(); this.otherColEditor.Setter = this.CreateOtherColValueSetter(); this.otherColEditor.PropertyName = Properties.EditorBaseRes.PropertyName_OtherCollider; this.otherColEditor.PropertyDesc = Properties.EditorBaseRes.PropertyDesc_OtherCollider; this.ParentGrid.ConfigureEditor(this.otherColEditor); this.AddPropertyEditor(this.otherColEditor); } } else if (this.otherColEditor != null) { this.RemovePropertyEditor(this.otherColEditor); this.otherColEditor = null; } }
public void UpdateFrom(PropertyEditor mainEditor) { if (mainEditor == null) return; foreach (GroupedPropertyEditor child in mainEditor.ChildrenDeep.OfType<GroupedPropertyEditor>()) this.SetEditorExpanded(child, child.Expanded); }
public PropertyEditor AddEditorForMember(MemberInfo member, IEnumerable<object> values = null, PropertyEditor replaceOld = null) { if (!(member is FieldInfo) && !(member is PropertyInfo)) { throw new ArgumentException("Only PropertyInfo and FieldInfo members are supported"); } PropertyEditor e; Type editType = ReflectTypeForMember(member, values ?? this.GetValue()); e = this.AutoCreateMemberEditor(member); if (e == null) e = this.ParentGrid.CreateEditor(editType, this); if (e == null) return null; e.BeginUpdate(); { if (member is PropertyInfo) { PropertyInfo property = member as PropertyInfo; e.Getter = this.CreatePropertyValueGetter(property); e.Setter = property.CanWrite ? this.CreatePropertyValueSetter(property) : null; e.PropertyName = property.Name; e.EditedMember = property; e.NonPublic = !this.memberPredicate(property, false); } else if (member is FieldInfo) { FieldInfo field = member as FieldInfo; e.Getter = this.CreateFieldValueGetter(field); e.Setter = this.CreateFieldValueSetter(field); e.PropertyName = field.Name; e.EditedMember = field; e.NonPublic = !this.memberPredicate(field, false); } if (replaceOld != null) { this.AddPropertyEditor(e, replaceOld); this.RemovePropertyEditor(replaceOld); replaceOld.Dispose(); } else { this.AddPropertyEditor(e); } this.ParentGrid.ConfigureEditor(e); } e.EndUpdate(); return e; }
protected override void OnEditorAdded(PropertyEditor editor) { base.OnEditorAdded(editor); this.UpdatePrefabModifiedState(editor); }
protected bool HasPropertyEditor(PropertyEditor editor) { return this.propertyEditors.Contains(editor); }
public PropertyEditor AddEditorForMember(MemberInfo member, IEnumerable <object> values = null, PropertyEditor replaceOld = null) { if (!(member is FieldInfo) && !(member is PropertyInfo)) { throw new ArgumentException("Only PropertyInfo and FieldInfo members are supported"); } PropertyEditor e; Type editType = ReflectTypeForMember(member, values ?? this.GetValue()); e = this.AutoCreateMemberEditor(member); if (e == null) { e = this.ParentGrid.CreateEditor(editType, this); } if (e == null) { return(null); } e.BeginUpdate(); { if (member is PropertyInfo) { PropertyInfo property = member as PropertyInfo; e.Getter = this.CreatePropertyValueGetter(property); e.Setter = property.CanWrite ? this.CreatePropertyValueSetter(property) : null; e.PropertyName = property.Name; e.EditedMember = property; e.NonPublic = !this.memberPredicate(property, false); } else if (member is FieldInfo) { FieldInfo field = member as FieldInfo; e.Getter = this.CreateFieldValueGetter(field); e.Setter = this.CreateFieldValueSetter(field); e.PropertyName = field.Name; e.EditedMember = field; e.NonPublic = !this.memberPredicate(field, false); } if (replaceOld != null) { this.AddPropertyEditor(e, replaceOld); this.RemovePropertyEditor(replaceOld); replaceOld.Dispose(); } else { this.AddPropertyEditor(e); } this.ParentGrid.ConfigureEditor(e); } e.EndUpdate(); return(e); }
private static string GetEditorFullId(PropertyEditor editor) { if (editor == null) return ""; string fullId = ""; while (editor != null) { fullId = GetEditorId(editor) + "/" + fullId; editor = editor.ParentEditor; } return fullId; }
protected virtual void OnEditorAdded(PropertyEditor e) { if (this.EditorAdded != null) this.EditorAdded(this, new PropertyEditorEventArgs(e)); }
protected override void OnEditorRemoving(PropertyEditor editor) { base.OnEditorRemoving(editor); this.UpdatePrefabModifiedState(); }
protected virtual void OnEditorRemoving(PropertyEditor e) { if (this.EditorRemoving != null) this.EditorRemoving(this, new PropertyEditorEventArgs(e)); }
public virtual MemberInfo MapEditorToMember(PropertyEditor editor) { return editor != null ? editor.EditedMember : null; }
protected void RemovePropertyEditor(PropertyEditor editor) { editor.ParentEditor = null; editor.ValueChanged -= this.OnValueChanged; editor.EditingFinished -= this.OnEditingFinished; editor.SizeChanged -= this.child_SizeChanged; this.OnEditorRemoving(editor); this.propertyEditors.Remove(editor); this.UpdateChildGeometry(); }
public override void ConfigureEditor(PropertyEditor editor, object configureData = null) { IEnumerable<EditorHintAttribute> hintOverride = configureData as IEnumerable<EditorHintAttribute>; IEnumerable<EditorHintAttribute> parentHint = null; if (editor.ParentEditor != null) { IEnumerable<EditorHintAttribute> parentHintOverride = editor.ParentEditor.ConfigureData as IEnumerable<EditorHintAttribute>; if (editor.ParentEditor.EditedMember != null) parentHint = EditorHintAttribute.GetAll<EditorHintAttribute>(editor.ParentEditor.EditedMember, parentHintOverride); else parentHint = parentHintOverride; } if (hintOverride == null && parentHint != null) { // No configuration data available? Allow to derive certain types from parent list or dictionary. if (editor.ParentEditor is IListPropertyEditor || editor.ParentEditor is IDictionaryPropertyEditor) { hintOverride = parentHint.Where(a => a is EditorHintDecimalPlacesAttribute || a is EditorHintIncrementAttribute || a is EditorHintRangeAttribute); } // That way we can specify the decimal places of an array of Vector2-structs and actually change those Vector2 editors. } // Invoke the PropertyEditor's configure method base.ConfigureEditor(editor, hintOverride); // Do some final configuration for editors that do not behave as intended by default. if (editor is MemberwisePropertyEditor) { MemberwisePropertyEditor memberEditor = editor as MemberwisePropertyEditor; memberEditor.MemberPredicate = this.EditorMemberPredicate; memberEditor.MemberAffectsOthers = this.EditorMemberAffectsOthers; memberEditor.MemberPropertySetter = this.EditorMemberPropertySetter; memberEditor.MemberFieldSetter = this.EditorMemberFieldSetter; } if (editor is IListPropertyEditor) { IListPropertyEditor listEditor = editor as IListPropertyEditor; listEditor.ListIndexSetter = this.EditorListIndexSetter; } if (editor is IDictionaryPropertyEditor) { IDictionaryPropertyEditor dictEditor = editor as IDictionaryPropertyEditor; dictEditor.DictionaryKeySetter = this.EditorDictionaryKeySetter; } var flagsAttrib = EditorHintAttribute.Get<EditorHintFlagsAttribute>(editor.EditedMember, hintOverride); if (flagsAttrib != null) { editor.ForceWriteBack = (flagsAttrib.Flags & MemberFlags.ForceWriteback) == MemberFlags.ForceWriteback; if ((flagsAttrib.Flags & MemberFlags.ReadOnly) == MemberFlags.ReadOnly) editor.Setter = null; } if (editor is NumericPropertyEditor) { var rangeAttrib = EditorHintAttribute.Get<EditorHintRangeAttribute>(editor.EditedMember, hintOverride); var incAttrib = EditorHintAttribute.Get<EditorHintIncrementAttribute>(editor.EditedMember, hintOverride); var placesAttrib = EditorHintAttribute.Get<EditorHintDecimalPlacesAttribute>(editor.EditedMember, hintOverride); NumericPropertyEditor numEditor = editor as NumericPropertyEditor; if (rangeAttrib != null) { numEditor.ValueBarMaximum = rangeAttrib.ReasonableMaximum; numEditor.ValueBarMinimum = rangeAttrib.ReasonableMinimum; numEditor.Maximum = rangeAttrib.LimitMaximum; numEditor.Minimum = rangeAttrib.LimitMinimum; } if (incAttrib != null) numEditor.Increment = incAttrib.Increment; if (placesAttrib != null) numEditor.DecimalPlaces = placesAttrib.Places; } }
public PropertyEditorEventArgs(PropertyEditor e) { this.editor = e; }