internal RuntimeAddin(AddinEngine addinEngine, RuntimeAddin parentAddin, ModuleDescription module)
{
this.addinEngine = addinEngine;
this.parentAddin = parentAddin;
this.module = module;
id = parentAddin.id;
baseDirectory = parentAddin.baseDirectory;
privatePath = parentAddin.privatePath;
ainfo = parentAddin.ainfo;
localizer = parentAddin.localizer;
module.RuntimeAddin = this;
}
void AddChildExtensions (AddinDescription conf, ModuleDescription module, AddinUpdateData updateData, string path, ExtensionNodeDescriptionCollection nodes, bool conditionChildren)
{
// Don't register conditions as extension nodes.
if (!conditionChildren)
updateData.RegisterExtension (conf, module, path);
foreach (ExtensionNodeDescription node in nodes) {
if (node.NodeName == "ComplexCondition")
continue;
relExtensionNodes++;
string id = node.GetAttribute ("id");
if (id.Length != 0)
AddChildExtensions (conf, module, updateData, path + "/" + id, node.ChildNodes, node.NodeName == "Condition");
}
}
void ScanAssemblyContents(IAssemblyReflector reflector, AddinDescription config, ModuleDescription module, object asm, AddinScanResult scanResult)
{
bool isMainModule = module == config.MainModule;
// Get dependencies
object[] deps = reflector.GetCustomAttributes (asm, typeof(AddinDependencyAttribute), false);
foreach (AddinDependencyAttribute dep in deps) {
AddinDependency adep = new AddinDependency ();
adep.AddinId = dep.Id;
adep.Version = dep.Version;
module.Dependencies.Add (adep);
}
if (isMainModule) {
// Get properties
object[] props = reflector.GetCustomAttributes (asm, typeof(AddinPropertyAttribute), false);
foreach (AddinPropertyAttribute prop in props)
config.Properties.SetPropertyValue (prop.Name, prop.Value, prop.Locale);
// Get extension points
object[] extPoints = reflector.GetCustomAttributes (asm, typeof(ExtensionPointAttribute), false);
foreach (ExtensionPointAttribute ext in extPoints) {
ExtensionPoint ep = config.AddExtensionPoint (ext.Path);
ep.Description = ext.Description;
ep.Name = ext.Name;
ExtensionNodeType nt = ep.AddExtensionNode (ext.NodeName, ext.NodeTypeName);
nt.ExtensionAttributeTypeName = ext.ExtensionAttributeTypeName;
}
}
// Look for extension nodes declared using assembly attributes
foreach (CustomAttribute att in reflector.GetRawCustomAttributes (asm, typeof(CustomExtensionAttribute), true))
AddCustomAttributeExtension (module, att, "Type");
// Get extensions or extension points applied to types
foreach (object t in reflector.GetAssemblyTypes (asm)) {
string typeFullName = reflector.GetTypeFullName (t);
// Look for extensions
object[] extensionAtts = reflector.GetCustomAttributes (t, typeof(ExtensionAttribute), false);
if (extensionAtts.Length > 0) {
Dictionary<string,ExtensionNodeDescription> nodes = new Dictionary<string, ExtensionNodeDescription> ();
ExtensionNodeDescription uniqueNode = null;
foreach (ExtensionAttribute eatt in extensionAtts) {
string path;
string nodeName = eatt.NodeName;
if (eatt.TypeName.Length > 0) {
path = "$" + eatt.TypeName;
}
else if (eatt.Path.Length == 0) {
path = GetBaseTypeNameList (reflector, t);
if (path == "$") {
// The type does not implement any interface and has no superclass.
// Will be reported later as an error.
path = "$" + typeFullName;
}
} else {
path = eatt.Path;
}
ExtensionNodeDescription elem = module.AddExtensionNode (path, nodeName);
nodes [path] = elem;
uniqueNode = elem;
if (eatt.Id.Length > 0) {
elem.SetAttribute ("id", eatt.Id);
elem.SetAttribute ("type", typeFullName);
} else {
elem.SetAttribute ("id", typeFullName);
}
if (eatt.InsertAfter.Length > 0)
elem.SetAttribute ("insertafter", eatt.InsertAfter);
if (eatt.InsertBefore.Length > 0)
elem.SetAttribute ("insertbefore", eatt.InsertBefore);
}
// Get the node attributes
foreach (ExtensionAttributeAttribute eat in reflector.GetCustomAttributes (t, typeof(ExtensionAttributeAttribute), false)) {
ExtensionNodeDescription node;
if (!string.IsNullOrEmpty (eat.Path))
nodes.TryGetValue (eat.Path, out node);
else if (eat.TypeName.Length > 0)
nodes.TryGetValue ("$" + eat.TypeName, out node);
else {
if (nodes.Count > 1)
throw new Exception ("Missing type or extension path value in ExtensionAttribute for type '" + typeFullName + "'.");
node = uniqueNode;
}
if (node == null)
throw new Exception ("Invalid type or path value in ExtensionAttribute for type '" + typeFullName + "'.");
node.SetAttribute (eat.Name ?? string.Empty, eat.Value ?? string.Empty);
}
}
else {
// Look for extension points
extensionAtts = reflector.GetCustomAttributes (t, typeof(TypeExtensionPointAttribute), false);
if (extensionAtts.Length > 0 && isMainModule) {
foreach (TypeExtensionPointAttribute epa in extensionAtts) {
ExtensionPoint ep;
ExtensionNodeType nt = new ExtensionNodeType ();
if (epa.Path.Length > 0) {
ep = config.AddExtensionPoint (epa.Path);
}
else {
ep = config.AddExtensionPoint (GetDefaultTypeExtensionPath (config, typeFullName));
nt.ObjectTypeName = typeFullName;
}
nt.Id = epa.NodeName;
nt.TypeName = epa.NodeTypeName;
nt.ExtensionAttributeTypeName = epa.ExtensionAttributeTypeName;
ep.NodeSet.NodeTypes.Add (nt);
ep.Description = epa.Description;
ep.Name = epa.Name;
ep.RootAddin = config.AddinId;
ep.SetExtensionsAddinId (config.AddinId);
}
}
else {
// Look for custom extension attribtues
foreach (CustomAttribute att in reflector.GetRawCustomAttributes (t, typeof(CustomExtensionAttribute), false)) {
ExtensionNodeDescription elem = AddCustomAttributeExtension (module, att, "Type");
elem.SetAttribute ("type", typeFullName);
if (string.IsNullOrEmpty (elem.GetAttribute ("id")))
elem.SetAttribute ("id", typeFullName);
}
}
}
}
}
ExtensionNodeDescription AddCustomAttributeExtension(ModuleDescription module, CustomAttribute att, string nameName)
{
string path;
if (!att.TryGetValue (CustomExtensionAttribute.PathFieldKey, out path))
path = "%" + att.TypeName;
ExtensionNodeDescription elem = module.AddExtensionNode (path, nameName);
foreach (KeyValuePair<string,string> prop in att) {
if (prop.Key != CustomExtensionAttribute.PathFieldKey)
elem.SetAttribute (prop.Key, prop.Value);
}
return elem;
}
public IEnumerable<string> GetMissingDependencies(AddinDescription desc, ModuleDescription mod)
{
foreach (Dependency dep in mod.Dependencies) {
AddinDependency adep = dep as AddinDependency;
if (adep == null)
continue;
var descs = FindDescriptions (desc.Domain, adep.FullAddinId);
if (descs.Count == 0)
yield return adep.FullAddinId;
}
}
void CollectModuleExtensionData(AddinDescription conf, ModuleDescription module, AddinUpdateData updateData, AddinIndex index)
{
foreach (Extension ext in module.Extensions) {
updateData.RelExtensions++;
updateData.RegisterExtension (conf, module, ext);
AddChildExtensions (conf, module, updateData, index, ext.Path, ext.ExtensionNodes, false);
}
}
void LoadExtensionElement(TreeNode tnode, string addin, ExtensionNodeDescriptionCollection extension, ModuleDescription module, ref int curPos, BaseCondition parentCondition, bool inComplextCondition, ArrayList addedNodes)
{
foreach (ExtensionNodeDescription elem in extension) {
if (inComplextCondition) {
parentCondition = ReadComplexCondition (elem, parentCondition);
inComplextCondition = false;
continue;
}
if (elem.NodeName == "ComplexCondition") {
LoadExtensionElement (tnode, addin, elem.ChildNodes, module, ref curPos, parentCondition, true, addedNodes);
continue;
}
if (elem.NodeName == "Condition") {
Condition cond = new Condition (AddinEngine, elem, parentCondition);
LoadExtensionElement (tnode, addin, elem.ChildNodes, module, ref curPos, cond, false, addedNodes);
continue;
}
var pnode = tnode;
ExtensionPoint extensionPoint = null;
while (pnode != null && (extensionPoint = pnode.ExtensionPoint) == null)
pnode = pnode.Parent;
string after = elem.GetAttribute ("insertafter");
if (after.Length == 0 && extensionPoint != null && curPos == -1)
after = extensionPoint.DefaultInsertAfter;
if (after.Length > 0) {
int i = tnode.Children.IndexOfNode (after);
if (i != -1)
curPos = i+1;
}
string before = elem.GetAttribute ("insertbefore");
if (before.Length == 0 && extensionPoint != null && curPos == -1)
before = extensionPoint.DefaultInsertBefore;
if (before.Length > 0) {
int i = tnode.Children.IndexOfNode (before);
if (i != -1)
curPos = i;
}
// If node position is not explicitly set, add the node at the end
if (curPos == -1)
curPos = tnode.Children.Count;
// Find the type of the node in this extension
ExtensionNodeType ntype = addinEngine.FindType (tnode.ExtensionNodeSet, elem.NodeName, addin);
if (ntype == null) {
addinEngine.ReportError ("Node '" + elem.NodeName + "' not allowed in extension: " + tnode.GetPath (), addin, null, false);
continue;
}
string id = elem.GetAttribute ("id");
if (id.Length == 0)
id = AutoIdPrefix + (++internalId);
TreeNode cnode = new TreeNode (addinEngine, id);
ExtensionNode enode = ReadNode (cnode, addin, ntype, elem, module);
if (enode == null)
continue;
cnode.Condition = parentCondition;
cnode.ExtensionNodeSet = ntype;
tnode.InsertChildNode (curPos, cnode);
addedNodes.Add (cnode);
if (cnode.Condition != null)
Context.RegisterNodeCondition (cnode, cnode.Condition);
// Load children
if (elem.ChildNodes.Count > 0) {
int cp = 0;
LoadExtensionElement (cnode, addin, elem.ChildNodes, module, ref cp, parentCondition, false, addedNodes);
}
curPos++;
}
if (Context.FireEvents)
tnode.NotifyChildrenChanged ();
}
bool ScanSubmodule (IProgressStatus monitor, ModuleDescription mod, IAssemblyReflector reflector, AddinDescription config, AddinScanResult scanResult, string assemblyName, object asm)
{
AddinDescription mconfig;
ScanEmbeddedDescription (monitor, assemblyName, reflector, asm, out mconfig);
if (mconfig != null) {
if (!mconfig.IsExtensionModel) {
monitor.ReportError ("Submodules can't define new add-ins: " + assemblyName, null);
return false;
}
if (mconfig.OptionalModules.Count != 0) {
monitor.ReportError ("Submodules can't define nested submodules: " + assemblyName, null);
return false;
}
if (mconfig.ConditionTypes.Count != 0) {
monitor.ReportError ("Submodules can't define condition types: " + assemblyName, null);
return false;
}
if (mconfig.ExtensionNodeSets.Count != 0) {
monitor.ReportError ("Submodules can't define extension node sets: " + assemblyName, null);
return false;
}
if (mconfig.ExtensionPoints.Count != 0) {
monitor.ReportError ("Submodules can't define extension points sets: " + assemblyName, null);
return false;
}
mod.MergeWith (mconfig.MainModule);
}
ScanAssemblyContents (reflector, config, mod, asm, scanResult);
return true;
}
internal void MergeWith (ModuleDescription module)
{
Dependencies.AddRange (module.Dependencies);
Extensions.AddRange (module.Extensions);
}
internal void MergeWith(ModuleDescription module)
{
Dependencies.AddRange(module.Dependencies);
Extensions.AddRange(module.Extensions);
}
bool CheckAddinDependencies (ModuleDescription module)
{
foreach (Dependency dep in module.Dependencies) {
AddinDependency pdep = dep as AddinDependency;
if (pdep != null && !AddinManager.SessionService.IsAddinLoaded (pdep.FullAddinId))
return false;
}
return true;
}
void LoadModule (ModuleDescription module, string ns, ArrayList plugList, ArrayList asmList)
{
// Load the assemblies
foreach (string s in module.Assemblies)
asmList.Add (Assembly.LoadFrom (Path.Combine (baseDirectory, s)));
// Collect dependent ids
foreach (Dependency dep in module.Dependencies) {
AddinDependency pdep = dep as AddinDependency;
if (pdep != null)
plugList.Add (AddinManager.SessionService.GetAddin (Addin.GetFullId (ns, pdep.AddinId, pdep.Version)));
}
}
bool IsAddinCompatible (AddinDescription installedDescription, AddinDescription description, ModuleDescription module)
{
string addinId = Addin.GetFullId (installedDescription.Namespace, installedDescription.LocalId, null);
string requiredVersion = null;
for (int n = module.Dependencies.Count - 1; n >= 0; n--) {
AddinDependency adep = module.Dependencies [n] as AddinDependency;
if (adep != null && Addin.GetFullId (description.Namespace, adep.AddinId, null) == addinId) {
requiredVersion = adep.Version;
break;
}
}
if (requiredVersion == null)
return false;
// Check if the required version is between rep.Description.CompatVersion and rep.Description.Version
if (Addin.CompareVersions (installedDescription.Version, requiredVersion) > 0)
return false;
if (installedDescription.CompatVersion.Length > 0 && Addin.CompareVersions (installedDescription.CompatVersion, requiredVersion) < 0)
return false;
return true;
}
ArrayList GetRootExtensionInfo (Hashtable hash, string path, AddinDescription description, ModuleDescription module, ArrayList rootExtensionPoints)
{
ArrayList list = new ArrayList ();
foreach (RootExtensionPoint rep in rootExtensionPoints) {
// Find an extension point defined in a root add-in which is compatible with the version of the extender dependency
if (IsAddinCompatible (rep.Description, description, module))
list.Add (rep.ExtensionPoint);
}
return list;
}
IEnumerable GetExtensionInfo (Hashtable hash, string path, AddinDescription description, ModuleDescription module, bool lookInParents)
{
ArrayList list = new ArrayList ();
object data = hash [path];
if (data == null && lookInParents) {
// Root add-in extension points are registered before any other kind of extension,
// so we should find it now.
data = GetParentExtensionInfo (path);
}
if (data is ArrayList) {
// Extension point which belongs to a root assembly.
list.AddRange (GetRootExtensionInfo (hash, path, description, module, (ArrayList) data));
}
else {
ExtensionPoint info = (ExtensionPoint) data;
if (info == null) {
info = new ExtensionPoint ();
info.Path = path;
hash [path] = info;
}
list.Add (info);
}
return list;
}
public AddinAssembliesFolder (ModuleDescription module)
{
this.Module = module;
}
public AddinFilesFolder (ModuleDescription module)
{
this.Module = module;
}
void IBinaryXmlElement.Read(BinaryXmlReader reader)
{
id = reader.ReadStringValue ("id");
ns = reader.ReadStringValue ("ns");
isroot = reader.ReadBooleanValue ("isroot");
name = reader.ReadStringValue ("name");
version = reader.ReadStringValue ("version");
compatVersion = reader.ReadStringValue ("compatVersion");
hasUserId = reader.ReadBooleanValue ("hasUserId");
author = reader.ReadStringValue ("author");
url = reader.ReadStringValue ("url");
copyright = reader.ReadStringValue ("copyright");
description = reader.ReadStringValue ("description");
category = reader.ReadStringValue ("category");
basePath = reader.ReadStringValue ("basePath");
sourceAddinFile = reader.ReadStringValue ("sourceAddinFile");
defaultEnabled = reader.ReadBooleanValue ("defaultEnabled");
domain = reader.ReadStringValue ("domain");
mainModule = (ModuleDescription) reader.ReadValue ("MainModule");
optionalModules = (ModuleCollection) reader.ReadValue ("OptionalModules", new ModuleCollection (this));
nodeSets = (ExtensionNodeSetCollection) reader.ReadValue ("NodeSets", new ExtensionNodeSetCollection (this));
extensionPoints = (ExtensionPointCollection) reader.ReadValue ("ExtensionPoints", new ExtensionPointCollection (this));
conditionTypes = (ConditionTypeDescriptionCollection) reader.ReadValue ("ConditionTypes", new ConditionTypeDescriptionCollection (this));
fileInfo = (object[]) reader.ReadValue ("FilesInfo", null);
localizer = (ExtensionNodeDescription) reader.ReadValue ("Localizer");
flags = (AddinFlags) reader.ReadInt32Value ("flags");
properties = (AddinPropertyCollectionImpl) reader.ReadValue ("Properties", new AddinPropertyCollectionImpl (this));
if (mainModule != null)
mainModule.SetParent (this);
}
public AddinAssembly (ModuleDescription module, string assembly)
{
this.Module = module;
this.Assembly = assembly;
}
public ExtensionNode ReadNode(TreeNode tnode, string addin, ExtensionNodeType ntype, ExtensionNodeDescription elem, ModuleDescription module)
{
try {
if (ntype.Type == null) {
if (!InitializeNodeType (ntype))
return null;
}
ExtensionNode node;
node = Activator.CreateInstance (ntype.Type) as ExtensionNode;
if (node == null) {
addinEngine.ReportError ("Extension node type '" + ntype.Type + "' must be a subclass of ExtensionNode", addin, null, false);
return null;
}
tnode.AttachExtensionNode (node);
node.SetData (addinEngine, addin, ntype, module);
node.Read (elem);
return node;
}
catch (Exception ex) {
addinEngine.ReportError ("Could not read extension node of type '" + ntype.Type + "' from extension path '" + tnode.GetPath() + "'", addin, ex, false);
return null;
}
}
public AddinFile (ModuleDescription module, string file)
{
this.Module = module;
this.File = file;
}
public string FindCondition(AddinDescription desc, ModuleDescription mod, string conditionId)
{
if (desc.ConditionTypes.Any (c => c.Id == conditionId))
return desc.AddinId;
foreach (Dependency dep in mod.Dependencies) {
AddinDependency adep = dep as AddinDependency;
if (adep == null)
continue;
var descs = FindDescriptions (desc.Domain, adep.FullAddinId);
foreach (var d in descs) {
var c = FindCondition (d, d.MainModule, conditionId);
if (c != null)
return c;
}
}
return null;
}
internal RuntimeAddin GetModule(ModuleDescription module)
{
// If requesting the root module, return this
if (module == module.ParentAddinDescription.MainModule)
return this;
if (module.RuntimeAddin != null)
return module.RuntimeAddin;
RuntimeAddin addin = new RuntimeAddin (addinEngine, this, module);
return addin;
}
void AddChildExtensions(AddinDescription conf, ModuleDescription module, AddinUpdateData updateData, AddinIndex index, string path, ExtensionNodeDescriptionCollection nodes, bool conditionChildren)
{
// Don't register conditions as extension nodes.
if (!conditionChildren)
updateData.RegisterExtension (conf, module, path);
foreach (ExtensionNodeDescription node in nodes) {
if (node.NodeName == "ComplexCondition")
continue;
updateData.RelExtensionNodes++;
string id = node.GetAttribute ("id");
if (id.Length != 0) {
bool isCondition = node.NodeName == "Condition";
if (isCondition) {
// Find the add-in that provides the implementation for this condition.
// Store that id in the condition. The add-in engine will ensure the add-in
// is loaded when it tries to evaluate this condition.
var condAsm = index.FindCondition (conf, module, id);
if (condAsm != null)
node.SetAttribute (Condition.SourceAddinAttribute, condAsm);
}
AddChildExtensions (conf, module, updateData, index, path + "/" + id, node.ChildNodes, isCondition);
}
}
}
internal AddinDescription Load(Addin iad)
{
ainfo = iad;
AddinDescription description = iad.Description;
id = description.AddinId;
baseDirectory = description.BasePath;
module = description.MainModule;
module.RuntimeAddin = this;
if (description.Localizer != null) {
string cls = description.Localizer.GetAttribute ("type");
// First try getting one of the stock localizers. If none of found try getting the type.
object fob = null;
Type t = Type.GetType ("Mono.Addins.Localization." + cls + "Localizer, " + GetType().Assembly.FullName, false);
if (t != null)
fob = Activator.CreateInstance (t);
if (fob == null)
fob = CreateInstance (cls, true);
IAddinLocalizerFactory factory = fob as IAddinLocalizerFactory;
if (factory == null)
throw new InvalidOperationException ("Localizer factory type '" + cls + "' must implement IAddinLocalizerFactory");
localizer = new AddinLocalizer (factory.CreateLocalizer (this, description.Localizer));
}
return description;
}
void ScanAssemblyAddinHeaders(IAssemblyReflector reflector, AddinDescription config, object asm, AddinScanResult scanResult)
{
// Get basic add-in information
AddinAttribute att = (AddinAttribute) reflector.GetCustomAttribute (asm, typeof(AddinAttribute), false);
if (att != null) {
if (att.Id.Length > 0)
config.LocalId = att.Id;
if (att.Version.Length > 0)
config.Version = att.Version;
if (att.Namespace.Length > 0)
config.Namespace = att.Namespace;
if (att.Category.Length > 0)
config.Category = att.Category;
if (att.CompatVersion.Length > 0)
config.CompatVersion = att.CompatVersion;
if (att.Url.Length > 0)
config.Url = att.Url;
config.IsRoot = att is AddinRootAttribute;
config.EnabledByDefault = att.EnabledByDefault;
config.Flags = att.Flags;
}
// Author attributes
object[] atts = reflector.GetCustomAttributes (asm, typeof(AddinAuthorAttribute), false);
foreach (AddinAuthorAttribute author in atts) {
if (config.Author.Length == 0)
config.Author = author.Name;
else
config.Author += ", " + author.Name;
}
// Name
atts = reflector.GetCustomAttributes (asm, typeof(AddinNameAttribute), false);
foreach (AddinNameAttribute at in atts) {
if (string.IsNullOrEmpty (at.Locale))
config.Name = at.Name;
else
config.Properties.SetPropertyValue ("Name", at.Name, at.Locale);
}
// Description
object catt = reflector.GetCustomAttribute (asm, typeof(AssemblyDescriptionAttribute), false);
if (catt != null && config.Description.Length == 0)
config.Description = ((AssemblyDescriptionAttribute)catt).Description;
atts = reflector.GetCustomAttributes (asm, typeof(AddinDescriptionAttribute), false);
foreach (AddinDescriptionAttribute at in atts) {
if (string.IsNullOrEmpty (at.Locale))
config.Description = at.Description;
else
config.Properties.SetPropertyValue ("Description", at.Description, at.Locale);
}
// Copyright
catt = reflector.GetCustomAttribute (asm, typeof(AssemblyCopyrightAttribute), false);
if (catt != null && config.Copyright.Length == 0)
config.Copyright = ((AssemblyCopyrightAttribute)catt).Copyright;
// Localizer
AddinLocalizerGettextAttribute locat = (AddinLocalizerGettextAttribute) reflector.GetCustomAttribute (asm, typeof(AddinLocalizerGettextAttribute), false);
if (locat != null) {
ExtensionNodeDescription node = new ExtensionNodeDescription ();
if (!string.IsNullOrEmpty (locat.Catalog))
node.SetAttribute ("catalog", locat.Catalog);
if (!string.IsNullOrEmpty (locat.Location))
node.SetAttribute ("location", locat.Catalog);
config.Localizer = node;
}
// Optional modules
atts = reflector.GetCustomAttributes (asm, typeof(AddinModuleAttribute), false);
foreach (AddinModuleAttribute mod in atts) {
if (mod.AssemblyFile.Length > 0) {
ModuleDescription module = new ModuleDescription ();
module.Assemblies.Add (mod.AssemblyFile);
config.OptionalModules.Add (module);
}
}
}
bool CheckAddinDependencies(ModuleDescription module, bool forceLoadAssemblies)
{
foreach (Dependency dep in module.Dependencies) {
AddinDependency pdep = dep as AddinDependency;
if (pdep == null)
continue;
if (!addinEngine.IsAddinLoaded (pdep.FullAddinId))
return false;
if (forceLoadAssemblies)
addinEngine.GetAddin (pdep.FullAddinId).EnsureAssembliesLoaded ();
}
return true;
}
void ScanAssemblyImports(IAssemblyReflector reflector, ModuleDescription module, object asm)
{
object[] atts = reflector.GetCustomAttributes (asm, typeof(ImportAddinAssemblyAttribute), false);
foreach (ImportAddinAssemblyAttribute import in atts) {
if (!string.IsNullOrEmpty (import.FilePath)) {
module.Assemblies.Add (import.FilePath);
if (!import.Scan)
module.IgnorePaths.Add (import.FilePath);
}
}
atts = reflector.GetCustomAttributes (asm, typeof(ImportAddinFileAttribute), false);
foreach (ImportAddinFileAttribute import in atts) {
if (!string.IsNullOrEmpty (import.FilePath))
module.DataFiles.Add (import.FilePath);
}
}
void LoadModule(ModuleDescription module, ArrayList asmList)
{
// Load the assemblies
foreach (string s in module.Assemblies) {
Assembly asm = null;
// don't load the assembly if it's already loaded
string asmPath = Path.Combine (baseDirectory, s);
foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies ()) {
// Sorry, you can't load addins from
// dynamic assemblies as get_Location
// throws a NotSupportedException
if (a is System.Reflection.Emit.AssemblyBuilder) {
continue;
}
if (a.Location == asmPath) {
asm = a;
break;
}
}
if (asm == null) {
asm = Assembly.LoadFrom (asmPath);
}
asmList.Add (asm);
}
}
void IBinaryXmlElement.Read (BinaryXmlReader reader)
{
id = reader.ReadStringValue ("id");
ns = reader.ReadStringValue ("ns");
isroot = reader.ReadBooleanValue ("isroot");
name = reader.ReadStringValue ("name");
version = reader.ReadStringValue ("version");
compatVersion = reader.ReadStringValue ("compatVersion");
hasUserId = reader.ReadBooleanValue ("hasUserId");
author = reader.ReadStringValue ("author");
url = reader.ReadStringValue ("url");
copyright = reader.ReadStringValue ("copyright");
description = reader.ReadStringValue ("description");
category = reader.ReadStringValue ("category");
basePath = reader.ReadStringValue ("basePath");
sourceAddinFile = reader.ReadStringValue ("sourceAddinFile");
mainModule = (ModuleDescription) reader.ReadValue ("MainModule");
optionalModules = (ModuleCollection) reader.ReadValue ("OptionalModules", new ModuleCollection (this));
nodeSets = (ExtensionNodeSetCollection) reader.ReadValue ("NodeSets", new ExtensionNodeSetCollection (this));
extensionPoints = (ExtensionPointCollection) reader.ReadValue ("ExtensionPoints", new ExtensionPointCollection (this));
conditionTypes = (ConditionTypeDescriptionCollection) reader.ReadValue ("ConditionTypes", new ConditionTypeDescriptionCollection (this));
if (mainModule != null)
mainModule.SetParent (this);
}
public void RegisterExtension (AddinDescription description, ModuleDescription module, string path)
{
foreach (ExtensionPoint einfo in GetExtensionInfo (pathHash, path, description, module, true)) {
if (!einfo.Addins.Contains (description.AddinId))
einfo.Addins.Add (description.AddinId);
}
}
