Exemple #1
0
 public void ProcessFieldsForType(List <FieldInfo> fields, Component affectedComponent,
                                  ExposedConfiguration configuration)
 {
     foreach (var field in fields)
     {
         ProcessField(field, affectedComponent, configuration);
     }
 }
Exemple #2
0
        public void Should_use_version_from_assembly()
        {
            var source = new ExposedConfiguration();

            var values = new ExposedValues(source, A.Fake <IConfiguration>(), typeof(ExposedValuesTests).Assembly);

            Assert.Equal("1.0.0.0", values["version"]);
        }
Exemple #3
0
        public void Should_create_from_configuration()
        {
            var source = new ExposedConfiguration
            {
                ["name1"] = "config1",
                ["name2"] = "config2",
                ["name3"] = "config3"
            };

            var configuration = A.Fake <IConfiguration>();

            SetupConfiguration(configuration, "config1", "value1");
            SetupConfiguration(configuration, "config2", "value2");

            var values = new ExposedValues(source, configuration);

            Assert.Equal(2, values.Count);
            Assert.Equal("value1", values["name1"]);
            Assert.Equal("value2", values["name2"]);
        }
Exemple #4
0
        private void ProcessField(FieldInfo field, Component affectedComponent, ExposedConfiguration configuration)
        {
            ExposedPropertyConfiguration propertyConfiguration = configuration.ScriptConfigurationManager.GetPropertyConfiguration(field.Name);

            if (propertyConfiguration.Enabled)
            {
                //singlefield
                if (!_arrayTypeUtils.IsSupportedArrayType(field.FieldType))
                {
                    _propertyProcessorManager.ProcessSingleFieldWithProcessor(propertyConfiguration,
                                                                              affectedComponent, field, field.FieldType);
                }
                //arrayfield
                else
                {
                    _propertyProcessorManager.ProcessArrayFieldWithProcessor(propertyConfiguration,
                                                                             affectedComponent, field, _arrayTypeUtils.GetElementTypeFromArray(field.FieldType));
                }
            }
        }
Exemple #5
0
        public ExposedValues(ExposedConfiguration configured, IConfiguration configuration, Assembly assembly = null)
        {
            Guard.NotNull(configured, nameof(configured));
            Guard.NotNull(configuration, nameof(configuration));

            foreach (var kvp in configured)
            {
                var value = configuration.GetValue <string>(kvp.Value);

                if (!string.IsNullOrWhiteSpace(value))
                {
                    this[kvp.Key] = value;
                }
            }

            if (assembly != null)
            {
                if (!ContainsKey("version"))
                {
                    this["version"] = assembly.GetName().Version.ToString();
                }
            }
        }
Exemple #6
0
        public void OnEnable()
        {
            _configFieldRenderer = ExposedEditorDi.Instance.Container.Resolve <IConfigFieldRenderer>();

            _exposedConfiguration = (ExposedConfiguration)target;
        }
Exemple #7
0
        private void RenderFieldForType(FieldInfo field, Component affectedComponent, ExposedConfiguration configuration)
        {
            string fieldId = field.Name;
            ExposedPropertyConfiguration propertyConfiguration = configuration.ScriptConfigurationManager.GetPropertyConfiguration(fieldId);

            EditorGUILayout.BeginHorizontal();
            RenderFieldReferencesInformation(field, affectedComponent);
            string typeName = _arrayTypeUtils.GetFormatedType(field.FieldType);

            _configFieldRenderer.RenderConfigField(affectedComponent, propertyConfiguration, fieldId, typeName);
        }