public bool CanDeploy (SolutionItem entry, MakefileType type)
{
Project project = entry as Project;
if ( project == null ) return false;
if ( FindSetupForProject ( project ) == null ) return false;
return true;
}
public FeatureSupportLevel GetSupportLevel (SolutionFolder parentCombine, SolutionItem entry)
{
if (entry is Project)
return FeatureSupportLevel.SupportedByDefault;
else
return FeatureSupportLevel.NotSupported;
}
public ProjectFile AddFileToProject(SolutionItem policyParent, Project project, string language, string directory, string name)
{
generatedFile = SaveFile (policyParent, project, language, directory, name);
if (generatedFile != null) {
string buildAction = this.buildAction ?? project.GetDefaultBuildAction (generatedFile);
ProjectFile projectFile = project.AddFile (generatedFile, buildAction);
if (!string.IsNullOrEmpty (dependsOn)) {
Dictionary<string,string> tags = new Dictionary<string,string> ();
ModifyTags (policyParent, project, language, name, generatedFile, ref tags);
string parsedDepName = StringParserService.Parse (dependsOn, tags);
if (projectFile.DependsOn != parsedDepName)
projectFile.DependsOn = parsedDepName;
}
if (!string.IsNullOrEmpty (customTool))
projectFile.Generator = customTool;
DotNetProject netProject = project as DotNetProject;
if (netProject != null) {
// Add required references
foreach (string aref in references) {
string res = netProject.AssemblyContext.GetAssemblyFullName (aref, netProject.TargetFramework);
res = netProject.AssemblyContext.GetAssemblyNameForVersion (res, netProject.TargetFramework);
if (!ContainsReference (netProject, res))
netProject.References.Add (new ProjectReference (ReferenceType.Package, aref));
}
}
return projectFile;
} else
return null;
}
public override bool AddToProject (SolutionItem parent, Project project, string language, string directory, string name)
{
// Replace template variables
string cname = Path.GetFileNameWithoutExtension (name);
string[,] tags = {
{"Name", cname},
};
string content = addinTemplate.OuterXml;
content = StringParserService.Parse (content, tags);
// Create the manifest
XmlDocument doc = new XmlDocument ();
doc.LoadXml (content);
string file = Path.Combine (directory, "manifest.addin.xml");
doc.Save (file);
project.AddFile (file, BuildAction.EmbeddedResource);
AddinData.EnableAddinAuthoringSupport ((DotNetProject)project);
return true;
}
public void Fill (SolutionFolder parentCombine, SolutionItem entry, ISolutionItemFeature[] features)
{
selectedFeatures.Clear ();
selectedEditors.Clear ();
this.entry = entry;
this.parentCombine = parentCombine;
foreach (Gtk.Widget w in box.Children) {
box.Remove (w);
w.Destroy ();
}
// Show enabled features at the beginning
foreach (ISolutionItemFeature feature in features)
if (feature.GetSupportLevel (parentCombine, entry) == FeatureSupportLevel.Enabled) {
Gtk.Widget editor = AddFeature (feature);
selectedFeatures.Add (feature);
selectedEditors.Add (editor);
}
foreach (ISolutionItemFeature feature in features)
if (feature.GetSupportLevel (parentCombine, entry) != FeatureSupportLevel.Enabled)
AddFeature (feature);
if (box.Children.Length == 0) {
// No features
Label lab = new Label ();
lab.Xalign = 0;
lab.Text = GettextCatalog.GetString ("There are no additional features available for this project.");
box.PackStart (lab, false, false, 0);
lab.Show ();
}
scrolled.AddWithViewport (box);
}
public virtual object GetService (SolutionItem item, Type type)
{
if (type.IsInstanceOfType (this))
return this;
else
return GetNext (item).GetService (item, type);
}
public void ApplyFeature (SolutionFolder parentCombine, SolutionItem entry, Widget editor)
{
GtkFeatureWidget fw = (GtkFeatureWidget) editor;
ReferenceManager refmgr = new ReferenceManager ((DotNetProject) entry);
refmgr.GtkPackageVersion = fw.SelectedVersion;
refmgr.Dispose ();
}
public void Fill (PackageBuilder builder, SolutionItem selection)
{
store.Clear ();
this.builder = builder;
if (selection is SolutionFolder) {
foreach (SolutionItem e in ((SolutionFolder)selection).GetAllItems ()) {
if (builder.CanBuild (e))
selectedEntries [e] = e;
}
}
else if (selection != null) {
selectedEntries [selection] = selection;
}
if (selection != null)
solution = selection.ParentSolution;
else {
solution = IdeApp.ProjectOperations.CurrentSelectedSolution;
if (solution == null) {
ReadOnlyCollection<Solution> items = IdeApp.ProjectOperations.CurrentSelectedWorkspaceItem.GetAllSolutions ();
if (items.Count > 0)
solution = items [0];
else
return;
}
}
AddEntry (TreeIter.Zero, solution.RootFolder);
}
public DeployDialog (SolutionItem defaultEntry, bool createBuilderOnly)
{
this.Build();
notebook.ShowTabs = false;
this.defaultEntry = defaultEntry;
if (createBuilderOnly) {
vboxSaveProject.Hide ();
checkSave.Active = true;
checkSave.Hide ();
saveSeparator.Hide ();
}
else {
pageSave.Hide ();
FillProjectSelectors ();
}
store = new ListStore (typeof(Xwt.Drawing.Image), typeof(string), typeof(object));
targetsTree.Model = store;
targetsTree.HeadersVisible = false;
CellRendererImage cr = new CellRendererImage();
cr.Yalign = 0;
targetsTree.AppendColumn ("", cr, "image", 0);
targetsTree.AppendColumn ("", new Gtk.CellRendererText(), "markup", 1);
targetsTree.Selection.Changed += delegate (object s, EventArgs a) {
UpdateButtons ();
};
FillBuilders ();
UpdateButtons ();
}
public override DeployFileCollection GetDeployFiles (DeployContext ctx, SolutionItem entry, ConfigurationSelector configuration)
{
if (entry is IDeployable)
return new DeployFileCollection (((IDeployable)entry).GetDeployFiles (configuration));
return base.GetDeployFiles (ctx, entry, configuration);
}
void AddEntry (TreeIter iter, SolutionItem entry)
{
string icon;
if (entry.ParentFolder == null)
icon = MonoDevelop.Ide.Gui.Stock.Solution;
else if (entry is SolutionFolder)
icon = MonoDevelop.Ide.Gui.Stock.SolutionFolderClosed;
else if (entry is Project)
icon = ((Project)entry).StockIcon;
else
icon = MonoDevelop.Ide.Gui.Stock.Project;
bool visible = builder.CanBuild (entry);
bool selected = selectedEntries.ContainsKey (entry);
if (!(entry is SolutionFolder) && !visible)
return;
if (!iter.Equals (TreeIter.Zero))
iter = store.AppendValues (iter, icon, entry.Name, entry, selected && visible, visible);
else
iter = store.AppendValues (icon, entry.Name, entry, selected && visible, visible);
if (selected)
tree.ExpandToPath (store.GetPath (iter));
if (entry is SolutionFolder) {
foreach (SolutionItem ce in ((SolutionFolder)entry).Items) {
AddEntry (iter, ce);
}
}
}
public bool BuildEnabledForItem (SolutionItem item)
{
foreach (SolutionConfigurationEntry entry in configurations) {
if (entry.Item == item)
return entry.Build && item.Configurations [entry.ItemConfiguration] != null;
}
return false;
}
public static string GetHeader (SolutionItem policyParent, string fileName, bool newFile)
{
StandardHeaderPolicy headerPolicy = policyParent != null ? policyParent.Policies.Get<StandardHeaderPolicy> () : MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy<StandardHeaderPolicy> ();
TextStylePolicy textPolicy = policyParent != null ? policyParent.Policies.Get<TextStylePolicy> ("text/plain") : MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy<TextStylePolicy> ("text/plain");
AuthorInformation authorInfo = policyParent != null ? policyParent.AuthorInformation : AuthorInformation.Default;
return GetHeader (authorInfo, headerPolicy, textPolicy, fileName, newFile);
}
public static bool CheckProjectPackageOfExtension (SolutionItem item, string packageExtension)
{
var project = item as Project;
var outputPath = project.GetOutputFileName (IdeApp.Workspace.ActiveConfiguration);
var outputDirectory = outputPath.ParentDirectory.FullPath.ToString ();
var files = Directory.GetFiles (outputDirectory);
return files.Any (f => f.ToLower ().Contains (packageExtension));
}
public void ApplyFeature (SolutionFolder parentFolder, SolutionItem entry, Gtk.Widget editor)
{
// The solution may not be saved yet
if (parentFolder.ParentSolution.FileName.IsNullOrEmpty || !System.IO.File.Exists (parentFolder.ParentSolution.FileName))
parentFolder.ParentSolution.Saved += OnSolutionSaved;
else
OnSolutionSaved (parentFolder.ParentSolution, null);
}
public string GetMappedConfiguration (SolutionItem item)
{
foreach (SolutionConfigurationEntry entry in configurations) {
if (entry.Item == item)
return entry.ItemConfiguration;
}
return null;
}
protected UnitTest (string name, WorkspaceObject ownerSolutionItem)
{
this.name = name;
this.ownerSolutionItem = ownerSolutionItem;
ownerSolutionEntityItem = ownerSolutionItem as SolutionItem;
if (ownerSolutionEntityItem != null)
ownerSolutionEntityItem.DefaultConfigurationChanged += OnConfugurationChanged;
}
public void Install (IProgressMonitor monitor, SolutionItem entry, string appName, string prefix, ConfigurationSelector configuration)
{
this.appName = appName;
using (DeployContext ctx = new DeployContext (this, "Linux", prefix)) {
InstallEntry (monitor, ctx, entry, configuration);
}
}
public SingleItemSolutionRunConfiguration (SolutionItem item, SolutionItemRunConfiguration config): base (item.ItemId + "|" + config?.Name)
{
Item = item;
RunConfiguration = config;
if (config != null && !config.IsDefaultConfiguration)
SetName (item.Name + " – " + config.Name);
else
SetName (item.Name);
}
public FeatureSupportLevel GetSupportLevel (SolutionFolder parentCombine, SolutionItem entry)
{
if (entry is TranslationProject && parentCombine != null)
return FeatureSupportLevel.Enabled;
else if ((entry is Project) && parentCombine != null)
return FeatureSupportLevel.Supported;
else
return FeatureSupportLevel.NotSupported;
}
public override bool AddToProject (SolutionItem policyParent, Project project, string language, string directory, string name)
{
var path = FilePath.Build (directory, project.Name + "-res.zip");
var file = new ProjectFile (path, "EmbeddedResource");
file.ResourceId = "XobotOS.Resources";
file.Visible = false;
project.AddFile (file);
return true;
}
public override bool AddToProject (SolutionItem policyParent, Project project, string language, string directory, string name)
{
if (!GtkDesignInfo.SupportsDesigner (project)) {
ReferenceManager mgr = new ReferenceManager (project as DotNetProject);
mgr.GtkPackageVersion = mgr.DefaultGtkVersion;
mgr.Dispose ();
}
GtkDesignInfo info = GtkDesignInfo.FromProject ((DotNetProject) project);
GuiBuilderProject gproject = info.GuiBuilderProject;
string fileName = fileTemplate.GetFileName (policyParent, project, language, directory, name);
fileTemplate.AddToProject (policyParent, project, language, directory, name);
ProjectDomService.Parse (project, fileName);
DotNetProject netProject = project as DotNetProject;
string ns = netProject != null ? netProject.GetDefaultNamespace (fileName) : "";
string cname = Path.GetFileNameWithoutExtension (fileName);
string fullName = ns.Length > 0 ? ns + "." + cname : cname;
string[,] tags = {
{"Name", cname},
{"Namespace", ns},
{"FullName", fullName}
};
XmlElement widgetElem = steticTemplate ["widget"];
if (widgetElem != null) {
string content = widgetElem.OuterXml;
content = StringParserService.Parse (content, tags);
XmlDocument doc = new XmlDocument ();
doc.LoadXml (content);
gproject.AddNewComponent (doc.DocumentElement);
gproject.Save (false);
IdeApp.ProjectOperations.Save (project);
return true;
}
widgetElem = steticTemplate ["action-group"];
if (widgetElem != null) {
string content = widgetElem.OuterXml;
content = StringParserService.Parse (content, tags);
XmlDocument doc = new XmlDocument ();
doc.LoadXml (content);
gproject.SteticProject.AddNewActionGroup (doc.DocumentElement);
gproject.Save (false);
IdeApp.ProjectOperations.Save (project);
return true;
}
throw new InvalidOperationException ("<widget> or <action-group> element not found in widget template.");
}
void AddClasses (ITreeBuilder builder, SolutionItem entry)
{
if (entry is SolutionFolder) {
foreach (SolutionItem e in ((SolutionFolder)entry).Items)
AddClasses (builder, e);
} else if (entry is Project) {
ProjectNodeBuilder.BuildChildNodes (builder, entry as Project);
}
}
TagModel GetTagModel (SolutionItem policyParent, Project project, string language, string identifier, string fileName)
{
var model = new TagModel();
var projectModel = ProjectTagModel ?? Outer.ProjectTagModel;
if (projectModel != null)
model.InnerModels = new [] { projectModel };
ModifyTags (policyParent, project, language, identifier, fileName, ref model.OverrideTags);
return model;
}
public override void Initialize (OptionsDialog dialog, object dataObject)
{
base.Initialize (dialog, dataObject);
solutionItem = dataObject as SolutionItem;
if (solutionItem != null)
workspaceItem = solutionItem.ParentSolution;
else
workspaceItem = dataObject as WorkspaceItem;
}
public override bool AddToProject (SolutionItem policyParent, Project project, string language, string directory, string name)
{
ProjectFile file = template.AddFileToProject (policyParent, project, language, directory, name);
if (file != null) {
file.BuildAction = BuildAction.EmbeddedResource;
return true;
}
else
return false;
}
public static ISolutionItemFeature[] GetFeatures (SolutionFolder parentCombine, SolutionItem entry)
{
List<ISolutionItemFeature> list = new List<ISolutionItemFeature> ();
foreach (ISolutionItemFeature e in AddinManager.GetExtensionObjects ("/MonoDevelop/Ide/ProjectFeatures", typeof(ISolutionItemFeature), true)) {
FeatureSupportLevel level = e.GetSupportLevel (parentCombine, entry);
if (level == FeatureSupportLevel.Enabled || level == FeatureSupportLevel.SupportedByDefault)
list.Add (e);
}
return list.ToArray ();
}
public override bool AddToProject (SolutionItem policyParent, Project project, string language, string directory, string name)
{
ProjectFile file = template.AddFileToProject (policyParent, project, language, directory, name);
if (file != null) {
file.BuildAction = BuildAction.Content;
file.CopyToOutputDirectory = mode;
return true;
}
else
return false;
}
public static bool IsAddinProject (SolutionItem targettedItem)
{
if (targettedItem.ExtendedProperties.Contains (MDToolHelper.PROJECT_GUID_PROP_KEY) == false)
{
return false;
}
var guids = (string)targettedItem.ExtendedProperties [MDToolHelper.PROJECT_GUID_PROP_KEY];
return guids.Contains (MDToolHelper.MONO_DEVELOP_ADDIN_PROJECT_GUIDS [0])
&& guids.Contains (MDToolHelper.MONO_DEVELOP_ADDIN_PROJECT_GUIDS [1]);
}
public FeatureSupportLevel GetSupportLevel (SolutionFolder parentCombine, SolutionItem entry)
{
if (!(entry is DotNetProject) || !GtkDesignInfo.SupportsRefactoring (entry as DotNetProject))
return FeatureSupportLevel.NotSupported;
else if (GtkDesignInfo.SupportsDesigner ((Project)entry))
return FeatureSupportLevel.Enabled;
else if (entry is DotNetAssemblyProject)
return FeatureSupportLevel.SupportedByDefault;
else
return FeatureSupportLevel.Supported;
}
void TrackStartupProject()
{
if (currentStartupProject != null && ((currentSolution != null && currentStartupProject != currentSolution.StartupItem) || currentSolution == null))
{
currentStartupProject.ExecutionTargetsChanged -= executionTargetsChanged;
currentStartupProject.Saved -= HandleUpdateCombos;
}
if (currentSolution != null)
{
currentStartupProject = currentSolution.StartupItem;
if (currentStartupProject != null)
{
currentStartupProject.ExecutionTargetsChanged += executionTargetsChanged;
currentStartupProject.Saved += HandleUpdateCombos;
}
}
else
{
currentStartupProject = null;
}
}
public bool BelongsToItem(IWorkspaceObject item, bool checkHierarchy)
{
if (!checkHierarchy)
{
return(item == parentObject);
}
IWorkspaceObject cit = parentObject;
do
{
if (cit == item)
{
return(true);
}
if (cit is SolutionItem)
{
SolutionItem si = (SolutionItem)cit;
if (si.ParentFolder != null)
{
cit = si.ParentFolder;
}
else
{
cit = si.ParentSolution;
}
}
else if (cit is WorkspaceItem)
{
cit = ((WorkspaceItem)cit).ParentWorkspace;
}
else
{
cit = null;
}
} while (cit != null);
return(false);
}
public override bool AddToProject(SolutionItem policyParent, Project project,
string language, string directory, string name)
{
bool addedSomething = false;
directory = Path.Combine(directory, dirName);
if (templates.Count == 0)
{
string relPath = FileService.AbsoluteToRelativePath(project.BaseDirectory, directory);
if (project.AddDirectory(relPath) != null)
{
addedSomething = true;
}
}
foreach (FileDescriptionTemplate t in templates)
{
addedSomething |= t.AddToProject(policyParent, project, language, directory, name);
}
return(addedSomething);
}
SolutionItem FindEntryMD1(object item, string fileName)
{
if (item is SolutionItem)
{
string file = MonoDevelop.Projects.Formats.MD1.MD1ProjectService.GetItemFileName((SolutionItem)item);
if (file != null && FileService.GetFullPath(file) == fileName)
{
return((SolutionItem)item);
}
}
if (item is Solution)
{
return(FindEntryMD1(((Solution)item).RootFolder, fileName));
}
else if (item is SolutionFolder)
{
foreach (SolutionItem ce in ((SolutionFolder)item).Items)
{
SolutionItem fi = FindEntryMD1(ce, fileName);
if (fi != null)
{
return(fi);
}
}
}
else if (item is Workspace)
{
foreach (WorkspaceItem wi in ((Workspace)item).Items)
{
SolutionItem fi = FindEntryMD1(wi, fileName);
if (fi != null)
{
return(fi);
}
}
}
return(null);
}
private static string GetResultName(SolutionItem solutionItem, IBuildInfo buildInfo)
{
var buildAction = buildInfo.BuildAction;
int errorStateProjectsCount = solutionItem.AllProjects.Count(item => item.State.IsErrorState());
if (buildInfo.BuildIsCancelled)
{
return(buildAction.Value == BuildActions.BuildActionClean ? Resources.BuildActionCancelled_Clean : Resources.BuildActionCancelled);
}
else if (!buildInfo.BuildedProjects.BuildWithoutErrors)
{
return(buildAction.Value == BuildActions.BuildActionClean ? Resources.BuildActionFailed_Clean : Resources.BuildActionFailed);
}
else if (errorStateProjectsCount == 0)
{
return(buildAction.Value == BuildActions.BuildActionClean ? Resources.BuildActionFinishedSuccessfully_Clean : Resources.BuildActionFinishedSuccessfully);
}
else
{
return(buildAction.Value == BuildActions.BuildActionClean ? Resources.BuildActionFinished_Clean : Resources.BuildActionFinished);
}
}
protected override void Run()
{
SolutionItem entry = IdeApp.ProjectOperations.CurrentSelectedSolutionItem;
DeployDialog dlg = new DeployDialog(entry, false);
try
{
if (MessageService.RunCustomDialog(dlg) == (int)Gtk.ResponseType.Ok)
{
if (dlg.SaveToProject)
{
Package p = new Package();
p.Name = dlg.NewPackageName;
p.PackageBuilder = dlg.PackageBuilder;
if (dlg.CreateNewProject)
{
PackagingProject project = new PackagingProject();
project.Name = dlg.NewProjectName;
project.FileName = Path.Combine(dlg.NewProjectSolution.BaseDirectory, project.Name + ".mdse");
project.Packages.Add(p);
dlg.NewProjectSolution.Items.Add(project);
IdeApp.ProjectOperations.Save(dlg.NewProjectSolution.ParentSolution);
}
else
{
dlg.ExistingPackagingProject.Packages.Add(p);
IdeApp.ProjectOperations.Save(dlg.ExistingPackagingProject);
}
}
Package pkg = new Package(dlg.PackageBuilder);
DeployOperations.BuildPackage(pkg);
}
}
finally
{
dlg.Destroy();
}
}
public IEnumerable <SolutionItem> CreateProjects(SolutionFolderItem policyParent, ProjectCreateInformation cInfo)
{
if (solutionDescriptor.EntryDescriptors.Length == 0)
{
throw new InvalidOperationException(GettextCatalog.GetString("Solution template doesn't have any project templates"));
}
var solutionEntryItems = new List <SolutionItem> ();
packageReferencesForCreatedProjects = new List <PackageReferencesForCreatedProject> ();
foreach (ISolutionItemDescriptor solutionItemDescriptor in GetItemsToCreate(solutionDescriptor, cInfo))
{
ProjectCreateInformation itemCreateInfo = GetItemSpecificCreateInfo(solutionItemDescriptor, cInfo);
itemCreateInfo = new ProjectTemplateCreateInformation(itemCreateInfo, cInfo.ProjectName);
SolutionItem solutionEntryItem = solutionItemDescriptor.CreateItem(itemCreateInfo, this.languagename);
if (solutionEntryItem != null)
{
solutionItemDescriptor.InitializeItem(policyParent, itemCreateInfo, this.languagename, solutionEntryItem);
SavePackageReferences(solutionEntryItem, solutionItemDescriptor, itemCreateInfo);
solutionEntryItems.Add(solutionEntryItem);
}
}
var pDesc = this.solutionDescriptor.EntryDescriptors.OfType <ProjectDescriptor> ().FirstOrDefault();
var metadata = new Dictionary <string, string> ();
metadata ["Id"] = this.Id;
metadata ["Name"] = this.nonLocalizedName;
metadata ["Language"] = this.LanguageName;
metadata ["Platform"] = pDesc != null ? pDesc.ProjectType : "Unknown";
TemplateCounter.Inc(1, null, metadata);
return(solutionEntryItems);
}
public override bool AddToProject(SolutionItem policyParent, Project project, string language, string directory, string name)
{
var file = inner.AddFileToProject(policyParent, project, language, directory, name);
if (file == null)
{
return(false);
}
if (!string.IsNullOrEmpty(ResourceId))
{
file.ResourceId = inner.ProcessContent(ResourceId);
}
/* TODO: Add required packages here?
* var dnproject = project as DotNetProject;
* if (dnproject != null)
* {
* }
*/
return(true);
}
public static async Task <string> GetStartupProjectOutputPathAsync()
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
IVsSolutionBuildManager buildManager;
IVsHierarchy startupProject;
Project project;
try
{
buildManager = await VS.Services.GetSolutionBuildManagerAsync();
ErrorHandler.ThrowOnFailure(buildManager.get_StartupProject(out startupProject));
project = (Project)await SolutionItem.FromHierarchyAsync(startupProject, (uint)VSConstants.VSITEMID.Root);
return(await project.GetOutPutAssemblyPathAsync());
}
catch
{
return(null);
}
}
public virtual void CopyFrom(PackageBuilder other)
{
childEntries = new List <SolutionItemReference> (other.childEntries);
rootEntry = other.rootEntry;
if (other.childCombineEntries != null)
{
childCombineEntries = new List <SolutionItem> (other.childCombineEntries);
}
else
{
childCombineEntries = null;
}
if (other.excludedFiles != null)
{
excludedFiles = new List <string> (other.excludedFiles);
}
else
{
excludedFiles = null;
}
rootSolutionItem = other.rootSolutionItem;
}
public DeployDialog(SolutionItem defaultEntry, bool createBuilderOnly)
{
this.Build();
notebook.ShowTabs = false;
this.defaultEntry = defaultEntry;
if (createBuilderOnly)
{
vboxSaveProject.Hide();
checkSave.Active = true;
checkSave.Hide();
saveSeparator.Hide();
}
else
{
pageSave.Hide();
FillProjectSelectors();
}
store = new ListStore(typeof(Gdk.Pixbuf), typeof(string), typeof(object));
targetsTree.Model = store;
targetsTree.HeadersVisible = false;
Gtk.CellRendererPixbuf cr = new Gtk.CellRendererPixbuf();
cr.Yalign = 0;
targetsTree.AppendColumn("", cr, "pixbuf", 0);
targetsTree.AppendColumn("", new Gtk.CellRendererText(), "markup", 1);
targetsTree.Selection.Changed += delegate(object s, EventArgs a)
{
UpdateButtons();
};
FillBuilders();
UpdateButtons();
}
protected override async Task ExecuteAsync(OleMenuCmdEventArgs e)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
SolutionExplorerWindow solutionExplorer = await VS.Windows.GetSolutionExplorerWindowAsync();
if (solutionExplorer != null)
{
List <SolutionItem> projects = new List <SolutionItem>();
foreach (SolutionItem item in await solutionExplorer.GetSelectionAsync())
{
SolutionItem project = item.FindParent(SolutionItemType.Project);
if (project != null)
{
projects.Add(project);
}
}
if (projects.Count > 0)
{
solutionExplorer.SetSelection(projects);
}
}
}
string CalcProjectPath(SolutionItem solution, out string projectFilePath, out string serverPath)
{
string result = string.Empty;
serverPath = string.Empty;
projectFilePath = string.Empty;
try {
result = GetProjectPath(solution.Path, out serverPath);
projectFilePath = solution.Path;
}
catch {
foreach (var project in solution.Children)
{
try {
result = GetProjectPath(project.Path, out serverPath);
projectFilePath = project.Path;
break;
}
catch {
}
}
}
return(result);
}
private static string GetMainString(SolutionItem solutionItem, IBuildInfo buildInfo, BuildMessagesSettings labelsSettings)
{
var unitName = GetUnitName(solutionItem, buildInfo, labelsSettings);
var actionName = GetActionName(buildInfo.BuildAction.Value);
var beginAtString = GetBeginAtString(buildInfo.BuildAction.Value);
var timeString = GetTimeString(buildInfo, labelsSettings);
string mainString;
switch (labelsSettings.MajorMessageFormat)
{
case BuildMajorMessageFormat.Entire:
mainString = string.Format(Resources.BuildBeginStateLabelTemplate_Default, actionName, unitName, beginAtString, timeString);
break;
case BuildMajorMessageFormat.Unnamed:
mainString = string.Format(Resources.BuildBeginStateLabelTemplate_ShortForm, actionName, beginAtString, timeString);
break;
default:
throw new ArgumentOutOfRangeException(nameof(labelsSettings.MajorMessageFormat));
}
return(mainString);
}
public SolutionItem CreateItem(ProjectCreateInformation projectCreateInformation, string defaultLanguage)
{
Type type = addin.GetType(typeName, false);
if (type == null)
{
MessageService.ShowError(GettextCatalog.GetString("Can't create project with type : {0}", typeName));
return(null);
}
// TODO NPM: should use the project service
SolutionItem item = (SolutionItem)Activator.CreateInstance(type);
item.InitializeFromTemplate(projectCreateInformation, template);
string newProjectName = StringParserService.Parse(name, new string[, ] {
{ "ProjectName", projectCreateInformation.ProjectName }
});
item.Name = newProjectName;
item.FileName = Path.Combine(projectCreateInformation.ProjectBasePath, newProjectName);
return(item);
}
public void ConvertToFormat(object obj)
{
if (obj == null)
{
return;
}
MSBuildHandler handler;
SolutionItem item = obj as SolutionItem;
if (item != null)
{
handler = item.GetItemHandler() as MSBuildHandler;
if (handler != null)
{
handler.SetSolutionFormat(this, true);
return;
}
}
MSBuildProjectService.InitializeItemHandler(item);
handler = (MSBuildHandler)item.ItemHandler;
handler.SetSolutionFormat(this, true);
}
public async Task <int> Run(string[] arguments)
{
DesktopService.Initialize();
Console.WriteLine(BrandingService.BrandApplicationName("MonoDevelop Gettext Update Tool"));
foreach (string s in arguments)
{
ReadArgument(s);
}
if (help)
{
Console.WriteLine("gettext-update [options] [project-file]");
Console.WriteLine("--f --file:FILE Project or solution file to build.");
Console.WriteLine("--p --project:PROJECT Name of the project to build.");
Console.WriteLine("--sort Sorts the output po file");
Console.WriteLine();
return(0);
}
if (file == null)
{
var files = Directory.EnumerateFiles(".");
foreach (string f in files)
{
if (Services.ProjectService.IsWorkspaceItemFile(f))
{
file = f;
break;
}
}
if (file == null)
{
Console.WriteLine("Solution file not found.");
return(1);
}
}
else if (!Services.ProjectService.IsWorkspaceItemFile(file))
{
Console.WriteLine("File '{0}' is not a project or solution.", file);
return(1);
}
ConsoleProgressMonitor monitor = new ConsoleProgressMonitor();
monitor.IgnoreLogMessages = true;
WorkspaceItem centry = await Services.ProjectService.ReadWorkspaceItem(monitor, file);
monitor.IgnoreLogMessages = false;
Solution solution = centry as Solution;
if (solution == null)
{
Console.WriteLine("File is not a solution: " + file);
return(1);
}
if (project != null)
{
SolutionItem item = solution.FindProjectByName(project);
if (item == null)
{
Console.WriteLine("The project '" + project + "' could not be found in " + file);
return(1);
}
TranslationProject tp = item as TranslationProject;
if (tp == null)
{
Console.WriteLine("The project '" + item.FileName + "' is not a translation project");
return(1);
}
tp.UpdateTranslations(monitor, sort);
}
else
{
foreach (TranslationProject p in solution.GetAllItems <TranslationProject>())
{
p.UpdateTranslations(monitor, sort);
}
}
return(0);
}
internal void LoadSolution(Solution sol, SlnFile sln, ProgressMonitor monitor, SolutionLoadContext ctx)
{
var version = sln.FormatVersion;
//Parse the .sln file
var folder = sol.RootFolder;
sol.Version = "0.1"; //FIXME:
monitor.BeginTask("Loading projects ..", sln.Projects.Count + 1);
Dictionary <string, SolutionFolderItem> items = new Dictionary <string, SolutionFolderItem> ();
List <string> sortedList = new List <string> ();
List <Task> loadTasks = new List <Task> ();
foreach (SlnProject sec in sln.Projects)
{
try {
// Valid guid?
new Guid(sec.TypeGuid);
} catch (FormatException) {
monitor.Step(1);
//Use default guid as projectGuid
LoggingService.LogDebug(GettextCatalog.GetString(
"Invalid Project type guid '{0}' on line #{1}. Ignoring.",
sec.Id,
sec.Line));
continue;
}
string projTypeGuid = sec.TypeGuid.ToUpper();
string projectName = sec.Name;
string projectPath = sec.FilePath;
string projectGuid = sec.Id;
lock (items)
sortedList.Add(projectGuid);
if (projTypeGuid == MSBuildProjectService.FolderTypeGuid)
{
//Solution folder
SolutionFolder sfolder = new SolutionFolder();
sfolder.Name = projectName;
sfolder.ItemId = projectGuid;
DeserializeSolutionItem(monitor, sol, sfolder, sec);
foreach (string f in ReadFolderFiles(sec))
{
sfolder.Files.Add(MSBuildProjectService.FromMSBuildPath(Path.GetDirectoryName(sol.FileName), f));
}
lock (items)
items.Add(projectGuid, sfolder);
monitor.Step(1);
continue;
}
if (projectPath.StartsWith("http://"))
{
monitor.ReportWarning(GettextCatalog.GetString(
"{0}({1}): Projects with non-local source (http://...) not supported. '{2}'.",
sol.FileName, sec.Line, projectPath));
monitor.Step(1);
continue;
}
string path = MSBuildProjectService.FromMSBuildPath(Path.GetDirectoryName(sol.FileName), projectPath);
if (String.IsNullOrEmpty(path))
{
monitor.ReportWarning(GettextCatalog.GetString(
"Invalid project path found in {0} : {1}", sol.FileName, projectPath));
LoggingService.LogWarning(GettextCatalog.GetString(
"Invalid project path found in {0} : {1}", sol.FileName, projectPath));
monitor.Step(1);
continue;
}
projectPath = Path.GetFullPath(path);
SolutionItem item = null;
Task <SolutionItem> loadTask;
DateTime ti = DateTime.Now;
if (sol.IsSolutionItemEnabled(projectPath))
{
loadTask = Services.ProjectService.ReadSolutionItem(monitor, projectPath, format, projTypeGuid, projectGuid, ctx);
}
else
{
loadTask = Task.FromResult <SolutionItem> (new UnloadedSolutionItem()
{
FileName = projectPath
});
}
var ft = loadTask.ContinueWith(ta => {
try {
item = ta.Result;
if (item == null)
{
throw new UnknownSolutionItemTypeException(projTypeGuid);
}
} catch (Exception cex) {
var e = UnwrapException(cex).First();
string unsupportedMessage = e.Message;
if (e is UserException)
{
var ex = (UserException)e;
LoggingService.LogError("{0}: {1}", ex.Message, ex.Details);
monitor.ReportError(string.Format("{0}{1}{1}{2}", ex.Message, Environment.NewLine, ex.Details), null);
}
else
{
LoggingService.LogError(string.Format("Error while trying to load the project {0}", projectPath), e);
monitor.ReportWarning(GettextCatalog.GetString(
"Error while trying to load the project '{0}': {1}", projectPath, e.Message));
}
SolutionItem uitem;
uitem = new UnknownSolutionItem()
{
FileName = projectPath,
LoadError = unsupportedMessage,
};
item = uitem;
item.ItemId = projectGuid;
item.TypeGuid = projTypeGuid;
}
item.UnresolvedProjectDependencies = ReadSolutionItemDependencies(sec);
// Deserialize the object
DeserializeSolutionItem(monitor, sol, item, sec);
lock (items) {
if (!items.ContainsKey(projectGuid))
{
items.Add(projectGuid, item);
}
else
{
monitor.ReportError(GettextCatalog.GetString("Invalid solution file. There are two projects with the same GUID. The project {0} will be ignored.", projectPath), null);
}
}
monitor.Step(1);
});
loadTasks.Add(ft);
}
Task.WaitAll(loadTasks.ToArray());
sol.LoadedProjects = new HashSet <string> (items.Keys);
var nested = sln.Sections.GetSection("NestedProjects");
if (nested != null)
{
LoadNestedProjects(nested, items, monitor);
}
// Resolve project dependencies
foreach (var it in items.Values.OfType <SolutionItem> ())
{
if (it.UnresolvedProjectDependencies != null)
{
foreach (var id in it.UnresolvedProjectDependencies.ToArray())
{
SolutionFolderItem dep;
if (items.TryGetValue(id, out dep) && dep is SolutionItem)
{
it.UnresolvedProjectDependencies.Remove(id);
it.ItemDependencies.Add((SolutionItem)dep);
}
}
if (it.UnresolvedProjectDependencies.Count == 0)
{
it.UnresolvedProjectDependencies = null;
}
}
}
//Add top level folders and projects to the main folder
foreach (string id in sortedList)
{
SolutionFolderItem ce;
if (items.TryGetValue(id, out ce) && ce.ParentFolder == null)
{
folder.Items.Add(ce);
}
}
//FIXME: This can be just SolutionConfiguration also!
LoadSolutionConfigurations(sln.SolutionConfigurationsSection, sol, monitor);
LoadProjectConfigurationMappings(sln.ProjectConfigurationsSection, sol, items, monitor);
foreach (var e in sln.Sections)
{
string name = e.Id;
if (name.StartsWith("MonoDevelopProperties."))
{
int i = name.IndexOf('.');
LoadMonoDevelopConfigurationProperties(name.Substring(i + 1), e, sol, monitor);
}
}
monitor.EndTask();
}
// Can add tags for substitution based on project, language or filename.
// If overriding but still want base implementation's tags, should invoke base method.
// We supply defaults whenever it is possible, to avoid having unsubstituted tags. However,
// do not substitute blanks when a sensible default cannot be guessed, because they result
//in less obvious errors.
public virtual void ModifyTags(SolutionItem policyParent, Project project, string language,
string identifier, string fileName, ref Dictionary <string, string> tags)
{
DotNetProject netProject = project as DotNetProject;
string languageExtension = "";
ILanguageBinding binding = null;
if (!string.IsNullOrEmpty(language))
{
binding = GetLanguageBinding(language);
if (binding != null)
{
languageExtension = Path.GetExtension(binding.GetFileName("Default")).Remove(0, 1);
}
}
//need a default namespace or if there is no project, substitutions can get very messed up
string ns;
if (project is IDotNetFileContainer)
{
ns = ((IDotNetFileContainer)project).GetDefaultNamespace(fileName);
}
else
{
ns = "Application";
}
//need an 'identifier' for tag substitution, e.g. class name or page name
//if not given an identifier, use fileName
if ((identifier == null) && (fileName != null))
{
identifier = Path.GetFileName(fileName);
}
if (identifier != null)
{
//remove all extensions
while (Path.GetExtension(identifier).Length > 0)
{
identifier = Path.GetFileNameWithoutExtension(identifier);
}
identifier = CreateIdentifierName(identifier);
tags ["Name"] = identifier;
tags ["FullName"] = ns.Length > 0 ? ns + "." + identifier : identifier;
//some .NET languages may be able to use keywords as identifiers if they're escaped
IDotNetLanguageBinding dnb = binding as IDotNetLanguageBinding;
if (dnb != null)
{
System.CodeDom.Compiler.CodeDomProvider provider = dnb.GetCodeDomProvider();
if (provider != null)
{
tags ["EscapedIdentifier"] = provider.CreateEscapedIdentifier(identifier);
}
}
}
tags ["Namespace"] = ns;
if (policyParent != null)
{
tags ["SolutionName"] = policyParent.Name;
}
if (project != null)
{
tags ["ProjectName"] = project.Name;
tags ["SafeProjectName"] = CreateIdentifierName(project.Name);
var info = project.AuthorInformation ?? AuthorInformation.Default;
tags ["AuthorCopyright"] = info.Copyright;
tags ["AuthorCompany"] = info.Company;
tags ["AuthorTrademark"] = info.Trademark;
tags ["AuthorEmail"] = info.Email;
tags ["AuthorName"] = info.Name;
}
if ((language != null) && (language.Length > 0))
{
tags ["Language"] = language;
}
if (languageExtension.Length > 0)
{
tags ["LanguageExtension"] = languageExtension;
}
if (fileName != FilePath.Null)
{
FilePath fileDirectory = Path.GetDirectoryName(fileName);
if (project != null && project.BaseDirectory != FilePath.Null && fileDirectory.IsChildPathOf(project.BaseDirectory))
{
tags ["ProjectRelativeDirectory"] = fileDirectory.ToRelative(project.BaseDirectory);
}
else
{
tags ["ProjectRelativeDirectory"] = fileDirectory;
}
tags ["FileNameWithoutExtension"] = Path.GetFileNameWithoutExtension(fileName);
tags ["Directory"] = fileDirectory;
tags ["FileName"] = fileName;
}
}
public sealed override bool AddToProject(SolutionItem policyParent, Project project, string language, string directory, string name)
{
return(AddFileToProject(policyParent, project, language, directory, name) != null);
}
public SolitionEnumeratorHelper(IDteWrapper dte)
{
this.dte = dte;
solution = dte.BuildTree();
}
public override bool CanBuild(SolutionItem entry)
{
return(entry is SolutionFolder || entry is SolutionEntityItem);
}
protected override bool OnBuild(IProgressMonitor monitor, DeployContext ctx)
{
string sourceFile;
SolutionItem entry = RootSolutionItem;
if (entry is SolutionFolder)
{
sourceFile = entry.ParentSolution.FileName;
}
else
{
sourceFile = ((SolutionEntityItem)entry).FileName;
}
AggregatedProgressMonitor mon = new AggregatedProgressMonitor();
mon.AddSlaveMonitor(monitor, MonitorAction.WriteLog | MonitorAction.ReportError | MonitorAction.ReportWarning | MonitorAction.ReportSuccess);
string tmpFolder = FileService.CreateTempDirectory();
try {
string tf = Path.GetFileNameWithoutExtension(targetFile);
if (tf.EndsWith(".tar"))
{
tf = Path.GetFileNameWithoutExtension(tf);
}
string folder = FileService.GetFullPath(Path.Combine(tmpFolder, tf));
Directory.CreateDirectory(folder);
// Export the project
SolutionItem[] ents = GetChildEntries();
string[] epaths = new string [ents.Length];
for (int n = 0; n < ents.Length; n++)
{
epaths [n] = ents [n].ItemId;
}
Services.ProjectService.Export(mon, sourceFile, epaths, folder, FileFormat);
if (!mon.AsyncOperation.Success)
{
return(false);
}
// Create the archive
string td = Path.GetDirectoryName(targetFile);
if (!Directory.Exists(td))
{
Directory.CreateDirectory(td);
}
DeployService.CreateArchive(mon, tmpFolder, targetFile);
}
finally {
Directory.Delete(tmpFolder, true);
}
if (monitor.AsyncOperation.Success)
{
monitor.Log.WriteLine(GettextCatalog.GetString("Created file: {0}", targetFile));
}
return(true);
}
// Recurses into children and tests if they are deployable.
public bool CanDeploy(SolutionItem entry, MakefileType type)
{
return(entry is SolutionFolder);
}
// Returns a stream with the content of the file.
// project and language parameters are optional
public virtual Stream CreateFileContent(SolutionItem policyParent, Project project, string language, string fileName, string identifier)
{
Dictionary <string, string> tags = new Dictionary <string, string> ();
ModifyTags(policyParent, project, language, identifier, fileName, ref tags);
string content = CreateContent(project, tags, language);
content = StringParserService.Parse(content, tags);
string mime = DesktopService.GetMimeTypeForUri(fileName);
CodeFormatter formatter = !string.IsNullOrEmpty(mime) ? CodeFormatterService.GetFormatter(mime) : null;
if (formatter != null)
{
var formatted = formatter.FormatText(policyParent != null ? policyParent.Policies : null, content);
if (formatted != null)
{
content = formatted;
}
}
var ms = new MemoryStream();
var bom = Encoding.UTF8.GetPreamble();
ms.Write(bom, 0, bom.Length);
byte[] data;
if (AddStandardHeader)
{
string header = StandardHeaderService.GetHeader(policyParent, fileName, true);
data = System.Text.Encoding.UTF8.GetBytes(header);
ms.Write(data, 0, data.Length);
}
Mono.TextEditor.TextDocument doc = new Mono.TextEditor.TextDocument();
doc.Text = content;
TextStylePolicy textPolicy = policyParent != null?policyParent.Policies.Get <TextStylePolicy> ("text/plain")
: MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy <TextStylePolicy> ("text/plain");
string eolMarker = TextStylePolicy.GetEolMarker(textPolicy.EolMarker);
byte[] eolMarkerBytes = System.Text.Encoding.UTF8.GetBytes(eolMarker);
var tabToSpaces = textPolicy.TabsToSpaces? new string (' ', textPolicy.TabWidth) : null;
foreach (Mono.TextEditor.DocumentLine line in doc.Lines)
{
var lineText = doc.GetTextAt(line.Offset, line.Length);
if (tabToSpaces != null)
{
lineText = lineText.Replace("\t", tabToSpaces);
}
data = System.Text.Encoding.UTF8.GetBytes(lineText);
ms.Write(data, 0, data.Length);
ms.Write(eolMarkerBytes, 0, eolMarkerBytes.Length);
}
ms.Position = 0;
return(ms);
}
public Makefile Deploy(AutotoolsContext ctx, SolutionItem entry, IProgressMonitor monitor)
{
generateAutotools = ctx.MakefileType == MakefileType.AutotoolsMakefile;
monitor.BeginTask(GettextCatalog.GetString(
"Creating {0} for Solution {1}",
generateAutotools ? "Makefile.am" : "Makefile", entry.Name), 1);
Makefile solutionMakefile = new Makefile();
StringBuilder solutionTop = new StringBuilder();
try
{
SolutionFolder solutionFolder = (SolutionFolder)entry;
string targetDirectory = solutionFolder.BaseDirectory;
StringBuilder subdirs = new StringBuilder();
subdirs.Append("#Warning: This is an automatically generated file, do not edit!\n");
if (!generateAutotools)
{
solutionTop.AppendFormat("top_srcdir={0}\n", FileService.AbsoluteToRelativePath(
entry.BaseDirectory, ctx.TargetSolution.BaseDirectory));
solutionTop.Append("include $(top_srcdir)/config.make\n");
solutionTop.Append("include $(top_srcdir)/Makefile.include\n");
solutionTop.Append("include $(top_srcdir)/rules.make\n\n");
solutionTop.Append("#include $(top_srcdir)/custom-hooks.make\n\n");
}
ArrayList children = new ArrayList();
foreach (SolutionConfiguration config in solutionFolder.ParentSolution.Configurations)
{
if (!ctx.IsSupportedConfiguration(config.Id))
{
continue;
}
if (generateAutotools)
{
subdirs.AppendFormat("if {0}\n", "ENABLE_" + ctx.EscapeAndUpperConfigName(config.Id));
}
else
{
subdirs.AppendFormat("ifeq ($(CONFIG),{0})\n", ctx.EscapeAndUpperConfigName(config.Id));
}
subdirs.Append(" SUBDIRS = ");
foreach (SolutionItem ce in CalculateSubDirOrder(ctx, solutionFolder, config))
{
string baseDirectory;
if (!(ce is SolutionEntityItem) && !(ce is SolutionFolder))
{
continue;
}
// Ignore projects which can't be deployed
IMakefileHandler handler = AutotoolsContext.GetMakefileHandler(ce, ctx.MakefileType);
if (handler == null)
{
continue;
}
baseDirectory = ce.BaseDirectory;
if (solutionFolder.BaseDirectory == baseDirectory)
{
subdirs.Append(" . ");
}
else
{
if (!baseDirectory.StartsWith(solutionFolder.BaseDirectory))
{
throw new Exception(GettextCatalog.GetString(
"Child projects must be in sub-directories of their parent"));
}
// add the subdirectory to the list
string path = FileService.AbsoluteToRelativePath(targetDirectory, baseDirectory);
if (path.StartsWith("." + Path.DirectorySeparatorChar))
{
path = path.Substring(2);
}
AutotoolsContext.CheckSpaces(path);
subdirs.Append(" ");
subdirs.Append(AutotoolsContext.EscapeStringForAutomake(path));
}
if (!children.Contains(ce))
{
children.Add(ce);
}
}
subdirs.Append("\nendif\n");
}
solutionTop.Append(subdirs.ToString());
string includedProject = null;
// deploy recursively
foreach (SolutionItem ce in children)
{
IMakefileHandler handler = AutotoolsContext.GetMakefileHandler(ce, ctx.MakefileType);
Makefile makefile;
string outpath;
if (handler != null && handler.CanDeploy(ce, ctx.MakefileType))
{
ctx.RegisterBuiltProject(ce);
makefile = handler.Deploy(ctx, ce, monitor);
if (targetDirectory == ce.BaseDirectory)
{
if (includedProject != null)
{
throw new Exception(GettextCatalog.GetString(
"More than 1 project in the same directory as the top-level solution is not supported."));
}
// project is in the solution directory
string projectMakefileName = ce.Name + ".make";
includedProject = String.Format("include {0}", projectMakefileName);
outpath = Path.Combine(targetDirectory, projectMakefileName);
ctx.AddGeneratedFile(outpath);
if (!generateAutotools)
{
solutionMakefile.SetVariable("EXTRA_DIST", projectMakefileName);
}
}
else
{
makefile.AppendToVariable("EXTRA_DIST", generateAutotools ? String.Empty : "Makefile");
outpath = Path.Combine(ce.BaseDirectory, "Makefile");
if (generateAutotools)
{
ctx.AddAutoconfFile(outpath);
outpath = outpath + ".am";
}
else
{
makefile.Append("install: install-local\nuninstall: uninstall-local\nclean: clean-local\n");
if (ce is SolutionFolder)
{
//non TargetCombine
makefile.Append("dist-local: dist-local-recursive\n");
}
else
{
makefile.Append("include $(top_srcdir)/rules.make\n");
}
}
ctx.AddGeneratedFile(outpath);
}
StreamWriter writer = new StreamWriter(outpath);
makefile.Write(writer);
writer.Close();
}
else
{
monitor.Log.WriteLine("Project '{0}' skipped.", ce.Name);
}
}
if (includedProject != null)
{
solutionTop.Append(GettextCatalog.GetString("\n# Include project specific makefile\n"));
solutionTop.Append(includedProject);
}
if (generateAutotools)
{
solutionMakefile.Append(solutionTop.ToString());
}
else
{
TemplateEngine templateEngine = new TemplateEngine();
templateEngine.Variables ["MAKEFILE_SOLUTION_TOP"] = solutionTop.ToString();
Stream stream = ctx.GetTemplateStream("Makefile.solution.template");
StreamReader reader = new StreamReader(stream);
StringWriter sw = new StringWriter();
templateEngine.Process(reader, sw);
reader.Close();
solutionMakefile.Append(sw.ToString());
if (solutionFolder.IsRoot)
{
// Emit dist and distcheck targets only for TargetCombine
reader = new StreamReader(Path.Combine(ctx.TemplateDir, "make-dist.targets"));
solutionMakefile.Append(reader.ReadToEnd());
reader.Close();
}
}
monitor.Step(1);
}
finally
{
monitor.EndTask();
}
return(solutionMakefile);
}
protected override void Run ()
{
SolutionItem entry = IdeApp.ProjectOperations.CurrentSelectedSolutionItem;
DeployOperations.Install (entry, IdeApp.Workspace.ActiveConfiguration);
}
public void InitializeItem(SolutionFolderItem policyParent, ProjectCreateInformation projectCreateInformation, string defaultLanguage, SolutionItem item)
{
MonoDevelop.Projects.Project project = item as MonoDevelop.Projects.Project;
if (project == null)
{
MessageService.ShowError(GettextCatalog.GetString("Can't create project with type: {0}", type));
return;
}
// Set the file before setting the name, to make sure the file extension is kept
project.FileName = Path.Combine(projectCreateInformation.ProjectBasePath, projectCreateInformation.ProjectName);
project.Name = projectCreateInformation.ProjectName;
var dnp = project as DotNetProject;
if (dnp != null)
{
if (policyParent.ParentSolution != null && !policyParent.ParentSolution.FileFormat.SupportsFramework(dnp.TargetFramework))
{
SetClosestSupportedTargetFramework(policyParent.ParentSolution.FileFormat, dnp);
}
var substitution = new string[, ] {
{ "ProjectName", GetProjectNameForSubstitution(projectCreateInformation) }
};
foreach (var desc in references)
{
if (!projectCreateInformation.ShouldCreate(desc.CreateCondition))
{
continue;
}
var pr = desc.Create();
if (pr.ReferenceType == ReferenceType.Project)
{
string referencedProjectName = ReplaceParameters(pr.Reference, substitution, projectCreateInformation);
var parsedReference = ProjectReference.RenameReference(pr, referencedProjectName);
dnp.References.Add(parsedReference);
}
else
{
dnp.References.Add(pr);
}
}
}
foreach (SingleFileDescriptionTemplate resourceTemplate in resources)
{
try {
if (!projectCreateInformation.ShouldCreate(resourceTemplate.CreateCondition))
{
continue;
}
var projectFile = new ProjectFile(resourceTemplate.SaveFile(policyParent, project, defaultLanguage, project.BaseDirectory, null));
projectFile.BuildAction = BuildAction.EmbeddedResource;
project.Files.Add(projectFile);
} catch (Exception ex) {
if (!IdeApp.IsInitialized)
{
throw;
}
MessageService.ShowError(GettextCatalog.GetString("File {0} could not be written.", resourceTemplate.Name), ex);
}
}
foreach (FileDescriptionTemplate fileTemplate in files)
{
try {
if (!projectCreateInformation.ShouldCreate(fileTemplate.CreateCondition))
{
continue;
}
fileTemplate.SetProjectTagModel(projectCreateInformation.Parameters);
fileTemplate.AddToProject(policyParent, project, defaultLanguage, project.BaseDirectory, null);
} catch (Exception ex) {
if (!IdeApp.IsInitialized)
{
throw;
}
MessageService.ShowError(GettextCatalog.GetString("File {0} could not be written.", fileTemplate.Name), ex);
} finally {
fileTemplate.SetProjectTagModel(null);
}
}
}
void LoadProjectConfigurationMappings(SlnPropertySetCollection sets, Solution sln, Dictionary <string, SolutionFolderItem> items, ProgressMonitor monitor)
{
if (sets == null)
{
return;
}
Dictionary <string, SolutionConfigurationEntry> cache = new Dictionary <string, SolutionConfigurationEntry> ();
Dictionary <string, string> ignoredProjects = new Dictionary <string, string> ();
foreach (var pset in sets)
{
var projGuid = pset.Id;
if (!items.ContainsKey(projGuid))
{
if (ignoredProjects.ContainsKey(projGuid))
{
// already warned
continue;
}
LoggingService.LogWarning(GettextCatalog.GetString("{0} ({1}) : Project with guid = '{2}' not found or not loaded. Ignoring",
sln.FileName, pset.Line + 1, projGuid));
ignoredProjects [projGuid] = projGuid;
continue;
}
SolutionFolderItem it;
if (!items.TryGetValue(projGuid, out it))
{
continue;
}
SolutionItem item = it as SolutionItem;
if (item == null || !item.SupportsConfigurations())
{
continue;
}
//Format:
// {projectGuid}.SolutionConfigName|SolutionPlatform.ActiveCfg = ProjConfigName|ProjPlatform
// {projectGuid}.SolutionConfigName|SolutionPlatform.Build.0 = ProjConfigName|ProjPlatform
// {projectGuid}.SolutionConfigName|SolutionPlatform.Deploy.0 = ProjConfigName|ProjPlatform
foreach (var prop in pset)
{
string action;
string projConfig = prop.Value;
string left = prop.Key;
if (left.EndsWith(".ActiveCfg"))
{
action = "ActiveCfg";
left = left.Substring(0, left.Length - 10);
}
else if (left.EndsWith(".Build.0"))
{
action = "Build.0";
left = left.Substring(0, left.Length - 8);
}
else if (left.EndsWith(".Deploy.0"))
{
action = "Deploy.0";
left = left.Substring(0, left.Length - 9);
}
else
{
LoggingService.LogWarning(GettextCatalog.GetString("{0} ({1}) : Unknown action. Only ActiveCfg, Build.0 and Deploy.0 supported.",
sln.FileName, pset.Line));
continue;
}
string slnConfig = left;
string key = projGuid + "." + slnConfig;
SolutionConfigurationEntry combineConfigEntry = null;
if (cache.ContainsKey(key))
{
combineConfigEntry = cache [key];
}
else
{
combineConfigEntry = GetConfigEntry(sln, item, slnConfig);
combineConfigEntry.Build = false; // Not buildable by default. Build will be enabled if a Build.0 entry is found
cache [key] = combineConfigEntry;
}
/* If both ActiveCfg & Build.0 entries are missing
* for a project, then default values :
* ActiveCfg : same as the solution config
* Build : true
*
* ELSE
* if Build (true/false) for the project will
* will depend on presence/absence of Build.0 entry
*/
if (action == "ActiveCfg")
{
combineConfigEntry.ItemConfiguration = FromSlnConfigurationId(projConfig);
}
else if (action == "Build.0")
{
combineConfigEntry.Build = true;
}
else if (action == "Deploy.0")
{
combineConfigEntry.Deploy = true;
}
}
}
}
public abstract bool AddToProject(SolutionItem policyParent, Project project, string language, string directory, string name);
