private void SetBeginLayout(InspectorItemRenderer renderer) { if (renderer.horizontalLayout == HorizontalLayout.BeginHorizontal) { EditorGUILayout.BeginHorizontal(); currentLayoutIsHorizontal = true; } if (renderer.verticalLayout == VerticalLayout.BeginVertical) { EditorGUILayout.BeginVertical(); } }
private void SetEndLayout(InspectorItemRenderer renderer) { if (renderer.horizontalLayout == HorizontalLayout.EndHorizontal) { EditorGUILayout.EndHorizontal(); currentLayoutIsHorizontal = false; } if (renderer.verticalLayout == VerticalLayout.EndVertical) { EditorGUILayout.EndVertical(); } }
//// <summary> /// Gets the message renderer for <c>InspectorItemRenderer</c> with the attribute MessageAttribute. /// </summary> /// <returns>The message renderer created to render MessageAttribute in the inspector.</returns> /// <param name="renderer">An item renderer.</param> protected override MessageRenderer GetMessageRenderer(InspectorItemRenderer renderer) { MessageRenderer result = null; MessageAttribute messageAttribute = AttributeHelper.GetAttribute <MessageAttribute>(renderer.entityInfo); if (messageAttribute != null) { result = new MessageRenderer(renderer, subtarget, subtarget, renderers.ToArray()); } return(result); }
public void Render() { bool renderMessage = true; if (!string.IsNullOrEmpty(method)) { MethodInfo methodInfo = caller.GetType().GetMethod(method, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static); if (methodInfo != null) { if (methodInfo.ReturnType == typeof(bool)) { renderMessage = (bool)methodInfo.Invoke(caller, null); } else { Debug.LogError("The method specified in the attribute Message have to return a bool."); } } else { Debug.LogError("The method specified in the attribute Message does not exist."); } } else if (!string.IsNullOrEmpty(id) && value != null) { InspectorItemRenderer conditionalRenderer = LookForRenderer(id); if (conditionalRenderer != null && conditionalRenderer.entityInfo.isField) { if (!value.Equals(conditionalRenderer.entityInfo.fieldInfo.GetValue(classFieldBelongTo))) { renderMessage = false; } } else { Debug.LogWarning("The identifier " + id + " was not found in the list of renderers, or this renderer " + "was not initialized from a field. Ensure that the id parameter of the attribute Visibility refers to the id of a field " + "(name of the field if you did not specify explicitly the id of the field in [Inspector(id = \"...\")."); } } if (renderMessage) { if (!string.IsNullOrEmpty(text)) { EditorGUILayout.HelpBox(text, messageType, true); } } }
/// <summary> /// Looks for renderer in the renderers list based on an id. The default id is the field or the method name of a renderer. /// But this id can be modified with Inspector attribute. /// </summary> /// <returns>The found renderer.</returns> /// <param name="rendererId">Renderer identifier.</param> /// <param name="rendererList">The list of Renderers to look in.</param> public static InspectorItemRenderer LookForRenderer(string rendererId, InspectorItemRenderer[] rendererList) { InspectorItemRenderer result = null; foreach (InspectorItemRenderer renderer in rendererList) { if (renderer.GetIdentifier() == rendererId) { result = renderer; break; } } return(result); }
/// <summary> /// Looks for renderer in the renderers list based on an id. The default id is the field or the method name of a renderer. /// But this id can be modified with Inspector attribute. /// </summary> /// <returns>The for renderer.</returns> /// <param name="rendererId">Renderer identifier.</param> private InspectorItemRenderer LookForRenderer(string rendererId) { InspectorItemRenderer result = null; foreach (InspectorItemRenderer renderer in otherRenderers) { if (renderer.GetIdentifier() == rendererId) { result = renderer; break; } } return(result); }
public VisibilitySetter(InspectorItemRenderer inspectorItemRenderer, object caller, object classFieldBelongTo, InspectorItemRenderer[] otherRenderers = null) { visibilityAttribute = AttributeHelper.GetAttribute <VisibilityAttribute>(inspectorItemRenderer.entityInfo); if (visibilityAttribute != null) { this.method = visibilityAttribute.method; this.id = visibilityAttribute.id; this.value = visibilityAttribute.value; } this.caller = caller; this.classFieldBelongTo = classFieldBelongTo; this.inspectorItemRenderer = inspectorItemRenderer; this.otherRenderers = otherRenderers; }
/// <summary> /// Gets the list of fields to render in inspector interface. /// </summary> /// <param name="target">The targeted object.</param> /// <returns></returns> public static List <InspectorItemRenderer> GetListOfFields(object target, string targetPath = "") { List <InspectorItemRenderer> fieldRenderers = new List <InspectorItemRenderer>(); FieldInfo[] fieldInfos = target.GetType().GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); string currentGroup = ""; foreach (FieldInfo fieldInfo in fieldInfos) { InspectorItemRenderer renderer = null; if (FieldInfoHelper.RenderedByEasyEditor(fieldInfo)) { string propertyPath = ""; if (string.IsNullOrEmpty(targetPath)) { propertyPath = fieldInfo.Name; } else { propertyPath = targetPath + "." + fieldInfo.Name; } renderer = InspectorItemRenderer.GetRendererFromFieldInfo(fieldInfo, propertyPath); } else { InspectorAttribute inspectorAttribute = AttributeHelper.GetAttribute <InspectorAttribute> (fieldInfo); if (inspectorAttribute != null && !FieldInfoHelper.IsSerializedInUnity(fieldInfo)) { Debug.LogWarning("You assigned the attribute" + " [Inspector] to the field " + fieldInfo.Name + " of object " + target.GetType() + " which is not serialized by Unity. EasyEditor will not render it."); } } if (renderer != null) { AssignGroup(renderer, currentGroup); currentGroup = renderer.inspectorAttribute.group; fieldRenderers.Add(renderer); } } return(fieldRenderers); }
/// <summary> /// Gets the list of methods to render in the inspector interface. /// </summary> /// <param name="caller">The caller.</param> /// <returns></returns> public static List <InspectorItemRenderer> GetListOfMethods(object caller) { List <InspectorItemRenderer> methodRenderers = new List <InspectorItemRenderer>(); MethodInfo[] methodInfos = caller.GetType().GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static); foreach (MethodInfo methodInfo in methodInfos) { InspectorItemRenderer renderer = InspectorItemRenderer.GetRendererFromMethodInfo(methodInfo, caller); if (renderer != null) { methodRenderers.Add(renderer); } } return(methodRenderers); }
/// <summary> /// Gets a default renderer for the entity info. Called when no type for the renderer was specified in <c>InspectorAttribute</c> for example /// </summary> /// <returns>The default renderer for the specified entity info.</returns> /// <param name="entityInfo">The entity info which needs a renderer.</param> /// <param name="caller">The object from which the method should be called if entity info is wrapping a methodInfo.</param> static private InspectorItemRenderer GetDefaultRendererFromEntityInfo(EntityInfo entityInfo) { InspectorItemRenderer renderer = null; Type rendererType = null; if (entityInfo.isMethod) { rendererType = Type.GetType("EasyEditor.ButtonRenderer"); } else if (entityInfo.isField) { rendererType = GetDefaultRendererTypeForField(entityInfo.fieldInfo); } renderer = InspectorItemRenderer.GetSpecifiedRendererFromEntityInfo(entityInfo, rendererType); return(renderer); }
/// <summary> /// Gets the list of methods to render in the inspector interface. /// </summary> /// <param name="caller">The caller.</param> /// <returns></returns> public static List <InspectorItemRenderer> GetListOfMethods(object caller, SerializedObject serializedObject, string pathToCaller = null) { List <InspectorItemRenderer> methodRenderers = new List <InspectorItemRenderer>(); BindingFlags flags = (BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static); List <MethodInfo> methodInfos = MethodInfoHelper.GetAllMethodsTillUnityBaseClass(caller.GetType(), flags); foreach (MethodInfo methodInfo in methodInfos) { InspectorItemRenderer renderer = InspectorItemRenderer.GetRendererFromMethodInfo(methodInfo, caller, serializedObject, pathToCaller); if (renderer != null) { methodRenderers.Add(renderer); } } return(methodRenderers); }
//// <summary> /// Gets the message renderer for <c>InspectorItemRenderer</c> with the attribute MessageAttribute. /// </summary> /// <returns>The message renderer created to render MessageAttribute in the inspector.</returns> /// <param name="renderer">An item renderer.</param> /// <param name="contextRenderer">The context in which the renderer is rendered.</param> public static MessageRenderer[] GetMessageRenderers(InspectorItemRenderer renderer, FullObjectRenderer contextRenderer) { List <MessageRenderer> result = new List <MessageRenderer>(); object caller = null; object classFieldBelongTo = null; FullObjectRenderer.GetContextualObjects(renderer, contextRenderer, out caller, out classFieldBelongTo); MessageAttribute[] messageAttributes = AttributeHelper.GetAttributes <MessageAttribute>(renderer.entityInfo); if (messageAttributes != null) { foreach (MessageAttribute messageAttribute in messageAttributes) { result.Add(new MessageRenderer(messageAttribute, caller, classFieldBelongTo, contextRenderer.renderers.ToArray())); } } return(result.ToArray()); }
/// <summary> /// Sets the visibility of a renderer based on the attribute [Visibility(string id, object value)]. If the object with the id 'id' /// has the value 'value', the the renderer holding the attribute is visible, otherwise it is not display in the inspector. /// </summary> private void SetVisibility() { foreach (InspectorItemRenderer renderer in renderers) { FieldInfo fieldInfo = null; if (renderer.entityInfo.isField) { fieldInfo = renderer.entityInfo.fieldInfo; } if (fieldInfo != null) { VisibilityAttribute visibilityAttribute = AttributeHelper.GetAttribute <VisibilityAttribute>(fieldInfo); if (visibilityAttribute != null) { InspectorItemRenderer conditionalRenderer = LookForRenderer(visibilityAttribute.id); if (conditionalRenderer != null && conditionalRenderer.entityInfo.isField) { if (visibilityAttribute.value.Equals(conditionalRenderer.entityInfo.fieldInfo.GetValue(_serializedObject.targetObject))) { ShowRenderer(renderer.GetIdentifier()); } else { HideRenderer(renderer.GetIdentifier()); } } else { Debug.LogWarning("The identifier " + visibilityAttribute.id + " was not found in the list of renderers, or this renderer " + "was not initialized from a field. Ensure that the id parameter of the attribute Visibility refers to the id of a field " + "(name of the field if you did not specify explicitly the id of the field in [Inspector(id = \"...\")."); } } } } }
//// <summary> /// Gets the message renderer for <c>InspectorItemRenderer</c> with the attribute MessageAttribute. /// If the renderer belongs to the editor script, then the method specified in MessageAttribute /// is looked for in the editor script. /// </summary> /// <returns>The message renderer created to render MessageAttribute in the inspector.</returns> /// <param name="renderer">An item renderer.</param> protected override MessageRenderer GetMessageRenderer(InspectorItemRenderer renderer) { MessageRenderer result = null; MessageAttribute messageAttribute = AttributeHelper.GetAttribute <MessageAttribute>(renderer.entityInfo); if (messageAttribute != null) { object caller = serializedObject.targetObject; if (renderer.entityInfo.isMethod) { if (typeof(EasyEditorBase).IsAssignableFrom(renderer.entityInfo.methodInfo.DeclaringType)) { caller = editorScript; } } result = new MessageRenderer(renderer, caller, serializedObject.targetObject, renderers.ToArray()); } return(result); }
/// <summary> /// Gets the message renderer for <c>InspectorItemRenderer</c> with the attribute MessageAttribute. /// Since messages can be displayed based on other fields or condition external to a specific /// InspectorItemRenderer, the renderer in charge of rendering a group of renderers (like ScriptObjectRenderer or /// InlineClassRenderer) needs to implement this function. /// </summary> /// <returns>The message renderer created to render MessageAttribute in the inspector.</returns> /// <param name="renderer">An item renderer.</param> protected virtual MessageRenderer GetMessageRenderer(InspectorItemRenderer renderer) { return(null); }
/// <summary> /// Gets the list of fields to render in inspector interface. /// </summary> /// <param name="target">The targeted object.</param> /// <returns></returns> public static List <InspectorItemRenderer> GetListOfFields(object target, SerializedObject serializedObject, string targetPath = "") { List <InspectorItemRenderer> fieldRenderers = new List <InspectorItemRenderer>(); BindingFlags flags = (BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); IEnumerable <FieldInfo> fieldInfos = FieldInfoHelper.GetAllFieldsTillUnityBaseClass(target.GetType(), flags); string currentGroup = ""; Type currentType = null; IEnumerable <FieldInfo> fieldInfoList = fieldInfos as IList <FieldInfo> ?? fieldInfos.ToList(); if (fieldInfoList.Any()) { currentType = fieldInfoList.First().DeclaringType; } foreach (FieldInfo fieldInfo in fieldInfoList) { InspectorItemRenderer renderer = null; if (FieldInfoHelper.IsSerializedInUnity(fieldInfo)) { string propertyPath = ""; if (string.IsNullOrEmpty(targetPath)) { propertyPath = fieldInfo.Name; } else { propertyPath = targetPath + "." + fieldInfo.Name; } renderer = InspectorItemRenderer.GetRendererFromFieldInfo(fieldInfo, serializedObject, propertyPath); } else { InspectorAttribute inspectorAttribute = AttributeHelper.GetAttribute <InspectorAttribute> (fieldInfo); if (inspectorAttribute != null && !FieldInfoHelper.IsSerializedInUnity(fieldInfo)) { Debug.LogWarning("You assigned the attribute" + " [Inspector] to the field " + fieldInfo.Name + " of object " + target.GetType() + " which is not serialized by Unity. EasyEditor will not render it."); } } if (renderer != null) { if (renderer.entityInfo.fieldInfo.DeclaringType != currentType) { currentGroup = ""; currentType = renderer.entityInfo.fieldInfo.DeclaringType; } AssignGroup(renderer, currentGroup); currentGroup = renderer.inspectorAttribute.group; fieldRenderers.Add(renderer); } } return(fieldRenderers); }
public InspectorItemRenderer LookForRenderer(string id) { return(InspectorItemRenderer.LookForRenderer(id, renderers.ToArray())); }
/// <summary> /// Called when the editor script is enable, usually when it is going to be displayed in the inspector. /// </summary> public void OnEnable() { scriptObjectRenderer = (ScriptObjectRenderer)InspectorItemRenderer.CreateRenderer(typeof(ScriptObjectRenderer)); scriptObjectRenderer.Initialize(this.serializedObject, this); }