public static ProcessorTypeDescription FindProcessor(string name, ImporterTypeDescription importer) { if (!string.IsNullOrEmpty(name)) { name = RemapOldNames(name); foreach (var i in Processors) { if (i.TypeName.Equals(name)) { return(i); } } //Debug.Fail(string.Format("Processor not found! name={0}, importer={1}", name, importer)); return(null); } if (importer != null) { foreach (var i in Processors) { if (i.TypeName.Equals(importer.DefaultProcessor)) { return(i); } } } //Debug.Fail(string.Format("Processor not found! name={0}, importer={1}", name, importer)); return(null); }
static PipelineTypes() { AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve; MissingImporter = new ImporterTypeDescription() { DisplayName = "Invalid / Missing Importer", }; MissingProcessor = new ProcessorTypeDescription() { DisplayName = "Invalid / Missing Processor", Properties = new ProcessorTypeDescription.ProcessorPropertyCollection(Array.Empty <ProcessorTypeDescription.Property>()), }; NullImporter = new ImporterTypeDescription() { DisplayName = "", }; NullProcessor = new ProcessorTypeDescription() { DisplayName = "", Properties = new ProcessorTypeDescription.ProcessorPropertyCollection(Array.Empty <ProcessorTypeDescription.Property>()), }; _watchers = new List <FileSystemWatcher>(); }
public void ResolveTypes() { if (BuildAction == BuildAction.Copy) { // Copy items do not have importers or processors. _importer = PipelineTypes.NullImporter; _processor = PipelineTypes.NullProcessor; } else { _importer = PipelineTypes.FindImporter(ImporterName, System.IO.Path.GetExtension(OriginalPath)); if (_importer != null && (string.IsNullOrEmpty(ImporterName) || ImporterName != _importer.TypeName)) ImporterName = _importer.TypeName; if (_importer == null) _importer = PipelineTypes.MissingImporter; _processor = PipelineTypes.FindProcessor(ProcessorName, _importer); if (_processor != null && (string.IsNullOrEmpty(ProcessorName) || ProcessorName != _processor.TypeName)) ProcessorName = _processor.TypeName; if (_processor == null) _processor = PipelineTypes.MissingProcessor; // ProcessorParams get deserialized as strings // this code converts them to object(s) of their actual type // so that the correct editor appears within the property grid. foreach (var p in _processor.Properties) { if (!ProcessorParams.ContainsKey(p.Name)) { ProcessorParams[p.Name] = p.DefaultValue; } else { var src = ProcessorParams[p.Name]; if (src != null) { var srcType = src.GetType(); var converter = PipelineTypes.FindConverter(p.Type); // Should we throw an exception here? // This property will actually not be editable in the property grid // since we do not have a type converter for it. if (converter.CanConvertFrom(srcType)) { var dst = converter.ConvertFrom(null, CultureInfo.InvariantCulture, src); ProcessorParams[p.Name] = dst; } } } } } }
public static void Load(PipelineProject project) { Unload(); var assemblyPaths = new List <string>(); var projectRoot = project.Location; foreach (var i in project.References) { var path = Path.Combine(projectRoot, i); if (string.IsNullOrEmpty(path)) { throw new ArgumentException("assemblyFilePath cannot be null!"); } if (!Path.IsPathRooted(path)) { throw new ArgumentException("assemblyFilePath must be absolute!"); } // Make sure we're not adding the same assembly twice. path = PathHelper.Normalize(path); if (!assemblyPaths.Contains(path)) { assemblyPaths.Add(path); } } ResolveAssemblies(assemblyPaths); var importerDescriptions = new ImporterTypeDescription[_importers.Count]; var cur = 0; foreach (var item in _importers) { // Find the abstract base class ContentImporter<T>. var baseType = item.Type.BaseType; while (!baseType.IsAbstract) { baseType = baseType.BaseType; } var outputType = baseType.GetGenericArguments()[0]; var name = item.Attribute.DisplayName; if (string.IsNullOrEmpty(name)) { name = item.GetType().Name; } var desc = new ImporterTypeDescription() { TypeName = item.Type.Name, DisplayName = name, DefaultProcessor = item.Attribute.DefaultProcessor, FileExtensions = item.Attribute.FileExtensions, OutputType = outputType, }; importerDescriptions[cur] = desc; cur++; } Importers = importerDescriptions; ImportersStandardValuesCollection = new TypeConverter.StandardValuesCollection(Importers); var processorDescriptions = new ProcessorTypeDescription[_processors.Count]; const BindingFlags bindings = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static; cur = 0; foreach (var item in _processors) { var obj = Activator.CreateInstance(item.Type); var typeProperties = item.Type.GetProperties(bindings); var properties = new List <ProcessorTypeDescription.Property>(); foreach (var i in typeProperties) { var attrs = i.GetCustomAttributes(true); var name = i.Name; var browsable = true; var defvalue = i.GetValue(obj, null); foreach (var a in attrs) { if (a is BrowsableAttribute) { browsable = (a as BrowsableAttribute).Browsable; } else if (a is DisplayNameAttribute) { name = (a as DisplayNameAttribute).DisplayName; } } var p = new ProcessorTypeDescription.Property() { Name = i.Name, DisplayName = name, Type = i.PropertyType, DefaultValue = defvalue, Browsable = browsable }; properties.Add(p); } var inputType = (obj as IContentProcessor).InputType; var desc = new ProcessorTypeDescription() { TypeName = item.Type.Name, DisplayName = item.Attribute.DisplayName, Properties = new ProcessorTypeDescription.ProcessorPropertyCollection(properties), InputType = inputType, }; if (string.IsNullOrEmpty(desc.DisplayName)) { desc.DisplayName = desc.TypeName; } processorDescriptions[cur] = desc; cur++; } Processors = processorDescriptions; ProcessorsStandardValuesCollection = new TypeConverter.StandardValuesCollection(Processors); }