This is a list of add-ins available in this repository.
");
sw.WriteLine ("
Add-in
Version
Description
");
foreach (PackageRepositoryEntry entry in addins) {
sw.WriteLine ("
" + entry.Addin.Name + "
" + entry.Addin.Version + "
" + entry.Addin.Description + "
");
}
sw.WriteLine ("
");
sw.WriteLine ("");
sw.Close ();
}
internal AddinSystemConfiguration Configuration {
get {
if (config == null) {
config = (AddinSystemConfiguration) AddinStore.ReadObject (RootConfigFile, typeof(AddinSystemConfiguration));
if (config == null)
config = new AddinSystemConfiguration ();
}
return config;
}
}
internal void SaveConfiguration ()
{
if (config != null) {
AddinStore.WriteObject (RootConfigFile, config);
}
}
internal void ResetConfiguration ()
{
if (File.Exists (RootConfigFile))
File.Delete (RootConfigFile);
ResetAddinInfo ();
}
internal void ResetAddinInfo ()
{
if (Directory.Exists (RepositoryCachePath))
Directory.Delete (RepositoryCachePath, true);
}
///
/// Gets a reference to an extensible application
///
///
/// Name of the application
///
///
/// The Application object. Null if not found.
///
public static Application GetExtensibleApplication (string name)
{
return GetExtensibleApplication (name, null);
}
///
/// Gets a reference to an extensible application
///
///
/// Name of the application
///
///
/// Custom paths where to look for the application.
///
///
/// The Application object. Null if not found.
///
public static Application GetExtensibleApplication (string name, IEnumerable searchPaths)
{
AddinsPcFileCache pcc = GetAddinsPcFileCache (searchPaths);
PackageInfo pi = pcc.GetPackageInfoByName (name, searchPaths);
if (pi != null)
return new Application (pi);
else
return null;
}
///
/// Gets a lis of all known extensible applications
///
///
/// A list of applications.
///
public static Application[] GetExtensibleApplications ()
{
return GetExtensibleApplications (null);
}
///
/// Gets a lis of all known extensible applications
///
///
/// Custom paths where to look for applications.
///
///
/// A list of applications.
///
public static Application[] GetExtensibleApplications (IEnumerable searchPaths)
{
List list = new List ();
AddinsPcFileCache pcc = GetAddinsPcFileCache (searchPaths);
foreach (PackageInfo pinfo in pcc.GetPackages (searchPaths)) {
if (pinfo.IsValidPackage)
list.Add (new Application (pinfo));
}
return list.ToArray ();
}
static AddinsPcFileCache pcFileCache;
static AddinsPcFileCache GetAddinsPcFileCache (IEnumerable searchPaths)
{
if (pcFileCache == null) {
pcFileCache = new AddinsPcFileCache ();
if (searchPaths != null)
pcFileCache.Update (searchPaths);
else
pcFileCache.Update ();
}
return pcFileCache;
}
}
class AddinsPcFileCacheContext: IPcFileCacheContext
{
public bool IsCustomDataComplete (string pcfile, PackageInfo pkg)
{
return true;
}
public void StoreCustomData (Mono.PkgConfig.PcFile pcfile, PackageInfo pkg)
{
}
public void ReportError (string message, System.Exception ex)
{
Console.WriteLine (message);
Console.WriteLine (ex);
}
}
class AddinsPcFileCache: PcFileCache
{
public AddinsPcFileCache (): base (new AddinsPcFileCacheContext ())
{
}
protected override string CacheDirectory {
get {
string path = Environment.GetFolderPath (Environment.SpecialFolder.ApplicationData);
path = Path.Combine (path, "mono.addins");
return path;
}
}
protected override void ParsePackageInfo (PcFile file, PackageInfo pinfo)
{
string rootPath = file.GetVariable ("MonoAddinsRoot");
string regPath = file.GetVariable ("MonoAddinsRegistry");
string addinsPath = file.GetVariable ("MonoAddinsInstallPath");
string databasePath = file.GetVariable ("MonoAddinsCachePath");
string testCmd = file.GetVariable ("MonoAddinsTestCommand");
if (string.IsNullOrEmpty (rootPath) || string.IsNullOrEmpty (regPath))
return;
pinfo.SetData ("MonoAddinsRoot", rootPath);
pinfo.SetData ("MonoAddinsRegistry", regPath);
pinfo.SetData ("MonoAddinsInstallPath", addinsPath);
pinfo.SetData ("MonoAddinsCachePath", databasePath);
pinfo.SetData ("MonoAddinsTestCommand", testCmd);
}
}
///
/// A registered extensible application
///
public class Application
{
AddinRegistry registry;
string description;
string name;
string testCommand;
string startupPath;
string registryPath;
string addinsPath;
string databasePath;
internal Application (PackageInfo pinfo)
{
name = pinfo.Name;
description = pinfo.Description;
startupPath = pinfo.GetData ("MonoAddinsRoot");
registryPath = pinfo.GetData ("MonoAddinsRegistry");
addinsPath = pinfo.GetData ("MonoAddinsInstallPath");
databasePath = pinfo.GetData ("MonoAddinsCachePath");
testCommand = pinfo.GetData ("MonoAddinsTestCommand");
}
///
/// Add-in registry of the application
///
public AddinRegistry Registry {
get {
if (registry == null)
registry = new AddinRegistry (RegistryPath, StartupPath, AddinsPath, AddinCachePath);
return registry;
}
}
///
/// Description of the application
///
public string Description {
get {
return description;
}
}
///
/// Name of the application
///
public string Name {
get {
return name;
}
}
///
/// Path to the add-in registry
///
public string RegistryPath {
get {
return registryPath;
}
}
///
/// Path to the directory that contains the main executable assembly of the application
///
public string StartupPath {
get {
return startupPath;
}
}
///
/// Command to be used to execute the application in add-in development mode.
///
public string TestCommand {
get {
return testCommand;
}
}
///
/// Path to the default add-ins directory for the aplpication
///
public string AddinsPath {
get {
return addinsPath;
}
}
///
/// Path to the add-in cache for the application
///
public string AddinCachePath {
get {
return databasePath;
}
}
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup/PackageCollection.cs 0000664 0001750 0001750 00000005302 12136523632 030125 0 ustar 00directhex directhex 0000000 0000000 //
// PackageCollection.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
using System.Xml;
using System.Xml.Serialization;
using System.Collections.Specialized;
namespace Mono.Addins.Setup
{
///
/// A collection of packages
///
public class PackageCollection: CollectionBase
{
///
/// Initializes a new instance of the class.
///
public PackageCollection ()
{
}
///
/// Copy constructor
///
///
/// Collection where to copy from
///
public PackageCollection (ICollection col)
{
AddRange (col);
}
///
/// Gets a package
///
///
/// Package index
///
public Package this [int n] {
get { return (Package) List [n]; }
}
///
/// Adds a package
///
///
/// A package
///
public void Add (Package p)
{
List.Add (p);
}
///
/// Checks if a package is present in the collection
///
///
/// The package
///
///
/// True if the package is preent
///
public bool Contains (Package p)
{
return List.Contains (p);
}
///
/// Adds a list of packages to the collection
///
///
/// The list of packages to add
///
public void AddRange (ICollection col)
{
foreach (Package p in col)
Add (p);
}
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup/AddinPackage.cs 0000664 0001750 0001750 00000027177 12136523632 027067 0 ustar 00directhex directhex 0000000 0000000 //
// AddinPackage.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
using System.Reflection;
using System.Diagnostics;
using System.Collections.Specialized;
using System.Net;
using ICSharpCode.SharpZipLib.Zip;
using Mono.Addins;
using Mono.Addins.Description;
using System.Collections.Generic;
using System.Linq;
namespace Mono.Addins.Setup
{
internal class AddinPackage: Package
{
AddinInfo info;
string packFile;
string url;
string tempFolder;
bool disablingOnUninstall;
bool uninstallingLoaded;
string configFile;
bool installed;
Addin iaddin;
public AddinHeader Addin {
get { return info; }
}
public override string Name {
get { return info.Name + " v" + info.Version; }
}
public static AddinPackage PackageFromRepository (AddinRepositoryEntry repAddin)
{
AddinPackage pack = new AddinPackage ();
pack.info = (AddinInfo) repAddin.Addin;
pack.url = new Uri (new Uri (repAddin.RepositoryUrl), repAddin.Url).ToString ();
return pack;
}
public static AddinPackage PackageFromFile (string file)
{
AddinPackage pack = new AddinPackage ();
pack.info = ReadAddinInfo (file);
pack.packFile = file;
return pack;
}
public static AddinPackage FromInstalledAddin (Addin sinfo)
{
AddinPackage pack = new AddinPackage ();
pack.info = AddinInfo.ReadFromDescription (sinfo.Description);
return pack;
}
static AddinInfo ReadAddinInfo (string file)
{
ZipFile zfile = new ZipFile (file);
foreach (ZipEntry ze in zfile) {
if (ze.Name == "addin.info") {
using (Stream s = zfile.GetInputStream (ze)) {
return AddinInfo.ReadFromAddinFile (new StreamReader (s));
}
}
}
throw new InstallException ("Addin configuration file not found in package.");
}
internal override bool IsUpgradeOf (Package p)
{
AddinPackage ap = p as AddinPackage;
if (ap == null) return false;
return info.SupportsVersion (ap.info.Version);
}
public override bool Equals (object ob)
{
AddinPackage ap = ob as AddinPackage;
if (ap == null) return false;
return ap.info.Id == info.Id && ap.info.Version == info.Version;
}
public override int GetHashCode ()
{
return (info.Id + info.Version).GetHashCode ();
}
internal override void PrepareInstall (IProgressMonitor monitor, AddinStore service)
{
if (service.Registry.IsRegisteredForUninstall (info.Id))
throw new InstallException ("The addin " + info.Name + " v" + info.Version + " is scheduled for uninstallation. Please restart the application before trying to install it again.");
if (service.Registry.GetAddin (Mono.Addins.Addin.GetFullId (info.Namespace, info.Id, info.Version), true) != null)
throw new InstallException ("The addin " + info.Name + " v" + info.Version + " is already installed.");
if (url != null)
packFile = service.DownloadFile (monitor, url);
tempFolder = CreateTempFolder ();
// Extract the files
using (FileStream fs = new FileStream (packFile, FileMode.Open, FileAccess.Read)) {
ZipFile zip = new ZipFile (fs);
foreach (ZipEntry entry in zip) {
string path = Path.Combine (tempFolder, entry.Name);
string dir = Path.GetDirectoryName (path);
if (!Directory.Exists (dir))
Directory.CreateDirectory (dir);
byte[] buffer = new byte [8192];
int n=0;
Stream inStream = zip.GetInputStream (entry);
Stream outStream = null;
try {
outStream = File.Create (path);
while ((n = inStream.Read (buffer, 0, buffer.Length)) > 0)
outStream.Write (buffer, 0, n);
} finally {
inStream.Close ();
if (outStream != null)
outStream.Close ();
}
}
}
foreach (string s in Directory.GetFiles (tempFolder)) {
if (Path.GetFileName (s) == "addin.info") {
configFile = s;
break;
}
}
if (configFile == null)
throw new InstallException ("Add-in information file not found in package.");
}
internal override void CommitInstall (IProgressMonitor monitor, AddinStore service)
{
service.RegisterAddin (monitor, info, tempFolder);
installed = true;
}
internal override void RollbackInstall (IProgressMonitor monitor, AddinStore service)
{
if (installed) {
iaddin = service.Registry.GetAddin (info.Id);
if (iaddin != null)
CommitUninstall (monitor, service);
}
}
internal override void EndInstall (IProgressMonitor monitor, AddinStore service)
{
if (url != null && packFile != null)
File.Delete (packFile);
if (tempFolder != null)
Directory.Delete (tempFolder, true);
}
internal override void Resolve (IProgressMonitor monitor, AddinStore service, PackageCollection toInstall, PackageCollection toUninstall, PackageCollection installedRequired, DependencyCollection unresolved)
{
Addin ia = service.Registry.GetAddin (Mono.Addins.Addin.GetIdName (info.Id));
if (ia != null) {
Package p = AddinPackage.FromInstalledAddin (ia);
if (!toUninstall.Contains (p))
toUninstall.Add (p);
if (!info.SupportsVersion (ia.Version)) {
// This addin breaks the api of the currently installed one,
// it has to be removed, together with all dependencies
Addin[] ainfos = service.GetDependentAddins (info.Id, true);
foreach (Addin ainfo in ainfos) {
p = AddinPackage.FromInstalledAddin (ainfo);
if (!toUninstall.Contains (p))
toUninstall.Add (p);
}
}
}
foreach (Dependency dep in info.Dependencies) {
service.ResolveDependency (monitor, dep, this, toInstall, toUninstall, installedRequired, unresolved);
}
}
internal override void PrepareUninstall (IProgressMonitor monitor, AddinStore service)
{
iaddin = service.Registry.GetAddin (info.Id, true);
if (iaddin == null)
throw new InstallException (string.Format ("The add-in '{0}' is not installed.", info.Name));
AddinDescription conf = iaddin.Description;
if (!File.Exists (iaddin.AddinFile)) {
monitor.ReportWarning (string.Format ("The add-in '{0}' is scheduled for uninstalling, but the add-in file could not be found.", info.Name));
return;
}
// The add-in is a core application add-in. It can't be uninstalled, so it will be disabled.
if (!service.IsUserAddin (iaddin.AddinFile)) {
disablingOnUninstall = true;
return;
}
// If the add-in assemblies are loaded, or if there is any file with a write lock, delay the uninstallation
HashSet files = new HashSet (GetInstalledFiles (conf));
if (AddinManager.CheckAssembliesLoaded (files) || files.Any (f => HasWriteLock (f))) {
uninstallingLoaded = true;
return;
}
if (!service.HasWriteAccess (iaddin.AddinFile))
throw new InstallException (AddinStore.GetUninstallErrorNoRoot (info));
foreach (string path in GetInstalledFiles (conf)) {
if (!service.HasWriteAccess (path))
throw new InstallException (AddinStore.GetUninstallErrorNoRoot (info));
}
tempFolder = CreateTempFolder ();
CopyAddinFiles (monitor, conf, iaddin.AddinFile, tempFolder);
}
bool HasWriteLock (string file)
{
if (!File.Exists (file))
return false;
try {
File.OpenWrite (file).Close ();
return false;
} catch {
return true;
}
}
IEnumerable 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;
}
}
internal override void CommitUninstall (IProgressMonitor monitor, AddinStore service)
{
if (disablingOnUninstall) {
disablingOnUninstall = false;
service.Registry.DisableAddin (info.Id);
return;
}
AddinDescription conf = iaddin.Description;
string basePath = Path.GetDirectoryName (conf.AddinFile);
if (uninstallingLoaded) {
List files = new List ();
files.Add (iaddin.AddinFile);
foreach (string f in GetInstalledFiles (conf))
files.Add (f);
service.Registry.RegisterForUninstall (info.Id, files);
return;
}
if (tempFolder == null)
return;
monitor.Log.WriteLine ("Uninstalling " + info.Name + " v" + info.Version);
foreach (string path in GetInstalledFiles (conf))
File.Delete (path);
File.Delete (iaddin.AddinFile);
RecDeleteDir (monitor, basePath);
monitor.Log.WriteLine ("Done");
}
void RecDeleteDir (IProgressMonitor monitor, string path)
{
if (Directory.GetFiles (path).Length != 0)
return;
foreach (string dir in Directory.GetDirectories (path))
RecDeleteDir (monitor, dir);
try {
Directory.Delete (path);
} catch {
monitor.ReportWarning ("Directory " + path + " could not be deleted.");
}
}
internal override void RollbackUninstall (IProgressMonitor monitor, AddinStore service)
{
disablingOnUninstall = false;
if (tempFolder != null) {
AddinDescription conf = iaddin.Description;
string configFile = Path.Combine (tempFolder, Path.GetFileName (iaddin.AddinFile));
string addinDir = Path.GetDirectoryName (iaddin.AddinFile);
CopyAddinFiles (monitor, conf, configFile, addinDir);
}
}
internal override void EndUninstall (IProgressMonitor monitor, AddinStore service)
{
if (tempFolder != null)
Directory.Delete (tempFolder, true);
tempFolder = null;
}
void CopyAddinFiles (IProgressMonitor monitor, AddinDescription conf, string configFile, string destPath)
{
if (!Directory.Exists (destPath))
Directory.CreateDirectory (destPath);
string dfile = Path.Combine (destPath, Path.GetFileName (configFile));
if (File.Exists (dfile))
File.Delete (dfile);
File.Copy (configFile, dfile);
string basePath = Path.GetDirectoryName (configFile);
foreach (string relPath in conf.AllFiles) {
string path = Path.Combine (basePath, relPath);
if (!File.Exists (path))
continue;
string destf = Path.Combine (destPath, Path.GetDirectoryName (relPath));
if (!Directory.Exists (destf))
Directory.CreateDirectory (destf);
dfile = Path.Combine (destPath, relPath);
if (File.Exists (dfile))
File.Delete (dfile);
File.Copy (path, dfile);
}
}
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup/ReferenceRepositoryEntry.cs 0000664 0001750 0001750 00000002663 12136523632 031605 0 ustar 00directhex directhex 0000000 0000000 //
// ReferenceRepositoryEntry.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
namespace Mono.Addins.Setup
{
internal class ReferenceRepositoryEntry: RepositoryEntry
{
DateTime lastModified;
public DateTime LastModified {
get { return lastModified; }
set { lastModified = value; }
}
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup/RepositoryRegistry.cs 0000664 0001750 0001750 00000056252 12136523632 030500 0 ustar 00directhex directhex 0000000 0000000 //
// RepositoryRegistry.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Linq;
using System.IO;
using System.Collections;
using Mono.Addins.Setup.ProgressMonitoring;
using System.Collections.Generic;
namespace Mono.Addins.Setup
{
///
/// A registry of on-line repositories
///
///
/// This class can be used to manage on-line repository subscriptions.
///
public class RepositoryRegistry
{
ArrayList repoList;
SetupService service;
internal RepositoryRegistry (SetupService service)
{
this.service = service;
}
///
/// Subscribes to an on-line repository
///
///
/// Progress monitor where to show progress status and log
///
///
/// URL of the repository
///
///
/// A repository reference
///
///
/// The repository index is not downloaded by default. It can be downloaded
/// by calling UpdateRepository.
///
public AddinRepository RegisterRepository (IProgressStatus monitor, string url)
{
return RegisterRepository (monitor, url, false);
}
///
/// Subscribes to an on-line repository
///
///
/// Progress monitor where to show progress status and log
///
///
/// URL of the repository
///
///
/// When set to True, the repository index will be downloaded.
///
///
/// A repository reference
///
public AddinRepository RegisterRepository (IProgressStatus monitor, string url, bool updateNow)
{
if (string.IsNullOrEmpty (url))
throw new ArgumentException ("Emtpy url");
if (!url.EndsWith (".mrep")) {
if (url [url.Length - 1] != '/')
url += "/";
url = url + "main.mrep";
}
RepositoryRecord rr = FindRepositoryRecord (url);
if (rr != null)
return rr;
rr = RegisterRepository (url, false);
try {
if (updateNow) {
UpdateRepository (monitor, url);
rr = FindRepositoryRecord (url);
Repository rep = rr.GetCachedRepository ();
if (rep != null)
rr.Name = rep.Name;
}
service.SaveConfiguration ();
return rr;
} catch (Exception ex) {
if (monitor != null)
monitor.ReportError ("The repository could not be registered", ex);
if (ContainsRepository (url))
RemoveRepository (url);
return null;
}
}
internal RepositoryRecord RegisterRepository (string url, bool isReference)
{
RepositoryRecord rr = FindRepositoryRecord (url);
if (rr != null) {
if (rr.IsReference && !isReference) {
rr.IsReference = false;
service.SaveConfiguration ();
}
return rr;
}
rr = new RepositoryRecord ();
rr.Url = url;
rr.IsReference = isReference;
string name = service.RepositoryCachePath;
if (!Directory.Exists (name))
Directory.CreateDirectory (name);
string host = new Uri (url).Host;
if (host.Length == 0)
host = "repo";
name = Path.Combine (name, host);
rr.File = name + "_" + service.Configuration.RepositoryIdCount + ".mrep";
rr.Id = "rep" + service.Configuration.RepositoryIdCount;
service.Configuration.Repositories.Add (rr);
service.Configuration.RepositoryIdCount++;
service.SaveConfiguration ();
repoList = null;
return rr;
}
internal RepositoryRecord FindRepositoryRecord (string url)
{
foreach (RepositoryRecord rr in service.Configuration.Repositories)
if (rr.Url == url) return rr;
return null;
}
///
/// Removes an on-line repository subscription.
///
///
/// URL of the repository.
///
public void RemoveRepository (string url)
{
RepositoryRecord rep = FindRepositoryRecord (url);
if (rep == null)
return; // Nothing to do
foreach (RepositoryRecord rr in service.Configuration.Repositories) {
if (rr == rep) continue;
Repository newRep = rr.GetCachedRepository ();
if (newRep == null) continue;
foreach (ReferenceRepositoryEntry re in newRep.Repositories) {
if (re.Url == url) {
// The repository can't be removed because there is another
// repository depending on it. Just mark it as a reference.
rep.IsReference = true;
return;
}
}
}
// There are no other repositories referencing this one, so we can safely delete
Repository delRep = rep.GetCachedRepository ();
service.Configuration.Repositories.Remove (rep);
rep.ClearCachedRepository ();
if (delRep != null) {
foreach (ReferenceRepositoryEntry re in delRep.Repositories)
RemoveRepository (new Uri (new Uri (url), re.Url).ToString ());
}
service.SaveConfiguration ();
repoList = null;
}
///
/// Enables or disables a repository
///
///
/// URL of the repository
///
///
/// 'true' if the repository has to be enabled.
///
///
/// Disabled repositories are ignored when calling UpdateAllRepositories.
///
public void SetRepositoryEnabled (string url, bool enabled)
{
RepositoryRecord rep = FindRepositoryRecord (url);
if (rep == null)
return; // Nothing to do
rep.Enabled = enabled;
Repository crep = rep.GetCachedRepository ();
if (crep != null) {
foreach (RepositoryEntry re in crep.Repositories)
SetRepositoryEnabled (new Uri (new Uri (url), re.Url).ToString (), enabled);
}
service.SaveConfiguration ();
}
///
/// Checks if a repository is already subscribed.
///
///
/// URL of the repository
///
///
/// True if the repository is already subscribed.
///
public bool ContainsRepository (string url)
{
return FindRepositoryRecord (url) != null;
}
ArrayList RepositoryList {
get {
if (repoList == null) {
ArrayList list = new ArrayList ();
foreach (RepositoryRecord rep in service.Configuration.Repositories) {
if (!rep.IsReference)
list.Add (rep);
}
repoList = list;
}
return repoList;
}
}
///
/// Gets a list of subscribed repositories
///
///
/// A list of repositories.
///
public AddinRepository[] GetRepositories ()
{
return (AddinRepository[]) RepositoryList.ToArray (typeof(AddinRepository));
}
///
/// Updates the add-in index of all subscribed repositories.
///
///
/// Progress monitor where to show progress status and log
///
public void UpdateAllRepositories (IProgressStatus monitor)
{
UpdateRepository (monitor, (string)null);
}
///
/// Updates the add-in index of the provided repository
///
///
/// Progress monitor where to show progress status and log
///
///
/// URL of the repository
///
public void UpdateRepository (IProgressStatus statusMonitor, string url)
{
repoList = null;
IProgressMonitor monitor = ProgressStatusMonitor.GetProgressMonitor (statusMonitor);
monitor.BeginTask ("Updating repositories", service.Configuration.Repositories.Count);
try {
int num = service.Configuration.Repositories.Count;
for (int n=0; n
/// Gets a list of available add-in updates.
///
///
/// A list of add-in references.
///
///
/// The list is generated by looking at the add-ins currently installed and checking if there is any
/// add-in with a newer version number in any of the subscribed repositories. This method uses cached
/// information from on-line repositories. Make sure you call UpdateRepository or UpdateAllRepositories
/// before using this method to ensure that the latest information is available.
///
public AddinRepositoryEntry[] GetAvailableUpdates ()
{
return GetAvailableAddin (null, null, null, true, RepositorySearchFlags.None);
}
///
/// Gets a list of available add-in updates.
///
///
/// Search flags
///
///
/// A list of add-in references.
///
///
/// The list is generated by looking at the add-ins currently installed and checking if there is any
/// add-in with a newer version number in any of the subscribed repositories. This method uses cached
/// information from on-line repositories. Make sure you call UpdateRepository or UpdateAllRepositories
/// before using this method to ensure that the latest information is available.
///
public AddinRepositoryEntry[] GetAvailableUpdates (RepositorySearchFlags flags)
{
return GetAvailableAddin (null, null, null, true, flags);
}
///
/// Gets a list of available add-in updates in a specific repository.
///
///
/// The repository URL
///
///
/// A list of add-in references.
///
///
/// The list is generated by looking at the add-ins currently installed and checking if there is any
/// add-in with a newer version number in the provided repository. This method uses cached
/// information from on-line repositories. Make sure you call UpdateRepository or UpdateAllRepositories
/// before using this method to ensure that the latest information is available.
///
public AddinRepositoryEntry[] GetAvailableUpdates (string repositoryUrl)
{
return GetAvailableAddin (repositoryUrl, null, null, true, RepositorySearchFlags.None);
}
#pragma warning disable 1591
[Obsolete ("Use GetAvailableAddinUpdates (id) instead")]
public AddinRepositoryEntry[] GetAvailableUpdates (string id, string version)
{
return GetAvailableAddin (null, id, version, true, RepositorySearchFlags.None);
}
[Obsolete ("Use GetAvailableAddinUpdates (repositoryUrl, id) instead")]
public AddinRepositoryEntry[] GetAvailableUpdates (string repositoryUrl, string id, string version)
{
return GetAvailableAddin (repositoryUrl, id, version, true, RepositorySearchFlags.None);
}
#pragma warning restore 1591
///
/// Gets a list of available updates for an add-in.
///
///
/// Identifier of the add-in.
///
///
/// List of updates for the specified add-in.
///
///
/// The list is generated by checking if there is any
/// add-in with a newer version number in any of the subscribed repositories. This method uses cached
/// information from on-line repositories. Make sure you call UpdateRepository or UpdateAllRepositories
/// before using this method to ensure that the latest information is available.
///
public AddinRepositoryEntry[] GetAvailableAddinUpdates (string id)
{
return GetAvailableAddin (null, id, null, true, RepositorySearchFlags.None);
}
///
/// Gets a list of available updates for an add-in.
///
///
/// Identifier of the add-in.
///
///
/// Search flags.
///
///
/// List of updates for the specified add-in.
///
///
/// The list is generated by checking if there is any
/// add-in with a newer version number in any of the subscribed repositories. This method uses cached
/// information from on-line repositories. Make sure you call UpdateRepository or UpdateAllRepositories
/// before using this method to ensure that the latest information is available.
///
public AddinRepositoryEntry[] GetAvailableAddinUpdates (string id, RepositorySearchFlags flags)
{
return GetAvailableAddin (null, id, null, true, flags);
}
///
/// Gets a list of available updates for an add-in in a specific repository
///
///
/// Identifier of the add-in.
///
///
/// Identifier of the add-in.
///
///
/// List of updates for the specified add-in.
///
///
/// The list is generated by checking if there is any
/// add-in with a newer version number in the provided repository. This method uses cached
/// information from on-line repositories. Make sure you call UpdateRepository or UpdateAllRepositories
/// before using this method to ensure that the latest information is available.
///
public AddinRepositoryEntry[] GetAvailableAddinUpdates (string repositoryUrl, string id)
{
return GetAvailableAddin (repositoryUrl, id, null, true, RepositorySearchFlags.None);
}
///
/// Gets a list of available updates for an add-in in a specific repository
///
///
/// Identifier of the add-in.
///
///
/// Identifier of the add-in.
///
///
/// Search flags.
///
///
/// List of updates for the specified add-in.
///
///
/// The list is generated by checking if there is any
/// add-in with a newer version number in the provided repository. This method uses cached
/// information from on-line repositories. Make sure you call UpdateRepository or UpdateAllRepositories
/// before using this method to ensure that the latest information is available.
///
public AddinRepositoryEntry[] GetAvailableAddinUpdates (string repositoryUrl, string id, RepositorySearchFlags flags)
{
return GetAvailableAddin (repositoryUrl, id, null, true, flags);
}
///
/// Gets a list of all available add-ins
///
///
/// A list of add-ins
///
///
/// This method uses cached
/// information from on-line repositories. Make sure you call UpdateRepository or UpdateAllRepositories
/// before using this method to ensure that the latest information is available.
///
public AddinRepositoryEntry[] GetAvailableAddins ()
{
return GetAvailableAddin (null, null, null, false, RepositorySearchFlags.None);
}
///
/// Gets a list of all available add-ins
///
///
/// The available addins.
///
///
/// Search flags.
///
///
/// This method uses cached
/// information from on-line repositories. Make sure you call UpdateRepository or UpdateAllRepositories
/// before using this method to ensure that the latest information is available.
///
public AddinRepositoryEntry[] GetAvailableAddins (RepositorySearchFlags flags)
{
return GetAvailableAddin (null, null, null, false, flags);
}
///
/// Gets a list of all available add-ins in a repository
///
///
/// A repository URL
///
///
/// A list of add-ins
///
///
/// This method uses cached
/// information from on-line repositories. Make sure you call UpdateRepository or UpdateAllRepositories
/// before using this method to ensure that the latest information is available.
///
public AddinRepositoryEntry[] GetAvailableAddins (string repositoryUrl)
{
return GetAvailableAddin (repositoryUrl, null, null);
}
///
/// Gets a list of all available add-ins in a repository
///
///
/// A repository URL
///
///
/// Search flags.
///
///
/// A list of add-ins
///
///
/// This method uses cached
/// information from on-line repositories. Make sure you call UpdateRepository or UpdateAllRepositories
/// before using this method to ensure that the latest information is available.
///
public AddinRepositoryEntry[] GetAvailableAddins (string repositoryUrl, RepositorySearchFlags flags)
{
return GetAvailableAddin (repositoryUrl, null, null, false, flags);
}
///
/// Checks if an add-in is available to be installed
///
///
/// Identifier of the add-in
///
///
/// Version of the add-in (optional, it can be null)
///
///
/// A list of add-ins
///
///
/// List of references to add-ins available in on-line repositories. This method uses cached
/// information from on-line repositories. Make sure you call UpdateRepository or UpdateAllRepositories
/// before using this method to ensure that the latest information is available.
///
public AddinRepositoryEntry[] GetAvailableAddin (string id, string version)
{
return GetAvailableAddin (null, id, version);
}
///
/// Checks if an add-in is available to be installed from a repository
///
///
/// A repository URL
///
///
/// Identifier of the add-in
///
///
/// Version of the add-in (optional, it can be null)
///
///
/// A list of add-ins
///
///
/// List of references to add-ins available in the repository. This method uses cached
/// information from on-line repositories. Make sure you call UpdateRepository or UpdateAllRepositories
/// before using this method to ensure that the latest information is available.
///
public AddinRepositoryEntry[] GetAvailableAddin (string repositoryUrl, string id, string version)
{
return GetAvailableAddin (repositoryUrl, id, version, false, RepositorySearchFlags.None);
}
PackageRepositoryEntry[] GetAvailableAddin (string repositoryUrl, string id, string version, bool updates, RepositorySearchFlags flags)
{
List list = new List ();
IEnumerable ee;
if (repositoryUrl != null) {
ArrayList repos = new ArrayList ();
GetRepositoryTree (repositoryUrl, repos);
ee = repos;
} else
ee = service.Configuration.Repositories;
foreach (RepositoryRecord rr in ee) {
if (!rr.Enabled)
continue;
Repository rep = rr.GetCachedRepository();
if (rep == null) continue;
foreach (PackageRepositoryEntry addin in rep.Addins) {
if ((id == null || Addin.GetIdName (addin.Addin.Id) == id) && (version == null || addin.Addin.Version == version)) {
if (updates) {
Addin ainfo = service.Registry.GetAddin (Addin.GetIdName (addin.Addin.Id));
if (ainfo == null || Addin.CompareVersions (ainfo.Version, addin.Addin.Version) <= 0)
continue;
}
list.Add (addin);
}
}
}
if ((flags & RepositorySearchFlags.LatestVersionsOnly) != 0)
FilterOldVersions (list);
// Old versions are returned first
list.Sort ();
return list.ToArray ();
}
void FilterOldVersions (List addins)
{
Dictionary versions = new Dictionary ();
foreach (PackageRepositoryEntry a in addins) {
string last;
string id, version;
Addin.GetIdParts (a.Addin.Id, out id, out version);
if (!versions.TryGetValue (id, out last) || Addin.CompareVersions (last, version) > 0)
versions [id] = version;
}
for (int n=0; n
/// No special search options
///
None,
///
/// Only the latest version of every add-in is included in the search
///
LatestVersionsOnly = 1,
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup/PcFileCache.cs 0000664 0001750 0001750 00000040172 12136523632 026650 0 ustar 00directhex directhex 0000000 0000000 //
// PcFileCache.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (c) 2009 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
using System;
using System.Text;
using System.Xml;
using System.IO;
using System.Collections.Generic;
namespace Mono.PkgConfig
{
internal interface IPcFileCacheContext where TP:PackageInfo, new()
{
// In the implementation of this method, the host application can extract
// information from the pc file and store it in the PackageInfo object
void StoreCustomData (PcFile pcfile, TP pkg);
// Should return false if the provided package does not have required
// custom data
bool IsCustomDataComplete (string pcfile, TP pkg);
// Called to report errors
void ReportError (string message, Exception ex);
}
internal interface IPcFileCacheContext: IPcFileCacheContext
{
}
internal abstract class PcFileCache: PcFileCache
{
public PcFileCache (IPcFileCacheContext ctx): base (ctx)
{
}
}
internal abstract class PcFileCache where TP:PackageInfo, new()
{
const string CACHE_VERSION = "2";
Dictionary infos = new Dictionary ();
Dictionary> filesByFolder = new Dictionary> ();
string cacheFile;
bool hasChanges;
IPcFileCacheContext ctx;
IEnumerable defaultPaths;
public PcFileCache (IPcFileCacheContext ctx)
{
this.ctx = ctx;
try {
string path = CacheDirectory;
if (!Directory.Exists (path))
Directory.CreateDirectory (path);
cacheFile = Path.Combine (path, "pkgconfig-cache-" + CACHE_VERSION + ".xml");
if (File.Exists (cacheFile))
Load ();
} catch (Exception ex) {
ctx.ReportError ("pc file cache could not be loaded.", ex);
}
}
protected abstract string CacheDirectory { get; }
// Updates the pkg-config index, using the default search directories
public void Update ()
{
Update (GetDefaultPaths ());
}
// Updates the pkg-config index, looking for .pc files in the provided directories
public void Update (IEnumerable pkgConfigDirs)
{
foreach (string pcdir in pkgConfigDirs) {
foreach (string pcfile in Directory.GetFiles (pcdir, "*.pc"))
GetPackageInfo (pcfile);
}
Save ();
}
public IEnumerable GetPackages ()
{
return GetPackages (null);
}
public IEnumerable GetPackages (IEnumerable pkgConfigDirs)
{
if (pkgConfigDirs == null)
pkgConfigDirs = GetDefaultPaths ();
foreach (string sp in pkgConfigDirs) {
List list;
if (filesByFolder.TryGetValue (Path.GetFullPath (sp), out list)) {
foreach (TP p in list)
yield return p;
}
}
}
public TP GetPackageInfoByName (string name)
{
return GetPackageInfoByName (name, null);
}
public TP GetPackageInfoByName (string name, IEnumerable pkgConfigDirs)
{
foreach (TP p in GetPackages (pkgConfigDirs))
if (p.Name == name)
return p;
return null;
}
// Returns information about a .pc file
public TP GetPackageInfo (string file)
{
TP info, oldInfo = null;
file = Path.GetFullPath (file);
DateTime wtime = File.GetLastWriteTime (file);
lock (infos) {
if (infos.TryGetValue (file, out info)) {
if (info.LastWriteTime == wtime)
return info;
oldInfo = info;
}
}
try {
info = ParsePackageInfo (file);
} catch (Exception ex) {
ctx.ReportError ("Error while parsing .pc file", ex);
info = new TP ();
}
lock (infos) {
if (!info.IsValidPackage)
info = new TP (); // Create a default empty instance
info.LastWriteTime = wtime;
Add (file, info, oldInfo);
hasChanges = true;
}
return info;
}
void Add (string file, TP info, TP replacedInfo)
{
infos [file] = info;
string dir = Path.GetFullPath (Path.GetDirectoryName (file));
List list;
if (!filesByFolder.TryGetValue (dir, out list)) {
list = new List ();
filesByFolder [dir] = list;
}
if (replacedInfo != null) {
int i = list.IndexOf (replacedInfo);
if (i != -1) {
list [i] = info;
return;
}
}
list.Add (info);
}
FileStream OpenFile (FileAccess access)
{
int retries = 6;
FileMode mode = access == FileAccess.Read ? FileMode.Open : FileMode.Create;
Exception lastException = null;
while (retries > 0) {
try {
return new FileStream (cacheFile, mode, access, FileShare.None);
} catch (Exception ex) {
// the file may be locked by another app. Wait a bit and try again
lastException = ex;
System.Threading.Thread.Sleep (200);
retries--;
}
}
ctx.ReportError ("File could not be opened: " + cacheFile, lastException);
return null;
}
void Load ()
{
// The serializer can't be used because this file is reused in xbuild
using (FileStream fs = OpenFile (FileAccess.Read)) {
if (fs == null)
return;
XmlTextReader xr = new XmlTextReader (fs);
xr.MoveToContent ();
xr.ReadStartElement ();
xr.MoveToContent ();
while (xr.NodeType == XmlNodeType.Element)
ReadPackage (xr);
}
}
public void Save ()
{
// The serializer can't be used because this file is reused in xbuild
lock (infos) {
if (!hasChanges)
return;
using (FileStream fs = OpenFile (FileAccess.Write)) {
if (fs == null)
return;
XmlTextWriter tw = new XmlTextWriter (new StreamWriter (fs));
tw.Formatting = Formatting.Indented;
tw.WriteStartElement ("PcFileCache");
foreach (KeyValuePair file in infos) {
WritePackage (tw, file.Key, file.Value);
}
tw.WriteEndElement (); // PcFileCache
tw.Flush ();
hasChanges = false;
}
}
}
void WritePackage (XmlTextWriter tw, string file, TP pinfo)
{
tw.WriteStartElement ("File");
tw.WriteAttributeString ("path", file);
tw.WriteAttributeString ("lastWriteTime", XmlConvert.ToString (pinfo.LastWriteTime, XmlDateTimeSerializationMode.Local));
if (pinfo.IsValidPackage) {
if (pinfo.Name != null)
tw.WriteAttributeString ("name", pinfo.Name);
if (pinfo.Version != null)
tw.WriteAttributeString ("version", pinfo.Version);
if (!string.IsNullOrEmpty (pinfo.Description))
tw.WriteAttributeString ("description", pinfo.Description);
if (pinfo.CustomData != null) {
foreach (KeyValuePair cd in pinfo.CustomData)
tw.WriteAttributeString (cd.Key, cd.Value);
}
WritePackageContent (tw, file, pinfo);
}
tw.WriteEndElement (); // File
}
protected virtual void WritePackageContent (XmlTextWriter tw, string file, TP pinfo)
{
}
void ReadPackage (XmlReader tr)
{
TP pinfo = new TP ();
string file = null;
tr.MoveToFirstAttribute ();
do {
switch (tr.LocalName) {
case "path": file = tr.Value; break;
case "lastWriteTime": pinfo.LastWriteTime = XmlConvert.ToDateTime (tr.Value, XmlDateTimeSerializationMode.Local); break;
case "name": pinfo.Name = tr.Value; break;
case "version": pinfo.Version = tr.Value; break;
case "description": pinfo.Description = tr.Value; break;
default: pinfo.SetData (tr.LocalName, tr.Value); break;
}
} while (tr.MoveToNextAttribute ());
tr.MoveToElement ();
if (!tr.IsEmptyElement) {
tr.ReadStartElement ();
tr.MoveToContent ();
ReadPackageContent (tr, pinfo);
tr.MoveToContent ();
tr.ReadEndElement ();
} else
tr.Read ();
tr.MoveToContent ();
if (!pinfo.IsValidPackage || ctx.IsCustomDataComplete (file, pinfo))
Add (file, pinfo, null);
}
protected virtual void ReadPackageContent (XmlReader tr, TP pinfo)
{
}
public object SyncRoot {
get { return infos; }
}
TP ParsePackageInfo (string pcfile)
{
PcFile file = new PcFile ();
file.Load (pcfile);
TP pinfo = new TP ();
pinfo.Name = Path.GetFileNameWithoutExtension (file.FilePath);
if (!file.HasErrors) {
pinfo.Version = file.Version;
pinfo.Description = file.Description;
ParsePackageInfo (file, pinfo);
ctx.StoreCustomData (file, pinfo);
}
return pinfo;
}
protected virtual void ParsePackageInfo (PcFile file, TP pinfo)
{
}
IEnumerable GetDefaultPaths ()
{
if (defaultPaths == null) {
string pkgConfigPath = Environment.GetEnvironmentVariable ("PKG_CONFIG_PATH");
string pkgConfigDir = Environment.GetEnvironmentVariable ("PKG_CONFIG_LIBDIR");
defaultPaths = GetPkgconfigPaths (null, pkgConfigPath, pkgConfigDir);
}
return defaultPaths;
}
public IEnumerable GetPkgconfigPaths (string prefix, string pkgConfigPath, string pkgConfigLibdir)
{
char[] sep = new char[] { Path.PathSeparator };
string[] pkgConfigPaths = null;
if (!String.IsNullOrEmpty (pkgConfigPath)) {
pkgConfigPaths = pkgConfigPath.Split (sep, StringSplitOptions.RemoveEmptyEntries);
if (pkgConfigPaths.Length == 0)
pkgConfigPaths = null;
}
string[] pkgConfigLibdirs = null;
if (!String.IsNullOrEmpty (pkgConfigLibdir)) {
pkgConfigLibdirs = pkgConfigLibdir.Split (sep, StringSplitOptions.RemoveEmptyEntries);
if (pkgConfigLibdirs.Length == 0)
pkgConfigLibdirs = null;
}
if (prefix == null)
prefix = PathUp (typeof (int).Assembly.Location, 4);
IEnumerable paths = GetUnfilteredPkgConfigDirs (pkgConfigPaths, pkgConfigLibdirs, new string [] { prefix });
return NormaliseAndFilterPaths (paths, Environment.CurrentDirectory);
}
IEnumerable GetUnfilteredPkgConfigDirs (IEnumerable pkgConfigPaths, IEnumerable pkgConfigLibdirs, IEnumerable systemPrefixes)
{
if (pkgConfigPaths != null) {
foreach (string dir in pkgConfigPaths)
yield return dir;
}
if (pkgConfigLibdirs != null) {
foreach (string dir in pkgConfigLibdirs)
yield return dir;
} else if (systemPrefixes != null) {
string[] suffixes = new string [] {
Path.Combine ("lib", "pkgconfig"),
Path.Combine ("lib64", "pkgconfig"),
Path.Combine ("libdata", "pkgconfig"),
Path.Combine ("share", "pkgconfig"),
};
foreach (string prefix in systemPrefixes)
foreach (string suffix in suffixes)
yield return Path.Combine (prefix, suffix);
}
}
IEnumerable NormaliseAndFilterPaths (IEnumerable paths, string workingDirectory)
{
Dictionary filtered = new Dictionary ();
foreach (string p in paths) {
string path = p;
if (!Path.IsPathRooted (path))
path = Path.Combine (workingDirectory, path);
path = Path.GetFullPath (path);
if (filtered.ContainsKey (path))
continue;
filtered.Add (path,path);
try {
if (!Directory.Exists (path))
continue;
} catch (IOException ex) {
ctx.ReportError ("Error checking for directory '" + path + "'.", ex);
}
yield return path;
}
}
static string PathUp (string path, int up)
{
if (up == 0)
return path;
for (int i = path.Length -1; i >= 0; i--) {
if (path[i] == Path.DirectorySeparatorChar) {
up--;
if (up == 0)
return path.Substring (0, i);
}
}
return null;
}
}
internal class PcFile
{
Dictionary variables = new Dictionary ();
string filePath;
string name;
string description;
string version;
string libs;
bool hasErrors;
public string Description {
get {
return description;
}
set {
description = value;
}
}
public string FilePath {
get {
return filePath;
}
set {
filePath = value;
}
}
public bool HasErrors {
get {
return hasErrors;
}
set {
hasErrors = value;
}
}
public string Libs {
get {
return libs;
}
set {
libs = value;
}
}
public string Name {
get {
return name;
}
set {
name = value;
}
}
public string Version {
get {
return version;
}
set {
version = value;
}
}
public string GetVariable (string varName)
{
string val;
variables.TryGetValue (varName, out val);
return val;
}
public void Load (string pcfile)
{
FilePath = pcfile;
variables.Add ("pcfiledir", Path.GetDirectoryName (pcfile));
using (StreamReader reader = new StreamReader (pcfile)) {
string line;
while ((line = reader.ReadLine ()) != null) {
int i = line.IndexOf (':');
int j = line.IndexOf ('=');
int k = System.Math.Min (i != -1 ? i : int.MaxValue, j != -1 ? j : int.MaxValue);
if (k == int.MaxValue)
continue;
string var = line.Substring (0, k).Trim ();
string value = line.Substring (k + 1).Trim ();
value = Evaluate (value);
if (k == j) {
// Is variable
variables [var] = value;
}
else {
switch (var) {
case "Name": Name = value; break;
case "Description": Description = value; break;
case "Version": Version = value; break;
case "Libs": Libs = value; break;
}
}
}
}
}
string Evaluate (string value)
{
int i = value.IndexOf ("${");
if (i == -1)
return value;
StringBuilder sb = new StringBuilder ();
int last = 0;
while (i != -1 && i < value.Length) {
sb.Append (value.Substring (last, i - last));
if (i == 0 || value [i - 1] != '$') {
// Evaluate if var is not escaped
i += 2;
int n = value.IndexOf ('}', i);
if (n == -1 || n == i) {
// Closing bracket not found or empty name
HasErrors = true;
return value;
}
string rname = value.Substring (i, n - i);
string rval;
if (variables.TryGetValue (rname, out rval))
sb.Append (rval);
else {
HasErrors = true;
return value;
}
i = n + 1;
last = i;
} else
last = i++;
if (i < value.Length - 1)
i = value.IndexOf ("${", i);
}
sb.Append (value.Substring (last, value.Length - last));
return sb.ToString ();
}
}
internal class PackageInfo
{
Dictionary customData;
string name;
string version;
string description;
DateTime lastWriteTime;
public string Name {
get { return name; }
set { name = value; }
}
public string Version {
get { return version; }
set { version = value; }
}
public string Description {
get { return description; }
set { description = value; }
}
public string GetData (string name)
{
if (customData == null)
return null;
string res;
customData.TryGetValue (name, out res);
return res;
}
public void SetData (string name, string value)
{
if (customData == null)
customData = new Dictionary ();
customData [name] = value;
}
public void RemoveData (string name)
{
if (customData != null)
customData.Remove (name);
}
internal Dictionary CustomData {
get { return customData; }
}
internal DateTime LastWriteTime {
get { return lastWriteTime; }
set { lastWriteTime = value; }
}
internal bool HasCustomData {
get { return customData != null && customData.Count > 0; }
}
internal protected virtual bool IsValidPackage {
get { return HasCustomData; }
}
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup/NativePackage.cs 0000664 0001750 0001750 00000004354 12136523632 027266 0 ustar 00directhex directhex 0000000 0000000 //
// NativePackage.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2005 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using Mono.Addins.Description;
namespace Mono.Addins.Setup
{
internal class NativePackage: Package
{
public override string Name {
get { return "Native package"; }
}
internal override void PrepareInstall (IProgressMonitor monitor, AddinStore service)
{
}
internal override void CommitInstall (IProgressMonitor monitor, AddinStore service)
{
}
internal override void RollbackInstall (IProgressMonitor monitor, AddinStore service)
{
}
internal override void Resolve (IProgressMonitor monitor, AddinStore service, PackageCollection toInstall, PackageCollection toUninstall, PackageCollection required, DependencyCollection unresolved)
{
}
internal override void PrepareUninstall (IProgressMonitor monitor, AddinStore service)
{
}
internal override void CommitUninstall (IProgressMonitor monitor, AddinStore service)
{
}
internal override void RollbackUninstall (IProgressMonitor monitor, AddinStore service)
{
}
internal override bool IsUpgradeOf (Package p)
{
return false;
}
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup/AddinInfo.cs 0000664 0001750 0001750 00000024066 12136523632 026421 0 ustar 00directhex directhex 0000000 0000000 //
// AddinInfo.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.IO;
using System.Collections;
using System.Xml;
using System.Xml.Serialization;
using Mono.Addins.Description;
namespace Mono.Addins.Setup
{
internal class AddinInfo: AddinHeader
{
string id = "";
string namspace = "";
string name = "";
string version = "";
string baseVersion = "";
string author = "";
string copyright = "";
string url = "";
string description = "";
string category = "";
DependencyCollection dependencies;
DependencyCollection optionalDependencies;
AddinPropertyCollectionImpl properties;
public AddinInfo ()
{
dependencies = new DependencyCollection ();
optionalDependencies = new DependencyCollection ();
properties = new AddinPropertyCollectionImpl ();
}
public string Id {
get { return Addin.GetFullId (namspace, id, version); }
}
[XmlElement ("Id")]
public string LocalId {
get { return id; }
set { id = value; }
}
public string Namespace {
get { return namspace; }
set { namspace = value; }
}
public string Name {
get {
string s = Properties.GetPropertyValue ("Name");
if (s.Length > 0)
return s;
if (name != null && name.Length > 0)
return name;
string sid = id;
if (sid.StartsWith ("__"))
sid = sid.Substring (2);
return Addin.GetFullId (namspace, sid, null);
}
set { name = value; }
}
public string Version {
get { return version; }
set { version = value; }
}
public string BaseVersion {
get { return baseVersion; }
set { baseVersion = value; }
}
public string Author {
get {
string s = Properties.GetPropertyValue ("Author");
if (s.Length > 0)
return s;
return author;
}
set { author = value; }
}
public string Copyright {
get {
string s = Properties.GetPropertyValue ("Copyright");
if (s.Length > 0)
return s;
return copyright;
}
set { copyright = value; }
}
public string Url {
get {
string s = Properties.GetPropertyValue ("Url");
if (s.Length > 0)
return s;
return url;
}
set { url = value; }
}
public string Description {
get {
string s = Properties.GetPropertyValue ("Description");
if (s.Length > 0)
return s;
return description;
}
set { description = value; }
}
public string Category {
get {
string s = Properties.GetPropertyValue ("Category");
if (s.Length > 0)
return s;
return category;
}
set { category = value; }
}
[XmlArrayItem ("AddinDependency", typeof(AddinDependency))]
[XmlArrayItem ("NativeDependency", typeof(NativeDependency))]
[XmlArrayItem ("AssemblyDependency", typeof(AssemblyDependency))]
public DependencyCollection Dependencies {
get { return dependencies; }
}
[XmlArrayItem ("AddinDependency", typeof(AddinDependency))]
[XmlArrayItem ("NativeDependency", typeof(NativeDependency))]
[XmlArrayItem ("AssemblyDependency", typeof(AssemblyDependency))]
public DependencyCollection OptionalDependencies {
get { return optionalDependencies; }
}
[XmlArrayItem ("Property", typeof(AddinProperty))]
public AddinPropertyCollectionImpl Properties {
get { return properties; }
}
AddinPropertyCollection AddinHeader.Properties {
get { return properties; }
}
public static AddinInfo ReadFromAddinFile (StreamReader r)
{
XmlDocument doc = new XmlDocument ();
doc.Load (r);
r.Close ();
AddinInfo info = new AddinInfo ();
info.id = doc.DocumentElement.GetAttribute ("id");
info.namspace = doc.DocumentElement.GetAttribute ("namespace");
info.name = doc.DocumentElement.GetAttribute ("name");
if (info.id == "") info.id = info.name;
info.version = doc.DocumentElement.GetAttribute ("version");
info.author = doc.DocumentElement.GetAttribute ("author");
info.copyright = doc.DocumentElement.GetAttribute ("copyright");
info.url = doc.DocumentElement.GetAttribute ("url");
info.description = doc.DocumentElement.GetAttribute ("description");
info.category = doc.DocumentElement.GetAttribute ("category");
info.baseVersion = doc.DocumentElement.GetAttribute ("compatVersion");
AddinPropertyCollectionImpl props = new AddinPropertyCollectionImpl ();
info.properties = props;
ReadHeader (info, props, doc.DocumentElement);
ReadDependencies (info.Dependencies, info.OptionalDependencies, doc.DocumentElement);
return info;
}
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);
}
static void ReadHeader (AddinInfo info, AddinPropertyCollectionImpl properties, XmlElement elem)
{
elem = elem.SelectSingleNode ("Header") as XmlElement;
if (elem == null)
return;
foreach (XmlNode xprop in elem.ChildNodes) {
XmlElement prop = xprop as XmlElement;
if (prop != null) {
switch (prop.LocalName) {
case "Id": info.id = prop.InnerText; break;
case "Namespace": info.namspace = prop.InnerText; break;
case "Version": info.version = prop.InnerText; break;
case "CompatVersion": info.baseVersion = prop.InnerText; break;
default: {
AddinProperty aprop = new AddinProperty ();
aprop.Name = prop.LocalName;
if (prop.HasAttribute ("locale"))
aprop.Locale = prop.GetAttribute ("locale");
aprop.Value = prop.InnerText;
properties.Add (aprop);
break;
}}
}
}
}
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;
}
public bool SupportsVersion (string version)
{
if (Addin.CompareVersions (Version, version) > 0)
return false;
if (baseVersion == "")
return true;
return Addin.CompareVersions (BaseVersion, version) >= 0;
}
public int CompareVersionTo (AddinHeader other)
{
return Addin.CompareVersions (this.version, other.Version);
}
}
///
/// Basic add-in information
///
public interface AddinHeader
{
///
/// Full identifier of the add-in
///
string Id {
get;
}
///
/// Display name of the add-in
///
string Name {
get;
}
///
/// Namespace of the add-in
///
string Namespace {
get;
}
///
/// Version of the add-in
///
string Version {
get;
}
///
/// Version with which this add-in is compatible
///
string BaseVersion {
get;
}
///
/// Add-in author
///
string Author {
get;
}
///
/// Add-in copyright
///
string Copyright {
get;
}
///
/// Web page URL with more information about the add-in
///
string Url {
get;
}
///
/// Description of the add-in
///
string Description {
get;
}
///
/// Category of the add-in
///
string Category {
get;
}
///
/// Dependencies of the add-in
///
DependencyCollection Dependencies {
get;
}
///
/// Optional dependencies of the add-in
///
DependencyCollection OptionalDependencies {
get;
}
///
/// Custom properties specified in the add-in header
///
AddinPropertyCollection Properties {
get;
}
///
/// Compares the versions of two add-ins
///
///
/// Another add-in
///
///
/// Result of comparison
///
int CompareVersionTo (AddinHeader other);
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup/InstallException.cs 0000664 0001750 0001750 00000003430 12136523632 030043 0 ustar 00directhex directhex 0000000 0000000 //
// InstallException.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
namespace Mono.Addins.Setup
{
///
/// An installation exception
///
public class InstallException: Exception
{
///
/// Initializes the exception
///
///
/// Error message
///
public InstallException (string msg): base (msg)
{
}
///
/// Initializes the exception
///
///
/// Error message
///
///
/// Inner exception
///
public InstallException (string msg, Exception ex): base (msg, ex)
{
}
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup/AddinStore.cs 0000664 0001750 0001750 00000047471 12136523632 026627 0 ustar 00directhex directhex 0000000 0000000 //
// AddinStore.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
using System.Collections.Specialized;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
using System.Reflection;
using System.Diagnostics;
using System.Net;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using ICSharpCode.SharpZipLib.Zip;
using Mono.Addins;
using Mono.Addins.Setup.ProgressMonitoring;
using Mono.Addins.Description;
using Mono.Addins.Serialization;
using System.Collections.Generic;
using System.Linq;
namespace Mono.Addins.Setup
{
internal class AddinStore
{
SetupService service;
public AddinStore (SetupService service)
{
this.service = service;
}
internal void ResetCachedData ()
{
}
public AddinRegistry Registry {
get { return service.Registry; }
}
public bool Install (IProgressStatus statusMonitor, params string[] files)
{
Package[] packages = new Package [files.Length];
for (int n=0; n ids)
{
IProgressMonitor monitor = ProgressStatusMonitor.GetProgressMonitor (statusMonitor);
monitor.BeginTask ("Uninstalling add-ins", ids.Count ());
foreach (string id in ids) {
bool rollback = false;
ArrayList toUninstall = new ArrayList ();
ArrayList uninstallPrepared = new ArrayList ();
Addin ia = service.Registry.GetAddin (id);
if (ia == null)
throw new InstallException ("The add-in '" + id + "' is not installed.");
toUninstall.Add (AddinPackage.FromInstalledAddin (ia));
Addin[] deps = GetDependentAddins (id, true);
foreach (Addin dep in deps)
toUninstall.Add (AddinPackage.FromInstalledAddin (dep));
monitor.BeginTask ("Deleting files", toUninstall.Count*2 + uninstallPrepared.Count + 1);
// Prepare install
foreach (Package mpack in toUninstall) {
try {
mpack.PrepareUninstall (monitor, this);
monitor.Step (1);
uninstallPrepared.Add (mpack);
} catch (Exception ex) {
ReportException (monitor, ex);
rollback = true;
break;
}
}
// Commit install
if (!rollback) {
foreach (Package mpack in toUninstall) {
try {
mpack.CommitUninstall (monitor, this);
monitor.Step (1);
} catch (Exception ex) {
ReportException (monitor, ex);
rollback = true;
break;
}
}
}
// Rollback if failed
if (rollback) {
monitor.BeginTask ("Rolling back uninstall", uninstallPrepared.Count);
foreach (Package mpack in uninstallPrepared) {
try {
mpack.RollbackUninstall (monitor, this);
} catch (Exception ex) {
ReportException (monitor, ex);
}
}
monitor.EndTask ();
}
monitor.Step (1);
// Cleanup
foreach (Package mpack in uninstallPrepared) {
try {
mpack.EndUninstall (monitor, this);
monitor.Step (1);
} catch (Exception ex) {
monitor.Log.WriteLine (ex);
}
}
monitor.EndTask ();
monitor.Step (1);
}
// Update the extension maps
service.Registry.Update (statusMonitor);
monitor.EndTask ();
service.SaveConfiguration ();
ResetCachedData ();
}
public Addin[] GetDependentAddins (string id, bool recursive)
{
ArrayList list = new ArrayList ();
FindDependentAddins (list, id, recursive);
return (Addin[]) list.ToArray (typeof (Addin));
}
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);
}
}
}
}
public bool ResolveDependencies (IProgressStatus statusMonitor, AddinRepositoryEntry[] addins, out PackageCollection resolved, out PackageCollection toUninstall, out DependencyCollection unresolved)
{
resolved = new PackageCollection ();
for (int n=0; n
//
// Copyright (c) 2009 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
using System;
using System.Text;
namespace Mono.Addins.Setup
{
enum WrappingType
{
None,
Char,
Word,
WordChar
}
class TextFormatter
{
string indentString = "";
string formattedIndentString;
int indentColumnWidth;
string paragFormattedIndentString;
int paragIndentColumnWidth;
int leftMargin;
int paragraphStartMargin;
WrappingType wrap;
int tabWidth;
bool tabsAsSpaces;
public int MaxColumns { get; set; }
StringBuilder builder = new StringBuilder ();
StringBuilder currentWord = new StringBuilder ();
int curCol;
bool lineStart = true;
bool lastWasSeparator;
bool paragraphStart = true;
int wordLevel;
public TextFormatter ()
{
MaxColumns = 80;
TabWidth = 4;
}
public int TabWidth {
get { return tabWidth; }
set {
tabWidth = value;
formattedIndentString = null;
}
}
public string IndentString {
get { return indentString; }
set {
if (value == null)
throw new ArgumentNullException ("value");
indentString = value;
formattedIndentString = null;
}
}
public int LeftMargin {
get {
return leftMargin;
}
set {
leftMargin = value;
formattedIndentString = null;
}
}
public int ParagraphStartMargin {
get { return paragraphStartMargin; }
set {
paragraphStartMargin = value;
formattedIndentString = null;
}
}
public WrappingType Wrap {
get {
return wrap;
}
set {
if (wrap != value) {
AppendCurrentWord ('x');
wrap = value;
}
}
}
public bool TabsAsSpaces {
get { return tabsAsSpaces; }
set {
tabsAsSpaces = value;
formattedIndentString = null;
}
}
string FormattedIndentString {
get {
if (formattedIndentString == null)
CreateIndentString ();
return formattedIndentString;
}
}
int IndentColumnWidth {
get {
if (formattedIndentString == null)
CreateIndentString ();
return indentColumnWidth;
}
}
string ParagFormattedIndentString {
get {
if (formattedIndentString == null)
CreateIndentString ();
return paragFormattedIndentString;
}
}
int ParagIndentColumnWidth {
get {
if (formattedIndentString == null)
CreateIndentString ();
return paragIndentColumnWidth;
}
}
public void Clear ()
{
builder = new StringBuilder ();
currentWord = new StringBuilder ();
curCol = 0;
lineStart = true;
paragraphStart = true;
lastWasSeparator = false;
}
public void AppendWord (string text)
{
BeginWord ();
Append (text);
EndWord ();
}
public void Append (string text)
{
if (string.IsNullOrEmpty (text))
return;
if (builder.Length == 0) {
curCol = IndentColumnWidth;
lineStart = true;
paragraphStart = true;
}
if (Wrap == WrappingType.None || Wrap == WrappingType.Char) {
AppendChars (text, Wrap == WrappingType.Char);
return;
}
int n = 0;
while (n < text.Length)
{
int sn = n;
bool foundSpace = false;
while (n < text.Length && !foundSpace) {
if ((char.IsWhiteSpace (text [n]) && wordLevel == 0) || text [n] == '\n')
foundSpace = true;
else
n++;
}
if (n != sn)
currentWord.Append (text.Substring (sn, n - sn));
if (foundSpace) {
AppendCurrentWord (text[n]);
n++;
}
}
}
public void AppendLine ()
{
AppendCurrentWord ('x');
AppendChar ('\n', false);
}
public void BeginWord ()
{
wordLevel++;
}
public void EndWord ()
{
if (wordLevel == 0)
throw new InvalidOperationException ("Missing BeginWord call");
wordLevel--;
char lastChar = 'x';
if (currentWord.Length > 0) {
lastChar = currentWord [currentWord.Length - 1];
if (char.IsWhiteSpace (lastChar))
currentWord.Remove (currentWord.Length - 1, 1);
}
AppendCurrentWord (lastChar);
}
public void FlushWord ()
{
AppendCurrentWord ('x');
if (curCol > MaxColumns)
AppendSoftBreak ();
}
public override string ToString ()
{
if (currentWord.Length > 0)
AppendCurrentWord ('x');
return builder.ToString ();
}
void AppendChars (string s, bool wrapChars)
{
foreach (char c in s)
AppendChar (c, wrapChars);
}
void AppendSoftBreak ()
{
AppendChar ('\n', true);
paragraphStart = false;
curCol = IndentColumnWidth;
}
void AppendChar (char c, bool wrapChars)
{
if (c == '\n') {
lineStart = true;
paragraphStart = true;
builder.Append (c);
curCol = ParagIndentColumnWidth;
lastWasSeparator = false;
return;
}
else if (lineStart) {
if (paragraphStart)
builder.Append (ParagFormattedIndentString);
else
builder.Append (FormattedIndentString);
lineStart = false;
paragraphStart = false;
lastWasSeparator = false;
}
if (wrapChars && curCol >= MaxColumns) {
AppendSoftBreak ();
if (!char.IsWhiteSpace (c))
AppendChar (c, false);
return;
}
if (c == '\t') {
int tw = GetTabWidth (curCol);
if (TabsAsSpaces)
builder.Append (' ', tw);
else
builder.Append (c);
curCol += tw;
}
else {
builder.Append (c);
curCol++;
}
}
void AppendCurrentWord (char separatorChar)
{
if (currentWord.Length == 0)
return;
if (Wrap == WrappingType.Word || Wrap == WrappingType.WordChar) {
if (curCol + currentWord.Length > MaxColumns) {
// If the last char was a word separator, remove it
if (lastWasSeparator)
builder.Remove (builder.Length - 1, 1);
if (!lineStart)
AppendSoftBreak ();
}
}
AppendChars (currentWord.ToString (), Wrap == WrappingType.WordChar);
if (char.IsWhiteSpace (separatorChar) || (separatorChar == '\n' && !lineStart)) {
lastWasSeparator = true;
AppendChar (separatorChar, true);
} else
lastWasSeparator = false;
currentWord = new StringBuilder ();
}
int GetTabWidth (int startCol)
{
int res = startCol % TabWidth;
if (res == 0)
return TabWidth;
else
return TabWidth - res;
}
void CreateIndentString ()
{
StringBuilder sb = new StringBuilder ();
indentColumnWidth = AddIndentString (sb, indentString);
paragFormattedIndentString = sb.ToString () + new string (' ', paragraphStartMargin);
paragIndentColumnWidth = indentColumnWidth + paragraphStartMargin;
if (LeftMargin > 0) {
sb.Append (' ', LeftMargin);
indentColumnWidth += LeftMargin;
}
formattedIndentString = sb.ToString ();
if (paragraphStart)
curCol = paragIndentColumnWidth;
else if (lineStart)
curCol = indentColumnWidth;
}
int AddIndentString (StringBuilder sb, string txt)
{
if (string.IsNullOrEmpty (txt))
return 0;
int count = 0;
foreach (char c in txt) {
if (c == '\t') {
int tw = GetTabWidth (count);
count += tw;
if (TabsAsSpaces)
sb.Append (' ', tw);
else
sb.Append (c);
}
else {
sb.Append (c);
count++;
}
}
return count;
}
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup/RepositoryEntry.cs 0000664 0001750 0001750 00000002706 12136523632 027764 0 ustar 00directhex directhex 0000000 0000000 //
// RepositoryEntry.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
namespace Mono.Addins.Setup
{
internal class RepositoryEntry
{
string url;
internal Repository owner;
public string Url {
get { return url; }
set { url = value; }
}
internal Repository Repository {
get { return owner; }
}
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup/RepositorySerializer.cs 0000664 0001750 0001750 00000004003 12136523632 030764 0 ustar 00directhex directhex 0000000 0000000 //
// RepositorySerializer.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;
using System.Text;
using System.Collections;
using System.Globalization;
namespace Mono.Addins.Setup
{
internal class RepositorySerializer : XmlSerializer
{
protected override void Serialize (object o, XmlSerializationWriter writer)
{
RepositoryWriter xsWriter = writer as RepositoryWriter;
xsWriter.WriteRoot_Repository (o);
}
protected override object Deserialize (XmlSerializationReader reader)
{
RepositoryReader xsReader = reader as RepositoryReader;
return xsReader.ReadRoot_Repository ();
}
protected override XmlSerializationWriter CreateWriter ()
{
return new RepositoryWriter ();
}
protected override XmlSerializationReader CreateReader ()
{
return new RepositoryReader ();
}
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup/AddinRepositoryEntry.cs 0000664 0001750 0001750 00000007741 12136523632 030730 0 ustar 00directhex directhex 0000000 0000000 //
// PackageRepositoryEntry.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Net;
using System.Collections.Generic;
using System.IO;
using System.Threading;
namespace Mono.Addins.Setup
{
internal class PackageRepositoryEntry: RepositoryEntry, AddinRepositoryEntry, IComparable
{
AddinInfo addin;
public AddinInfo Addin {
get { return addin; }
set { addin = value; }
}
AddinHeader AddinRepositoryEntry.Addin {
get { return addin; }
}
public string RepositoryUrl {
get { return Repository.Url; }
}
public string RepositoryName {
get { return Repository.Name; }
}
public int CompareTo (object other)
{
PackageRepositoryEntry rep = (PackageRepositoryEntry) other;
string n1 = Mono.Addins.Addin.GetIdName (Addin.Id);
string n2 = Mono.Addins.Addin.GetIdName (rep.Addin.Id);
if (n1 != n2)
return n1.CompareTo (n2);
else
return Mono.Addins.Addin.CompareVersions (rep.Addin.Version, Addin.Version);
}
public IAsyncResult BeginDownloadSupportFile (string name, AsyncCallback cb, object state)
{
return Repository.BeginDownloadSupportFile (name, cb, state);
}
public Stream EndDownloadSupportFile (IAsyncResult ares)
{
return Repository.EndDownloadSupportFile (ares);
}
}
///
/// A reference to an add-in available in an on-line repository
///
public interface AddinRepositoryEntry
{
///
/// Add-in information
///
AddinHeader Addin {
get;
}
///
/// Url to the add-in package
///
string Url {
get;
}
///
/// The URL of the repository
///
string RepositoryUrl {
get;
}
///
/// Name of the repository
///
string RepositoryName {
get;
}
///
/// Begins downloading a support file
///
///
/// Result of the asynchronous operation, to be used when calling EndDownloadSupportFile to
/// get the download result.
///
///
/// Name of the file.
///
///
/// Callback to be called when the download operation ends.
///
///
/// Custom state object provided by the caller.
///
///
/// This method can be used to get the contents of a support file of an add-in.
/// A support file is a file referenced in the custom properties of an add-in.
///
IAsyncResult BeginDownloadSupportFile (string name, AsyncCallback cb, object state);
///
/// Gets the result of the asynchronous download of a file
///
///
/// The downloaded file.
///
///
/// The async result object returned by BeginDownloadSupportFile.
///
Stream EndDownloadSupportFile (IAsyncResult ares);
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup/Package.cs 0000664 0001750 0001750 00000007137 12136523632 026121 0 ustar 00directhex directhex 0000000 0000000 //
// Package.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.IO;
using Mono.Addins.Description;
namespace Mono.Addins.Setup
{
///
/// An add-in package
///
public abstract class Package
{
internal Package ()
{
}
///
/// Name of the package
///
public abstract string Name { get; }
///
/// Returns true if the package will be installed in the shared directory,
/// false if it will be installed in the user directory.
///
public virtual bool SharedInstall {
get { return false; }
}
///
/// Creates a package object for an add-in available in an on-line repository
///
///
/// An add-in reference
///
///
/// The package
///
public static Package FromRepository (AddinRepositoryEntry repAddin)
{
return AddinPackage.PackageFromRepository (repAddin);
}
///
/// Creates a package object for a local package file
///
///
/// Package file path
///
///
/// The package
///
public static Package FromFile (string file)
{
return AddinPackage.PackageFromFile (file);
}
internal abstract void Resolve (IProgressMonitor monitor, AddinStore service, PackageCollection toInstall, PackageCollection toUninstall, PackageCollection required, DependencyCollection unresolved);
internal abstract void PrepareInstall (IProgressMonitor monitor, AddinStore service);
internal abstract void CommitInstall (IProgressMonitor monitor, AddinStore service);
internal abstract void RollbackInstall (IProgressMonitor monitor, AddinStore service);
internal abstract void PrepareUninstall (IProgressMonitor monitor, AddinStore service);
internal abstract void CommitUninstall (IProgressMonitor monitor, AddinStore service);
internal abstract void RollbackUninstall (IProgressMonitor monitor, AddinStore service);
internal abstract bool IsUpgradeOf (Package p);
internal virtual void EndInstall (IProgressMonitor monitor, AddinStore service)
{
}
internal virtual void EndUninstall (IProgressMonitor monitor, AddinStore service)
{
}
internal string CreateTempFolder ()
{
string bname = Path.Combine (Path.GetTempPath (), "mdtmp");
string tempFolder = bname;
int n = 0;
while (Directory.Exists (tempFolder))
tempFolder = bname + (++n);
return tempFolder;
}
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup/RepositoryRecord.cs 0000664 0001750 0001750 00000007733 12136523632 030106 0 ustar 00directhex directhex 0000000 0000000 //
// RepositoryRecord.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
namespace Mono.Addins.Setup
{
internal class RepositoryRecord: AddinRepository
{
string id;
bool isReference;
string file;
string url;
string name;
bool enabled = true;
DateTime lastModified = new DateTime (1900,1,1);
[XmlAttribute ("id")]
public string Id {
get { return id; }
set { id = value; }
}
public bool IsReference {
get { return isReference; }
set { isReference = value; }
}
public string File {
get { return file; }
set { file = value; }
}
public string CachedFilesDir {
get {
return Path.Combine (Path.GetDirectoryName (File), Path.GetFileNameWithoutExtension (File) + "_files");
}
}
public string Url {
get { return url; }
set { url = value; }
}
public string Name {
get { return name; }
set { name = value; }
}
public string Title {
get { return Name != null && Name != "" ? Name : Url; }
}
public DateTime LastModified {
get { return lastModified; }
set { lastModified = value; }
}
[System.ComponentModel.DefaultValue (true)]
public bool Enabled {
get { return this.enabled; }
set { enabled = value; }
}
public Repository GetCachedRepository ()
{
Repository repo = (Repository) AddinStore.ReadObject (File, typeof(Repository));
if (repo != null)
repo.CachedFilesDir = CachedFilesDir;
return repo;
}
public void ClearCachedRepository ()
{
if (System.IO.File.Exists (File))
System.IO.File.Delete (File);
if (Directory.Exists (CachedFilesDir))
Directory.Delete (CachedFilesDir, true);
}
internal void UpdateCachedRepository (Repository newRep)
{
newRep.url = Url;
if (newRep.Name == null)
newRep.Name = new Uri (Url).Host;
AddinStore.WriteObject (File, newRep);
if (name == null)
name = newRep.Name;
newRep.CachedFilesDir = CachedFilesDir;
}
}
///
/// An on-line add-in repository
///
public interface AddinRepository
{
///
/// Path to the cached add-in repository file
///
string File {
get;
}
///
/// Url of the repository
///
string Url {
get;
}
///
/// Do not use. Use Title instead.
///
string Name {
get;
set;
}
///
/// Title of the repository
///
string Title {
get;
}
///
/// Last change timestamp
///
DateTime LastModified {
get;
}
///
/// Gets a value indicating whether this is enabled.
///
///
/// true if enabled; otherwise, false.
///
bool Enabled {
get;
}
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup/RepositoryEntryCollection.cs 0000664 0001750 0001750 00000003650 12136523632 031777 0 ustar 00directhex directhex 0000000 0000000 //
// RepositoryEntryCollection.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
namespace Mono.Addins.Setup
{
internal class RepositoryEntryCollection: CollectionBase
{
Repository owner;
internal RepositoryEntryCollection (Repository owner)
{
this.owner = owner;
}
public RepositoryEntry this [int n] {
get { return (RepositoryEntry) List [n]; }
}
public void Add (RepositoryEntry entry)
{
List.Add (entry);
}
public void Remove (RepositoryEntry entry)
{
List.Remove (entry);
}
protected override void OnInsert(int index, object value)
{
((RepositoryEntry)value).owner = owner;
}
protected override void OnSet(int index, object oldValue, object newValue)
{
((RepositoryEntry)newValue).owner = owner;
}
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup/serializers.xml 0000664 0001750 0001750 00000001347 12136523632 027312 0 ustar 00directhex directhex 0000000 0000000 AddinSystemConfigurationReaderAddinSystemConfigurationWriterMono.Addins.SetupAddinSystemConfigurationReaderWriter.cstrueRepositoryReaderRepositoryWriterMono.Addins.SetupRepositoryReaderWriter.cstrue
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup/AddinInfoCollection.cs 0000664 0001750 0001750 00000002711 12136523632 030426 0 ustar 00directhex directhex 0000000 0000000 //
// AddinInfoCollection.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
namespace Mono.Addins.Setup
{
internal class AddinInfoCollection: CollectionBase
{
public AddinInfo this [int n] {
get { return (AddinInfo) List [n]; }
}
public void Add (AddinInfo p)
{
List.Add (p);
}
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup/IProgressMonitor.cs 0000664 0001750 0001750 00000003227 12136523632 030047 0 ustar 00directhex directhex 0000000 0000000 //
// IProgressMonitor.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.IO;
namespace Mono.Addins
{
internal interface IProgressMonitor: IDisposable
{
void BeginTask (string name, int totalWork);
void BeginStepTask (string name, int totalWork, int stepSize);
void EndTask ();
void Step (int work);
TextWriter Log { get; }
int LogLevel { get; }
void ReportWarning (string message);
void ReportError (string message, Exception exception);
bool IsCancelRequested { get; }
void Cancel ();
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup/AddinSystemConfigurationReaderWriter.cs 0000664 0001750 0001750 00000027336 12136523632 034065 0 ustar 00directhex directhex 0000000 0000000 // It is automatically generated
using System;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;
using System.Text;
using System.Collections;
using System.Globalization;
namespace Mono.Addins.Setup
{
internal class AddinSystemConfigurationReader : XmlSerializationReader
{
static readonly System.Reflection.MethodInfo fromBinHexStringMethod = typeof (XmlConvert).GetMethod ("FromBinHexString", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic, null, new Type [] {typeof (string)}, null);
static byte [] FromBinHexString (string input)
{
return input == null ? null : (byte []) fromBinHexStringMethod.Invoke (null, new object [] {input});
}
public object ReadRoot_AddinSystemConfiguration ()
{
Reader.MoveToContent();
if (Reader.LocalName != "AddinSystemConfiguration" || Reader.NamespaceURI != "")
throw CreateUnknownNodeException();
return ReadObject_AddinSystemConfiguration (true, true);
}
public Mono.Addins.Setup.AddinSystemConfiguration ReadObject_AddinSystemConfiguration (bool isNullable, bool checkType)
{
Mono.Addins.Setup.AddinSystemConfiguration ob = null;
if (isNullable && ReadNull()) return null;
if (checkType)
{
System.Xml.XmlQualifiedName t = GetXsiType();
if (t == null)
{ }
else if (t.Name != "AddinSystemConfiguration" || t.Namespace != "")
throw CreateUnknownTypeException(t);
}
ob = (Mono.Addins.Setup.AddinSystemConfiguration) Activator.CreateInstance(typeof(Mono.Addins.Setup.AddinSystemConfiguration), true);
Reader.MoveToElement();
while (Reader.MoveToNextAttribute())
{
if (IsXmlnsAttribute (Reader.Name)) {
}
else {
UnknownNode (ob);
}
}
Reader.MoveToElement ();
Reader.MoveToElement();
if (Reader.IsEmptyElement) {
Reader.Skip ();
return ob;
}
Reader.ReadStartElement();
Reader.MoveToContent();
bool b0=false, b1=false, b2=false, b3=false;
while (Reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
if (Reader.NodeType == System.Xml.XmlNodeType.Element)
{
if (Reader.LocalName == "AddinPaths" && Reader.NamespaceURI == "" && !b3) {
if (((object)ob.@AddinPaths) == null)
throw CreateReadOnlyCollectionException ("System.Collections.Specialized.StringCollection");
if (Reader.IsEmptyElement) {
Reader.Skip();
} else {
int n4 = 0;
Reader.ReadStartElement();
Reader.MoveToContent();
while (Reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
if (Reader.NodeType == System.Xml.XmlNodeType.Element)
{
if (Reader.LocalName == "Addin" && Reader.NamespaceURI == "") {
string s5 = Reader.ReadElementString ();
if (((object)ob.@AddinPaths) == null)
throw CreateReadOnlyCollectionException ("System.Collections.Specialized.StringCollection");
ob.@AddinPaths.Add (s5);
n4++;
}
else UnknownNode (null);
}
else UnknownNode (null);
Reader.MoveToContent();
}
ReadEndElement();
}
b3 = true;
}
else if (Reader.LocalName == "RepositoryIdCount" && Reader.NamespaceURI == "" && !b1) {
b1 = true;
string s6 = Reader.ReadElementString ();
ob.@RepositoryIdCount = Int32.Parse (s6, CultureInfo.InvariantCulture);
}
else if (Reader.LocalName == "DisabledAddins" && Reader.NamespaceURI == "" && !b2) {
if (((object)ob.@DisabledAddins) == null)
throw CreateReadOnlyCollectionException ("System.Collections.Specialized.StringCollection");
if (Reader.IsEmptyElement) {
Reader.Skip();
} else {
int n7 = 0;
Reader.ReadStartElement();
Reader.MoveToContent();
while (Reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
if (Reader.NodeType == System.Xml.XmlNodeType.Element)
{
if (Reader.LocalName == "Addin" && Reader.NamespaceURI == "") {
string s8 = Reader.ReadElementString ();
if (((object)ob.@DisabledAddins) == null)
throw CreateReadOnlyCollectionException ("System.Collections.Specialized.StringCollection");
ob.@DisabledAddins.Add (s8);
n7++;
}
else UnknownNode (null);
}
else UnknownNode (null);
Reader.MoveToContent();
}
ReadEndElement();
}
b2 = true;
}
else if (Reader.LocalName == "Repositories" && Reader.NamespaceURI == "" && !b0) {
if (((object)ob.@Repositories) == null)
throw CreateReadOnlyCollectionException ("System.Collections.ArrayList");
if (Reader.IsEmptyElement) {
Reader.Skip();
} else {
int n9 = 0;
Reader.ReadStartElement();
Reader.MoveToContent();
while (Reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
if (Reader.NodeType == System.Xml.XmlNodeType.Element)
{
if (Reader.LocalName == "Repository" && Reader.NamespaceURI == "") {
if (((object)ob.@Repositories) == null)
throw CreateReadOnlyCollectionException ("System.Collections.ArrayList");
ob.@Repositories.Add (ReadObject_RepositoryRecord (false, true));
n9++;
}
else UnknownNode (null);
}
else UnknownNode (null);
Reader.MoveToContent();
}
ReadEndElement();
}
b0 = true;
}
else {
UnknownNode (ob);
}
}
else
UnknownNode(ob);
Reader.MoveToContent();
}
ReadEndElement();
return ob;
}
public Mono.Addins.Setup.RepositoryRecord ReadObject_RepositoryRecord (bool isNullable, bool checkType)
{
Mono.Addins.Setup.RepositoryRecord ob = null;
if (isNullable && ReadNull()) return null;
if (checkType)
{
System.Xml.XmlQualifiedName t = GetXsiType();
if (t == null)
{ }
else if (t.Name != "RepositoryRecord" || t.Namespace != "")
throw CreateUnknownTypeException(t);
}
ob = (Mono.Addins.Setup.RepositoryRecord) Activator.CreateInstance(typeof(Mono.Addins.Setup.RepositoryRecord), true);
Reader.MoveToElement();
while (Reader.MoveToNextAttribute())
{
if (Reader.LocalName == "id" && Reader.NamespaceURI == "") {
ob.@Id = Reader.Value;
}
else if (IsXmlnsAttribute (Reader.Name)) {
}
else {
UnknownNode (ob);
}
}
Reader.MoveToElement ();
Reader.MoveToElement();
if (Reader.IsEmptyElement) {
Reader.Skip ();
return ob;
}
Reader.ReadStartElement();
Reader.MoveToContent();
bool b10=false, b11=false, b12=false, b13=false, b14=false, b15=false;
while (Reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
if (Reader.NodeType == System.Xml.XmlNodeType.Element)
{
if (Reader.LocalName == "File" && Reader.NamespaceURI == "" && !b11) {
b11 = true;
string s16 = Reader.ReadElementString ();
ob.@File = s16;
}
else if (Reader.LocalName == "Enabled" && Reader.NamespaceURI == "" && !b15) {
b15 = true;
string s17 = Reader.ReadElementString ();
ob.@Enabled = XmlConvert.ToBoolean (s17);
}
else if (Reader.LocalName == "IsReference" && Reader.NamespaceURI == "" && !b10) {
b10 = true;
string s18 = Reader.ReadElementString ();
ob.@IsReference = XmlConvert.ToBoolean (s18);
}
else if (Reader.LocalName == "Name" && Reader.NamespaceURI == "" && !b13) {
b13 = true;
string s19 = Reader.ReadElementString ();
ob.@Name = s19;
}
else if (Reader.LocalName == "Url" && Reader.NamespaceURI == "" && !b12) {
b12 = true;
string s20 = Reader.ReadElementString ();
ob.@Url = s20;
}
else if (Reader.LocalName == "LastModified" && Reader.NamespaceURI == "" && !b14) {
b14 = true;
string s21 = Reader.ReadElementString ();
ob.@LastModified = XmlConvert.ToDateTime (s21, XmlDateTimeSerializationMode.RoundtripKind);
}
else {
UnknownNode (ob);
}
}
else
UnknownNode(ob);
Reader.MoveToContent();
}
ReadEndElement();
return ob;
}
protected override void InitCallbacks ()
{
}
protected override void InitIDs ()
{
}
}
internal class AddinSystemConfigurationWriter : XmlSerializationWriter
{
const string xmlNamespace = "http://www.w3.org/2000/xmlns/";
static readonly System.Reflection.MethodInfo toBinHexStringMethod = typeof (XmlConvert).GetMethod ("ToBinHexString", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic, null, new Type [] {typeof (byte [])}, null);
static string ToBinHexString (byte [] input)
{
return input == null ? null : (string) toBinHexStringMethod.Invoke (null, new object [] {input});
}
public void WriteRoot_AddinSystemConfiguration (object o)
{
WriteStartDocument ();
Mono.Addins.Setup.AddinSystemConfiguration ob = (Mono.Addins.Setup.AddinSystemConfiguration) o;
TopLevelElement ();
WriteObject_AddinSystemConfiguration (ob, "AddinSystemConfiguration", "", true, false, true);
}
void WriteObject_AddinSystemConfiguration (Mono.Addins.Setup.AddinSystemConfiguration ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)
{
if (((object)ob) == null)
{
if (isNullable)
WriteNullTagLiteral(element, namesp);
return;
}
System.Type type = ob.GetType ();
if (type == typeof(Mono.Addins.Setup.AddinSystemConfiguration))
{ }
else {
throw CreateUnknownTypeException (ob);
}
if (writeWrappingElem) {
WriteStartElement (element, namesp, ob);
}
if (needType) WriteXsiType("AddinSystemConfiguration", "");
if (ob.@Repositories != null) {
WriteStartElement ("Repositories", "", ob.@Repositories);
for (int n22 = 0; n22 < ob.@Repositories.Count; n22++) {
WriteObject_RepositoryRecord (((Mono.Addins.Setup.RepositoryRecord) ob.@Repositories[n22]), "Repository", "", false, false, true);
}
WriteEndElement (ob.@Repositories);
}
WriteElementString ("RepositoryIdCount", "", ob.@RepositoryIdCount.ToString(CultureInfo.InvariantCulture));
if (ob.@DisabledAddins != null) {
WriteStartElement ("DisabledAddins", "", ob.@DisabledAddins);
for (int n23 = 0; n23 < ob.@DisabledAddins.Count; n23++) {
WriteElementString ("Addin", "", ob.@DisabledAddins[n23]);
}
WriteEndElement (ob.@DisabledAddins);
}
if (ob.@AddinPaths != null) {
WriteStartElement ("AddinPaths", "", ob.@AddinPaths);
for (int n24 = 0; n24 < ob.@AddinPaths.Count; n24++) {
WriteElementString ("Addin", "", ob.@AddinPaths[n24]);
}
WriteEndElement (ob.@AddinPaths);
}
if (writeWrappingElem) WriteEndElement (ob);
}
void WriteObject_RepositoryRecord (Mono.Addins.Setup.RepositoryRecord ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)
{
if (((object)ob) == null)
{
if (isNullable)
WriteNullTagLiteral(element, namesp);
return;
}
System.Type type = ob.GetType ();
if (type == typeof(Mono.Addins.Setup.RepositoryRecord))
{ }
else {
throw CreateUnknownTypeException (ob);
}
if (writeWrappingElem) {
WriteStartElement (element, namesp, ob);
}
if (needType) WriteXsiType("RepositoryRecord", "");
WriteAttribute ("id", "", ob.@Id);
WriteElementString ("IsReference", "", (ob.@IsReference?"true":"false"));
WriteElementString ("File", "", ob.@File);
WriteElementString ("Url", "", ob.@Url);
WriteElementString ("Name", "", ob.@Name);
WriteElementString ("LastModified", "", XmlConvert.ToString (ob.@LastModified, XmlDateTimeSerializationMode.RoundtripKind));
if (ob.@Enabled != true) {
WriteElementString ("Enabled", "", (ob.@Enabled?"true":"false"));
}
if (writeWrappingElem) WriteEndElement (ob);
}
protected override void InitCallbacks ()
{
}
}
}
mono-addins-1.0/Mono.Addins.Setup/Makefile.in 0000664 0001750 0001750 00000042270 12136523720 023067 0 ustar 00directhex directhex 0000000 0000000 # Makefile.in generated by automake 1.11.6 from Makefile.am.
# @configure_input@
# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
# Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
am__make_dryrun = \
{ \
am__dry=no; \
case $$MAKEFLAGS in \
*\\[\ \ ]*) \
echo 'am--echo: ; @echo "AM" OK' | $(MAKE) -f - 2>/dev/null \
| grep '^AM OK$$' >/dev/null || am__dry=yes;; \
*) \
for am__flg in $$MAKEFLAGS; do \
case $$am__flg in \
*=*|--*) ;; \
*n*) am__dry=yes; break;; \
esac; \
done;; \
esac; \
test $$am__dry = yes; \
}
pkgdatadir = $(datadir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkglibexecdir = $(libexecdir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in \
$(srcdir)/mono-addins-setup.pc.in \
$(top_srcdir)/Makefile.include $(top_srcdir)/xbuild.include \
ChangeLog
subdir = ./Mono.Addins.Setup
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(install_sh) -d
CONFIG_CLEAN_FILES = mono-addins-setup.pc
CONFIG_CLEAN_VPATH_FILES =
am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
am__vpath_adj = case $$p in \
$(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
*) f=$$p;; \
esac;
am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
am__install_max = 40
am__nobase_strip_setup = \
srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
am__nobase_strip = \
for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
am__nobase_list = $(am__nobase_strip_setup); \
for p in $$list; do echo "$$p $$p"; done | \
sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
$(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
if (++n[$$2] == $(am__install_max)) \
{ print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
END { for (dir in files) print dir, files[dir] }'
am__base_list = \
sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
am__uninstall_files_from_dir = { \
test -z "$$files" \
|| { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
|| { echo " ( cd '$$dir' && rm -f" $$files ")"; \
$(am__cd) "$$dir" && rm -f $$files; }; \
}
am__installdirs = "$(DESTDIR)$(bindir)" "$(DESTDIR)$(pkgconfigdir)"
SCRIPTS = $(bin_SCRIPTS)
SOURCES =
DIST_SOURCES =
am__can_run_installinfo = \
case $$AM_UPDATE_INFO_DIR in \
n|no|NO) false;; \
*) (install-info --version) >/dev/null 2>&1;; \
esac
DATA = $(pkgconfig_DATA)
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@
AL = @AL@
AMTAR = @AMTAR@
API_VERSION = @API_VERSION@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
GACUTIL = @GACUTIL@
GACUTIL_FLAGS = @GACUTIL_FLAGS@
GACUTIL_POLICY_FLAGS = @GACUTIL_POLICY_FLAGS@
GTK_SHARP_20_CFLAGS = @GTK_SHARP_20_CFLAGS@
GTK_SHARP_20_LIBS = @GTK_SHARP_20_LIBS@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LTLIBOBJS = @LTLIBOBJS@
MAINT = @MAINT@
MAKEINFO = @MAKEINFO@
MCS = @MCS@
MKDIR_P = @MKDIR_P@
MONODOC_CFLAGS = @MONODOC_CFLAGS@
MONODOC_LIBS = @MONODOC_LIBS@
MONO_ADDINS_DEFAULT_LIB = @MONO_ADDINS_DEFAULT_LIB@
MONO_ADDINS_GUI_DEFAULT_LIB = @MONO_ADDINS_GUI_DEFAULT_LIB@
MONO_ADDINS_MSBUILD_DEFAULT_LIB = @MONO_ADDINS_MSBUILD_DEFAULT_LIB@
MONO_ADDINS_SETUP_DEFAULT_LIB = @MONO_ADDINS_SETUP_DEFAULT_LIB@
MONO_NUNIT_CFLAGS = @MONO_NUNIT_CFLAGS@
MONO_NUNIT_LIBS = @MONO_NUNIT_LIBS@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
POLICY_VERSIONS = @POLICY_VERSIONS@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
STRIP = @STRIP@
VERSION = @VERSION@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
am__leading_dot = @am__leading_dot@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build_alias = @build_alias@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
host_alias = @host_alias@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target_alias = @target_alias@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
ASSEMBLY = ../bin/Mono.Addins.Setup.dll
ASSEMBLY_NAME = Mono.Addins.Setup
PC_FILES_IN = mono-addins-setup.pc.in
pc_files = $(PC_FILES_IN:.pc.in=.pc)
POLICY_ASSEMBLIES = $(addsuffix .$(ASSEMBLY_NAME).dll, $(addprefix policy., $(POLICY_VERSIONS)))
POLICY_CONFIGS = $(addsuffix .config, $(addprefix policy., $(POLICY_VERSIONS)))
EXTRA_DIST = \
$(wildcard $(ALL_FILES))
CLEANFILES = $(ASSEMBLY) $(ASSEMBLY).mdb $(DLL_REFERENCES) \
$(POLICY_ASSEMBLIES) $(POLICY_CONFIGS)
DISTCLEANFILES = $(GENERATED_FILES) $(build_datafiles) $(pc_files)
bin_SCRIPTS = $(ASSEMBLY_WRAPPER)
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = $(pc_files)
ALL_CSPROJ = $(wildcard *.csproj)
MAIN_SLN = $(top_builddir)/Mono.Addins.sln
@ENABLE_GUI_FALSE@PROFILE_NAME = DebugNotGui
@ENABLE_GUI_TRUE@PROFILE_NAME = Debug
XBUILD = xbuild
XBUILD_VERBOSITY = quiet
XBUILD_ARGS = /verbosity:$(XBUILD_VERBOSITY) /nologo /property:CodePage=65001
XBUILD_PROFILE = /property:Configuration=$(PROFILE_NAME)
# Figure out how far we are from top_builddir
DEPTH = $(shell echo "$(top_builddir)" | tr '/' '\n' | grep -c '..')
EXTS := *.bmp *.cs *.csproj *.html *.png *.snk *.config *.stetic *.glade *.xml *.xsd *.exe.addins *.template *.tt *.txt
ALL_FILES := $(EXTS) \
$(addprefix */,$(EXTS)) \
$(addprefix */*/,$(EXTS)) \
$(addprefix */*/*/,$(EXTS)) \
$(addprefix */*/*/*/,$(EXTS)) \
$(addprefix */*/*/*/*/,$(EXTS)) \
$(wildcard icons/*) \
$(wildcard templates/*)
WILDCARDED_FILES := $(wildcard $(ALL_FILES))
all: all-am
.SUFFIXES:
$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(top_srcdir)/Makefile.include $(top_srcdir)/xbuild.include $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign ./Mono.Addins.Setup/Makefile'; \
$(am__cd) $(top_srcdir) && \
$(AUTOMAKE) --foreign ./Mono.Addins.Setup/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_srcdir)/Makefile.include $(top_srcdir)/xbuild.include:
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(am__aclocal_m4_deps):
mono-addins-setup.pc: $(top_builddir)/config.status $(srcdir)/mono-addins-setup.pc.in
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@
install-binSCRIPTS: $(bin_SCRIPTS)
@$(NORMAL_INSTALL)
@list='$(bin_SCRIPTS)'; test -n "$(bindir)" || list=; \
if test -n "$$list"; then \
echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \
$(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \
fi; \
for p in $$list; do \
if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
if test -f "$$d$$p"; then echo "$$d$$p"; echo "$$p"; else :; fi; \
done | \
sed -e 'p;s,.*/,,;n' \
-e 'h;s|.*|.|' \
-e 'p;x;s,.*/,,;$(transform)' | sed 'N;N;N;s,\n, ,g' | \
$(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1; } \
{ d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
if ($$2 == $$4) { files[d] = files[d] " " $$1; \
if (++n[d] == $(am__install_max)) { \
print "f", d, files[d]; n[d] = 0; files[d] = "" } } \
else { print "f", d "/" $$4, $$1 } } \
END { for (d in files) print "f", d, files[d] }' | \
while read type dir files; do \
if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
test -z "$$files" || { \
echo " $(INSTALL_SCRIPT) $$files '$(DESTDIR)$(bindir)$$dir'"; \
$(INSTALL_SCRIPT) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
} \
; done
uninstall-binSCRIPTS:
@$(NORMAL_UNINSTALL)
@list='$(bin_SCRIPTS)'; test -n "$(bindir)" || exit 0; \
files=`for p in $$list; do echo "$$p"; done | \
sed -e 's,.*/,,;$(transform)'`; \
dir='$(DESTDIR)$(bindir)'; $(am__uninstall_files_from_dir)
install-pkgconfigDATA: $(pkgconfig_DATA)
@$(NORMAL_INSTALL)
@list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \
if test -n "$$list"; then \
echo " $(MKDIR_P) '$(DESTDIR)$(pkgconfigdir)'"; \
$(MKDIR_P) "$(DESTDIR)$(pkgconfigdir)" || exit 1; \
fi; \
for p in $$list; do \
if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
echo "$$d$$p"; \
done | $(am__base_list) | \
while read files; do \
echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(pkgconfigdir)'"; \
$(INSTALL_DATA) $$files "$(DESTDIR)$(pkgconfigdir)" || exit $$?; \
done
uninstall-pkgconfigDATA:
@$(NORMAL_UNINSTALL)
@list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \
files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
dir='$(DESTDIR)$(pkgconfigdir)'; $(am__uninstall_files_from_dir)
tags: TAGS
TAGS:
ctags: CTAGS
CTAGS:
distdir: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d "$(distdir)/$$file"; then \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
else \
test -f "$(distdir)/$$file" \
|| cp -p $$d/$$file "$(distdir)/$$file" \
|| exit 1; \
fi; \
done
check-am: all-am
check: check-am
all-am: Makefile $(SCRIPTS) $(DATA)
installdirs:
for dir in "$(DESTDIR)$(bindir)" "$(DESTDIR)$(pkgconfigdir)"; do \
test -z "$$dir" || $(MKDIR_P) "$$dir"; \
done
install: install-am
install-exec: install-exec-am
install-data: install-data-am
uninstall: uninstall-am
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-am
install-strip:
if test -z '$(STRIP)'; then \
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
install; \
else \
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
"INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
fi
mostlyclean-generic:
clean-generic:
-test -z "$(CLEANFILES)" || rm -f $(CLEANFILES)
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
-test -z "$(DISTCLEANFILES)" || rm -f $(DISTCLEANFILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean-am: clean-generic mostlyclean-am
distclean: distclean-am
-rm -f Makefile
distclean-am: clean-am distclean-generic
dvi: dvi-am
dvi-am:
html: html-am
html-am:
info: info-am
info-am:
install-data-am: install-data-local install-pkgconfigDATA
install-dvi: install-dvi-am
install-dvi-am:
install-exec-am: install-binSCRIPTS
install-html: install-html-am
install-html-am:
install-info: install-info-am
install-info-am:
install-man:
install-pdf: install-pdf-am
install-pdf-am:
install-ps: install-ps-am
install-ps-am:
installcheck-am:
maintainer-clean: maintainer-clean-am
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-am
mostlyclean-am: mostlyclean-generic
pdf: pdf-am
pdf-am:
ps: ps-am
ps-am:
uninstall-am: uninstall-binSCRIPTS uninstall-local \
uninstall-pkgconfigDATA
.MAKE: install-am install-strip
.PHONY: all all-am check check-am clean clean-generic distclean \
distclean-generic distdir dvi dvi-am html html-am info info-am \
install install-am install-binSCRIPTS install-data \
install-data-am install-data-local install-dvi install-dvi-am \
install-exec install-exec-am install-html install-html-am \
install-info install-info-am install-man install-pdf \
install-pdf-am install-pkgconfigDATA install-ps install-ps-am \
install-strip installcheck installcheck-am installdirs \
maintainer-clean maintainer-clean-generic mostlyclean \
mostlyclean-generic pdf pdf-am ps ps-am uninstall uninstall-am \
uninstall-binSCRIPTS uninstall-local uninstall-pkgconfigDATA
install-data-local: gac-install
uninstall-local: gac-uninstall
$(build_datafiles): $(BUILD_DIR)/% : $(addprefix $(srcdir)/, %)
mkdir -p $(dir $@)
cp $< $@
policy.%.config: $(top_builddir)/policy.config
sed -e "s/@ASSEMBLY_NAME@/$(ASSEMBLY_NAME)/" -e "s/@POLICY@/$*/" $(top_builddir)/policy.config > $@
$(POLICY_ASSEMBLIES) : policy.%.$(ASSEMBLY_NAME).dll: policy.%.config $(top_srcdir)/mono-addins.snk
$(AL) -link:policy.$*.config -out:$@ -keyfile:$(top_srcdir)/mono-addins.snk
gac-install: $(POLICY_ASSEMBLIES)
$(GACUTIL) /i $(ASSEMBLY) /f $(GACUTIL_FLAGS) || exit 1;
@for p in $(POLICY_ASSEMBLIES); do \
echo $(GACUTIL) /i $$p /f $(GACUTIL_POLICY_FLAGS) || exit 1; \
$(GACUTIL) /i $$p /f $(GACUTIL_POLICY_FLAGS) || exit 1; \
done
gac-uninstall:
$(GACUTIL) /us $(ASSEMBLY) $(GACUTIL_FLAGS) || exit 1;
@for p in $(POLICY_ASSEMBLIES); do \
echo $(GACUTIL) /us $$p /f $(GACUTIL_POLICY_FLAGS) || exit 1; \
$(GACUTIL) /us $$p /f $(GACUTIL_POLICY_FLAGS) || exit 1; \
done
all: csproj_build
clean: csproj_clean
csproj_build: $(POLICY_ASSEMBLIES)
@if test x$(SKIP) != xy ; then \
echo Building $(ALL_CSPROJ); \
for p in $(ALL_CSPROJ); do $(XBUILD) $(XBUILD_ARGS) $$p; done \
fi
csproj_clean:
@if test x$(SKIP) != xy -a $(DEPTH) -gt $(MAKELEVEL); then \
echo Cleaning $(ALL_CSPROJ); \
for p in $(ALL_CSPROJ); do $(XBUILD) $(XBUILD_ARGS) $$p /t:Clean; done \
fi
rm -f $(CLEANFILES)
sln_build:
@echo Building $(MAIN_SLN)
@$(XBUILD) $(XBUILD_ARGS) $(MAIN_SLN) $(XBUILD_PROFILE)
sln_clean:
@echo Cleaning $(MAIN_SLN)
@$(XBUILD) $(XBUILD_ARGS) $(MAIN_SLN) $(XBUILD_PROFILE) /t:Clean
print_extradist:
@echo $(WILDCARDED_FILES)
.PHONY: all clean csproj_build csproj_clean sln_build sln_clean
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup.csproj 0000664 0001750 0001750 00000012034 12136524015 025445 0 ustar 00directhex directhex 0000000 0000000
DebugAnyCPU8.0.50727{A85C9721-C054-4BD8-A1F3-0227615F0A36}LibraryMono.Addins.Setup2.0Mono.Addins.SetupTrue..\mono-addins.snkv4.0TruefullTrue..\binprompt4TrueFalseTrue1574noneTrue..\binprompt4TrueFalse{91DD5A2D-9FE3-4C3C-9253-876141874DAD}Mono.AddinsFalse mono-addins-1.0/Mono.Addins.Setup/policy.0.5.config 0000664 0001750 0001750 00000000554 12136524030 024003 0 ustar 00directhex directhex 0000000 0000000
mono-addins-1.0/Mono.Addins.Setup/policy.0.3.config 0000664 0001750 0001750 00000000554 12136524030 024001 0 ustar 00directhex directhex 0000000 0000000
mono-addins-1.0/Mono.Addins.Setup/obj/ 0000775 0001750 0001750 00000000000 12136524043 021566 5 ustar 00directhex directhex 0000000 0000000 mono-addins-1.0/Mono.Addins.Setup/obj/Debug/ 0000775 0001750 0001750 00000000000 12136524044 022615 5 ustar 00directhex directhex 0000000 0000000 mono-addins-1.0/Mono.Addins.Setup/obj/Debug/Mono.Addins.Setup.csproj.FilesWrittenAbsolute.txt 0000664 0001750 0001750 00000000344 12136524037 034205 0 ustar 00directhex directhex 0000000 0000000 /tmp/mono-addins/bin/Mono.Addins.Setup.dll.mdb
/tmp/mono-addins/bin/Mono.Addins.Setup.dll
/tmp/mono-addins/Mono.Addins.Setup/obj/Debug/Mono.Addins.Setup.dll
/tmp/mono-addins/Mono.Addins.Setup/obj/Debug/Mono.Addins.Setup.dll.mdb
mono-addins-1.0/Mono.Addins.Setup/ChangeLog 0000664 0001750 0001750 00000022060 12136523632 022571 0 ustar 00directhex directhex 0000000 0000000 2010-10-14 Lluis Sanchez Gual
* SetupService.cs: Build package now returns a list of the
generated files.
2010-07-01 Lluis Sanchez Gual
* Mono.Addins.Setup.csproj: Generate documentation.
2010-07-01 Lluis Sanchez Gual
* Mono.Addins.Setup/Package.cs:
* Mono.Addins.Setup/AddinInfo.cs:
* Mono.Addins.Setup/SetupTool.cs:
* Mono.Addins.Setup/SetupService.cs:
* Mono.Addins.Setup/RepositoryRecord.cs:
* Mono.Addins.Setup/InstallException.cs:
* Mono.Addins.Setup/PackageCollection.cs:
* Mono.Addins.Setup/RepositoryRegistry.cs:
* Mono.Addins.Setup/AddinRepositoryEntry.cs:
* Mono.Addins.Setup/ConsoleAddinInstaller.cs: Added some
documentation.
2010-05-25 Lluis Sanchez Gual
* Mono.Addins.Setup.csproj: Fix output directory for the
Release configuration.
2010-04-08 Lluis Sanchez Gual
* Mono.Addins.Setup/AddinStore.cs: Properly get the url path
(old way didn't work on windows).
2010-04-08 Lluis Sanchez Gual
* Mono.Addins.Setup/RepositoryRegistry.cs: GetAvailableUpdates
(id,version) doesn't work. It makes no sense to ask for
updates for a specific add-in version. Added
GetAvaliableAddinUpdates methods which take only an id and
no version.
2010-03-30 Lluis Sanchez Gual
* Mono.Addins.Setup.csproj: csc doesn't like iso-2.
2010-03-29 Lluis Sanchez Gual
* Mono.Addins.Setup.csproj: Make sure the solution builds on
MS.NET 2.0.
2010-03-26 Lluis Sanchez Gual
* Mono.Addins.Setup.csproj: Flush.
2009-11-13 Lluis Sanchez Gual
* Mono.Addins.Setup/SetupTool.cs: Allow specifying multiple
levels of verbosity.
2009-09-01 Lluis Sanchez Gual
* AssemblyInfo.cs: Bump Mono.Addins version.
2009-08-25 Lluis Sanchez Gual
* Mono.Addins.Setup/PcFileCache.cs: Updated from MD.
2009-08-24 Lluis Sanchez Gual
* Mono.Addins.Setup/PcFileCache.cs:
* Mono.Addins.Setup/SetupService.cs: Make it buildable in .net
2.0.
2009-08-21 Lluis Sanchez Gual
* Mono.Addins.Setup/SetupService.cs: Applications can now
register a test command to be used for testing add-ins.
Don't use the pkg-config command, use instead the
PcFileCache.
* Mono.Addins.Setup/PcFileCache.cs: Updated.
2009-08-20 Lluis Sanchez Gual
* Makefile.am:
* Mono.Addins.Setup.csproj:
* Mono.Addins.Setup/SetupTool.cs:
* Mono.Addins.Setup/PcFileCache.cs:
* Mono.Addins.Setup/SetupService.cs: Added a new project which
Implements an msbuild task for resolving add-in references.
2009-08-19 Lluis Sanchez Gual
* Mono.Addins.Setup.csproj: Update target framework to 2.0.
2009-06-17 Lluis Sanchez Gual
* Mono.Addins.Setup/SetupService.cs: Added method for getting
a registry from a package name.
* Mono.Addins.Setup/SetupTool.cs: Added some more help for the
info command.
2009-06-04 Lluis Sanchez Gual
* Makefile.am:
* Mono.Addins.Setup.csproj: Remove unnecessary Mono.Posix
reference.
2009-05-28 Lluis Sanchez Gual
* Mono.Addins.Setup.csproj: Properly sign assemblies.
2009-02-06 Lluis Sanchez Gual
* Mono.Addins.Setup/SetupTool.cs: Added command for getting
the list of assemblies of an add-in.
2009/02/06 Lluis Sanchez Gual
* Mono.Addins.Setup.csproj: Updated.
2008-11-10 Lluis Sanchez Gual
* mono-addins-setup.pc.in: Respect custom libdir during ./configure.
Fixes bug #443205. Patch by Diego Pettenò.
2008-11-10 Lluis Sanchez Gual
* Makefile.am: Fix building with parallel make jobs (-j8). Fixes bug
#443206. Patch by Diego Pettenò.
2008-08-22 Lluis Sanchez Gual
* Mono.Addins.Setup.csproj, Mono.Addins.Setup.mdp: Use msbuild file
format for projects. Removed the old MD1 projects.
2008-07-15 Lluis Sanchez Gual
* Mono.Addins.Setup/SetupTool.cs: Add missing parameter documentation.
2008-06-11 Lluis Sanchez Gual
* Mono.Addins.Setup.mdp: Updated.
* Mono.Addins.Setup/SetupTool.cs: Don't allow uninstalling add-ins with
the CantUninstall flag. Same for hidden flag.
2008-02-06 Lluis Sanchez Gual
* AssemblyInfo.cs: Added support for pluggable add-in assembly reflectors.
Implemented an add-in assembly reflector based on Cecil.
2008-01-18 Lluis Sanchez Gual
* Mono.Addins.Setup/RepositoryRegistry.cs: Don't break the api.
2008-01-17 Lluis Sanchez Gual
* Mono.Addins.Setup/AddinPackage.cs: Delete subdirectories when
uninstalling.
* Mono.Addins.Setup/AddinStore.cs: Use a more informative uninstall message.
* Mono.Addins.Setup/RepositoryRegistry.cs: Fix a nullref. Improved error
reporting.
2007-12-15 Lluis Sanchez Gual
* mono-addins-setup.pc.in: Update assembly paths.
2007-12-12 Lluis Sanchez Gual
* Mono.Addins.Setup/SetupTool.cs: Typo fix.
* Makefile.am: Generate and install policy files for old Mono.Addins
versions.
2007-12-05 Lluis Sanchez Gual
* Mono.Addins.Setup/AddinPackage.cs: When checking if an add-in is
installed, don't provide the version number. This will return whatever
version is installed.
2007-12-04 Lluis Sanchez Gual
* mono-addins-setup.pc.in: Fix dependencies.
2007-12-03 Lluis Sanchez Gual
* Mono.Addins.Setup.mdp: Updated.
* Mono.Addins.Setup/SetupTool.cs: Added initial support for generating
add-in documentation as XML.
2007-10-29 Lluis Sanchez Gual
* Mono.Addins.Setup.mdp: Update paths.
2007-10-18 Lluis Sanchez Gual
* AssemblyInfo.cs: Get ready for 0.3 release.
2007-09-10 Lluis Sanchez Gual
* Mono.Addins.Setup/RepositoryRegistry.cs: Make sure RegisterRepository
always returns a reference to the new repo.
2007-07-05 Lluis Sanchez Gual
* Mono.Addins.Setup.mdp: Minor fix.
2007-07-03 Lluis Sanchez Gual
* AssemblyInfo.cs, Mono.Addins.Setup.mdp, Makefile.am: Sign the
assembly.
* Mono.Addins.Setup/ConsoleAddinInstaller.cs: New IAddinInstaller
implementation.
2007-07-02 Lluis Sanchez Gual
* Mono.Addins.Setup.ProgressMonitoring/ConsoleProgressMonitor.cs,
Mono.Addins.Setup.ProgressMonitoring/ProgressStatusMonitor.cs,
Mono.Addins.Setup.ProgressMonitoring/NullProgressMonitor.cs,
Mono.Addins.Setup/IProgressMonitor.cs: Track api changes.
* Mono.Addins.Setup/SetupService.cs, Mono.Addins.Setup/AddinStore.cs:
Added new overload for ResolveDependencies.
* Mono.Addins.Setup/SetupTool.cs: Added new CheckInstall command. Fixed
some issues with add-in id comparison.
* Mono.Addins.Setup/AddinRepositoryEntry.cs,
Mono.Addins.Setup/RepositoryRegistry.cs: When looking for
installable add-ins, sort the result by version number. Some fix in
the code that compares ids.
2007-05-07 Lluis Sanchez Gual
* Mono.Addins.Setup/SetupService.cs: When creating a package,
generating a valid file name when the add-in doesn't have an ID.
Fixed the generated html page. Don't add the go-mono repository by
default.
* Mono.Addins.Setup/AddinInfo.cs: Generate a better default name when
not provided.
* Mono.Addins.Setup/RepositoryRegistry.cs: Added method for registering
a repository without updating it.
2007-05-04 Lluis Sanchez Gual
* Mono.Addins.mdp: Updated.
* Mono.Addins/ExtensionContext.cs: Fixed GetExtensionObjects overload
which was not using the correct reuseCachedInstance value.
* Mono.Addins/ExtensionTree.cs: Improved error message. When looking
for a type in an assembly, avoid throwing an exception too early,
since it may be found in other assemblies.
* Mono.Addins.Database/AddinDatabase.cs: In the addin info cache, also
store information about unsuccessful lookups, to avoid looking for
an add-in again if we found that it doesn't exist. In Update(),
don't use verbose output by default.
2007-04-04 Lluis Sanchez Gual
* Mono.Addins.Setup.ProgressMonitoring/NullProgressMonitor.cs: Fix
warning.
* Mono.Addins.Setup/SetupTool.cs, Makefile.am: Use ISO-1 compliant c#
only.
2007-04-04 Lluis Sanchez Gual
* Mono.Addins.Setup.csproj: Added msbuild project files. Patch by
Matthijs ter Woord.
* Mono.Addins.Setup/AddinPackage.cs, Mono.Addins.Setup/AddinStore.cs,
Mono.Addins.Setup/SetupTool.cs,
Mono.Addins.Setup/RepositoryRegistry.cs: Removed Mono.Posix
dependency. Patch by Matthijs ter Woord.
2007-03-30 Lluis Sanchez Gual
* Mono.Addins.Setup/SetupTool.cs: Cosmetic fixes.
* Mono.Addins.Setup/RepositoryRegistry.cs: Fix NRE (repoList may change
as a result of initializing the configuration).
2007-03-23 Lluis Sanchez Gual
* Mono.Addins.Setup.mdp, Makefile.am: Removed unused file.
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup.ProgressMonitoring/ 0000775 0001750 0001750 00000000000 12136524044 030076 5 ustar 00directhex directhex 0000000 0000000 mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup.ProgressMonitoring/ProgressTracker.cs 0000664 0001750 0001750 00000006457 12136523632 033563 0 ustar 00directhex directhex 0000000 0000000 //
// ProgressTracker.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
namespace Mono.Addins.Setup.ProgressMonitoring
{
internal class ProgressTracker
{
bool done;
ArrayList tasks = new ArrayList ();
class Task
{
public string Name;
public int TotalWork;
public int CurrentWork;
public int StepSize = 1;
public bool IsStep;
public double GetWorkPercent (double part)
{
if (TotalWork <= 0) return 0;
if (CurrentWork >= TotalWork) return 1.0;
return ((double)CurrentWork + part) / (double)TotalWork;
}
}
public void Reset ()
{
done = false;
tasks.Clear ();
}
public void BeginTask (string name, int totalWork)
{
Task t = new Task ();
t.Name = name;
t.TotalWork = totalWork;
tasks.Add (t);
}
public void BeginStepTask (string name, int totalWork, int stepSize)
{
Task t = new Task ();
t.StepSize = stepSize;
t.IsStep = true;
t.Name = name;
t.TotalWork = totalWork;
tasks.Add (t);
}
public void EndTask ()
{
if (tasks.Count > 0) {
Task t = LastTask;
tasks.RemoveAt (tasks.Count - 1);
if (t.IsStep)
Step (t.StepSize);
}
}
public void Step (int work)
{
if (tasks.Count == 0) return;
Task t = LastTask;
t.CurrentWork += work;
if (t.CurrentWork > t.TotalWork)
t.CurrentWork = t.TotalWork;
}
Task LastTask {
get { return (Task)tasks [tasks.Count-1]; }
}
public string CurrentTask {
get {
if (tasks.Count == 0) return null;
return LastTask.Name;
}
}
public double CurrentTaskWork {
get {
if (tasks.Count == 0) return 0;
return LastTask.GetWorkPercent (0);
}
}
public bool UnknownWork {
get {
if (tasks.Count == 0) return false;
return LastTask.TotalWork <= 1;
}
}
public double GlobalWork {
get {
if (done) return 1.0;
double work = 0;
for (int n = tasks.Count - 1; n >= 0; n--) {
Task t = (Task) tasks [n];
work = t.GetWorkPercent (work) * (double)t.StepSize;
}
return work;
}
}
public bool InProgress {
get { return !done; }
}
public void Done ()
{
done = true;
tasks.Clear ();
}
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup.ProgressMonitoring/ProgressStatusMonitor.cs 0000664 0001750 0001750 00000006035 12136523632 035013 0 ustar 00directhex directhex 0000000 0000000 //
// ProgressStatusMonitor.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.IO;
namespace Mono.Addins.Setup.ProgressMonitoring
{
internal class ProgressStatusMonitor: MarshalByRefObject, IProgressMonitor
{
IProgressStatus status;
LogTextWriter logger;
ProgressTracker tracker = new ProgressTracker ();
public ProgressStatusMonitor (IProgressStatus status)
{
this.status = status;
logger = new LogTextWriter ();
logger.TextWritten += new LogTextEventHandler (WriteLog);
}
public static IProgressMonitor GetProgressMonitor (IProgressStatus status)
{
if (status == null)
return new NullProgressMonitor ();
else
return new ProgressStatusMonitor (status);
}
public void BeginTask (string name, int totalWork)
{
tracker.BeginTask (name, totalWork);
status.SetMessage (tracker.CurrentTask);
status.SetProgress (tracker.GlobalWork);
}
public void BeginStepTask (string name, int totalWork, int stepSize)
{
tracker.BeginStepTask (name, totalWork, stepSize);
status.SetMessage (tracker.CurrentTask);
status.SetProgress (tracker.GlobalWork);
}
public void Step (int work)
{
tracker.Step (work);
status.SetProgress (tracker.GlobalWork);
}
public void EndTask ()
{
tracker.EndTask ();
status.SetMessage (tracker.CurrentTask);
status.SetProgress (tracker.GlobalWork);
}
void WriteLog (string text)
{
status.Log (text);
}
public TextWriter Log {
get { return logger; }
}
public void ReportWarning (string message)
{
status.ReportWarning (message);
}
public void ReportError (string message, Exception ex)
{
status.ReportError (message, ex);
}
public bool IsCancelRequested {
get { return status.IsCanceled; }
}
public void Cancel ()
{
status.Cancel ();
}
public int LogLevel {
get { return status.LogLevel; }
}
public void Dispose ()
{
}
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup.ProgressMonitoring/ConsoleProgressMonitor.cs 0000664 0001750 0001750 00000010644 12136523632 035133 0 ustar 00directhex directhex 0000000 0000000 //
// ConsoleProgressMonitor.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.IO;
namespace Mono.Addins.Setup.ProgressMonitoring
{
internal class ConsoleProgressMonitor: NullProgressMonitor
{
int columns = 80;
bool indent = true;
bool wrap = true;
int ilevel = 0;
int isize = 3;
int col = -1;
int logLevel;
LogTextWriter logger;
public ConsoleProgressMonitor (): this (1)
{
}
public ConsoleProgressMonitor (int logLevel)
{
this.logLevel = logLevel;
logger = new LogTextWriter ();
logger.TextWritten += new LogTextEventHandler (WriteLog);
}
public bool WrapText {
get { return wrap; }
set { wrap = value; }
}
public int WrapColumns {
get { return columns; }
set { columns = value; }
}
public bool IndentTasks {
get { return indent; }
set { indent = value; }
}
public override int LogLevel {
get { return logLevel; }
}
public override void BeginTask (string name, int totalWork)
{
WriteText (name);
Indent ();
}
public override void BeginStepTask (string name, int totalWork, int stepSize)
{
BeginTask (name, totalWork);
}
public override void EndTask ()
{
Unindent ();
}
void WriteLog (string text)
{
WriteText (text);
}
public override TextWriter Log {
get { return logger; }
}
public override void ReportSuccess (string message)
{
WriteText (message);
}
public override void ReportWarning (string message)
{
if (logLevel != 0)
WriteText ("WARNING: " + message + "\n");
}
public override void ReportError (string message, Exception ex)
{
if (logLevel == 0)
return;
if (message != null && ex != null) {
WriteText ("ERROR: " + message + "\n");
if (logLevel > 1)
WriteText (ex + "\n");
}
if (message != null)
WriteText ("ERROR: " + message + "\n");
else if (ex != null) {
if (logLevel > 1)
WriteText ("ERROR: " + ex + "\n");
else
WriteText ("ERROR: " + ex.Message + "\n");
}
}
void WriteText (string text)
{
if (indent)
WriteText (text, ilevel);
else
WriteText (text, 0);
}
void WriteText (string text, int leftMargin)
{
if (text == null || text.Length == 0)
return;
int n = 0;
int maxCols = wrap ? columns : int.MaxValue;
while (n < text.Length)
{
if (col == -1) {
Console.Write (new String (' ', leftMargin));
col = leftMargin;
}
int lastWhite = -1;
int sn = n;
bool eol = false;
while (col < maxCols && n < text.Length) {
char c = text [n];
if (c == '\r') {
n++;
continue;
}
if (c == '\n') {
eol = true;
break;
}
if (char.IsWhiteSpace (c))
lastWhite = n;
col++;
n++;
}
if (lastWhite == -1 || col < maxCols)
lastWhite = n;
else if (col >= maxCols)
n = lastWhite + 1;
Console.Write (text.Substring (sn, lastWhite - sn));
if (eol || col >= maxCols) {
col = -1;
Console.WriteLine ();
if (eol) n++;
}
}
}
void Indent ()
{
ilevel += isize;
if (col != -1) {
Console.WriteLine ();
col = -1;
}
}
void Unindent ()
{
ilevel -= isize;
if (ilevel < 0) ilevel = 0;
if (col != -1) {
Console.WriteLine ();
col = -1;
}
}
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup.ProgressMonitoring/NullProgressMonitor.cs 0000664 0001750 0001750 00000007210 12136523632 034436 0 ustar 00directhex directhex 0000000 0000000 //
// NullProgressMonitor.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
using System.Threading;
using System.IO;
namespace Mono.Addins.Setup.ProgressMonitoring
{
internal class NullProgressMonitor: MarshalByRefObject, IProgressMonitor
{
bool done, canceled;
ArrayList errors;
ArrayList warnings;
ArrayList messages;
public string[] Messages {
get {
if (messages != null)
return (string[]) messages.ToArray (typeof(string));
else
return new string [0];
}
}
public string[] Warnings {
get {
if (warnings != null)
return (string[]) warnings.ToArray (typeof(string));
else
return new string [0];
}
}
public ProgressError[] Errors {
get {
if (errors != null)
return (ProgressError[]) errors.ToArray (typeof(ProgressError));
else
return new ProgressError [0];
}
}
public virtual void BeginTask (string name, int totalWork)
{
}
public virtual void EndTask ()
{
}
public virtual void BeginStepTask (string name, int totalWork, int stepSize)
{
}
public virtual void Step (int work)
{
}
public virtual TextWriter Log {
get { return TextWriter.Null; }
}
public virtual void ReportSuccess (string message)
{
if (messages == null)
messages = new ArrayList ();
messages.Add (message);
}
public virtual void ReportWarning (string message)
{
if (warnings == null)
warnings = new ArrayList ();
messages.Add (message);
}
public virtual void ReportError (string message, Exception ex)
{
if (errors == null)
errors = new ArrayList ();
if (message == null && ex != null)
message = ex.Message;
else if (message != null && ex != null) {
if (!message.EndsWith (".")) message += ".";
message += " " + ex.Message;
}
errors.Add (new ProgressError (message, ex));
}
public bool IsCancelRequested {
get { return canceled; }
}
public void Cancel ()
{
canceled = true;
}
public virtual int LogLevel {
get { return 1; }
}
public virtual void Dispose ()
{
lock (this) {
if (done) return;
done = true;
}
OnCompleted ();
}
protected virtual void OnCompleted ()
{
}
}
internal class ProgressError
{
Exception ex;
string message;
public ProgressError (string message, Exception ex)
{
this.ex = ex;
this.message = message;
}
public string Message {
get { return message; }
}
public Exception Exception {
get { return ex; } }
}
}
mono-addins-1.0/Mono.Addins.Setup/Mono.Addins.Setup.ProgressMonitoring/LogTextWriter.cs 0000664 0001750 0001750 00000004723 12136523632 033220 0 ustar 00directhex directhex 0000000 0000000 //
// LogTextWriter.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.IO;
using System.Text;
using System.Collections;
namespace Mono.Addins.Setup.ProgressMonitoring
{
internal delegate void LogTextEventHandler (string writtenText);
internal class LogTextWriter: TextWriter
{
ArrayList chainedWriters;
public void ChainWriter (TextWriter writer)
{
if (chainedWriters == null) chainedWriters = new ArrayList ();
chainedWriters.Add (writer);
}
public void UnchainWriter (TextWriter writer)
{
if (chainedWriters != null) {
chainedWriters.Remove (writer);
if (chainedWriters.Count == 0)
chainedWriters = null;
}
}
public override Encoding Encoding {
get { return Encoding.Default; }
}
public override void Close ()
{
if (Closed != null)
Closed (this, null);
}
public override void Write (char value)
{
if (TextWritten != null)
TextWritten (value.ToString ());
if (chainedWriters != null)
foreach (TextWriter cw in chainedWriters)
cw.Write (value);
}
public override void Write (string value)
{
if (TextWritten != null)
TextWritten (value);
if (chainedWriters != null)
foreach (TextWriter cw in chainedWriters)
cw.Write (value);
}
public event LogTextEventHandler TextWritten;
public event EventHandler Closed;
}
}
mono-addins-1.0/Mono.Addins.Setup/policy.0.6.config 0000664 0001750 0001750 00000000554 12136524031 024005 0 ustar 00directhex directhex 0000000 0000000
mono-addins-1.0/Mono.Addins.Setup/policy.0.4.config 0000664 0001750 0001750 00000000554 12136524030 024002 0 ustar 00directhex directhex 0000000 0000000
mono-addins-1.0/Mono.Addins.Setup/policy.0.2.config 0000664 0001750 0001750 00000000554 12136524030 024000 0 ustar 00directhex directhex 0000000 0000000
mono-addins-1.0/Mono.Addins/ 0000775 0001750 0001750 00000000000 12136524043 017715 5 ustar 00directhex directhex 0000000 0000000 mono-addins-1.0/Mono.Addins/AssemblyInfo.cs 0000664 0001750 0001750 00000002003 12136523632 022635 0 ustar 00directhex directhex 0000000 0000000 using System.Reflection;
using System.Runtime.CompilerServices;
// Information about this assembly is defined by the following
// attributes.
//
// change them to the information which is associated with the assembly
// you compile.
[assembly: AssemblyTitle("Mono.Addins")]
[assembly: AssemblyCopyright("Copyright (C) 2007 Novell, Inc (http://www.novell.com)")]
// The assembly version has following format :
//
// Major.Minor.Build.Revision
//
// You can specify all values by your own or you can build default build and revision
// numbers with the '*' character (the default):
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: InternalsVisibleTo ("Mono.Addins.Setup, PublicKey=00240000048000009400000006020000002400005253413100" +
"0400000100010079159977d2d03a8e6bea7a2e74e8d1afcc93e8851974952bb480a12c9134474d04062447c37e0e68c080536fcf3c" +
"3fbe2ff9c979ce998475e506e8ce82dd5b0f350dc10e93bf2eeecf874b24770c5081dbea7447fddafa277b22de47d6ffea449674a4" +
"f9fccf84d15069089380284dbdd35f46cdff12a1bd78e4ef0065d016df")]
mono-addins-1.0/Mono.Addins/Makefile.am 0000664 0001750 0001750 00000000441 12136523632 021753 0 ustar 00directhex directhex 0000000 0000000
ASSEMBLY = ../bin/Mono.Addins.dll
ASSEMBLY_NAME=Mono.Addins
PC_FILES_IN = mono-addins.pc.in
install-data-local: gac-install
uninstall-local: gac-uninstall
include $(top_srcdir)/Makefile.include
include $(top_srcdir)/xbuild.include
CLEANFILES += $(POLICY_ASSEMBLIES) $(POLICY_CONFIGS)
mono-addins-1.0/Mono.Addins/Mono.Addins.csproj 0000664 0001750 0001750 00000022212 12136524015 023246 0 ustar 00directhex directhex 0000000 0000000
DebugAnyCPU8.0.50727{91DD5A2D-9FE3-4C3C-9253-876141874DAD}LibraryMono.Addins2.0Mono.AddinsTrue..\mono-addins.snkv4.0TruefullTrue..\binprompt4TrueFalseTrue1574noneTrue..\binprompt4TrueFalse mono-addins-1.0/Mono.Addins/Mono.Addins/ 0000775 0001750 0001750 00000000000 12136524043 022026 5 ustar 00directhex directhex 0000000 0000000 mono-addins-1.0/Mono.Addins/Mono.Addins/NodeAttributeAttribute.cs 0000664 0001750 0001750 00000017355 12136523632 027030 0 ustar 00directhex directhex 0000000 0000000 //
// NodeAttributeAttribute.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
namespace Mono.Addins
{
///
/// Indicates that a field or property is bound to a node attribute
///
[AttributeUsage (AttributeTargets.Class | AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple=true)]
public class NodeAttributeAttribute: Attribute
{
string name;
bool required;
bool localizable;
Type type;
string typeName;
string description;
///
/// Initializes a new instance
///
public NodeAttributeAttribute ()
{
}
///
/// Initializes a new instance
///
///
/// XML name of the attribute.
///
public NodeAttributeAttribute (string name)
:this (name, false, null)
{
}
///
/// Initializes a new instance
///
///
/// XML name of the attribute.
///
///
/// Description of the attribute.
///
public NodeAttributeAttribute (string name, string description)
:this (name, false, description)
{
}
///
/// Initializes a new instance
///
///
/// XML name of the attribute.
///
///
/// Indicates whether the attribute is required or not.
///
public NodeAttributeAttribute (string name, bool required)
: this (name, required, null)
{
}
///
/// Initializes a new instance
///
///
/// XML name of the attribute.
///
///
/// Indicates whether the attribute is required or not.
///
///
/// Description of the attribute.
///
public NodeAttributeAttribute (string name, bool required, string description)
{
this.name = name;
this.required = required;
this.description = description;
}
///
/// Initializes a new instance
///
///
/// XML name of the attribute.
///
///
/// Type of the extension node attribute.
///
///
/// The type of the attribute is only required when applying this attribute at class level.
/// It is not required when it is applied to a field, since the attribute type will be the type of the field.
///
public NodeAttributeAttribute (string name, Type type)
: this (name, type, false, null)
{
}
///
/// Initializes a new instance
///
///
/// XML name of the attribute.
///
///
/// Type of the extension node attribute.
///
///
/// Description of the attribute.
///
///
/// The type of the attribute is only required when applying this attribute at class level.
/// It is not required when it is applied to a field, since the attribute type will be the type of the field.
///
public NodeAttributeAttribute (string name, Type type, string description)
: this (name, type, false, description)
{
}
///
/// Initializes a new instance
///
///
/// XML name of the attribute.
///
///
/// Type of the extension node attribute.
///
///
/// Indicates whether the attribute is required or not.
///
///
/// The type of the attribute is only required when applying this attribute at class level.
/// It is not required when it is applied to a field, since the attribute type will be the type of the field.
///
public NodeAttributeAttribute (string name, Type type, bool required)
: this (name, type, false, null)
{
}
///
/// Initializes a new instance
///
///
/// XML name of the attribute.
///
///
/// Type of the extension node attribute.
///
///
/// Indicates whether the attribute is required or not.
///
///
/// Description of the attribute.
///
///
/// The type of the attribute is only required when applying this attribute at class level.
/// It is not required when it is applied to a field, since the attribute type will be the type of the field.
///
public NodeAttributeAttribute (string name, Type type, bool required, string description)
{
this.name = name;
this.type = type;
this.required = required;
this.description = description;
}
///
/// XML name of the attribute.
///
///
/// If the name is not specified, the field name to which the [NodeAttribute]
/// is applied will be used as name. Providing a name is mandatory when applying
/// [NodeAttribute] at class level.
///
public string Name {
get { return name != null ? name : string.Empty; }
set { name = value; }
}
///
/// Indicates whether the attribute is required or not.
///
public bool Required {
get { return required; }
set { required = value; }
}
///
/// Type of the extension node attribute.
///
///
/// To be used only when applying [NodeAttribute] at class level. It is not required when it
/// is applied to a field, since the attribute type will be the type of the field.
///
public Type Type {
get { return type; }
set { type = value; typeName = type.FullName; }
}
internal string TypeName {
get { return typeName; }
set { typeName = value; type = null; }
}
///
/// Description of the attribute.
///
///
/// To be used in the extension point documentation.
///
public string Description {
get { return description != null ? description : string.Empty; }
set { description = value; }
}
///
/// When set to True, the value of the field or property is expected to be a string id which
/// will be localized by the add-in engine
///
public bool Localizable {
get { return localizable; }
set { localizable = value; }
}
///
/// Gets or sets the type of the content.
///
///
/// Allows specifying the type of the content of a string attribute.
/// This value is for documentation purposes only.
///
public ContentType ContentType { get; set; }
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/AddinDescriptionAttribute.cs 0000664 0001750 0001750 00000004672 12136523632 027500 0 ustar 00directhex directhex 0000000 0000000 //
// AddinDescriptionAttribute.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (c) 2011 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
using System;
namespace Mono.Addins
{
///
/// Describes the purpose of an add-in or add-in root
///
[AttributeUsage (AttributeTargets.Assembly, AllowMultiple = true)]
public class AddinDescriptionAttribute: Attribute
{
///
/// Initializes a new instance of the class.
///
///
/// Description of the add-in
///
public AddinDescriptionAttribute (string description)
{
Description = description;
}
///
/// Initializes a new instance of the class.
///
///
/// Description of the add-in
///
///
/// Locale of the description (for example, 'en-US', or 'en')
///
public AddinDescriptionAttribute (string description, string locale)
{
Description = description;
Locale = locale;
}
///
/// Description of the add-in
///
public string Description { get; set; }
///
/// Locale of the description (for example, 'en-US', or 'en')
///
public string Locale { get; set; }
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/MissingDependencyException.cs 0000664 0001750 0001750 00000003215 12136523632 027650 0 ustar 00directhex directhex 0000000 0000000 //
// MissingDependencyException.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Runtime.Serialization;
namespace Mono.Addins
{
///
/// Exception thrown when the add-in engine can't find a required add-in dependency
///
[Serializable]
internal class MissingDependencyException: Exception
{
public MissingDependencyException (SerializationInfo inf, StreamingContext ctx) : base (inf, ctx)
{
}
public MissingDependencyException (string message): base (message)
{
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/NodeElement.cs 0000664 0001750 0001750 00000005470 12136523632 024565 0 ustar 00directhex directhex 0000000 0000000 //
// NodeElement.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
namespace Mono.Addins
{
///
/// An extension node element.
///
///
/// A raw representation of an extension node. Contains the basic information
/// needed to create ExtensionNode instances.
///
public interface NodeElement
{
///
/// Name of the node element.
///
string NodeName { get; }
///
/// Gets element attributes.
///
///
/// Name of the attribute
///
///
/// The value of the attribute
///
string GetAttribute (string key);
///
/// Gets all attributes defined in the element.
///
NodeAttribute[] Attributes { get; }
///
/// Gets child nodes of this node
///
NodeElementCollection ChildNodes { get; }
}
///
/// Attribute of a NodeElement.
///
public class NodeAttribute
{
internal string name;
internal string value;
internal NodeAttribute ()
{
}
///
/// Name of the attribute.
///
public string Name {
get { return name; }
}
///
/// Value of the attribute.
///
public string Value {
get { return value; }
}
}
///
/// A collection of NodeElement objects
///
public interface NodeElementCollection: IList, ICollection, IEnumerable
{
///
/// Gets the at the specified index
///
///
/// Index
///
new NodeElement this [int n] { get; }
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/AddinDependencyAttribute.cs 0000664 0001750 0001750 00000004014 12136523632 027261 0 ustar 00directhex directhex 0000000 0000000 //
// AddinDependencyAttribute.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
namespace Mono.Addins
{
///
/// Declares a dependency on an add-in or add-in host
///
[AttributeUsage (AttributeTargets.Assembly, AllowMultiple=true)]
public class AddinDependencyAttribute: Attribute
{
string id;
string version;
///
/// Initializes the attribute
///
///
/// Identifier of the add-in
///
///
/// Version of the add-in
///
public AddinDependencyAttribute (string id, string version)
{
this.id = id;
this.version = version;
}
///
/// Identifier of the add-in
///
public string Id {
get { return id; }
}
///
/// Version of the add-in
///
public string Version {
get { return version; }
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/AddinManager.cs 0000664 0001750 0001750 00000066644 12136523632 024712 0 ustar 00directhex directhex 0000000 0000000 //
// AddinManager.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.IO;
using System.Reflection;
using System.Collections;
using System.Collections.Generic;
using Mono.Addins.Localization;
namespace Mono.Addins
{
///
/// Provides access to add-in and extension model management operations.
///
public class AddinManager
{
static AddinEngine sessionService;
private AddinManager ()
{
}
///
/// Initializes the add-in engine.
///
///
/// The add-in engine needs to be initialized before doing any add-in operation.
/// When initialized with this method, it will look for add-ins in the global add-in registry.
///
public static void Initialize ()
{
// Code not shared with the other Initialize since I need to get the calling assembly
Assembly asm = Assembly.GetEntryAssembly ();
if (asm == null) asm = Assembly.GetCallingAssembly ();
AddinEngine.Initialize (asm, null, null, null);
}
///
/// Initializes the add-in engine.
///
///
/// Location of the add-in registry.
///
///
/// The add-in engine needs to be initialized before doing any add-in operation.
/// Configuration information about the add-in registry will be stored in the
/// provided location. The add-in engine will look for add-ins in an 'addins'
/// subdirectory of the provided directory.
///
/// When specifying a path, it is possible to use a special folder name as root.
/// For example: [Personal]/.config/MyApp. In this case, [Personal] will be replaced
/// by the location of the Environment.SpecialFolder.Personal folder. Any value
/// of the Environment.SpecialFolder enumeration can be used (always between square
/// brackets)
///
public static void Initialize (string configDir)
{
Assembly asm = Assembly.GetEntryAssembly ();
if (asm == null) asm = Assembly.GetCallingAssembly ();
AddinEngine.Initialize (asm, configDir, null, null);
}
///
/// Initializes the add-in engine.
///
///
/// Location of the add-in registry.
///
///
/// Add-ins directory. If the path is relative, it is considered to be relative
/// to the configDir directory.
///
///
/// The add-in engine needs to be initialized before doing any add-in operation.
/// Configuration information about the add-in registry will be stored in the
/// provided location. The add-in engine will look for add-ins in the provided
/// 'addinsDir' directory.
///
/// When specifying a path, it is possible to use a special folder name as root.
/// For example: [Personal]/.config/MyApp. In this case, [Personal] will be replaced
/// by the location of the Environment.SpecialFolder.Personal folder. Any value
/// of the Environment.SpecialFolder enumeration can be used (always between square
/// brackets)
///
public static void Initialize (string configDir, string addinsDir)
{
Assembly asm = Assembly.GetEntryAssembly ();
if (asm == null) asm = Assembly.GetCallingAssembly ();
AddinEngine.Initialize (asm, configDir, addinsDir, null);
}
///
/// Initializes the add-in engine.
///
///
/// Location of the add-in registry.
///
///
/// Add-ins directory. If the path is relative, it is considered to be relative
/// to the configDir directory.
///
///
/// Location of the add-in database. If the path is relative, it is considered to be relative
/// to the configDir directory.
///
///
/// The add-in engine needs to be initialized before doing any add-in operation.
/// Configuration information about the add-in registry will be stored in the
/// provided location. The add-in engine will look for add-ins in the provided
/// 'addinsDir' directory. Cached information about add-ins will be stored in
/// the 'databaseDir' directory.
///
/// When specifying a path, it is possible to use a special folder name as root.
/// For example: [Personal]/.config/MyApp. In this case, [Personal] will be replaced
/// by the location of the Environment.SpecialFolder.Personal folder. Any value
/// of the Environment.SpecialFolder enumeration can be used (always between square
/// brackets)
///
public static void Initialize (string configDir, string addinsDir, string databaseDir)
{
Assembly asm = Assembly.GetEntryAssembly ();
if (asm == null) asm = Assembly.GetCallingAssembly ();
AddinEngine.Initialize (asm, configDir, addinsDir, databaseDir);
}
///
/// Finalizes an add-in engine.
///
public static void Shutdown ()
{
AddinEngine.Shutdown ();
}
///
/// Sets the default localizer to be used for this add-in engine
///
///
/// The add-in localizer
///
public static void InitializeDefaultLocalizer (IAddinLocalizer localizer)
{
AddinEngine.InitializeDefaultLocalizer (localizer);
}
internal static string StartupDirectory {
get { return AddinEngine.StartupDirectory; }
}
///
/// Gets whether the add-in engine has been initialized.
///
public static bool IsInitialized {
get { return AddinEngine.IsInitialized; }
}
///
/// Gets the default add-in installer
///
///
/// The default installer is used by the CheckInstalled method to request
/// the installation of missing add-ins.
///
public static IAddinInstaller DefaultInstaller {
get { return AddinEngine.DefaultInstaller; }
set { AddinEngine.DefaultInstaller = value; }
}
///
/// Gets the default localizer for this add-in engine
///
public static AddinLocalizer DefaultLocalizer {
get {
return AddinEngine.DefaultLocalizer;
}
}
///
/// Gets the localizer for the add-in that is invoking this property
///
public static AddinLocalizer CurrentLocalizer {
get {
AddinEngine.CheckInitialized ();
RuntimeAddin addin = AddinEngine.GetAddinForAssembly (Assembly.GetCallingAssembly ());
if (addin != null)
return addin.Localizer;
else
return AddinEngine.DefaultLocalizer;
}
}
///
/// Gets a reference to the RuntimeAddin object for the add-in that is invoking this property
///
public static RuntimeAddin CurrentAddin {
get {
AddinEngine.CheckInitialized ();
return AddinEngine.GetAddinForAssembly (Assembly.GetCallingAssembly ());
}
}
///
/// Gets the default add-in engine
///
public static AddinEngine AddinEngine {
get {
if (sessionService == null)
sessionService = new AddinEngine();
return sessionService;
}
}
///
/// Gets the add-in registry bound to the default add-in engine
///
public static AddinRegistry Registry {
get {
return AddinEngine.Registry;
}
}
///
/// Checks if the provided add-ins are installed, and requests the installation of those
/// which aren't.
///
///
/// Message to show to the user when new add-ins have to be installed.
///
///
/// List of IDs of the add-ins to be checked.
///
///
/// This method checks if the specified add-ins are installed.
/// If some of the add-ins are not installed, it will use
/// the installer assigned to the DefaultAddinInstaller property
/// to install them. If the installation fails, or if DefaultAddinInstaller
/// is not set, an exception will be thrown.
///
public static void CheckInstalled (string message, params string[] addinIds)
{
AddinEngine.CheckInstalled (message, addinIds);
}
///
/// Checks if an add-in has been loaded.
///
///
/// Full identifier of the add-in.
///
///
/// True if the add-in is loaded.
///
public static bool IsAddinLoaded (string id)
{
return AddinEngine.IsAddinLoaded (id);
}
///
/// Forces the loading of an add-in.
///
///
/// Status monitor to keep track of the loading process.
///
///
/// Full identifier of the add-in to load.
///
///
/// This method loads all assemblies that belong to an add-in in memory.
/// All add-ins on which the specified add-in depends will also be loaded.
/// Notice that in general add-ins don't need to be explicitely loaded using
/// this method, since the add-in engine will load them on demand.
///
public static void LoadAddin (IProgressStatus statusMonitor, string id)
{
AddinEngine.LoadAddin (statusMonitor, id);
}
///
/// Creates a new extension context.
///
///
/// The new extension context.
///
///
/// Extension contexts can be used to query the extension model using particular condition values.
///
public static ExtensionContext CreateExtensionContext ()
{
return AddinEngine.CreateExtensionContext ();
}
///
/// Returns the extension node in a path
///
///
/// Location of the node.
///
///
/// The node, or null if not found.
///
public static ExtensionNode GetExtensionNode (string path)
{
AddinEngine.CheckInitialized ();
return AddinEngine.GetExtensionNode (path);
}
///
/// Returns the extension node in a path
///
///
/// Location of the node.
///
///
/// The node, or null if not found.
///
public static T GetExtensionNode (string path) where T:ExtensionNode
{
AddinEngine.CheckInitialized ();
return AddinEngine.GetExtensionNode (path);
}
///
/// Gets extension nodes registered in a path.
///
///
/// An extension path.>
///
///
/// All nodes registered in the provided path.
///
public static ExtensionNodeList GetExtensionNodes (string path)
{
AddinEngine.CheckInitialized ();
return AddinEngine.GetExtensionNodes (path);
}
///
/// Gets extension nodes registered in a path.
///
///
/// An extension path.
///
///
/// Expected node type.
///
///
/// A list of nodes
///
///
/// This method returns all nodes registered under the provided path.
/// It will throw a InvalidOperationException if the type of one of
/// the registered nodes is not assignable to the provided type.
///
public static ExtensionNodeList GetExtensionNodes (string path, Type expectedNodeType)
{
AddinEngine.CheckInitialized ();
return AddinEngine.GetExtensionNodes (path, expectedNodeType);
}
///
/// Gets extension nodes registered in a path.
///
///
/// An extension path.
///
///
/// A list of nodes
///
///
/// This method returns all nodes registered under the provided path.
/// It will throw a InvalidOperationException if the type of one of
/// the registered nodes is not assignable to the provided type.
///
public static ExtensionNodeList GetExtensionNodes (string path) where T:ExtensionNode
{
AddinEngine.CheckInitialized ();
return AddinEngine.GetExtensionNodes (path);
}
///
/// Gets extension nodes for a type extension point
///
///
/// Type defining the extension point
///
///
/// A list of nodes
///
///
/// This method returns all extension nodes bound to the provided type.
///
public static ExtensionNodeList GetExtensionNodes (Type instanceType)
{
AddinEngine.CheckInitialized ();
return AddinEngine.GetExtensionNodes (instanceType);
}
///
/// Gets extension nodes for a type extension point
///
///
/// Type defining the extension point
///
///
/// Expected extension node type
///
///
/// A list of nodes
///
///
/// This method returns all nodes registered for the provided type.
/// It will throw a InvalidOperationException if the type of one of
/// the registered nodes is not assignable to the provided node type.
///
public static ExtensionNodeList GetExtensionNodes (Type instanceType, Type expectedNodeType)
{
AddinEngine.CheckInitialized ();
return AddinEngine.GetExtensionNodes (instanceType, expectedNodeType);
}
///
/// Gets extension nodes for a type extension point
///
///
/// Type defining the extension point
///
///
/// A list of nodes
///
///
/// This method returns all nodes registered for the provided type.
/// It will throw a InvalidOperationException if the type of one of
/// the registered nodes is not assignable to the specified node type argument.
///
public static ExtensionNodeList GetExtensionNodes (Type instanceType) where T: ExtensionNode
{
AddinEngine.CheckInitialized ();
return AddinEngine.GetExtensionNodes (instanceType);
}
///
/// Gets extension objects registered for a type extension point.
///
///
/// Type defining the extension point
///
///
/// A list of objects
///
public static object[] GetExtensionObjects (Type instanceType)
{
AddinEngine.CheckInitialized ();
return AddinEngine.GetExtensionObjects (instanceType);
}
///
/// Gets extension objects registered for a type extension point.
///
///
/// A list of objects
///
///
/// The type argument of this generic method is the type that defines
/// the extension point.
///
public static T[] GetExtensionObjects ()
{
AddinEngine.CheckInitialized ();
return AddinEngine.GetExtensionObjects ();
}
///
/// Gets extension objects registered for a type extension point.
///
///
/// Type defining the extension point
///
///
/// When set to True, it will return instances created in previous calls.
///
///
/// A list of extension objects.
///
public static object[] GetExtensionObjects (Type instanceType, bool reuseCachedInstance)
{
AddinEngine.CheckInitialized ();
return AddinEngine.GetExtensionObjects (instanceType, reuseCachedInstance);
}
///
/// Gets extension objects registered for a type extension point.
///
///
/// When set to True, it will return instances created in previous calls.
///
///
/// A list of extension objects.
///
///
/// The type argument of this generic method is the type that defines
/// the extension point.
///
public static T[] GetExtensionObjects (bool reuseCachedInstance)
{
AddinEngine.CheckInitialized ();
return AddinEngine.GetExtensionObjects (reuseCachedInstance);
}
///
/// Gets extension objects registered in a path
///
///
/// An extension path.
///
///
/// An array of objects registered in the path.
///
///
/// This method can only be used if all nodes in the provided extension path
/// are of type Mono.Addins.TypeExtensionNode. The returned array is composed
/// by all objects created by calling the TypeExtensionNode.CreateInstance()
/// method for each node.
///
public static object[] GetExtensionObjects (string path)
{
AddinEngine.CheckInitialized ();
return AddinEngine.GetExtensionObjects (path);
}
///
/// Gets extension objects registered in a path.
///
///
/// An extension path.
///
///
/// When set to True, it will return instances created in previous calls.
///
///
/// An array of objects registered in the path.
///
///
/// This method can only be used if all nodes in the provided extension path
/// are of type Mono.Addins.TypeExtensionNode. The returned array is composed
/// by all objects created by calling the TypeExtensionNode.CreateInstance()
/// method for each node (or TypeExtensionNode.GetInstance() if
/// reuseCachedInstance is set to true)
///
public static object[] GetExtensionObjects (string path, bool reuseCachedInstance)
{
AddinEngine.CheckInitialized ();
return AddinEngine.GetExtensionObjects (path, reuseCachedInstance);
}
///
/// Gets extension objects registered in a path.
///
///
/// An extension path.
///
///
/// Type of the return array elements.
///
///
/// An array of objects registered in the path.
///
///
/// This method can only be used if all nodes in the provided extension path
/// are of type Mono.Addins.TypeExtensionNode. The returned array is composed
/// by all objects created by calling the TypeExtensionNode.CreateInstance()
/// method for each node.
///
/// An InvalidOperationException exception is thrown if one of the found
/// objects is not a subclass of the provided type.
///
public static object[] GetExtensionObjects (string path, Type arrayElementType)
{
AddinEngine.CheckInitialized ();
return AddinEngine.GetExtensionObjects (path, arrayElementType);
}
///
/// Gets extension objects registered in a path.
///
///
/// An extension path.
///
///
/// An array of objects registered in the path.
///
///
/// This method can only be used if all nodes in the provided extension path
/// are of type Mono.Addins.TypeExtensionNode. The returned array is composed
/// by all objects created by calling the TypeExtensionNode.CreateInstance()
/// method for each node.
///
/// An InvalidOperationException exception is thrown if one of the found
/// objects is not a subclass of the provided type.
///
public static T[] GetExtensionObjects (string path)
{
AddinEngine.CheckInitialized ();
return AddinEngine.GetExtensionObjects (path);
}
///
/// Gets extension objects registered in a path.
///
///
/// An extension path.
///
///
/// Type of the return array elements.
///
///
/// When set to True, it will return instances created in previous calls.
///
///
/// An array of objects registered in the path.
///
///
/// This method can only be used if all nodes in the provided extension path
/// are of type Mono.Addins.TypeExtensionNode. The returned array is composed
/// by all objects created by calling the TypeExtensionNode.CreateInstance()
/// method for each node (or TypeExtensionNode.GetInstance() if
/// reuseCachedInstance is set to true).
///
/// An InvalidOperationException exception is thrown if one of the found
/// objects is not a subclass of the provided type.
///
public static object[] GetExtensionObjects (string path, Type arrayElementType, bool reuseCachedInstance)
{
AddinEngine.CheckInitialized ();
return AddinEngine.GetExtensionObjects (path, arrayElementType, reuseCachedInstance);
}
///
/// Gets extension objects registered in a path.
///
///
/// An extension path.
///
///
/// When set to True, it will return instances created in previous calls.
///
///
/// An array of objects registered in the path.
///
///
/// This method can only be used if all nodes in the provided extension path
/// are of type Mono.Addins.TypeExtensionNode. The returned array is composed
/// by all objects created by calling the TypeExtensionNode.CreateInstance()
/// method for each node (or TypeExtensionNode.GetInstance() if
/// reuseCachedInstance is set to true).
///
/// An InvalidOperationException exception is thrown if one of the found
/// objects is not a subclass of the provided type.
///
public static T[] GetExtensionObjects (string path, bool reuseCachedInstance)
{
AddinEngine.CheckInitialized ();
return AddinEngine.GetExtensionObjects (path, reuseCachedInstance);
}
///
/// Extension change event.
///
///
/// This event is fired when any extension point in the add-in system changes.
/// The event args object provides the path of the changed extension, although
/// it does not provide information about what changed. Hosts subscribing to
/// this event should get the new list of nodes using a query method such as
/// AddinManager.GetExtensionNodes() and then update whatever needs to be updated.
///
public static event ExtensionEventHandler ExtensionChanged {
add { AddinEngine.CheckInitialized(); AddinEngine.ExtensionChanged += value; }
remove { AddinEngine.CheckInitialized(); AddinEngine.ExtensionChanged -= value; }
}
///
/// Register a listener of extension node changes.
///
///
/// Path of the node.
///
///
/// A handler method.
///
///
/// Hosts can call this method to be subscribed to an extension change
/// event for a specific path. The event will be fired once for every
/// individual node change. The event arguments include the change type
/// (Add or Remove) and the extension node added or removed.
///
/// NOTE: The handler will be called for all nodes existing in the path at the moment of registration.
///
public static void AddExtensionNodeHandler (string path, ExtensionNodeEventHandler handler)
{
AddinEngine.CheckInitialized ();
AddinEngine.AddExtensionNodeHandler (path, handler);
}
///
/// Unregister a listener of extension node changes.
///
///
/// Path of the node.
///
///
/// A handler method.
///
///
/// This method unregisters a delegate from the node change event of a path.
///
public static void RemoveExtensionNodeHandler (string path, ExtensionNodeEventHandler handler)
{
AddinEngine.CheckInitialized ();
AddinEngine.RemoveExtensionNodeHandler (path, handler);
}
///
/// Register a listener of extension node changes.
///
///
/// Type defining the extension point
///
///
/// A handler method.
///
///
/// Hosts can call this method to be subscribed to an extension change
/// event for a specific type extension point. The event will be fired once for every
/// individual node change. The event arguments include the change type
/// (Add or Remove) and the extension node added or removed.
///
/// NOTE: The handler will be called for all nodes existing in the path at the moment of registration.
///
public static void AddExtensionNodeHandler (Type instanceType, ExtensionNodeEventHandler handler)
{
AddinEngine.CheckInitialized ();
AddinEngine.AddExtensionNodeHandler (instanceType, handler);
}
///
/// Unregister a listener of extension node changes.
///
///
/// Type defining the extension point
///
///
/// A handler method.
///
public static void RemoveExtensionNodeHandler (Type instanceType, ExtensionNodeEventHandler handler)
{
AddinEngine.CheckInitialized ();
AddinEngine.RemoveExtensionNodeHandler (instanceType, handler);
}
///
/// Add-in loading error event.
///
///
/// This event is fired when there is an error when loading the extension
/// of an add-in, or any other kind of error that may happen when querying extension points.
///
public static event AddinErrorEventHandler AddinLoadError {
add { AddinEngine.AddinLoadError += value; }
remove { AddinEngine.AddinLoadError -= value; }
}
///
/// Add-in loaded event.
///
///
/// Fired after loading an add-in in memory.
///
public static event AddinEventHandler AddinLoaded {
add { AddinEngine.AddinLoaded += value; }
remove { AddinEngine.AddinLoaded -= value; }
}
///
/// Add-in unload event.
///
///
/// Fired when an add-in is unloaded from memory. It may happen an add-in is disabled or uninstalled.
///
public static event AddinEventHandler AddinUnloaded {
add { AddinEngine.AddinUnloaded += value; }
remove { AddinEngine.AddinUnloaded -= value; }
}
internal static bool CheckAssembliesLoaded (HashSet files)
{
foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies ()) {
if (asm is System.Reflection.Emit.AssemblyBuilder)
continue;
try {
Uri u;
if (!Uri.TryCreate (asm.CodeBase, UriKind.Absolute, out u))
continue;
string asmFile = u.LocalPath;
if (files.Contains (Path.GetFullPath (asmFile)))
return true;
} catch {
// Ignore
}
}
return false;
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/TypeExtensionPointAttribute.cs 0000664 0001750 0001750 00000007243 12136523632 030102 0 ustar 00directhex directhex 0000000 0000000 //
// TypeExtensionPointAttribute.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
namespace Mono.Addins
{
///
/// Declares an extension point bound to a type
///
[AttributeUsage (AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple=true)]
public class TypeExtensionPointAttribute: Attribute
{
string path;
string nodeName;
Type nodeType;
string nodeTypeName;
string desc;
string name;
Type customAttributeType;
string customAttributeTypeName;
///
/// Initializes a new instance
///
public TypeExtensionPointAttribute ()
{
}
///
/// Initializes a new instance
///
///
/// Path that identifies the extension point
///
public TypeExtensionPointAttribute (string path)
{
this.path = path;
}
///
/// Path that identifies the extension point
///
public string Path {
get { return path != null ? path : string.Empty; }
set { path = value; }
}
///
/// Description of the extension point.
///
public string Description {
get { return desc != null ? desc : string.Empty; }
set { desc = value; }
}
///
/// Element name to be used when defining an extension in an XML manifest. The default name is "Type".
///
public string NodeName {
get { return nodeName != null && nodeName.Length > 0 ? nodeName : "Type"; }
set { nodeName = value; }
}
///
/// Display name of the extension point.
///
public string Name {
get { return name != null ? name : string.Empty; }
set { name = value; }
}
///
/// Type of the extension node to be created for extensions
///
public Type NodeType {
get { return nodeType != null ? nodeType : typeof(TypeExtensionNode); }
set { nodeType = value; nodeTypeName = value.FullName; }
}
internal string NodeTypeName {
get { return nodeTypeName != null ? nodeTypeName : typeof(TypeExtensionNode).FullName; }
set { nodeTypeName = value; nodeType = null; }
}
///
/// Type of the custom attribute to be used to specify metadata for the extension point
///
public Type ExtensionAttributeType {
get { return this.customAttributeType; }
set { this.customAttributeType = value; customAttributeTypeName = value.FullName; }
}
internal string ExtensionAttributeTypeName {
get { return this.customAttributeTypeName; }
set { this.customAttributeTypeName = value; }
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/AddinRootAttribute.cs 0000664 0001750 0001750 00000004144 12136523632 026132 0 ustar 00directhex directhex 0000000 0000000 //
// AddinRootAttribute.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
namespace Mono.Addins
{
///
/// Marks an assembly as being an add-in root.
///
///
/// An add-in root is an assemly which can be extended by add-ins.
///
[AttributeUsage (AttributeTargets.Assembly)]
public class AddinRootAttribute: AddinAttribute
{
///
/// Initializes a new instance
///
public AddinRootAttribute ()
{
}
///
/// Initializes a new instance
///
///
/// Identifier of the add-in root
///
public AddinRootAttribute (string id): base (id)
{
}
///
/// Initializes a new instance
///
///
/// Identifier of the add-in root
///
///
/// Version of the add-in root
///
public AddinRootAttribute (string id, string version): base (id, version)
{
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/RuntimeAddin.cs 0000664 0001750 0001750 00000046131 12136524015 024744 0 ustar 00directhex directhex 0000000 0000000 //
// RuntimeAddin.cs
//
// Author:
// Lluis Sanchez Gual,
// Georg Wächter
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Xml;
using System.Resources;
using System.Globalization;
using Mono.Addins.Description;
using Mono.Addins.Localization;
namespace Mono.Addins
{
///
/// Run-time representation of an add-in.
///
public class RuntimeAddin
{
string id;
string baseDirectory;
string privatePath;
Addin ainfo;
RuntimeAddin parentAddin;
Assembly[] assemblies;
RuntimeAddin[] depAddins;
ResourceManager[] resourceManagers;
AddinLocalizer localizer;
ModuleDescription module;
AddinEngine addinEngine;
internal RuntimeAddin (AddinEngine addinEngine)
{
this.addinEngine = addinEngine;
}
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;
}
internal ModuleDescription Module {
get { return module; }
}
internal Assembly[] Assemblies {
get {
EnsureAssembliesLoaded ();
return assemblies;
}
}
///
/// Identifier of the add-in.
///
public string Id {
get { return Addin.GetIdName (id); }
}
///
/// Version of the add-in.
///
public string Version {
get { return Addin.GetIdVersion (id); }
}
internal Addin Addin {
get { return ainfo; }
}
///
/// Returns a string that represents the current RuntimeAddin.
///
///
/// A string that represents the current RuntimeAddin.
///
public override string ToString ()
{
return ainfo.ToString ();
}
ResourceManager[] GetResourceManagers ()
{
if (resourceManagers != null)
return resourceManagers;
EnsureAssembliesLoaded ();
ArrayList managersList = new ArrayList ();
// Search for embedded resource files
foreach (Assembly asm in assemblies)
{
foreach (string res in asm.GetManifestResourceNames ()) {
if (res.EndsWith (".resources"))
managersList.Add (new ResourceManager (res.Substring (0, res.Length - ".resources".Length), asm));
}
}
return resourceManagers = (ResourceManager[]) managersList.ToArray (typeof(ResourceManager));
}
///
/// Gets a resource string
///
///
/// Name of the resource
///
///
/// The value of the resource string, or null if the resource can't be found.
///
///
/// The add-in engine will look for resources in the main add-in assembly and in all included add-in assemblies.
///
public string GetResourceString (string name)
{
return (string) GetResourceObject (name, true, null);
}
///
/// Gets a resource string
///
///
/// Name of the resource
///
///
/// When set to true, an exception will be thrown if the resource is not found.
///
///
/// The value of the resource string
///
///
/// The add-in engine will look for resources in the main add-in assembly and in all included add-in assemblies.
///
public string GetResourceString (string name, bool throwIfNotFound)
{
return (string) GetResourceObject (name, throwIfNotFound, null);
}
///
/// Gets a resource string
///
///
/// Name of the resource
///
///
/// When set to true, an exception will be thrown if the resource is not found.
///
///
/// Culture of the resource
///
///
/// The value of the resource string
///
///
/// The add-in engine will look for resources in the main add-in assembly and in all included add-in assemblies.
///
public string GetResourceString (string name, bool throwIfNotFound, CultureInfo culture)
{
return (string) GetResourceObject (name, throwIfNotFound, culture);
}
///
/// Gets a resource object
///
///
/// Name of the resource
///
///
/// Value of the resource
///
///
/// The add-in engine will look for resources in the main add-in assembly and in all included add-in assemblies.
///
public object GetResourceObject (string name)
{
return GetResourceObject (name, true, null);
}
///
/// Gets a resource object
///
///
/// Name of the resource
///
///
/// When set to true, an exception will be thrown if the resource is not found.
///
///
/// Value of the resource
///
///
/// The add-in engine will look for resources in the main add-in assembly and in all included add-in assemblies.
///
public object GetResourceObject (string name, bool throwIfNotFound)
{
return GetResourceObject (name, throwIfNotFound, null);
}
///
/// Gets a resource object
///
///
/// Name of the resource
///
///
/// When set to true, an exception will be thrown if the resource is not found.
///
///
/// Culture of the resource
///
///
/// Value of the resource
///
///
/// The add-in engine will look for resources in the main add-in assembly and in all included add-in assemblies.
///
public object GetResourceObject (string name, bool throwIfNotFound, CultureInfo culture)
{
// Look in resources of this add-in
foreach (ResourceManager manager in GetAllResourceManagers ()) {
object t = manager.GetObject (name, culture);
if (t != null)
return t;
}
// Look in resources of dependent add-ins
foreach (RuntimeAddin addin in GetAllDependencies ()) {
object t = addin.GetResourceObject (name, false, culture);
if (t != null)
return t;
}
if (throwIfNotFound)
throw new InvalidOperationException ("Resource object '" + name + "' not found in add-in '" + id + "'");
return null;
}
///
/// Gets a type defined in the add-in
///
///
/// Full name of the type
///
///
/// A type.
///
///
/// The type will be looked up in the assemblies that implement the add-in,
/// and recursivelly in all add-ins on which it depends.
///
/// This method throws an InvalidOperationException if the type can't be found.
///
public Type GetType (string typeName)
{
return GetType (typeName, true);
}
///
/// Gets a type defined in the add-in
///
///
/// Full name of the type
///
///
/// Indicates whether the method should throw an exception if the type can't be found.
///
///
/// A
///
///
/// The type will be looked up in the assemblies that implement the add-in,
/// and recursivelly in all add-ins on which it depends.
///
/// If the type can't be found, this method throw a InvalidOperationException if
/// 'throwIfNotFound' is 'true', or 'null' otherwise.
///
public Type GetType (string typeName, bool throwIfNotFound)
{
EnsureAssembliesLoaded ();
// Look in the addin assemblies
Type at = Type.GetType (typeName, false);
if (at != null)
return at;
foreach (Assembly asm in GetAllAssemblies ()) {
Type t = asm.GetType (typeName, false);
if (t != null)
return t;
}
// Look in the dependent add-ins
foreach (RuntimeAddin addin in GetAllDependencies ()) {
Type t = addin.GetType (typeName, false);
if (t != null)
return t;
}
if (throwIfNotFound)
throw new InvalidOperationException ("Type '" + typeName + "' not found in add-in '" + id + "'");
return null;
}
IEnumerable GetAllResourceManagers ()
{
foreach (ResourceManager rm in GetResourceManagers ())
yield return rm;
if (parentAddin != null) {
foreach (ResourceManager rm in parentAddin.GetResourceManagers ())
yield return rm;
}
}
IEnumerable GetAllAssemblies ()
{
foreach (Assembly asm in Assemblies)
yield return asm;
// Look in the parent addin assemblies
if (parentAddin != null) {
foreach (Assembly asm in parentAddin.Assemblies)
yield return asm;
}
}
IEnumerable GetAllDependencies ()
{
// Look in the dependent add-ins
foreach (RuntimeAddin addin in GetDepAddins ())
yield return addin;
if (parentAddin != null) {
// Look in the parent dependent add-ins
foreach (RuntimeAddin addin in parentAddin.GetDepAddins ())
yield return addin;
}
}
///
/// Creates an instance of a type defined in the add-in
///
///
/// Name of the type.
///
///
/// A new instance of the type
///
///
/// The type will be looked up in the assemblies that implement the add-in,
/// and recursivelly in all add-ins on which it depends.
///
/// This method throws an InvalidOperationException if the type can't be found.
///
/// The specified type must have a default constructor.
///
public object CreateInstance (string typeName)
{
return CreateInstance (typeName, true);
}
///
/// Creates an instance of a type defined in the add-in
///
///
/// Name of the type.
///
///
/// Indicates whether the method should throw an exception if the type can't be found.
///
///
/// A new instance of the type
///
///
/// The type will be looked up in the assemblies that implement the add-in,
/// and recursivelly in all add-ins on which it depends.
///
/// If the type can't be found, this method throw a InvalidOperationException if
/// 'throwIfNotFound' is 'true', or 'null' otherwise.
///
/// The specified type must have a default constructor.
///
public object CreateInstance (string typeName, bool throwIfNotFound)
{
Type type = GetType (typeName, throwIfNotFound);
if (type == null)
return null;
else
return Activator.CreateInstance (type, true);
}
///
/// Gets the path of an add-in file
///
///
/// Relative path of the file
///
///
/// Full path of the file
///
///
/// This method can be used to get the full path of a data file deployed together with the add-in.
///
public string GetFilePath (string fileName)
{
return Path.Combine (baseDirectory, fileName);
}
///
/// Gets the path of an add-in file
///
///
/// Components of the file path
///
///
/// Full path of the file
///
///
/// This method can be used to get the full path of a data file deployed together with the add-in.
///
public string GetFilePath (params string[] filePath)
{
return Path.Combine (baseDirectory, string.Join ("" + Path.DirectorySeparatorChar, filePath));
}
///
/// Path to a directory where add-ins can store private configuration or status data
///
public string PrivateDataPath {
get {
if (privatePath == null) {
privatePath = ainfo.PrivateDataPath;
if (!Directory.Exists (privatePath))
Directory.CreateDirectory (privatePath);
}
return privatePath;
}
}
///
/// Gets the content of a resource
///
///
/// Name of the resource
///
///
/// Content of the resource, or null if not found
///
///
/// The add-in engine will look for resources in the main add-in assembly and in all included add-in assemblies.
///
public Stream GetResource (string resourceName)
{
return GetResource (resourceName, false);
}
///
/// Gets the content of a resource
///
///
/// Name of the resource
///
///
/// When set to true, an exception will be thrown if the resource is not found.
///
///
/// Content of the resource.
///
///
/// The add-in engine will look for resources in the main add-in assembly and in all included add-in assemblies.
///
public Stream GetResource (string resourceName, bool throwIfNotFound)
{
EnsureAssembliesLoaded ();
// Look in the addin assemblies
foreach (Assembly asm in GetAllAssemblies ()) {
Stream res = asm.GetManifestResourceStream (resourceName);
if (res != null)
return res;
}
// Look in the dependent add-ins
foreach (RuntimeAddin addin in GetAllDependencies ()) {
Stream res = addin.GetResource (resourceName);
if (res != null)
return res;
}
if (throwIfNotFound)
throw new InvalidOperationException ("Resource '" + resourceName + "' not found in add-in '" + id + "'");
return null;
}
///
/// Localizer which can be used to localize strings defined in this add-in
///
public AddinLocalizer Localizer {
get {
if (localizer != null)
return localizer;
else
return addinEngine.DefaultLocalizer;
}
}
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;
}
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;
}
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));
}
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 || a.IsDynamic) {
continue;
}
try {
if (a.Location == asmPath) {
asm = a;
break;
}
} catch (NotSupportedException) {
// Some assemblies don't have a location
}
}
if (asm == null) {
asm = Assembly.LoadFrom (asmPath);
}
asmList.Add (asm);
}
}
internal void UnloadExtensions ()
{
addinEngine.UnregisterAddinNodeSets (id);
}
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;
}
internal bool AssembliesLoaded {
get { return assemblies != null; }
}
void EnsureAssembliesLoaded ()
{
if (assemblies != null)
return;
ArrayList asmList = new ArrayList ();
// Load the assemblies of the module
CheckAddinDependencies (module, true);
LoadModule (module, asmList);
assemblies = (Assembly[]) asmList.ToArray (typeof(Assembly));
addinEngine.RegisterAssemblies (this);
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/Addin.cs 0000664 0001750 0001750 00000024527 12136523632 023411 0 ustar 00directhex directhex 0000000 0000000 //
// Addin.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2005 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
using System.Collections.Specialized;
using Mono.Addins.Description;
using Mono.Addins.Database;
using System.Linq;
namespace Mono.Addins
{
///
/// An add-in.
///
public class Addin
{
AddinInfo addin;
string configFile;
string sourceFile;
WeakReference desc;
AddinDatabase database;
bool? isLatestVersion;
bool? isUserAddin;
string id;
internal Addin (AddinDatabase database, string file)
{
this.database = database;
configFile = file;
}
///
/// Full identifier of the add-in, including namespace and version.
///
public string Id {
get {
if (configFile != null) {
if (id == null)
id = Path.GetFileNameWithoutExtension (configFile);
return id;
}
return this.AddinInfo.Id;
}
}
///
/// Namespace of the add-in.
///
public string Namespace {
get { return this.AddinInfo.Namespace; }
}
///
/// Identifier of the add-in (without namespace)
///
public string LocalId {
get { return this.AddinInfo.LocalId; }
}
///
/// Version of the add-in
///
public string Version {
get { return this.AddinInfo.Version; }
}
///
/// Display name of the add-in
///
public string Name {
get { return this.AddinInfo.Name; }
}
///
/// Custom properties specified in the add-in header
///
public AddinPropertyCollection Properties {
get { return this.AddinInfo.Properties; }
}
internal string PrivateDataPath {
get { return Path.Combine (database.AddinPrivateDataPath, Path.GetFileNameWithoutExtension (Description.FileName)); }
}
///
/// Checks version compatibility.
///
///
/// An add-in version.
///
///
/// True if the provided version is compatible with this add-in.
///
///
/// This method checks the CompatVersion property to know if the provided version is compatible with the version of this add-in.
///
public bool SupportsVersion (string version)
{
return AddinInfo.SupportsVersion (version);
}
///
/// Returns a that represents the current .
///
///
/// A that represents the current .
///
public override string ToString ()
{
return Id;
}
internal AddinInfo AddinInfo {
get {
if (addin == null) {
try {
addin = AddinInfo.ReadFromDescription (Description);
} catch (Exception ex) {
throw new InvalidOperationException ("Could not read add-in file: " + configFile, ex);
}
}
return addin;
}
}
///
/// Gets or sets the enabled status of the add-in.
///
///
/// This property can be used to enable or disable an add-in.
/// The enabled status of an add-in is stored in the add-in registry,
/// so when an add-in is disabled, it will be disabled for all applications
/// sharing the same registry.
/// When an add-in is enabled or disabled, the extension points currently loaded
/// in memory will be properly updated to include or exclude extensions from the add-in.
///
public bool Enabled {
get {
if (!IsLatestVersion)
return false;
return AddinInfo.IsRoot ? true : database.IsAddinEnabled (Description.Domain, AddinInfo.Id, true);
}
set {
if (value)
database.EnableAddin (Description.Domain, AddinInfo.Id, true);
else
database.DisableAddin (Description.Domain, AddinInfo.Id);
}
}
internal bool IsLatestVersion {
get {
if (isLatestVersion == null) {
string id, version;
Addin.GetIdParts (AddinInfo.Id, out id, out version);
var addins = database.GetInstalledAddins (null, AddinSearchFlagsInternal.IncludeAll | AddinSearchFlagsInternal.LatestVersionsOnly);
isLatestVersion = addins.Where (a => Addin.GetIdName (a.Id) == id && a.Version == version).Any ();
}
return isLatestVersion.Value;
}
set {
isLatestVersion = value;
}
}
///
/// Returns 'true' if the add-in is installed in the user's personal folder
///
public bool IsUserAddin {
get {
if (isUserAddin == null)
SetIsUserAddin (Description);
return isUserAddin.Value;
}
}
void SetIsUserAddin (AddinDescription adesc)
{
string installPath = database.Registry.DefaultAddinsFolder;
if (installPath [installPath.Length - 1] != Path.DirectorySeparatorChar)
installPath += Path.DirectorySeparatorChar;
isUserAddin = adesc != null && Path.GetFullPath (adesc.AddinFile).StartsWith (installPath);
}
///
/// Path to the add-in file (it can be an assembly or a standalone XML manifest)
///
public string AddinFile {
get {
if (sourceFile == null && addin == null)
LoadAddinInfo ();
return sourceFile;
}
}
void LoadAddinInfo ()
{
if (addin == null) {
try {
AddinDescription m = Description;
sourceFile = m.AddinFile;
addin = AddinInfo.ReadFromDescription (m);
} catch (Exception ex) {
throw new InvalidOperationException ("Could not read add-in file: " + configFile, ex);
}
}
}
///
/// Description of the add-in
///
public AddinDescription Description {
get {
if (desc != null) {
AddinDescription d = desc.Target as AddinDescription;
if (d != null)
return d;
}
AddinDescription m;
database.ReadAddinDescription (new ConsoleProgressStatus (true), configFile, out m);
if (m == null) {
try {
if (File.Exists (configFile)) {
// The file is corrupted. Remove it.
File.Delete (configFile);
}
} catch {
// Ignore
}
throw new InvalidOperationException ("Could not read add-in description");
}
if (addin == null) {
addin = AddinInfo.ReadFromDescription (m);
sourceFile = m.AddinFile;
}
SetIsUserAddin (m);
if (!isUserAddin.Value)
m.Flags |= AddinFlags.CantUninstall;
desc = new WeakReference (m);
return m;
}
}
internal void ResetCachedData ()
{
desc = null;
addin = null;
}
///
/// Compares two add-in versions
///
///
/// -1 if v1 is greater than v2, 0 if v1 == v2, 1 if v1 less than v2
///
///
/// A version
///
///
/// A version
///
public static int CompareVersions (string v1, string v2)
{
string[] a1 = v1.Split ('.');
string[] a2 = v2.Split ('.');
for (int n=0; n= a2.Length)
return -1;
if (a1[n].Length == 0) {
if (a2[n].Length != 0)
return 1;
continue;
}
try {
int n1 = int.Parse (a1[n]);
int n2 = int.Parse (a2[n]);
if (n1 < n2)
return 1;
else if (n1 > n2)
return -1;
} catch {
return 1;
}
}
if (a2.Length > a1.Length)
return 1;
return 0;
}
///
/// Returns the identifier of an add-in
///
///
/// The full identifier.
///
///
/// Namespace of the add-in
///
///
/// Name of the add-in
///
///
/// Version of the add-in
///
public static string GetFullId (string ns, string id, string version)
{
string res;
if (id.StartsWith ("::"))
res = id.Substring (2);
else if (ns != null && ns.Length > 0)
res = ns + "." + id;
else
res = id;
if (version != null && version.Length > 0)
return res + "," + version;
else
return res;
}
///
/// Given a full add-in identifier, returns the namespace and name of the add-in (it removes the version number)
///
///
/// Add-in identifier.
///
public static string GetIdName (string addinId)
{
int i = addinId.IndexOf (',');
if (i != -1)
return addinId.Substring (0, i);
else
return addinId;
}
///
/// Given a full add-in identifier, returns the version the add-in
///
///
/// The version.
///
public static string GetIdVersion (string addinId)
{
int i = addinId.IndexOf (',');
if (i != -1)
return addinId.Substring (i + 1).Trim ();
else
return string.Empty;
}
///
/// Splits a full add-in identifier in name and version
///
///
/// Add-in identifier.
///
///
/// The resulting name
///
///
/// The resulting version
///
public static void GetIdParts (string addinId, out string name, out string version)
{
int i = addinId.IndexOf (',');
if (i != -1) {
name = addinId.Substring (0, i);
version = addinId.Substring (i+1).Trim ();
} else {
name = addinId;
version = string.Empty;
}
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/TreeNodeCollection.cs 0000664 0001750 0001750 00000004232 12136523632 026102 0 ustar 00directhex directhex 0000000 0000000 //
// TreeNodeCollection.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
namespace Mono.Addins
{
class TreeNodeCollection: IEnumerable
{
ArrayList list;
internal static TreeNodeCollection Empty = new TreeNodeCollection (null);
public TreeNodeCollection (ArrayList list)
{
this.list = list;
}
public IEnumerator GetEnumerator ()
{
if (list != null)
return list.GetEnumerator ();
else
return Type.EmptyTypes.GetEnumerator ();
}
public TreeNode this [int n] {
get {
if (list != null)
return (TreeNode) list [n];
else
throw new System.IndexOutOfRangeException ();
}
}
public int IndexOfNode (string id)
{
for (int n=0; n
/// An add-in registry.
///
///
/// An add-in registry is a data structure used by the add-in engine to locate add-ins to load.
///
/// A registry can be configured to look for add-ins in several directories. However, add-ins
/// copied to those directories won't be detected until an explicit add-in scan is requested.
/// The registry can be updated by an application by calling Registry.Update(), or by a user by
/// running the 'mautil' add-in setup tool.
///
/// The registry has information about the location of every add-in and a timestamp of the last
/// check, so the Update method will only scan new or modified add-ins. An application can
/// add a call to Registry.Update() in the Main method to detect all new add-ins every time the
/// app is started.
///
/// Every add-in added to the registry is parsed and validated, and if there is any error it
/// will be rejected. The registry is also in charge of scanning the add-in assemblies and look
/// for extensions and other information declared using custom attributes. That information is
/// merged with the manifest information (if there is one) to create a complete add-in
/// description ready to be used at run-time.
///
/// Mono.Addins allows sharing an add-in registry among several applications. In this context,
/// all applications sharing the registry share the same extension point model, and it is
/// possible to implement add-ins which extend several hosts.
///
public class AddinRegistry: IDisposable
{
AddinDatabase database;
StringCollection addinDirs;
string basePath;
string currentDomain;
string startupDirectory;
string addinsDir;
string databaseDir;
///
/// Initializes a new instance.
///
///
/// Location of the add-in registry.
///
///
/// Creates a new add-in registry located in the provided path.
/// The add-in registry will look for add-ins in an 'addins'
/// subdirectory of the provided registryPath.
///
/// When specifying a path, it is possible to use a special folder name as root.
/// For example: [Personal]/.config/MyApp. In this case, [Personal] will be replaced
/// by the location of the Environment.SpecialFolder.Personal folder. Any value
/// of the Environment.SpecialFolder enumeration can be used (always between square
/// brackets)
///
public AddinRegistry (string registryPath): this (null, registryPath, null, null, null)
{
}
///
/// Initializes a new instance.
///
///
/// Location of the add-in registry.
///
///
/// Location of the application.
///
///
/// Creates a new add-in registry located in the provided path.
/// The add-in registry will look for add-ins in an 'addins'
/// subdirectory of the provided registryPath.
///
/// When specifying a path, it is possible to use a special folder name as root.
/// For example: [Personal]/.config/MyApp. In this case, [Personal] will be replaced
/// by the location of the Environment.SpecialFolder.Personal folder. Any value
/// of the Environment.SpecialFolder enumeration can be used (always between square
/// brackets)
///
public AddinRegistry (string registryPath, string startupDirectory): this (null, registryPath, startupDirectory, null, null)
{
}
///
/// Initializes a new instance of the class.
///
///
/// Location of the add-in registry.
///
///
/// Location of the application.
///
///
/// Add-ins directory. If the path is relative, it is considered to be relative
/// to the configDir directory.
///
///
/// Creates a new add-in registry located in the provided path.
/// Configuration information about the add-in registry will be stored in
/// 'registryPath'. The add-in registry will look for add-ins in the provided
/// 'addinsDir' directory.
///
/// When specifying a path, it is possible to use a special folder name as root.
/// For example: [Personal]/.config/MyApp. In this case, [Personal] will be replaced
/// by the location of the Environment.SpecialFolder.Personal folder. Any value
/// of the Environment.SpecialFolder enumeration can be used (always between square
/// brackets)
///
public AddinRegistry (string registryPath, string startupDirectory, string addinsDir): this (null, registryPath, startupDirectory, addinsDir, null)
{
}
///
/// Initializes a new instance of the class.
///
///
/// Location of the add-in registry.
///
///
/// Location of the application.
///
///
/// Add-ins directory. If the path is relative, it is considered to be relative
/// to the configDir directory.
///
///
/// Location of the add-in database. If the path is relative, it is considered to be relative
/// to the configDir directory.
///
///
/// Creates a new add-in registry located in the provided path.
/// Configuration information about the add-in registry will be stored in
/// 'registryPath'. The add-in registry will look for add-ins in the provided
/// 'addinsDir' directory. Cached information about add-ins will be stored in
/// the 'databaseDir' directory.
///
/// When specifying a path, it is possible to use a special folder name as root.
/// For example: [Personal]/.config/MyApp. In this case, [Personal] will be replaced
/// by the location of the Environment.SpecialFolder.Personal folder. Any value
/// of the Environment.SpecialFolder enumeration can be used (always between square
/// brackets)
///
public AddinRegistry (string registryPath, string startupDirectory, string addinsDir, string databaseDir): this (null, registryPath, startupDirectory, addinsDir, databaseDir)
{
}
internal AddinRegistry (AddinEngine engine, string registryPath, string startupDirectory, string addinsDir, string databaseDir)
{
basePath = Path.GetFullPath (Util.NormalizePath (registryPath));
if (addinsDir != null) {
addinsDir = Util.NormalizePath (addinsDir);
if (Path.IsPathRooted (addinsDir))
this.addinsDir = Path.GetFullPath (addinsDir);
else
this.addinsDir = Path.GetFullPath (Path.Combine (basePath, addinsDir));
} else
this.addinsDir = Path.Combine (basePath, "addins");
if (databaseDir != null) {
databaseDir = Util.NormalizePath (databaseDir);
if (Path.IsPathRooted (databaseDir))
this.databaseDir = Path.GetFullPath (databaseDir);
else
this.databaseDir = Path.GetFullPath (Path.Combine (basePath, databaseDir));
}
else
this.databaseDir = Path.GetFullPath (basePath);
// Look for add-ins in the hosts directory and in the default
// addins directory
addinDirs = new StringCollection ();
addinDirs.Add (DefaultAddinsFolder);
// Initialize the database after all paths have been set
database = new AddinDatabase (engine, this);
// Get the domain corresponding to the startup folder
if (startupDirectory != null && startupDirectory.Length > 0) {
this.startupDirectory = Util.NormalizePath (startupDirectory);
currentDomain = database.GetFolderDomain (null, this.startupDirectory);
} else
currentDomain = AddinDatabase.GlobalDomain;
}
///
/// Gets the global registry.
///
///
/// The global registry
///
///
/// The global add-in registry is created in "~/.config/mono.addins",
/// and it is the default registry used when none is specified.
///
public static AddinRegistry GetGlobalRegistry ()
{
return GetGlobalRegistry (null, null);
}
internal static AddinRegistry GetGlobalRegistry (AddinEngine engine, string startupDirectory)
{
AddinRegistry reg = new AddinRegistry (engine, GlobalRegistryPath, startupDirectory, null, null);
string baseDir;
if (Util.IsWindows)
baseDir = Environment.GetFolderPath (Environment.SpecialFolder.CommonProgramFiles);
else
baseDir = "/etc";
reg.GlobalAddinDirectories.Add (Path.Combine (baseDir, "mono.addins"));
return reg;
}
internal bool UnknownDomain {
get { return currentDomain == AddinDatabase.UnknownDomain; }
}
internal static string GlobalRegistryPath {
get {
string customDir = Environment.GetEnvironmentVariable ("MONO_ADDINS_GLOBAL_REGISTRY");
if (customDir != null && customDir.Length > 0)
return Path.GetFullPath (Util.NormalizePath (customDir));
string path = Environment.GetFolderPath (Environment.SpecialFolder.ApplicationData);
path = Path.Combine (path, "mono.addins");
return Path.GetFullPath (path);
}
}
internal string CurrentDomain {
get { return currentDomain; }
}
///
/// Location of the add-in registry.
///
public string RegistryPath {
get { return basePath; }
}
///
/// Disposes the add-in engine.
///
public void Dispose ()
{
database.Shutdown ();
}
///
/// Returns an add-in from the registry.
///
///
/// Identifier of the add-in.
///
///
/// The add-in, or 'null' if not found.
///
///
/// The add-in identifier may optionally include a version number, for example: "TextEditor.Xml,1.2"
///
public Addin GetAddin (string id)
{
if (currentDomain == AddinDatabase.UnknownDomain)
return null;
Addin ad = database.GetInstalledAddin (currentDomain, id);
if (ad != null && IsRegisteredForUninstall (ad.Id))
return null;
return ad;
}
///
/// Returns an add-in from the registry.
///
///
/// Identifier of the add-in.
///
///
/// 'true' if the exact add-in version must be found.
///
///
/// The add-in, or 'null' if not found.
///
///
/// The add-in identifier may optionally include a version number, for example: "TextEditor.Xml,1.2".
/// In this case, if the exact version is not found and exactVersionMatch is 'false', it will
/// return one than is compatible with the required version.
///
public Addin GetAddin (string id, bool exactVersionMatch)
{
if (currentDomain == AddinDatabase.UnknownDomain)
return null;
Addin ad = database.GetInstalledAddin (currentDomain, id, exactVersionMatch);
if (ad != null && IsRegisteredForUninstall (ad.Id))
return null;
return ad;
}
///
/// Gets all add-ins or add-in roots registered in the registry.
///
///
/// The addins.
///
///
/// Flags.
///
public Addin[] GetModules (AddinSearchFlags flags)
{
if (currentDomain == AddinDatabase.UnknownDomain)
return new Addin [0];
AddinSearchFlagsInternal f = (AddinSearchFlagsInternal)(int)flags;
return database.GetInstalledAddins (currentDomain, f | AddinSearchFlagsInternal.ExcludePendingUninstall).ToArray ();
}
///
/// Gets all add-ins registered in the registry.
///
///
/// Add-ins registered in the registry.
///
public Addin[] GetAddins ()
{
return GetModules (AddinSearchFlags.IncludeAddins);
}
///
/// Gets all add-in roots registered in the registry.
///
///
/// Descriptions of all add-in roots.
///
public Addin[] GetAddinRoots ()
{
return GetModules (AddinSearchFlags.IncludeRoots);
}
///
/// Loads an add-in description
///
///
/// Progress tracker.
///
///
/// Name of the file to load
///
///
/// An add-in description
///
///
/// 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.
///
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);
}
}
///
/// Reads an XML add-in manifest
///
///
/// Path to the XML file
///
///
/// An add-in description
///
public AddinDescription ReadAddinManifestFile (string file)
{
AddinDescription desc = AddinDescription.Read (file);
if (currentDomain != AddinDatabase.UnknownDomain) {
desc.OwnerDatabase = database;
desc.Domain = currentDomain;
}
return desc;
}
///
/// Reads an XML add-in manifest
///
///
/// Reader that contains the XML
///
///
/// Base path to use to discover add-in files
///
///
/// An add-in description
///
public AddinDescription ReadAddinManifestFile (TextReader reader, string baseFile)
{
if (currentDomain == AddinDatabase.UnknownDomain)
return null;
AddinDescription desc = AddinDescription.Read (reader, baseFile);
desc.OwnerDatabase = database;
desc.Domain = currentDomain;
return desc;
}
///
/// Checks whether an add-in is enabled.
///
///
/// Identifier of the add-in.
///
///
/// 'true' if the add-in is enabled.
///
public bool IsAddinEnabled (string id)
{
if (currentDomain == AddinDatabase.UnknownDomain)
return false;
return database.IsAddinEnabled (currentDomain, id);
}
///
/// Enables an add-in.
///
///
/// Identifier of the add-in
///
///
/// If the enabled add-in depends on other add-ins which are disabled,
/// those will automatically be enabled too.
///
public void EnableAddin (string id)
{
if (currentDomain == AddinDatabase.UnknownDomain)
return;
database.EnableAddin (currentDomain, id, true);
}
///
/// Disables an add-in.
///
///
/// Identifier of the add-in.
///
///
/// When an add-in is disabled, all extension points it defines will be ignored
/// by the add-in engine. Other add-ins which depend on the disabled add-in will
/// also automatically be disabled.
///
public void DisableAddin (string id)
{
if (currentDomain == AddinDatabase.UnknownDomain)
return;
database.DisableAddin (currentDomain, id);
}
///
/// Registers a set of add-ins for uninstallation.
///
///
/// Identifier of the add-in
///
///
/// Files to be uninstalled
///
///
/// This method can be used to instruct the add-in manager to uninstall
/// an add-in the next time the registry is updated. This is useful
/// when an add-in manager can't delete an add-in because if it is
/// loaded.
///
public void RegisterForUninstall (string id, IEnumerable files)
{
database.RegisterForUninstall (currentDomain, id, files);
}
///
/// Determines whether an add-in is registered for uninstallation
///
///
/// true if the add-in is registered for uninstallation
///
///
/// Identifier of the add-in
///
public bool IsRegisteredForUninstall (string addinId)
{
return database.IsRegisteredForUninstall (currentDomain, addinId);
}
///
/// Gets a value indicating whether there are pending add-ins to be uninstalled installed
///
public bool HasPendingUninstalls {
get { return database.HasPendingUninstalls (currentDomain); }
}
///
/// Internal use only
///
public void DumpFile (string file)
{
Mono.Addins.Serialization.BinaryXmlReader.DumpFile (file);
}
///
/// Resets the configuration files of the registry
///
public void ResetConfiguration ()
{
database.ResetConfiguration ();
}
internal void NotifyDatabaseUpdated ()
{
if (startupDirectory != null)
currentDomain = database.GetFolderDomain (null, startupDirectory);
}
///
/// Updates the add-in registry.
///
///
/// This method must be called after modifying, installing or uninstalling add-ins.
///
/// When calling Update, every add-in added to the registry is parsed and validated,
/// and if there is any error it will be rejected. It will also cache add-in information
/// needed at run-time.
///
/// If during the update operation the registry finds new add-ins or detects that some
/// add-ins have been deleted, the loaded extension points will be updated to include
/// or exclude extension nodes from those add-ins.
///
public void Update ()
{
Update (new ConsoleProgressStatus (false));
}
///
/// Updates the add-in registry.
///
///
/// Progress monitor to keep track of the update operation.
///
///
/// This method must be called after modifying, installing or uninstalling add-ins.
///
/// When calling Update, every add-in added to the registry is parsed and validated,
/// and if there is any error it will be rejected. It will also cache add-in information
/// needed at run-time.
///
/// If during the update operation the registry finds new add-ins or detects that some
/// add-ins have been deleted, the loaded extension points will be updated to include
/// or exclude extension nodes from those add-ins.
///
public void Update (IProgressStatus monitor)
{
database.Update (monitor, currentDomain);
}
///
/// Regenerates the cached data of the add-in registry.
///
///
/// Progress monitor to keep track of the rebuild operation.
///
public void Rebuild (IProgressStatus monitor)
{
database.Repair (monitor, currentDomain);
}
///
/// Registers an extension. Only AddinFileSystemExtension extensions are supported right now.
///
///
/// The extension to register
///
public void RegisterExtension (object extension)
{
database.RegisterExtension (extension);
}
///
/// Unregisters an extension.
///
///
/// The extension to unregister
///
public void UnregisterExtension (object extension)
{
database.UnregisterExtension (extension);
}
internal void CopyExtensionsFrom (AddinRegistry other)
{
database.CopyExtensions (other.database);
}
internal Addin GetAddinForHostAssembly (string filePath)
{
if (currentDomain == AddinDatabase.UnknownDomain)
return null;
return database.GetAddinForHostAssembly (currentDomain, filePath);
}
internal bool AddinDependsOn (string id1, string id2)
{
return database.AddinDependsOn (currentDomain, id1, id2);
}
internal void ScanFolders (IProgressStatus monitor, string folderToScan, StringCollection filesToIgnore)
{
database.ScanFolders (monitor, currentDomain, folderToScan, filesToIgnore);
}
internal void ParseAddin (IProgressStatus progressStatus, string file, string outFile)
{
database.ParseAddin (progressStatus, currentDomain, file, outFile, true);
}
///
/// Gets the default add-ins folder of the registry.
///
///
/// For every add-in registry there is an add-in folder where the registry will look for add-ins by default.
/// This folder is an "addins" subdirectory of the directory where the repository is located. In most cases,
/// this folder will only contain .addins files referencing other more convenient locations for add-ins.
///
public string DefaultAddinsFolder {
get { return addinsDir; }
}
internal string AddinCachePath {
get { return databaseDir; }
}
internal StringCollection GlobalAddinDirectories {
get { return addinDirs; }
}
internal string StartupDirectory {
get {
return startupDirectory;
}
}
internal bool CreateHostAddinsFile (string hostFile)
{
hostFile = Path.GetFullPath (hostFile);
string baseName = Path.GetFileNameWithoutExtension (hostFile);
if (!Directory.Exists (database.HostsPath))
Directory.CreateDirectory (database.HostsPath);
foreach (string s in Directory.GetFiles (database.HostsPath, baseName + "*.addins")) {
try {
using (StreamReader sr = new StreamReader (s)) {
XmlTextReader tr = new XmlTextReader (sr);
tr.MoveToContent ();
string host = tr.GetAttribute ("host-reference");
if (host == hostFile)
return false;
}
}
catch {
// Ignore this file
}
}
string file = Path.Combine (database.HostsPath, baseName) + ".addins";
int n=1;
while (File.Exists (file)) {
file = Path.Combine (database.HostsPath, baseName) + "_" + n + ".addins";
n++;
}
using (StreamWriter sw = new StreamWriter (file)) {
XmlTextWriter tw = new XmlTextWriter (sw);
tw.Formatting = Formatting.Indented;
tw.WriteStartElement ("Addins");
tw.WriteAttributeString ("host-reference", hostFile);
tw.WriteStartElement ("Directory");
tw.WriteAttributeString ("shared", "false");
tw.WriteString (Path.GetDirectoryName (hostFile));
tw.WriteEndElement ();
tw.Close ();
}
return true;
}
#pragma warning disable 1591
[Obsolete]
public static string[] GetRegisteredStartupFolders (string registryPath)
{
string dbDir = Path.Combine (registryPath, "addin-db-" + AddinDatabase.VersionTag);
dbDir = Path.Combine (dbDir, "hosts");
if (!Directory.Exists (dbDir))
return new string [0];
ArrayList dirs = new ArrayList ();
foreach (string s in Directory.GetFiles (dbDir, "*.addins")) {
try {
using (StreamReader sr = new StreamReader (s)) {
XmlTextReader tr = new XmlTextReader (sr);
tr.MoveToContent ();
string host = tr.GetAttribute ("host-reference");
host = Path.GetDirectoryName (host);
if (!dirs.Contains (host))
dirs.Add (host);
}
}
catch {
// Ignore this file
}
}
return (string[]) dirs.ToArray (typeof(string));
}
#pragma warning restore 1591
}
///
/// Addin search flags.
///
[Flags]
public enum AddinSearchFlags
{
///
/// Add-ins are included in the search
///
IncludeAddins = 1,
///
/// Add-in roots are included in the search
///
IncludeRoots = 1 << 1,
///
/// Both add-in and add-in roots are included in the search
///
IncludeAll = IncludeAddins | IncludeRoots,
///
/// Only the latest version of every add-in or add-in root is included in the search
///
LatestVersionsOnly = 1 << 3
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/ExtensionPointAttribute.cs 0000664 0001750 0001750 00000011704 12136523632 027235 0 ustar 00directhex directhex 0000000 0000000 //
// ExtensionPointAttribute.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
namespace Mono.Addins
{
///
/// Declares an extension point.
///
[AttributeUsage (AttributeTargets.Assembly, AllowMultiple=true)]
public class ExtensionPointAttribute: Attribute
{
string path;
Type nodeType;
string nodeName;
string desc;
string name;
Type objectType;
string nodeTypeName;
string objectTypeName;
Type customAttributeType;
string customAttributeTypeName;
///
/// Initializes a new instance
///
public ExtensionPointAttribute ()
{
}
///
/// Initializes a new instance
///
///
/// Extension path that identifies the extension point
///
public ExtensionPointAttribute (string path)
{
this.path = path;
}
///
/// Initializes a new instance
///
///
/// Extension path that identifies the extension point
///
///
/// Type of the extension node to be created for extensions
///
public ExtensionPointAttribute (string path, Type nodeType)
{
this.path = path;
this.nodeType = nodeType;
}
///
/// Initializes a new instance
///
///
/// Extension path that identifies the extension point
///
///
/// Element name to be used when defining an extension in an XML manifest.
///
///
/// Type of the extension node to be created for extensions
///
public ExtensionPointAttribute (string path, string nodeName, Type nodeType)
{
this.path = path;
this.nodeType = nodeType;
this.nodeName = nodeName;
}
///
/// Extension path that identifies the extension point
///
public string Path {
get { return path != null ? path : string.Empty; }
set { path = value; }
}
///
/// Long description of the extension point.
///
public string Description {
get { return desc != null ? desc : string.Empty; }
set { desc = value; }
}
///
/// Type of the extension node to be created for extensions
///
public Type NodeType {
get { return nodeType != null ? nodeType : typeof(TypeExtensionNode); }
set { nodeType = value; nodeTypeName = value.FullName; }
}
///
/// Expected extension object type (when nodes are of type TypeExtensionNode)
///
public Type ObjectType {
get { return objectType; }
set { objectType = value; objectTypeName = value.FullName; }
}
internal string NodeTypeName {
get { return nodeTypeName != null ? nodeTypeName : typeof(TypeExtensionNode).FullName; }
set { nodeTypeName = value; }
}
internal string ObjectTypeName {
get { return objectTypeName; }
set { objectTypeName = value; }
}
///
/// Element name to be used when defining an extension in an XML manifest. The default name is "Type".
///
public string NodeName {
get { return nodeName != null && nodeName.Length > 0 ? nodeName : string.Empty; }
set { nodeName = value; }
}
///
/// Display name of the extension point.
///
public string Name {
get { return name != null ? name : string.Empty; }
set { name = value; }
}
///
/// Type of the custom attribute to be used to specify metadata for the extension point
///
public Type ExtensionAttributeType {
get { return this.customAttributeType; }
set { this.customAttributeType = value; customAttributeTypeName = value.FullName; }
}
internal string ExtensionAttributeTypeName {
get { return this.customAttributeTypeName; }
set { this.customAttributeTypeName = value; }
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/TreeNode.cs 0000664 0001750 0001750 00000021456 12136523632 024075 0 ustar 00directhex directhex 0000000 0000000 //
// TreeNode.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Text;
using System.Collections;
using Mono.Addins.Description;
namespace Mono.Addins
{
class TreeNode
{
ArrayList childrenList;
TreeNodeCollection children;
ExtensionNode extensionNode;
bool childrenLoaded;
string id;
TreeNode parent;
ExtensionNodeSet nodeTypes;
ExtensionPoint extensionPoint;
BaseCondition condition;
protected AddinEngine addinEngine;
public TreeNode (AddinEngine addinEngine, string id)
{
this.id = id;
this.addinEngine = addinEngine;
// Root node
if (id.Length == 0)
childrenLoaded = true;
}
public AddinEngine AddinEngine {
get { return addinEngine; }
}
internal void AttachExtensionNode (ExtensionNode enode)
{
this.extensionNode = enode;
if (extensionNode != null)
extensionNode.SetTreeNode (this);
}
public string Id {
get { return id; }
}
public ExtensionNode ExtensionNode {
get {
if (extensionNode == null && extensionPoint != null) {
extensionNode = new ExtensionNode ();
extensionNode.SetData (addinEngine, extensionPoint.RootAddin, null, null);
AttachExtensionNode (extensionNode);
}
return extensionNode;
}
}
public ExtensionPoint ExtensionPoint {
get { return extensionPoint; }
set { extensionPoint = value; }
}
public ExtensionNodeSet ExtensionNodeSet {
get { return nodeTypes; }
set { nodeTypes = value; }
}
public TreeNode Parent {
get { return parent; }
}
public BaseCondition Condition {
get { return condition; }
set {
condition = value;
}
}
public virtual ExtensionContext Context {
get {
if (parent != null)
return parent.Context;
else
return null;
}
}
public bool IsEnabled {
get {
if (condition == null)
return true;
ExtensionContext ctx = Context;
if (ctx == null)
return true;
else
return condition.Evaluate (ctx);
}
}
public bool ChildrenLoaded {
get { return childrenLoaded; }
}
public void AddChildNode (TreeNode node)
{
node.parent = this;
if (childrenList == null)
childrenList = new ArrayList ();
childrenList.Add (node);
}
public void InsertChildNode (int n, TreeNode node)
{
node.parent = this;
if (childrenList == null)
childrenList = new ArrayList ();
childrenList.Insert (n, node);
// Dont call NotifyChildrenChanged here. It is called by ExtensionTree,
// after inserting all children of the node.
}
internal int ChildCount {
get { return childrenList == null ? 0 : childrenList.Count; }
}
public ExtensionNode GetExtensionNode (string path, string childId)
{
TreeNode node = GetNode (path, childId);
return node != null ? node.ExtensionNode : null;
}
public ExtensionNode GetExtensionNode (string path)
{
TreeNode node = GetNode (path);
return node != null ? node.ExtensionNode : null;
}
public TreeNode GetNode (string path, string childId)
{
if (childId == null || childId.Length == 0)
return GetNode (path);
else
return GetNode (path + "/" + childId);
}
public TreeNode GetNode (string path)
{
return GetNode (path, false);
}
public TreeNode GetNode (string path, bool buildPath)
{
if (path.StartsWith ("/"))
path = path.Substring (1);
string[] parts = path.Split ('/');
TreeNode curNode = this;
foreach (string part in parts) {
int i = curNode.Children.IndexOfNode (part);
if (i != -1) {
curNode = curNode.Children [i];
continue;
}
if (buildPath) {
TreeNode newNode = new TreeNode (addinEngine, part);
curNode.AddChildNode (newNode);
curNode = newNode;
} else
return null;
}
return curNode;
}
public TreeNodeCollection Children {
get {
if (!childrenLoaded) {
childrenLoaded = true;
if (extensionPoint != null)
Context.LoadExtensions (GetPath ());
// We have to keep the relation info, since add-ins may be loaded/unloaded
}
if (childrenList == null)
return TreeNodeCollection.Empty;
if (children == null)
children = new TreeNodeCollection (childrenList);
return children;
}
}
public string GetPath ()
{
int num=0;
TreeNode node = this;
while (node != null) {
num++;
node = node.parent;
}
string[] ids = new string [num];
node = this;
while (node != null) {
ids [--num] = node.id;
node = node.parent;
}
return string.Join ("/", ids);
}
public void NotifyAddinLoaded (RuntimeAddin ad, bool recursive)
{
if (extensionNode != null && extensionNode.AddinId == ad.Addin.Id)
extensionNode.OnAddinLoaded ();
if (recursive && childrenLoaded) {
foreach (TreeNode node in Children.Clone ())
node.NotifyAddinLoaded (ad, true);
}
}
public ExtensionPoint FindLoadedExtensionPoint (string path)
{
if (path.StartsWith ("/"))
path = path.Substring (1);
string[] parts = path.Split ('/');
TreeNode curNode = this;
foreach (string part in parts) {
int i = curNode.Children.IndexOfNode (part);
if (i != -1) {
curNode = curNode.Children [i];
if (!curNode.ChildrenLoaded)
return null;
if (curNode.ExtensionPoint != null)
return curNode.ExtensionPoint;
continue;
}
return null;
}
return null;
}
public void FindAddinNodes (string id, ArrayList nodes)
{
if (id != null && extensionPoint != null && extensionPoint.RootAddin == id) {
// It is an extension point created by the add-in. All nodes below this
// extension point will be added to the list, even if they come from other add-ins.
id = null;
}
if (childrenLoaded) {
// Deep-first search, to make sure children are removed before the parent.
foreach (TreeNode node in Children)
node.FindAddinNodes (id, nodes);
}
if (id == null || (ExtensionNode != null && ExtensionNode.AddinId == id))
nodes.Add (this);
}
public bool FindExtensionPathByType (IProgressStatus monitor, Type type, string nodeName, out string path, out string pathNodeName)
{
if (extensionPoint != null) {
foreach (ExtensionNodeType nt in extensionPoint.NodeSet.NodeTypes) {
if (nt.ObjectTypeName.Length > 0 && (nodeName.Length == 0 || nodeName == nt.Id)) {
RuntimeAddin addin = addinEngine.GetAddin (extensionPoint.RootAddin);
Type ot = addin.GetType (nt.ObjectTypeName);
if (ot != null) {
if (ot.IsAssignableFrom (type)) {
path = extensionPoint.Path;
pathNodeName = nt.Id;
return true;
}
}
else
monitor.ReportError ("Type '" + nt.ObjectTypeName + "' not found in add-in '" + Id + "'", null);
}
}
}
else {
foreach (TreeNode node in Children) {
if (node.FindExtensionPathByType (monitor, type, nodeName, out path, out pathNodeName))
return true;
}
}
path = null;
pathNodeName = null;
return false;
}
public void Remove ()
{
if (parent != null) {
if (Condition != null)
Context.UnregisterNodeCondition (this, Condition);
parent.childrenList.Remove (this);
parent.NotifyChildrenChanged ();
}
}
public bool NotifyChildrenChanged ()
{
if (extensionNode != null)
return extensionNode.NotifyChildChanged ();
else
return false;
}
public void ResetCachedData ()
{
if (extensionPoint != null) {
string aid = Addin.GetIdName (extensionPoint.ParentAddinDescription.AddinId);
RuntimeAddin ad = addinEngine.GetAddin (aid);
if (ad != null)
extensionPoint = ad.Addin.Description.ExtensionPoints [GetPath ()];
}
if (childrenList != null) {
foreach (TreeNode cn in childrenList)
cn.ResetCachedData ();
}
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/IProgressStatus.cs 0000664 0001750 0001750 00000006367 12136523632 025515 0 ustar 00directhex directhex 0000000 0000000 //
// IProgressStatus.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
namespace Mono.Addins
{
///
/// Progress status listener.
///
public interface IProgressStatus
{
///
/// Sets the description of the current operation.
///
///
/// A message
///
///
/// This method is called by the add-in engine to show a description of the operation being monitorized.
///
void SetMessage (string msg);
///
/// Sets the progress of the operation.
///
///
/// A number between 0 and 1. 0 means no progress, 1 means operation completed.
///
///
/// This method is called by the add-in engine to show the progress of the operation being monitorized.
///
void SetProgress (double progress);
///
/// Writes text to the log.
///
///
/// Message to write
///
void Log (string msg);
///
/// Log level requested by the user: 0: no log, 1: normal log, >1 verbose log
///
int LogLevel { get; }
///
/// Reports a warning.
///
///
/// Warning message
///
///
/// This method is called by the add-in engine to report a warning in the operation being monitorized.
///
void ReportWarning (string message);
///
/// Reports an error.
///
///
/// Error message
///
///
/// Exception that caused the error. It can be null.
///
///
/// This method is called by the add-in engine to report an error occurred while executing the operation being monitorized.
///
void ReportError (string message, Exception exception);
///
/// Returns True when the user requested to cancel this operation
///
bool IsCanceled { get; }
///
/// Cancels the operation being montorized.
///
void Cancel ();
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/AddinLocalizer.cs 0000664 0001750 0001750 00000012467 12136523632 025256 0 ustar 00directhex directhex 0000000 0000000 //
// AddinLocalizer.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using Mono.Addins.Localization;
namespace Mono.Addins
{
///
/// Converts message identifiers to localized messages.
///
public class AddinLocalizer
{
IAddinLocalizer localizer;
IPluralAddinLocalizer pluralLocalizer;
internal AddinLocalizer (IAddinLocalizer localizer)
{
this.localizer = localizer;
pluralLocalizer = localizer as IPluralAddinLocalizer;
}
///
/// Gets a localized message
///
///
/// Message identifier
///
///
/// The localized message
///
public string GetString (string msgid)
{
return localizer.GetString (msgid);
}
///
/// Gets a formatted and localized message
///
///
/// Message identifier (can contain string format placeholders)
///
///
/// Arguments for the string format operation
///
///
/// The formatted and localized string
///
public string GetString (string msgid, params string[] args)
{
return string.Format (localizer.GetString (msgid), args);
}
///
/// Gets a formatted and localized message
///
///
/// Message identifier (can contain string format placeholders)
///
///
/// Arguments for the string format operation
///
///
/// The formatted and localized string
///
public string GetString (string msgid, params object[] args)
{
return string.Format (localizer.GetString (msgid), args);
}
///
/// Gets a localized plural form for a message identifier
///
///
/// Message identifier for the singular form
///
///
/// Default result message for the plural form
///
///
/// Value count. Determines wether to use singular or plural form.
///
///
/// The localized message
///
public string GetPluralString (string msgid, string defaultPlural, int n)
{
// If the localizer does not support plural forms, just use GetString to
// get a translation. It is not correct to check 'n' in this case because
// there is no guarantee that 'defaultPlural' will be translated.
if (pluralLocalizer != null)
return pluralLocalizer.GetPluralString (msgid, defaultPlural, n);
else
return GetString (msgid);
}
///
/// Gets a localized and formatted plural form for a message identifier
///
///
/// Message identifier for the singular form (can contain string format placeholders)
///
///
/// Default result message for the plural form (can contain string format placeholders)
///
///
/// Value count. Determines whether to use singular or plural form.
///
///
/// Arguments for the string format operation
///
///
/// The localized message
///
public string GetPluralString (string singular, string defaultPlural, int n, params string[] args)
{
return string.Format (GetPluralString (singular, defaultPlural, n), args);
}
///
/// Gets a localized and formatted plural form for a message identifier
///
///
/// Message identifier for the singular form (can contain string format placeholders)
///
///
/// Default result message for the plural form (can contain string format placeholders)
///
///
/// Value count. Determines whether to use singular or plural form.
///
///
/// Arguments for the string format operation
///
///
/// The localized message
///
public string GetPluralString (string singular, string defaultPlural, int n, params object[] args)
{
return string.Format (GetPluralString (singular, defaultPlural, n), args);
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/ContentType.cs 0000664 0001750 0001750 00000003143 12136523632 024635 0 ustar 00directhex directhex 0000000 0000000 //
// ContentType.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (c) 2011 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
using System;
namespace Mono.Addins
{
///
/// Type of the content of a string extension node attribute
///
public enum ContentType
{
///
/// Plain text
///
Text,
///
/// A class name
///
Class,
///
/// A resource name
///
Resource,
///
/// A file name
///
File
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/TypeExtensionNode.cs 0000664 0001750 0001750 00000011152 12136523632 026004 0 ustar 00directhex directhex 0000000 0000000 //
// TypeExtensionNode.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Xml;
namespace Mono.Addins
{
///
/// An extension node which specifies a type.
///
///
/// This class is a kind of Mono.Addins.ExtensionNode which can be used to register
/// types in an extension point. This is a very common case: a host application
/// defines an interface, and add-ins create classes that implement that interface.
/// The host will define an extension point which will use TypeExtensionNode as node
/// type. Add-ins will register the classes they implement in that extension point.
///
/// When the nodes of an extension point are of type TypeExtensionNode it is then
/// possible to use query methods such as AddinManager.GetExtensionObjects(string),
/// which will get all nodes in the provided extension path and will create an object
/// for each node.
///
/// When declaring extension nodes in an add-in manifest, the class names can be
/// specified using the 'class' or 'type' attribute. If none of those attributes is
/// provided, the class name will be taken from the 'id' attribute.
///
/// TypeExtensionNode is the default extension type used when no type is provided
/// in the definition of an extension point.
///
[ExtensionNode ("Type", Description="Specifies a class that will be used to create an extension object.")]
[NodeAttribute ("class", typeof(Type), false, ContentType = ContentType.Class, Description="Name of the class. If a value is not provided, the class name will be taken from the 'id' attribute")]
public class TypeExtensionNode: InstanceExtensionNode
{
string typeName;
Type type;
///
/// Reads the extension node data
///
///
/// The element containing the extension data
///
///
/// This method can be overriden to provide a custom method for reading extension node data from an element.
/// The default implementation reads the attributes if the element and assigns the values to the fields
/// and properties of the extension node that have the corresponding [NodeAttribute] decoration.
///
internal protected override void Read (NodeElement elem)
{
base.Read (elem);
typeName = elem.GetAttribute ("type");
if (typeName.Length == 0)
typeName = elem.GetAttribute ("class");
if (typeName.Length == 0)
typeName = elem.GetAttribute ("id");
}
///
/// Creates a new extension object
///
///
/// The extension object
///
public override object CreateInstance ()
{
return Activator.CreateInstance (Type);
}
///
/// Type of the object that this node creates
///
public Type Type {
get {
if (type == null) {
if (typeName.Length == 0)
throw new InvalidOperationException ("Type name not specified.");
type = Addin.GetType (typeName, true);
}
return type;
}
}
}
///
/// An extension node which specifies a type with custom extension metadata
///
///
/// This is the default type for type extension nodes bound to a custom extension attribute.
///
public class TypeExtensionNode: TypeExtensionNode where T:CustomExtensionAttribute
{
T data;
///
/// The custom attribute containing the extension metadata
///
[NodeAttribute]
public T Data {
get { return data; }
internal set { data = value; }
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/ExtensionNodeAttribute.cs 0000664 0001750 0001750 00000006357 12136523632 027041 0 ustar 00directhex directhex 0000000 0000000 //
// ExtensionNodeAttribute.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
namespace Mono.Addins
{
///
/// This attribute can be applied to an ExtensionNode subclass to specify the default name and description.
///
///
/// This information will be used when an extension point does not define a name or description for a node type.
///
[AttributeUsage (AttributeTargets.Class)]
public class ExtensionNodeAttribute: Attribute
{
string nodeName;
string description;
string customAttributeTypeName;
Type customAttributeType;
///
/// Initializes the attribute
///
public ExtensionNodeAttribute ()
{
}
///
/// Initializes the attribute
///
///
/// Name of the node
///
public ExtensionNodeAttribute (string nodeName)
{
this.nodeName = nodeName;
}
///
/// Initializes the attribute
///
///
/// Name of the node
///
///
/// Description of the node
///
public ExtensionNodeAttribute (string nodeName, string description)
{
this.nodeName = nodeName;
this.description = description;
}
///
/// Default name of the extension node
///
public string NodeName {
get { return nodeName != null ? nodeName : string.Empty; }
set { nodeName = value; }
}
///
/// Default description of the extension node type
///
public string Description {
get { return description != null ? description : string.Empty; }
set { description = value; }
}
///
/// Type of a custom attribute which can be used to specify metadata for this extension node type
///
public Type ExtensionAttributeType {
get { return customAttributeType; }
set { customAttributeType = value; customAttributeTypeName = value.FullName; }
}
internal string ExtensionAttributeTypeName {
get { return customAttributeTypeName ?? string.Empty; }
set { customAttributeTypeName = value; }
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/ConditionType.cs 0000664 0001750 0001750 00000013471 12136523632 025156 0 ustar 00directhex directhex 0000000 0000000 //
// ConditionType.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Xml;
using Mono.Addins.Description;
using System.Collections;
namespace Mono.Addins
{
///
/// A condition evaluator.
///
///
/// Add-ins may use conditions to register nodes in an extension point which
/// are only visible under some contexts. For example, an add-in registering
/// a custom menu option to the main menu of a sample text editor might want
/// to make that option visible only for some kind of files. To allow add-ins
/// to do this kind of check, the host application needs to define a new condition.
///
public abstract class ConditionType
{
internal event EventHandler Changed;
string id;
///
/// Evaluates the condition.
///
///
/// Condition node information.
///
///
/// 'true' if the condition is satisfied.
///
public abstract bool Evaluate (NodeElement conditionNode);
///
/// Notifies that the condition has changed, and that it has to be re-evaluated.
///
/// This method must be called when there is a change in the state that determines
/// the result of the evaluation. When this method is called, all node conditions
/// depending on it are reevaluated and the corresponding events for adding or
/// removing extension nodes are fired.
///
///
public void NotifyChanged ()
{
if (Changed != null)
Changed (this, EventArgs.Empty);
}
internal string Id {
get { return id; }
set { id = value; }
}
}
internal class BaseCondition
{
BaseCondition parent;
internal BaseCondition (BaseCondition parent)
{
this.parent = parent;
}
public virtual bool Evaluate (ExtensionContext ctx)
{
return parent == null || parent.Evaluate (ctx);
}
internal virtual void GetConditionTypes (ArrayList listToFill)
{
}
}
internal class NullCondition: BaseCondition
{
public NullCondition (): base (null)
{
}
public override bool Evaluate (ExtensionContext ctx)
{
return false;
}
}
class OrCondition: BaseCondition
{
BaseCondition[] conditions;
public OrCondition (BaseCondition[] conditions, BaseCondition parent): base (parent)
{
this.conditions = conditions;
}
public override bool Evaluate (ExtensionContext ctx)
{
if (!base.Evaluate (ctx))
return false;
foreach (BaseCondition cond in conditions)
if (cond.Evaluate (ctx))
return true;
return false;
}
internal override void GetConditionTypes (ArrayList listToFill)
{
foreach (BaseCondition cond in conditions)
cond.GetConditionTypes (listToFill);
}
}
class AndCondition: BaseCondition
{
BaseCondition[] conditions;
public AndCondition (BaseCondition[] conditions, BaseCondition parent): base (parent)
{
this.conditions = conditions;
}
public override bool Evaluate (ExtensionContext ctx)
{
if (!base.Evaluate (ctx))
return false;
foreach (BaseCondition cond in conditions)
if (!cond.Evaluate (ctx))
return false;
return true;
}
internal override void GetConditionTypes (ArrayList listToFill)
{
foreach (BaseCondition cond in conditions)
cond.GetConditionTypes (listToFill);
}
}
class NotCondition: BaseCondition
{
BaseCondition baseCond;
public NotCondition (BaseCondition baseCond, BaseCondition parent): base (parent)
{
this.baseCond = baseCond;
}
public override bool Evaluate (ExtensionContext ctx)
{
return !base.Evaluate (ctx);
}
internal override void GetConditionTypes (System.Collections.ArrayList listToFill)
{
baseCond.GetConditionTypes (listToFill);
}
}
internal sealed class Condition: BaseCondition
{
ExtensionNodeDescription node;
string typeId;
AddinEngine addinEngine;
internal Condition (AddinEngine addinEngine, ExtensionNodeDescription element, BaseCondition parent): base (parent)
{
this.addinEngine = addinEngine;
typeId = element.GetAttribute ("id");
node = element;
}
public override bool Evaluate (ExtensionContext ctx)
{
if (!base.Evaluate (ctx))
return false;
ConditionType type = ctx.GetCondition (typeId);
if (type == null) {
addinEngine.ReportError ("Condition '" + typeId + "' not found in current extension context.", null, null, false);
return false;
}
try {
return type.Evaluate (node);
}
catch (Exception ex) {
addinEngine.ReportError ("Error while evaluating condition '" + typeId + "'", null, ex, false);
return false;
}
}
internal override void GetConditionTypes (ArrayList listToFill)
{
listToFill.Add (typeId);
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/AddinInfo.cs 0000664 0001750 0001750 00000012501 12136523632 024212 0 ustar 00directhex directhex 0000000 0000000 //
// AddinInfo.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.IO;
using System.Collections;
using System.Xml;
using System.Xml.Serialization;
using Mono.Addins.Description;
namespace Mono.Addins
{
internal class AddinInfo
{
string id = "";
string namspace = "";
string name = "";
string version = "";
string baseVersion = "";
string author = "";
string copyright = "";
string url = "";
string description = "";
string category = "";
bool defaultEnabled = true;
bool isroot;
DependencyCollection dependencies;
DependencyCollection optionalDependencies;
AddinPropertyCollection properties;
private AddinInfo ()
{
dependencies = new DependencyCollection ();
optionalDependencies = new DependencyCollection ();
}
public string Id {
get { return Addin.GetFullId (namspace, id, version); }
}
public string LocalId {
get { return id; }
set { id = value; }
}
public string Namespace {
get { return namspace; }
set { namspace = value; }
}
public bool IsRoot {
get { return isroot; }
set { isroot = value; }
}
public string Name {
get {
string s = Properties.GetPropertyValue ("Name");
if (s.Length > 0)
return s;
if (name != null && name.Length > 0)
return name;
string sid = id;
if (sid.StartsWith ("__"))
sid = sid.Substring (2);
return Addin.GetFullId (namspace, sid, null);
}
set { name = value; }
}
public string Version {
get { return version; }
set { version = value; }
}
public string BaseVersion {
get { return baseVersion; }
set { baseVersion = value; }
}
public string Author {
get {
string s = Properties.GetPropertyValue ("Author");
if (s.Length > 0)
return s;
return author;
}
set { author = value; }
}
public string Copyright {
get {
string s = Properties.GetPropertyValue ("Copyright");
if (s.Length > 0)
return s;
return copyright;
}
set { copyright = value; }
}
public string Url {
get {
string s = Properties.GetPropertyValue ("Url");
if (s.Length > 0)
return s;
return url;
}
set { url = value; }
}
public string Description {
get {
string s = Properties.GetPropertyValue ("Description");
if (s.Length > 0)
return s;
return description;
}
set { description = value; }
}
public string Category {
get {
string s = Properties.GetPropertyValue ("Category");
if (s.Length > 0)
return s;
return category;
}
set { category = value; }
}
public bool EnabledByDefault {
get { return defaultEnabled; }
set { defaultEnabled = value; }
}
public DependencyCollection Dependencies {
get { return dependencies; }
}
public DependencyCollection OptionalDependencies {
get { return optionalDependencies; }
}
public AddinPropertyCollection Properties {
get { return properties; }
}
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.isroot = description.IsRoot;
info.defaultEnabled = description.EnabledByDefault;
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);
}
info.properties = description.Properties;
return info;
}
public bool SupportsVersion (string version)
{
if (Addin.CompareVersions (Version, version) > 0)
return false;
if (baseVersion == "")
return true;
return Addin.CompareVersions (BaseVersion, version) >= 0;
}
public int CompareVersionTo (AddinInfo other)
{
return Addin.CompareVersions (this.version, other.Version);
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/AddinAttribute.cs 0000664 0001750 0001750 00000007367 12136523632 025300 0 ustar 00directhex directhex 0000000 0000000 //
// AddinAttribute.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using Mono.Addins.Description;
namespace Mono.Addins
{
///
/// Marks an assembly as being an add-in.
///
[AttributeUsage (AttributeTargets.Assembly)]
public class AddinAttribute: Attribute
{
string id;
string version;
string ns;
string category;
bool enabledByDefault = true;
AddinFlags flags;
string compatVersion;
string url;
///
/// Initializes an add-in marker attribute
///
public AddinAttribute ()
{
}
///
/// Initializes an add-in marker attribute
///
///
/// Identifier of the add-in
///
public AddinAttribute (string id)
{
this.id = id;
}
///
/// Initializes an add-in marker attribute
///
///
/// Identifier of the add-in
///
///
/// Version of the add-in
///
public AddinAttribute (string id, string version)
{
this.id = id;
this.version = version;
}
///
/// Identifier of the add-in.
///
public string Id {
get { return id != null ? id : string.Empty; }
set { id = value; }
}
///
/// Version of the add-in.
///
public string Version {
get { return version != null ? version : string.Empty; }
set { version = value; }
}
///
/// Version of the add-in with which this add-in is backwards compatible.
///
public string CompatVersion {
get { return compatVersion != null ? compatVersion : string.Empty; }
set { compatVersion = value; }
}
///
/// Namespace of the add-in
///
public string Namespace {
get { return ns != null ? ns : string.Empty; }
set { ns = value; }
}
///
/// Category of the add-in
///
public string Category {
get { return category != null ? category : string.Empty; }
set { category = value; }
}
///
/// Url to a web page with more information about the add-in
///
public string Url {
get { return url != null ? url : string.Empty; }
set { url = value; }
}
///
/// When set to True, the add-in will be automatically enabled after installing.
/// It's True by default.
///
public bool EnabledByDefault {
get { return this.enabledByDefault; }
set { this.enabledByDefault = value; }
}
///
/// Add-in flags
///
public AddinFlags Flags {
get { return this.flags; }
set { this.flags = value; }
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/AddinEventArgs.cs 0000664 0001750 0001750 00000003671 12136523632 025225 0 ustar 00directhex directhex 0000000 0000000 //
// AddinEventArgs.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
namespace Mono.Addins
{
///
/// Delegate to be used in add-in engine events
///
public delegate void AddinEventHandler (object sender, AddinEventArgs args);
///
/// Provides information about an add-in engine event.
///
public class AddinEventArgs: EventArgs
{
string addinId;
///
/// Initializes a new instance of the class.
///
///
/// Add-in identifier.
///
public AddinEventArgs (string addinId)
{
this.addinId = addinId;
}
///
/// Identifier of the add-in that generated the event.
///
public string AddinId {
get { return addinId; }
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/ExtensionTree.cs 0000664 0001750 0001750 00000026550 12136523632 025164 0 ustar 00directhex directhex 0000000 0000000 //
// ExtensionTree.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
using System.Reflection;
using System.Xml;
using Mono.Addins.Description;
using System.Collections.Generic;
namespace Mono.Addins
{
internal class ExtensionTree: TreeNode
{
int internalId;
internal const string AutoIdPrefix = "__nid_";
ExtensionContext context;
public ExtensionTree (AddinEngine addinEngine, ExtensionContext context): base (addinEngine, "")
{
this.context = context;
}
public override ExtensionContext Context {
get { return context; }
}
public void LoadExtension (string addin, Extension extension, ArrayList addedNodes)
{
TreeNode tnode = GetNode (extension.Path);
if (tnode == null) {
addinEngine.ReportError ("Can't load extensions for path '" + extension.Path + "'. Extension point not defined.", addin, null, false);
return;
}
int curPos = tnode.ChildCount;
LoadExtensionElement (tnode, addin, extension.ExtensionNodes, (ModuleDescription) extension.Parent, ref curPos, tnode.Condition, false, addedNodes);
}
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;
}
string after = elem.GetAttribute ("insertafter");
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) {
int i = tnode.Children.IndexOfNode (before);
if (i != -1)
curPos = i;
}
// 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 ();
}
BaseCondition ReadComplexCondition (ExtensionNodeDescription elem, BaseCondition parentCondition)
{
if (elem.NodeName == "Or" || elem.NodeName == "And" || elem.NodeName == "Not") {
ArrayList conds = new ArrayList ();
foreach (ExtensionNodeDescription celem in elem.ChildNodes) {
conds.Add (ReadComplexCondition (celem, null));
}
if (elem.NodeName == "Or")
return new OrCondition ((BaseCondition[]) conds.ToArray (typeof(BaseCondition)), parentCondition);
else if (elem.NodeName == "And")
return new AndCondition ((BaseCondition[]) conds.ToArray (typeof(BaseCondition)), parentCondition);
else {
if (conds.Count != 1) {
addinEngine.ReportError ("Invalid complex condition element '" + elem.NodeName + "'. 'Not' condition can only have one parameter.", null, null, false);
return new NullCondition ();
}
return new NotCondition ((BaseCondition) conds [0], parentCondition);
}
}
if (elem.NodeName == "Condition") {
return new Condition (AddinEngine, elem, parentCondition);
}
addinEngine.ReportError ("Invalid complex condition element '" + elem.NodeName + "'.", null, null, false);
return new NullCondition ();
}
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;
}
}
bool InitializeNodeType (ExtensionNodeType ntype)
{
RuntimeAddin p = addinEngine.GetAddin (ntype.AddinId);
if (p == null) {
if (!addinEngine.IsAddinLoaded (ntype.AddinId)) {
if (!addinEngine.LoadAddin (null, ntype.AddinId, false))
return false;
p = addinEngine.GetAddin (ntype.AddinId);
if (p == null) {
addinEngine.ReportError ("Add-in not found", ntype.AddinId, null, false);
return false;
}
}
}
// If no type name is provided, use TypeExtensionNode by default
if (ntype.TypeName == null || ntype.TypeName.Length == 0 || ntype.TypeName == typeof(TypeExtensionNode).FullName) {
// If it has a custom attribute, use the generic version of TypeExtensionNode
if (ntype.ExtensionAttributeTypeName.Length > 0) {
Type attType = p.GetType (ntype.ExtensionAttributeTypeName, false);
if (attType == null) {
addinEngine.ReportError ("Custom attribute type '" + ntype.ExtensionAttributeTypeName + "' not found.", ntype.AddinId, null, false);
return false;
}
if (ntype.ObjectTypeName.Length > 0)
ntype.Type = typeof(TypeExtensionNode<>).MakeGenericType (attType);
else
ntype.Type = typeof(ExtensionNode<>).MakeGenericType (attType);
} else {
ntype.Type = typeof(TypeExtensionNode);
return true;
}
}
else {
ntype.Type = p.GetType (ntype.TypeName, false);
if (ntype.Type == null) {
addinEngine.ReportError ("Extension node type '" + ntype.TypeName + "' not found.", ntype.AddinId, null, false);
return false;
}
}
// Check if the type has NodeAttribute attributes applied to fields.
ExtensionNodeType.FieldData boundAttributeType = null;
Dictionary fields = GetMembersMap (ntype.Type, out boundAttributeType);
ntype.CustomAttributeMember = boundAttributeType;
if (fields.Count > 0)
ntype.Fields = fields;
// If the node type is bound to a custom attribute and there is a member bound to that attribute,
// get the member map for the attribute.
if (boundAttributeType != null) {
if (ntype.ExtensionAttributeTypeName.Length == 0)
throw new InvalidOperationException ("Extension node not bound to a custom attribute.");
if (ntype.ExtensionAttributeTypeName != boundAttributeType.MemberType.FullName)
throw new InvalidOperationException ("Incorrect custom attribute type declaration in " + ntype.Type + ". Expected '" + ntype.ExtensionAttributeTypeName + "' found '" + boundAttributeType.MemberType.FullName + "'");
fields = GetMembersMap (boundAttributeType.MemberType, out boundAttributeType);
if (fields.Count > 0)
ntype.CustomAttributeFields = fields;
}
return true;
}
Dictionary GetMembersMap (Type type, out ExtensionNodeType.FieldData boundAttributeType)
{
string fname;
Dictionary fields = new Dictionary ();
boundAttributeType = null;
while (type != typeof(object) && type != null) {
foreach (FieldInfo field in type.GetFields (BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)) {
NodeAttributeAttribute at = (NodeAttributeAttribute) Attribute.GetCustomAttribute (field, typeof(NodeAttributeAttribute), true);
if (at != null) {
ExtensionNodeType.FieldData fd = CreateFieldData (field, at, out fname, ref boundAttributeType);
if (fd != null)
fields [fname] = fd;
}
}
foreach (PropertyInfo prop in type.GetProperties (BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)) {
NodeAttributeAttribute at = (NodeAttributeAttribute) Attribute.GetCustomAttribute (prop, typeof(NodeAttributeAttribute), true);
if (at != null) {
ExtensionNodeType.FieldData fd = CreateFieldData (prop, at, out fname, ref boundAttributeType);
if (fd != null)
fields [fname] = fd;
}
}
type = type.BaseType;
}
return fields;
}
ExtensionNodeType.FieldData CreateFieldData (MemberInfo member, NodeAttributeAttribute at, out string name, ref ExtensionNodeType.FieldData boundAttributeType)
{
ExtensionNodeType.FieldData fdata = new ExtensionNodeType.FieldData ();
fdata.Member = member;
fdata.Required = at.Required;
fdata.Localizable = at.Localizable;
if (at.Name != null && at.Name.Length > 0)
name = at.Name;
else
name = member.Name;
if (typeof(CustomExtensionAttribute).IsAssignableFrom (fdata.MemberType)) {
if (boundAttributeType != null)
throw new InvalidOperationException ("Type '" + member.DeclaringType + "' has two members bound to a custom attribute. There can be only one.");
boundAttributeType = fdata;
return null;
}
return fdata;
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/ExtensionNodeChildAttribute.cs 0000664 0001750 0001750 00000006255 12136523632 030002 0 ustar 00directhex directhex 0000000 0000000 //
// ExtensionNodeChildAttribute.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
namespace Mono.Addins
{
///
/// Declares allowed children of an extension node type.
///
///
/// This attribute allows declaring the type of children that an extension node can have.
///
[AttributeUsage (AttributeTargets.Class, AllowMultiple=true)]
public class ExtensionNodeChildAttribute: Attribute
{
string nodeName;
Type extensionNodeType;
string extensionNodeTypeName;
///
/// Initializes a new instance
///
///
/// Name of the allowed child extension node.
///
public ExtensionNodeChildAttribute (string nodeName)
: this (typeof(TypeExtensionNode), nodeName)
{
}
///
/// Initializes a new instance
///
///
/// Type of the allowed child extension node.
///
public ExtensionNodeChildAttribute (Type extensionNodeType)
: this (extensionNodeType, null)
{
}
///
/// Initializes a new instance
///
///
/// Type of the allowed child extension node.
///
///
/// Name of the allowed child extension node.
///
public ExtensionNodeChildAttribute (Type extensionNodeType, string nodeName)
{
ExtensionNodeType = extensionNodeType;
this.nodeName = nodeName;
}
///
/// Name of the allowed child extension node.
///
public string NodeName {
get { return nodeName != null ? nodeName : string.Empty; }
set { nodeName = value; }
}
///
/// Type of the allowed child extension node.
///
public Type ExtensionNodeType {
get { return extensionNodeType; }
set { extensionNodeType = value; extensionNodeTypeName = value.FullName; }
}
internal string ExtensionNodeTypeName {
get { return extensionNodeTypeName; }
set { extensionNodeTypeName = value; extensionNodeType = null; }
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/AddinAuthorAttribute.cs 0000664 0001750 0001750 00000003440 12136523632 026447 0 ustar 00directhex directhex 0000000 0000000 //
// AddinAuthorAttribute.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (c) 2010 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
using System;
namespace Mono.Addins
{
///
/// Declares an author of the add-in
///
[AttributeUsage (AttributeTargets.Assembly, AllowMultiple=true)]
public class AddinAuthorAttribute: Attribute
{
string name;
///
/// Initializes the attribute
///
///
/// Name of the author
///
public AddinAuthorAttribute (string name)
{
this.name = name;
}
///
/// Author name
///
public string Name {
get { return this.name; }
set { this.name = value; }
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/ExtensionAttributeAttribute.cs 0000664 0001750 0001750 00000007546 12136523632 030120 0 ustar 00directhex directhex 0000000 0000000 //
// ExtensionAttributeAttribute.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (c) 2010 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
using System;
namespace Mono.Addins
{
///
/// Assigns an attribute value to an extension
///
///
/// This attribute can be used together with the [Extenion] attribute to specify
/// a value for an attribute of the extension.
///
public class ExtensionAttributeAttribute: Attribute
{
Type targetType;
string targetTypeName;
string name;
string val;
string path;
///
/// Initializes a new instance of the class.
///
///
/// Name of the attribute
///
///
/// Value of the attribute
///
public ExtensionAttributeAttribute (string name, string value)
{
Name = name;
Value = value;
}
///
/// Initializes a new instance of the class.
///
///
/// Type of the extension for which the attribute value is being set
///
///
/// Name of the attribute
///
///
/// Value of the attribute
///
public ExtensionAttributeAttribute (Type type, string name, string value)
{
Name = name;
Value = value;
Type = type;
}
///
/// Initializes a new instance of the class.
///
///
/// Path of the extension for which the attribute value is being set
///
///
/// Name of the attribute
///
///
/// Value of the attribute
///
public ExtensionAttributeAttribute (string path, string name, string value)
{
Name = name;
Value = value;
Path = path;
}
///
/// Name of the attribute
///
public string Name {
get { return this.name; }
set { this.name = value; }
}
///
/// Value of the attribute
///
public string Value {
get { return this.val; }
set { this.val = value; }
}
///
/// Path of the extension for which the attribute value is being set
///
public string Path {
get { return this.path; }
set { this.path = value; }
}
///
/// Type of the extension for which the attribute value is being set
///
public Type Type {
get { return targetType; }
set { targetType = value; targetTypeName = targetType.FullName; }
}
internal string TypeName {
get { return targetTypeName ?? string.Empty; }
set { targetTypeName = value; }
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/AddinNameAttribute.cs 0000664 0001750 0001750 00000004437 12136523632 026074 0 ustar 00directhex directhex 0000000 0000000 //
// AddinNameAttribute.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (c) 2011 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
using System;
namespace Mono.Addins
{
///
/// Sets the display name of an add-in
///
[AttributeUsage (AttributeTargets.Assembly, AllowMultiple = true)]
public class AddinNameAttribute: Attribute
{
///
/// Initializes a new instance of the class.
///
///
/// Name of the add-in
///
public AddinNameAttribute (string name)
{
Name = name;
}
///
/// Initializes a new instance of the class.
///
///
/// Name of the add-in
///
///
/// Locale of the name (for example, 'en-US', or 'en')
///
public AddinNameAttribute (string name, string locale)
{
Name = name;
Locale = locale;
}
///
/// Name of the add-in
///
public string Name { get; set; }
///
/// Locale of the name (for example, 'en-US', or 'en')
///
public string Locale { get; set; }
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/ExtensionAttribute.cs 0000664 0001750 0001750 00000012605 12136523632 026224 0 ustar 00directhex directhex 0000000 0000000 //
// ExtensionAttribute.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
namespace Mono.Addins
{
///
/// Declares a type extension.
///
///
/// When applied to a class, specifies that the class is an extension
/// class to be registered in a matching extension point.
///
[AttributeUsage (AttributeTargets.Class, AllowMultiple=true)]
public class ExtensionAttribute: Attribute
{
string path;
string nodeName;
string id;
string insertBefore;
string insertAfter;
string typeName;
Type type;
///
/// Initializes a new instance of the ExtensionAttribute class.
///
public ExtensionAttribute ()
{
}
///
/// Initializes a new instance
///
///
/// Path of the extension point.
///
/// The path is only required if there are several extension points defined for the same type.
public ExtensionAttribute (string path)
{
this.path = path;
}
///
/// Initializes a new instance
///
///
/// Type defining the extension point being extended
///
///
/// This constructor can be used to explicitly specify the type that defines the extension point
/// to be extended. By default, Mono.Addins will try to find any extension point defined in any
/// of the base classes or interfaces. The type parameter can be used when there is more than one
/// base type providing an extension point.
///
public ExtensionAttribute (Type type)
{
Type = type;
}
///
/// Path of the extension point being extended
///
///
/// The path is only required if there are several extension points defined for the same type.
///
public string Path {
get { return path ?? string.Empty; }
set { path = value; }
}
///
/// Name of the extension node
///
///
/// Extension points may require extensions to use a specific node name.
/// This is needed when an extension point may contain several different types of nodes.
///
public string NodeName {
get { return !string.IsNullOrEmpty (nodeName) ? nodeName : "Type"; }
set { nodeName = value; }
}
///
/// Identifier of the extension node.
///
///
/// The ExtensionAttribute.InsertAfter and ExtensionAttribute.InsertBefore
/// properties can be used to specify the relative location of a node. The nodes
/// referenced in those properties must be defined either in the add-in host
/// being extended, or in any add-in on which this add-in depends.
///
public string Id {
get { return id ?? string.Empty; }
set { id = value; }
}
///
/// Identifier of the extension node before which this node has to be added in the extension point.
///
///
/// The ExtensionAttribute.InsertAfter and ExtensionAttribute.InsertBefore
/// properties can be used to specify the relative location of a node. The nodes
/// referenced in those properties must be defined either in the add-in host
/// being extended, or in any add-in on which this add-in depends.
///
public string InsertBefore {
get { return insertBefore ?? string.Empty; }
set { insertBefore = value; }
}
///
/// Identifier of the extension node after which this node has to be added in the extension point.
///
public string InsertAfter {
get { return insertAfter ?? string.Empty; }
set { insertAfter = value; }
}
///
/// Type defining the extension point being extended
///
///
/// This property can be used to explicitly specify the type that defines the extension point
/// to be extended. By default, Mono.Addins will try to find any extension point defined in any
/// of the base classes or interfaces. This property can be used when there is more than one
/// base type providing an extension point.
///
public Type Type {
get { return type; }
set { type = value; typeName = type.FullName; }
}
internal string TypeName {
get { return typeName ?? string.Empty; }
set { typeName = value; }
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/ExtensionContext.cs 0000664 0001750 0001750 00000122132 12136523632 025702 0 ustar 00directhex directhex 0000000 0000000 //
// ExtensionContext.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using Mono.Addins.Description;
namespace Mono.Addins
{
///
/// An extension context.
///
///
/// Extension contexts can be used to query the extension tree
/// using particular condition values. Extension points which
/// declare the availability of a condition type can only be
/// queryed using an extension context which provides an
/// evaluator for that condition.
///
public class ExtensionContext
{
Hashtable conditionTypes = new Hashtable ();
Hashtable conditionsToNodes = new Hashtable ();
List childContexts;
ExtensionContext parentContext;
ExtensionTree tree;
bool fireEvents = false;
ArrayList runTimeEnabledAddins;
ArrayList runTimeDisabledAddins;
///
/// Extension change event.
///
///
/// This event is fired when any extension point in the add-in system changes.
/// The event args object provides the path of the changed extension, although
/// it does not provide information about what changed. Hosts subscribing to
/// this event should get the new list of nodes using a query method such as
/// AddinManager.GetExtensionNodes() and then update whatever needs to be updated.
///
public event ExtensionEventHandler ExtensionChanged;
internal void Initialize (AddinEngine addinEngine)
{
fireEvents = false;
tree = new ExtensionTree (addinEngine, this);
}
#pragma warning disable 1591
[ObsoleteAttribute]
protected void Clear ()
{
}
#pragma warning restore 1591
internal void ClearContext ()
{
conditionTypes.Clear ();
conditionsToNodes.Clear ();
childContexts = null;
parentContext = null;
tree = null;
runTimeEnabledAddins = null;
runTimeDisabledAddins = null;
}
internal AddinEngine AddinEngine {
get { return tree.AddinEngine; }
}
void CleanDisposedChildContexts ()
{
if (childContexts != null)
childContexts.RemoveAll (w => w.Target == null);
}
internal virtual void ResetCachedData ()
{
tree.ResetCachedData ();
if (childContexts != null) {
foreach (WeakReference wref in childContexts) {
ExtensionContext ctx = wref.Target as ExtensionContext;
if (ctx != null)
ctx.ResetCachedData ();
}
}
}
internal ExtensionContext CreateChildContext ()
{
lock (conditionTypes) {
if (childContexts == null)
childContexts = new List ();
else
CleanDisposedChildContexts ();
ExtensionContext ctx = new ExtensionContext ();
ctx.Initialize (AddinEngine);
ctx.parentContext = this;
WeakReference wref = new WeakReference (ctx);
childContexts.Add (wref);
return ctx;
}
}
///
/// Registers a new condition in the extension context.
///
///
/// Identifier of the condition.
///
///
/// Condition evaluator.
///
///
/// The registered condition will be particular to this extension context.
/// Any event that might be fired as a result of changes in the condition will
/// only be fired in this context.
///
public void RegisterCondition (string id, ConditionType type)
{
type.Id = id;
ConditionInfo info = CreateConditionInfo (id);
ConditionType ot = info.CondType as ConditionType;
if (ot != null)
ot.Changed -= new EventHandler (OnConditionChanged);
info.CondType = type;
type.Changed += new EventHandler (OnConditionChanged);
}
///
/// Registers a new condition in the extension context.
///
///
/// Identifier of the condition.
///
///
/// Type of the condition evaluator. Must be a subclass of Mono.Addins.ConditionType.
///
///
/// The registered condition will be particular to this extension context. Any event
/// that might be fired as a result of changes in the condition will only be fired in this context.
///
public void RegisterCondition (string id, Type type)
{
// Allows delayed creation of condition types
ConditionInfo info = CreateConditionInfo (id);
ConditionType ot = info.CondType as ConditionType;
if (ot != null)
ot.Changed -= new EventHandler (OnConditionChanged);
info.CondType = type;
}
ConditionInfo CreateConditionInfo (string id)
{
ConditionInfo info = conditionTypes [id] as ConditionInfo;
if (info == null) {
info = new ConditionInfo ();
conditionTypes [id] = info;
}
return info;
}
internal bool FireEvents {
get { return fireEvents; }
}
internal ConditionType GetCondition (string id)
{
ConditionType ct;
ConditionInfo info = (ConditionInfo) conditionTypes [id];
if (info != null) {
if (info.CondType is Type) {
// The condition was registered as a type, create an instance now
ct = (ConditionType) Activator.CreateInstance ((Type)info.CondType);
ct.Id = id;
ct.Changed += new EventHandler (OnConditionChanged);
info.CondType = ct;
}
else
ct = info.CondType as ConditionType;
if (ct != null)
return ct;
}
if (parentContext != null)
return parentContext.GetCondition (id);
else
return null;
}
internal void RegisterNodeCondition (TreeNode node, BaseCondition cond)
{
ArrayList list = (ArrayList) conditionsToNodes [cond];
if (list == null) {
list = new ArrayList ();
conditionsToNodes [cond] = list;
ArrayList conditionTypeIds = new ArrayList ();
cond.GetConditionTypes (conditionTypeIds);
foreach (string cid in conditionTypeIds) {
// Make sure the condition is properly created
GetCondition (cid);
ConditionInfo info = CreateConditionInfo (cid);
if (info.BoundConditions == null)
info.BoundConditions = new ArrayList ();
info.BoundConditions.Add (cond);
}
}
list.Add (node);
}
internal void UnregisterNodeCondition (TreeNode node, BaseCondition cond)
{
ArrayList list = (ArrayList) conditionsToNodes [cond];
if (list == null)
return;
list.Remove (node);
if (list.Count == 0) {
conditionsToNodes.Remove (cond);
ArrayList conditionTypeIds = new ArrayList ();
cond.GetConditionTypes (conditionTypeIds);
foreach (string cid in conditionTypes.Keys) {
ConditionInfo info = conditionTypes [cid] as ConditionInfo;
if (info != null && info.BoundConditions != null)
info.BoundConditions.Remove (cond);
}
}
}
///
/// Returns the extension node in a path
///
///
/// Location of the node.
///
///
/// The node, or null if not found.
///
public ExtensionNode GetExtensionNode (string path)
{
TreeNode node = GetNode (path);
if (node == null)
return null;
if (node.Condition == null || node.Condition.Evaluate (this))
return node.ExtensionNode;
else
return null;
}
///
/// Returns the extension node in a path
///
///
/// Location of the node.
///
///
/// The node, or null if not found.
///
public T GetExtensionNode (string path) where T: ExtensionNode
{
return (T) GetExtensionNode (path);
}
///
/// Gets extension nodes registered in a path.
///
///
/// An extension path.>
///
///
/// All nodes registered in the provided path.
///
public ExtensionNodeList GetExtensionNodes (string path)
{
return GetExtensionNodes (path, null);
}
///
/// Gets extension nodes registered in a path.
///
///
/// An extension path.
///
///
/// A list of nodes
///
///
/// This method returns all nodes registered under the provided path.
/// It will throw a InvalidOperationException if the type of one of
/// the registered nodes is not assignable to the provided type.
///
public ExtensionNodeList GetExtensionNodes (string path) where T: ExtensionNode
{
ExtensionNodeList nodes = GetExtensionNodes (path, typeof(T));
return new ExtensionNodeList (nodes.list);
}
///
/// Gets extension nodes for a type extension point
///
///
/// Type defining the extension point
///
///
/// A list of nodes
///
///
/// This method returns all extension nodes bound to the provided type.
///
public ExtensionNodeList GetExtensionNodes (Type instanceType)
{
return GetExtensionNodes (instanceType, typeof(ExtensionNode));
}
///
/// Gets extension nodes for a type extension point
///
///
/// Type defining the extension point
///
///
/// Expected extension node type
///
///
/// A list of nodes
///
///
/// This method returns all nodes registered for the provided type.
/// It will throw a InvalidOperationException if the type of one of
/// the registered nodes is not assignable to the provided node type.
///
public ExtensionNodeList GetExtensionNodes (Type instanceType, Type expectedNodeType)
{
string path = AddinEngine.GetAutoTypeExtensionPoint (instanceType);
if (path == null)
return new ExtensionNodeList (null);
return GetExtensionNodes (path, expectedNodeType);
}
///
/// Gets extension nodes for a type extension point
///
///
/// Type defining the extension point
///
///
/// A list of nodes
///
///
/// This method returns all nodes registered for the provided type.
/// It will throw a InvalidOperationException if the type of one of
/// the registered nodes is not assignable to the specified node type argument.
///
public ExtensionNodeList GetExtensionNodes (Type instanceType) where T: ExtensionNode
{
string path = AddinEngine.GetAutoTypeExtensionPoint (instanceType);
if (path == null)
return new ExtensionNodeList (null);
return new ExtensionNodeList (GetExtensionNodes (path, typeof (T)).list);
}
///
/// Gets extension nodes registered in a path.
///
///
/// An extension path.
///
///
/// Expected node type.
///
///
/// A list of nodes
///
///
/// This method returns all nodes registered under the provided path.
/// It will throw a InvalidOperationException if the type of one of
/// the registered nodes is not assignable to the provided type.
///
public ExtensionNodeList GetExtensionNodes (string path, Type expectedNodeType)
{
TreeNode node = GetNode (path);
if (node == null || node.ExtensionNode == null)
return ExtensionNodeList.Empty;
ExtensionNodeList list = node.ExtensionNode.ChildNodes;
if (expectedNodeType != null) {
bool foundError = false;
foreach (ExtensionNode cnode in list) {
if (!expectedNodeType.IsInstanceOfType (cnode)) {
foundError = true;
AddinEngine.ReportError ("Error while getting nodes for path '" + path + "'. Expected subclass of node type '" + expectedNodeType + "'. Found '" + cnode.GetType (), null, null, false);
}
}
if (foundError) {
// Create a new list excluding the elements that failed the test
List newList = new List ();
foreach (ExtensionNode cnode in list) {
if (expectedNodeType.IsInstanceOfType (cnode))
newList.Add (cnode);
}
return new ExtensionNodeList (newList);
}
}
return list;
}
///
/// Gets extension objects registered for a type extension point.
///
///
/// Type defining the extension point
///
///
/// A list of objects
///
public object[] GetExtensionObjects (Type instanceType)
{
return GetExtensionObjects (instanceType, true);
}
///
/// Gets extension objects registered for a type extension point.
///
///
/// A list of objects
///
///
/// The type argument of this generic method is the type that defines
/// the extension point.
///
public T[] GetExtensionObjects ()
{
return GetExtensionObjects (true);
}
///
/// Gets extension objects registered for a type extension point.
///
///
/// Type defining the extension point
///
///
/// When set to True, it will return instances created in previous calls.
///
///
/// A list of extension objects.
///
public object[] GetExtensionObjects (Type instanceType, bool reuseCachedInstance)
{
string path = AddinEngine.GetAutoTypeExtensionPoint (instanceType);
if (path == null)
return (object[]) Array.CreateInstance (instanceType, 0);
return GetExtensionObjects (path, instanceType, reuseCachedInstance);
}
///
/// Gets extension objects registered for a type extension point.
///
///
/// When set to True, it will return instances created in previous calls.
///
///
/// A list of extension objects.
///
///
/// The type argument of this generic method is the type that defines
/// the extension point.
///
public T[] GetExtensionObjects (bool reuseCachedInstance)
{
string path = AddinEngine.GetAutoTypeExtensionPoint (typeof(T));
if (path == null)
return new T[0];
return GetExtensionObjects (path, reuseCachedInstance);
}
///
/// Gets extension objects registered in a path
///
///
/// An extension path.
///
///
/// An array of objects registered in the path.
///
///
/// This method can only be used if all nodes in the provided extension path
/// are of type Mono.Addins.TypeExtensionNode. The returned array is composed
/// by all objects created by calling the TypeExtensionNode.CreateInstance()
/// method for each node.
///
public object[] GetExtensionObjects (string path)
{
return GetExtensionObjects (path, typeof(object), true);
}
///
/// Gets extension objects registered in a path.
///
///
/// An extension path.
///
///
/// When set to True, it will return instances created in previous calls.
///
///
/// An array of objects registered in the path.
///
///
/// This method can only be used if all nodes in the provided extension path
/// are of type Mono.Addins.TypeExtensionNode. The returned array is composed
/// by all objects created by calling the TypeExtensionNode.CreateInstance()
/// method for each node (or TypeExtensionNode.GetInstance() if
/// reuseCachedInstance is set to true)
///
public object[] GetExtensionObjects (string path, bool reuseCachedInstance)
{
return GetExtensionObjects (path, typeof(object), reuseCachedInstance);
}
///
/// Gets extension objects registered in a path.
///
///
/// An extension path.
///
///
/// Type of the return array elements.
///
///
/// An array of objects registered in the path.
///
///
/// This method can only be used if all nodes in the provided extension path
/// are of type Mono.Addins.TypeExtensionNode. The returned array is composed
/// by all objects created by calling the TypeExtensionNode.CreateInstance()
/// method for each node.
///
/// An InvalidOperationException exception is thrown if one of the found
/// objects is not a subclass of the provided type.
///
public object[] GetExtensionObjects (string path, Type arrayElementType)
{
return GetExtensionObjects (path, arrayElementType, true);
}
///
/// Gets extension objects registered in a path.
///
///
/// An extension path.
///
///
/// An array of objects registered in the path.
///
///
/// This method can only be used if all nodes in the provided extension path
/// are of type Mono.Addins.TypeExtensionNode. The returned array is composed
/// by all objects created by calling the TypeExtensionNode.CreateInstance()
/// method for each node.
///
/// An InvalidOperationException exception is thrown if one of the found
/// objects is not a subclass of the provided type.
///
public T[] GetExtensionObjects (string path)
{
return GetExtensionObjects (path, true);
}
///
/// Gets extension objects registered in a path.
///
///
/// An extension path.
///
///
/// When set to True, it will return instances created in previous calls.
///
///
/// An array of objects registered in the path.
///
///
/// This method can only be used if all nodes in the provided extension path
/// are of type Mono.Addins.TypeExtensionNode. The returned array is composed
/// by all objects created by calling the TypeExtensionNode.CreateInstance()
/// method for each node (or TypeExtensionNode.GetInstance() if
/// reuseCachedInstance is set to true).
///
/// An InvalidOperationException exception is thrown if one of the found
/// objects is not a subclass of the provided type.
///
public T[] GetExtensionObjects (string path, bool reuseCachedInstance)
{
ExtensionNode node = GetExtensionNode (path);
if (node == null)
throw new InvalidOperationException ("Extension node not found in path: " + path);
return node.GetChildObjects (reuseCachedInstance);
}
///
/// Gets extension objects registered in a path.
///
///
/// An extension path.
///
///
/// Type of the return array elements.
///
///
/// When set to True, it will return instances created in previous calls.
///
///
/// An array of objects registered in the path.
///
///
/// This method can only be used if all nodes in the provided extension path
/// are of type Mono.Addins.TypeExtensionNode. The returned array is composed
/// by all objects created by calling the TypeExtensionNode.CreateInstance()
/// method for each node (or TypeExtensionNode.GetInstance() if
/// reuseCachedInstance is set to true).
///
/// An InvalidOperationException exception is thrown if one of the found
/// objects is not a subclass of the provided type.
///
public object[] GetExtensionObjects (string path, Type arrayElementType, bool reuseCachedInstance)
{
ExtensionNode node = GetExtensionNode (path);
if (node == null)
throw new InvalidOperationException ("Extension node not found in path: " + path);
return node.GetChildObjects (arrayElementType, reuseCachedInstance);
}
///
/// Register a listener of extension node changes.
///
///
/// Path of the node.
///
///
/// A handler method.
///
///
/// Hosts can call this method to be subscribed to an extension change
/// event for a specific path. The event will be fired once for every
/// individual node change. The event arguments include the change type
/// (Add or Remove) and the extension node added or removed.
///
/// NOTE: The handler will be called for all nodes existing in the path at the moment of registration.
///
public void AddExtensionNodeHandler (string path, ExtensionNodeEventHandler handler)
{
ExtensionNode node = GetExtensionNode (path);
if (node == null)
throw new InvalidOperationException ("Extension node not found in path: " + path);
node.ExtensionNodeChanged += handler;
}
///
/// Unregister a listener of extension node changes.
///
///
/// Path of the node.
///
///
/// A handler method.
///
///
/// This method unregisters a delegate from the node change event of a path.
///
public void RemoveExtensionNodeHandler (string path, ExtensionNodeEventHandler handler)
{
ExtensionNode node = GetExtensionNode (path);
if (node == null)
throw new InvalidOperationException ("Extension node not found in path: " + path);
node.ExtensionNodeChanged -= handler;
}
///
/// Register a listener of extension node changes.
///
///
/// Type defining the extension point
///
///
/// A handler method.
///
///
/// Hosts can call this method to be subscribed to an extension change
/// event for a specific type extension point. The event will be fired once for every
/// individual node change. The event arguments include the change type
/// (Add or Remove) and the extension node added or removed.
///
/// NOTE: The handler will be called for all nodes existing in the path at the moment of registration.
///
public void AddExtensionNodeHandler (Type instanceType, ExtensionNodeEventHandler handler)
{
string path = AddinEngine.GetAutoTypeExtensionPoint (instanceType);
if (path == null)
throw new InvalidOperationException ("Type '" + instanceType + "' not bound to an extension point.");
AddExtensionNodeHandler (path, handler);
}
///
/// Unregister a listener of extension node changes.
///
///
/// Type defining the extension point
///
///
/// A handler method.
///
public void RemoveExtensionNodeHandler (Type instanceType, ExtensionNodeEventHandler handler)
{
string path = AddinEngine.GetAutoTypeExtensionPoint (instanceType);
if (path == null)
throw new InvalidOperationException ("Type '" + instanceType + "' not bound to an extension point.");
RemoveExtensionNodeHandler (path, handler);
}
void OnConditionChanged (object s, EventArgs a)
{
ConditionType cond = (ConditionType) s;
NotifyConditionChanged (cond);
}
internal void NotifyConditionChanged (ConditionType cond)
{
try {
fireEvents = true;
ConditionInfo info = (ConditionInfo) conditionTypes [cond.Id];
if (info != null && info.BoundConditions != null) {
Hashtable parentsToNotify = new Hashtable ();
foreach (BaseCondition c in info.BoundConditions) {
ArrayList nodeList = (ArrayList) conditionsToNodes [c];
if (nodeList != null) {
foreach (TreeNode node in nodeList)
parentsToNotify [node.Parent] = null;
}
}
foreach (TreeNode node in parentsToNotify.Keys) {
if (node.NotifyChildrenChanged ())
NotifyExtensionsChanged (new ExtensionEventArgs (node.GetPath ()));
}
}
}
finally {
fireEvents = false;
}
// Notify child contexts
lock (conditionTypes) {
if (childContexts != null) {
CleanDisposedChildContexts ();
foreach (WeakReference wref in childContexts) {
ExtensionContext ctx = wref.Target as ExtensionContext;
if (ctx != null)
ctx.NotifyConditionChanged (cond);
}
}
}
}
internal void NotifyExtensionsChanged (ExtensionEventArgs args)
{
if (!fireEvents)
return;
if (ExtensionChanged != null)
ExtensionChanged (this, args);
}
internal void NotifyAddinLoaded (RuntimeAddin ad)
{
tree.NotifyAddinLoaded (ad, true);
lock (conditionTypes) {
if (childContexts != null) {
CleanDisposedChildContexts ();
foreach (WeakReference wref in childContexts) {
ExtensionContext ctx = wref.Target as ExtensionContext;
if (ctx != null)
ctx.NotifyAddinLoaded (ad);
}
}
}
}
internal void CreateExtensionPoint (ExtensionPoint ep)
{
TreeNode node = tree.GetNode (ep.Path, true);
if (node.ExtensionPoint == null) {
node.ExtensionPoint = ep;
node.ExtensionNodeSet = ep.NodeSet;
}
}
internal void ActivateAddinExtensions (string id)
{
// Looks for loaded extension points which are extended by the provided
// add-in, and adds the new nodes
try {
fireEvents = true;
Addin addin = AddinEngine.Registry.GetAddin (id);
if (addin == null) {
AddinEngine.ReportError ("Required add-in not found", id, null, false);
return;
}
// Take note that this add-in has been enabled at run-time
// Needed because loaded add-in descriptions may not include this add-in.
RegisterRuntimeEnabledAddin (id);
// Look for loaded extension points
Hashtable eps = new Hashtable ();
ArrayList newExtensions = new ArrayList ();
foreach (ModuleDescription mod in addin.Description.AllModules) {
foreach (Extension ext in mod.Extensions) {
if (!newExtensions.Contains (ext.Path))
newExtensions.Add (ext.Path);
ExtensionPoint ep = tree.FindLoadedExtensionPoint (ext.Path);
if (ep != null && !eps.Contains (ep))
eps.Add (ep, ep);
}
}
// Add the new nodes
ArrayList loadedNodes = new ArrayList ();
foreach (ExtensionPoint ep in eps.Keys) {
ExtensionLoadData data = GetAddinExtensions (id, ep);
if (data != null) {
foreach (Extension ext in data.Extensions) {
TreeNode node = GetNode (ext.Path);
if (node != null && node.ExtensionNodeSet != null) {
if (node.ChildrenLoaded)
LoadModuleExtensionNodes (ext, data.AddinId, node.ExtensionNodeSet, loadedNodes);
}
else
AddinEngine.ReportError ("Extension node not found or not extensible: " + ext.Path, id, null, false);
}
}
}
// Call the OnAddinLoaded method on nodes, if the add-in is already loaded
foreach (TreeNode nod in loadedNodes)
nod.ExtensionNode.OnAddinLoaded ();
// Global extension change event. Other events are fired by LoadModuleExtensionNodes.
// The event is called for all extensions, even for those not loaded. This is for coherence,
// although that something that it doesn't make much sense to do (subcribing the ExtensionChanged
// event without first getting the list of nodes that may change).
foreach (string newExt in newExtensions)
NotifyExtensionsChanged (new ExtensionEventArgs (newExt));
}
finally {
fireEvents = false;
}
// Do the same in child contexts
lock (conditionTypes) {
if (childContexts != null) {
CleanDisposedChildContexts ();
foreach (WeakReference wref in childContexts) {
ExtensionContext ctx = wref.Target as ExtensionContext;
if (ctx != null)
ctx.ActivateAddinExtensions (id);
}
}
}
}
internal void RemoveAddinExtensions (string id)
{
try {
// Registers this add-in as disabled, so from now on extension from this
// add-in will be ignored
RegisterRuntimeDisabledAddin (id);
fireEvents = true;
// This method removes all extension nodes added by the add-in
// Get all nodes created by the addin
ArrayList list = new ArrayList ();
tree.FindAddinNodes (id, list);
// Remove each node and notify the change
foreach (TreeNode node in list) {
if (node.ExtensionNode == null) {
// It's an extension point. Just remove it, no notifications are needed
node.Remove ();
}
else {
node.ExtensionNode.OnAddinUnloaded ();
node.Remove ();
}
}
// Notify global extension point changes.
// The event is called for all extensions, even for those not loaded. This is for coherence,
// although that something that it doesn't make much sense to do (subcribing the ExtensionChanged
// event without first getting the list of nodes that may change).
// We get the runtime add-in because the add-in may already have been deleted from the registry
RuntimeAddin addin = AddinEngine.GetAddin (id);
if (addin != null) {
ArrayList paths = new ArrayList ();
// Using addin.Module.ParentAddinDescription here because addin.Addin.Description may not
// have a valid reference (the description is lazy loaded and may already have been removed from the registry)
foreach (ModuleDescription mod in addin.Module.ParentAddinDescription.AllModules) {
foreach (Extension ext in mod.Extensions) {
if (!paths.Contains (ext.Path))
paths.Add (ext.Path);
}
}
foreach (string path in paths)
NotifyExtensionsChanged (new ExtensionEventArgs (path));
}
} finally {
fireEvents = false;
}
}
void RegisterRuntimeDisabledAddin (string addinId)
{
if (runTimeDisabledAddins == null)
runTimeDisabledAddins = new ArrayList ();
if (!runTimeDisabledAddins.Contains (addinId))
runTimeDisabledAddins.Add (addinId);
if (runTimeEnabledAddins != null)
runTimeEnabledAddins.Remove (addinId);
}
void RegisterRuntimeEnabledAddin (string addinId)
{
if (runTimeEnabledAddins == null)
runTimeEnabledAddins = new ArrayList ();
if (!runTimeEnabledAddins.Contains (addinId))
runTimeEnabledAddins.Add (addinId);
if (runTimeDisabledAddins != null)
runTimeDisabledAddins.Remove (addinId);
}
internal ICollection GetAddinsForPath (string path, List col)
{
ArrayList newlist = null;
// Always consider add-ins which have been enabled at runtime since
// they may contain extensioin for this path.
// Ignore addins disabled at run-time.
if (runTimeEnabledAddins != null && runTimeEnabledAddins.Count > 0) {
newlist = new ArrayList ();
newlist.AddRange (col);
foreach (string s in runTimeEnabledAddins)
if (!newlist.Contains (s))
newlist.Add (s);
}
if (runTimeDisabledAddins != null && runTimeDisabledAddins.Count > 0) {
if (newlist == null) {
newlist = new ArrayList ();
newlist.AddRange (col);
}
foreach (string s in runTimeDisabledAddins)
newlist.Remove (s);
}
return newlist != null ? (ICollection)newlist : (ICollection)col;
}
// Load the extension nodes at the specified path. If the path
// contains extension nodes implemented in an add-in which is
// not loaded, the add-in will be automatically loaded
internal void LoadExtensions (string requestedExtensionPath)
{
TreeNode node = GetNode (requestedExtensionPath);
if (node == null)
throw new InvalidOperationException ("Extension point not defined: " + requestedExtensionPath);
ExtensionPoint ep = node.ExtensionPoint;
if (ep != null) {
// Collect extensions to be loaded from add-ins. Before loading the extensions,
// they must be sorted, that's why loading is split in two steps (collecting + loading).
ArrayList loadData = new ArrayList ();
foreach (string addin in GetAddinsForPath (ep.Path, ep.Addins)) {
ExtensionLoadData ed = GetAddinExtensions (addin, ep);
if (ed != null) {
// Insert the addin data taking into account dependencies.
// An add-in must be processed after all its dependencies.
bool added = false;
for (int n=0; n
/// Delegate to be used in extension point subscriptions
///
public delegate void ExtensionEventHandler (object sender, ExtensionEventArgs args);
///
/// Delegate to be used in extension point subscriptions
///
public delegate void ExtensionNodeEventHandler (object sender, ExtensionNodeEventArgs args);
///
/// Arguments for extension events.
///
public class ExtensionEventArgs: EventArgs
{
string path;
internal ExtensionEventArgs ()
{
}
///
/// Creates a new instance.
///
///
/// Path of the extension node that has changed.
///
public ExtensionEventArgs (string path)
{
this.path = path;
}
///
/// Path of the extension node that has changed.
///
public virtual string Path {
get { return path; }
}
///
/// Checks if a path has changed.
///
///
/// An extension path.
///
///
/// 'true' if the path is affected by the extension change event.
///
///
/// Checks if the specified path or any of its children paths is affected by the extension change event.
///
public bool PathChanged (string pathToCheck)
{
if (pathToCheck.EndsWith ("/"))
return path.StartsWith (pathToCheck);
else
return path.StartsWith (pathToCheck) && (pathToCheck.Length == path.Length || path [pathToCheck.Length] == '/');
}
}
///
/// Arguments for extension node events.
///
public class ExtensionNodeEventArgs: ExtensionEventArgs
{
ExtensionNode node;
ExtensionChange change;
///
/// Creates a new instance
///
///
/// Type of change.
///
///
/// Node that has been added or removed.
///
public ExtensionNodeEventArgs (ExtensionChange change, ExtensionNode node)
{
this.node = node;
this.change = change;
}
///
/// Path of the extension that changed.
///
public override string Path {
get { return node.Path; }
}
///
/// Type of change.
///
public ExtensionChange Change {
get { return change; }
}
///
/// Node that has been added or removed.
///
public ExtensionNode ExtensionNode {
get { return node; }
}
///
/// Extension object that has been added or removed.
///
public object ExtensionObject {
get {
InstanceExtensionNode tnode = node as InstanceExtensionNode;
if (tnode == null)
throw new InvalidOperationException ("Node is not an InstanceExtensionNode");
return tnode.GetInstance ();
}
}
}
///
/// Type of change in an extension change event.
///
public enum ExtensionChange
{
///
/// An extension node has been added.
///
Add,
///
/// An extension node has been removed.
///
Remove
}
internal class ExtensionLoadData
{
public string AddinId;
public ArrayList Extensions;
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/CustomExtensionAttribute.cs 0000664 0001750 0001750 00000005346 12136523632 027423 0 ustar 00directhex directhex 0000000 0000000 //
// CustomExtensionAttribute.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (c) 2010 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
using System;
namespace Mono.Addins
{
///
/// Base class for custon extension attributes.
///
///
/// Custom extension attributes can be used to declare extensions with custom metadata.
/// All custom extension attributes must subclass CustomExtensionAttribute.
///
public class CustomExtensionAttribute: Attribute
{
string id;
string insertBefore;
string insertAfter;
string path;
internal const string PathFieldKey = "__path";
///
/// Identifier of the node
///
[NodeAttributeAttribute ("id")]
public string Id {
get { return id; }
set { id = value; }
}
///
/// Identifier of the node before which this node has to be placed
///
[NodeAttributeAttribute ("insertbefore")]
public string InsertBefore {
get { return insertBefore; }
set { insertBefore = value; }
}
///
/// Identifier of the node after which this node has to be placed
///
[NodeAttributeAttribute ("insertafter")]
public string InsertAfter {
get { return insertAfter; }
set { insertAfter = value; }
}
///
/// Path of the extension point being extended.
///
///
/// This property is optional and useful only when there are several extension points which allow
/// using this custom attribute to define extensions.
///
[NodeAttributeAttribute ("__path")]
public string Path {
get { return path; }
set { path = value; }
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/AddinModuleAttribute.cs 0000664 0001750 0001750 00000003627 12136523632 026441 0 ustar 00directhex directhex 0000000 0000000 //
// AddinModuleAttribute.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (c) 2010 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
using System;
namespace Mono.Addins
{
///
/// Declares an optional add-in module
///
public class AddinModuleAttribute: Attribute
{
string assemblyFile;
///
/// Initializes the instance.
///
///
/// Relative path to the assembly that implements the optional module
///
public AddinModuleAttribute (string assemblyFile)
{
this.assemblyFile = assemblyFile;
}
///
/// Relative path to the assembly that implements the optional module
///
public string AssemblyFile {
get { return this.assemblyFile ?? string.Empty; }
set { this.assemblyFile = value; }
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/AddinEngine.cs 0000775 0001750 0001750 00000054630 12136524015 024534 0 ustar 00directhex directhex 0000000 0000000 //
// AddinService.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Linq;
using System.Xml;
using System.Collections;
using System.Reflection;
using Mono.Addins.Description;
using Mono.Addins.Database;
using Mono.Addins.Localization;
using System.Collections.Generic;
namespace Mono.Addins
{
///
/// An add-in engine.
///
///
/// This class allows hosting several independent add-in engines in a single application domain.
/// In general, applications use the AddinManager class to query and manage extensions. This class is static,
/// so the API is easily accessible. However, some kind applications may need to use several isolated
/// add-in engines, and in this case the AddinManager class can't be used, because it is bound to a single
/// add-in engine. Those applications can instead create several instances of the AddinEngine class. Each
/// add-in engine can be independently initialized with different add-in registries and extension models.
///
public class AddinEngine: ExtensionContext
{
bool initialized;
string startupDirectory;
AddinRegistry registry;
IAddinInstaller installer;
bool checkAssemblyLoadConflicts;
Hashtable loadedAddins = new Hashtable ();
Dictionary nodeSets = new Dictionary ();
Hashtable autoExtensionTypes = new Hashtable ();
Hashtable loadedAssemblies = new Hashtable ();
AddinLocalizer defaultLocalizer;
IProgressStatus defaultProgressStatus = new ConsoleProgressStatus (false);
///
/// Raised when there is an error while loading an add-in
///
public static event AddinErrorEventHandler AddinLoadError;
///
/// Raised when an add-in is loaded
///
public static event AddinEventHandler AddinLoaded;
///
/// Raised when an add-in is unloaded
///
public static event AddinEventHandler AddinUnloaded;
///
/// Initializes a new instance of the class.
///
public AddinEngine ()
{
}
///
/// Initializes the add-in engine
///
///
/// Location of the add-in registry.
///
/// The add-in engine needs to be initialized before doing any add-in operation.
/// When initialized with this method, it will look for add-in in the add-in registry
/// located in the specified path.
///
public void Initialize (string configDir)
{
if (initialized)
return;
Assembly asm = Assembly.GetEntryAssembly ();
if (asm == null) asm = Assembly.GetCallingAssembly ();
Initialize (asm, configDir, null, null);
}
///
/// Initializes the add-in engine.
///
///
/// Location of the add-in registry.
///
///
/// Add-ins directory. If the path is relative, it is considered to be relative
/// to the configDir directory.
///
///
/// The add-in engine needs to be initialized before doing any add-in operation.
/// Configuration information about the add-in registry will be stored in the
/// provided location. The add-in engine will look for add-ins in the provided
/// 'addinsDir' directory.
///
/// When specifying a path, it is possible to use a special folder name as root.
/// For example: [Personal]/.config/MyApp. In this case, [Personal] will be replaced
/// by the location of the Environment.SpecialFolder.Personal folder. Any value
/// of the Environment.SpecialFolder enumeration can be used (always between square
/// brackets)
///
public void Initialize (string configDir, string addinsDir)
{
if (initialized)
return;
Assembly asm = Assembly.GetEntryAssembly ();
if (asm == null) asm = Assembly.GetCallingAssembly ();
Initialize (asm, configDir, addinsDir, null);
}
///
/// Initializes the add-in engine.
///
///
/// Location of the add-in registry.
///
///
/// Add-ins directory. If the path is relative, it is considered to be relative
/// to the configDir directory.
///
///
/// Location of the add-in database. If the path is relative, it is considered to be relative
/// to the configDir directory.
///
///
/// The add-in engine needs to be initialized before doing any add-in operation.
/// Configuration information about the add-in registry will be stored in the
/// provided location. The add-in engine will look for add-ins in the provided
/// 'addinsDir' directory. Cached information about add-ins will be stored in
/// the 'databaseDir' directory.
///
/// When specifying a path, it is possible to use a special folder name as root.
/// For example: [Personal]/.config/MyApp. In this case, [Personal] will be replaced
/// by the location of the Environment.SpecialFolder.Personal folder. Any value
/// of the Environment.SpecialFolder enumeration can be used (always between square
/// brackets)
///
public void Initialize (string configDir, string addinsDir, string databaseDir)
{
if (initialized)
return;
Assembly asm = Assembly.GetEntryAssembly ();
if (asm == null) asm = Assembly.GetCallingAssembly ();
Initialize (asm, configDir, addinsDir, databaseDir);
}
internal void Initialize (Assembly startupAsm, string configDir, string addinsDir, string databaseDir)
{
if (initialized)
return;
Initialize (this);
string asmFile = new Uri (startupAsm.CodeBase).LocalPath;
startupDirectory = System.IO.Path.GetDirectoryName (asmFile);
string customDir = Environment.GetEnvironmentVariable ("MONO_ADDINS_REGISTRY");
if (customDir != null && customDir.Length > 0)
configDir = customDir;
if (configDir == null || configDir.Length == 0)
registry = AddinRegistry.GetGlobalRegistry (this, startupDirectory);
else
registry = new AddinRegistry (this, configDir, startupDirectory, addinsDir, databaseDir);
if (registry.CreateHostAddinsFile (asmFile) || registry.UnknownDomain)
registry.Update (new ConsoleProgressStatus (false));
initialized = true;
ActivateRoots ();
OnAssemblyLoaded (null, null);
AppDomain.CurrentDomain.AssemblyLoad += new AssemblyLoadEventHandler (OnAssemblyLoaded);
}
///
/// Finalizes the add-in engine.
///
public void Shutdown ()
{
initialized = false;
AppDomain.CurrentDomain.AssemblyLoad -= new AssemblyLoadEventHandler (OnAssemblyLoaded);
loadedAddins.Clear ();
loadedAssemblies.Clear ();
registry.Dispose ();
registry = null;
startupDirectory = null;
ClearContext ();
}
///
/// Sets the default localizer to be used for this add-in engine
///
///
/// The add-in localizer
///
public void InitializeDefaultLocalizer (IAddinLocalizer localizer)
{
CheckInitialized ();
if (localizer != null)
defaultLocalizer = new AddinLocalizer (localizer);
else
defaultLocalizer = null;
}
internal string StartupDirectory {
get { return startupDirectory; }
}
///
/// Gets whether the add-in engine has been initialized.
///
public bool IsInitialized {
get { return initialized; }
}
///
/// Gets the default add-in installer
///
///
/// The default installer is used by the CheckInstalled method to request
/// the installation of missing add-ins.
///
public IAddinInstaller DefaultInstaller {
get { return installer; }
set { installer = value; }
}
///
/// Gets the default localizer for this add-in engine
///
public AddinLocalizer DefaultLocalizer {
get {
CheckInitialized ();
if (defaultLocalizer != null)
return defaultLocalizer;
else
return NullLocalizer.Instance;
}
}
internal ExtensionContext DefaultContext {
get { return this; }
}
///
/// Gets the localizer for the add-in that is invoking this property
///
public AddinLocalizer CurrentLocalizer {
get {
CheckInitialized ();
Assembly asm = Assembly.GetCallingAssembly ();
RuntimeAddin addin = GetAddinForAssembly (asm);
if (addin != null)
return addin.Localizer;
else
return DefaultLocalizer;
}
}
///
/// Gets a reference to the RuntimeAddin object for the add-in that is invoking this property
///
public RuntimeAddin CurrentAddin {
get {
CheckInitialized ();
Assembly asm = Assembly.GetCallingAssembly ();
return GetAddinForAssembly (asm);
}
}
///
/// Gets the add-in registry bound to this add-in engine
///
public AddinRegistry Registry {
get {
CheckInitialized ();
return registry;
}
}
internal RuntimeAddin GetAddinForAssembly (Assembly asm)
{
return (RuntimeAddin) loadedAssemblies [asm];
}
///
/// Checks if the provided add-ins are installed, and requests the installation of those
/// which aren't.
///
///
/// Message to show to the user when new add-ins have to be installed.
///
///
/// List of IDs of the add-ins to be checked.
///
///
/// This method checks if the specified add-ins are installed.
/// If some of the add-ins are not installed, it will use
/// the installer assigned to the DefaultAddinInstaller property
/// to install them. If the installation fails, or if DefaultAddinInstaller
/// is not set, an exception will be thrown.
///
public void CheckInstalled (string message, params string[] addinIds)
{
ArrayList notInstalled = new ArrayList ();
foreach (string id in addinIds) {
Addin addin = Registry.GetAddin (id, false);
if (addin != null) {
// The add-in is already installed
// If the add-in is disabled, enable it now
if (!addin.Enabled)
addin.Enabled = true;
} else {
notInstalled.Add (id);
}
}
if (notInstalled.Count == 0)
return;
if (installer == null)
throw new InvalidOperationException ("Add-in installer not set");
// Install the add-ins
installer.InstallAddins (Registry, message, (string[]) notInstalled.ToArray (typeof(string)));
}
// Enables or disables conflict checking while loading assemblies.
// Disabling makes loading faster, but less safe.
internal bool CheckAssemblyLoadConflicts {
get { return checkAssemblyLoadConflicts; }
set { checkAssemblyLoadConflicts = value; }
}
///
/// Checks if an add-in has been loaded.
///
///
/// Full identifier of the add-in.
///
///
/// True if the add-in is loaded.
///
public bool IsAddinLoaded (string id)
{
CheckInitialized ();
return loadedAddins.Contains (Addin.GetIdName (id));
}
internal RuntimeAddin GetAddin (string id)
{
return (RuntimeAddin) loadedAddins [Addin.GetIdName (id)];
}
internal void ActivateAddin (string id)
{
ActivateAddinExtensions (id);
}
internal void UnloadAddin (string id)
{
RemoveAddinExtensions (id);
RuntimeAddin addin = GetAddin (id);
if (addin != null) {
addin.UnloadExtensions ();
loadedAddins.Remove (Addin.GetIdName (id));
if (addin.AssembliesLoaded) {
foreach (Assembly asm in addin.Assemblies)
loadedAssemblies.Remove (asm);
}
ReportAddinUnload (id);
}
}
///
/// Forces the loading of an add-in.
///
///
/// Status monitor to keep track of the loading process.
///
///
/// Full identifier of the add-in to load.
///
///
/// This method loads all assemblies that belong to an add-in in memory.
/// All add-ins on which the specified add-in depends will also be loaded.
/// Notice that in general add-ins don't need to be explicitely loaded using
/// this method, since the add-in engine will load them on demand.
///
public void LoadAddin (IProgressStatus statusMonitor, string id)
{
CheckInitialized ();
LoadAddin (statusMonitor, id, true);
}
internal bool LoadAddin (IProgressStatus statusMonitor, string id, bool throwExceptions)
{
try {
if (IsAddinLoaded (id))
return true;
if (!Registry.IsAddinEnabled (id)) {
string msg = GettextCatalog.GetString ("Disabled add-ins can't be loaded.");
ReportError (msg, id, null, false);
if (throwExceptions)
throw new InvalidOperationException (msg);
return false;
}
ArrayList addins = new ArrayList ();
Stack depCheck = new Stack ();
ResolveLoadDependencies (addins, depCheck, id, false);
addins.Reverse ();
if (statusMonitor != null)
statusMonitor.SetMessage ("Loading Addins");
for (int n=0; n 0) {
Type ntype = addin.GetType (nt.ObjectTypeName, true);
RegisterAutoTypeExtensionPoint (ntype, ep.Path);
}
}
}
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;
}
internal void RegisterNodeSet (string addinId, ExtensionNodeSet nset)
{
nset.SourceAddinId = addinId;
nodeSets [nset.Id] = nset;
}
internal void UnregisterAddinNodeSets (string addinId)
{
foreach (var nset in nodeSets.Values.Where (n => n.SourceAddinId == addinId).ToArray ())
nodeSets.Remove (nset.Id);
}
internal string GetNodeTypeAddin (ExtensionNodeSet nset, string type, string callingAddinId)
{
ExtensionNodeType nt = FindType (nset, type, callingAddinId);
if (nt != null)
return nt.AddinId;
else
return null;
}
internal ExtensionNodeType FindType (ExtensionNodeSet nset, string name, string callingAddinId)
{
if (nset == null)
return null;
foreach (ExtensionNodeType nt in nset.NodeTypes) {
if (nt.Id == name)
return nt;
}
foreach (string ns in nset.NodeSets) {
ExtensionNodeSet regSet;
if (!nodeSets.TryGetValue (ns, out regSet)) {
ReportError ("Unknown node set: " + ns, callingAddinId, null, false);
return null;
}
ExtensionNodeType nt = FindType (regSet, name, callingAddinId);
if (nt != null)
return nt;
}
return null;
}
internal void RegisterAutoTypeExtensionPoint (Type type, string path)
{
autoExtensionTypes [type] = path;
}
internal void UnregisterAutoTypeExtensionPoint (Type type, string path)
{
autoExtensionTypes.Remove (type);
}
internal string GetAutoTypeExtensionPoint (Type type)
{
return autoExtensionTypes [type] as string;
}
void OnAssemblyLoaded (object s, AssemblyLoadEventArgs a)
{
if (a != null)
CheckHostAssembly (a.LoadedAssembly);
}
internal void ActivateRoots ()
{
foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies ())
CheckHostAssembly (asm);
}
void CheckHostAssembly (Assembly asm)
{
if (AddinDatabase.RunningSetupProcess || asm is System.Reflection.Emit.AssemblyBuilder || asm.IsDynamic)
return;
string codeBase;
try {
codeBase = asm.CodeBase;
} catch {
return;
}
Uri u;
if (!Uri.TryCreate (codeBase, UriKind.Absolute, out u))
return;
string asmFile = u.LocalPath;
Addin ainfo = Registry.GetAddinForHostAssembly (asmFile);
if (ainfo != null && !IsAddinLoaded (ainfo.Id)) {
AddinDescription adesc = null;
try {
adesc = ainfo.Description;
} catch (Exception ex) {
defaultProgressStatus.ReportError ("Add-in description could not be loaded.", ex);
}
if (adesc == null || adesc.FilesChanged ()) {
// If the add-in has changed, update the add-in database.
// We do it here because once loaded, add-in roots can't be
// reloaded like regular add-ins.
Registry.Update (null);
ainfo = Registry.GetAddinForHostAssembly (asmFile);
if (ainfo == null)
return;
}
LoadAddin (null, ainfo.Id, false);
}
}
///
/// Creates a new extension context.
///
///
/// The new extension context.
///
///
/// Extension contexts can be used to query the extension model using particular condition values.
///
public ExtensionContext CreateExtensionContext ()
{
CheckInitialized ();
return CreateChildContext ();
}
internal void CheckInitialized ()
{
if (!initialized)
throw new InvalidOperationException ("Add-in engine not initialized.");
}
internal void ReportError (string message, string addinId, Exception exception, bool fatal)
{
if (AddinLoadError != null)
AddinLoadError (null, new AddinErrorEventArgs (message, addinId, exception));
else {
Console.WriteLine (message);
if (exception != null)
Console.WriteLine (exception);
}
}
internal void ReportAddinLoad (string id)
{
if (AddinLoaded != null) {
try {
AddinLoaded (null, new AddinEventArgs (id));
} catch {
// Ignore subscriber exceptions
}
}
}
internal void ReportAddinUnload (string id)
{
if (AddinUnloaded != null) {
try {
AddinUnloaded (null, new AddinEventArgs (id));
} catch {
// Ignore subscriber exceptions
}
}
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/AddinErrorEventArgs.cs 0000664 0001750 0001750 00000004511 12136523632 026231 0 ustar 00directhex directhex 0000000 0000000 //
// AddinErrorEventArgs.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
namespace Mono.Addins
{
///
/// Delegate to be used in add-in error subscriptions
///
public delegate void AddinErrorEventHandler (object sender, AddinErrorEventArgs args);
///
/// Provides information about an add-in loading error.
///
public class AddinErrorEventArgs: AddinEventArgs
{
Exception exception;
string message;
///
/// Initializes a new instance of the class.
///
///
/// Error message
///
///
/// Add-in identifier.
///
///
/// Exception that caused the error.
///
public AddinErrorEventArgs (string message, string addinId, Exception exception): base (addinId)
{
this.message = message;
this.exception = exception;
}
///
/// Exception that caused the error.
///
public Exception Exception {
get { return exception; }
}
///
/// Error message
///
public string Message {
get { return message; }
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/ImportAddinFileAttribute.cs 0000664 0001750 0001750 00000004620 12136523632 027260 0 ustar 00directhex directhex 0000000 0000000 //
// ImportAddinFileAttribute.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (c) 2010 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
using System;
namespace Mono.Addins
{
///
/// Declares an add-in file import
///
///
/// An add-in may be composed by several assemblies and data files.
/// Data files must be declared in the main assembly using this attribute, or in the XML manifest.
///
/// It is important to properly declare all files used by an add-in.
/// This information is used by setup tools to know exactly what needs to be packaged when creating
/// an add-in package, or to know what needs to be deleted when removing an add-in.
///
[AttributeUsage (AttributeTargets.Assembly, AllowMultiple = true)]
public class ImportAddinFileAttribute: Attribute
{
string filePath;
///
/// Initializes a new instance
///
///
/// Path to the file. Must be relative to the assembly declaring this attribute.
///
public ImportAddinFileAttribute (string filePath)
{
this.filePath = filePath;
}
///
/// Path to the file. Must be relative to the assembly declaring this attribute.
///
public string FilePath {
get { return filePath; }
set { filePath = value; }
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/IAddinInstaller.cs 0000664 0001750 0001750 00000001100 12136523632 025356 0 ustar 00directhex directhex 0000000 0000000
using System;
namespace Mono.Addins
{
///
/// An add-in installation handler
///
public interface IAddinInstaller
{
///
/// Installs a set of add-ins
///
///
/// Registry where to install
///
///
/// Message to show to the user when new add-ins have to be installed.
///
///
/// List of IDs of the add-ins to be installed.
///
void InstallAddins (AddinRegistry reg, string message, string[] addinIds);
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/ConsoleProgressStatus.cs 0000664 0001750 0001750 00000011173 12136523632 026716 0 ustar 00directhex directhex 0000000 0000000 //
// ConsoleProgressStatus.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
namespace Mono.Addins
{
///
/// An IProgressStatus class which writes output to the console.
///
public class ConsoleProgressStatus: MarshalByRefObject, IProgressStatus
{
bool canceled;
int logLevel;
///
/// Initializes a new instance
///
///
/// Set to true to enabled verbose log
///
public ConsoleProgressStatus (bool verboseLog)
{
if (verboseLog)
logLevel = 2;
else
logLevel = 1;
}
///
/// Initializes a new instance
///
///
/// Verbosity level. 0: not verbose, 1: normal, >1 extra verbose
///
public ConsoleProgressStatus (int logLevel)
{
this.logLevel = logLevel;
}
///
/// Sets the description of the current operation.
///
///
/// A message
///
///
/// This method is called by the add-in engine to show a description of the operation being monitorized.
///
public void SetMessage (string msg)
{
}
///
/// Sets the progress of the operation.
///
///
/// A number between 0 and 1. 0 means no progress, 1 means operation completed.
///
///
/// This method is called by the add-in engine to show the progress of the operation being monitorized.
///
public void SetProgress (double progress)
{
}
///
/// Writes text to the log.
///
///
/// Message to write
///
public void Log (string msg)
{
Console.WriteLine (msg);
}
///
/// Reports a warning.
///
///
/// Warning message
///
///
/// This method is called by the add-in engine to report a warning in the operation being monitorized.
///
public void ReportWarning (string message)
{
if (logLevel > 0)
Console.WriteLine ("WARNING: " + message);
}
///
/// Reports an error.
///
///
/// Error message
///
///
/// Exception that caused the error. It can be null.
///
///
/// This method is called by the add-in engine to report an error occurred while executing the operation being monitorized.
///
public void ReportError (string message, Exception exception)
{
if (logLevel == 0)
return;
Console.Write ("ERROR: ");
if (logLevel > 1) {
if (message != null)
Console.WriteLine (message);
if (exception != null)
Console.WriteLine (exception);
} else {
if (message != null && exception != null)
Console.WriteLine (message + " (" + exception.Message + ")");
else {
if (message != null)
Console.WriteLine (message);
if (exception != null)
Console.WriteLine (exception.Message);
}
}
}
///
/// Returns True when the user requested to cancel this operation
///
public bool IsCanceled {
get { return canceled; }
}
///
/// Log level requested by the user: 0: no log, 1: normal log, >1 verbose log
///
public int LogLevel {
get { return logLevel; }
}
///
/// Cancels the operation being montorized.
///
public void Cancel ()
{
canceled = true;
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/ImportAddinAssemblyAttribute.cs 0000664 0001750 0001750 00000005513 12136523632 030162 0 ustar 00directhex directhex 0000000 0000000 //
// ImportAddinAssemblyAttribute.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (c) 2010 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
using System;
namespace Mono.Addins
{
///
/// Declares an add-in assembly import
///
///
/// An add-in may be composed by several assemblies and data files.
/// Assemblies must be declared in the main assembly using this attribute, or in the XML manifest.
///
/// It is important to properly declare all files used by an add-in.
/// For example, when a type from the add-in is required (e.g. an ICommand implementation),
/// only properly declared assemblies will be checked.
/// This information is also used by setup tools to know exactly what needs to be packaged when creating
/// an add-in package, or to know what needs to be deleted when removing an add-in.
///
[AttributeUsage (AttributeTargets.Assembly, AllowMultiple = true)]
public class ImportAddinAssemblyAttribute: Attribute
{
string filePath;
bool scan = true;
///
/// Initializes a new instance
///
///
/// Path to the assembly. Must be relative to the assembly declaring this attribute.
///
public ImportAddinAssemblyAttribute (string filePath)
{
this.filePath = filePath;
}
///
/// Path to the assembly. Must be relative to the assembly declaring this attribute.
///
public string FilePath {
get { return filePath; }
set { filePath = value; }
}
///
/// When set to true (the default), the included assembly will be scanned
/// looking for extension point declarations.
///
public bool Scan {
get { return this.scan; }
set { this.scan = value; }
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/ExtensionNode.cs 0000664 0001750 0001750 00000041640 12136523632 025147 0 ustar 00directhex directhex 0000000 0000000 //
// ExtensionNode.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
using System.Collections.Generic;
using System.Xml;
using System.Reflection;
using Mono.Addins.Description;
namespace Mono.Addins
{
///
/// A node of the extension model.
///
///
/// An extension node is an element registered by an add-in in an extension point.
/// A host can get nodes registered in an extension point using methods such as
/// AddinManager.GetExtensionNodes(string), which returns a collection of ExtensionNode objects.
///
/// ExtensionNode will normally be used as a base class of more complex extension point types.
/// The most common subclass is Mono.Addins.TypeExtensionNode, which allows registering a class
/// implemented in an add-in.
///
public class ExtensionNode
{
bool childrenLoaded;
TreeNode treeNode;
ExtensionNodeList childNodes;
RuntimeAddin addin;
string addinId;
ExtensionNodeType nodeType;
ModuleDescription module;
AddinEngine addinEngine;
event ExtensionNodeEventHandler extensionNodeChanged;
///
/// Identifier of the node.
///
///
/// It is not mandatory to specify an 'id' for a node. When none is provided,
/// the add-in manager will automatically generate an unique id for the node.
/// The ExtensionNode.HasId property can be used to know if the 'id' has been
/// specified by the developer or not.
///
public string Id {
get { return treeNode != null ? treeNode.Id : string.Empty; }
}
///
/// Location of this node in the extension tree.
///
///
/// The node path is composed by the path of the extension point where it is defined,
/// the identifiers of its parent nodes, and its own identifier.
///
public string Path {
get { return treeNode != null ? treeNode.GetPath () : string.Empty; }
}
///
/// Parent node of this node.
///
public ExtensionNode Parent {
get {
if (treeNode != null && treeNode.Parent != null)
return treeNode.Parent.ExtensionNode;
else
return null;
}
}
///
/// Extension context to which this node belongs
///
public ExtensionContext ExtensionContext {
get { return treeNode.Context; }
}
///
/// Specifies whether the extension node has as an Id or not.
///
///
/// It is not mandatory to specify an 'id' for a node. When none is provided,
/// the add-in manager will automatically generate an unique id for the node.
/// This property will return true if an 'id' was provided for the node, and
/// false if the id was assigned by the add-in manager.
///
public bool HasId {
get { return !Id.StartsWith (ExtensionTree.AutoIdPrefix); }
}
internal void SetTreeNode (TreeNode node)
{
treeNode = node;
}
internal void SetData (AddinEngine addinEngine, string plugid, ExtensionNodeType nodeType, ModuleDescription module)
{
this.addinEngine = addinEngine;
this.addinId = plugid;
this.nodeType = nodeType;
this.module = module;
}
internal string AddinId {
get { return addinId; }
}
internal TreeNode TreeNode {
get { return treeNode; }
}
///
/// The add-in that registered this extension node.
///
///
/// This property provides access to the resources and types of the add-in that created this extension node.
///
public RuntimeAddin Addin {
get {
if (addin == null && addinId != null) {
if (!addinEngine.IsAddinLoaded (addinId))
addinEngine.LoadAddin (null, addinId, true);
addin = addinEngine.GetAddin (addinId);
if (addin != null)
addin = addin.GetModule (module);
}
if (addin == null)
throw new InvalidOperationException ("Add-in '" + addinId + "' could not be loaded.");
return addin;
}
}
///
/// Notifies that a child node of this node has been added or removed.
///
///
/// The first time the event is subscribed, the handler will be called for each existing node.
///
public event ExtensionNodeEventHandler ExtensionNodeChanged {
add {
extensionNodeChanged += value;
foreach (ExtensionNode node in ChildNodes) {
try {
value (this, new ExtensionNodeEventArgs (ExtensionChange.Add, node));
} catch (Exception ex) {
addinEngine.ReportError (null, node.Addin != null ? node.Addin.Id : null, ex, false);
}
}
}
remove {
extensionNodeChanged -= value;
}
}
///
/// Child nodes of this extension node.
///
public ExtensionNodeList ChildNodes {
get {
if (childrenLoaded)
return childNodes;
try {
if (treeNode.Children.Count == 0) {
childNodes = ExtensionNodeList.Empty;
return childNodes;
}
}
catch (Exception ex) {
addinEngine.ReportError (null, null, ex, false);
childNodes = ExtensionNodeList.Empty;
return childNodes;
} finally {
childrenLoaded = true;
}
List list = new List ();
foreach (TreeNode cn in treeNode.Children) {
// For each node check if it is visible for the current context.
// If something fails while evaluating the condition, just ignore the node.
try {
if (cn.ExtensionNode != null && cn.IsEnabled)
list.Add (cn.ExtensionNode);
} catch (Exception ex) {
addinEngine.ReportError (null, null, ex, false);
}
}
if (list.Count > 0)
childNodes = new ExtensionNodeList (list);
else
childNodes = ExtensionNodeList.Empty;
return childNodes;
}
}
///
/// Returns the child objects of a node.
///
///
/// An array of child objects.
///
///
/// This method only works if all children of this node are of type Mono.Addins.TypeExtensionNode.
/// The returned array is composed by all objects created by calling the
/// TypeExtensionNode.GetInstance() method for each node.
///
public object[] GetChildObjects ()
{
return GetChildObjects (typeof(object), true);
}
///
/// Returns the child objects of a node.
///
///
/// True if the method can reuse instances created in previous calls.
///
///
/// An array of child objects.
///
///
/// This method only works if all children of this node are of type Mono.Addins.TypeExtensionNode.
/// The returned array is composed by all objects created by calling the TypeExtensionNode.CreateInstance()
/// method for each node (or TypeExtensionNode.GetInstance() if reuseCachedInstance is set to true).
///
public object[] GetChildObjects (bool reuseCachedInstance)
{
return GetChildObjects (typeof(object), reuseCachedInstance);
}
///
/// Returns the child objects of a node (with type check).
///
///
/// Type of the return array elements.
///
///
/// An array of child objects.
///
///
/// This method only works if all children of this node are of type Mono.Addins.TypeExtensionNode.
/// The returned array is composed by all objects created by calling the
/// TypeExtensionNode.GetInstance(Type) method for each node.
///
/// An InvalidOperationException exception is thrown if one of the found child objects is not a
/// subclass of the provided type.
///
public object[] GetChildObjects (Type arrayElementType)
{
return GetChildObjects (arrayElementType, true);
}
///
/// Returns the child objects of a node (casting to the specified type)
///
///
/// An array of child objects.
///
///
/// This method only works if all children of this node are of type Mono.Addins.TypeExtensionNode.
/// The returned array is composed by all objects created by calling the
/// TypeExtensionNode.GetInstance() method for each node.
///
public T[] GetChildObjects ()
{
return (T[]) GetChildObjectsInternal (typeof(T), true);
}
///
/// Returns the child objects of a node (with type check).
///
///
/// Type of the return array elements.
///
///
/// True if the method can reuse instances created in previous calls.
///
///
/// An array of child objects.
///
///
/// This method only works if all children of this node are of type Mono.Addins.TypeExtensionNode.
/// The returned array is composed by all objects created by calling the TypeExtensionNode.CreateInstance(Type)
/// method for each node (or TypeExtensionNode.GetInstance(Type) if reuseCachedInstance is set to true).
///
/// An InvalidOperationException exception will be thrown if one of the found child objects is not a subclass
/// of the provided type.
///
public object[] GetChildObjects (Type arrayElementType, bool reuseCachedInstance)
{
return (object[]) GetChildObjectsInternal (arrayElementType, reuseCachedInstance);
}
///
/// Returns the child objects of a node (casting to the specified type).
///
///
/// True if the method can reuse instances created in previous calls.
///
///
/// An array of child objects.
///
///
/// This method only works if all children of this node are of type Mono.Addins.TypeExtensionNode.
/// The returned array is composed by all objects created by calling the TypeExtensionNode.CreateInstance()
/// method for each node (or TypeExtensionNode.GetInstance() if reuseCachedInstance is set to true).
///
public T[] GetChildObjects (bool reuseCachedInstance)
{
return (T[]) GetChildObjectsInternal (typeof(T), reuseCachedInstance);
}
Array GetChildObjectsInternal (Type arrayElementType, bool reuseCachedInstance)
{
ArrayList list = new ArrayList (ChildNodes.Count);
for (int n=0; n
/// Reads the extension node data
///
///
/// The element containing the extension data
///
///
/// This method can be overriden to provide a custom method for reading extension node data from an element.
/// The default implementation reads the attributes if the element and assigns the values to the fields
/// and properties of the extension node that have the corresponding [NodeAttribute] decoration.
///
internal protected virtual void Read (NodeElement elem)
{
if (nodeType == null)
return;
NodeAttribute[] attributes = elem.Attributes;
ReadObject (this, attributes, nodeType.Fields);
if (nodeType.CustomAttributeMember != null) {
object att = Activator.CreateInstance (nodeType.CustomAttributeMember.MemberType);
ReadObject (att, attributes, nodeType.CustomAttributeFields);
nodeType.CustomAttributeMember.SetValue (this, att);
}
}
void ReadObject (object ob, NodeAttribute[] attributes, Dictionary fields)
{
if (fields == null)
return;
// Make a copy because we are going to remove fields that have been used
fields = new Dictionary (fields);
foreach (NodeAttribute at in attributes) {
ExtensionNodeType.FieldData f;
if (!fields.TryGetValue (at.name, out f))
continue;
fields.Remove (at.name);
object val;
Type memberType = f.MemberType;
if (memberType == typeof(string)) {
if (f.Localizable)
val = Addin.Localizer.GetString (at.value);
else
val = at.value;
}
else if (memberType == typeof(string[])) {
string[] ss = at.value.Split (',');
if (ss.Length == 0 && ss[0].Length == 0)
val = new string [0];
else {
for (int n=0; n 0) {
// Check if one of the remaining fields is mandatory
foreach (KeyValuePair e in fields) {
ExtensionNodeType.FieldData f = e.Value;
if (f.Required)
throw new InvalidOperationException ("Required attribute '" + e.Key + "' not found.");
}
}
}
internal bool NotifyChildChanged ()
{
if (!childrenLoaded)
return false;
ExtensionNodeList oldList = childNodes;
childrenLoaded = false;
bool changed = false;
foreach (ExtensionNode nod in oldList) {
if (ChildNodes [nod.Id] == null) {
changed = true;
OnChildNodeRemoved (nod);
}
}
foreach (ExtensionNode nod in ChildNodes) {
if (oldList [nod.Id] == null) {
changed = true;
OnChildNodeAdded (nod);
}
}
if (changed)
OnChildrenChanged ();
return changed;
}
///
/// Called when the add-in that defined this extension node is actually loaded in memory.
///
internal protected virtual void OnAddinLoaded ()
{
}
///
/// Called when the add-in that defined this extension node is being
/// unloaded from memory.
///
internal protected virtual void OnAddinUnloaded ()
{
}
///
/// Called when the children list of this node has changed. It may be due to add-ins
/// being loaded/unloaded, or to conditions being changed.
///
protected virtual void OnChildrenChanged ()
{
}
///
/// Called when a child node is added
///
///
/// Added node.
///
protected virtual void OnChildNodeAdded (ExtensionNode node)
{
if (extensionNodeChanged != null)
extensionNodeChanged (this, new ExtensionNodeEventArgs (ExtensionChange.Add, node));
}
///
/// Called when a child node is removed
///
///
/// Removed node.
///
protected virtual void OnChildNodeRemoved (ExtensionNode node)
{
if (extensionNodeChanged != null)
extensionNodeChanged (this, new ExtensionNodeEventArgs (ExtensionChange.Remove, node));
}
}
///
/// An extension node with custom metadata
///
///
/// This is the default type for extension nodes bound to a custom extension attribute.
///
public class ExtensionNode: ExtensionNode where T:CustomExtensionAttribute
{
T data;
///
/// The custom attribute containing the extension metadata
///
[NodeAttribute]
public T Data {
get { return data; }
internal set { data = value; }
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/AddinLocalizerGettextAttribute.cs 0000664 0001750 0001750 00000007037 12136523632 030504 0 ustar 00directhex directhex 0000000 0000000 //
// AddinLocalizerAttribute.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (c) 2010 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
using System;
namespace Mono.Addins
{
///
/// Declares a Gettext-based localizer for an add-in
///
[AttributeUsage (AttributeTargets.Assembly)]
public class AddinLocalizerGettextAttribute: Attribute
{
string catalog;
string location;
///
/// Initializes a new instance of the class.
///
public AddinLocalizerGettextAttribute ()
{
}
///
/// Initializes a new instance of the class.
///
///
/// Name of the catalog which contains the strings.
///
public AddinLocalizerGettextAttribute (string catalog)
{
this.catalog = catalog;
}
///
/// Initializes a new instance of the class.
///
///
/// Name of the catalog which contains the strings.
///
///
/// Relative path to the location of the catalog. This path must be relative to the add-in location.
///
///
/// The location path must contain a directory structure like this:
///
/// {language-id}/LC_MESSAGES/{Catalog}.mo
///
/// For example, the catalog for spanish strings would be located at:
///
/// locale/es/LC_MESSAGES/some-addin.mo
///
public AddinLocalizerGettextAttribute (string catalog, string location)
{
this.catalog = catalog;
this.location = location;
}
///
/// Name of the catalog which contains the strings.
///
public string Catalog {
get { return this.catalog; }
set { this.catalog = value; }
}
///
/// Relative path to the location of the catalog. This path must be relative to the add-in location.
///
///
/// When not specified, the default value of this property is 'locale'.
/// The location path must contain a directory structure like this:
///
/// {language-id}/LC_MESSAGES/{Catalog}.mo
///
/// For example, the catalog for spanish strings would be located at:
///
/// locale/es/LC_MESSAGES/some-addin.mo
///
public string Location {
get { return this.location; }
set { this.location = value; }
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/GettextCatalog.cs 0000664 0001750 0001750 00000003026 12136523632 025300 0 ustar 00directhex directhex 0000000 0000000 //
// GettextCatalog.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
namespace Mono.Addins
{
// TODO: Add real translation suport, which can work in Windows
internal class GettextCatalog
{
public static string GetString (string str)
{
return str;
}
public static string GetString (string str, params object[] arguments)
{
return string.Format (GetString (str), arguments);
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/ExtensionNodeList.cs 0000664 0001750 0001750 00000011625 12136523632 026003 0 ustar 00directhex directhex 0000000 0000000 //
// ExtensionNodeList.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
using System.Collections.Generic;
namespace Mono.Addins
{
///
/// A list of extension nodes.
///
public class ExtensionNodeList: IEnumerable
{
internal List list;
internal static ExtensionNodeList Empty = new ExtensionNodeList (new List ());
internal ExtensionNodeList (List list)
{
this.list = list;
}
///
/// Returns the node in the specified index.
///
///
/// The index.
///
public ExtensionNode this [int n] {
get {
if (list == null)
throw new System.IndexOutOfRangeException ();
else
return (ExtensionNode) list [n];
}
}
///
/// Returns the node with the specified ID.
///
///
/// An id.
///
public ExtensionNode this [string id] {
get {
if (list == null)
return null;
else {
for (int n = list.Count - 1; n >= 0; n--)
if (((ExtensionNode) list [n]).Id == id)
return (ExtensionNode) list [n];
return null;
}
}
}
///
/// Gets an enumerator which enumerates all nodes in the list
///
public IEnumerator GetEnumerator ()
{
if (list == null)
return ((IList)Type.EmptyTypes).GetEnumerator ();
return list.GetEnumerator ();
}
///
/// Number of nodes of the collection.
///
public int Count {
get { return list == null ? 0 : list.Count; }
}
///
/// Copies all nodes to an array
///
///
/// The target array
///
///
/// Initial index where to copy to
///
public void CopyTo (ExtensionNode[] array, int index)
{
if (list != null)
list.CopyTo (array, index);
}
}
///
/// A list of extension nodes.
///
public class ExtensionNodeList: IEnumerable, IEnumerable where T: ExtensionNode
{
List list;
internal static ExtensionNodeList Empty = new ExtensionNodeList (new List ());
internal ExtensionNodeList (List list)
{
this.list = list;
}
///
/// Returns the node in the specified index.
///
///
/// The index.
///
public T this [int n] {
get {
if (list == null)
throw new System.IndexOutOfRangeException ();
else
return (T) list [n];
}
}
///
/// Returns the node with the specified ID.
///
///
/// An id.
///
public T this [string id] {
get {
if (list == null)
return null;
else {
for (int n = list.Count - 1; n >= 0; n--)
if (list [n].Id == id)
return (T) list [n];
return null;
}
}
}
///
/// Gets an enumerator which enumerates all nodes in the list
///
public IEnumerator GetEnumerator ()
{
if (list == null)
yield break;
foreach (ExtensionNode n in list)
yield return (T) n;
}
IEnumerator IEnumerable.GetEnumerator ()
{
if (list == null)
return ((IList)Type.EmptyTypes).GetEnumerator ();
return list.GetEnumerator ();
}
///
/// Number of nodes of the collection.
///
public int Count {
get { return list == null ? 0 : list.Count; }
}
///
/// Copies all nodes to an array
///
///
/// The target array
///
///
/// Initial index where to copy to
///
public void CopyTo (T[] array, int index)
{
if (list != null)
list.CopyTo (array, index);
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/AddinPropertyAttribute.cs 0000664 0001750 0001750 00000005235 12136523632 027035 0 ustar 00directhex directhex 0000000 0000000 //
// AddinPropertyAttribute.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (c) 2011 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
using System;
namespace Mono.Addins
{
///
/// Defines an add-in property
///
[AttributeUsage (AttributeTargets.Assembly, AllowMultiple=true)]
public class AddinPropertyAttribute: Attribute
{
///
/// Initializes a new instance of the class.
///
///
/// Name of the property
///
///
/// Value of the property
///
public AddinPropertyAttribute (string name, string value): this (name, null, value)
{
}
///
/// Initializes a new instance of the class.
///
///
/// Name of the property
///
///
/// Locale of the property. It can be null if the property is not bound to a locale.
///
///
/// Value of the property
///
public AddinPropertyAttribute (string name, string locale, string value)
{
Name = name;
Locale = locale;
Value = value;
}
///
/// Name of the property
///
public string Name { get; set; }
///
/// Locale of the property. It can be null if the property is not bound to a locale.
///
public string Locale { get; set; }
///
/// Value of the property
///
public string Value { get; set; }
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins/InstanceExtensionNode.cs 0000664 0001750 0001750 00000006377 12136523632 026644 0 ustar 00directhex directhex 0000000 0000000 //
// InstanceExtensionNode.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
namespace Mono.Addins
{
///
/// Base class for extension nodes which create extension objects
///
public abstract class InstanceExtensionNode: ExtensionNode
{
object cachedInstance;
///
/// Gets the extension object declared by this node
///
///
/// Expected object type. An exception will be thrown if the object is not an instance of the specified type.
///
///
/// The extension object
///
///
/// The extension object is cached and the same instance will be returned at every call.
///
public object GetInstance (Type expectedType)
{
object ob = GetInstance ();
if (!expectedType.IsInstanceOfType (ob))
throw new InvalidOperationException (string.Format ("Expected subclass of type '{0}'. Found '{1}'.", expectedType, ob.GetType ()));
return ob;
}
///
/// Gets the extension object declared by this node
///
///
/// The extension object
///
///
/// The extension object is cached and the same instance will be returned at every call.
///
public object GetInstance ()
{
if (cachedInstance == null)
cachedInstance = CreateInstance ();
return cachedInstance;
}
///
/// Creates a new extension object
///
///
/// Expected object type. An exception will be thrown if the object is not an instance of the specified type.
///
///
/// The extension object
///
public object CreateInstance (Type expectedType)
{
object ob = CreateInstance ();
if (!expectedType.IsInstanceOfType (ob))
throw new InvalidOperationException (string.Format ("Expected subclass of type '{0}'. Found '{1}'.", expectedType, ob.GetType ()));
return ob;
}
///
/// Creates a new extension object
///
///
/// The extension object
///
public abstract object CreateInstance ();
}
}
mono-addins-1.0/Mono.Addins/Makefile.in 0000664 0001750 0001750 00000042171 12136523720 021770 0 ustar 00directhex directhex 0000000 0000000 # Makefile.in generated by automake 1.11.6 from Makefile.am.
# @configure_input@
# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
# Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
am__make_dryrun = \
{ \
am__dry=no; \
case $$MAKEFLAGS in \
*\\[\ \ ]*) \
echo 'am--echo: ; @echo "AM" OK' | $(MAKE) -f - 2>/dev/null \
| grep '^AM OK$$' >/dev/null || am__dry=yes;; \
*) \
for am__flg in $$MAKEFLAGS; do \
case $$am__flg in \
*=*|--*) ;; \
*n*) am__dry=yes; break;; \
esac; \
done;; \
esac; \
test $$am__dry = yes; \
}
pkgdatadir = $(datadir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkglibexecdir = $(libexecdir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in \
$(srcdir)/mono-addins.pc.in $(top_srcdir)/Makefile.include \
$(top_srcdir)/xbuild.include ChangeLog
subdir = ./Mono.Addins
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(install_sh) -d
CONFIG_CLEAN_FILES = mono-addins.pc
CONFIG_CLEAN_VPATH_FILES =
am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
am__vpath_adj = case $$p in \
$(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
*) f=$$p;; \
esac;
am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
am__install_max = 40
am__nobase_strip_setup = \
srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
am__nobase_strip = \
for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
am__nobase_list = $(am__nobase_strip_setup); \
for p in $$list; do echo "$$p $$p"; done | \
sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
$(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
if (++n[$$2] == $(am__install_max)) \
{ print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
END { for (dir in files) print dir, files[dir] }'
am__base_list = \
sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
am__uninstall_files_from_dir = { \
test -z "$$files" \
|| { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
|| { echo " ( cd '$$dir' && rm -f" $$files ")"; \
$(am__cd) "$$dir" && rm -f $$files; }; \
}
am__installdirs = "$(DESTDIR)$(bindir)" "$(DESTDIR)$(pkgconfigdir)"
SCRIPTS = $(bin_SCRIPTS)
SOURCES =
DIST_SOURCES =
am__can_run_installinfo = \
case $$AM_UPDATE_INFO_DIR in \
n|no|NO) false;; \
*) (install-info --version) >/dev/null 2>&1;; \
esac
DATA = $(pkgconfig_DATA)
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@
AL = @AL@
AMTAR = @AMTAR@
API_VERSION = @API_VERSION@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
GACUTIL = @GACUTIL@
GACUTIL_FLAGS = @GACUTIL_FLAGS@
GACUTIL_POLICY_FLAGS = @GACUTIL_POLICY_FLAGS@
GTK_SHARP_20_CFLAGS = @GTK_SHARP_20_CFLAGS@
GTK_SHARP_20_LIBS = @GTK_SHARP_20_LIBS@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LTLIBOBJS = @LTLIBOBJS@
MAINT = @MAINT@
MAKEINFO = @MAKEINFO@
MCS = @MCS@
MKDIR_P = @MKDIR_P@
MONODOC_CFLAGS = @MONODOC_CFLAGS@
MONODOC_LIBS = @MONODOC_LIBS@
MONO_ADDINS_DEFAULT_LIB = @MONO_ADDINS_DEFAULT_LIB@
MONO_ADDINS_GUI_DEFAULT_LIB = @MONO_ADDINS_GUI_DEFAULT_LIB@
MONO_ADDINS_MSBUILD_DEFAULT_LIB = @MONO_ADDINS_MSBUILD_DEFAULT_LIB@
MONO_ADDINS_SETUP_DEFAULT_LIB = @MONO_ADDINS_SETUP_DEFAULT_LIB@
MONO_NUNIT_CFLAGS = @MONO_NUNIT_CFLAGS@
MONO_NUNIT_LIBS = @MONO_NUNIT_LIBS@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
POLICY_VERSIONS = @POLICY_VERSIONS@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
STRIP = @STRIP@
VERSION = @VERSION@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
am__leading_dot = @am__leading_dot@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build_alias = @build_alias@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
host_alias = @host_alias@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target_alias = @target_alias@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
ASSEMBLY = ../bin/Mono.Addins.dll
ASSEMBLY_NAME = Mono.Addins
PC_FILES_IN = mono-addins.pc.in
pc_files = $(PC_FILES_IN:.pc.in=.pc)
POLICY_ASSEMBLIES = $(addsuffix .$(ASSEMBLY_NAME).dll, $(addprefix policy., $(POLICY_VERSIONS)))
POLICY_CONFIGS = $(addsuffix .config, $(addprefix policy., $(POLICY_VERSIONS)))
EXTRA_DIST = \
$(wildcard $(ALL_FILES))
CLEANFILES = $(ASSEMBLY) $(ASSEMBLY).mdb $(DLL_REFERENCES) \
$(POLICY_ASSEMBLIES) $(POLICY_CONFIGS)
DISTCLEANFILES = $(GENERATED_FILES) $(build_datafiles) $(pc_files)
bin_SCRIPTS = $(ASSEMBLY_WRAPPER)
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = $(pc_files)
ALL_CSPROJ = $(wildcard *.csproj)
MAIN_SLN = $(top_builddir)/Mono.Addins.sln
@ENABLE_GUI_FALSE@PROFILE_NAME = DebugNotGui
@ENABLE_GUI_TRUE@PROFILE_NAME = Debug
XBUILD = xbuild
XBUILD_VERBOSITY = quiet
XBUILD_ARGS = /verbosity:$(XBUILD_VERBOSITY) /nologo /property:CodePage=65001
XBUILD_PROFILE = /property:Configuration=$(PROFILE_NAME)
# Figure out how far we are from top_builddir
DEPTH = $(shell echo "$(top_builddir)" | tr '/' '\n' | grep -c '..')
EXTS := *.bmp *.cs *.csproj *.html *.png *.snk *.config *.stetic *.glade *.xml *.xsd *.exe.addins *.template *.tt *.txt
ALL_FILES := $(EXTS) \
$(addprefix */,$(EXTS)) \
$(addprefix */*/,$(EXTS)) \
$(addprefix */*/*/,$(EXTS)) \
$(addprefix */*/*/*/,$(EXTS)) \
$(addprefix */*/*/*/*/,$(EXTS)) \
$(wildcard icons/*) \
$(wildcard templates/*)
WILDCARDED_FILES := $(wildcard $(ALL_FILES))
all: all-am
.SUFFIXES:
$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(top_srcdir)/Makefile.include $(top_srcdir)/xbuild.include $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign ./Mono.Addins/Makefile'; \
$(am__cd) $(top_srcdir) && \
$(AUTOMAKE) --foreign ./Mono.Addins/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_srcdir)/Makefile.include $(top_srcdir)/xbuild.include:
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(am__aclocal_m4_deps):
mono-addins.pc: $(top_builddir)/config.status $(srcdir)/mono-addins.pc.in
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@
install-binSCRIPTS: $(bin_SCRIPTS)
@$(NORMAL_INSTALL)
@list='$(bin_SCRIPTS)'; test -n "$(bindir)" || list=; \
if test -n "$$list"; then \
echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \
$(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \
fi; \
for p in $$list; do \
if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
if test -f "$$d$$p"; then echo "$$d$$p"; echo "$$p"; else :; fi; \
done | \
sed -e 'p;s,.*/,,;n' \
-e 'h;s|.*|.|' \
-e 'p;x;s,.*/,,;$(transform)' | sed 'N;N;N;s,\n, ,g' | \
$(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1; } \
{ d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
if ($$2 == $$4) { files[d] = files[d] " " $$1; \
if (++n[d] == $(am__install_max)) { \
print "f", d, files[d]; n[d] = 0; files[d] = "" } } \
else { print "f", d "/" $$4, $$1 } } \
END { for (d in files) print "f", d, files[d] }' | \
while read type dir files; do \
if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
test -z "$$files" || { \
echo " $(INSTALL_SCRIPT) $$files '$(DESTDIR)$(bindir)$$dir'"; \
$(INSTALL_SCRIPT) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
} \
; done
uninstall-binSCRIPTS:
@$(NORMAL_UNINSTALL)
@list='$(bin_SCRIPTS)'; test -n "$(bindir)" || exit 0; \
files=`for p in $$list; do echo "$$p"; done | \
sed -e 's,.*/,,;$(transform)'`; \
dir='$(DESTDIR)$(bindir)'; $(am__uninstall_files_from_dir)
install-pkgconfigDATA: $(pkgconfig_DATA)
@$(NORMAL_INSTALL)
@list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \
if test -n "$$list"; then \
echo " $(MKDIR_P) '$(DESTDIR)$(pkgconfigdir)'"; \
$(MKDIR_P) "$(DESTDIR)$(pkgconfigdir)" || exit 1; \
fi; \
for p in $$list; do \
if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
echo "$$d$$p"; \
done | $(am__base_list) | \
while read files; do \
echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(pkgconfigdir)'"; \
$(INSTALL_DATA) $$files "$(DESTDIR)$(pkgconfigdir)" || exit $$?; \
done
uninstall-pkgconfigDATA:
@$(NORMAL_UNINSTALL)
@list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \
files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
dir='$(DESTDIR)$(pkgconfigdir)'; $(am__uninstall_files_from_dir)
tags: TAGS
TAGS:
ctags: CTAGS
CTAGS:
distdir: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d "$(distdir)/$$file"; then \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
else \
test -f "$(distdir)/$$file" \
|| cp -p $$d/$$file "$(distdir)/$$file" \
|| exit 1; \
fi; \
done
check-am: all-am
check: check-am
all-am: Makefile $(SCRIPTS) $(DATA)
installdirs:
for dir in "$(DESTDIR)$(bindir)" "$(DESTDIR)$(pkgconfigdir)"; do \
test -z "$$dir" || $(MKDIR_P) "$$dir"; \
done
install: install-am
install-exec: install-exec-am
install-data: install-data-am
uninstall: uninstall-am
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-am
install-strip:
if test -z '$(STRIP)'; then \
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
install; \
else \
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
"INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
fi
mostlyclean-generic:
clean-generic:
-test -z "$(CLEANFILES)" || rm -f $(CLEANFILES)
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
-test -z "$(DISTCLEANFILES)" || rm -f $(DISTCLEANFILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean-am: clean-generic mostlyclean-am
distclean: distclean-am
-rm -f Makefile
distclean-am: clean-am distclean-generic
dvi: dvi-am
dvi-am:
html: html-am
html-am:
info: info-am
info-am:
install-data-am: install-data-local install-pkgconfigDATA
install-dvi: install-dvi-am
install-dvi-am:
install-exec-am: install-binSCRIPTS
install-html: install-html-am
install-html-am:
install-info: install-info-am
install-info-am:
install-man:
install-pdf: install-pdf-am
install-pdf-am:
install-ps: install-ps-am
install-ps-am:
installcheck-am:
maintainer-clean: maintainer-clean-am
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-am
mostlyclean-am: mostlyclean-generic
pdf: pdf-am
pdf-am:
ps: ps-am
ps-am:
uninstall-am: uninstall-binSCRIPTS uninstall-local \
uninstall-pkgconfigDATA
.MAKE: install-am install-strip
.PHONY: all all-am check check-am clean clean-generic distclean \
distclean-generic distdir dvi dvi-am html html-am info info-am \
install install-am install-binSCRIPTS install-data \
install-data-am install-data-local install-dvi install-dvi-am \
install-exec install-exec-am install-html install-html-am \
install-info install-info-am install-man install-pdf \
install-pdf-am install-pkgconfigDATA install-ps install-ps-am \
install-strip installcheck installcheck-am installdirs \
maintainer-clean maintainer-clean-generic mostlyclean \
mostlyclean-generic pdf pdf-am ps ps-am uninstall uninstall-am \
uninstall-binSCRIPTS uninstall-local uninstall-pkgconfigDATA
install-data-local: gac-install
uninstall-local: gac-uninstall
$(build_datafiles): $(BUILD_DIR)/% : $(addprefix $(srcdir)/, %)
mkdir -p $(dir $@)
cp $< $@
policy.%.config: $(top_builddir)/policy.config
sed -e "s/@ASSEMBLY_NAME@/$(ASSEMBLY_NAME)/" -e "s/@POLICY@/$*/" $(top_builddir)/policy.config > $@
$(POLICY_ASSEMBLIES) : policy.%.$(ASSEMBLY_NAME).dll: policy.%.config $(top_srcdir)/mono-addins.snk
$(AL) -link:policy.$*.config -out:$@ -keyfile:$(top_srcdir)/mono-addins.snk
gac-install: $(POLICY_ASSEMBLIES)
$(GACUTIL) /i $(ASSEMBLY) /f $(GACUTIL_FLAGS) || exit 1;
@for p in $(POLICY_ASSEMBLIES); do \
echo $(GACUTIL) /i $$p /f $(GACUTIL_POLICY_FLAGS) || exit 1; \
$(GACUTIL) /i $$p /f $(GACUTIL_POLICY_FLAGS) || exit 1; \
done
gac-uninstall:
$(GACUTIL) /us $(ASSEMBLY) $(GACUTIL_FLAGS) || exit 1;
@for p in $(POLICY_ASSEMBLIES); do \
echo $(GACUTIL) /us $$p /f $(GACUTIL_POLICY_FLAGS) || exit 1; \
$(GACUTIL) /us $$p /f $(GACUTIL_POLICY_FLAGS) || exit 1; \
done
all: csproj_build
clean: csproj_clean
csproj_build: $(POLICY_ASSEMBLIES)
@if test x$(SKIP) != xy ; then \
echo Building $(ALL_CSPROJ); \
for p in $(ALL_CSPROJ); do $(XBUILD) $(XBUILD_ARGS) $$p; done \
fi
csproj_clean:
@if test x$(SKIP) != xy -a $(DEPTH) -gt $(MAKELEVEL); then \
echo Cleaning $(ALL_CSPROJ); \
for p in $(ALL_CSPROJ); do $(XBUILD) $(XBUILD_ARGS) $$p /t:Clean; done \
fi
rm -f $(CLEANFILES)
sln_build:
@echo Building $(MAIN_SLN)
@$(XBUILD) $(XBUILD_ARGS) $(MAIN_SLN) $(XBUILD_PROFILE)
sln_clean:
@echo Cleaning $(MAIN_SLN)
@$(XBUILD) $(XBUILD_ARGS) $(MAIN_SLN) $(XBUILD_PROFILE) /t:Clean
print_extradist:
@echo $(WILDCARDED_FILES)
.PHONY: all clean csproj_build csproj_clean sln_build sln_clean
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:
mono-addins-1.0/Mono.Addins/serializers.config 0000664 0001750 0001750 00000001367 12136523632 023452 0 ustar 00directhex directhex 0000000 0000000 AddinSystemConfigurationReaderAddinSystemConfigurationWritertrueOrigin.Core.Addins.SetupAddinSystemConfigurationReaderWriter.csRepositoryReaderRepositoryWritertrueOrigin.Core.Addins.SetupRepositoryReaderWriter.cs
mono-addins-1.0/Mono.Addins/Mono.Addins.Serialization/ 0000775 0001750 0001750 00000000000 12136524043 024642 5 ustar 00directhex directhex 0000000 0000000 mono-addins-1.0/Mono.Addins/Mono.Addins.Serialization/BinaryXmlWriter.cs 0000664 0001750 0001750 00000014207 12136523632 030302 0 ustar 00directhex directhex 0000000 0000000 //
// BinaryXmlWriter.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
using System.Text;
using System.IO;
namespace Mono.Addins.Serialization
{
internal class BinaryXmlWriter
{
BinaryWriter writer;
BinaryXmlTypeMap typeMap;
Hashtable stringTable = new Hashtable ();
public BinaryXmlWriter (Stream stream, BinaryXmlTypeMap typeMap)
{
this.typeMap = typeMap;
writer = new BinaryWriter (stream);
}
public void WriteBeginElement (string name)
{
writer.Write (BinaryXmlReader.TagBeginElement);
WriteString (name);
}
public void WriteEndElement ()
{
writer.Write (BinaryXmlReader.TagEndElement);
}
void WriteValueHeader (string name, TypeCode type)
{
writer.Write (BinaryXmlReader.TagValue);
WriteString (name);
writer.Write ((byte) type);
}
public void WriteValue (string name, bool b)
{
WriteValueHeader (name, TypeCode.Boolean);
writer.Write (b);
}
public void WriteValue (string name, string s)
{
WriteValueHeader (name, TypeCode.String);
WriteString (s);
}
public void WriteValue (string name, char value)
{
WriteValueHeader (name, TypeCode.Char);
writer.Write (value);
}
public void WriteValue (string name, byte value)
{
WriteValueHeader (name, TypeCode.Byte);
writer.Write (value);
}
public void WriteValue (string name, short value)
{
WriteValueHeader (name, TypeCode.Int16);
writer.Write (value);
}
public void WriteValue (string name, int value)
{
WriteValueHeader (name, TypeCode.Int32);
writer.Write (value);
}
public void WriteValue (string name, long value)
{
WriteValueHeader (name, TypeCode.Int64);
writer.Write (value);
}
public void WriteValue (string name, DateTime value)
{
WriteValueHeader (name, TypeCode.DateTime);
writer.Write (value.Ticks);
}
public void WriteValue (string name, object ob)
{
TypeCode t = ob != null ? Type.GetTypeCode (ob.GetType ()) : TypeCode.Empty;
WriteValueHeader (name, t);
if (t != TypeCode.Empty)
WriteValue (ob, t);
}
public void WriteValue (string name, IBinaryXmlElement ob)
{
if (ob == null)
WriteValueHeader (name, TypeCode.Empty);
else {
WriteValueHeader (name, TypeCode.Object);
WriteObject (ob);
}
}
void WriteValue (object ob)
{
if (ob == null)
writer.Write ((byte) TypeCode.Empty);
else {
TypeCode t = Type.GetTypeCode (ob.GetType ());
writer.Write ((byte) t);
WriteValue (ob, t);
}
}
void WriteValue (object ob, TypeCode t)
{
switch (t) {
case TypeCode.Boolean: writer.Write ((bool)ob); break;
case TypeCode.Char: writer.Write ((char)ob); break;
case TypeCode.SByte: writer.Write ((sbyte)ob); break;
case TypeCode.Byte: writer.Write ((byte)ob); break;
case TypeCode.Int16: writer.Write ((short)ob); break;
case TypeCode.UInt16: writer.Write ((ushort)ob); break;
case TypeCode.Int32: writer.Write ((int)ob); break;
case TypeCode.UInt32: writer.Write ((uint)ob); break;
case TypeCode.Int64: writer.Write ((long)ob); break;
case TypeCode.UInt64: writer.Write ((ulong)ob); break;
case TypeCode.Single: writer.Write ((float)ob); break;
case TypeCode.Double: writer.Write ((double)ob); break;
case TypeCode.DateTime: writer.Write (((DateTime)ob).Ticks); break;
case TypeCode.String: WriteString ((string)ob); break;
case TypeCode.Object: WriteObject (ob); break;
default:
throw new InvalidOperationException ("Unexpected value type: " + t);
}
}
void WriteObject (object ob)
{
if (ob == null)
writer.Write (BinaryXmlReader.TagObjectNull);
else {
IBinaryXmlElement elem = ob as IBinaryXmlElement;
if (elem != null) {
writer.Write (BinaryXmlReader.TagObject);
WriteString (typeMap.GetTypeName (elem));
elem.Write (this);
WriteEndElement ();
}
else if (ob is IDictionary) {
IDictionary dict = (IDictionary) ob;
writer.Write (BinaryXmlReader.TagObjectDictionary);
writer.Write (dict.Count);
foreach (DictionaryEntry e in dict) {
WriteValue (e.Key);
WriteValue (e.Value);
}
}
else if (ob is ICollection) {
ICollection col = (ICollection) ob;
writer.Write (BinaryXmlReader.TagObjectArray);
if (ob is Array)
writer.Write ((byte) Type.GetTypeCode (ob.GetType().GetElementType ()));
else
writer.Write ((byte) TypeCode.Object);
writer.Write (col.Count);
foreach (object e in col) {
WriteValue (e);
}
}
else
throw new InvalidOperationException ("Invalid object type: " + ob.GetType ());
}
}
void WriteString (string s)
{
if (s == null)
writer.Write (-1);
else {
object ind = stringTable [s];
if (ind == null) {
stringTable.Add (s, stringTable.Count);
byte[] bytes = Encoding.UTF8.GetBytes (s);
writer.Write (bytes.Length);
writer.Write (bytes);
} else {
// +2 because -1 is reserved for null, and 0 is considered positive
writer.Write (-((int)ind + 2));
}
}
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins.Serialization/BinaryXmlTypeMap.cs 0000664 0001750 0001750 00000004172 12136523632 030405 0 ustar 00directhex directhex 0000000 0000000 //
// BinaryXmlTypeMap.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
namespace Mono.Addins.Serialization
{
internal class BinaryXmlTypeMap
{
Hashtable types = new Hashtable ();
Hashtable names = new Hashtable ();
public BinaryXmlTypeMap ()
{
}
public BinaryXmlTypeMap (params Type[] types)
{
foreach (Type t in types)
RegisterType (t);
}
public void RegisterType (Type type)
{
RegisterType (type, type.Name);
}
public void RegisterType (Type type, string name)
{
names [type] = name;
types [name] = type;
}
public string GetTypeName (object ob)
{
string s = (string) names [ob.GetType ()];
if (s == null)
throw new InvalidOperationException ("Type not registered: " + ob.GetType ());
return s;
}
public IBinaryXmlElement CreateObject (string typeName)
{
Type t = (Type) types [typeName];
if (t == null)
return null;
return (IBinaryXmlElement) Activator.CreateInstance (t,true);
}
}
}
mono-addins-1.0/Mono.Addins/Mono.Addins.Serialization/BinaryXmlReader.cs 0000664 0001750 0001750 00000034322 12136523632 030230 0 ustar 00directhex directhex 0000000 0000000 //
// BinaryXmlReader.cs
//
// Author:
// Lluis Sanchez Gual
//
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
using System.Text;
using System.IO;
namespace Mono.Addins.Serialization
{
internal class BinaryXmlReader
{
BinaryReader reader;
internal const byte TagEndOfFile = 0;
internal const byte TagBeginElement = 1;
internal const byte TagEndElement = 2;
internal const byte TagValue = 4;
internal const byte TagObject = 5;
internal const byte TagObjectArray = 6;
internal const byte TagObjectDictionary = 7;
internal const byte TagObjectNull = 8;
byte currentType;
string currentName;
ArrayList stringTable = new ArrayList ();
BinaryXmlTypeMap typeMap;
object contextData;
bool ignoreDesc;
public BinaryXmlReader (Stream stream, BinaryXmlTypeMap typeMap)
{
reader = new BinaryReader (stream);
this.typeMap = typeMap;
ReadNext ();
}
public BinaryXmlTypeMap TypeMap {
get { return typeMap; }
set { typeMap = value; }
}
public object ContextData {
get { return contextData; }
set { contextData = value; }
}
// Returns 'true' if description data must be ignored when reading the contents of a file
public bool IgnoreDescriptionData {
get { return ignoreDesc; }
set { ignoreDesc = value; }
}
void ReadNext ()
{
int b = reader.BaseStream.ReadByte ();
if (b == -1) {
currentType = TagEndOfFile;
return;
}
currentType = (byte) b;
if (currentType == TagBeginElement || currentType == TagValue)
currentName = ReadString ();
}
string ReadString ()
{
// The first integer means:
// >=0: string of the specified length
// -1: null string
// <-1: a string from the string table
int len = reader.ReadInt32 ();
if (len == -1)
return null;
if (len < -1)
return (string) stringTable [-(len + 2)];
byte[] bytes = new byte [len];
int n = 0;
while (n < len) {
int read = reader.Read (bytes, n, len - n);
if (read == 0)
throw new InvalidOperationException ("Length too high for string: " + len);
n += read;
}
string s = Encoding.UTF8.GetString (bytes);
stringTable.Add (s);
return s;
}
public string LocalName {
get { return currentName; }
}
public bool IsElement {
get { return currentType == TagBeginElement; }
}
public bool IsValue {
get { return currentType == TagValue; }
}
TypeCode ReadValueType (TypeCode type)
{
if (currentType != TagValue)
throw new InvalidOperationException ("Reader not positioned on a value.");
TypeCode t = (TypeCode) reader.ReadByte ();
if (t != type && type != TypeCode.Empty)
throw new InvalidOperationException ("Invalid value type. Expected " + type + ", found " + t);
return t;
}
public string ReadStringValue (string name)
{
if (!SkipToValue (name))
return null;
return ReadStringValue ();
}
public string ReadStringValue ()
{
if (currentType != TagValue)
throw new InvalidOperationException ("Reader not positioned on a value.");
TypeCode t = (TypeCode) reader.ReadByte ();
if (t == TypeCode.Empty) {
ReadNext ();
return null;
}
if (t != TypeCode.String)
throw new InvalidOperationException ("Invalid value type. Expected String, found " + t);
string s = ReadString ();
ReadNext ();
return s;
}
public bool ReadBooleanValue (string name)
{
if (!SkipToValue (name))
return false;
return ReadBooleanValue ();
}
public bool ReadBooleanValue ()
{
ReadValueType (TypeCode.Boolean);
bool value = reader.ReadBoolean ();
ReadNext ();
return value;
}
public char ReadCharValue (string name)
{
if (!SkipToValue (name))
return (char)0;
return ReadCharValue ();
}
public char ReadCharValue ()
{
ReadValueType (TypeCode.Char);
char value = reader.ReadChar ();
ReadNext ();
return value;
}
public byte ReadByteValue (string name)
{
if (!SkipToValue (name))
return (byte)0;
return ReadByteValue ();
}
public byte ReadByteValue ()
{
ReadValueType (TypeCode.Byte);
byte value = reader.ReadByte ();
ReadNext ();
return value;
}
public short ReadInt16Value (string name)
{
if (!SkipToValue (name))
return (short)0;
return ReadInt16Value ();
}
public short ReadInt16Value ()
{
ReadValueType (TypeCode.Int16);
short value = reader.ReadInt16 ();
ReadNext ();
return value;
}
public int ReadInt32Value (string name)
{
if (!SkipToValue (name))
return 0;
return ReadInt32Value ();
}
public int ReadInt32Value ()
{
ReadValueType (TypeCode.Int32);
int value = reader.ReadInt32 ();
ReadNext ();
return value;
}
public long ReadInt64Value (string name)
{
if (!SkipToValue (name))
return (long)0;
return ReadInt64Value ();
}
public long ReadInt64Value ()
{
ReadValueType (TypeCode.Int64);
long value = reader.ReadInt64 ();
ReadNext ();
return value;
}
public DateTime ReadDateTimeValue (string name)
{
if (!SkipToValue (name))
return DateTime.MinValue;
return ReadDateTimeValue ();
}
public DateTime ReadDateTimeValue ()
{
ReadValueType (TypeCode.DateTime);
DateTime value = new DateTime (reader.ReadInt64 ());
ReadNext ();
return value;
}
public object ReadValue (string name)
{
if (!SkipToValue (name))
return null;
return ReadValue ();
}
public object ReadValue ()
{
object res = ReadValueInternal ();
ReadNext ();
return res;
}
public object ReadValue (string name, object targetInstance)
{
if (!SkipToValue (name))
return null;
return ReadValue (targetInstance);
}
public object ReadValue (object targetInstance)
{
TypeCode t = (TypeCode) reader.ReadByte ();
if (t == TypeCode.Empty) {
ReadNext ();
return null;
}
if (t != TypeCode.Object)
throw new InvalidOperationException ("Invalid value type. Expected Object, found " + t);
object res = ReadObject (targetInstance);
ReadNext ();
return res;
}
object ReadValueInternal ()
{
TypeCode t = (TypeCode) reader.ReadByte ();
if (t == TypeCode.Empty)
return null;
return ReadValueInternal (t);
}
object ReadValueInternal (TypeCode t)
{
object res;
switch (t) {
case TypeCode.Boolean: res = reader.ReadBoolean (); break;
case TypeCode.Char: res = reader.ReadChar (); break;
case TypeCode.SByte: res = reader.ReadSByte (); break;
case TypeCode.Byte: res = reader.ReadByte (); break;
case TypeCode.Int16: res = reader.ReadInt16 (); break;
case TypeCode.UInt16: res = reader.ReadUInt16 (); break;
case TypeCode.Int32: res = reader.ReadInt32 (); break;
case TypeCode.UInt32: res = reader.ReadUInt32 (); break;
case TypeCode.Int64: res = reader.ReadInt64 (); break;
case TypeCode.UInt64: res = reader.ReadUInt64 (); break;
case TypeCode.Single: res = reader.ReadSingle (); break;
case TypeCode.Double: res = reader.ReadDouble (); break;
case TypeCode.DateTime: res = new DateTime (reader.ReadInt64 ()); break;
case TypeCode.String: res = ReadString (); break;
case TypeCode.Object: res = ReadObject (null); break;
case TypeCode.Empty: res = null; break;
default:
throw new InvalidOperationException ("Unexpected value type: " + t);
}
return res;
}
bool SkipToValue (string name)
{
do {
if ((currentType == TagBeginElement || currentType == TagValue) && currentName == name)
return true;
if (EndOfElement)
return false;
Skip ();
} while (true);
}
public void ReadBeginElement ()
{
if (currentType != TagBeginElement)
throw new InvalidOperationException ("Reader not positioned on an element.");
ReadNext ();
}
public void ReadEndElement ()
{
if (currentType != TagEndElement)
throw new InvalidOperationException ("Reader not positioned on an element.");
ReadNext ();
}
public bool EndOfElement {
get { return currentType == TagEndElement; }
}
public void Skip ()
{
if (currentType == TagValue)
ReadValue ();
else if (currentType == TagEndElement)
ReadNext ();
else if (currentType == TagBeginElement) {
ReadNext ();
while (!EndOfElement)
Skip ();
ReadNext ();
}
}
object ReadObject (object targetInstance)
{
byte ot = reader.ReadByte ();
if (ot == TagObjectNull) {
return null;
}
else if (ot == TagObject) {
string tname = ReadString ();
IBinaryXmlElement ob;
if (targetInstance != null) {
ob = targetInstance as IBinaryXmlElement;
if (ob == null)
throw new InvalidOperationException ("Target instance has an invalid type. Expected an IBinaryXmlElement implementation.");
} else {
ob = typeMap.CreateObject (tname);
}
ReadNext ();
ob.Read (this);
while (currentType != TagEndElement)
Skip ();
return ob;
}
else if (ot == TagObjectArray) {
TypeCode tc = (TypeCode) reader.ReadByte ();
int len = reader.ReadInt32 ();
if (targetInstance != null) {
IList list = targetInstance as IList;
if (list == null)
throw new InvalidOperationException ("Target instance has an invalid type. Expected an IList implementation.");
for (int n=0; n");
DumpElement (ind + IndSize);
Console.WriteLine (new string (' ', ind) + "");
}
}
public void DumpElement (int ind)
{
ReadNext ();
while (currentType != TagEndElement) {
Dump (ind + IndSize);
ReadNext ();
}
}
void DumpValue (int ind)
{
TypeCode t = (TypeCode) reader.ReadByte ();
if (t != TypeCode.Object) {
object ob = ReadValueInternal (t);
if (ob == null) ob = "(null)";
Console.Write (ob);
} else {
byte ot = reader.ReadByte ();
switch (ot) {
case TagObjectNull: {
Console.Write ("(null)");
break;
}
case TagObject: {
string tname = ReadString ();
Console.WriteLine ("(" + tname + ")");
DumpElement (ind + IndSize);
break;
}
case TagObjectArray: {
TypeCode tc = (TypeCode) reader.ReadByte ();
int len = reader.ReadInt32 ();
Console.WriteLine ("(" + tc + "[" + len + "])");
for (int n=0; n
mono-addins-1.0/Mono.Addins/policy.0.3.config 0000664 0001750 0001750 00000000546 12136524024 022706 0 ustar 00directhex directhex 0000000 0000000
mono-addins-1.0/Mono.Addins/obj/ 0000775 0001750 0001750 00000000000 12136524043 020467 5 ustar 00directhex directhex 0000000 0000000 mono-addins-1.0/Mono.Addins/obj/Debug/ 0000775 0001750 0001750 00000000000 12136524043 021515 5 ustar 00directhex directhex 0000000 0000000 mono-addins-1.0/Mono.Addins/obj/Debug/Mono.Addins.csproj.FilesWrittenAbsolute.txt 0000664 0001750 0001750 00000000300 12136524037 031777 0 ustar 00directhex directhex 0000000 0000000 /tmp/mono-addins/bin/Mono.Addins.dll.mdb
/tmp/mono-addins/bin/Mono.Addins.dll
/tmp/mono-addins/Mono.Addins/obj/Debug/Mono.Addins.dll
/tmp/mono-addins/Mono.Addins/obj/Debug/Mono.Addins.dll.mdb
mono-addins-1.0/Mono.Addins/ChangeLog 0000664 0001750 0001750 00000122057 12136523632 021501 0 ustar 00directhex directhex 0000000 0000000 2010-10-14 Lluis Sanchez Gual
* AddinScanner.cs: Don't inherit CustomExtension attributes.
The attribute must be explicitly applied to classes to be
marked as extensions.
2010-07-01 Lluis Sanchez Gual
* Mono.Addins.csproj:
* Mono.Addins.Description/Extension.cs:
* Mono.Addins.Description/Dependency.cs:
* Mono.Addins.Description/AddinFlags.cs:
* Mono.Addins.Description/ExtensionPoint.cs:
* Mono.Addins.Description/AddinDependency.cs:
* Mono.Addins.Description/AddinDescription.cs:
* Mono.Addins.Description/ExtensionNodeSet.cs:
* Mono.Addins.Description/NativeDependency.cs:
* Mono.Addins.Localization/IAddinLocalizer.cs:
* Mono.Addins.Description/ObjectDescription.cs:
* Mono.Addins.Description/ModuleDescription.cs:
* Mono.Addins.Description/ExtensionNodeType.cs:
* Mono.Addins.Description/NodeTypeAttribute.cs:
* Mono.Addins.Description/AssemblyDependency.cs:
* Mono.Addins.Description/ExtensionCollection.cs:
* Mono.Addins.Description/DependencyCollection.cs:
* Mono.Addins.Localization/IPluralAddinLocalizer.cs:
* Mono.Addins.Localization/IAddinLocalizerFactory.cs:
* Mono.Addins.Description/ExtensionNodeDescription.cs:
* Mono.Addins.Description/ExtensionPointCollection.cs:
* Mono.Addins.Description/ConditionTypeDescription.cs:
* Mono.Addins.Description/ExtensionNodeSetCollection.cs:
* Mono.Addins.Description/ModuleDescriptionCollection.cs:
* Mono.Addins.Description/NodeTypeAttributeCollection.cs:
* Mono.Addins.Description/ExtensionNodeTypeCollection.cs:
* Mono.Addins.Description/ObjectDescriptionCollection.cs:
* Mono.Addins.Description/ExtensionNodeDescriptionCollection.cs:
* Mono.Addins.Description/ConditionTypeDescriptionCollection.cs:
Added documentation.
2010-06-17 Lluis Sanchez Gual
* Mono.Addins/NodeElement.cs:
* Mono.Addins/RuntimeAddin.cs:
* Mono.Addins/IProgressStatus.cs:
* Mono.Addins/IAddinInstaller.cs:
* Mono.Addins/TypeExtensionNode.cs:
* Mono.Addins/ExtensionNodeList.cs:
* Mono.Addins/InstanceExtensionNode.cs:
* Mono.Addins/NodeAttributeAttribute.cs:
* Mono.Addins/ExtensionNodeAttribute.cs:
* Mono.Addins/ExtensionPointAttribute.cs:
* Mono.Addins/ImportAddinFileAttribute.cs:
* Mono.Addins/MissingDependencyException.cs:
* Mono.Addins/TypeExtensionPointAttribute.cs:
* Mono.Addins/ExtensionNodeChildAttribute.cs:
* Mono.Addins/ImportAddinAssemblyAttribute.cs: Added some
documentation.
2010-05-27 Lluis Sanchez Gual
* Mono.Addins/AddinManager.cs:
* Mono.Addins/ConditionType.cs:
* Mono.Addins/ExtensionNode.cs:
* Mono.Addins/ExtensionContext.cs:
* Mono.Addins/ExtensionAttribute.cs:
* Mono.Addins/AddinRootAttribute.cs:
* Mono.Addins/ConsoleProgressStatus.cs:
* Mono.Addins/CustomExtensionAttribute.cs:
* Mono.Addins/ExtensionAttributeAttribute.cs: More
documentation.
2010-05-27 Lluis Sanchez Gual
* Mono.Addins/AddinEngine.cs:
* Mono.Addins/AddinManager.cs:
* Mono.Addins/AddinRegistry.cs:
* Mono.Addins/AddinEventArgs.cs:
* Mono.Addins/AddinLocalizer.cs:
* Mono.Addins/AddinAttribute.cs:
* Mono.Addins/AddinErrorEventArgs.cs:
* Mono.Addins/AddinModuleAttribute.cs:
* Mono.Addins/AddinAuthorAttribute.cs:
* Mono.Addins/AddinDependencyAttribute.cs:
* Mono.Addins/AddinLocalizerGettextAttribute.cs: Added some
API documentation.
2010-05-25 Lluis Sanchez Gual
* Mono.Addins.Database/AddinScanResult.cs: Properly resolve
Mono.Addins.
2010-05-25 Lluis Sanchez Gual
* Mono.Addins/AddinManager.cs:
* Mono.Addins/ExtensionContext.cs: Added methods for
subscribing type-bound extension points.
2010-05-25 Lluis Sanchez Gual
* Mono.Addins.csproj: Add Debug and Release configurations.
* Mono.Addins.Database/AddinScanner.cs: Fixed node type
parsing issue with TypeExtensionPointAttribute.
2010-05-21 Lluis Sanchez Gual
* Mono.Addins.Database/AddinUpdateData.cs: When resolving
extension from an optional module, include dependencies
defined in the main module.
* Mono.Addins.Database/SetupDomain.cs: Flush.
* Mono.Addins.Database/AddinScanner.cs: Look for assembly
imports in the main assembly.
2010-05-21 Lluis Sanchez Gual
* Mono.Addins/ExtensionNode.cs:
* Mono.Addins/ExtensionTree.cs: Data extension points bound to
an attribute now generate nodes of type
ExtensionNode
* Mono.Addins/Addin.cs: Added some docs.
* Mono.Addins.Database/AddinScanner.cs:
* Mono.Addins/ExtensionNodeAttribute.cs:
* Mono.Addins.Database/AddinUpdateData.cs:
* Mono.Addins.Description/ExtensionNodeType.cs: Changed name
of property (for consistency)
* Mono.Addins/ExtensionPointAttribute.cs: Don't set a default
node name. The default name is assigned while scanning.
* Mono.Addins.Database/DefaultAssemblyReflector.cs: This class
should not be public.
2010-05-20 Lluis Sanchez Gual
* Makefile.am:
* Mono.Addins.csproj: Updated.
* Mono.Addins/TreeNode.cs:
* Mono.Addins/AddinEngine.cs:
* Mono.Addins/RuntimeAddin.cs:
* Mono.Addins/AddinManager.cs:
* Mono.Addins/ExtensionTree.cs:
* Mono.Addins/ExtensionNode.cs:
* Mono.Addins/ConditionType.cs:
* Mono.Addins/AddinRegistry.cs:
* Mono.Addins/ExtensionContext.cs:
* Mono.Addins/AddinSessionService.cs:
* Mono.Addins.Database/AddinDatabase.cs:
* Mono.Addins.Description/Dependency.cs:
* Mono.Addins.Description/AddinDependency.cs:
* Mono.Addins.Description/NativeDependency.cs:
* Mono.Addins.Description/AssemblyDependency.cs: New
AddinEngine class, which can be used to support several
engines in a single domain.
* Mono.Addins/AddinAttribute.cs:
* Mono.Addins/AddinModuleAttribute.cs:
* Mono.Addins.Database/AddinScanner.cs:
* Mono.Addins/ImportAddinFileAttribute.cs:
* Mono.Addins/ImportAddinAssemblyAttribute.cs: Added support
for new add-in declaration attributes.
* Mono.Addins/AddinCategoryAttribute.cs: Removed.
* Mono.Addins/ExtensionPointAttribute.cs:
* Mono.Addins/TypeExtensionPointAttribute.cs: Use a better
name for the custom attribute type property.
* Mono.Addins.Database/IAssemblyReflector.cs:
* Mono.Addins.Database/DefaultAssemblyReflector.cs: Added
methods for getting resources from an assembly.
2010-03-30 Lluis Sanchez Gual
* Mono.Addins.Serialization/BinaryXmlReader.cs: Properly
detect EOF.
* Mono.Addins/Addin.cs: If a file is corrupted and can't be
read, delete it so that it can be properly regenerated.
2010-03-30 Lluis Sanchez Gual
* Mono.Addins.csproj: csc doesn't like iso-2.
2010-03-29 Lluis Sanchez Gual
* Mono.Addins.csproj:
* Mono.Addins/TypeExtensionNode.cs:
* Mono.Addins/AddinAuthorAttribute.cs:
* Mono.Addins.Database/AddinScanner.cs:
* Mono.Addins/CustomExtensionAttribute.cs:
* Mono.Addins.Database/IAssemblyReflector.cs:
* Mono.Addins/ExtensionAttributeAttribute.cs: Make sure the
solution builds on MS.NET 2.0.
2010-03-26 Lluis Sanchez Gual
* Mono.Addins.Database/AddinScanner.cs: Fix bug #541661 -
Assemblies with capital .DLL cannot be loaded.
2010-03-26 Lluis Sanchez Gual
* Makefile.am:
* Mono.Addins.csproj:
* Mono.Addins/AddinAttribute.cs:
* Mono.Addins/AddinAuthorAttribute.cs:
* Mono.Addins.Database/AddinScanner.cs:
* Mono.Addins/AddinCategoryAttribute.cs:
* Mono.Addins/AddinLocalizerGettextAttribute.cs: Allow
specifying some add-in properties using attribtues.
2010-03-26 Lluis Sanchez Gual
* Mono.Addins.Database/AddinScanner.cs:
* Mono.Addins.Description/AddinDescription.cs: Added support
for multiple .addin.xml files in a single assembly.
2010-03-26 Lluis Sanchez Gual
* Makefile.am:
* Mono.Addins.csproj:
* Mono.Addins/AddinManager.cs:
* Mono.Addins/ExtensionNode.cs:
* Mono.Addins/ExtensionTree.cs:
* Mono.Addins/ExtensionContext.cs:
* Mono.Addins/TypeExtensionNode.cs:
* Mono.Addins/ExtensionNodeList.cs:
* Mono.Addins/ExtensionAttribute.cs:
* Mono.Addins.Database/AddinScanner.cs:
* Mono.Addins/ExtensionNodeAttribute.cs:
* Mono.Addins/NodeAttributeAttribute.cs:
* Mono.Addins/ExtensionPointAttribute.cs:
* Mono.Addins.Database/AddinUpdateData.cs:
* Mono.Addins/CustomExtensionAttribute.cs:
* Mono.Addins/ExtensionAttributeAttribute.cs:
* Mono.Addins.Database/IAssemblyReflector.cs:
* Mono.Addins/TypeExtensionPointAttribute.cs:
* Mono.Addins.Description/ExtensionNodeType.cs:
* Mono.Addins.Database/DefaultAssemblyReflector.cs:
* Mono.Addins.Description/ExtensionNodeDescription.cs: Allow
using custom attributes for specifying extension node
metadata.
* Mono.Addins.Database/AddinDatabase.cs: Consolidate
extensions before saving the final add-in descriptions. That
means merging extensions with the same path and making sure
the extension nodes have a correct ordering.
2010-03-25 Lluis Sanchez Gual
* Mono.Addins.Database/AddinScanner.cs: Removed special
handling of type references inside add-in roots. Type
references will now be resolved like in the add-ins, when
mapping the extensions.
2010-03-01 Lluis Sanchez Gual
* Mono.Addins.Database/AddinDatabase.cs: Let's use app domains
for mono too.
2010-02-26 Lluis Sanchez Gual