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); }