bool VisitEnum <TContainer, TValue>(
            InspectorContext inspectorContext,
            IProperty <TContainer> property,
            ref TValue value,
            PropertyPath path,
            bool isWrapper)
        {
            var inspector = GetCustomInspector(property, ref value, path, isWrapper);

            if (null == inspector)
            {
                if (RuntimeTypeInfoCache <TValue> .IsEnumFlags)
                {
                    GuiFactory.FlagsField(property, ref value, path, inspectorContext);
                }
                else
                {
                    GuiFactory.EnumField(property, ref value, path, inspectorContext);
                }
            }
            else
            {
                using (inspectorContext.MakeIgnoreInspectorScope())
                {
                    var customInspector = new CustomInspectorElement(path, inspector, inspectorContext.Root);
                    inspectorContext.Parent.contentContainer.Add(customInspector);
                }
            }

            return(true);
        }
コード例 #2
0
            public VisitStatus Visit <TContainer>(Property <TContainer, KeyValuePair <TKey, TValue> > property, ref TContainer container, ref KeyValuePair <TKey, TValue> value)
            {
                var visitor = DictionaryElement.GetVisitor();

                visitor.AddToPath(property);
                try
                {
                    var inspector = (IInspector <KeyValuePair <TKey, TValue> >) new KeyValuePairInspector <TDictionary, TKey, TValue>
                    {
                        DictionaryElement = DictionaryElement
                    };

                    inspector.Context = new InspectorContext <KeyValuePair <TKey, TValue> >(
                        visitor.VisitorContext.Root,
                        visitor.GetCurrentPath(),
                        property
                        );

                    var customInspector = new CustomInspectorElement(
                        visitor.GetCurrentPath(),
                        inspector,
                        visitor.VisitorContext.Root);
                    visitor.VisitorContext.Parent.contentContainer.Add(customInspector);
                }
                finally
                {
                    visitor.RemoveFromPath(property);
                }

                return(VisitStatus.Stop);
            }
コード例 #3
0
        protected override void VisitProperty <TContainer, TValue>(Property <TContainer, TValue> property,
                                                                   ref TContainer container, ref TValue value)
        {
            if (!RuntimeTypeInfoCache.IsContainerType(value.GetType()))
            {
                return;
            }

            var isWrapper = typeof(PropertyWrapper <TValue>).IsInstanceOfType(container);

            if (!isWrapper)
            {
                AddToPath(property);
            }

            try
            {
                var path = GetCurrentPath();
                using (var references = VisitorContext.MakeVisitedReferencesScope(this, ref value, path))
                {
                    if (references.VisitedOnCurrentBranch)
                    {
                        VisitorContext.Parent.Add(new CircularReferenceElement <TValue>(VisitorContext.Root, property, value, path, references.GetReferencePath()));
                        return;
                    }

                    var inspector = default(IInspector);
                    if (!path.Empty || EnableRootCustomInspectors)
                    {
                        var visitor = new CustomInspectorVisitor <TValue>();
                        visitor.PropertyPath = path;
                        visitor.Root         = VisitorContext.Root;
                        visitor.Property     = property;
                        PropertyContainer.Visit(ref value, visitor);
                        inspector = visitor.Inspector;
                    }

                    var old = EnableRootCustomInspectors;
                    EnableRootCustomInspectors = true;
                    if (null != inspector)
                    {
                        var customInspector = new CustomInspectorElement(path, inspector, VisitorContext.Root);
                        VisitorContext.Parent.contentContainer.Add(customInspector);
                    }
                    else
                    {
                        RecurseProperty(ref value, property, path);
                    }

                    EnableRootCustomInspectors = old;
                }
            }
            finally
            {
                if (!isWrapper)
                {
                    RemoveFromPath(property);
                }
            }
        }
コード例 #4
0
        VisitStatus VisitPrimitive <TContainer, TValue, TElement>(
            IProperty <TContainer> property,
            ref TValue value,
            DrawHandler <TContainer, TValue, TElement> handler
            )
        {
            Visitor.AddToPath(property);
            try
            {
                var path = Visitor.GetCurrentPath();

                var inspector = AllowInspector ? GetPropertyDrawer <TValue>(property, Visitor.VisitorContext.Root, path) : null;
                NoReentrace = true;
                if (null == inspector)
                {
                    handler(property, ref value, path, VisitorContext);
                }
                else
                {
                    var customInspector = new CustomInspectorElement(path, inspector, Visitor.VisitorContext.Root);
                    Visitor.VisitorContext.Parent.contentContainer.Add(customInspector);
                }
            }
            finally
            {
                Visitor.RemoveFromPath(property);
                NoReentrace = false;
            }
            return(VisitStatus.Stop);
        }
コード例 #5
0
        public VisitStatus Visit <TContainer, TValue>(Property <TContainer, TValue> property, ref TContainer container,
                                                      ref TValue value)
        {
            if (RuntimeTypeInfoCache <TValue> .IsEnum)
            {
                Visitor.AddToPath(property);
                try
                {
                    var path      = Visitor.GetCurrentPath();
                    var inspector = AllowInspector ? GetInspector <TValue>(property, VisitorContext.Root, path) : null;
                    NoReentrace = true;
                    if (null != inspector)
                    {
                        var customInspector = new CustomInspectorElement(path, inspector, Visitor.VisitorContext.Root);
                        Visitor.VisitorContext.Parent.contentContainer.Add(customInspector);
                        return(VisitStatus.Stop);
                    }
                }
                finally
                {
                    NoReentrace = false;
                    Visitor.RemoveFromPath(property);
                }

                return(RuntimeTypeInfoCache <TValue> .IsEnumFlags
                    ? VisitPrimitive(property, ref value, GuiFactory.FlagsField)
                    : VisitPrimitive(property, ref value, GuiFactory.EnumField));
            }
            return(VisitStatus.Unhandled);
        }
コード例 #6
0
        bool TryVisitWithCustomInspector <TDeclaredValue>(ref TDeclaredValue value, PropertyPath path, IProperty property)
        {
            var inspector = GetCustomInspector(ref value, path, property);
            var old       = EnableRootCustomInspectors;

            EnableRootCustomInspectors = true;
            if (null != inspector)
            {
                var customInspector = new CustomInspectorElement(path, inspector, VisitorContext.Root);
                VisitorContext.Parent.contentContainer.Add(customInspector);
                return(true);
            }
            EnableRootCustomInspectors = old;
            return(false);
        }
コード例 #7
0
            public bool Visit <TContainer>(InspectorVisitor.InspectorContext inspectorContext, IProperty <TContainer> property, ref KeyValuePair <TKey, TValue> value, PropertyPath path)
            {
                var visitor   = DictionaryElement.GetVisitor();
                var inspector =
                    (IInspector <KeyValuePair <TKey, TValue> >) new KeyValuePairPropertyInspector <TDictionary, TKey, TValue>
                {
                    DictionaryElement = DictionaryElement
                };

                inspector.Context = new InspectorContext <KeyValuePair <TKey, TValue> >(
                    visitor.Context.Root,
                    path,
                    property
                    );

                var customInspector = new CustomInspectorElement(
                    path,
                    inspector,
                    visitor.Context.Root);

                visitor.Context.Parent.contentContainer.Add(customInspector);
                return(true);
            }
        bool PrimitiveVisit <TValue, TElement>(
            InspectorContext inspectorContext,
            IProperty property,
            ref TValue value,
            PropertyPath path,
            FactoryHandler <TValue, TElement> handler)
        {
            var inspector = GetAttributeDrawer(property, ref value, path);

            if (null == inspector)
            {
                handler(property, ref value, path, inspectorContext);
            }
            else
            {
                using (inspectorContext.MakeIgnoreInspectorScope())
                {
                    var customInspector = new CustomInspectorElement(path, inspector, inspectorContext.Root);
                    inspectorContext.Parent.contentContainer.Add(customInspector);
                }
            }

            return(true);
        }
コード例 #9
0
        void IPropertyVisitor.Visit <TContainer, TValue>(
            Property <TContainer, TValue> property,
            ref TContainer container)
        {
            if (IsExcluded(property))
            {
                return;
            }

            var value     = property.GetValue(ref container);
            var isWrapper = container is PropertyWrapper <TValue>;

            Context.IsRootObject = isWrapper;

            // Null values
            if (RuntimeTypeInfoCache <TValue> .CanBeNull &&
                ShouldBeTreatedAsNull(property, ref container, ref value) &&
                ShouldStayNull(property, ref container, ref value))
            {
                using (Context.MakePathScope(property))
                {
                    if (VisitNull(Context, property, ref value, Context.CopyCurrentPath()))
                    {
                        return;
                    }
                }
            }

            foreach (var adapter in m_AdapterOverrides)
            {
                if (!(adapter is IInspectorVisit <TValue> partiallyTyped))
                {
                    continue;
                }

                using (Context.MakePathScope(property))
                {
                    if (partiallyTyped.Visit(Context, property, ref value, Context.CopyCurrentPath()))
                    {
                        return;
                    }
                }
            }

            // Primitives
            if (this is IInspectorVisit <TValue> typed)
            {
                using (Context.MakePathScope(property))
                {
                    if (typed.Visit(Context, property, ref value, Context.CopyCurrentPath()))
                    {
                        return;
                    }
                }
            }

            // UnityEngine.Object
            if (this is IInspectorContravariantVisit <TValue> contravariant)
            {
                using (Context.MakePathScope(property))
                {
                    if (contravariant.Visit(Context, property, value, Context.CopyCurrentPath()))
                    {
                        return;
                    }
                }
            }

            // Enums
            if (RuntimeTypeInfoCache <TValue> .IsEnum)
            {
                using (Context.MakePathScope(property))
                {
                    if (VisitEnum(Context, property, ref value, Context.CopyCurrentPath(), isWrapper))
                    {
                        return;
                    }
                }
            }

            try
            {
                // Regular visit
                if (!isWrapper)
                {
                    Context.AddToPath(property);
                }

                var path = Context.CopyCurrentPath();
                using (var references = Context.MakeVisitedReferencesScope(ref value, path))
                {
                    if (references.VisitedOnCurrentBranch)
                    {
                        Context.Parent.Add(new CircularReferenceElement <TValue>(Context.Root, property, value, path,
                                                                                 references.GetReferencePath()));
                        return;
                    }

                    var inspector = GetCustomInspector(property, ref value, path, isWrapper);
                    if (null != inspector)
                    {
                        var customInspector = new CustomInspectorElement(path, inspector, Context.Root);
                        Context.Parent.contentContainer.Add(customInspector);
                        return;
                    }

                    if (path.PartsCount > 0)
                    {
                        if (string.IsNullOrEmpty(GuiFactory.GetDisplayName(property)))
                        {
                            PropertyContainer.TryAccept(this, ref value);
                        }
                        else
                        {
                            // Give a chance for different property bags to handle themselves
                            if (PropertyBagStore.TryGetPropertyBagForValue(ref value, out var valuePropertyBag))
                            {
                                switch (valuePropertyBag)
                                {
                                case IDictionaryPropertyAccept <TValue> accept:
                                    accept.Accept(this, property, ref container, ref value);
                                    break;

                                case IListPropertyAccept <TValue> accept:
                                    accept.Accept(this, property, ref container, ref value);
                                    break;

                                case ISetPropertyAccept <TValue> accept:
                                    accept.Accept(this, property, ref container, ref value);
                                    break;

                                case ICollectionPropertyAccept <TValue> accept:
                                    accept.Accept(this, property, ref container, ref value);
                                    break;

                                default:
                                    var foldout = GuiFactory.Foldout <TValue>(property, path, Context);
                                    using (Context.MakeParentScope(foldout))
                                        PropertyContainer.TryAccept(this, ref value);
                                    break;
                                }
                            }
                        }
                    }
                    else
                    {
                        PropertyContainer.TryAccept(this, ref value);
                    }
                }
            }
            finally
            {
                if (!isWrapper)
                {
                    Context.RemoveFromPath(property);
                }
            }
        }