Ejemplo n.º 1
0
        private void CreateListData(InspectableProperty property)
        {
            var root = property.GetRootPath();
            // Try to find the grand parent in ReorderableListData
            var data = listIndex.Find(listData => listData.Parent.Equals(root));

            if (data == null)
            {
                data = new ReorderableListData(root);
                listIndex.Add(data);
            }

            data.AddProperty(property);
            if (property.HasAttribute <ReorderableAttribute>())
            {
                var reorderableAttr = property.GetAttributes <ReorderableAttribute>()[0] as ReorderableAttribute;
                if (reorderableAttr != null)
                {
                    HandleReorderableOptions(reorderableAttr, property, data);
                }
            }
            if (property.HasAttribute <BackgroundColorAttribute>())
            {
                var bgColorAttr = property.GetAttributes <BackgroundColorAttribute>()[0] as BackgroundColorAttribute;
                if (bgColorAttr != null)
                {
                    HandleBackgroundColorOptions(bgColorAttr, property, data);
                }
            }
        }
        private float ElementHeightCallback(InspectableProperty property, int index)
        {
            var height   = 3f;
            var iterProp = property.GetArrayElementAtIndex(index);

            if (iterProp.IsExpanded || !ElementHeights.ContainsKey(index))
            {
                var displayName = new GUIContent(iterProp.DisplayName);
                if (ElementNameCallback != null)
                {
                    var elementName = ElementNameCallback(index);
                    displayName = elementName == null ? GUIContent.none : new GUIContent(elementName);
                }

                height += EasyGUI.GetInspectableObjectHeight(iterProp, displayName, IsDrawObjectReference);
                if (!iterProp.IsExpanded)
                {
                    ElementHeights.Add(index, height);
                }
            }
            else
            {
                height = ElementHeights[index];
            }

            return(height);
        }
Ejemplo n.º 3
0
        public InspectableProperty FindPropertyRelative(string relativePropertyPath)
        {
            InspectableProperty property = null;

            if (!string.IsNullOrEmpty(relativePropertyPath))
            {
                string[] paths = relativePropertyPath.Split(StopChar);
                if (paths.Length > 0 && propertyBase.Properties != null)
                {
                    foreach (var child in propertyBase.Properties)
                    {
                        if (child.Name == paths[0])
                        {
                            property = new InspectableProperty(child);
                            if (paths.Length == 1)
                            {
                                return(property);
                            }
                            else
                            {
                                int    startIndex = paths[0].Length + 1;
                                string path       = relativePropertyPath.Substring(startIndex, relativePropertyPath.Length - startIndex);
                                property = property.FindPropertyRelative(path);
                                if (property != null)
                                {
                                    return(property);
                                }
                            }
                        }
                    }
                }
            }
            return(property);
        }
Ejemplo n.º 4
0
        public InspectableProperty GetFixedBufferElementAtIndex(int index)
        {
            InspectableProperty property = Copy();
            InspectableProperty result   = null;

            if (index >= 0 && index < property.FixedBufferSize)
            {
                int i = 0;
                if (property.NextVisible(true))
                {
                    property.NextVisible(false);
                    do
                    {
                        if (i == index)
                        {
                            result = property;
                            break;
                        }
                        i++;
                    } while (property.NextVisible(false));
                }
            }
            else
            {
                result = null;
            }
            return(result);
        }
Ejemplo n.º 5
0
        public bool DuplicateCommand()
        {
            var length     = PropertyPath.LastIndexOf(StopStr);
            var parentPath = PropertyPath.Substring(0, length);
            var property   = FindProperty(parentPath);
            var property2  = property.Copy();

            if (property != null && property.IsArray)
            {
                int index = 0;
                // Skip Array Size Property
                property2.NextVisible(true);
                while (property2.NextVisible(false))
                {
                    if (InspectableProperty.EqualContents(property2, this))
                    {
                        object o = property.GetArrayElementAtIndex(index).Value;
                        property.InsertArrayElementAtIndex(index);
                        property.GetArrayElementAtIndex(index).Value = o;
                        return(true);
                    }
                    index++;
                }
            }
            return(false);
        }
        public void AddProperty(InspectableProperty property)
        {
            // Check if this property actually belongs to the same direct child
            if (!property.GetRootPath().Equals(Parent))
            {
                return;
            }

            if (extendListIndex.ContainsKey(property.PropertyPath))
            {
                return;
            }

            InspectableReorderableList propList = new InspectableReorderableList(
                property.InspectableObject.SerializedObject, property,
                draggable: true, displayHeader: false,
                displayAddButton: true, displayRemoveButton: true)
            {
                headerHeight = 5
            };

            propList.drawElementBackgroundCallback = delegate(Rect position, int index, bool active, bool focused)
            {
                if (DrawBackgroundCallback != null)
                {
                    Rect backgroundRect = new Rect(position);
                    if (index <= 0)
                    {
                        backgroundRect.yMin -= 8;
                    }
                    if (index >= propList.count - 1)
                    {
                        backgroundRect.yMax += 3;
                    }
                    EditorGUI.DrawRect(backgroundRect, DrawBackgroundCallback(active, focused));
                }
                else
                {
                    propList.drawElementBackgroundCallback = null;
                }
            };

            propList.drawElementCallback = delegate(Rect position, int index, bool active, bool focused)
            {
                var iterProp    = property.GetArrayElementAtIndex(index);
                var displayName = new GUIContent(iterProp.DisplayName);
                if (ElementNameCallback != null)
                {
                    var elementName = ElementNameCallback(index);
                    displayName = elementName == null ? GUIContent.none : new GUIContent(elementName);
                }

                EasyGUI.TryDrawInspectableObject(position, iterProp, displayName, IsDrawObjectReference);
            };

            propList.elementHeightCallback = index => ElementHeightCallback(property, index);

            extendListIndex.Add(property.PropertyPath, propList);
        }
Ejemplo n.º 7
0
        internal float GetPropertyHeightSafe(InspectableProperty property, GUIContent label)
        {
            InspectableAttributeUtility.s_DrawerStack.Push(this);
            float propertyHeight = this.GetPropertyHeight(property, label);

            InspectableAttributeUtility.s_DrawerStack.Pop();
            return(propertyHeight);
        }
Ejemplo n.º 8
0
 public PropertyGUIData(InspectableProperty property, Rect totalPosition, bool wasBoldDefaultFont, bool wasEnabled, Color color)
 {
     Property           = property;
     TotalPosition      = totalPosition;
     WasBoldDefaultFont = wasBoldDefaultFont;
     WasEnabled         = wasEnabled;
     Color = color;
 }
Ejemplo n.º 9
0
        private string DoHeader(InspectableProperty property, Rect position, string displayName)
        {
            displayName = string.IsNullOrEmpty(displayName) ? property.DisplayName : displayName;
            string headerName = string.Format(HeaderStr, displayName, property.ArraySize);

            EasyGUI.PropertyField(position, property, new GUIContent(headerName), false);
            return(headerName);
        }
Ejemplo n.º 10
0
            public bool MoveNext()
            {
                uint num = (uint)position;

                position = -1;
                switch (num)
                {
                case 0:
                    if (!target.IsArray)
                    {
                        end = target.GetEndProperty();
                        if (target.NextVisible(true) && !InspectableProperty.EqualContents(target, end))
                        {
                            current = target;
                            if (!disposing)
                            {
                                position = 2;
                            }
                            return(true);
                        }
                        position = -1;
                        return(false);
                    }
                    index = 0;
                    break;

                case 1:
                    index++;
                    break;

                case 2:
                    if (target.NextVisible(true) && !InspectableProperty.EqualContents(target, end))
                    {
                        current = target;
                        if (!disposing)
                        {
                            position = 2;
                        }
                        return(true);
                    }
                    position = -1;
                    return(false);

                default:
                    return(false);
                }
                if (index >= target.ArraySize)
                {
                    position = -1;
                    return(false);
                }
                current = target.GetArrayElementAtIndex(index);
                if (!disposing)
                {
                    position = 1;
                }
                return(true);
            }
Ejemplo n.º 11
0
 public static bool HasAttribute <T>(this InspectableProperty property)
 {
     object[] attrs = GetAttributes <T>(property);
     if (attrs != null)
     {
         return(attrs.Length > 0);
     }
     return(false);
 }
Ejemplo n.º 12
0
        private void Initialize(InspectableProperty property)
        {
            if (isInitialized)
            {
                return;
            }

            FindTargetProperties(property.Copy());
        }
Ejemplo n.º 13
0
        public static void PasteComponentValues(object userData)
        {
            InspectableProperty   inspectableProperty = (InspectableProperty)userData;
            InspectableObjectData data = clipboard[inspectableProperty.InspectableObject.Type];

            JsonUtility.FromJsonOverwrite(data.Data, inspectableProperty.InspectableObject.Object);
            inspectableProperty.InspectableObject.ParentProperty.SetInspectableObjectData(data);
            inspectableProperty.InspectableObject.SerializedObject.ApplyModifiedProperties();
        }
Ejemplo n.º 14
0
        private void Initialize(InspectableProperty property, bool force)
        {
            if (force)
            {
                isInitialized = false;
            }

            Initialize(property);
        }
Ejemplo n.º 15
0
        public override void OnGUI(Rect position, InspectableProperty property, GUIContent label)
        {
            EditorGUI.BeginChangeCheck();
            var index = EditorGUI.MaskField(position, property.DisplayName, property.IntValue, property.EnumDisplayNames);

            if (EditorGUI.EndChangeCheck())
            {
                property.IntValue = index;
            }
        }
        public InspectableHandler GetHandler(InspectableProperty property)
        {
            InspectableHandler handler;
            int key = GetPropertyHash(property);

            if (InspectableHandlers.TryGetValue(key, out handler))
            {
                return(handler);
            }
            return(null);
        }
Ejemplo n.º 17
0
        public static string GetRootPath(this InspectableProperty property)
        {
            var rootPath = property.PropertyPath;
            var firstDot = property.PropertyPath.IndexOf(StopChar);

            if (firstDot > 0)
            {
                rootPath = property.PropertyPath.Substring(0, firstDot);
            }
            return(rootPath);
        }
Ejemplo n.º 18
0
 private void SetValue(InspectableProperty property, float value)
 {
     if (property.PropertyType == InspectablePropertyType.Integer)
     {
         property.IntValue = (int)value;
     }
     else if (property.PropertyType == InspectablePropertyType.Float)
     {
         property.FloatValue = value;
     }
 }
Ejemplo n.º 19
0
        private void DrawPropertySortableArray(Rect position, InspectableProperty property, GUIContent label)
        {
            // Try to get the sortable list this property belongs to
            ReorderableListData listData = null;

            if (listIndex.Count > 0)
            {
                listData = listIndex.Find(data => property.PropertyPath.StartsWith(data.Parent));
            }

            UnityEditor.Editor scriptableEditor;
            bool isScriptableEditor = editableIndex.TryGetValue(property.PropertyPath, out scriptableEditor);

            // Has ReorderableList and Try to show the list
            if (listData != null && listData.DoProperty(position, property))
            {
            }
            // Else try to draw ScriptableObject editor
            else if (isScriptableEditor)
            {
                bool hasHeader = property.HasAttribute <HeaderAttribute>();
                bool hasSpace  = property.HasAttribute <SpaceAttribute>();

                hasSpace |= hasHeader;

                // No data in property, draw property field with create button
                if (scriptableEditor == null)
                {
                    var fieldPosition  = new Rect(position);
                    var buttonPosition = new Rect(position);
                    fieldPosition.width -= hasSpace ? 60 : 50;
                    buttonPosition.xMin  = fieldPosition.xMax;

                    EasyGUI.PropertyField(fieldPosition, property);
                    bool doCreate = GUI.Button(buttonPosition, Create, EditorStyles.miniButton);

                    if (doCreate)
                    {
                        var propType = property.GetTypeReflection();
                        ScriptableObjectUtility.CreateAssetWithSavePrompt(propType, postCreated: createdAsset =>
                        {
                            property.ObjectReference = createdAsset;
                            property.IsExpanded      = true;
                            return(false);
                        });
                    }
                }
            }
            else
            {
                EasyGUI.PropertyField(position, property, label, property.IsExpanded);
            }
        }
Ejemplo n.º 20
0
        public override float GetPropertyHeight(InspectableProperty property, GUIContent label)
        {
            // Try to get the sortable list this property belongs to
            ReorderableListData listData = null;

            if (listIndex.Count > 0)
            {
                listData = listIndex.Find(data => property.PropertyPath.StartsWith(data.Parent));
            }

            return(listData != null?listData.GetPropertyHeight(property) : EasyGUI.GetPropertyHeight(property, label, property.IsExpanded));
        }
Ejemplo n.º 21
0
        public InspectableProperty GetEndProperty(bool includeInVisible = false)
        {
            InspectableProperty property = Copy();

            if (includeInVisible)
            {
                property.Next(false);
                return(property);
            }
            property.NextVisible(false);
            return(property);
        }
Ejemplo n.º 22
0
        public static T GetParent <T>(this InspectableProperty property)
        {
            var obj    = property.InspectableObject.Object;
            var length = property.PropertyPath.LastIndexOf(StopChar);

            if (length > -1)
            {
                var path = property.PropertyPath.Substring(0, length);
                obj = property.InspectableObject.FindProperty(path).Value;
            }
            return((T)obj);
        }
Ejemplo n.º 23
0
 private float GetValue(InspectableProperty property)
 {
     if (property.PropertyType == InspectablePropertyType.Integer)
     {
         return(property.IntValue);
     }
     else if (property.PropertyType == InspectablePropertyType.Float)
     {
         return(property.FloatValue);
     }
     return(0);
 }
Ejemplo n.º 24
0
        private static FieldInfo GetFieldInfoFromProperty(InspectableProperty property, out Type type)
        {
            var classType = GetScriptTypeFromProperty(property);

            if (classType == null)
            {
                type = null;
                return(null);
            }

            return(GetFieldInfoFromPropertyPath(classType, property.PropertyPath, out type));
        }
Ejemplo n.º 25
0
        public override void OnGUI(Rect position, InspectableProperty property, GUIContent label)
        {
            var range       = Attribute as MinMaxRangeAttribute;
            var minProperty = property.FindPropertyRelative(Min);
            var maxProperty = property.FindPropertyRelative(Max);

            if (minProperty != null && maxProperty != null)
            {
                minValue = GetValue(minProperty);
                maxValue = GetValue(maxProperty);

                Rect contentPosition = EditorGUI.PrefixLabel(position, label);
                EditorGUI.BeginChangeCheck();

                int indentLevel = EditorGUI.indentLevel;
                EditorGUI.indentLevel = 0;
                if (range.Min == float.MinValue || range.Max == float.MaxValue)
                {
                    var tempPosition = new Rect(contentPosition);
                    tempPosition.xMax = tempPosition.xMin + 0.2f * contentPosition.width;
                    EditorGUI.LabelField(tempPosition, Min);
                    tempPosition.xMin  = tempPosition.xMax;
                    tempPosition.xMax += 0.3f * contentPosition.width;
                    minValue           = EditorGUI.FloatField(tempPosition, minValue);
                    tempPosition.xMin  = tempPosition.xMax;
                    tempPosition.xMax += 0.2f * contentPosition.width;
                    EditorGUI.LabelField(tempPosition, Max);
                    tempPosition.xMin  = tempPosition.xMax;
                    tempPosition.xMax += 0.3f * contentPosition.width;
                    maxValue           = EditorGUI.FloatField(tempPosition, maxValue);
                }
                else
                {
                    var tempPosition = new Rect(contentPosition);
                    tempPosition.xMax  = tempPosition.xMin + 0.2f * contentPosition.width;
                    minValue           = EditorGUI.FloatField(tempPosition, minValue);
                    tempPosition.xMin  = tempPosition.xMax;
                    tempPosition.xMax += 0.6f * contentPosition.width;
                    EditorGUI.MinMaxSlider(tempPosition, ref minValue, ref maxValue, range.Min, range.Max);
                    tempPosition.xMin  = tempPosition.xMax;
                    tempPosition.xMax += 0.2f * contentPosition.width;
                    maxValue           = EditorGUI.FloatField(tempPosition, maxValue);
                }
                EditorGUI.indentLevel = indentLevel;

                if (EditorGUI.EndChangeCheck())
                {
                    SetValue(minProperty, minValue);
                    SetValue(maxProperty, maxValue);
                }
            }
        }
Ejemplo n.º 26
0
        public override float GetPropertyHeight(InspectableProperty property, GUIContent label)
        {
            var height = base.GetPropertyHeight(property, label);

            if (!useSearchIndex.ContainsKey(property.PropertyPath))
            {
                useSearchIndex.Add(property.PropertyPath, false);
            }
            if (useSearchIndex[property.PropertyPath])
            {
                height += EditorGUIUtility.singleLineHeight + 6;
            }
            return(height);
        }
Ejemplo n.º 27
0
        public override void OnGUI(Rect position, InspectableProperty property, GUIContent label)
        {
            Initialize(property);

            EditorGUI.BeginChangeCheck();

            DrawPropertySortableArray(position, property, label);

            if (EditorGUI.EndChangeCheck())
            {
                property.InspectableObject.ApplyModifiedProperties();
                Initialize(property, true);
            }
        }
Ejemplo n.º 28
0
        public static void CopyComponent(object userData)
        {
            InspectableProperty inspectableProperty = (InspectableProperty)userData;

            datas.Clear();
            datas.Add(inspectableProperty.InspectableObject.ParentProperty.GetInspectableObjectData());
            if (clipboard.ContainsKey(datas[0].Type))
            {
                clipboard[datas[0].Type] = datas[0];
            }
            else
            {
                clipboard.Add(datas[0].Type, datas[0]);
            }
        }
Ejemplo n.º 29
0
        protected virtual void EmitPropertyField(Rect position, InspectableProperty targetInspectableProperty, GUIContent label)
        {
            var multiline = GetMultilineAttribute();

            if (multiline == null)
            {
                var range = GetRangeAttribute();
                if (range == null)
                {
                    EasyGUI.PropertyField(position, targetInspectableProperty, label, includeChildren: true);
                }
                else
                {
                    if (targetInspectableProperty.PropertyType == InspectablePropertyType.Float)
                    {
                        EasyGUI.Slider(position, targetInspectableProperty, range.Min, range.Max, label);
                    }
                    else if (targetInspectableProperty.PropertyType == InspectablePropertyType.Integer)
                    {
                        EasyGUI.IntSlider(position, targetInspectableProperty, (int)range.Min, (int)range.Max, label);
                    }
                    else
                    {
                        EditorGUI.LabelField(position, label.text, "Use Range with float or int.");
                    }
                }
            }
            else
            {
                var property = targetInspectableProperty;

                label = EasyGUI.BeginProperty(position, label, property);
                var method = typeof(EditorGUI).GetMethod("MultiFieldPrefixLabel", BindingFlags.Static | BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.NonPublic);
                position = (Rect)method.Invoke(null, new object[] { position, 0, label, 1 });

                EditorGUI.BeginChangeCheck();
                int indentLevel = EditorGUI.indentLevel;
                EditorGUI.indentLevel = 0;
                var stringValue = EditorGUI.TextArea(position, property.StringValue);
                EditorGUI.indentLevel = indentLevel;
                if (EditorGUI.EndChangeCheck())
                {
                    property.StringValue = stringValue;
                }
                EasyGUI.EndProperty();
            }
        }
Ejemplo n.º 30
0
        public override void OnGUI(Rect position, InspectableProperty property, GUIContent label)
        {
            RangeAttribute rangeAttribute = (RangeAttribute)base.Attribute;

            if (property.PropertyType == InspectablePropertyType.Float)
            {
                EasyGUI.Slider(position, property, rangeAttribute.min, rangeAttribute.max, label);
            }
            else if (property.PropertyType == InspectablePropertyType.Integer)
            {
                EasyGUI.IntSlider(position, property, (int)rangeAttribute.min, (int)rangeAttribute.max, label);
            }
            else
            {
                EditorGUI.LabelField(position, label.text, "Use Range with float or int.");
            }
        }