private void OnEditSharedEditors(object sender, EventArgs e)
{
PropertyDescriptor propdef = TypeDescriptor.GetProperties(Control)["RowTemplateList"];
if (propdef == null)
{
return;
}
UITypeEditor editor = (UITypeEditor)propdef.GetEditor(typeof(UITypeEditor));
RuntimeServiceProvider serviceProvider =
new RuntimeServiceProvider(this.Control, this.Component, propdef);
editor.EditValue(serviceProvider, serviceProvider, propdef.GetValue(this.Control));
}
public static object EditValue(this ComponentDesigner designer, object objectToChange, string propName)
{
PropertyDescriptor prop = TypeDescriptor.GetProperties(objectToChange)[propName];
EditorServiceContext context = new EditorServiceContext(designer, prop);
var editor = prop.GetEditor(typeof(System.Drawing.Design.UITypeEditor)) as System.Drawing.Design.UITypeEditor;
object curVal = prop.GetValue(objectToChange);
object newVal = editor.EditValue(context, context, curVal);
if (newVal != curVal)
{
try { prop.SetValue(objectToChange, newVal); }
catch (CheckoutException) { }
}
return(newVal);
}
public void EnsureUITypeEditorForProperty(Type type, string propertyName, Type expectedEditorType)
{
PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(type);
Assert.NotNull(properties);
Assert.NotEmpty(properties);
PropertyDescriptor propertyDescriptor = properties.Find(propertyName, true);
Assert.NotNull(propertyDescriptor);
var editor = propertyDescriptor.GetEditor(typeof(UITypeEditor));
Assert.NotNull(editor);
Assert.Equal(expectedEditorType, editor.GetType());
}
public static void EditValue(IWin32Window owner, object component, string propertyName)
{
PropertyDescriptor prop = TypeDescriptor.GetProperties(component)[propertyName];
if (prop == null) throw new ArgumentException("propertyName");
UITypeEditor editor = (UITypeEditor)prop.GetEditor(typeof(UITypeEditor));
MyHelper ctx = new MyHelper(owner, component, prop);
if (editor != null && editor.GetEditStyle(ctx) == UITypeEditorEditStyle.Modal)
{
object value = prop.GetValue(component);
value = editor.EditValue(ctx, ctx, value);
if (!prop.IsReadOnly)
{
prop.SetValue(component, value);
}
}
}
public static object EditValue(ComponentDesigner designer, object objectToChange, string propName)
{
PropertyDescriptor prop = TypeDescriptor.GetProperties(objectToChange)[propName];
EditorServiceContext context = new EditorServiceContext(designer, prop);
UITypeEditor editor = prop.GetEditor(typeof(UITypeEditor)) as UITypeEditor;
object obj2 = prop.GetValue(objectToChange);
object obj3 = editor.EditValue(context, context, obj2);
if (obj3 != obj2)
{
try {
prop.SetValue(objectToChange, obj3);
}
catch (CheckoutException) {
}
}
return(obj3);
}
private UITypeEditor GetEditor()
{
if (PropertyDescriptor != null)
{
try // can happen, because we are missing some editors
{
if (PropertyDescriptor != null)
{
return((UITypeEditor)PropertyDescriptor.GetEditor(typeof(UITypeEditor)));
}
}
catch
{
// property_grid.ShowError ("Unable to load UITypeEditor for property '" + PropertyDescriptor.Name + "'.");
}
}
return(null);
}
/// <summary>
/// Determines if the descriptor represents an automatic design collection property.
/// </summary>
public static bool IsAutoDesignCollectionProperty(this PropertyDescriptor descriptor)
{
var editor = descriptor.GetEditor(typeof(UITypeEditor));
var converter = descriptor.Converter;
// Descriptor must be using a Collection<T>
var supportedCollectionType = descriptor.IsPropertyTypeGeneric(typeof(Collection <>));
// Descriptor must be using a derivative of Extensibility.DesignCollectionEditor editor,
// or default collection editor, NOT declare an arbitrary one or a derivative of default collection editor
var supportedEditor = ((editor is NuPattern.ComponentModel.Design.DesignCollectionEditor) ||
(editor != null && editor.GetType() == typeof(System.ComponentModel.Design.CollectionEditor)));
// Descriptor must be using a derivative of Extensibility.DesignCollectionConverter,
// or default collection converter, NOT declare an arbitrary one or a derivative of default collection converter
var supportedConverter = ((converter != null && converter.GetType() == typeof(System.ComponentModel.CollectionConverter)) ||
(converter is DesignCollectionConverter));
return(supportedCollectionType && supportedEditor && supportedConverter);
}
/// <summary>
/// Factory method for creating the appropriate drop-down control based on the given property descriptor.
/// If the property descriptor supports a UITypeEditor, a TypeEditorHost will be created with that editor.
/// If not, and the TypeConverver attached to the PropertyDescriptor supports standard values, a
/// TypeEditorHostListBox will be created with this TypeConverter.
/// </summary>
/// <param name="propertyDescriptor">A property descriptor describing the property being set</param>
/// <param name="instance">The object instance being edited</param>
/// <param name="editControlStyle">The type of control to show in the edit area.</param>
/// <returns>A TypeEditorHost instance if the given property descriptor supports it, null otherwise.</returns>
public static new TypeEditorHost Create(PropertyDescriptor propertyDescriptor, object instance, TypeEditorHostEditControlStyle editControlStyle)
{
TypeEditorHost host = null;
if (propertyDescriptor != null)
{
UITypeEditor editor = propertyDescriptor.GetEditor(typeof(UITypeEditor)) as UITypeEditor;
if (editor != null)
{
return(new OnScreenTypeEditorHost(editor, propertyDescriptor, instance, editControlStyle));
}
TypeConverter typeConverter = propertyDescriptor.Converter;
if ((typeConverter != null) && typeConverter.GetStandardValuesSupported(null))
{
host = new OnScreenTypeEditorHostListBox(typeConverter, propertyDescriptor, instance, editControlStyle);
}
}
return(host);
}
public static object EditValue(ComponentDesigner designer, object objectToChange, string propName)
{
PropertyDescriptor item = TypeDescriptor.GetProperties(objectToChange)[propName];
EditorServiceContext editorServiceContext = new EditorServiceContext(designer, item);
UITypeEditor editor = item.GetEditor(typeof(UITypeEditor)) as UITypeEditor;
object @value = item.GetValue(objectToChange);
object obj = editor.EditValue(editorServiceContext, editorServiceContext, @value);
if (obj != @value)
{
try
{
item.SetValue(objectToChange, obj);
}
catch (CheckoutException)
{
}
}
return(obj);
}
public static object EditValue(ComponentDesigner designer, object objectToChange, string propName)
{
PropertyDescriptor property = TypeDescriptor.GetProperties(objectToChange)[propName];
EditorServiceContext editorServiceContext = new EditorServiceContext(designer, property);
UITypeEditor editor = property.GetEditor(typeof(UITypeEditor)) as UITypeEditor;
object obj1 = property.GetValue(objectToChange);
object obj2 = editor.EditValue((ITypeDescriptorContext)editorServiceContext, (IServiceProvider)editorServiceContext, obj1);
if (obj2 != obj1)
{
try
{
property.SetValue(objectToChange, obj2);
}
catch (CheckoutException ex)
{
}
}
return(obj2);
}
public InspectorEditorCell GetEditor(PropertyDescriptor pd)
{
InspectorEditorCell cell = pd.GetEditor(typeof(InspectorEditorCell)) as InspectorEditorCell;
if (cell != null)
{
return(cell);
}
Type editorType = GetEditorType(pd);
if (editorType == null)
{
return(Default);
}
if (typeof(IInspectorEditor).IsAssignableFrom(editorType))
{
if (!typeof(Gtk.Widget).IsAssignableFrom(editorType))
{
throw new Exception("The property editor '" + editorType + "' must be a Gtk Widget");
}
return(Default);
}
cell = cellCache [editorType] as InspectorEditorCell;
if (cell != null)
{
return(cell);
}
if (!typeof(InspectorEditorCell).IsAssignableFrom(editorType))
{
throw new Exception("The property editor '" + editorType + "' must be a subclass of " +
"Stetic.InspectorEditorCell or implement Stetic.IInspectorEditor");
}
cell = (InspectorEditorCell)Activator.CreateInstance(editorType);
cellCache [editorType] = cell;
return(cell);
}
/// <summary>
/// </summary>
/// <param name="designer"></param>
/// <param name="objectToChange"></param>
/// <param name="propName"></param>
/// <returns></returns>
public static object EditValue(ComponentDesigner designer, object objectToChange, string propName)
{
PropertyDescriptor descriptor = TypeDescriptor.GetProperties(objectToChange)[propName];
NuGenCollectionEditorServiceContext context = new NuGenCollectionEditorServiceContext(designer, descriptor);
UITypeEditor editor = descriptor.GetEditor(typeof(UITypeEditor)) as UITypeEditor;
object oldValue = descriptor.GetValue(objectToChange);
object newValue = editor.EditValue(context, context, oldValue);
if (newValue != oldValue)
{
try
{
descriptor.SetValue(objectToChange, newValue);
}
catch (CheckoutException)
{
}
}
return(newValue);
}
/// <summary>
/// Gets a UI type editor for the given property descriptor and context</summary>
/// <param name="descriptor">Property descriptor</param>
/// <param name="context">Type descriptor context</param>
/// <returns>UI type editor for the given property descriptor and context</returns>
public static UITypeEditor GetUITypeEditor(
PropertyDescriptor descriptor,
ITypeDescriptorContext context)
{
UITypeEditor editor = descriptor.GetEditor(typeof(UITypeEditor)) as UITypeEditor;
if (editor == null)
{
if (StandardValuesUIEditor.CanCreateStandardValues(descriptor, context))
{
editor = new StandardValuesUIEditor(descriptor);
}
else
{
Type type = descriptor.PropertyType;
editor = TypeDescriptor.GetEditor(type, typeof(UITypeEditor)) as UITypeEditor;
}
}
return(editor);
}
private void button3_Click(object sender, EventArgs e)
{
//listBox1 is the object containing the collection. Remember, if the collection
//belongs to the class you're editing, you can use this
//Items is the name of the property that is the collection you wish to edit.
PropertyDescriptor pd = TypeDescriptor.GetProperties(settings)["Remotes"];
UITypeEditor editor = (UITypeEditor)pd.GetEditor(typeof(UITypeEditor));
RuntimeServiceProvider serviceProvider = new RuntimeServiceProvider();
editor.EditValue(serviceProvider, serviceProvider, settings.Remotes);
settings.Remotes.WriteXML(settings.PhonebookFilename);
comboBox1.Items.Clear();
foreach (Remote remote in settings.Remotes)
{
comboBox1.Items.Add(remote.Name);
}
if (comboBox1.Items.Count > 0)
{
comboBox1.SelectedIndex = 0;
}
}
/// <summary>
/// Factory method for creating the appropriate drop-down control based on the given property descriptor. Always
/// creates a TypeEditorHost with the TypeEditorHostEditControlStyle.Editable style.
/// </summary>
/// <param name="propertyDescriptor">
/// Property descriptor used to create the drop-down. If the property descriptor supports a UITypeEditor,
/// that will be used first. Otherwise, the type converter will be used.
/// </param>
/// <param name="instance">Instance of the object being edited.</param>
/// <returns>A DropDownControl instance if the given property descriptor supports it, null otherwise.</returns>
internal static TypeEditorHost CreateTypeEditorHost(PropertyDescriptor propertyDescriptor, object instance)
{
TypeEditorHost dropDown = null;
if (propertyDescriptor != null)
{
var uiTypeEditor = propertyDescriptor.GetEditor(typeof(UITypeEditor)) as UITypeEditor;
if (uiTypeEditor != null) // UITypeEditor case
{
dropDown = new TreeGridDesignerInPlaceEditDropDown(uiTypeEditor, propertyDescriptor, instance);
}
else
{
var converter = propertyDescriptor.Converter;
if (converter != null &&
converter.GetStandardValuesSupported(null)) // converter case
{
dropDown = new TreeGridDesignerInPlaceEditCombo(converter, propertyDescriptor, instance);
}
}
}
return(dropDown);
}
public static bool EditValue(IWin32Window owner, object component, string propertyName)
{
PropertyDescriptor prop = TypeDescriptor.GetProperties(component)[propertyName];
if (prop == null)
{
throw new ArgumentException("PropertyName [" + propertyName + "] in object not found.");
}
UITypeEditor editor = (UITypeEditor)prop.GetEditor(typeof(UITypeEditor));
CollectionEditor ctx = new CollectionEditor(owner, component, prop);
if (editor != null && editor.GetEditStyle(ctx) == UITypeEditorEditStyle.Modal)
{
object value = prop.GetValue(component);
value = editor.EditValue(ctx, ctx, value);
if (!prop.IsReadOnly)
{
prop.SetValue(component, value);
return(true);
}
}
return(false);
}
public override object GetEditor(Type editorBaseType)
{
return(_parent.GetEditor(editorBaseType));
}
public override object GetEditor(Type editorBaseType)
{
return(descriptor.GetEditor(editorBaseType));
}
public override object GetEditor(Type editorBaseType)
{
return(prop.GetEditor(editorBaseType));
}
public override object GetEditor(Type editorBaseType)
{
return(_reflectedPropDescriptor.GetEditor(editorBaseType));
}
internal static Control CreateEditorControl(PropertyDescriptor descriptor)
{
if (descriptor == null)
{
throw new ArgumentNullException("descriptor");
}
var propertyType = descriptor.PropertyType;
object editor = null;
try
{
editor = descriptor.GetEditor(typeof(IEditorPartField));
}
catch (Exception e)
{
Logger.WriteException(e);
}
var propName = descriptor.Name;
if (editor != null)
{
var partField = editor as IEditorPartField;
if (partField != null)
{
partField.Options = GetEditorOptionsAttribute(descriptor.Attributes);
partField.TitleContainerCssClass = "sn-iu-label";
partField.TitleCssClass = "sn-iu-title";
partField.DescriptionCssClass = "sn-iu-desc";
partField.ControlWrapperCssClass = "sn-iu-control";
partField.Title = GetDisplayName(descriptor);
partField.Description = GetDescription(descriptor);
partField.EditorPartCssClass = "sn-inputunit ui-helper-clearfix sn-custom-editorpart-text sn-editorpart-" + propName;
partField.PropertyName = propName;
if (propertyType == typeof(bool))
{
partField.EditorPartCssClass = "sn-inputunit ui-helper-clearfix sn-custom-editorpart-boolean sn-editorpart-" + propName;
}
if (typeof(Enum).IsAssignableFrom(propertyType))
{
// TODO: fill the instance of the EditorPart control with datas. Best solution is extend the IEditorPartField interface with Fill method
}
var result = partField as Control;
result.ID = "Custom" + propName;
return(result);
}
}
if (propertyType == typeof(bool))
{
var checkBox = new CheckBoxEditorPartField();
checkBox.ID = "CheckBox" + propName;
checkBox.Options = GetEditorOptionsAttribute(descriptor.Attributes);
checkBox.EditorPartCssClass = "sn-inputunit ui-helper-clearfix sn-custom-editorpart-boolean sn-editorpart-" + propName;
checkBox.Title = GetDisplayName(descriptor);
checkBox.Description = GetDescription(descriptor);
checkBox.TitleContainerCssClass = "sn-iu-label";
checkBox.TitleCssClass = "sn-iu-title";
checkBox.DescriptionCssClass = "sn-iu-desc";
checkBox.ControlWrapperCssClass = "sn-iu-control";
checkBox.PropertyName = propName;
return(checkBox);
}
if (typeof(Enum).IsAssignableFrom(propertyType))
{
ICollection standardValues = descriptor.Converter.GetStandardValues();
if (standardValues != null)
{
var list = new DropDownPartField();
list.ID = "DropDown" + propName;
list.Options = GetEditorOptionsAttribute(descriptor.Attributes);
list.EditorPartCssClass = "sn-inputunit ui-helper-clearfix sn-custom-editorpart-enum sn-editorpart-" + propName;
list.Title = GetDisplayName(descriptor);
list.Description = GetDescription(descriptor);
list.TitleContainerCssClass = "sn-iu-label";
list.TitleCssClass = "sn-iu-title";
list.DescriptionCssClass = "sn-iu-desc";
list.ControlWrapperCssClass = "sn-iu-control";
list.PropertyName = propName;
foreach (object value in standardValues)
{
var resourceKey = String.Concat("Enum-", propName, "-", value.ToString());
var text = ResourceManager.Current.GetStringOrNull("PortletFramework", resourceKey) as string;
if (string.IsNullOrEmpty(text))
{
text = descriptor.Converter.ConvertToString(value);
}
list.Items.Add(new ListItem(text, value.ToString()));
}
return(list);
}
return(null);
}
var textBox = new TextEditorPartField();
textBox.ID = "TextBox" + propName;
textBox.Options = GetEditorOptionsAttribute(descriptor.Attributes);
textBox.EditorPartCssClass = "sn-inputunit ui-helper-clearfix sn-custom-editorpart-text sn-editorpart-" + propName;
textBox.Title = GetDisplayName(descriptor);
textBox.Description = GetDescription(descriptor);
textBox.TitleContainerCssClass = "sn-iu-label";
textBox.TitleCssClass = "sn-iu-title";
textBox.DescriptionCssClass = "sn-iu-desc";
textBox.ControlWrapperCssClass = "sn-iu-control";
textBox.Columns = 30;
textBox.PropertyName = propName;
return(textBox);
}
public override object GetEditor(Type editorBaseType)
{
return(originalPropertyDescriptor.GetEditor(editorBaseType));
//return new MethodEditor();
}
public override object GetEditor(Type editorBaseType)
{
return(m_original.GetEditor(editorBaseType));
}
public override object GetEditor(Type editorBaseType)
{
return(_basePropertyDescriptor.GetEditor(editorBaseType));
}
private UITypeEditor GetActualEditor(ITypeDescriptorContext context)
{
if (context == null)
{
return(actualEditor);
}
XmlPropertySetting setting = (XmlPropertySetting)context.Instance;
//Find property
//setting.Property
//Find type converter
//Convert value
//Find corresponding UITypeEditor
//Edit converted value
if (setting.Property == null)
{
this.actualEditor = null;
return(null);
}
string[] propertyParts = setting.Property.Split('.');
string propertyName;
string className;
if (propertyParts.Length > 1)
{
propertyName = propertyParts[propertyParts.Length - 1];
className = string.Join(".", propertyParts, 0, propertyParts.Length - 1);
}
else
{
MessageBox.Show("Invalid property name. Property consist of type FullName\".\"PropertyName.");
this.actualEditor = null;
return(null);
}
RadProperty prop = RadProperty.FindSafe(className, propertyName);
this.currProperty = prop;
TypeConverter converter;
if (prop != null)
{
converter = TypeDescriptor.GetConverter(prop.PropertyType);
}
else
{
MessageBox.Show("Can't find property " + setting.Property + ". Property " + propertyName + "not registered for RadObject" + className);
this.actualEditor = null;
return(null);
}
this.actualPropertyType = prop.PropertyType;
if (converter == null ||
!converter.CanConvertFrom(typeof(string)) ||
!converter.CanConvertTo(typeof(string)))
{
if (!converter.CanConvertFrom(typeof(string)))
{
MessageBox.Show("Converter can't convert from string");
}
else
if (!converter.CanConvertTo(typeof(string)))
{
MessageBox.Show("Converter can't convert to string");
}
else
{
MessageBox.Show("Converter for type not found");
}
this.actualEditor = null;
return(null);
}
this.actualConverter = converter;
PropertyDescriptor actualProperty = TypeDescriptor.GetProperties(prop.OwnerType).Find(prop.Name, false);
if (actualProperty != null)
{
this.actualEditor = (UITypeEditor)actualProperty.GetEditor(typeof(UITypeEditor));
}
else
{
this.actualEditor = (UITypeEditor)TypeDescriptor.GetEditor(prop.PropertyType, typeof(UITypeEditor));
}
return(actualEditor);
}
/// <summary>
/// Returns an editor for the ValueEditor type</summary>
/// <returns>Editor for the ValueEditor type</returns>
public ValueEditor GetCustomEditor()
{
return(m_descriptor.GetEditor(typeof(ValueEditor)) as ValueEditor);
}
public void Constructor_WithLinkedDatabaseStatus_HlcdFilePathHaveExpectedAttributeValue(bool isLinked)
{
// Setup
var mocks = new MockRepository();
var importHandler = mocks.Stub <IHydraulicLocationConfigurationDatabaseImportHandler>();
mocks.ReplayAll();
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = isLinked
? CreateLinkedHydraulicBoundaryDatabase()
: new HydraulicBoundaryDatabase();
// Call
var properties = new HydraulicBoundaryDatabaseProperties(hydraulicBoundaryDatabase, importHandler);
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
Assert.AreEqual(12, dynamicProperties.Count);
const string expectedCategory = "Algemeen";
PropertyDescriptor hrdFilePathProperty = dynamicProperties[hrdFilePathPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(hrdFilePathProperty,
expectedCategory,
"HRD bestandslocatie",
"Locatie van het HRD bestand.",
true);
PropertyDescriptor hlcdFilePathProperty = dynamicProperties[hlcdFilePathPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(hlcdFilePathProperty,
expectedCategory,
"HLCD bestandslocatie",
"Locatie van het HLCD bestand.",
!isLinked);
if (isLinked)
{
object hlcdFilePathEditor = hlcdFilePathProperty.GetEditor(typeof(UITypeEditor));
Assert.IsInstanceOf <HlcdFileNameEditor>(hlcdFilePathEditor);
}
PropertyDescriptor usePreprocessorClosureProperty = dynamicProperties[usePreprocessorClosurePropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(usePreprocessorClosureProperty,
expectedCategory,
"Gebruik preprocessor sluitregime database",
"Gebruik de preprocessor sluitregime database bij het uitvoeren van een berekening.",
true);
PropertyDescriptor scenarioNameProperty = dynamicProperties[scenarioNamePropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(scenarioNameProperty,
expectedCategory,
"Klimaatscenario",
"Algemene naam van het klimaatscenario.",
true);
PropertyDescriptor yearProperty = dynamicProperties[yearPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(yearProperty,
expectedCategory,
"Zichtjaar",
"Jaartal van het jaar waarop de statistiek van toepassing is.",
true);
PropertyDescriptor scopeProperty = dynamicProperties[scopePropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(scopeProperty,
expectedCategory,
"Toepassingskader",
"Projectkader waarin de statistiek bedoeld is te gebruiken.",
true);
PropertyDescriptor seaLevelProperty = dynamicProperties[seaLevelPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(seaLevelProperty,
expectedCategory,
"Zeewaterstand",
"Klimaatinformatie met betrekking tot de zeewaterstand.",
true);
PropertyDescriptor riverDischargeProperty = dynamicProperties[riverDischargePropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(riverDischargeProperty,
expectedCategory,
"Rivierafvoer",
"Klimaatinformatie met betrekking tot de rivierafvoer.",
true);
PropertyDescriptor lakeLevelProperty = dynamicProperties[lakeLevelPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(lakeLevelProperty,
expectedCategory,
"Meerpeil",
"Klimaatinformatie met betrekking tot het meerpeil/de meerpeilen.",
true);
PropertyDescriptor windDirectionProperty = dynamicProperties[windDirectionPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(windDirectionProperty,
expectedCategory,
"Windrichting",
"Klimaatinformatie met betrekking tot de windrichting.",
true);
PropertyDescriptor windSpeedProperty = dynamicProperties[windSpeedPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(windSpeedProperty,
expectedCategory,
"Windsnelheid",
"Klimaatinformatie met betrekking tot de windsnelheid.",
true);
PropertyDescriptor commentProperty = dynamicProperties[commentPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(commentProperty,
expectedCategory,
"Overig",
"Overige informatie.",
true);
}
private UITypeEditor GetActualEditor(ITypeDescriptorContext context)
{
if (context == null)
{
return(this.actualEditor);
}
XmlPropertySetting instance = (XmlPropertySetting)context.Instance;
if (instance.Property == null)
{
this.actualEditor = (UITypeEditor)null;
return((UITypeEditor)null);
}
string[] strArray = instance.Property.Split('.');
if (strArray.Length > 1)
{
string propertyName = strArray[strArray.Length - 1];
string className = string.Join(".", strArray, 0, strArray.Length - 1);
RadProperty safe = RadProperty.FindSafe(className, propertyName);
this.currProperty = safe;
if (safe != null)
{
TypeConverter converter = TypeDescriptor.GetConverter(safe.PropertyType);
this.actualPropertyType = safe.PropertyType;
if (converter == null || !converter.CanConvertFrom(typeof(string)) || !converter.CanConvertTo(typeof(string)))
{
if (!converter.CanConvertFrom(typeof(string)))
{
int num1 = (int)MessageBox.Show("Converter can't convert from string");
}
else if (!converter.CanConvertTo(typeof(string)))
{
int num2 = (int)MessageBox.Show("Converter can't convert to string");
}
else
{
int num3 = (int)MessageBox.Show("Converter for type not found");
}
this.actualEditor = (UITypeEditor)null;
return((UITypeEditor)null);
}
this.actualConverter = converter;
PropertyDescriptor propertyDescriptor = TypeDescriptor.GetProperties(safe.OwnerType).Find(safe.Name, false);
this.actualEditor = propertyDescriptor == null ? (UITypeEditor)TypeDescriptor.GetEditor(safe.PropertyType, typeof(UITypeEditor)) : (UITypeEditor)propertyDescriptor.GetEditor(typeof(UITypeEditor));
return(this.actualEditor);
}
int num = (int)MessageBox.Show("Can't find property " + instance.Property + ". Property " + propertyName + "not registered for RadObject" + className);
this.actualEditor = (UITypeEditor)null;
return((UITypeEditor)null);
}
int num4 = (int)MessageBox.Show("Invalid property name. Property consist of type FullName\".\"PropertyName.");
this.actualEditor = (UITypeEditor)null;
return((UITypeEditor)null);
}
