internal AddinDescription Load(Addin iad)
{
ainfo = iad;
ArrayList plugList = new ArrayList();
ArrayList asmList = new ArrayList();
AddinDescription description = iad.Description;
id = description.AddinId;
baseDirectory = description.BasePath;
// Load the main modules
LoadModule(description.MainModule, description.Namespace, plugList, asmList);
// Load the optional modules, if the dependencies are present
foreach (ModuleDescription module in description.OptionalModules)
{
if (CheckAddinDependencies(module))
{
LoadModule(module, description.Namespace, plugList, asmList);
}
}
depAddins = (RuntimeAddin[])plugList.ToArray(typeof(RuntimeAddin));
assemblies = (Assembly[])asmList.ToArray(typeof(Assembly));
return(description);
}
void FillAddin(TreeIter iter, AddinDescription addin)
{
foreach (ExtensionPoint ep in addin.ExtensionPoints)
{
string name;
if (ep.Name.Length > 0 && ep.Description.Length > 0)
{
name = "<b>" + GLib.Markup.EscapeText(ep.Name) + "</b>\n";
name += "<small>" + GLib.Markup.EscapeText(ep.Description) + "</small>";
}
else if (ep.Name.Length > 0)
{
name = "<b>" + GLib.Markup.EscapeText(ep.Name) + "</b>";
}
else if (ep.Description.Length > 0)
{
name = "<b>" + GLib.Markup.EscapeText(ep.Description) + "</b>";
}
else
{
name = "<b>" + GLib.Markup.EscapeText(ep.Path) + "</b>";
}
TreeIter epIter = store.AppendValues(iter, name, ep, ep, true, selection.Contains(ep), null, false, !showExtensionNodes);
if (showExtensionNodes)
{
// Add a dummy node to make sure the expand button is shown
store.AppendValues(epIter, "", null, null, false, false, null, true, 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);
}
void ScanAssemblyAddinHeaders(AddinDescription config, Assembly asm, AddinScanResult scanResult)
{
// Get basic add-in information
AddinAttribute att = (AddinAttribute)Attribute.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;
}
config.IsRoot = att is AddinRootAttribute;
}
}
void RegisterHostTypeNode(AddinDescription config, Type t, ArrayList assemblies)
{
foreach (ExtensionAttribute eatt in t.GetCustomAttributes(typeof(ExtensionAttribute), false))
{
if (eatt.Path.Length > 0)
{
continue;
}
foreach (ExtensionPoint ep in config.ExtensionPoints)
{
foreach (ExtensionNodeType nt in ep.NodeSet.NodeTypes)
{
if (nt.ObjectTypeName.Length == 0)
{
continue;
}
Type etype = FindAddinType(nt.ObjectTypeName, assemblies);
if (etype != null && etype.IsAssignableFrom(t))
{
RegisterTypeNode(config, eatt, ep.Path, nt.Id, t);
return;
}
}
}
}
}
public SelectNodeSetDialog(DotNetProject project, AddinRegistry registry, AddinDescription desc)
{
this.Build();
this.project = project;
this.registry = registry;
this.desc = desc;
foreach (AddinDependency adep in desc.MainModule.Dependencies)
{
Addin addin = registry.GetAddin(adep.FullAddinId);
if (addin != null && addin.Description != null)
{
foreach (ExtensionNodeSet ns in addin.Description.ExtensionNodeSets)
{
combo.AppendText(ns.Id);
sets [ns.Id] = ns;
}
}
}
foreach (ExtensionNodeSet ns in desc.ExtensionNodeSets)
{
combo.AppendText(ns.Id);
sets [ns.Id] = ns;
}
nodeseteditor.AllowEditing = false;
buttonOk.Sensitive = false;
}
/// <summary>
/// Loads an add-in description
/// </summary>
/// <param name="progressStatus">
/// Progress tracker.
/// </param>
/// <param name="file">
/// Name of the file to load
/// </param>
/// <returns>
/// An add-in description
/// </returns>
/// <remarks>
/// This method loads an add-in description from a file. The file can be an XML manifest or an
/// assembly that implements an add-in.
/// </remarks>
public AddinDescription GetAddinDescription(IProgressStatus progressStatus, string file)
{
if (currentDomain == AddinDatabase.UnknownDomain)
{
return(null);
}
string outFile = Path.GetTempFileName();
try {
database.ParseAddin(progressStatus, currentDomain, file, outFile, false);
}
catch {
File.Delete(outFile);
throw;
}
try {
AddinDescription desc = AddinDescription.Read(outFile);
if (desc != null)
{
desc.AddinFile = file;
desc.OwnerDatabase = database;
}
return(desc);
}
catch {
// Errors are already reported using the progress status object
return(null);
}
finally {
File.Delete(outFile);
}
}
public void ApplyFeature(SolutionFolder parentCombine, SolutionItem entry, Widget ed)
{
AddinFeatureWidget editor = (AddinFeatureWidget)ed;
AddinData data = AddinData.EnableAddinAuthoringSupport((DotNetProject)entry);
DotNetProject project = (DotNetProject)entry;
if (editor.HasRegistryInfo)
{
project.GetAddinData().ApplicationName = editor.ApplicationName;
}
AddinDescription desc = data.LoadAddinManifest();
if (editor.AddinId.Length > 0)
{
desc.LocalId = editor.AddinId;
}
if (editor.AddinName.Length > 0)
{
desc.Name = editor.AddinName;
}
desc.Namespace = editor.AddinNamespace;
desc.IsRoot = project.CompileTarget != CompileTarget.Library || editor.IsRoot;
desc.Version = "1.0";
desc.Save();
data.NotifyChanged();
}
public override void BuildNode(ITreeBuilder treeBuilder, object dataObject, ref string label, ref Gdk.Pixbuf icon, ref Gdk.Pixbuf closedIcon)
{
AddinDescription ad = (AddinDescription)dataObject;
label = Util.GetDisplayName(ad);
icon = Context.GetIcon("md-addin");
}
AddinDescription DescFromResource(string res)
{
using (Stream s = GetType().Assembly.GetManifestResourceStream(res))
{
return(AddinDescription.Read(s, "."));
}
}
public void Reload()
{
adesc = data.AddinRegistry.ReadAddinManifestFile(data.AddinManifestFileName);
descWidget.Fill(adesc, data);
IsDirty = false;
descTimestamp = File.GetLastWriteTime(data.AddinManifestFileName);
}
public void Fill(AddinDescription desc)
{
string name = desc.Name;
if (string.IsNullOrEmpty(name))
{
name = desc.LocalId;
}
labelName.Markup = "<small>Add-in</small>\n<big><b>" + GLib.Markup.EscapeText(name) + "</b></big>";
if (!string.IsNullOrEmpty(desc.Description))
{
labelDesc.Text = desc.Description;
}
else
{
labelDesc.Hide();
}
labelId.Text = desc.LocalId;
labelNamespace.Text = desc.Namespace;
labelVersion.Text = desc.Version;
labelAuthor.Text = desc.Author;
labelCopyright.Text = desc.Copyright;
}
void CollectExtensions(AddinDescription desc, string path, List <Extension> extensions, List <ExtensionNodeDescription> nodes)
{
foreach (Extension ext in desc.MainModule.Extensions)
{
if (ext.Path == path || ext.Path.StartsWith(path + "/"))
{
extensions.Add(ext);
}
else if (path.StartsWith(ext.Path + "/"))
{
string subp = path.Substring(ext.Path.Length);
ExtensionNodeDescription foundNode = null;
ExtensionNodeDescriptionCollection list = ext.ExtensionNodes;
foreach (string p in subp.Split('/'))
{
if (p.Length == 0)
{
continue;
}
foundNode = list [p];
if (foundNode == null)
{
break;
}
}
if (foundNode != null)
{
foreach (ExtensionNodeDescription n in foundNode.ChildNodes)
{
nodes.Add(n);
}
}
}
}
}
internal override void CommitUninstall(IProgressMonitor monitor, AddinStore service)
{
if (tempFolder == null)
{
return;
}
monitor.Log.WriteLine("Uninstalling " + info.Name + " v" + info.Version);
AddinDescription conf = iaddin.Description;
string basePath = Path.GetDirectoryName(conf.AddinFile);
foreach (string relPath in conf.AllFiles)
{
string path = Path.Combine(basePath, relPath);
if (!File.Exists(path))
{
continue;
}
File.Delete(path);
}
File.Delete(iaddin.AddinFile);
RecDeleteDir(monitor, basePath);
monitor.Log.WriteLine("Done");
}
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);
}
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 void RegisterNodeSet(AddinDescription description, ExtensionNodeSet nset)
{
List <RootExtensionPoint> extensions;
if (nodeSetHash.TryGetValue(nset.Id, out extensions))
{
// Extension point already registered
List <ExtensionPoint> compatExtensions = GetCompatibleExtensionPoints(nset.Id, description, description.MainModule, extensions);
if (compatExtensions.Count > 0)
{
foreach (ExtensionPoint einfo in compatExtensions)
{
einfo.NodeSet.MergeWith(null, nset);
}
return;
}
}
// Create a new extension set
RootExtensionPoint rep = new RootExtensionPoint();
rep.ExtensionPoint = new ExtensionPoint();
rep.ExtensionPoint.SetNodeSet(nset);
rep.ExtensionPoint.RootAddin = description.AddinId;
rep.ExtensionPoint.Path = nset.Id;
rep.Description = description;
if (extensions == null)
{
extensions = new List <RootExtensionPoint> ();
nodeSetHash [nset.Id] = extensions;
}
extensions.Add(rep);
}
internal static void RemoveReferences(AddinData data, string[] fullIds)
{
AddinDescription desc = data.LoadAddinManifest();
AddinDescriptionView view = FindLoadedDescription(data);
foreach (string ad in fullIds)
{
RemoveReference(desc, ad);
if (view != null)
{
RemoveReference(view.AddinDescription, ad);
}
}
if (view != null)
{
view.Update();
view.BeginInternalUpdate();
}
try {
desc.Save();
data.NotifyChanged(true);
} finally {
if (view != null)
{
view.EndInternalUpdate();
}
}
}
public AddinDescription ReadAddinManifestFile(string file)
{
AddinDescription desc = AddinDescription.Read(file);
desc.OwnerDatabase = database;
return(desc);
}
public static void SaveFormatted(AddinDescription adesc)
{
XmlDocument doc = adesc.SaveToXml();
XmlFormatter formatter = new XmlFormatter();
TextStylePolicy textPolicy = new TextStylePolicy(80, 4, false, false, true, EolMarker.Unix);
XmlFormattingPolicy xmlPolicy = new XmlFormattingPolicy();
XmlFormatingSettings f = new XmlFormatingSettings();
f.ScopeXPath.Add("*/*");
f.EmptyLinesBeforeStart = 1;
f.EmptyLinesAfterEnd = 1;
xmlPolicy.Formats.Add(f);
f = new XmlFormatingSettings();
f.ScopeXPath.Add("Addin");
f.AttributesInNewLine = true;
f.AlignAttributes = true;
f.AttributesInNewLine = false;
xmlPolicy.Formats.Add(f);
string xml = formatter.FormatXml(textPolicy, xmlPolicy, doc.OuterXml);
File.WriteAllText(adesc.FileName, xml);
}
internal static AddinInfo ReadFromDescription(AddinDescription description)
{
AddinInfo info = new AddinInfo();
info.id = description.LocalId;
info.namspace = description.Namespace;
info.name = description.Name;
info.version = description.Version;
info.author = description.Author;
info.copyright = description.Copyright;
info.url = description.Url;
info.description = description.Description;
info.category = description.Category;
info.baseVersion = description.CompatVersion;
info.properties = new AddinPropertyCollectionImpl(description.Properties);
foreach (Dependency dep in description.MainModule.Dependencies)
{
info.Dependencies.Add(dep);
}
foreach (ModuleDescription mod in description.OptionalModules)
{
foreach (Dependency dep in mod.Dependencies)
{
info.OptionalDependencies.Add(dep);
}
}
return(info);
}
IEnumerable <string> GetInstalledFiles(AddinDescription conf)
{
string basePath = Path.GetDirectoryName(conf.AddinFile);
foreach (string relPath in conf.AllFiles)
{
string afile = Path.Combine(basePath, relPath);
if (File.Exists(afile))
{
yield return(afile);
}
}
foreach (var p in conf.Properties)
{
string file;
try {
file = Path.Combine(basePath, p.Value);
if (!File.Exists(file))
{
file = null;
}
} catch {
file = null;
}
if (file != null)
{
yield return(file);
}
}
}
void ScanNodeSet(AddinDescription config, ExtensionNodeSet nset, ArrayList assemblies, Hashtable internalNodeSets)
{
foreach (ExtensionNodeType nt in nset.NodeTypes)
{
ScanNodeType(config, nt, assemblies, internalNodeSets);
}
}
public void RegisterExtension(AddinDescription description, ModuleDescription module, Extension extension)
{
if (extension.Path.StartsWith("$"))
{
string[] objectTypes = extension.Path.Substring(1).Split(',');
bool found = false;
foreach (string s in objectTypes)
{
ArrayList list = (ArrayList)objectTypeExtensions [s];
if (list != null)
{
found = true;
foreach (ExtensionPoint ep in list)
{
if (IsAddinCompatible(ep.ParentAddinDescription, description, module))
{
extension.Path = ep.Path;
RegisterExtension(description, module, ep.Path);
}
}
}
}
if (!found)
{
monitor.ReportWarning("The add-in '" + description.AddinId + "' is trying to register the class '" + extension.Path.Substring(1) + "', but there isn't any add-in defining a suitable extension point");
}
}
}
void GetNodes(AddinDescription desc, ExtensionNodeSet nset, ArrayList list, Hashtable visited)
{
if (visited.Contains(nset))
{
return;
}
visited.Add(nset, nset);
foreach (ExtensionNodeType nt in nset.NodeTypes)
{
if (!visited.Contains(nt.Id + " " + nt.TypeName))
{
list.Add(nt);
visited.Add(nt.Id + " " + nt.TypeName, nt);
}
}
foreach (string nsid in nset.NodeSets)
{
ExtensionNodeSet rset = desc.ExtensionNodeSets [nsid];
if (rset != null)
{
GetNodes(desc, rset, list, visited);
}
}
}
public void RegisterExtension(AddinDescription description, ModuleDescription module, string path)
{
ArrayList extensions = (ArrayList)pathHash [path];
if (extensions == null)
{
// Root add-in extension points are registered before any other kind of extension,
// so we should find it now.
extensions = GetParentExtensionInfo(path);
}
if (extensions == null)
{
monitor.ReportWarning("The add-in '" + description.AddinId + "' is trying to extend '" + path + "', but there isn't any add-in defining this extension point");
return;
}
bool found = false;
foreach (RootExtensionPoint einfo in extensions)
{
if (IsAddinCompatible(einfo.Description, description, module))
{
if (!einfo.ExtensionPoint.Addins.Contains(description.AddinId))
{
einfo.ExtensionPoint.Addins.Add(description.AddinId);
}
found = true;
}
}
if (!found)
{
monitor.ReportWarning("The add-in '" + description.AddinId + "' is trying to extend '" + path + "', but there isn't any compatible add-in defining this extension point");
}
}
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 void RegisterExtensionPoint(AddinDescription description, ExtensionPoint ep)
{
List <RootExtensionPoint> extensions;
if (pathHash.TryGetValue(ep.Path, out extensions))
{
// Extension point already registered
List <ExtensionPoint> compatExtensions = GetCompatibleExtensionPoints(ep.Path, description, description.MainModule, extensions);
if (compatExtensions.Count > 0)
{
foreach (ExtensionPoint einfo in compatExtensions)
{
einfo.MergeWith(null, ep);
}
RegisterObjectTypes(ep);
return;
}
}
// Create a new extension
RootExtensionPoint rep = new RootExtensionPoint();
rep.ExtensionPoint = ep;
rep.ExtensionPoint.RootAddin = description.AddinId;
rep.Description = description;
if (extensions == null)
{
extensions = new List <RootExtensionPoint> ();
pathHash [ep.Path] = extensions;
}
extensions.Add(rep);
RegisterObjectTypes(ep);
}
TreeIter AddAddin(AddinDescription adesc)
{
TreeIter it;
if (store.GetIterFirst(out it))
{
do
{
if ((string)store.GetValue(it, ColAddin) == adesc.AddinId)
{
return(it);
}
}while (store.IterNext(ref it));
}
if (adesc != this.adesc)
{
string txt = GLib.Markup.EscapeText(adesc.Name);
return(store.AppendValues(txt, adesc.AddinId, null, null, pixAddin, true, null));
}
else
{
string txt = AddinManager.CurrentLocalizer.GetString("Local extension points");
return(store.AppendValues(txt, adesc.AddinId, null, null, pixLocalAddin, true, null));
}
}
internal override void CommitUninstall(IProgressMonitor monitor, AddinStore service)
{
if (tempFolder == null)
{
return;
}
monitor.Log.WriteLine("Uninstalling " + info.Name + " v" + info.Version);
AddinDescription conf = iaddin.Description;
string basePath = Path.GetDirectoryName(conf.AddinFile);
foreach (string relPath in conf.AllFiles)
{
string path = Path.Combine(basePath, relPath);
if (!File.Exists(path))
{
continue;
}
File.Delete(path);
}
File.Delete(iaddin.AddinFile);
if (Directory.GetFiles(basePath).Length == 0)
{
try {
Directory.Delete(basePath);
} catch {
monitor.ReportWarning("Directory " + basePath + " could not be deleted.");
}
}
monitor.Log.WriteLine("Done");
}
