/// <summary>
/// Alert this edit interface that its data contents have changed. This will check to see
/// that the editInterface this is called on is not null before executing.
/// </summary>
/// <param name="editInterface">The Edit Interface. Can be null.</param>
public static void safeAlertDataContentsChanged(this EditInterface editInterface)
{
if (editInterface != null)
{
editInterface.alertDataContentsChanged();
}
}
/// <summary>
/// This extension method allows an easy way to fire the
/// DataNeedsRefresh function without having to check for null in the
/// client code.
/// </summary>
/// <param name="editInterface">The Edit Interface. Can be null.</param>
public static void safeFireDataNeedsRefresh(this EditInterface editInterface)
{
if (editInterface != null)
{
editInterface.fireDataNeedsRefresh();
}
}
/// <summary>
/// Alert a sub interface on this specififed by key edit interface that its data contents have changed.
/// This will check to see that the editInterface this is called on is not null before executing.
/// </summary>
/// <param name="parentInterface">The parent edit interface. Can be null.</param>
/// <param name="key">The key for the sub interface.</param>
public static void safeAlertSubInterfaceDataContentsChanged(this EditInterface parentInterface, Object key)
{
if (parentInterface != null)
{
parentInterface.getEditInterfaceFor(key).safeAlertDataContentsChanged();
}
}
/// <summary>
/// Create a new EditInterface and add the properties discovered by
/// scanner. A new one is created every time this function is called.
/// </summary>
/// <param name="target">The target object to scan.</param>
/// <param name="scanner">The scanner to use.</param>
/// <param name="name">The name of the EditInterface.</param>
/// <param name="validateCallback">A callback to set for validating.</param>
/// <returns>A new EditInterface from the scanned info.</returns>
public static EditInterface createEditInterface(Object target, MemberScanner scanner, String name, Validate validateCallback, ReflectedEditablePropertyProvider customPropProvider)
{
EditInterface edit = buildInterface(name, validateCallback);
addProperties(scanner, target, target.GetType(), edit, customPropProvider);
return(edit);
}
/// <summary>
/// Safe version of removeSubInterface. Will check for the calling object to be null first. Will first find the
/// SubEditInterface specified by key and then remove value from it.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="editInterface"></param>
/// <param name="value"></param>
/// <param name="key"></param>
public static void safeRemoveSubInterfaceForObject <T>(this EditInterface editInterface, Object key, T value)
where T : class
{
if (editInterface != null)
{
editInterface.getEditInterfaceFor(key).removeSubInterface <T>(value);
}
}
/// <summary>
/// Safe version of addSubInterface. Will check for the calling object to be null first.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="editInterface"></param>
/// <param name="value"></param>
public static void safeAddSubInterface <T>(this EditInterface editInterface, T value)
where T : class
{
if (editInterface != null)
{
editInterface.addSubInterface <T>(value);
}
}
/// <summary>
/// Safe version of removeSubInterface. Will check for the calling object to be null first.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="editInterface"></param>
/// <param name="key"></param>
public static void safeRemoveSubInterface <T>(this EditInterface editInterface, T key)
where T : class
{
if (editInterface != null)
{
editInterface.removeSubInterface <T>(key);
}
}
/// <summary>
/// Add an EditInterface below this one.
/// </summary>
/// <param name="editInterface">The subinterface to add.</param>
public void addSubInterface(EditInterface editInterface)
{
subInterfaces.AddLast(editInterface);
editInterface.ParentEditInterface = this;
if (OnSubInterfaceAdded != null)
{
OnSubInterfaceAdded.Invoke(editInterface);
}
}
/// <summary>
/// Add a SubEditInteface for a particluar object. This is most useful to bind to say a list
/// instance or other value that will not change inside the client object, but the contents might
/// that you might need to refresh. You could also use it to key a SubEditInterface to an object.
/// </summary>
/// <param name="fieldObject">The field's current value.</param>
/// <param name="editInterface">The EditInteface to bind to that fields value.</param>
public void addSubInterfaceForObject(Object fieldObject, EditInterface editInterface)
{
if (objectSubInterfaces == null)
{
objectSubInterfaces = new Dictionary <object, EditInterface>();
}
objectSubInterfaces.Add(fieldObject, editInterface);
addSubInterface(editInterface);
}
/// <summary>
/// Add a subinterface bound to source.
/// </summary>
/// <param name="source">The class that provided the subinterface.</param>
/// <param name="subInterface">The subinterface to bind to source.</param>
public void addSubInterface(T source, EditInterface subInterface)
{
editInterface.addSubInterface(subInterface);
subInterface.ManagerBinding = source;
interfaceDictionary.Add(source, subInterface);
foreach (EditInterfaceCommand command in commandList)
{
subInterface.addCommand(command);
}
}
/// <summary>
/// Get the edit interface for a given key, if the key does not have an associated EditInterface null
/// will be returned.
/// </summary>
/// <param name="key">The key to lookup.</param>
/// <returns>The associated EditInterface or null if there isn't one.</returns>
public EditInterface getEditInterfaceFor(Object key)
{
EditInterface ret = null;
if (objectSubInterfaces != null)
{
objectSubInterfaces.TryGetValue(key, out ret);
}
return(ret);
}
/// <summary>
/// Build the EditInterface for the given type.
/// </summary>
/// <param name="name">The name to use.</param>
/// <param name="target">The target object.</param>
/// <param name="validateCallback">Validate callback.</param>
/// <returns>An EditInterface for the specific object.</returns>
private static EditInterface buildInterface(String name, Validate validateCallback)
{
EditInterface createdInterface = new EditInterface(name, null, null, validateCallback);
EditablePropertyInfo propertyInfo = new EditablePropertyInfo();
propertyInfo.addColumn(new EditablePropertyColumn("Name", true));
propertyInfo.addColumn(new EditablePropertyColumn("Value", false));
createdInterface.setPropertyInfo(propertyInfo);
return(createdInterface);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="editInterface">The EditInterface to manage subinterfaces for.</param>
/// <param name="createEditInterface">The function to call to create EditInterfaces for T types.</param>
/// <param name="items">The initial list of items, can be null.</param>
internal EditInterfaceManager(EditInterface editInterface, CreateEditInterfaceDelegate createEditInterface, IEnumerable <T> items)
: this(editInterface)
{
this.createEditInterface = createEditInterface;
if (items != null)
{
foreach (var item in items)
{
addItem(item);
}
}
}
/// <summary>
/// Remove a sub interface.
/// </summary>
/// <param name="editInterface">The subinterface to remove.</param>
public void removeSubInterface(EditInterface editInterface)
{
if (subInterfaces.Remove(editInterface))
{
if (objectSubInterfaces != null)
{
//Reverse lookup editInterface in case it is part of the objectSubInterfaces.
KeyValuePair <Object, EditInterface> fieldRef = objectSubInterfaces.FirstOrDefault(i => i.Value == editInterface);
if (fieldRef.Key != null)
{
objectSubInterfaces.Remove(fieldRef.Key);
}
}
editInterface.ParentEditInterface = null;
if (OnSubInterfaceRemoved != null)
{
OnSubInterfaceRemoved.Invoke(editInterface);
}
}
}
/// <summary>
/// Add values to an edit interface.
/// </summary>
/// <param name="target"></param>
/// <param name="target">The target object.</param>
/// <param name="startType">The type to start the scan on. Can be used to specify something higher than the target's type up the hierarchy.</param>
/// <param name="scanner">The MemberScanner to use.</param>
/// <param name="edit">The EditInterface that accepts name/value pair properties to add properties to.</param>
public static void expandEditInterface(Object target, Type startType, MemberScanner scanner, EditInterface edit, ReflectedEditablePropertyProvider customPropProvider)
{
addProperties(scanner, target, startType, edit, customPropProvider);
}
/// <summary>
/// Add values to an edit interface.
/// </summary>
/// <param name="target"></param>
/// <param name="target">The target object.</param>
/// <param name="startType">The type to start the scan on. Can be used to specify something higher than the target's type up the hierarchy.</param>
/// <param name="scanner">The MemberScanner to use.</param>
/// <param name="edit">The EditInterface that accepts name/value pair properties to add properties to.</param>
public static void expandEditInterface(Object target, Type startType, MemberScanner scanner, EditInterface edit)
{
expandEditInterface(target, startType, scanner, edit, DefaultReflectedEditablePropertyProvider.Instance);
}
public ReflectedListItemEditableProperty(EditInterface rowEditInterface)
{
this.rowEditInterface = rowEditInterface;
}
/// <summary>
/// Find the key object for the given sub edit interface. You must define a EditInterfaceManager for type T before calling this function
/// or it will throw an exception.
/// </summary>
/// <typeparam name="T">The type of the key object. Must match the type defined for the EditInterfaceManager.</typeparam>
/// <param name="subInterface">The EditInterface to lookup.</param>
/// <returns></returns>
public T resolveSourceObject <T>(EditInterface subInterface)
where T : class
{
return(getEditInterfaceManager <T>().resolveSourceObject(subInterface));
}
/// <summary>
/// Create an empty EditInterface appropriate to use with the ReflectedEditInterface.
/// </summary>
/// <param name="name">The name of the interface.</param>
/// <param name="validateCallback">A validation callback.</param>
/// <returns>A new EditInterface.</returns>
public static EditInterface createUnscannedEditInterface(String name, Validate validateCallback)
{
EditInterface edit = buildInterface(name, validateCallback);
return(edit);
}
/// <summary>
/// Find the source object that was used to create the given EditInterface.
/// </summary>
/// <param name="subInterface">The EditInterface to discover the creator of.</param>
/// <returns>The creator of subInterface according to this binding.</returns>
public T resolveSourceObject(EditInterface subInterface)
{
return(subInterface.ManagerBinding as T);
}
/// <summary>
/// Add properties to an existing EditInterface.
/// </summary>
/// <param name="scanner"></param>
/// <param name="target"></param>
/// <param name="edit"></param>
private static void addProperties(MemberScanner scanner, Object target, Type startType, EditInterface edit, ReflectedEditablePropertyProvider customPropProvider)
{
IEnumerable <MemberWrapper> members = scanner.getMatchingMembers(startType);
foreach (MemberWrapper memberWrapper in members)
{
if (!customPropProvider.addProperties(memberWrapper, target, edit))
{
EditableAttribute editable = findEditableAttribute(memberWrapper);
bool addAsProperty = (editable != null && editable.ForceAsProperty) || ReflectedVariable.canCreateVariable(memberWrapper.getWrappedType());
if (addAsProperty)
{
edit.addEditableProperty(editable.createEditableProperty(memberWrapper, target));
}
else
{
Object subObject = memberWrapper.getValue(target, null);
if (subObject is EditInterfaceOverride)
{
EditInterfaceOverride custom = (EditInterfaceOverride)subObject;
edit.addSubInterface(custom.getEditInterface(memberWrapper.getWrappedName(), scanner));
}
else if (subObject != null)
{
edit.addSubInterface(createEditInterface(subObject, scanner, memberWrapper.getWrappedName() + " - " + memberWrapper.getWrappedType(), null));
}
}
}
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="editInterface">The EditInterface to manage subinterfaces for.</param>
internal EditInterfaceManager(EditInterface editInterface)
{
this.editInterface = editInterface;
}
public EditablePropertyManager(EditInterface editInterface)
{
this.editInterface = editInterface;
}
/// <summary>
/// Add a keyed sub edit interface. You must define a EditInterfaceManager for type T before calling this function
/// or it will throw an exception.
/// </summary>
/// <typeparam name="T">The type of the key.</typeparam>
/// <param name="key">The key value.</param>
/// <param name="subInterface">The subInterface to add.</param>
public void addSubInterface <T>(T key, EditInterface subInterface)
where T : class
{
getEditInterfaceManager <T>().addSubInterface(key, subInterface);
}