public void HandleDrawnType(Type drawnType, Type propertyType, FieldInfo field, PropertyAttribute attribute) { Type drawerTypeForType = ScriptAttributeUtility.GetDrawerTypeForType(drawnType); if (drawerTypeForType != null) { if (typeof(PropertyDrawer).IsAssignableFrom(drawerTypeForType)) { if (propertyType != null && propertyType.IsArrayOrList()) { return; } this.m_PropertyDrawer = (PropertyDrawer)Activator.CreateInstance(drawerTypeForType); this.m_PropertyDrawer.m_FieldInfo = field; this.m_PropertyDrawer.m_Attribute = attribute; } else if (typeof(DecoratorDrawer).IsAssignableFrom(drawerTypeForType)) { if (field != null && field.FieldType.IsArrayOrList() && !propertyType.IsArrayOrList()) { return; } DecoratorDrawer decoratorDrawer = (DecoratorDrawer)Activator.CreateInstance(drawerTypeForType); decoratorDrawer.m_Attribute = attribute; if (this.m_DecoratorDrawers == null) { this.m_DecoratorDrawers = new List <DecoratorDrawer>(); } this.m_DecoratorDrawers.Add(decoratorDrawer); } } }
public bool CanCacheInspectorGUI(SerializedProperty property) { bool result; if (this.m_DecoratorDrawers != null && !this.isCurrentlyNested) { if (this.m_DecoratorDrawers.Any((DecoratorDrawer decorator) => !decorator.CanCacheInspectorGUI())) { result = false; return(result); } } if (this.propertyDrawer != null) { result = this.propertyDrawer.CanCacheInspectorGUISafe(property.Copy()); } else { property = property.Copy(); SerializedProperty endProperty = property.GetEndProperty(); bool enterChildren = property.isExpanded && EditorGUI.HasVisibleChildFields(property); while (property.NextVisible(enterChildren) && !SerializedProperty.EqualContents(property, endProperty)) { if (!ScriptAttributeUtility.GetHandler(property).CanCacheInspectorGUI(property)) { result = false; return(result); } enterChildren = false; } result = true; } return(result); }
internal void Show(Type requiredType, SerializedProperty property, bool allowSceneObjects, List <int> allowedInstanceIDs = null, Action <UnityObject> onObjectSelectorClosed = null, Action <UnityObject> onObjectSelectedUpdated = null) { if (property == null) { throw new ArgumentNullException(nameof(property)); } if (requiredType == null) { ScriptAttributeUtility.GetFieldInfoFromProperty(property, out requiredType); // case 951876: built-in types do not actually have reflectable fields, so their object types must be extracted from the type string // this works because built-in types will only ever have serialized references to other built-in types, which this window's filter expects as unqualified names if (requiredType == null) { m_RequiredTypes = new string[] { s_MatchPPtrTypeName.Match(property.type).Groups[1].Value } } ; } // Don't select anything on multi selection UnityObject obj = property.hasMultipleDifferentValues ? null : property.objectReferenceValue; UnityObject objectBeingEdited = property.serializedObject.targetObject; m_EditedProperty = property; Show(obj, new Type[] { requiredType }, objectBeingEdited, allowSceneObjects, allowedInstanceIDs, onObjectSelectorClosed, onObjectSelectedUpdated); }
public bool CanCacheInspectorGUI(SerializedProperty property) { if (m_DecoratorDrawers != null && !isCurrentlyNested && m_DecoratorDrawers.Any(decorator => !decorator.CanCacheInspectorGUI())) { return(false); } if (propertyDrawer != null) { return(propertyDrawer.CanCacheInspectorGUISafe(property.Copy())); } property = property.Copy(); SerializedProperty endProperty = property.GetEndProperty(); bool childrenAreExpanded = property.isExpanded && EditorGUI.HasVisibleChildFields(property); // Loop through all child properties while (property.NextVisible(childrenAreExpanded) && !SerializedProperty.EqualContents(property, endProperty)) { if (!ScriptAttributeUtility.GetHandler(property).CanCacheInspectorGUI(property)) { return(false); } childrenAreExpanded = false; } return(true); }
public float GetHeight(SerializedProperty property, GUIContent label, bool includeChildren) { float num = 0f; if (this.m_DecoratorDrawers != null && !this.isCurrentlyNested) { foreach (DecoratorDrawer current in this.m_DecoratorDrawers) { num += current.GetHeight(); } } if (this.propertyDrawer != null) { num += this.propertyDrawer.GetPropertyHeightSafe(property.Copy(), label ?? EditorGUIUtility.TempContent(property.displayName)); } else if (!includeChildren) { num += EditorGUI.GetSinglePropertyHeight(property, label); } else { property = property.Copy(); SerializedProperty endProperty = property.GetEndProperty(); num += EditorGUI.GetSinglePropertyHeight(property, label); bool enterChildren = property.isExpanded && EditorGUI.HasVisibleChildFields(property); while (property.NextVisible(enterChildren) && !SerializedProperty.EqualContents(property, endProperty)) { num += ScriptAttributeUtility.GetHandler(property).GetHeight(property, EditorGUIUtility.TempContent(property.displayName), true); enterChildren = false; num += 2f; } } return(num); }
internal override bool OnOptimizedInspectorGUI(Rect contentRect) { m_SerializedObject.UpdateIfRequiredOrScript(); bool childrenAreExpanded = true; bool wasEnabled = GUI.enabled; var visibleRect = GUIClip.visibleRect; var contentOffset = contentRect.y; if (Event.current.type != EventType.Repaint) { visibleRect = m_LastVisibleRect; } // Release keyboard focus before scrolling so that the virtual scrolling focus wrong control. if (Event.current.type == EventType.ScrollWheel) { GUIUtility.keyboardControl = 0; } var behaviour = target as MonoBehaviour; var property = m_SerializedObject.GetIterator(); var isInspectorModeNormal = inspectorMode == InspectorMode.Normal; using (new UnityEditor.Localization.Editor.LocalizationGroup(behaviour)) { while (property.NextVisible(childrenAreExpanded)) { var handler = ScriptAttributeUtility.GetHandler(property); var hasPropertyDrawer = handler.propertyDrawer != null; childrenAreExpanded = !hasPropertyDrawer && property.isExpanded && EditorGUI.HasVisibleChildFields(property); contentRect.height = handler.GetHeight(property, null, hasPropertyDrawer); if (contentRect.Overlaps(visibleRect)) { EditorGUI.indentLevel = property.depth; using (new EditorGUI.DisabledScope(isInspectorModeNormal && "m_Script" == property.propertyPath)) childrenAreExpanded &= handler.OnGUI(contentRect, property, null, false, visibleRect); } contentRect.y += contentRect.height + EditorGUI.kControlVerticalSpacing; } } // Fix new height if (Event.current.type == EventType.Repaint) { m_LastVisibleRect = visibleRect; var newHeight = contentRect.y - contentOffset; if (newHeight != m_LastHeight) { m_LastHeight = contentRect.y - contentOffset; Repaint(); } } GUI.enabled = wasEnabled; return(m_SerializedObject.ApplyModifiedProperties()); }
internal static PropertyHandler GetHandler(SerializedProperty property) { if (property == null || property.serializedObject.inspectorMode != InspectorMode.Normal) { return(ScriptAttributeUtility.s_SharedNullHandler); } PropertyHandler handler1 = ScriptAttributeUtility.propertyHandlerCache.GetHandler(property); if (handler1 != null) { return(handler1); } System.Type type = (System.Type)null; List <PropertyAttribute> propertyAttributeList = (List <PropertyAttribute>)null; System.Reflection.FieldInfo field = (System.Reflection.FieldInfo)null; UnityEngine.Object targetObject = property.serializedObject.targetObject; if (targetObject is MonoBehaviour || targetObject is ScriptableObject) { field = ScriptAttributeUtility.GetFieldInfoFromProperty(property, out type); propertyAttributeList = ScriptAttributeUtility.GetFieldAttributes(field); } else { if (ScriptAttributeUtility.s_BuiltinAttributes == null) { ScriptAttributeUtility.PopulateBuiltinAttributes(); } if (propertyAttributeList == null) { propertyAttributeList = ScriptAttributeUtility.GetBuiltinAttributes(property); } } PropertyHandler handler2 = ScriptAttributeUtility.s_NextHandler; if (propertyAttributeList != null) { for (int index = propertyAttributeList.Count - 1; index >= 0; --index) { handler2.HandleAttribute(propertyAttributeList[index], field, type); } } if (!handler2.hasPropertyDrawer && type != null) { handler2.HandleDrawnType(type, type, field, (PropertyAttribute)null); } if (handler2.empty) { ScriptAttributeUtility.propertyHandlerCache.SetHandler(property, ScriptAttributeUtility.s_SharedNullHandler); handler2 = ScriptAttributeUtility.s_SharedNullHandler; } else { ScriptAttributeUtility.propertyHandlerCache.SetHandler(property, handler2); ScriptAttributeUtility.s_NextHandler = new PropertyHandler(); } return(handler2); }
internal override bool OnOptimizedInspectorGUI(Rect contentRect) { bool childrenAreExpanded = true; bool wasEnabled = GUI.enabled; var visibleRect = GUIClip.visibleRect; var contentOffset = contentRect.y; if (Event.current.type != EventType.Repaint) { visibleRect = m_LastVisibleRect; } // Release keyboard focus before scrolling so that the virtual scrolling focus wrong control. if (Event.current.type == EventType.ScrollWheel) { GUIUtility.keyboardControl = 0; } contentRect.xMin += InspectorWindow.kInspectorPaddingLeft; contentRect.xMax -= InspectorWindow.kInspectorPaddingRight; var property = m_SerializedObject.GetIterator(); var isInspectorModeNormal = inspectorMode == InspectorMode.Normal; while (property.NextVisible(childrenAreExpanded)) { var handler = ScriptAttributeUtility.GetHandler(property); contentRect.height = handler.GetHeight(property, null, false); if (contentRect.Overlaps(visibleRect)) { EditorGUI.indentLevel = property.depth; using (new EditorGUI.DisabledScope(isInspectorModeNormal && "m_Script" == property.propertyPath)) childrenAreExpanded = handler.OnGUI(contentRect, property, null, false, visibleRect) && property.isExpanded; } else { childrenAreExpanded = property.isExpanded; } contentRect.y += contentRect.height + EditorGUI.kControlVerticalSpacing; } // Fix new height if (Event.current.type == EventType.Repaint) { m_LastVisibleRect = visibleRect; var newHeight = contentRect.y - contentOffset; if (newHeight != m_LastHeight) { m_LastHeight = contentRect.y - contentOffset; Repaint(); } } GUI.enabled = wasEnabled; return(m_SerializedObject.ApplyModifiedProperties()); }
private static System.Reflection.FieldInfo GetFieldInfoFromProperty(SerializedProperty property, out System.Type type) { System.Type typeFromProperty = ScriptAttributeUtility.GetScriptTypeFromProperty(property); if (typeFromProperty != null) { return(ScriptAttributeUtility.GetFieldInfoFromPropertyPath(typeFromProperty, property.propertyPath, out type)); } type = (System.Type)null; return((System.Reflection.FieldInfo)null); }
private static FieldInfo GetFieldInfoFromProperty(SerializedProperty property, out Type type) { Type scriptTypeFromProperty = ScriptAttributeUtility.GetScriptTypeFromProperty(property); if (scriptTypeFromProperty == null) { type = null; return(null); } return(ScriptAttributeUtility.GetFieldInfoFromPropertyPath(scriptTypeFromProperty, property.propertyPath, out type)); }
SelectorHandlerType GetSelectorHandlerFromProperty(SerializedProperty property) { var fieldInfo = ScriptAttributeUtility.GetFieldInfoFromProperty(property, out _); if (fieldInfo == null) { return(null); } return(GetSelectorHandlerFromFieldInfo(fieldInfo)); }
public override VisualElement CreatePropertyGUI(SerializedProperty property) { ScriptAttributeUtility.GetFieldInfoFromProperty(property, out var fieldType); var objectField = EditorUIService.instance.CreateObjectField(); var genericType = fieldType.GetGenericArguments()[0]; EditorUIService.instance.SetObjectField(objectField, property.objectReferenceValue, genericType, property.displayName); objectField.bindingPath = property.propertyPath; return(objectField); }
public override VisualElement CreatePropertyGUI(SerializedProperty property) { ScriptAttributeUtility.GetFieldInfoFromProperty(property, out var fieldType); var objectField = new UnityEditor.UIElements.ObjectField(property.displayName); var genericType = fieldType.GetGenericArguments()[0]; objectField.objectType = genericType; objectField.value = property.objectReferenceValue; objectField.bindingPath = property.propertyPath; return(objectField); }
internal static System.Type GetDrawerTypeForType(System.Type type) { if (ScriptAttributeUtility.s_DrawerTypeForType == null) { ScriptAttributeUtility.BuildDrawerTypeForTypeDictionary(); } ScriptAttributeUtility.DrawerKeySet drawerKeySet; ScriptAttributeUtility.s_DrawerTypeForType.TryGetValue(type, out drawerKeySet); if (drawerKeySet.drawer != null || !type.IsGenericType) { return(drawerKeySet.drawer); } ScriptAttributeUtility.s_DrawerTypeForType.TryGetValue(type.GetGenericTypeDefinition(), out drawerKeySet); return(drawerKeySet.drawer); }
public void HandleDrawnType(SerializedProperty property, Type drawnType, Type propertyType, FieldInfo field, PropertyAttribute attribute) { Type drawerType = ScriptAttributeUtility.GetDrawerTypeForPropertyAndType(property, drawnType); // If we found a drawer type, instantiate the drawer, cache it, and return it. if (drawerType != null) { if (typeof(PropertyDrawer).IsAssignableFrom(drawerType)) { // Use PropertyDrawer on array elements, not on array itself. // If there's a PropertyAttribute on an array, we want to apply it to the individual array elements instead. // This is the only convenient way we can let the user apply PropertyDrawer attributes to elements inside an array. if (propertyType != null && propertyType.IsArrayOrList()) { return; } var propertyDrawerForType = (PropertyDrawer)System.Activator.CreateInstance(drawerType); propertyDrawerForType.m_FieldInfo = field; // Will be null by design if default type drawer! propertyDrawerForType.m_Attribute = attribute; if (m_PropertyDrawers == null) { m_PropertyDrawers = new List <PropertyDrawer>(); } m_PropertyDrawers.Add(propertyDrawerForType); } else if (typeof(DecoratorDrawer).IsAssignableFrom(drawerType)) { // Draw decorators on array itself, not on each array elements if (field != null && field.FieldType.IsArrayOrList() && !propertyType.IsArrayOrList()) { return; } DecoratorDrawer decoratorDrawerForType = (DecoratorDrawer)System.Activator.CreateInstance(drawerType); decoratorDrawerForType.m_Attribute = attribute; if (m_DecoratorDrawers == null) { m_DecoratorDrawers = new List <DecoratorDrawer>(); } m_DecoratorDrawers.Add(decoratorDrawerForType); } } }
internal static FieldInfo GetFieldInfoFromProperty(SerializedProperty property, out Type type) { Type scriptTypeFromProperty = ScriptAttributeUtility.GetScriptTypeFromProperty(property); FieldInfo result; if (scriptTypeFromProperty == null) { type = null; result = null; } else { result = ScriptAttributeUtility.GetFieldInfoFromPropertyPath(scriptTypeFromProperty, property.propertyPath, out type); } return(result); }
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) { System.Type fieldType; ScriptAttributeUtility.GetFieldInfoFromProperty(property, out fieldType); EditorGUI.BeginChangeCheck(); var value = property.objectReferenceValue; position = EditorGUI.PrefixLabel(position, label); value = EditorGUI.ObjectField(position, value, fieldType.GetGenericArguments()[0], false); if (EditorGUI.EndChangeCheck()) { property.objectReferenceValue = value; } }
public float GetHeight(SerializedProperty property, GUIContent label, bool includeChildren) { float height = 0; if (m_DecoratorDrawers != null && !isCurrentlyNested) { foreach (DecoratorDrawer drawer in m_DecoratorDrawers) { height += drawer.GetHeight(); } } if (propertyDrawer != null) { height += propertyDrawer.GetPropertyHeightSafe(property.Copy(), label ?? EditorGUIUtility.TempContent(property.displayName)); } else if (!includeChildren) { height += EditorGUI.GetSinglePropertyHeight(property, label); } else { property = property.Copy(); // First property with custom label height += EditorGUI.GetSinglePropertyHeight(property, label); bool childrenAreExpanded = property.isExpanded && EditorGUI.HasVisibleChildFields(property); // Loop through all child properties var tc = EditorGUIUtility.TempContent(property.displayName); if (childrenAreExpanded) { SerializedProperty endProperty = property.GetEndProperty(); while (property.NextVisible(childrenAreExpanded) && !SerializedProperty.EqualContents(property, endProperty)) { height += ScriptAttributeUtility.GetHandler(property).GetHeight(property, tc, true); childrenAreExpanded = false; height += EditorGUI.kControlVerticalSpacing; } } } return(height); }
public bool CanCacheInspectorGUI(SerializedProperty property) { if (m_DecoratorDrawers != null && !isCurrentlyNested && m_DecoratorDrawers.Any(decorator => !decorator.CanCacheInspectorGUI())) { return(false); } if (propertyDrawer != null) { // Retrieve drawer BEFORE increasing nesting. PropertyDrawer drawer = propertyDrawer; using (var nestingContext = IncrementNestingContext()) { return(drawer.CanCacheInspectorGUISafe(property.Copy())); } } property = property.Copy(); bool childrenAreExpanded = property.isExpanded && EditorGUI.HasVisibleChildFields(property); // Loop through all child properties if (childrenAreExpanded) { PropertyHandler handler = null; SerializedProperty endProperty = property.GetEndProperty(); while (property.NextVisible(childrenAreExpanded) && !SerializedProperty.EqualContents(property, endProperty)) { if (handler == null) { handler = ScriptAttributeUtility.GetHandler(property); } if (!handler.CanCacheInspectorGUI(property)) { return(false); } childrenAreExpanded = false; } } return(true); }
public float GetHeight(SerializedProperty property, GUIContent label, bool includeChildren) { float num1 = 0.0f; if (this.m_DecoratorDrawers != null && !this.isCurrentlyNested) { using (List <DecoratorDrawer> .Enumerator enumerator = this.m_DecoratorDrawers.GetEnumerator()) { while (enumerator.MoveNext()) { DecoratorDrawer current = enumerator.Current; num1 += current.GetHeight(); } } } float num2; if (this.propertyDrawer != null) { num2 = num1 + this.propertyDrawer.GetPropertyHeightSafe(property.Copy(), label ?? EditorGUIUtility.TempContent(property.displayName)); } else if (!includeChildren) { num2 = num1 + EditorGUI.GetSinglePropertyHeight(property, label); } else { property = property.Copy(); SerializedProperty endProperty = property.GetEndProperty(); num2 = num1 + EditorGUI.GetSinglePropertyHeight(property, label); bool enterChildren = property.isExpanded && EditorGUI.HasVisibleChildFields(property); while (property.NextVisible(enterChildren) && !SerializedProperty.EqualContents(property, endProperty)) { float num3 = num2 + ScriptAttributeUtility.GetHandler(property).GetHeight(property, EditorGUIUtility.TempContent(property.displayName), true); enterChildren = false; num2 = num3 + 2f; } } return(num2); }
internal override bool OnOptimizedInspectorGUI(Rect contentRect) { bool childrenAreExpanded = true; bool wasEnabled = GUI.enabled; var visibleRect = GUIClip.visibleRect; var contentOffset = contentRect.y; contentRect.xMin += InspectorWindow.kInspectorPaddingLeft; contentRect.xMax -= InspectorWindow.kInspectorPaddingRight; contentRect.y += EditorGUI.kControlVerticalSpacing; var property = m_SerializedObject.GetIterator(); var isInspectorModeNormal = m_InspectorMode == InspectorMode.Normal; while (property.NextVisible(childrenAreExpanded)) { var handler = ScriptAttributeUtility.GetHandler(property); contentRect.height = handler.GetHeight(property, null, false); if (contentRect.Overlaps(visibleRect)) { EditorGUI.indentLevel = property.depth; using (new EditorGUI.DisabledScope(isInspectorModeNormal && "m_Script" == property.propertyPath)) childrenAreExpanded = handler.OnGUI(contentRect, property, null, false, visibleRect); } else { childrenAreExpanded = property.isExpanded; } contentRect.y += contentRect.height + EditorGUI.kControlVerticalSpacing; } m_LastHeight = contentRect.y - contentOffset; GUI.enabled = wasEnabled; return(m_SerializedObject.ApplyModifiedProperties()); }
internal static Type GetDrawerTypeForType(Type type) { if (ScriptAttributeUtility.s_DrawerTypeForType == null) { ScriptAttributeUtility.BuildDrawerTypeForTypeDictionary(); } ScriptAttributeUtility.DrawerKeySet drawerKeySet; ScriptAttributeUtility.s_DrawerTypeForType.TryGetValue(type, out drawerKeySet); Type drawer; if (drawerKeySet.drawer != null) { drawer = drawerKeySet.drawer; } else { if (type.IsGenericType) { ScriptAttributeUtility.s_DrawerTypeForType.TryGetValue(type.GetGenericTypeDefinition(), out drawerKeySet); } drawer = drawerKeySet.drawer; } return(drawer); }
internal static PropertyHandler GetHandler(SerializedProperty property) { PropertyHandler result; if (property == null) { result = ScriptAttributeUtility.s_SharedNullHandler; } else if (property.serializedObject.inspectorMode != InspectorMode.Normal) { result = ScriptAttributeUtility.s_SharedNullHandler; } else { PropertyHandler handler = ScriptAttributeUtility.propertyHandlerCache.GetHandler(property); if (handler != null) { result = handler; } else { Type type = null; List <PropertyAttribute> list = null; FieldInfo field = null; UnityEngine.Object targetObject = property.serializedObject.targetObject; if (targetObject is MonoBehaviour || targetObject is ScriptableObject) { field = ScriptAttributeUtility.GetFieldInfoFromProperty(property, out type); list = ScriptAttributeUtility.GetFieldAttributes(field); } else { if (ScriptAttributeUtility.s_BuiltinAttributes == null) { ScriptAttributeUtility.PopulateBuiltinAttributes(); } if (list == null) { list = ScriptAttributeUtility.GetBuiltinAttributes(property); } } handler = ScriptAttributeUtility.s_NextHandler; if (list != null) { for (int i = list.Count - 1; i >= 0; i--) { handler.HandleAttribute(list[i], field, type); } } if (!handler.hasPropertyDrawer && type != null) { handler.HandleDrawnType(type, type, field, null); } if (handler.empty) { ScriptAttributeUtility.propertyHandlerCache.SetHandler(property, ScriptAttributeUtility.s_SharedNullHandler); handler = ScriptAttributeUtility.s_SharedNullHandler; } else { ScriptAttributeUtility.propertyHandlerCache.SetHandler(property, handler); ScriptAttributeUtility.s_NextHandler = new PropertyHandler(); } result = handler; } } return(result); }
internal bool OnGUI(Rect position, SerializedProperty property, GUIContent label, bool includeChildren, Rect visibleArea) { float oldLabelWidth, oldFieldWidth; float propHeight = position.height; position.height = 0; if (m_DecoratorDrawers != null && !isCurrentlyNested) { foreach (DecoratorDrawer decorator in m_DecoratorDrawers) { position.height = decorator.GetHeight(); oldLabelWidth = EditorGUIUtility.labelWidth; oldFieldWidth = EditorGUIUtility.fieldWidth; decorator.OnGUI(position); EditorGUIUtility.labelWidth = oldLabelWidth; EditorGUIUtility.fieldWidth = oldFieldWidth; position.y += position.height; propHeight -= position.height; } } position.height = propHeight; if (propertyDrawer != null) { // Remember widths oldLabelWidth = EditorGUIUtility.labelWidth; oldFieldWidth = EditorGUIUtility.fieldWidth; // Draw with custom drawer propertyDrawer.OnGUISafe(position, property.Copy(), label ?? EditorGUIUtility.TempContent(property.localizedDisplayName)); // Restore widths EditorGUIUtility.labelWidth = oldLabelWidth; EditorGUIUtility.fieldWidth = oldFieldWidth; return(false); } else { if (!includeChildren) { return(EditorGUI.DefaultPropertyField(position, property, label)); } // Remember state Vector2 oldIconSize = EditorGUIUtility.GetIconSize(); bool wasEnabled = GUI.enabled; int origIndent = EditorGUI.indentLevel; int relIndent = origIndent - property.depth; SerializedProperty prop = property.Copy(); position.height = EditorGUI.GetSinglePropertyHeight(prop, label); // First property with custom label EditorGUI.indentLevel = prop.depth + relIndent; bool childrenAreExpanded = EditorGUI.DefaultPropertyField(position, prop, label) && EditorGUI.HasVisibleChildFields(prop); position.y += position.height + EditorGUI.kControlVerticalSpacing; // Loop through all child properties if (childrenAreExpanded) { SerializedProperty endProperty = prop.GetEndProperty(); while (prop.NextVisible(childrenAreExpanded) && !SerializedProperty.EqualContents(prop, endProperty)) { var handler = ScriptAttributeUtility.GetHandler(prop); EditorGUI.indentLevel = prop.depth + relIndent; position.height = handler.GetHeight(prop, null, false); if (position.Overlaps(visibleArea)) { EditorGUI.BeginChangeCheck(); childrenAreExpanded = handler.OnGUI(position, prop, null, false) && EditorGUI.HasVisibleChildFields(prop); // Changing child properties (like array size) may invalidate the iterator, // so stop now, or we may get errors. if (EditorGUI.EndChangeCheck()) { break; } } position.y += position.height + EditorGUI.kControlVerticalSpacing; } } // Restore state GUI.enabled = wasEnabled; EditorGUIUtility.SetIconSize(oldIconSize); EditorGUI.indentLevel = origIndent; return(false); } }
internal override bool GetOptimizedGUIBlock(bool isDirty, bool isVisible, out float height) { height = -1; // Don't use optimizedGUI for audio filters var behaviour = target as MonoBehaviour; if (behaviour != null && AudioUtil.HasAudioCallback(behaviour) && AudioUtil.GetCustomFilterChannelCount(behaviour) > 0) { return(false); } if (ObjectIsMonoBehaviourOrScriptableObject(target)) { return(false); } if (isDirty) { ResetOptimizedBlock(); } if (!isVisible) { height = 0; return(true); } // Return cached result if any. if (m_OptimizedBlockState != OptimizedBlockState.CheckOptimizedBlock) { if (m_OptimizedBlockState == OptimizedBlockState.NoOptimizedBlock) { return(false); } height = m_LastHeight; return(true); } // Update serialized object representation if (m_SerializedObject == null) { m_SerializedObject = new SerializedObject(targets, m_Context) { inspectorMode = inspectorMode } } ; else { m_SerializedObject.Update(); m_SerializedObject.inspectorMode = inspectorMode; } height = 0; SerializedProperty property = m_SerializedObject.GetIterator(); bool childrenAreExpanded = true; while (property.NextVisible(childrenAreExpanded)) { var handler = ScriptAttributeUtility.GetHandler(property); height += handler.GetHeight(property, null, false) + EditorGUI.kControlVerticalSpacing; childrenAreExpanded = property.isExpanded && EditorGUI.HasVisibleChildFields(property); } m_LastHeight = height; m_OptimizedBlockState = OptimizedBlockState.HasOptimizedBlock; return(true); }
public float GetHeight(SerializedProperty property, GUIContent label, bool includeChildren) { float height = 0; if (m_DecoratorDrawers != null && !isCurrentlyNested) { foreach (DecoratorDrawer drawer in m_DecoratorDrawers) { height += drawer.GetHeight(); } } if (propertyDrawer != null) { // Retrieve drawer BEFORE increasing nesting. PropertyDrawer drawer = propertyDrawer; using (var nestingContext = IncrementNestingContext()) { height += drawer.GetPropertyHeightSafe(property.Copy(), label ?? EditorGUIUtility.TempContent(property.localizedDisplayName, tooltip)); } } else if (!includeChildren) { height += EditorGUI.GetSinglePropertyHeight(property, label); } else if (UseReorderabelListControl(property)) { ReorderableListWrapper reorderableList; string key = ReorderableListWrapper.GetPropertyIdentifier(property); // If collection doesn't have a ReorderableList assigned to it, create one and assign it if (!s_reorderableLists.TryGetValue(key, out reorderableList)) { reorderableList = new ReorderableListWrapper(property, label, true); s_reorderableLists[key] = reorderableList; } reorderableList.Property = property; height += s_reorderableLists[key].GetHeight(); return(height); } else { property = property.Copy(); // First property with custom label height += EditorGUI.GetSinglePropertyHeight(property, label); bool childrenAreExpanded = property.isExpanded && EditorGUI.HasVisibleChildFields(property); // Loop through all child properties var tc = EditorGUIUtility.TempContent(property.localizedDisplayName, tooltip); if (childrenAreExpanded) { SerializedProperty endProperty = property.GetEndProperty(); while (property.NextVisible(childrenAreExpanded) && !SerializedProperty.EqualContents(property, endProperty)) { height += ScriptAttributeUtility.GetHandler(property).GetHeight(property, tc, true); childrenAreExpanded = false; height += EditorGUI.kControlVerticalSpacing; } } } return(height); }
internal bool OnGUI(Rect position, SerializedProperty property, GUIContent label, bool includeChildren, Rect visibleArea) { TestInvalidateCache(); float oldLabelWidth, oldFieldWidth; float propHeight = position.height; position.height = 0; if (m_DecoratorDrawers != null && !isCurrentlyNested) { foreach (DecoratorDrawer decorator in m_DecoratorDrawers) { position.height = decorator.GetHeight(); oldLabelWidth = EditorGUIUtility.labelWidth; oldFieldWidth = EditorGUIUtility.fieldWidth; decorator.OnGUI(position); EditorGUIUtility.labelWidth = oldLabelWidth; EditorGUIUtility.fieldWidth = oldFieldWidth; position.y += position.height; propHeight -= position.height; } } position.height = propHeight; if (propertyDrawer != null) { // Remember widths oldLabelWidth = EditorGUIUtility.labelWidth; oldFieldWidth = EditorGUIUtility.fieldWidth; // Draw with custom drawer - retrieve it BEFORE increasing nesting. PropertyDrawer drawer = propertyDrawer; using (var nestingContext = IncrementNestingContext()) { drawer.OnGUISafe(position, property.Copy(), label ?? EditorGUIUtility.TempContent(property.localizedDisplayName, tooltip)); } // Restore widths EditorGUIUtility.labelWidth = oldLabelWidth; EditorGUIUtility.fieldWidth = oldFieldWidth; return(false); } else { if (!includeChildren) { return(EditorGUI.DefaultPropertyField(position, property, label)); } if (UseReorderabelListControl(property)) { ReorderableListWrapper reorderableList; string key = ReorderableListWrapper.GetPropertyIdentifier(property); if (!s_reorderableLists.TryGetValue(key, out reorderableList)) { // Manual layout controls don't call GetHeight() method so we need to have a way to initialized list as we prepare to render it here reorderableList = new ReorderableListWrapper(property, label, true); s_reorderableLists[key] = reorderableList; } // Calculate visibility rect specifically for reorderable list as when applied for the whole serialized object, // it causes collapsed out of sight array elements appear thus messing up scroll-bar experience var screenPos = GUIUtility.GUIToScreenPoint(position.position); screenPos.y = Mathf.Clamp(screenPos.y, GUIView.current?.screenPosition.yMin ?? 0, GUIView.current?.screenPosition.yMax ?? Screen.height); Rect listVisibility = new Rect(screenPos.x, screenPos.y, GUIView.current?.screenPosition.width ?? Screen.width, GUIView.current?.screenPosition.height ?? Screen.height); listVisibility = GUIUtility.ScreenToGUIRect(listVisibility); reorderableList.Property = property; reorderableList.Draw(label, position, listVisibility, tooltip, includeChildren); return(!includeChildren && property.isExpanded); } // Remember state Vector2 oldIconSize = EditorGUIUtility.GetIconSize(); bool wasEnabled = GUI.enabled; int origIndent = EditorGUI.indentLevel; int relIndent = origIndent - property.depth; SerializedProperty prop = property.Copy(); position.height = EditorGUI.GetSinglePropertyHeight(prop, label); // First property with custom label EditorGUI.indentLevel = prop.depth + relIndent; bool childrenAreExpanded = EditorGUI.DefaultPropertyField(position, prop, label) && EditorGUI.HasVisibleChildFields(prop); position.y += position.height + EditorGUI.kControlVerticalSpacing; // Loop through all child properties if (childrenAreExpanded) { SerializedProperty endProperty = prop.GetEndProperty(); while (prop.NextVisible(childrenAreExpanded) && !SerializedProperty.EqualContents(prop, endProperty)) { var handler = ScriptAttributeUtility.GetHandler(prop); EditorGUI.indentLevel = prop.depth + relIndent; position.height = handler.GetHeight(prop, null, UseReorderabelListControl(prop) && includeChildren); if (position.Overlaps(visibleArea)) { EditorGUI.BeginChangeCheck(); childrenAreExpanded = handler.OnGUI(position, prop, null, UseReorderabelListControl(prop)) && EditorGUI.HasVisibleChildFields(prop); // Changing child properties (like array size) may invalidate the iterator, // so stop now, or we may get errors. if (EditorGUI.EndChangeCheck()) { break; } } position.y += position.height + EditorGUI.kControlVerticalSpacing; } } // Restore state GUI.enabled = wasEnabled; EditorGUIUtility.SetIconSize(oldIconSize); EditorGUI.indentLevel = origIndent; return(false); } }
internal void Show(UnityObject obj, Type requiredType, SerializedProperty property, bool allowSceneObjects, List <int> allowedInstanceIDs, Action <UnityObject> onObjectSelectorClosed, Action <UnityObject> onObjectSelectedUpdated) { m_ObjectSelectorReceiver = null; m_AllowSceneObjects = allowSceneObjects; m_IsShowingAssets = true; m_SkipHiddenPackages = true; m_AllowedIDs = allowedInstanceIDs; m_OnObjectSelectorClosed = onObjectSelectorClosed; m_OnObjectSelectorUpdated = onObjectSelectedUpdated; if (property != null) { if (requiredType == null) { ScriptAttributeUtility.GetFieldInfoFromProperty(property, out requiredType); // case 951876: built-in types do not actually have reflectable fields, so their object types must be extracted from the type string // this works because built-in types will only ever have serialized references to other built-in types, which this window's filter expects as unqualified names if (requiredType == null) { m_RequiredType = s_MatchPPtrTypeName.Match(property.type).Groups[1].Value; } } obj = property.objectReferenceValue; m_ObjectBeingEdited = property.serializedObject.targetObject; // Do not allow to show scene objects if the object being edited is persistent if (m_ObjectBeingEdited != null && EditorUtility.IsPersistent(m_ObjectBeingEdited)) { m_AllowSceneObjects = false; } } // Set which tab should be visible at startup if (m_AllowSceneObjects) { if (obj != null) { if (typeof(Component).IsAssignableFrom(obj.GetType())) { obj = ((Component)obj).gameObject; } // Set the right tab visible (so we can see our selection) m_IsShowingAssets = EditorUtility.IsPersistent(obj); } else { m_IsShowingAssets = (requiredType != typeof(GameObject) && !typeof(Component).IsAssignableFrom(requiredType)); } } else { m_IsShowingAssets = true; } // Set member variables m_DelegateView = GUIView.current; // type filter requires unqualified names for built-in types, but will prioritize them over user types, so ensure user types are namespace-qualified if (requiredType != null) { m_RequiredType = typeof(ScriptableObject).IsAssignableFrom(requiredType) || typeof(MonoBehaviour).IsAssignableFrom(requiredType) ? requiredType.FullName : requiredType.Name; } m_SearchFilter = ""; m_OriginalSelection = obj; m_ModalUndoGroup = Undo.GetCurrentGroup(); // Freeze to prevent flicker on OSX. // Screen will be updated again when calling // SetFreezeDisplay(false) further down. ContainerWindow.SetFreezeDisplay(true); ShowWithMode(ShowMode.AuxWindow); titleContent = EditorGUIUtility.TrTextContent("Select " + (requiredType == null ? m_RequiredType : requiredType.Name)); // Deal with window size Rect p = m_Parent == null ? new Rect(0, 0, 1, 1) : m_Parent.window.position; p.width = EditorPrefs.GetFloat("ObjectSelectorWidth", 200); p.height = EditorPrefs.GetFloat("ObjectSelectorHeight", 390); position = p; minSize = new Vector2(kMinWidth, kMinTopSize + kPreviewExpandedAreaHeight + 2 * kPreviewMargin); maxSize = new Vector2(10000, 10000); SetupPreview(); // Focus Focus(); ContainerWindow.SetFreezeDisplay(false); m_FocusSearchFilter = true; // Add after unfreezing display because AuxWindowManager.cpp assumes that aux windows are added after we get 'got/lost'- focus calls. if (m_Parent != null) { m_Parent.AddToAuxWindowList(); } // Initial selection int initialSelection = obj != null?obj.GetInstanceID() : 0; if (property != null && property.hasMultipleDifferentValues) { initialSelection = 0; // don't select anything on multi selection } if (initialSelection != 0) { var assetPath = AssetDatabase.GetAssetPath(initialSelection); if (m_SkipHiddenPackages && !PackageManagerUtilityInternal.IsPathInVisiblePackage(assetPath)) { m_SkipHiddenPackages = false; } } if (ShouldTreeViewBeUsed(m_RequiredType)) { m_ObjectTreeWithSearch.Init(position, this, CreateAndSetTreeView, TreeViewSelection, ItemWasDoubleClicked, initialSelection, 0); } else { // To frame the selected item we need to wait to initialize the search until our window has been setup InitIfNeeded(); m_ListArea.InitSelection(new[] { initialSelection }); if (initialSelection != 0) { m_ListArea.Frame(initialSelection, true, false); } } }
private static void PopulateBuiltinAttributes() { ScriptAttributeUtility.s_BuiltinAttributes = new Dictionary <string, List <PropertyAttribute> >(); ScriptAttributeUtility.AddBuiltinAttribute("GUIText", "m_Text", new MultilineAttribute()); ScriptAttributeUtility.AddBuiltinAttribute("TextMesh", "m_Text", new MultilineAttribute()); }
public bool OnGUI(Rect position, SerializedProperty property, GUIContent label, bool includeChildren) { float num = position.height; position.height = 0f; if (this.m_DecoratorDrawers != null && !this.isCurrentlyNested) { foreach (DecoratorDrawer current in this.m_DecoratorDrawers) { position.height = current.GetHeight(); float labelWidth = EditorGUIUtility.labelWidth; float fieldWidth = EditorGUIUtility.fieldWidth; current.OnGUI(position); EditorGUIUtility.labelWidth = labelWidth; EditorGUIUtility.fieldWidth = fieldWidth; position.y += position.height; num -= position.height; } } position.height = num; if (this.propertyDrawer != null) { float labelWidth = EditorGUIUtility.labelWidth; float fieldWidth = EditorGUIUtility.fieldWidth; this.propertyDrawer.OnGUISafe(position, property.Copy(), label ?? EditorGUIUtility.TempContent(property.displayName)); EditorGUIUtility.labelWidth = labelWidth; EditorGUIUtility.fieldWidth = fieldWidth; return(false); } if (!includeChildren) { return(EditorGUI.DefaultPropertyField(position, property, label)); } Vector2 iconSize = EditorGUIUtility.GetIconSize(); bool enabled = GUI.enabled; int indentLevel = EditorGUI.indentLevel; int num2 = indentLevel - property.depth; SerializedProperty serializedProperty = property.Copy(); SerializedProperty endProperty = serializedProperty.GetEndProperty(); position.height = EditorGUI.GetSinglePropertyHeight(serializedProperty, label); EditorGUI.indentLevel = serializedProperty.depth + num2; bool enterChildren = EditorGUI.DefaultPropertyField(position, serializedProperty, label) && EditorGUI.HasVisibleChildFields(serializedProperty); position.y += position.height + 2f; while (serializedProperty.NextVisible(enterChildren) && !SerializedProperty.EqualContents(serializedProperty, endProperty)) { EditorGUI.indentLevel = serializedProperty.depth + num2; position.height = EditorGUI.GetPropertyHeight(serializedProperty, null, false); EditorGUI.BeginChangeCheck(); enterChildren = (ScriptAttributeUtility.GetHandler(serializedProperty).OnGUI(position, serializedProperty, null, false) && EditorGUI.HasVisibleChildFields(serializedProperty)); if (EditorGUI.EndChangeCheck()) { break; } position.y += position.height + 2f; } GUI.enabled = enabled; EditorGUIUtility.SetIconSize(iconSize); EditorGUI.indentLevel = indentLevel; return(false); }