Ejemplo n.º 1
0
        /// <summary>
        /// Creates a new inspectable field GUI for the specified property.
        /// </summary>
        /// <param name="parent">Parent Inspector this field belongs to.</param>
        /// <param name="title">Name of the property, or some other value to set as the title.</param>
        /// <param name="path">Full path to this property (includes name of this property and all parent properties).</param>
        /// <param name="type">Type of property this field will be used for displaying.</param>
        /// <param name="depth">Determines how deep within the inspector nesting hierarchy is this field. Some fields may
        ///                     contain other fields, in which case you should increase this value by one.</param>
        /// <param name="layout">Parent layout that all the field elements will be added to.</param>
        /// <param name="property">Serializable property referencing the array whose contents to display.</param>
        public InspectableField(Inspector parent, string title, string path, SerializableProperty.FieldType type, 
            int depth, InspectableFieldLayout layout, SerializableProperty property)
        {
            this.parent = parent;
            this.layout = layout;
            this.title = title;
            this.path = path;
            this.type = type;
            this.depth = depth;

            Property = property;
        }
Ejemplo n.º 2
0
            /// <summary>
            /// Constructs a new dictionary GUI.
            /// </summary>
            /// <param name="parent">Parent Inspector this field belongs to.</param>
            /// <param name="title">Label to display on the list GUI title.</param>
            /// <param name="path">Full path to this property (includes name of this property and all parent properties).
            /// </param>
            /// <param name="property">Serializable property referencing a dictionary</param>
            /// <param name="layout">Layout to which to append the list GUI elements to.</param>
            /// <param name="depth">Determines at which depth to render the background. Useful when you have multiple
            ///                     nested containers whose backgrounds are overlaping. Also determines background style,
            ///                     depths divisible by two will use an alternate style.</param>
            protected InspectableDictionaryGUI(Inspector parent, LocString title, string path, SerializableProperty property, 
                GUILayout layout, int depth = 0)
                : base(title, layout, depth)
            {
                this.property = property;
                this.parent = parent;
                this.path = path;

                dictionary = property.GetValue<IDictionary>();
                if (dictionary != null)
                    numElements = dictionary.Count;

                UpdateKeys();
            }
Ejemplo n.º 3
0
 /// <summary>
 /// Creates a new inspectable integer GUI for the specified property.
 /// </summary>
 /// <param name="parent">Parent Inspector this field belongs to.</param>
 /// <param name="title">Name of the property, or some other value to set as the title.</param>
 /// <param name="path">Full path to this property (includes name of this property and all parent properties).</param>
 /// <param name="depth">Determines how deep within the inspector nesting hierarchy is this field. Some fields may
 ///                     contain other fields, in which case you should increase this value by one.</param>
 /// <param name="layout">Parent layout that all the field elements will be added to.</param>
 /// <param name="property">Serializable property referencing the array whose contents to display.</param>
 public InspectableInt(Inspector parent, string title, string path, int depth, InspectableFieldLayout layout,
                       SerializableProperty property)
     : base(parent, title, path, SerializableProperty.FieldType.Int, depth, layout, property)
 {
 }
Ejemplo n.º 4
0
        /// <summary>
        /// Creates a new inspectable field, automatically detecting the most appropriate implementation for the type
        /// contained in the provided serializable property. This may be one of the built-in inspectable field implemetations
        /// (like ones for primitives like int or bool), or a user defined implementation defined with a 
        /// <see cref="CustomInspector"/> attribute.
        /// </summary>
        /// <param name="parent">Parent Inspector this field belongs to.</param>
        /// <param name="title">Name of the property, or some other value to set as the title.</param>
        /// <param name="path">Full path to this property (includes name of this property and all parent properties).</param>
        /// <param name="layoutIndex">Index into the parent layout at which to insert the GUI elements for the field .</param>
        /// <param name="depth">Determines how deep within the inspector nesting hierarchy is this field. Some fields may
        ///                     contain other fields, in which case you should increase this value by one.</param>
        /// <param name="layout">Parent layout that all the field elements will be added to.</param>
        /// <param name="property">Serializable property referencing the array whose contents to display.</param>
        /// <param name="style">Information related the field style</param>
        /// <returns>Inspectable field implementation that can be used for displaying the GUI for a serializable property
        ///          of the provided type.</returns>
        public static InspectableField CreateInspectable(Inspector parent, string title, string path, int layoutIndex, 
            int depth, InspectableFieldLayout layout, SerializableProperty property, InspectableFieldStyleInfo style = null)
        {
            InspectableField field = null;

            Type customInspectable = InspectorUtility.GetCustomInspectable(property.InternalType);
            if (customInspectable != null)
            {
                field = (InspectableField) Activator.CreateInstance(customInspectable, depth, title, property);
            }
            else
            {
                switch (property.Type)
                {
                    case SerializableProperty.FieldType.Int:
                        if (style?.RangeStyle == null || !style.RangeStyle.Slider)
                        {
                            field = new InspectableInt(parent, title, path, depth, layout, property, style);
                        }
                        else
                        {
                            field = new InspectableRangedInt(parent, title, path, depth, layout, property, style);
                        }
                        break;
                    case SerializableProperty.FieldType.Float:
                        if (style?.RangeStyle == null || !style.RangeStyle.Slider)
                        {
                            field = new InspectableFloat(parent, title, path, depth, layout, property, style);
                        }
                        else
                        {
                            field = new InspectableRangedFloat(parent, title, path, depth, layout, property, style);
                        }
                        break;
                    case SerializableProperty.FieldType.Bool:
                        field = new InspectableBool(parent, title, path, depth, layout, property);
                        break;
                    case SerializableProperty.FieldType.Color:
                        field = new InspectableColor(parent, title, path, depth, layout, property);
                        break;
                    case SerializableProperty.FieldType.String:
                        field = new InspectableString(parent, title, path, depth, layout, property);
                        break;
                    case SerializableProperty.FieldType.Vector2:
                        field = new InspectableVector2(parent, title, path, depth, layout, property);
                        break;
                    case SerializableProperty.FieldType.Vector3:
                        field = new InspectableVector3(parent, title, path, depth, layout, property);
                        break;
                    case SerializableProperty.FieldType.Vector4:
                        field = new InspectableVector4(parent, title, path, depth, layout, property);
                        break;
                    case SerializableProperty.FieldType.ResourceRef:
                        field = new InspectableResourceRef(parent, title, path, depth, layout, property);
                        break;
                    case SerializableProperty.FieldType.GameObjectRef:
                        field = new InspectableGameObjectRef(parent, title, path, depth, layout, property);
                        break;
                    case SerializableProperty.FieldType.Object:
                        field = new InspectableObject(parent, title, path, depth, layout, property);
                        break;
                    case SerializableProperty.FieldType.Array:
                        field = new InspectableArray(parent, title, path, depth, layout, property);
                        break;
                    case SerializableProperty.FieldType.List:
                        field = new InspectableList(parent, title, path, depth, layout, property);
                        break;
                    case SerializableProperty.FieldType.Dictionary:
                        field = new InspectableDictionary(parent, title, path, depth, layout, property);
                        break;
                }
            }

            if (field == null)
                throw new Exception("No inspector exists for the provided field type.");

            field.Initialize(layoutIndex);
            field.Refresh(layoutIndex);

            return field;
        }
Ejemplo n.º 5
0
            /// <summary>
            /// Creates a new inspectable list GUI object that displays the contents of the provided serializable property.
            /// </summary>
            /// <param name="parent">Parent Inspector this field belongs to.</param>
            /// <param name="title">Label to display on the list GUI title.</param>
            /// <param name="path">Full path to this property (includes name of this property and all parent properties).
            /// </param>
            /// <param name="property">Serializable property referencing a list.</param>
            /// <param name="layout">Layout to which to append the list GUI elements to.</param>
            /// <param name="depth">Determines at which depth to render the background. Useful when you have multiple
            ///                     nested containers whose backgrounds are overlaping. Also determines background style,
            ///                     depths divisible by two will use an alternate style.</param>
            public static InspectableListGUI Create(Inspector parent, LocString title, string path, 
                SerializableProperty property, GUILayout layout, int depth)
            {
                InspectableListGUI listGUI = new InspectableListGUI(parent, title, path, property, layout, depth);
                listGUI.BuildGUI();

                return listGUI;
            }
Ejemplo n.º 6
0
        /// <summary>
        /// Creates a new inspectable field, automatically detecting the most appropriate implementation for the type
        /// contained in the provided serializable property. This may be one of the built-in inspectable field implemetations
        /// (like ones for primitives like int or bool), or a user defined implementation defined with a
        /// <see cref="CustomInspector"/> attribute.
        /// </summary>
        /// <param name="parent">Parent Inspector this field belongs to.</param>
        /// <param name="title">Name of the property, or some other value to set as the title.</param>
        /// <param name="path">Full path to this property (includes name of this property and all parent properties).</param>
        /// <param name="layoutIndex">Index into the parent layout at which to insert the GUI elements for the field .</param>
        /// <param name="depth">Determines how deep within the inspector nesting hierarchy is this field. Some fields may
        ///                     contain other fields, in which case you should increase this value by one.</param>
        /// <param name="layout">Parent layout that all the field elements will be added to.</param>
        /// <param name="property">Serializable property referencing the array whose contents to display.</param>
        /// <param name="style">Information related the field style</param>
        /// <returns>Inspectable field implementation that can be used for displaying the GUI for a serializable property
        ///          of the provided type.</returns>
        public static InspectableField CreateInspectable(Inspector parent, string title, string path, int layoutIndex,
                                                         int depth, InspectableFieldLayout layout, SerializableProperty property, InspectableFieldStyleInfo style = null)
        {
            InspectableField field = null;

            Type customInspectable = InspectorUtility.GetCustomInspectable(property.InternalType);

            if (customInspectable != null)
            {
                field = (InspectableField)Activator.CreateInstance(customInspectable, depth, title, property);
            }
            else
            {
                switch (property.Type)
                {
                case SerializableProperty.FieldType.Int:
                    if (style?.RangeStyle == null || !style.RangeStyle.Slider)
                    {
                        field = new InspectableInt(parent, title, path, depth, layout, property, style);
                    }
                    else
                    {
                        field = new InspectableRangedInt(parent, title, path, depth, layout, property, style);
                    }
                    break;

                case SerializableProperty.FieldType.Float:
                    if (style?.RangeStyle == null || !style.RangeStyle.Slider)
                    {
                        field = new InspectableFloat(parent, title, path, depth, layout, property, style);
                    }
                    else
                    {
                        field = new InspectableRangedFloat(parent, title, path, depth, layout, property, style);
                    }
                    break;

                case SerializableProperty.FieldType.Bool:
                    field = new InspectableBool(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.Color:
                    field = new InspectableColor(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.String:
                    field = new InspectableString(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.Vector2:
                    field = new InspectableVector2(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.Vector3:
                    field = new InspectableVector3(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.Vector4:
                    field = new InspectableVector4(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.Resource:
                    field = new InspectableResourceRef(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.GameObjectRef:
                    field = new InspectableGameObjectRef(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.Object:
                    field = new InspectableObject(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.Array:
                    field = new InspectableArray(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.List:
                    field = new InspectableList(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.Dictionary:
                    field = new InspectableDictionary(parent, title, path, depth, layout, property);
                    break;
                }
            }

            if (field == null)
            {
                throw new Exception("No inspector exists for the provided field type.");
            }

            field.Initialize(layoutIndex);
            field.Refresh(layoutIndex);

            return(field);
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Creates a new inspectable field, automatically detecting the most appropriate implementation for the type
        /// contained in the provided serializable property. This may be one of the built-in inspectable field implemetations
        /// (like ones for primitives like int or bool), or a user defined implementation defined with a
        /// <see cref="CustomInspector"/> attribute.
        /// </summary>
        /// <param name="parent">Parent Inspector this field belongs to.</param>
        /// <param name="title">Name of the property, or some other value to set as the title.</param>
        /// <param name="path">Full path to this property (includes name of this property and all parent properties).</param>
        /// <param name="layoutIndex">Index into the parent layout at which to insert the GUI elements for the field .</param>
        /// <param name="depth">Determines how deep within the inspector nesting hierarchy is this field. Some fields may
        ///                     contain other fields, in which case you should increase this value by one.</param>
        /// <param name="layout">Parent layout that all the field elements will be added to.</param>
        /// <param name="property">Serializable property referencing the array whose contents to display.</param>
        /// <param name="style">Information that can be used for customizing field rendering and behaviour.</param>
        /// <returns>Inspectable field implementation that can be used for displaying the GUI for a serializable property
        ///          of the provided type.</returns>
        public static InspectableField CreateInspectable(Inspector parent, string title, string path, int layoutIndex,
                                                         int depth, InspectableFieldLayout layout, SerializableProperty property, InspectableFieldStyleInfo style = null)
        {
            InspectableField field = null;

            Type type = property.InternalType;

            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(RRef <>))
            {
                type = type.GenericTypeArguments[0];
            }

            Type customInspectable = InspectorUtility.GetCustomInspectable(type);

            if (customInspectable != null)
            {
                field = (InspectableField)Activator.CreateInstance(customInspectable, depth, title, property);
            }
            else
            {
                switch (property.Type)
                {
                case SerializableProperty.FieldType.Int:
                    if (style != null && style.StyleFlags.HasFlag(InspectableFieldStyleFlags.UseLayerMask))
                    {
                        field = new InspectableLayerMask(parent, title, path, depth, layout, property);
                    }
                    else
                    {
                        if (style?.RangeStyle == null || !style.RangeStyle.Slider)
                        {
                            field = new InspectableInt(parent, title, path, depth, layout, property, style);
                        }
                        else
                        {
                            field = new InspectableRangedInt(parent, title, path, depth, layout, property, style);
                        }
                    }

                    break;

                case SerializableProperty.FieldType.Float:
                    if (style?.RangeStyle == null || !style.RangeStyle.Slider)
                    {
                        field = new InspectableFloat(parent, title, path, depth, layout, property, style);
                    }
                    else
                    {
                        field = new InspectableRangedFloat(parent, title, path, depth, layout, property, style);
                    }
                    break;

                case SerializableProperty.FieldType.Bool:
                    field = new InspectableBool(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.Color:
                    field = new InspectableColor(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.ColorGradient:
                    field = new InspectableColorGradient(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.Curve:
                    field = new InspectableCurve(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.FloatDistribution:
                    field = new InspectableFloatDistribution(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.Vector2Distribution:
                    field = new InspectableVector2Distribution(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.Vector3Distribution:
                    field = new InspectableVector3Distribution(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.ColorDistribution:
                    field = new InspectableColorDistribution(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.String:
                    field = new InspectableString(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.Vector2:
                    field = new InspectableVector2(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.Vector3:
                    field = new InspectableVector3(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.Vector4:
                    field = new InspectableVector4(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.Quaternion:
                    field = new InspectableQuaternion(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.Resource:
                    field = new InspectableResource(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.RRef:
                    field = new InspectableRRef(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.GameObjectRef:
                    field = new InspectableGameObjectRef(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.Object:
                    field = new InspectableObject(parent, title, path, depth, layout, property, style);
                    break;

                case SerializableProperty.FieldType.Array:
                    field = new InspectableArray(parent, title, path, depth, layout, property, style);
                    break;

                case SerializableProperty.FieldType.List:
                    field = new InspectableList(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.Dictionary:
                    field = new InspectableDictionary(parent, title, path, depth, layout, property);
                    break;

                case SerializableProperty.FieldType.Enum:
                    field = new InspectableEnum(parent, title, path, depth, layout, property);
                    break;
                }
            }

            if (field == null)
            {
                throw new Exception("No inspector exists for the provided field type.");
            }

            field.Initialize(layoutIndex);
            field.Refresh(layoutIndex);

            return(field);
        }
Ejemplo n.º 8
0
 /// <summary>
 /// Creates a new inspectable array GUI for the specified property.
 /// </summary>
 /// <param name="parent">Parent Inspector this field belongs to.</param>
 /// <param name="title">Name of the property, or some other value to set as the title.</param>
 /// <param name="path">Full path to this property (includes name of this property and all parent properties).</param>
 /// <param name="depth">Determines how deep within the inspector nesting hierarchy is this field. Some fields may
 ///                     contain other fields, in which case you should increase this value by one.</param>
 /// <param name="layout">Parent layout that all the field elements will be added to.</param>
 /// <param name="property">Serializable property referencing the array whose contents to display.</param>
 public InspectableObject(Inspector parent, string title, string path, int depth, InspectableFieldLayout layout, 
     SerializableProperty property)
     : base(parent, title, path, SerializableProperty.FieldType.Object, depth, layout, property)
 {
     isExpanded = parent.Persistent.GetBool(path + "_Expanded");
 }
Ejemplo n.º 9
0
        /// <summary>
        /// Creates inspectable fields all the fields/properties of the specified object.
        /// </summary>
        /// <param name="obj">Object whose fields the GUI will be drawn for.</param>
        /// <param name="parent">Parent Inspector to draw in.</param>
        /// <param name="path">Full path to the field this provided object was retrieved from.</param>
        /// <param name="depth">
        /// Determines how deep within the inspector nesting hierarchy is this objects. Some fields may contain other
        /// fields, in which case you should increase this value by one.
        /// </param>
        /// <param name="layout">Parent layout that all the field GUI elements will be added to.</param>
        /// <param name="overrideCallback">
        /// Optional callback that allows you to override the look of individual fields in the object. If non-null the
        /// callback will be called with information about every field in the provided object. If the callback returns
        /// non-null that inspectable field will be used for drawing the GUI, otherwise the default inspector field type
        /// will be used.
        /// </param>
        public static List <InspectableField> CreateFields(SerializableObject obj, Inspector parent, string path,
                                                           int depth, GUILayoutY layout, FieldOverrideCallback overrideCallback = null)
        {
            // Retrieve fields and sort by order
            SerializableField[] fields = obj.Fields;
            Array.Sort(fields,
                       (x, y) =>
            {
                int orderX = x.Flags.HasFlag(SerializableFieldAttributes.Order) ? x.Style.Order : 0;
                int orderY = y.Flags.HasFlag(SerializableFieldAttributes.Order) ? y.Style.Order : 0;

                return(orderX.CompareTo(orderY));
            });

            // Generate per-field GUI while grouping by category
            Dictionary <string, Tuple <int, GUILayoutY> > categories = new Dictionary <string, Tuple <int, GUILayoutY> >();

            int rootIndex = 0;
            List <InspectableField> inspectableFields = new List <InspectableField>();

            foreach (var field in fields)
            {
                if (!field.Flags.HasFlag(SerializableFieldAttributes.Inspectable))
                {
                    continue;
                }

                string category = null;
                if (field.Flags.HasFlag(SerializableFieldAttributes.Category))
                {
                    category = field.Style.CategoryName;
                }

                Tuple <int, GUILayoutY> categoryInfo = null;
                if (!string.IsNullOrEmpty(category))
                {
                    if (!categories.TryGetValue(category, out categoryInfo))
                    {
                        InspectableFieldLayout fieldLayout        = new InspectableFieldLayout(layout);
                        GUILayoutY             categoryRootLayout = fieldLayout.AddLayoutY(rootIndex);
                        GUILayoutX             guiTitleLayout     = categoryRootLayout.AddLayoutX();

                        bool isExpanded = parent.Persistent.GetBool(path + "/[" + category + "]_Expanded");

                        GUIToggle guiFoldout = new GUIToggle(category, EditorStyles.Foldout);
                        guiFoldout.Value           = isExpanded;
                        guiFoldout.AcceptsKeyFocus = false;
                        guiFoldout.OnToggled      += x =>
                        {
                            parent.Persistent.SetBool(path + "/[" + category + "]_Expanded", x);
                        };
                        guiTitleLayout.AddElement(guiFoldout);

                        GUILayoutX categoryContentLayout = categoryRootLayout.AddLayoutX();
                        categoryContentLayout.AddSpace(IndentAmount);

                        GUIPanel   guiContentPanel  = categoryContentLayout.AddPanel();
                        GUILayoutX guiIndentLayoutX = guiContentPanel.AddLayoutX();
                        guiIndentLayoutX.AddSpace(IndentAmount);
                        GUILayoutY guiIndentLayoutY = guiIndentLayoutX.AddLayoutY();
                        guiIndentLayoutY.AddSpace(IndentAmount);
                        GUILayoutY categoryLayout = guiIndentLayoutY.AddLayoutY();
                        guiIndentLayoutY.AddSpace(IndentAmount);
                        guiIndentLayoutX.AddSpace(IndentAmount);
                        categoryContentLayout.AddSpace(IndentAmount);

                        short  backgroundDepth = (short)(Inspector.START_BACKGROUND_DEPTH - depth - 1);
                        string bgPanelStyle    = depth % 2 == 0
                            ? EditorStylesInternal.InspectorContentBgAlternate
                            : EditorStylesInternal.InspectorContentBg;
                        GUIPanel   backgroundPanel    = guiContentPanel.AddPanel(backgroundDepth);
                        GUITexture inspectorContentBg = new GUITexture(null, bgPanelStyle);
                        backgroundPanel.AddElement(inspectorContentBg);

                        categories[category] = new Tuple <int, GUILayoutY>(0, categoryLayout);
                        rootIndex++;
                    }
                }

                int        currentIndex;
                GUILayoutY parentLayout;
                if (categoryInfo != null)
                {
                    currentIndex = categoryInfo.Item1;
                    parentLayout = categoryInfo.Item2;
                }
                else
                {
                    currentIndex = rootIndex;
                    parentLayout = layout;
                }

                string fieldName = field.Name;
                string childPath = string.IsNullOrEmpty(path) ? fieldName : path + "/" + fieldName;

                InspectableField inspectableField = null;

                if (overrideCallback != null)
                {
                    inspectableField = overrideCallback(field, parent, path, new InspectableFieldLayout(parentLayout),
                                                        currentIndex, depth);
                }

                if (inspectableField == null)
                {
                    inspectableField = CreateField(parent, fieldName, childPath,
                                                   currentIndex, depth, new InspectableFieldLayout(parentLayout), field.GetProperty(),
                                                   InspectableFieldStyle.Create(field));
                }

                inspectableFields.Add(inspectableField);
                currentIndex += inspectableField.GetNumLayoutElements();

                if (categoryInfo != null)
                {
                    categories[category] = new Tuple <int, GUILayoutY>(currentIndex, parentLayout);
                }
                else
                {
                    rootIndex = currentIndex;
                }
            }

            return(inspectableFields);
        }
Ejemplo n.º 10
0
 /// <summary>
 /// Creates a new inspectable float GUI for the specified property with a range.
 /// </summary>
 /// <param name="parent">Parent Inspector this field belongs to.</param>
 /// <param name="title">Name of the property, or some other value to set as the title.</param>
 /// <param name="path">Full path to this property (includes name of this property and all parent properties).</param>
 /// <param name="depth">Determines how deep within the inspector nesting hierarchy is this field. Some fields may
 ///                     contain other fields, in which case you should increase this value by one.</param>
 /// <param name="layout">Parent layout that all the field elements will be added to.</param>
 /// <param name="property">Serializable property referencing the array whose contents to display.</param>
 /// <param name="style">Information about the range of the field.</param>
 public InspectableRangedInt(Inspector parent, string title, string path, int depth, InspectableFieldLayout layout,
                             SerializableProperty property, InspectableFieldStyleInfo style)
     : base(parent, title, path, SerializableProperty.FieldType.Float, depth, layout, property, style)
 {
 }
Ejemplo n.º 11
0
 /// <summary>
 /// Creates a new inspectable float GUI for the specified property.
 /// </summary>
 /// <param name="parent">Parent Inspector this field belongs to.</param>
 /// <param name="title">Name of the property, or some other value to set as the title.</param>
 /// <param name="path">Full path to this property (includes name of this property and all parent properties).</param>
 /// <param name="depth">Determines how deep within the inspector nesting hierarchy is this field. Some fields may
 ///                     contain other fields, in which case you should increase this value by one.</param>
 /// <param name="layout">Parent layout that all the field elements will be added to.</param>
 /// <param name="property">Serializable property referencing the array whose contents to display.</param>
 /// <param name="style">Contains information about the field style</param>
 public InspectableFloat(Inspector parent, string title, string path, int depth, InspectableFieldLayout layout, 
     SerializableProperty property, InspectableFieldStyleInfo style)
     : base(parent, title, path, SerializableProperty.FieldType.Float, depth, layout, property)
 {
     this.style = style;
 }
Ejemplo n.º 12
0
 /// <summary>
 /// Creates a new inspectable array GUI for the specified property.
 /// </summary>
 /// <param name="parent">Parent Inspector this field belongs to.</param>
 /// <param name="title">Name of the property, or some other value to set as the title.</param>
 /// <param name="path">Full path to this property (includes name of this property and all parent properties).</param>
 /// <param name="depth">Determines how deep within the inspector nesting hierarchy is this field. Some fields may
 ///                     contain other fields, in which case you should increase this value by one.</param>
 /// <param name="layout">Parent layout that all the field elements will be added to.</param>
 /// <param name="property">Serializable property referencing the array whose contents to display.</param>
 public InspectableObject(Inspector parent, string title, string path, int depth, InspectableFieldLayout layout,
                          SerializableProperty property)
     : base(parent, title, path, SerializableProperty.FieldType.Object, depth, layout, property)
 {
     isExpanded = parent.Persistent.GetBool(path + "_Expanded");
 }
Ejemplo n.º 13
0
 /// <summary>
 /// Creates a new inspectable ranged field GUI for the specified property.
 /// </summary>
 /// <param name="parent">Parent Inspector this field belongs to.</param>
 /// <param name="title">Name of the property, or some other value to set as the title.</param>
 /// <param name="path">Full path to this property (includes name of this property and all parent properties).</param>
 /// <param name="type">Type of property this field will be used for displaying.</param>
 /// <param name="depth">Determines how deep within the inspector nesting hierarchy is this field. Some fields may
 ///                     contain other fields, in which case you should increase this value by one.</param>
 /// <param name="layout">Parent layout that all the field elements will be added to.</param>
 /// <param name="property">Serializable property referencing the array whose contents to display.</param>
 /// <param name="style">Contains information about the field style</param>
 public InspectableRangedField(Inspector parent, string title, string path, SerializableProperty.FieldType type,
                               int depth, InspectableFieldLayout layout, SerializableProperty property, InspectableFieldStyleInfo style) : base(parent, title, path, type, depth, layout, property)
 {
     this.style = style;
 }
Ejemplo n.º 14
0
            /// <summary>
            /// Builds the inspectable dictionary GUI elements. Must be called at least once in order for the contents to 
            /// be populated.
            /// </summary>
            /// <param name="parent">Parent Inspector this field belongs to.</param>
            /// <param name="title">Label to display on the list GUI title.</param>
            /// <param name="path">Full path to this property (includes name of this property and all parent properties).
            /// </param>
            /// <param name="property">Serializable property referencing a dictionary</param>
            /// <param name="layout">Layout to which to append the list GUI elements to.</param>
            /// <param name="depth">Determines at which depth to render the background. Useful when you have multiple
            ///                     nested containers whose backgrounds are overlaping. Also determines background style,
            ///                     depths divisible by two will use an alternate style.</param>
            public static InspectableDictionaryGUI Create(Inspector parent, LocString title, string path, 
                SerializableProperty property, GUILayout layout, int depth = 0)
            {
                InspectableDictionaryGUI guiDictionary = new InspectableDictionaryGUI(parent, title, path, property,
                    layout, depth);
                guiDictionary.BuildGUI();

                return guiDictionary;
            }
Ejemplo n.º 15
0
            /// <summary>
            /// Constructs a new empty inspectable list GUI.
            /// </summary>
            /// <param name="parent">Parent Inspector this field belongs to.</param>
            /// <param name="title">Label to display on the list GUI title.</param>
            /// <param name="path">Full path to this property (includes name of this property and all parent properties).
            /// </param>
            /// <param name="property">Serializable property referencing a list.</param>
            /// <param name="layout">Layout to which to append the list GUI elements to.</param>
            /// <param name="depth">Determines at which depth to render the background. Useful when you have multiple
            ///                     nested containers whose backgrounds are overlaping. Also determines background style,
            ///                     depths divisible by two will use an alternate style.</param>
            public InspectableListGUI(Inspector parent, LocString title, string path, SerializableProperty property, 
                GUILayout layout, int depth)
                : base(title, layout, depth)
            {
                this.property = property;
                this.parent = parent;
                this.path = path;

                list = property.GetValue<IList>();
                if (list != null)
                    numElements = list.Count;
            }
Ejemplo n.º 16
0
 /// <summary>
 /// Creates a new inspectable color GUI for the specified property.
 /// </summary>
 /// <param name="parent">Parent Inspector this field belongs to.</param>
 /// <param name="title">Name of the property, or some other value to set as the title.</param>
 /// <param name="path">Full path to this property (includes name of this property and all parent properties).</param>
 /// <param name="depth">Determines how deep within the inspector nesting hierarchy is this field. Some fields may
 ///                     contain other fields, in which case you should increase this value by one.</param>
 /// <param name="layout">Parent layout that all the field elements will be added to.</param>
 /// <param name="property">Serializable property referencing the array whose contents to display.</param>
 public InspectableColor(Inspector parent, string title, string path, int depth, InspectableFieldLayout layout, 
     SerializableProperty property)
     : base(parent, title, path, SerializableProperty.FieldType.Color, depth, layout, property)
 {
 }
Ejemplo n.º 17
0
 /// <summary>
 /// Creates a new inspectable AABox GUI for the specified property.
 /// </summary>
 /// <param name="parent">Parent Inspector this field belongs to.</param>
 /// <param name="title">Name of the property, or some other value to set as the title.</param>
 /// <param name="path">Full path to this property (includes name of this property and all parent properties).</param>
 /// <param name="depth">Determines how deep within the inspector nesting hierarchy is this field. Some fields may
 ///                     contain other fields, in which case you should increase this value by one.</param>
 /// <param name="layout">Parent layout that all the field elements will be added to.</param>
 /// <param name="property">Serializable property referencing the field whose contents to display.</param>
 /// <param name="style">Information that can be used for customizing field rendering and behaviour.</param>
 public InspectableAABox(Inspector parent, string title, string path, int depth, InspectableFieldLayout layout,
                         SerializableProperty property, InspectableFieldStyle style)
     : base(parent, title, path, SerializableProperty.FieldType.Object, depth, layout, property)
 {
 }