private void init(ListlikeAbstractor <T> list, String name, Func <T> createNewCallback, Action <T> removedCallback, Validate validateCallback, MemberScanner memberScanner)
{
this.list = list;
this.createNewCallback = createNewCallback;
this.removedCallback = removedCallback;
this.validateCallback = validateCallback;
//If no member scanner passed, set it to the default one
if (memberScanner == null)
{
memberScanner = ReflectedEditInterface.DefaultScanner;
}
this.memberScanner = memberScanner;
EditablePropertyInfo propertyInfo = new EditablePropertyInfo();
foreach (var item in this.memberScanner.getMatchingMembers(typeof(T)))
{
propertyInfo.addColumn(new EditablePropertyColumn(item.getWrappedName(), false));
}
addPropertyCallback = add;
removePropertyCallback = remove;
setPropertyInfo(propertyInfo);
for (int i = 0; i < list.Count; ++i)
{
addProperty(i);
}
}
/// <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>
/// 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>
/// Save an object to a SaveInfo.
/// </summary>
/// <param name="source">The source object to save.</param>
/// <param name="info">The info to save the object to.</param>
/// <param name="scanner">The MemberScanner to use to save the object.</param>
public static void SaveObject(Object source, SaveInfo info, MemberScanner scanner)
{
foreach (MemberWrapper wrapper in scanner.getMatchingMembers(source.GetType()))
{
info.AddReflectedValue(wrapper.getWrappedName(), wrapper.getValue(source, null), wrapper.getWrappedType());
}
}
/// <summary>
/// This function will provide the customized EditInterface for this
/// class when it is scanned by the ReflectedEditInterface scanner. If
/// it is not scanned with that scanner this function is not
/// automatically called.
/// </summary>
/// <param name="memberName">The name of the member that contains this object.</param>
/// <param name="scanner">The MemberScanner used to scan the parent object.</param>
/// <returns>A new EditInterface for this class.</returns>
public EditInterface getEditInterface(string memberName, MemberScanner scanner)
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(this, BehaviorEditMemberScanner.Scanner, memberName + " - " + this.GetType().Name, null);
customizeEditInterface(editInterface);
}
return(editInterface);
}
public EditInterface getEditInterface(string memberName, MemberScanner scanner)
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(this, scanner, memberName, null);
editInterface.addCommand(new EditInterfaceCommand("Capture Layers", callback => captureState()));
editInterface.addCommand(new EditInterfaceCommand("Preview", callback => apply()));
}
return(editInterface);
}
/// <summary>
/// Restore an object from a LoadInfo.
/// </summary>
/// <param name="source">The object to restore values to.</param>
/// <param name="info">The LoadInfo with the values to restore.</param>
/// <param name="scanner">A MemberScanner to use to restore the object.</param>
public static void RestoreObject(Object source, LoadInfo info, MemberScanner scanner)
{
foreach (MemberWrapper wrapper in scanner.getMatchingMembers(source.GetType()))
{
if (info.hasValue(wrapper.getWrappedName()))
{
wrapper.setValue(source, info.getValueObject(wrapper.getWrappedName()), null);
}
}
}
public EditInterface getEditInterface(string memberName, MemberScanner scanner)
{
if (editInterface == null)
{
editInterface = ReflectedEditInterface.createEditInterface(this, scanner, memberName, null);
editInterface.addCommand(new EditInterfaceCommand("Capture Camera Position", captureCameraPosition));
editInterface.addCommand(new EditInterfaceCommand("Preview", callback =>
{
callback.runOneWayCustomQuery(CustomEditQueries.PreviewCameraPosition, this);
}));
}
return(editInterface);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="target">The target object.</param>
/// <param name="scanner">The MemberScanner to use to learn about target.</param>
public ReflectedObjectEditableProperty(Object target, MemberScanner scanner)
{
this.target = target;
this.memberScanner = scanner;
IEnumerable <MemberWrapper> matches = memberScanner.getMatchingMembers(target.GetType());
variableList = new List <ReflectedVariable>();
foreach (MemberWrapper wrapper in matches)
{
if (ReflectedVariable.canCreateVariable(wrapper.getWrappedType()))
{
variableList.Add(ReflectedVariable.createVariable(wrapper, target));
}
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="name">A name for this interface.</param>
/// <param name="collection">The collection that has the elements this interface will hold.</param>
/// <param name="scanner">A MemberScanner to discover the properties of T with.</param>
public ReflectedCollectionEditInterface(String name, IEnumerable <T> collection, MemberScanner scanner)
{
this.memberScanner = scanner;
this.name = name;
IEnumerable <MemberWrapper> matches = memberScanner.getMatchingMembers(typeof(T));
foreach (MemberWrapper wrapper in matches)
{
if (ReflectedVariable.canCreateVariable(wrapper.getWrappedType()))
{
propertyInfo.addColumn(new EditablePropertyColumn(wrapper.getWrappedName(), false));
}
}
foreach (T item in collection)
{
addItem(item);
}
}
/// <summary>
/// Static constructor.
/// </summary>
static CopyMemberScanner()
{
scanner = new FilteredMemberScanner(new CopyMemberScanner());
}
static ReflectedObjectEditableProperty()
{
sharedScanner = new FilteredMemberScanner(new EditableAttributeFilter());
}
/// <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="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 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, Type startType, MemberScanner scanner, String name, Validate validateCallback)
{
return(createEditInterface(target, startType, scanner, name, validateCallback, DefaultReflectedEditablePropertyProvider.Instance));
}
/// <summary>
/// Staic constructor.
/// </summary>
static BehaviorEditMemberScanner()
{
scanner = new FilteredMemberScanner(new BehaviorEditMemberScanner());
}
/// <summary>
/// Create a new instance. The removedCallback and memberScanner are optional, if a member scanner is not provided the ReflectedEditInterface.DefaultScanner
/// will be used.
/// </summary>
/// <param name="list">The list to wrap.</param>
/// <param name="name">The name of the EditInterface created.</param>
/// <param name="createNewCallback">This function is called when a new item is added to the list, it is required.</param>
/// <param name="removedCallback">This funciton is called when an item is removed from the list, it can be null.</param>
/// <param name="validateCallback">Optional callback to validate list contents.</param>
/// <param name="memberScanner">The member scanner to use to find items to add to each entry's EditInterface, if null it will be the ReflectedEditInterface.DefaultScanner.</param>
public ReflectedListLikeEditInterface(LinkedList <T> list, String name, Func <T> createNewCallback, Action <T> removedCallback = null, Validate validateCallback = null, MemberScanner memberScanner = null)
: base(name)
{
init(new LinkedListAbstractor <T>(list), name, createNewCallback, removedCallback, validateCallback, memberScanner);
}
/// <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);
}
