public override void BuildChildNodes(ITreeBuilder treeBuilder, object dataObject)
{
AddinDescription ad = (AddinDescription)dataObject;
HashSet <string> localPoints = new HashSet <string> ();
foreach (ExtensionPoint ep in ad.ExtensionPoints)
{
treeBuilder.AddChild(ep);
localPoints.Add(ep.Path);
}
foreach (Extension ex in ad.MainModule.Extensions)
{
if (!localPoints.Contains(ex.Path))
{
treeBuilder.AddChild(ex);
}
}
treeBuilder.AddChild(new TreeViewItem(GettextCatalog.GetString("Dependencies"), MonoDevelop.Ide.Gui.Stock.ClosedReferenceFolder), true);
foreach (Dependency dep in ad.MainModule.Dependencies)
{
AddinDependency adep = dep as AddinDependency;
if (adep != null)
{
treeBuilder.AddChild(new TreeViewItem(adep.FullAddinId, "md-addin-reference"));
}
}
}
public override void BuildNode(ITreeBuilder treeBuilder, object dataObject, ref string label, ref Pixbuf icon, ref Pixbuf closedIcon)
{
AddinDependency adep = (AddinDependency)dataObject;
label = Addin.GetIdName(adep.AddinId);
icon = closedIcon = Context.GetIcon("md-addin-reference");
}
bool IsAddinCompatible(AddinDescription installedDescription, AddinDescription description, ModuleDescription module)
{
if (installedDescription == description)
{
return(true);
}
if (installedDescription.Domain != AddinDatabase.GlobalDomain)
{
if (description.Domain != AddinDatabase.GlobalDomain && description.Domain != installedDescription.Domain)
{
return(false);
}
}
else if (description.Domain != AddinDatabase.GlobalDomain)
{
return(false);
}
string addinId = Addin.GetFullId(installedDescription.Namespace, installedDescription.LocalId, null);
string requiredVersion = null;
IEnumerable deps;
if (module == description.MainModule)
{
deps = module.Dependencies;
}
else
{
ArrayList list = new ArrayList();
list.AddRange(module.Dependencies);
list.AddRange(description.MainModule.Dependencies);
deps = list;
}
foreach (object dep in deps)
{
AddinDependency adep = dep 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);
}
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);
}
public void Fill()
{
state.Save();
store.Clear();
List <AddinDescription> deps = new List <AddinDescription> ();
deps.Add(adesc);
foreach (Dependency dep in adesc.MainModule.Dependencies)
{
AddinDependency adep = dep as AddinDependency;
if (adep == null)
{
continue;
}
Addin ad = data.AddinRegistry.GetAddin(adep.FullAddinId);
if (ad != null && ad.Description != null)
{
deps.Add(ad.Description);
}
}
foreach (Extension ext in adesc.MainModule.Extensions)
{
AddExtension(ext, deps);
}
UpdateButtons();
state.Load();
}
RuntimeAddin[] GetDepAddins()
{
if (depAddins != null)
{
return(depAddins);
}
ArrayList plugList = new ArrayList();
string ns = ainfo.Description.Namespace;
// Collect dependent ids
foreach (Dependency dep in module.Dependencies)
{
AddinDependency pdep = dep as AddinDependency;
if (pdep != null)
{
RuntimeAddin adn = addinEngine.GetAddin(Addin.GetFullId(ns, pdep.AddinId, pdep.Version));
if (adn != null)
{
plugList.Add(adn);
}
else
{
addinEngine.ReportError("Add-in dependency not loaded: " + pdep.FullAddinId, module.ParentAddinDescription.AddinId, null, false);
}
}
}
return(depAddins = (RuntimeAddin[])plugList.ToArray(typeof(RuntimeAddin)));
}
static void ReadDependencies(DependencyCollection deps, DependencyCollection opDeps, XmlElement elem)
{
foreach (XmlElement dep in elem.SelectNodes("Dependencies/Addin"))
{
AddinDependency adep = new AddinDependency();
adep.AddinId = dep.GetAttribute("id");
string v = dep.GetAttribute("version");
if (v.Length != 0)
{
adep.Version = v;
}
deps.Add(adep);
}
foreach (XmlElement dep in elem.SelectNodes("Dependencies/Assembly"))
{
AssemblyDependency adep = new AssemblyDependency();
adep.FullName = dep.GetAttribute("name");
adep.Package = dep.GetAttribute("package");
deps.Add(adep);
}
foreach (XmlElement mod in elem.SelectNodes("Module"))
{
ReadDependencies(opDeps, opDeps, mod);
}
}
void FillExtensionPoint(TreeIter iter, ExtensionPoint ep)
{
// Add extension node types
FillExtensionNodeSet(iter, ep.NodeSet);
// Add extension nodes from known add-ins
ArrayList extensions = new ArrayList();
CollectExtensions(ep.ParentAddinDescription, ep.Path, extensions);
foreach (Dependency dep in ep.ParentAddinDescription.MainModule.Dependencies)
{
AddinDependency adep = dep as AddinDependency;
if (adep == null)
{
continue;
}
Addin addin = registry.GetAddin(adep.FullAddinId);
if (addin != null)
{
CollectExtensions(addin.Description, ep.Path, extensions);
}
}
// Sort the extensions, to make sure they are added in the correct order
// That is, deepest children last.
extensions.Sort(new ExtensionComparer());
// iter = store.AppendValues (iter, "Extensions", null, ep, false, false, null, false, true);
// Add the nodes
foreach (Extension ext in extensions)
{
string subp = ext.Path.Substring(ep.Path.Length);
TreeIter citer = iter;
ExtensionNodeSet ns = ep.NodeSet;
bool found = true;
foreach (string p in subp.Split('/'))
{
if (p.Length == 0)
{
continue;
}
if (!GetNodeBranch(citer, p, ns, out citer, out ns))
{
found = false;
break;
}
}
if (found)
{
FillNodes(citer, ns, ext.ExtensionNodes);
}
}
}
internal static ExtensionNodeDescriptionCollection GetExtensionNodes(AddinRegistry registry, AddinDescription desc, string path)
{
ArrayList extensions = new ArrayList();
CollectExtensions(desc, path, extensions);
foreach (Dependency dep in desc.MainModule.Dependencies)
{
AddinDependency adep = dep as AddinDependency;
if (adep == null)
{
continue;
}
Addin addin = registry.GetAddin(adep.FullAddinId);
if (addin != null)
{
CollectExtensions(addin.Description, path, extensions);
}
}
// Sort the extensions, to make sure they are added in the correct order
// That is, deepest children last.
extensions.Sort(new ExtensionComparer());
ExtensionNodeDescriptionCollection nodes = new ExtensionNodeDescriptionCollection();
// Add the nodes
foreach (Extension ext in extensions)
{
string subp = path.Substring(ext.Path.Length);
ExtensionNodeDescriptionCollection col = ext.ExtensionNodes;
foreach (string p in subp.Split('/'))
{
if (p.Length == 0)
{
continue;
}
ExtensionNodeDescription node = col [p];
if (node == null)
{
col = null;
break;
}
else
{
col = node.ChildNodes;
}
}
if (col != null)
{
nodes.AddRange(col);
}
}
return(nodes);
}
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)
{
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);
}
// Collect dependent ids
foreach (Dependency dep in module.Dependencies)
{
AddinDependency pdep = dep as AddinDependency;
if (pdep != null)
{
RuntimeAddin adn = AddinManager.SessionService.GetAddin(Addin.GetFullId(ns, pdep.AddinId, pdep.Version));
if (adn != null)
{
plugList.Add(adn);
}
else
{
AddinManager.ReportError("Add-in dependency not loaded: " + pdep.FullAddinId, module.ParentAddinDescription.AddinId, null, false);
}
}
}
}
internal void ResolveDependency(IProgressMonitor monitor, Dependency dep, AddinPackage parentPackage, PackageCollection toInstall, PackageCollection toUninstall, PackageCollection installedRequired, DependencyCollection unresolved)
{
AddinDependency adep = dep as AddinDependency;
if (adep == null)
{
return;
}
string nsid = Addin.GetFullId(parentPackage.Addin.Namespace, adep.AddinId, null);
foreach (Package p in toInstall)
{
AddinPackage ap = p as AddinPackage;
if (ap != null)
{
if (Addin.GetIdName(ap.Addin.Id) == nsid && ((AddinInfo)ap.Addin).SupportsVersion(adep.Version))
{
return;
}
}
}
ArrayList addins = new ArrayList();
addins.AddRange(service.Registry.GetAddins());
addins.AddRange(service.Registry.GetAddinRoots());
foreach (Addin addin in addins)
{
if (Addin.GetIdName(addin.Id) == nsid && addin.SupportsVersion(adep.Version))
{
AddinPackage p = AddinPackage.FromInstalledAddin(addin);
if (!installedRequired.Contains(p))
{
installedRequired.Add(p);
}
return;
}
}
AddinRepositoryEntry[] avaddins = service.Repositories.GetAvailableAddins();
foreach (PackageRepositoryEntry avAddin in avaddins)
{
if (Addin.GetIdName(avAddin.Addin.Id) == nsid && ((AddinInfo)avAddin.Addin).SupportsVersion(adep.Version))
{
toInstall.Add(AddinPackage.FromRepository(avAddin));
return;
}
}
unresolved.Add(adep);
}
public override void DeleteItem()
{
DotNetProject p = CurrentNode.GetParentDataItem(typeof(Project), true) as DotNetProject;
AddinData data = AddinData.GetAddinData(p);
AddinDependency adep = (AddinDependency)CurrentNode.DataItem;
string q = AddinManager.CurrentLocalizer.GetString("Are you sure you want to remove the reference to add-in '{0}'?", Addin.GetIdName(adep.AddinId));
if (MessageService.Confirm(q, AlertButton.Remove))
{
AddinAuthoringService.RemoveReferences(data, new string[] { adep.FullAddinId });
}
}
/// <summary>
/// Gets a dependency description for the specified addin.
/// </summary>
/// <param name="addinId"></param>
/// <returns></returns>
public DependencyDescription GetDependencyDescription(AddinId addinId)
{
VerifyInitialized();
Addin addin;
if (_addinFramework.Repository.TryGetAddin(ref addinId._guid, out addin))
{
return(null);
}
var addinRecord = addin.AddinRecord;
List <AddinRecord> dependedAddins;
if (_addinRelationManager.TryGetReferencedAddins(addinRecord, out dependedAddins))
{
List <AddinRecord> extendedAddins;
if (_addinRelationManager.TryGetExtendedAddins(addinRecord, out extendedAddins))
{
dependedAddins.AddRange(extendedAddins);
}
}
else
{
if (_addinRelationManager.TryGetExtendedAddins(addinRecord, out dependedAddins))
{
return(null);
}
}
var addinDependencies = new AddinDependency[dependedAddins.Count];
for (int i = 0; i < addinDependencies.Length; i++)
{
var dependedAddin = dependedAddins[i];
addinDependencies[i] = new AddinDependency(dependedAddin.Guid,
dependedAddin.AddinHeader.Version, dependedAddin.AddinHeader.CompatVersion);
}
var appAssemblyResolver = new DependedApplicationAssemblyResolver();
var appAssemblyDependencies = appAssemblyResolver.GetRequiredApplicationAssemblyDependencies(addinRecord);
return(new DependencyDescription
{
ExtendedAddins = addinDependencies,
ApplicationAssemblies = appAssemblyDependencies
});
}
bool CheckOptionalAddinDependencies(AddinDescription conf, ModuleDescription module)
{
foreach (Dependency dep in module.Dependencies)
{
AddinDependency pdep = dep as AddinDependency;
if (pdep != null)
{
Addin pinfo = AddinManager.Registry.GetAddin(Addin.GetFullId(conf.Namespace, pdep.AddinId, pdep.Version));
if (pinfo == null || !pinfo.Enabled)
{
return(false);
}
}
}
return(true);
}
public static void AddDependencies(AddinDescription desc, AddinScanResult scanResult)
{
// Not implemented in AddinScanResult to avoid making AddinDescription remotable
foreach (ModuleDescription mod in desc.AllModules)
{
foreach (Dependency dep in mod.Dependencies)
{
AddinDependency adep = dep as AddinDependency;
if (adep == null)
{
continue;
}
string depid = Addin.GetFullId(desc.Namespace, adep.AddinId, adep.Version);
scanResult.AddAddinToUpdateRelations(depid);
}
}
}
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 DependsOn(AddinDescription a1, AddinDescription a2)
{
foreach (ModuleDescription module in a1.AllModules)
{
foreach (Dependency dep in module.Dependencies)
{
AddinDependency adep = dep as AddinDependency;
if (adep != null && adep.FullAddinId == a2.AddinId)
{
return(true);
}
else
{
Console.WriteLine("pp???:" + dep);
}
}
}
return(false);
}
public void Fill(AddinRegistry reg, AddinDescription localDesc, AddinDescription pdesc, string path)
{
List <AddinDescription> deps = new List <AddinDescription> ();
foreach (Dependency dep in pdesc.MainModule.Dependencies)
{
AddinDependency adep = dep as AddinDependency;
if (adep == null)
{
continue;
}
Addin addin = reg.GetAddin(adep.FullAddinId);
if (addin != null)
{
deps.Add(addin.Description);
}
}
Fill(localDesc, pdesc, path, deps);
}
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);
}
public static IEnumerable <MissingDepInfo> GetMissingDependencies(Addin addin)
{
IEnumerable <Addin> allAddins = AddinManager.Registry.GetAddins().Union(AddinManager.Registry.GetAddinRoots());
foreach (var dep in addin.Description.MainModule.Dependencies)
{
AddinDependency adep = dep as AddinDependency;
if (adep != null)
{
if (!allAddins.Any(a => Addin.GetIdName(a.Id) == Addin.GetIdName(adep.FullAddinId) && a.SupportsVersion(adep.Version)))
{
Addin found = allAddins.FirstOrDefault(a => Addin.GetIdName(a.Id) == Addin.GetIdName(adep.FullAddinId));
yield return(new MissingDepInfo()
{
Addin = Addin.GetIdName(adep.FullAddinId), Required = adep.Version, Found = found != null ? found.Version : null
});
}
}
}
}
void FindDependentAddins(ArrayList list, string id, bool recursive)
{
foreach (Addin iaddin in service.Registry.GetAddins())
{
if (list.Contains(iaddin))
{
continue;
}
foreach (Dependency dep in iaddin.Description.MainModule.Dependencies)
{
AddinDependency adep = dep as AddinDependency;
if (adep != null && adep.AddinId == id)
{
list.Add(iaddin);
if (recursive)
{
FindDependentAddins(list, iaddin.Id, true);
}
}
}
}
}
bool ResolveLoadDependencies(ArrayList addins, Stack depCheck, string id, bool optional)
{
if (IsAddinLoaded(id))
{
return(true);
}
if (depCheck.Contains(id))
{
throw new InvalidOperationException("A cyclic addin dependency has been detected.");
}
depCheck.Push(id);
Addin iad = Registry.GetAddin(id);
if (iad == null || !iad.Enabled)
{
if (optional)
{
return(false);
}
else if (iad != null && !iad.Enabled)
{
throw new MissingDependencyException(GettextCatalog.GetString("The required addin '{0}' is disabled.", id));
}
else
{
throw new MissingDependencyException(GettextCatalog.GetString("The required addin '{0}' is not installed.", id));
}
}
// If this addin has already been requested, bring it to the head
// of the list, so it is loaded earlier than before.
addins.Remove(iad);
addins.Add(iad);
foreach (Dependency dep in iad.AddinInfo.Dependencies)
{
AddinDependency adep = dep as AddinDependency;
if (adep != null)
{
try {
string adepid = Addin.GetFullId(iad.AddinInfo.Namespace, adep.AddinId, adep.Version);
ResolveLoadDependencies(addins, depCheck, adepid, false);
} catch (MissingDependencyException) {
if (optional)
{
return(false);
}
else
{
throw;
}
}
}
}
if (iad.AddinInfo.OptionalDependencies != null)
{
foreach (Dependency dep in iad.AddinInfo.OptionalDependencies)
{
AddinDependency adep = dep as AddinDependency;
if (adep != null)
{
string adepid = Addin.GetFullId(iad.Namespace, adep.AddinId, adep.Version);
if (!ResolveLoadDependencies(addins, depCheck, adepid, true))
{
return(false);
}
}
}
}
depCheck.Pop();
return(true);
}
public override string GetNodeName(ITreeNavigator thisNode, object dataObject)
{
AddinDependency adep = (AddinDependency)dataObject;
return(Addin.GetIdName(adep.AddinId));
}
void ScanAssemblyContents(AddinDescription config, Assembly asm, ArrayList hostExtensionClasses, AddinScanResult scanResult)
{
// Get dependencies
object[] deps = asm.GetCustomAttributes(typeof(AddinDependencyAttribute), false);
foreach (AddinDependencyAttribute dep in deps)
{
AddinDependency adep = new AddinDependency();
adep.AddinId = dep.Id;
adep.Version = dep.Version;
config.MainModule.Dependencies.Add(adep);
}
// Get extension points
object[] extPoints = asm.GetCustomAttributes(typeof(ExtensionPointAttribute), false);
foreach (ExtensionPointAttribute ext in extPoints)
{
ExtensionPoint ep = config.AddExtensionPoint(ext.Path);
ep.Description = ext.Description;
ep.Name = ext.Name;
ep.AddExtensionNode(ext.NodeName, ext.NodeType.FullName);
}
foreach (Type t in asm.GetTypes())
{
if (Attribute.IsDefined(t, typeof(ExtensionAttribute)))
{
foreach (ExtensionAttribute eatt in t.GetCustomAttributes(typeof(ExtensionAttribute), false))
{
string path;
string nodeName;
if (eatt.Path.Length == 0)
{
if (config.IsRoot)
{
// The extension point must be one of the defined by the assembly
// Look for it later, when the assembly has been fully scanned.
hostExtensionClasses.Add(t);
continue;
}
else
{
path = GetBaseTypeNameList(t);
if (path == "$")
{
// The type does not implement any interface and has no superclass.
// Will be reported later as an error.
path = "$" + t.FullName;
}
nodeName = "Type";
}
}
else
{
path = eatt.Path;
nodeName = eatt.NodeName;
}
ExtensionNodeDescription elem = config.MainModule.AddExtensionNode(path, nodeName);
if (eatt.Id.Length > 0)
{
elem.SetAttribute("id", eatt.Id);
elem.SetAttribute("type", t.FullName);
}
else
{
elem.SetAttribute("id", t.FullName);
}
if (eatt.InsertAfter.Length > 0)
{
elem.SetAttribute("insertafter", eatt.InsertAfter);
}
if (eatt.InsertBefore.Length > 0)
{
elem.SetAttribute("insertbefore", eatt.InsertAfter);
}
}
}
else if (Attribute.IsDefined(t, typeof(TypeExtensionPointAttribute)))
{
foreach (TypeExtensionPointAttribute epa in t.GetCustomAttributes(typeof(TypeExtensionPointAttribute), false))
{
ExtensionPoint ep;
ExtensionNodeType nt = new ExtensionNodeType();
if (epa.Path.Length > 0)
{
ep = config.AddExtensionPoint(epa.Path);
}
else
{
ep = config.AddExtensionPoint(GetDefaultTypeExtensionPath(config, t));
nt.ObjectTypeName = t.FullName;
}
nt.Id = epa.NodeName;
nt.TypeName = epa.NodeType.FullName;
ep.NodeSet.NodeTypes.Add(nt);
ep.Description = epa.Description;
ep.Name = epa.Name;
ep.RootAddin = config.AddinId;
ep.SetExtensionsAddinId(config.AddinId);
}
}
}
}