753 lines
22 KiB
C#
753 lines
22 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.Reflection;
|
|
|
|
using UniversalEditor.ObjectModels.Markup;
|
|
using UniversalEditor.DataFormats.Markup.XML;
|
|
using UniversalEditor.ObjectModels.Solution;
|
|
using UniversalEditor.Accessors;
|
|
using UniversalEditor.ObjectModels.PropertyList;
|
|
using UniversalEditor.DataFormats.PropertyList.XML;
|
|
using UniversalEditor.ObjectModels.Project;
|
|
using UniversalEditor.ObjectModels.UEPackage;
|
|
using UniversalEditor.DataFormats.UEPackage;
|
|
|
|
namespace UniversalEditor.Common
|
|
{
|
|
public static class Reflection
|
|
{
|
|
private static int _ObjectModelReferenceComparer(ObjectModelReference a, ObjectModelReference b)
|
|
{
|
|
if (a.Type.BaseType == typeof(ObjectModel) && b.Type.BaseType != typeof(ObjectModel))
|
|
{
|
|
return 1;
|
|
}
|
|
else if (a.Type.BaseType != typeof(ObjectModel) && b.Type.BaseType == typeof(ObjectModel))
|
|
{
|
|
return -1;
|
|
}
|
|
return a.Type.FullName.CompareTo(b.Type.FullName);
|
|
}
|
|
|
|
private static Type[] mvarAvailableTypes = null;
|
|
public static Type[] GetAvailableTypes(Type[] inheritsFrom = null)
|
|
{
|
|
if (mvarAvailableTypes == null)
|
|
{
|
|
List<Type> types = new List<Type>();
|
|
Assembly[] asms = GetAvailableAssemblies();
|
|
foreach (Assembly asm in asms)
|
|
{
|
|
Type[] types1 = null;
|
|
try
|
|
{
|
|
types1 = asm.GetTypes();
|
|
}
|
|
catch (ReflectionTypeLoadException ex)
|
|
{
|
|
Console.Error.WriteLine("ReflectionTypeLoadException(" + ex.LoaderExceptions.Length.ToString() + "): " + asm.FullName);
|
|
Console.Error.WriteLine(ex.Message);
|
|
|
|
types1 = ex.Types;
|
|
}
|
|
|
|
if (types1 == null) continue;
|
|
|
|
foreach (Type type in types1)
|
|
{
|
|
if (type == null) continue;
|
|
types.Add(type);
|
|
}
|
|
}
|
|
mvarAvailableTypes = types.ToArray();
|
|
}
|
|
|
|
if (inheritsFrom != null)
|
|
{
|
|
List<Type> retval = new List<Type>();
|
|
foreach (Type tAvailable in mvarAvailableTypes)
|
|
{
|
|
foreach (Type tInheritsFrom in inheritsFrom)
|
|
{
|
|
if (tAvailable.IsSubclassOf(tInheritsFrom)) retval.Add(tAvailable);
|
|
}
|
|
}
|
|
return retval.ToArray();
|
|
}
|
|
return mvarAvailableTypes;
|
|
}
|
|
|
|
#region Initialization
|
|
private static bool mvarInitialized = false;
|
|
private static void Initialize()
|
|
{
|
|
if (mvarInitialized) return;
|
|
|
|
Type[] types = GetAvailableTypes();
|
|
|
|
#region Initializing Object Models
|
|
List<AccessorReference> listAccessors = new List<AccessorReference>();
|
|
List<ObjectModelReference> listObjectModels = new List<ObjectModelReference>();
|
|
List<DataFormatReference> listDataFormats = new List<DataFormatReference>();
|
|
List<DocumentTemplate> listDocumentTemplates = new List<DocumentTemplate>();
|
|
List<ProjectTemplate> listProjectTemplates = new List<ProjectTemplate>();
|
|
List<ConverterReference> listConverters = new List<ConverterReference>();
|
|
List<ProjectType> listProjectTypes = new List<ProjectType>();
|
|
{
|
|
foreach (Type type in types)
|
|
{
|
|
if (type == null) continue;
|
|
if (mvarAvailableObjectModels == null && (type.IsSubclassOf(typeof(ObjectModel)) && !type.IsAbstract))
|
|
{
|
|
ObjectModel tmp = null;
|
|
|
|
try
|
|
{
|
|
tmp = (type.Assembly.CreateInstance(type.FullName) as ObjectModel);
|
|
}
|
|
catch (TargetInvocationException)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
ObjectModelReference omr = tmp.MakeReference();
|
|
|
|
if (!listObjectModels.Contains(omr))
|
|
listObjectModels.Add(omr);
|
|
}
|
|
else if (mvarAvailableAccessors == null && (type.IsSubclassOf(typeof(Accessor)) && !type.IsAbstract))
|
|
{
|
|
try
|
|
{
|
|
Accessor a = (type.Assembly.CreateInstance(type.FullName) as Accessor);
|
|
AccessorReference ar = a.MakeReference();
|
|
if (ar != null)
|
|
{
|
|
if (!listAccessors.Contains(ar))
|
|
listAccessors.Add(ar);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
else if (mvarAvailableDataFormats == null && (type.IsSubclassOf(typeof(DataFormat)) && !type.IsAbstract))
|
|
{
|
|
try
|
|
{
|
|
DataFormat df = (type.Assembly.CreateInstance(type.FullName) as DataFormat);
|
|
DataFormatReference dfr = df.MakeReference();
|
|
if (dfr != null)
|
|
{
|
|
if (!listDataFormats.Contains(dfr))
|
|
listDataFormats.Add(dfr);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
else if (mvarAvailableDocumentTemplates == null && (type.IsSubclassOf(typeof(DocumentTemplate)) && !type.IsAbstract))
|
|
{
|
|
DocumentTemplate template = (type.Assembly.CreateInstance(type.FullName) as DocumentTemplate);
|
|
if (template != null)
|
|
{
|
|
if (!listDocumentTemplates.Contains(template))
|
|
listDocumentTemplates.Add(template);
|
|
}
|
|
}
|
|
else if (mvarAvailableConverters == null && (type.IsSubclassOf(typeof(Converter)) && !type.IsAbstract))
|
|
{
|
|
Converter item = (type.Assembly.CreateInstance(type.FullName) as Converter);
|
|
if (item != null)
|
|
{
|
|
ConverterReference cr = item.MakeReference();
|
|
if (!listConverters.Contains(cr))
|
|
listConverters.Add(cr);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
listObjectModels.Sort(new Comparison<ObjectModelReference>(_ObjectModelReferenceComparer));
|
|
listDataFormats.Sort(new Comparison<DataFormatReference>(_DataFormatReferenceComparer));
|
|
#endregion
|
|
|
|
InitializeFromXML(ref listObjectModels, ref listDataFormats, ref listProjectTypes, ref listDocumentTemplates, ref listProjectTemplates);
|
|
mvarInitialized = true;
|
|
|
|
if (mvarAvailableObjectModels == null) mvarAvailableObjectModels = listObjectModels.ToArray();
|
|
if (mvarAvailableDataFormats == null) mvarAvailableDataFormats = listDataFormats.ToArray();
|
|
if (mvarAvailableProjectTypes == null) mvarAvailableProjectTypes = listProjectTypes.ToArray();
|
|
if (mvarAvailableConverters == null) mvarAvailableConverters = listConverters.ToArray();
|
|
|
|
if (mvarAvailableDocumentTemplates == null) mvarAvailableDocumentTemplates = listDocumentTemplates.ToArray();
|
|
if (mvarAvailableProjectTemplates == null) mvarAvailableProjectTemplates = listProjectTemplates.ToArray();
|
|
if (mvarAvailableAccessors == null) mvarAvailableAccessors = listAccessors.ToArray();
|
|
}
|
|
|
|
private static int _DataFormatReferenceComparer(DataFormatReference dfr1, DataFormatReference dfr2)
|
|
{
|
|
if (dfr1.Type.IsAbstract)
|
|
{
|
|
return 1;
|
|
}
|
|
if (dfr2.Type.IsAbstract)
|
|
{
|
|
return -1;
|
|
}
|
|
return dfr2.Priority.CompareTo(dfr1.Priority);
|
|
}
|
|
|
|
// FIXME: refactor this into a single XML configuration file loader at the beginning of engine launch
|
|
private static void InitializeFromXML(ref List<ObjectModelReference> listObjectModels, ref List<DataFormatReference> listDataFormats, ref List<ProjectType> listProjectTypes, ref List<DocumentTemplate> listDocumentTemplates, ref List<ProjectTemplate> listProjectTemplates)
|
|
{
|
|
System.Collections.Specialized.StringCollection paths = new System.Collections.Specialized.StringCollection();
|
|
paths.Add(System.Environment.CurrentDirectory);
|
|
paths.Add(System.IO.Path.Combine(new string[]
|
|
{
|
|
System.Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "universal-editor"
|
|
}));
|
|
|
|
foreach (string path in paths)
|
|
{
|
|
string configurationFileNameFilter = System.Configuration.ConfigurationManager.AppSettings["UniversalEditor.Configuration.ConfigurationFileNameFilter"];
|
|
if (configurationFileNameFilter == null) configurationFileNameFilter = "*.uexml";
|
|
|
|
string[] XMLFileNames = null;
|
|
XMLFileNames = System.IO.Directory.GetFiles(path, configurationFileNameFilter, System.IO.SearchOption.AllDirectories);
|
|
foreach (string fileName in XMLFileNames)
|
|
{
|
|
#if !DEBUG
|
|
try
|
|
{
|
|
#endif
|
|
string basePath = System.IO.Path.GetDirectoryName(fileName);
|
|
|
|
UEPackageObjectModel mom = new UEPackageObjectModel();
|
|
UEPackageXMLDataFormat xdf = new UEPackageXMLDataFormat();
|
|
xdf.IncludeTemplates = false;
|
|
ObjectModel om = mom;
|
|
|
|
try
|
|
{
|
|
Document.Load(om, xdf, new FileAccessor(fileName, false, false, false), true);
|
|
}
|
|
catch (InvalidDataFormatException ex)
|
|
{
|
|
// ignore it
|
|
}
|
|
|
|
foreach (ProjectType projtype in mom.ProjectTypes)
|
|
{
|
|
listProjectTypes.Add(projtype);
|
|
}
|
|
#if !DEBUG
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// ensure project types are loaded before running the next pass
|
|
mvarAvailableProjectTypes = listProjectTypes.ToArray();
|
|
|
|
foreach (string fileName in XMLFileNames)
|
|
{
|
|
try
|
|
{
|
|
string basePath = System.IO.Path.GetDirectoryName(fileName);
|
|
|
|
UEPackageObjectModel mom = new UEPackageObjectModel();
|
|
UEPackageXMLDataFormat xdf = new UEPackageXMLDataFormat();
|
|
xdf.IncludeProjectTypes = false;
|
|
ObjectModel om = mom;
|
|
|
|
Document.Load(om, xdf, new FileAccessor(fileName, false, false, false), true);
|
|
|
|
foreach (DocumentTemplate template in mom.DocumentTemplates)
|
|
{
|
|
listDocumentTemplates.Add(template);
|
|
}
|
|
foreach (ProjectTemplate template in mom.ProjectTemplates)
|
|
{
|
|
listProjectTemplates.Add(template);
|
|
}
|
|
|
|
foreach (Association assoc in mom.Associations)
|
|
{
|
|
Association.Register(assoc);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Object Models
|
|
private static ObjectModelReference[] mvarAvailableObjectModels = null;
|
|
public static ObjectModelReference[] GetAvailableObjectModels()
|
|
{
|
|
if (mvarAvailableObjectModels == null) Initialize();
|
|
return mvarAvailableObjectModels;
|
|
}
|
|
|
|
public static T GetAvailableObjectModel<T>(string filename) where T : ObjectModel
|
|
{
|
|
return GetAvailableObjectModel<T>(new FileAccessor(filename));
|
|
}
|
|
public static T GetAvailableObjectModel<T>(Accessor accessor) where T : ObjectModel
|
|
{
|
|
ObjectModelReference[] omrs = GetAvailableObjectModels(accessor);
|
|
if (omrs.Length == 0)
|
|
{
|
|
// we failed to find an object model from the accessor, so let's try and
|
|
// force the loading of the object model we're told to load in the first place
|
|
|
|
Type type = typeof(T);
|
|
ObjectModel om = (ObjectModel)type.Assembly.CreateInstance(type.FullName);
|
|
ObjectModelReference omr = om.MakeReference();
|
|
|
|
DataFormatReference[] dfrs = GetAvailableDataFormats(omr);
|
|
|
|
foreach (DataFormatReference dfr in dfrs)
|
|
{
|
|
try
|
|
{
|
|
DataFormat df = dfr.Create();
|
|
Document.Load(om, df, accessor);
|
|
break;
|
|
}
|
|
catch (InvalidDataFormatException ex)
|
|
{
|
|
accessor.Close ();
|
|
continue;
|
|
}
|
|
catch (NotImplementedException ex)
|
|
{
|
|
accessor.Close ();
|
|
continue;
|
|
}
|
|
}
|
|
return (T)om;
|
|
}
|
|
foreach (ObjectModelReference omr in omrs)
|
|
{
|
|
if (omr.Type == typeof(T))
|
|
{
|
|
ObjectModel om = (T)omr.Create();
|
|
|
|
DataFormatReference[] dfrs = GetAvailableDataFormats(accessor, omr);
|
|
foreach (DataFormatReference dfr in dfrs)
|
|
{
|
|
DataFormat df = dfr.Create();
|
|
Document doc = new Document(om, df, accessor);
|
|
try
|
|
{
|
|
doc.InputAccessor.Open();
|
|
doc.Load();
|
|
doc.InputAccessor.Close();
|
|
break;
|
|
}
|
|
catch (InvalidDataFormatException ex)
|
|
{
|
|
if (!(Array.IndexOf(dfrs, df) < dfrs.Length - 1))
|
|
{
|
|
throw ex;
|
|
}
|
|
doc.InputAccessor.Close();
|
|
}
|
|
}
|
|
return (T)om;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
public static bool GetAvailableObjectModel<T>(string filename, ref T objectToFill) where T : ObjectModel
|
|
{
|
|
return GetAvailableObjectModel<T>(new FileAccessor(filename), ref objectToFill);
|
|
}
|
|
public static bool GetAvailableObjectModel<T>(Accessor accessor, ref T objectToFill) where T : ObjectModel
|
|
{
|
|
ObjectModel om = (T)objectToFill;
|
|
DataFormatReference[] dfrs = GetAvailableDataFormats(accessor);
|
|
if (dfrs.Length == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
for (int i = 0; i < dfrs.Length; i++)
|
|
{
|
|
DataFormat df = dfrs[i].Create();
|
|
Document doc = new Document(om, df, accessor);
|
|
try
|
|
{
|
|
doc.InputAccessor.Open();
|
|
doc.Load();
|
|
doc.InputAccessor.Close();
|
|
|
|
return true;
|
|
}
|
|
catch (DataFormatException)
|
|
{
|
|
doc.InputAccessor.Close();
|
|
}
|
|
catch (NotSupportedException)
|
|
{
|
|
doc.InputAccessor.Close();
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static ObjectModelReference[] GetAvailableObjectModels(DataFormatReference dfr)
|
|
{
|
|
return GetAvailableObjectModels(dfr, DataFormatCapabilities.All);
|
|
}
|
|
public static ObjectModelReference[] GetAvailableObjectModels(DataFormatReference dfr, DataFormatCapabilities capabilities)
|
|
{
|
|
ObjectModelReference[] array = GetAvailableObjectModels();
|
|
List<ObjectModelReference> list = new List<ObjectModelReference>();
|
|
|
|
foreach (ObjectModelReference om in array)
|
|
{
|
|
if ((dfr.Capabilities[om.Type] & capabilities) == capabilities)
|
|
{
|
|
list.Add(om);
|
|
}
|
|
}
|
|
return list.ToArray();
|
|
}
|
|
public static ObjectModelReference[] GetAvailableObjectModels(Accessor accessor, DataFormatCapabilities capabilities = DataFormatCapabilities.All)
|
|
{
|
|
ObjectModelReference[] array = GetAvailableObjectModels();
|
|
DataFormatReference[] dfs = GetAvailableDataFormats(accessor);
|
|
List<ObjectModelReference> list = new List<ObjectModelReference>();
|
|
if (dfs.Length == 0) return list.ToArray();
|
|
|
|
foreach (ObjectModelReference om in array)
|
|
{
|
|
if (om == null) continue;
|
|
|
|
foreach (DataFormatReference df in dfs)
|
|
{
|
|
if (df == null) continue;
|
|
if ((df.Capabilities[om.Type] & capabilities) == capabilities)
|
|
{
|
|
list.Add(om);
|
|
}
|
|
}
|
|
}
|
|
return list.ToArray();
|
|
}
|
|
public static ObjectModelReference GetAvailableObjectModelByTypeName(string TypeName)
|
|
{
|
|
ObjectModelReference[] omrs = GetAvailableObjectModels();
|
|
foreach (ObjectModelReference omr in omrs)
|
|
{
|
|
if (omr.Type.FullName == TypeName)
|
|
{
|
|
return omr;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
public static ObjectModelReference GetAvailableObjectModelByID(Guid ID)
|
|
{
|
|
ObjectModelReference[] omrs = GetAvailableObjectModels();
|
|
foreach (ObjectModelReference omr in omrs)
|
|
{
|
|
if (omr.ID == ID)
|
|
{
|
|
return omr;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
#endregion
|
|
#region Converters
|
|
private static ConverterReference[] mvarAvailableConverters = null;
|
|
public static ConverterReference[] GetAvailableConverters()
|
|
{
|
|
if (mvarAvailableConverters == null) Initialize();
|
|
return mvarAvailableConverters;
|
|
}
|
|
public static ConverterReference[] GetAvailableConverters(Type from, Type to)
|
|
{
|
|
ConverterReference[] crs = GetAvailableConverters();
|
|
List<ConverterReference> list = new List<ConverterReference>();
|
|
foreach (ConverterReference cr in crs)
|
|
{
|
|
if (cr.Capabilities.Contains(from, to)) list.Add(cr);
|
|
}
|
|
return list.ToArray();
|
|
}
|
|
#endregion
|
|
#region Accessors
|
|
private static AccessorReference[] mvarAvailableAccessors = null;
|
|
public static AccessorReference[] GetAvailableAccessors()
|
|
{
|
|
if (mvarAvailableAccessors == null) Initialize();
|
|
return mvarAvailableAccessors;
|
|
}
|
|
public static AccessorReference[] GetAvailableAccessors(string fileName)
|
|
{
|
|
AccessorReference[] accrefs = GetAvailableAccessors();
|
|
List<AccessorReference> _list = new List<AccessorReference>();
|
|
foreach (AccessorReference ar in accrefs)
|
|
{
|
|
foreach (string schema in ar.Schemas)
|
|
{
|
|
if (fileName.StartsWith(schema + "://"))
|
|
{
|
|
_list.Add(ar);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return _list.ToArray();
|
|
}
|
|
#endregion
|
|
#region Data Formats
|
|
private static DataFormatReference[] mvarAvailableDataFormats = null;
|
|
public static DataFormatReference[] GetAvailableDataFormats()
|
|
{
|
|
if (mvarAvailableDataFormats == null) Initialize();
|
|
return mvarAvailableDataFormats;
|
|
}
|
|
|
|
public static DataFormatReference[] GetAvailableDataFormats(string filename)
|
|
{
|
|
Association[] associations = Association.FromCriteria(new AssociationCriteria() { FileName = filename });
|
|
List<DataFormatReference> list = new List<DataFormatReference>();
|
|
foreach (Association association in associations)
|
|
{
|
|
for (int i = 0; i < association.DataFormats.Count; i++)
|
|
{
|
|
list.Add(association.DataFormats[i]);
|
|
}
|
|
}
|
|
list.Sort(new Comparison<DataFormatReference>(_DataFormatReferenceComparer));
|
|
return list.ToArray();
|
|
}
|
|
public static DataFormatReference[] GetAvailableDataFormats(Accessor accessor)
|
|
{
|
|
bool needsOpen = false;
|
|
if (!accessor.IsOpen)
|
|
{
|
|
// we need to open the accessor before we can sniff the file
|
|
needsOpen = true;
|
|
accessor.Open();
|
|
}
|
|
|
|
Association[] associations = Association.FromCriteria(new AssociationCriteria() { Accessor = accessor });
|
|
List<DataFormatReference> list = new List<DataFormatReference>();
|
|
foreach (Association association in associations)
|
|
{
|
|
for (int i = 0; i < association.DataFormats.Count; i++)
|
|
{
|
|
list.Add(association.DataFormats[i]);
|
|
}
|
|
}
|
|
list.Sort(new Comparison<DataFormatReference>(_DataFormatReferenceComparer));
|
|
|
|
if (needsOpen)
|
|
{
|
|
// close the accessor since we're done with it
|
|
accessor.Close();
|
|
}
|
|
return list.ToArray();
|
|
}
|
|
|
|
public static DataFormatReference[] GetAvailableDataFormats(ObjectModelReference objectModelReference)
|
|
{
|
|
List<DataFormatReference> list = new List<DataFormatReference>();
|
|
DataFormatReference[] dfs = GetAvailableDataFormats();
|
|
foreach (DataFormatReference df in dfs)
|
|
{
|
|
if (df.Capabilities[objectModelReference.Type] != DataFormatCapabilities.None)
|
|
{
|
|
list.Add(df);
|
|
}
|
|
}
|
|
return list.ToArray();
|
|
}
|
|
public static DataFormatReference[] GetAvailableDataFormats(Accessor accessor, ObjectModelReference omr)
|
|
{
|
|
AssociationCriteria ac = new AssociationCriteria() { Accessor = accessor, ObjectModel = omr };
|
|
Association[] associations = Association.FromCriteria(ac);
|
|
List<DataFormatReference> dfrs = new List<DataFormatReference>();
|
|
foreach (Association assocs in associations)
|
|
{
|
|
for (int i = 0; i < assocs.DataFormats.Count; i++)
|
|
{
|
|
dfrs.Add(assocs.DataFormats[i]);
|
|
}
|
|
}
|
|
return dfrs.ToArray();
|
|
}
|
|
public static DataFormatReference GetDataFormatByTypeName(string TypeName)
|
|
{
|
|
DataFormatReference[] dfrs = GetAvailableDataFormats();
|
|
foreach (DataFormatReference dfr in dfrs)
|
|
{
|
|
if (dfr.Type.FullName == TypeName)
|
|
{
|
|
return dfr;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
#endregion
|
|
#region Assemblies
|
|
private static Assembly[] mvarAvailableAssemblies = null;
|
|
public static Assembly[] GetAvailableAssemblies()
|
|
{
|
|
if (mvarAvailableAssemblies == null)
|
|
{
|
|
List<Assembly> list = new List<Assembly>();
|
|
|
|
List<string> asmdirs = new List<string>();
|
|
string dir = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
|
|
asmdirs.Add(dir);
|
|
asmdirs.Add(dir + System.IO.Path.DirectorySeparatorChar.ToString() + "Plugins");
|
|
|
|
foreach (string asmdir in asmdirs)
|
|
{
|
|
if (!System.IO.Directory.Exists(asmdir)) continue;
|
|
|
|
string[] FileNamesEXE = System.IO.Directory.GetFiles(asmdir, "*.exe", System.IO.SearchOption.TopDirectoryOnly);
|
|
string[] FileNamesDLL = System.IO.Directory.GetFiles(asmdir, "*.dll", System.IO.SearchOption.TopDirectoryOnly);
|
|
|
|
string[] FileNames = new string[FileNamesEXE.Length + FileNamesDLL.Length];
|
|
Array.Copy(FileNamesEXE, 0, FileNames, 0, FileNamesEXE.Length);
|
|
Array.Copy(FileNamesDLL, 0, FileNames, FileNamesEXE.Length, FileNamesDLL.Length);
|
|
|
|
foreach (string FileName in FileNames)
|
|
{
|
|
try
|
|
{
|
|
Assembly asm = Assembly.LoadFile(FileName);
|
|
list.Add(asm);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
mvarAvailableAssemblies = list.ToArray();
|
|
}
|
|
return mvarAvailableAssemblies;
|
|
}
|
|
#endregion
|
|
|
|
private static DocumentTemplate[] mvarAvailableDocumentTemplates = null;
|
|
public static DocumentTemplate[] GetAvailableDocumentTemplates()
|
|
{
|
|
if (mvarAvailableDocumentTemplates == null) Initialize();
|
|
return mvarAvailableDocumentTemplates;
|
|
}
|
|
public static DocumentTemplate[] GetAvailableDocumentTemplates(ObjectModelReference omr)
|
|
{
|
|
DocumentTemplate[] templates = GetAvailableDocumentTemplates();
|
|
List<DocumentTemplate> retval = new List<DocumentTemplate>();
|
|
foreach (DocumentTemplate template in templates)
|
|
{
|
|
if (template.ObjectModelReference != null)
|
|
{
|
|
if (omr == null || (template.ObjectModelReference.TypeName == omr.TypeName || (template.ObjectModelReference.ID != Guid.Empty && template.ObjectModelReference.ID == omr.ID)))
|
|
{
|
|
retval.Add(template);
|
|
}
|
|
}
|
|
}
|
|
return retval.ToArray();
|
|
}
|
|
|
|
private static ProjectTemplate[] mvarAvailableProjectTemplates = null;
|
|
public static ProjectTemplate[] GetAvailableProjectTemplates()
|
|
{
|
|
if (mvarAvailableProjectTemplates == null) Initialize();
|
|
return mvarAvailableProjectTemplates;
|
|
}
|
|
|
|
private static ProjectType[] mvarAvailableProjectTypes = null;
|
|
public static ProjectType GetProjectTypeByTypeID(Guid guid)
|
|
{
|
|
if (mvarAvailableProjectTypes == null) Initialize();
|
|
foreach (ProjectType type in mvarAvailableProjectTypes)
|
|
{
|
|
if (type.ID == guid) return type;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
#if HANDLER
|
|
private static HandlerReference[] mvarAvailableHandlers = null;
|
|
public static HandlerReference[] GetAvailableHandlers()
|
|
{
|
|
if (mvarAvailableHandlers == null) Initialize();
|
|
return mvarAvailableHandlers;
|
|
}
|
|
public static HandlerReference[] GetAvailableHandlers(string FileName)
|
|
{
|
|
if (mvarAvailableHandlers == null) Initialize();
|
|
List<HandlerReference> handlers = new List<HandlerReference>();
|
|
foreach (HandlerReference hr in mvarAvailableHandlers)
|
|
{
|
|
if (hr is FileHandlerReference)
|
|
{
|
|
FileHandlerReference fh = (hr as FileHandlerReference);
|
|
if (!fh.Supports(FileName)) continue;
|
|
|
|
handlers.Add(fh);
|
|
}
|
|
}
|
|
return handlers.ToArray();
|
|
}
|
|
#endif
|
|
|
|
public static ObjectModel GetAvailableObjectModel(byte[] data, string filename, string ObjectModelTypeName)
|
|
{
|
|
return GetAvailableObjectModel(new MemoryAccessor(data, filename), ObjectModelTypeName);
|
|
}
|
|
public static ObjectModel GetAvailableObjectModel(Accessor accessor, string ObjectModelTypeName)
|
|
{
|
|
long resetpos = accessor.Position;
|
|
|
|
DataFormatReference[] dfrs = GetAvailableDataFormats(accessor);
|
|
foreach (DataFormatReference dfr in dfrs)
|
|
{
|
|
ObjectModelReference[] omrs = GetAvailableObjectModels(dfr);
|
|
foreach (ObjectModelReference omr in omrs)
|
|
{
|
|
if (omr.Type.FullName == ObjectModelTypeName)
|
|
{
|
|
ObjectModel om = omr.Create();
|
|
if (om == null) return null;
|
|
|
|
DataFormat df = dfr.Create();
|
|
try
|
|
{
|
|
Document.Load(om, df, accessor);
|
|
}
|
|
catch (InvalidDataFormatException)
|
|
{
|
|
accessor.Position = resetpos;
|
|
break;
|
|
}
|
|
|
|
return om;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
}
|