public override void OnMultipleNodeDrop(object[] dataObjects, DragOperation operation, DropPosition pos)
{
DotNetProject p = (DotNetProject)CurrentNode.GetParentDataItem(typeof(Project), false);
AddinData adata = p.GetAddinData();
ExtensionNodeInfo en = (ExtensionNodeInfo)CurrentNode.DataItem;
foreach (ExtensionNodeInfo newNode in dataObjects)
{
if (newNode.Node.Parent is ExtensionNodeDescription)
{
((ExtensionNodeDescription)newNode.Node.Parent).ChildNodes.Remove(en.Node);
}
else
{
((Extension)newNode.Node.Parent).ExtensionNodes.Remove(newNode.Node);
}
InsertNode(adata, en, pos, newNode.Node);
// Add all other nodes after the first node
en = newNode;
pos = DropPosition.After;
}
adata.CachedAddinManifest.Save();
adata.NotifyChanged(false);
}
public override void ActivateItem()
{
DotNetProject project = (DotNetProject)CurrentNode.GetParentDataItem(typeof(DotNetProject), true);
if (project == null)
{
return;
}
AddinData data = project.GetAddinData();
if (data == null)
{
return;
}
ExtensionPoint ep = (ExtensionPoint)CurrentNode.DataItem;
ExtensionPoint epc = new ExtensionPoint();
epc.CopyFrom(ep);
NewExtensionPointDialog epdlg = new NewExtensionPointDialog(project, data.AddinRegistry, data.CachedAddinManifest, epc);
if (epdlg.Run() == (int)Gtk.ResponseType.Ok)
{
ep.CopyFrom(epc);
data.CachedAddinManifest.Save();
}
epdlg.Destroy();
}
public void OnAddExtensionPoint()
{
DotNetProject project = (DotNetProject)CurrentNode.DataItem;
if (project == null)
{
return;
}
AddinData data = project.GetAddinData();
if (project == null)
{
return;
}
ExtensionPoint ep = new ExtensionPoint();
NewExtensionPointDialog dlg = new NewExtensionPointDialog(project, data.AddinRegistry, data.CachedAddinManifest, ep);
try {
if (dlg.Run() == (int)Gtk.ResponseType.Ok)
{
data.CachedAddinManifest.ExtensionPoints.Add(ep);
data.SaveAddinManifest();
data.NotifyChanged(false);
}
} finally {
dlg.Destroy();
}
}
public void OnUpdateAddExtension(CommandInfo cinfo)
{
if (CurrentNode.DataItem is ProjectFolder || CurrentNode.DataItem is DotNetProject)
{
DotNetProject p = CurrentNode.GetParentDataItem(typeof(Project), true) as DotNetProject;
cinfo.Visible = p != null && AddinData.GetAddinData(p) != null;
}
}
public void OnAddExtension()
{
DotNetProject project = (DotNetProject)CurrentNode.DataItem;
if (project == null)
{
return;
}
AddinData data = project.GetAddinData();
if (project == null)
{
return;
}
AddinDescription adesc = data.CachedAddinManifest;
ExtensionSelectorDialog dlg = new ExtensionSelectorDialog(data.AddinRegistry, adesc, adesc.IsRoot, false);
if (dlg.Run() == (int)Gtk.ResponseType.Ok)
{
foreach (object ob in dlg.GetSelection())
{
AddinDescription desc = null;
if (ob is ExtensionPoint)
{
ExtensionPoint ep = (ExtensionPoint)ob;
Extension ext = new Extension(ep.Path);
adesc.MainModule.Extensions.Add(ext);
desc = (AddinDescription)ep.Parent;
}
else if (ob is ExtensionNodeDescription)
{
ExtensionNodeDescription node = (ExtensionNodeDescription)ob;
desc = node.ParentAddinDescription;
string path = "";
while (node != null && !(node.Parent is Extension))
{
if (!node.IsCondition)
{
path = "/" + node.Id + path;
}
node = node.Parent as ExtensionNodeDescription;
}
Extension eext = (Extension)node.Parent;
Extension ext = new Extension(eext.Path + "/" + node.Id + path);
adesc.MainModule.Extensions.Add(ext);
}
if (adesc.AddinId != desc.AddinId && !adesc.MainModule.DependsOnAddin(desc.AddinId))
{
adesc.MainModule.Dependencies.Add(new AddinDependency(desc.AddinId));
}
}
adesc.Save();
}
dlg.Destroy();
}
void UpdateAddinDescription()
{
try {
AddinData adata = AddinData.GetAddinData((DotNetProject)this.Document.Project);
adesc = adata.AddinRegistry.ReadAddinManifestFile(new StringReader(Editor.Text), Document.FileName);
registry = adata.AddinRegistry;
} catch {
}
}
ExtensionNodeDescription InsertNode(AddinData adata, ExtensionNodeInfo refNode, DropPosition pos, ExtensionNodeDescription newNode)
{
ExtensionNodeDescriptionCollection nodes = null;
newNode.InsertBefore = "";
newNode.InsertAfter = "";
if (refNode.CanModify)
{
if (pos == DropPosition.Into)
{
nodes = refNode.Node.ChildNodes;
}
else if (refNode.Node.Parent is ExtensionNodeDescription)
{
nodes = ((ExtensionNodeDescription)refNode.Node.Parent).ChildNodes;
}
}
else
{
if (pos == DropPosition.After)
{
newNode.InsertAfter = refNode.Node.Id;
}
else if (pos == DropPosition.Before)
{
newNode.InsertBefore = refNode.Node.Id;
}
}
if (nodes == null)
{
string path = refNode.Node.GetParentPath();
if (pos == DropPosition.Into)
{
path += "/" + refNode.Node.Id;
}
Extension ext = adata.CachedAddinManifest.MainModule.GetExtension(path);
nodes = ext.ExtensionNodes;
}
for (int n = 0; n < nodes.Count; n++)
{
ExtensionNodeDescription node = nodes [n];
if (node == refNode.Node)
{
if (pos == DropPosition.After)
{
n++;
}
nodes.Insert(n, newNode);
return(newNode);
}
}
nodes.Add(newNode);
return(newNode);
}
void OnProjectChanged(object s, EventArgs a)
{
AddinData data = (AddinData)s;
ITreeBuilder tb = Context.GetTreeBuilder(data.Project);
if (tb != null)
{
tb.UpdateAll();
}
}
void HandleDataChanged(object sender, EventArgs e)
{
AddinData data = (AddinData)sender;
ITreeBuilder tb = Context.GetTreeBuilder(data.Project);
if (tb != null)
{
tb.UpdateAll();
}
}
public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
AddinData data = (AddinData)dataObject;
ProjectFile file = data.Project.GetProjectFile(data.AddinManifestFileName);
if (file != null)
{
builder.AddChild(file);
}
}
public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
if (dataObject is DotNetProject)
{
AddinData data = AddinData.GetAddinData((DotNetProject)dataObject);
if (data != null)
{
builder.AddChild(data);
}
}
}
public override void OnNodeAdded(object dataObject)
{
if (dataObject is DotNetProject)
{
AddinData data = AddinData.GetAddinData((DotNetProject)dataObject);
if (data != null)
{
data.Changed += OnProjectChanged;
}
}
}
public override void DeleteItem()
{
DotNetProject p = CurrentNode.GetParentDataItem(typeof(Project), true) as DotNetProject;
AddinData data = AddinData.GetAddinData(p);
AddinDependency adep = (AddinDependency)CurrentNode.DataItem;
string q = AddinManager.CurrentLocalizer.GetString("Are you sure you want to remove the reference to add-in '{0}'?", Addin.GetIdName(adep.AddinId));
if (MessageService.Confirm(q, AlertButton.Remove))
{
AddinAuthoringService.RemoveReferences(data, new string[] { adep.FullAddinId });
}
}
public void AddAddinDependency()
{
DotNetProject p = CurrentNode.GetParentDataItem(typeof(Project), true) as DotNetProject;
AddinData data = AddinData.GetAddinData(p);
ExtensionSelectorDialog dlg = new ExtensionSelectorDialog(data.AddinRegistry, null, data.CachedAddinManifest.IsRoot, true);
if (dlg.Run() == (int)Gtk.ResponseType.Ok)
{
AddinAuthoringService.AddReferences(data, dlg.GetSelection());
}
dlg.Destroy();
}
public override void OnNodeRemoved(object dataObject)
{
DotNetProject project = (DotNetProject)dataObject;
project.NameChanged -= projectNameChanged;
AddinData data = project.GetAddinData();
if (data != null)
{
data.Changed -= HandleDataChanged;
}
}
public void AddNodeBefore(object data)
{
DotNetProject p = (DotNetProject)CurrentNode.GetParentDataItem(typeof(Project), false);
AddinData adata = p.GetAddinData();
ExtensionNodeInfo en = (ExtensionNodeInfo)CurrentNode.DataItem;
ExtensionNodeType ntype = (ExtensionNodeType)data;
ExtensionNodeDescription newNode = new ExtensionNodeDescription(ntype.NodeName);
InsertNode(adata, en, DropPosition.Before, newNode);
adata.CachedAddinManifest.Save();
adata.NotifyChanged(false);
}
public static IEnumerable <object> BuildChildNodes(ITreeBuilder treeBuilder, AddinData data, Func <AddinDescription, bool> includeAddin)
{
AddinDescription adesc = data.CachedAddinManifest;
HashSet <string> localPoints = new HashSet <string> ();
if (includeAddin(adesc))
{
foreach (ExtensionPoint ep in adesc.ExtensionPoints)
{
yield return(ep);
localPoints.Add(ep.Path);
}
}
foreach (Extension ext in adesc.MainModule.Extensions)
{
if (!localPoints.Contains(ext.Path))
{
if (includeAddin != null)
{
object ob = ext.GetExtendedObject();
while (!(ob is ExtensionPoint) && ob != null)
{
if (ob is Extension)
{
ob = ((Extension)ob).GetExtendedObject();
}
else if (ob is ExtensionNodeDescription)
{
ob = ((ExtensionNodeDescription)ob).Parent;
}
else
{
ob = null;
}
}
if (ob != null && includeAddin(((ExtensionPoint)ob).ParentAddinDescription))
{
yield return(ext);
}
}
else
{
yield return(ext);
}
}
}
}
public override void BuildChildNodes(ITreeBuilder treeBuilder, object dataObject)
{
base.BuildChildNodes(treeBuilder, dataObject);
DotNetProject p = (DotNetProject)treeBuilder.GetParentDataItem(typeof(DotNetProject), false);
if (p != null)
{
AddinData data = AddinData.GetAddinData(p);
if (data != null)
{
foreach (Dependency adep in data.CachedAddinManifest.MainModule.Dependencies)
{
treeBuilder.AddChild(adep);
}
}
}
}
public void OnAddExtension()
{
DotNetProject p = CurrentNode.GetParentDataItem(typeof(Project), true) as DotNetProject;
AddinData data = AddinData.GetAddinData(p);
AddinDescription desc = data.LoadAddinManifest();
ExtensionSelectorDialog dlg = new ExtensionSelectorDialog(data.AddinRegistry, null, desc.IsRoot, false);
if (dlg.Run() == (int)ResponseType.Ok)
{
foreach (object ob in dlg.GetSelection())
{
Console.WriteLine("pp s: " + ob);
}
}
dlg.Destroy();
}
public override bool HasChildNodes(ITreeBuilder builder, object dataObject)
{
if (base.HasChildNodes(builder, dataObject))
{
return(true);
}
DotNetProject p = (DotNetProject)builder.GetParentDataItem(typeof(DotNetProject), false);
if (p != null)
{
AddinData data = AddinData.GetAddinData(p);
if (data != null)
{
return(data.CachedAddinManifest.MainModule.Dependencies.Count > 0);
}
}
return(false);
}
public override void OnAddAttributeValues(string attName)
{
if (attName == "insertafter" || attName == "insertbefore")
{
string parentPath = ((BaseExtensionCompletionContext)ParentContext).GetPath();
if (parentPath != null)
{
foreach (ExtensionNodeDescription en in AddinData.GetExtensionNodes(AddinRegistry, AddinDescription, parentPath))
{
if (!string.IsNullOrEmpty(en.Id))
{
ExtensionNodeType nt = en.GetNodeType();
string desc = nt != null ? nt.Description : "";
Add(en.Id, desc);
}
}
}
}
}
public override void DeleteMultipleItems()
{
if (MessageService.Confirm(GettextCatalog.GetString("Are you sure you want to delete the selected nodes?"), AlertButton.Delete))
{
foreach (var nav in CurrentNodes)
{
ExtensionNodeInfo en = (ExtensionNodeInfo)nav.DataItem;
if (en.Node.Parent is Extension)
{
((Extension)en.Node.Parent).ExtensionNodes.Remove(en.Node);
}
else if (en.Node.Parent is ExtensionNodeDescription)
{
((ExtensionNodeDescription)en.Node.Parent).ChildNodes.Remove(en.Node);
}
}
}
DotNetProject p = (DotNetProject)CurrentNode.GetParentDataItem(typeof(Project), false);
AddinData adata = p.GetAddinData();
adata.SaveAddinManifest();
adata.NotifyChanged(false);
}
public override void DeleteMultipleItems()
{
string msg = GettextCatalog.GetString("The following extensions and all the nodes they contain will be deleted:") + "\n\n";
foreach (var nav in CurrentNodes)
{
msg += Util.GetDisplayName((Extension)nav.DataItem) + "\n";
}
if (MessageService.Confirm(GettextCatalog.GetString("Are you sure you want to delete the selected extensions?"), msg, AlertButton.Delete))
{
foreach (var nav in CurrentNodes)
{
Extension ex = (Extension)nav.DataItem;
ModuleDescription module = (ModuleDescription)ex.Parent;
module.Extensions.Remove(ex);
}
}
DotNetProject p = (DotNetProject)CurrentNode.GetParentDataItem(typeof(Project), false);
AddinData adata = p.GetAddinData();
adata.SaveAddinManifest();
adata.NotifyChanged(false);
}
public override void BuildChildNodes(ITreeBuilder builder, object dataObject)
{
DotNetProject project = (DotNetProject)dataObject;
AddinData data = project.GetAddinData();
if (data != null && data.CachedAddinManifest != null)
{
AddinDescription adesc = data.CachedAddinManifest;
HashSet <string> localPoints = new HashSet <string> ();
foreach (ExtensionPoint ep in adesc.ExtensionPoints)
{
builder.AddChild(ep);
localPoints.Add(ep.Path);
}
foreach (Extension ext in adesc.MainModule.Extensions)
{
if (!localPoints.Contains(ext.Path))
{
builder.AddChild(ext);
}
}
}
}
public override void DeleteMultipleItems()
{
string msg = GettextCatalog.GetString("The following extension points and all the nodes they contain will be deleted:") + "\n\n";
foreach (var nav in CurrentNodes)
{
msg += Util.GetDisplayName((ExtensionPoint)nav.DataItem) + "\n";
}
if (MessageService.Confirm(GettextCatalog.GetString("Are you sure you want to delete the selected extension points?"), msg, AlertButton.Delete))
{
foreach (var nav in CurrentNodes)
{
ExtensionPoint ep = (ExtensionPoint)nav.DataItem;
ep.ParentAddinDescription.ExtensionPoints.Remove(ep);
foreach (ModuleDescription module in ep.ParentAddinDescription.AllModules)
{
List <Extension> toDelete = new List <Extension> ();
foreach (Extension ext in module.Extensions)
{
if (ext.Path == ep.Path || ext.Path.StartsWith(ep.Path + "/"))
{
toDelete.Add(ext);
}
}
foreach (Extension ext in toDelete)
{
module.Extensions.Remove(ext);
}
}
}
}
DotNetProject p = (DotNetProject)CurrentNode.GetParentDataItem(typeof(Project), false);
AddinData adata = p.GetAddinData();
adata.SaveAddinManifest();
adata.NotifyChanged(false);
}
public void AddNodeBefore(object data)
{
DotNetProject p = (DotNetProject)CurrentNode.GetParentDataItem(typeof(Project), false);
AddinData adata = p.GetAddinData();
Extension en = GetExtension();
ExtensionNodeType ntype = (ExtensionNodeType)data;
ExtensionNodeDescription newNode = new ExtensionNodeDescription(ntype.NodeName);
en.ExtensionNodes.Add(newNode);
CurrentNode.Expanded = true;
adata.SaveAddinManifest();
adata.NotifyChanged(false);
DispatchService.GuiDispatch(delegate {
ITreeNavigator nav = Tree.GetNodeAtObject(new ExtensionNodeInfo(newNode, false));
if (nav != null)
{
nav.Selected = true;
}
});
}
ExtensionNodeDescription InsertNode (AddinData adata, ExtensionNodeInfo refNode, DropPosition pos, ExtensionNodeDescription newNode)
{
ExtensionNodeDescriptionCollection nodes = null;
newNode.InsertBefore = "";
newNode.InsertAfter = "";
if (refNode.CanModify) {
if (pos == DropPosition.Into)
nodes = refNode.Node.ChildNodes;
else if (refNode.Node.Parent is ExtensionNodeDescription)
nodes = ((ExtensionNodeDescription)refNode.Node.Parent).ChildNodes;
} else {
if (pos == DropPosition.After)
newNode.InsertAfter = refNode.Node.Id;
else if (pos == DropPosition.Before)
newNode.InsertBefore = refNode.Node.Id;
}
if (nodes == null) {
string path = refNode.Node.GetParentPath ();
if (pos == DropPosition.Into)
path += "/" + refNode.Node.Id;
Extension ext = adata.CachedAddinManifest.MainModule.GetExtension (path);
nodes = ext.ExtensionNodes;
}
for (int n = 0; n < nodes.Count; n++) {
ExtensionNodeDescription node = nodes [n];
if (node == refNode.Node) {
if (pos == DropPosition.After) n++;
nodes.Insert (n, newNode);
return newNode;
}
}
nodes.Add (newNode);
return newNode;
}
public void SetSourceTagBuildDataAsync(int appId, int stagId, AddinData[] addins)
{
this.SetSourceTagBuildDataAsync(appId, stagId, addins, null);
}
AddinData BuildProjectAddin(BuildContext ctx, SourceTagInfo stag, string logFile, string sourcePath, AppReleaseInfo rel, AddinProjectAddin addin)
{
SetupService ss = new SetupService();
bool generatedXplatPackage = false;
HashSet <string> foundPlatforms = new HashSet <string> ();
AddinData ainfo = new AddinData();
foreach (AddinProjectSource psource in addin.Sources)
{
if (string.IsNullOrEmpty(psource.AddinFile))
{
throw new Exception("AddinFile element not found in addin-project.xml");
}
string platforms = psource.Platforms;
if (string.IsNullOrEmpty(platforms))
{
platforms = ctx.Application.Platforms;
}
string[] platformList = platforms.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
foreach (string plat in platformList)
{
if (!foundPlatforms.Add(plat))
{
throw new Exception("Platform " + plat + " specificed in more than open Project element");
}
}
string outFile = NormalizePath(psource.AddinFile);
if (!string.IsNullOrEmpty(psource.BuildFile))
{
// Build the project
// Move the sources to the work area (which is sandboxed)
if (!Directory.Exists(ctx.LocalSettings.WorkAreaPath))
{
Directory.CreateDirectory(ctx.LocalSettings.WorkAreaPath);
}
string workArea = Path.Combine(ctx.LocalSettings.WorkAreaPath, "builder");
if (Directory.Exists(workArea))
{
Directory.Delete(workArea, true);
}
Directory.Move(sourcePath, workArea);
StringBuilder output = new StringBuilder();
try {
string solFile = Path.Combine(workArea, NormalizePath(psource.BuildFile));
// Restore packages
RunCommand(true, "nuget", "restore \"" + solFile + "\"", output, output, Timeout.Infinite);
string refPath = rel.GetAssembliesPath(ctx);
if (ContaintsMdTargetsFile(workArea) && !string.IsNullOrEmpty(ctx.LocalSettings.LocalAppInstallPath))
{
foreach (var p in ctx.LocalSettings.LocalAppInstallPath.Split(new [] { ';' }, StringSplitOptions.RemoveEmptyEntries))
{
var ip = Path.Combine(refPath, "__install", p);
if (Directory.Exists(ip))
{
refPath = ip;
break;
}
}
}
string ops = " \"/p:ReferencePath=" + refPath + "\"";
if (!string.IsNullOrEmpty(psource.BuildConfiguration))
{
ops += " \"/property:Configuration=" + psource.BuildConfiguration + "\"";
}
ops = ops + " \"" + solFile + "\"";
// Clean the project
RunCommand(true, ctx.LocalSettings.MSBuildCommand, "/t:Clean " + ops, output, output, Timeout.Infinite);
// Build
RunCommand(true, ctx.LocalSettings.MSBuildCommand, ops, output, output, Timeout.Infinite);
}
finally {
output = output.Replace(workArea, "/build");
File.AppendAllText(logFile, "<pre>" + HttpUtility.HtmlEncode(output.ToString()) + "</pre>");
Directory.Move(workArea, sourcePath);
}
}
// Generate the package
string tmpPath = Path.Combine(sourcePath, "tmp");
File.AppendAllText(logFile, "<p><b>Building Package</b></p>");
LocalStatusMonitor monitor = new LocalStatusMonitor();
try {
if (Directory.Exists(tmpPath))
{
Directory.Delete(tmpPath, true);
}
Directory.CreateDirectory(tmpPath);
ss.BuildPackage(monitor, tmpPath, Path.Combine(sourcePath, outFile));
string file = Directory.GetFiles(tmpPath, "*.mpack").FirstOrDefault();
if (file == null)
{
throw new Exception("Add-in generation failed");
}
AddinInfo ai = ReadAddinInfo(file);
ainfo.AddinVersion = ai.Version;
ainfo.AddinId = Mono.Addins.Addin.GetIdName(ai.Id);
if (!generatedXplatPackage && platformList.Length > 0)
{
File.Copy(file, Path.Combine(stag.GetPackagePath(ctx), "All.mpack"), true);
generatedXplatPackage = true;
}
else
{
foreach (string plat in platformList)
{
File.Copy(file, Path.Combine(stag.GetPackagePath(ctx), plat + ".mpack"), true);
}
}
}
finally {
try {
Directory.Delete(tmpPath, true);
}
catch { }
File.AppendAllText(logFile, "<pre>" + HttpUtility.HtmlEncode(monitor.ToString()) + "</pre>");
}
}
ainfo.Platforms = string.Join(" ", foundPlatforms.ToArray());
ainfo.AppVersion = rel.AppVersion;
return(ainfo);
}
public static IEnumerable<object> BuildChildNodes (ITreeBuilder treeBuilder, AddinData data, Func<AddinDescription,bool> includeAddin)
{
AddinDescription adesc = data.CachedAddinManifest;
HashSet<string> localPoints = new HashSet<string> ();
if (includeAddin (adesc)) {
foreach (ExtensionPoint ep in adesc.ExtensionPoints) {
yield return ep;
localPoints.Add (ep.Path);
}
}
foreach (Extension ext in adesc.MainModule.Extensions) {
if (!localPoints.Contains (ext.Path)) {
if (includeAddin != null) {
object ob = ext.GetExtendedObject ();
while (!(ob is ExtensionPoint) && ob != null) {
if (ob is Extension)
ob = ((Extension)ob).GetExtendedObject ();
else if (ob is ExtensionNodeDescription)
ob = ((ExtensionNodeDescription)ob).Parent;
else
ob = null;
}
if (ob != null && includeAddin (((ExtensionPoint)ob).ParentAddinDescription))
yield return ext;
} else {
yield return ext;
}
}
}
}
public System.IAsyncResult BeginSetSourceTagBuildData(int appId, int stagId, AddinData[] addins, System.AsyncCallback callback, object asyncState)
{
return this.BeginInvoke("SetSourceTagBuildData", new object[] {
appId,
stagId,
addins}, callback, asyncState);
}
public void SetSourceTagBuildData(int appId, int stagId, AddinData[] addins)
{
this.Invoke("SetSourceTagBuildData", new object[] {
appId,
stagId,
addins});
}
public override void OnNodeRemoved(object dataObject)
{
AddinData w = (AddinData)dataObject;
w.Changed -= updateDelegate;
}
public void SetSourceTagBuildDataAsync(int appId, int stagId, AddinData[] addins, object userState)
{
if ((this.SetSourceTagBuildDataOperationCompleted == null)) {
this.SetSourceTagBuildDataOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetSourceTagBuildDataCompleted);
}
this.InvokeAsync("SetSourceTagBuildData", new object[] {
appId,
stagId,
addins}, this.SetSourceTagBuildDataOperationCompleted, userState);
}
public void OnUpdateAddAddinDependency(CommandInfo cinfo)
{
DotNetProject p = CurrentNode.GetParentDataItem(typeof(Project), true) as DotNetProject;
cinfo.Visible = p != null && AddinData.GetAddinData(p) != null;
}
