public virtual DeployFileCollection GetCombineDeployFiles (DeployContext ctx, SolutionFolder combine, ConfigurationSelector configuration)
{
if (Next != null)
return Next.GetDeployFiles (ctx, combine, configuration);
else
return new DeployFileCollection ();
}
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 (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);
}
internal void AddProject(AbstractDProject sub)
{
var folder = sub.BaseDirectory == BaseDirectory || sub.BaseDirectory.IsChildPathOf (BaseDirectory) ? RootFolder : ExternalDepFolder;
if (folder == ExternalDepFolder && sub is DubProject) {
var packageName = (sub as DubProject).packageName.Split(':');
for (int i = 0; i < packageName.Length - 1; i++) {
bool foundSubFolder = false;
foreach (var subFolder in folder.GetAllItems<SolutionFolder>()) {
if (String.Equals (subFolder.Name, packageName [i], StringComparison.CurrentCultureIgnoreCase)) {
folder = subFolder;
foundSubFolder = true;
break;
}
}
if (!foundSubFolder) {
var newSubFolder = new SolutionFolder{ Name = packageName [i] };
folder.AddItem (newSubFolder);
folder = newSubFolder;
}
}
}
if (!folder.Items.Contains (sub))
folder.AddItem (sub, false);
}
public FeatureSupportLevel GetSupportLevel (SolutionFolder parentCombine, SolutionItem entry)
{
if (entry is Project)
return FeatureSupportLevel.SupportedByDefault;
else
return FeatureSupportLevel.NotSupported;
}
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 void CheckProjectContainsItself()
{
var folder = new SolutionFolder ();
var project = new DotNetAssemblyProject { Name = "foo" };
folder.AddItem (project);
Assert.IsNotNull (folder.GetProjectContainingFile (project.FileName), "#1");
}
public ProtobuildSubmodule (ProtobuildModuleInfo latestModuleInfo, ProtobuildModuleInfo submodule, SolutionFolder rootFolder)
{
parentModule = latestModuleInfo;
currentModule = submodule;
RootFolder = rootFolder;
Packages = new ProtobuildPackages(this);
Definitions = new ItemCollection<IProtobuildDefinition>();
Submodules = new ItemCollection<ProtobuildSubmodule>();
}
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 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 SolutionFolderTestGroup (SolutionFolder c): base (c.Name, c)
{
string storeId = c.ItemId;
string resultsPath = Path.Combine (c.BaseDirectory, "test-results");
ResultsStore = new XmlResultsStore (resultsPath, storeId);
combine = c;
combine.ItemAdded += OnEntryChanged;
combine.ItemRemoved += OnEntryChanged;
combine.NameChanged += OnCombineRenamed;
}
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;
}
public SolutionFolderTestGroup (SolutionFolder c): base (c.Name, c)
{
string storeId = c.ItemId;
string resultsPath = MonoDevelop.NUnit.RootTest.GetTestResultsDirectory (c.BaseDirectory);
ResultsStore = new XmlResultsStore (resultsPath, storeId);
combine = c;
combine.ItemAdded += OnEntryChanged;
combine.ItemRemoved += OnEntryChanged;
combine.NameChanged += OnCombineRenamed;
}
public FeatureSupportLevel GetSupportLevel (SolutionFolder parentCombine, SolutionItem entry)
{
if (parentCombine == null)
return FeatureSupportLevel.NotSupported;
if (entry is PackagingProject)
return FeatureSupportLevel.Enabled;
else if (entry is Project)
return FeatureSupportLevel.SupportedByDefault;
else
return FeatureSupportLevel.NotSupported;
}
ProjectCreateInformation CreateProjectCreateInformation (NewProjectConfiguration config, SolutionFolder parentFolder)
{
ProjectCreateInformation cinfo = new ProjectCreateInformation ();
cinfo.SolutionPath = new FilePath (config.SolutionLocation).ResolveLinks ();
cinfo.ProjectBasePath = new FilePath (config.ProjectLocation).ResolveLinks ();
cinfo.ProjectName = config.ProjectName;
cinfo.SolutionName = config.SolutionName;
cinfo.ParentFolder = parentFolder;
cinfo.ActiveConfiguration = IdeApp.Workspace.ActiveConfiguration;
cinfo.Parameters = config.Parameters;
return cinfo;
}
public static SolutionFolder AddSolutionFolder(this Solution solution, string name, params FilePath[] files)
{
var solutionFolder = new SolutionFolder {
Name = name
};
foreach (FilePath file in files) {
solutionFolder.Files.Add (file);
}
solution.RootFolder.AddItem (solutionFolder);
return solutionFolder;
}
public SolutionFolderTestGroup (SolutionFolder c): base (c.Name, c)
{
string storeId = c.ItemId;
string resultsPath = UnitTestService.GetTestResultsDirectory (c.BaseDirectory);
ResultsStore = new BinaryResultsStore (resultsPath, storeId);
folder = c;
folder.NameChanged += OnCombineRenamed;
if (c.IsRoot) {
folder.ParentSolution.SolutionItemAdded += OnEntryChanged;
folder.ParentSolution.SolutionItemRemoved += OnEntryChanged;
}
}
ProcessedTemplateResult ProcessTemplate (DefaultSolutionTemplate template, NewProjectConfiguration config, SolutionFolder parentFolder)
{
IEnumerable<IWorkspaceFileObject> newItems = null;
ProjectCreateInformation cinfo = CreateProjectCreateInformation (config, parentFolder);
if (parentFolder == null) {
IWorkspaceFileObject newItem = template.Template.CreateWorkspaceItem (cinfo);
if (newItem != null) {
newItems = new [] { newItem };
}
} else {
newItems = template.Template.CreateProjects (parentFolder, cinfo);
}
return new DefaultProcessedTemplateResult (template.Template, newItems, cinfo.ProjectBasePath);
}
public SolutionFolderTestGroup (SolutionFolder c): base (c.Name, c)
{
string storeId = c.ItemId;
string resultsPath = MonoDevelop.NUnit.RootTest.GetTestResultsDirectory (c.BaseDirectory);
ResultsStore = new BinaryResultsStore (resultsPath, storeId);
folder = c;
folder.NameChanged += OnCombineRenamed;
if (c.IsRoot) {
folder.ParentSolution.SolutionItemAdded += OnEntryChanged;
folder.ParentSolution.SolutionItemRemoved += OnEntryChanged;
IdeApp.Workspace.ReferenceAddedToProject += OnReferenceChanged;
IdeApp.Workspace.ReferenceRemovedFromProject += OnReferenceChanged;
}
}
public FeatureSupportLevel GetSupportLevel (SolutionFolder parentCombine, SolutionItem entry)
{
if (!(entry is DotNetProject) || !GtkDesignInfo.SupportsRefactoring (entry as DotNetProject))
return FeatureSupportLevel.NotSupported;
ReferenceManager refmgr = new ReferenceManager ((DotNetProject)entry);
if (refmgr.SupportedGtkVersions.Count == 0)
return FeatureSupportLevel.NotSupported;
if (GtkDesignInfo.SupportsDesigner ((Project)entry))
return FeatureSupportLevel.Enabled;
else if (entry is DotNetAssemblyProject)
return FeatureSupportLevel.SupportedByDefault;
else
return FeatureSupportLevel.Supported;
}
public SolutionFolderNode(SolutionFolder solutionFolder, IconProvider iconProvider)
: base(solutionFolder.FilePath)
{
this.SolutionFolder = solutionFolder;
this._iconProvider = iconProvider;
Text = solutionFolder.Name;
UpdateTextOnFilePathChanged = false;
AddStub();
ImageIndex = SelectedImageIndex = (_iconProvider = iconProvider).GetImageIndex(solutionFolder);
solutionFolder.Nodes.InsertedItem += Nodes_InsertedItem;
solutionFolder.Nodes.RemovedItem += Nodes_RemovedItem;
solutionFolder.FilePathChanged += solutionFolder_FilePathChanged;
}
private static int CountProjects(SolutionFolder folder)
{
int count = 0;
if (folder is ProjectEntry || folder is Solution)
count++;
foreach (var node in folder.Nodes)
{
if (node is SolutionFolder)
{
count += CountProjects(node as SolutionFolder);
}
}
return count;
}
public CreateProjectDialog(SolutionFolder parentFolder)
{
_parentFolder = parentFolder;
_templates = LiteDevelopApplication.Current.ExtensionHost.TemplateService.GetProjectTemplates();
InitializeComponent();
templatesListView.TemplateService = LiteDevelopApplication.Current.ExtensionHost.TemplateService;
SetupMuiComponents();
checkBox1.Checked = checkBox1.Visible = parentFolder == null;
if (parentFolder == null)
directoryTextBox.Text = LiteDevelopSettings.Instance.GetValue("Projects.DefaultProjectsPath");
else
directoryTextBox.Text = parentFolder.FilePath.HasExtension ? parentFolder.FilePath.ParentDirectory.FullPath : parentFolder.FilePath.FullPath;
languagesTreeView.Populate(_templates);
}
public void addFilesToSolution(Project solutionFolderProject, SolutionFolder solutionFolder, string basePath)
{
//For each file, add to the folder
foreach (var file in Directory.EnumerateFiles(basePath))
{
//Add the file as a copy into the solution folder
solutionFolderProject.ProjectItems.AddFromFileCopy(file);
}
//for each directory, create a new solution folder and add the files
foreach (var dir in Directory.EnumerateDirectories(basePath))
{
//Create a new solution folder and return a Project object
Project folderProject = solutionFolder.AddSolutionFolder(Path.GetFileName(dir));
//Cast the Project object to a SolutionFolder to be able to create more Solution Folders children
SolutionFolder solFolder = (SolutionFolder)folderProject.Object;
//Call the function to add the original files to the solution folder
addFilesToSolution(folderProject, solFolder, dir);
}
}
private Project AddProject(string projectSufix, string templateName, SolutionFolder sourceSolutionFolder = null, string folderName = null)
{
string destination = _replacementsDictionary["$destinationdirectory$"];
if (_sourceFolder)
{
destination = Path.Combine(destination, "Source");
}
var projectName = $"{_replacementsDictionary["$safeprojectname$"]}.{projectSufix}";
Project project;
if (sourceSolutionFolder == null)
{
if (folderName != null)
{
SolutionFolder optionalFolder = _dte.Solution.AddSolutionFolderEx(folderName);
project = optionalFolder.AddProject(destination, projectName, templateName);
}
else
{
project = _dte.Solution.AddProject(destination, projectName, templateName);
}
}
else
{
if (folderName != null)
{
SolutionFolder folder = (SolutionFolder)sourceSolutionFolder.AddSolutionFolderEx(folderName);
project = folder.AddProject(destination, projectName, templateName);
}
else
{
project = sourceSolutionFolder.AddProject(destination, projectName, templateName);
}
}
return project;
}
public PackagingFeatureWidget (SolutionFolder parentFolder, SolutionItem entry)
{
this.Build();
this.entry = entry;
this.parentFolder = parentFolder;
creatingPackProject = entry is PackagingProject;
if (!creatingPackProject) {
ReadOnlyCollection<PackagingProject> packProjects = parentFolder.ParentSolution.GetAllSolutionItems<PackagingProject> ();
newPackProject = new PackagingProject ();
string label = GettextCatalog.GetString ("Create packages for this project in a new Packaging Project");
AddCreatePackageSection (box, label, newPackProject, packProjects.Count > 0);
foreach (PackagingProject project in packProjects)
AddProject (project);
} else {
string label = GettextCatalog.GetString ("Select packages to add to the new Packaging Project");
AddCreatePackageSection (box, label, (PackagingProject) entry, false);
}
}
public void ApplyFeature (SolutionFolder parentCombine, SolutionItem entry)
{
TranslationProject newProject;
if (entry is TranslationProject)
newProject = (TranslationProject) entry;
else {
newProject = new TranslationProject ();
newProject.Name = entry.Name + "Translation";
string path = System.IO.Path.Combine (parentCombine.BaseDirectory, newProject.Name);
if (!System.IO.Directory.Exists (path))
System.IO.Directory.CreateDirectory (path);
newProject.FileName = System.IO.Path.Combine (path, newProject.Name + ".mdse");
parentCombine.Items.Add (newProject);
}
TreeIter iter;
if (store.GetIterFirst (out iter)) {
do {
string code = (string)store.GetValue (iter, 1);
newProject.AddNewTranslation (code, new NullProgressMonitor ());
} while (store.IterNext (ref iter));
}
}
public Widget CreateFeatureEditor(SolutionFolder parentCombine, SolutionItem entry)
{
return(new GtkFeatureWidget((DotNetProject)entry));
}
void OpenEvent(object sender, EventArgs e)
{
if (!btn_new.Sensitive)
{
return;
}
if (notebook.Page == 0)
{
if (!CreateProject())
{
return;
}
Solution parentSolution = null;
if (parentFolder == null)
{
WorkspaceItem item = (WorkspaceItem)newItem;
parentSolution = item as Solution;
if (parentSolution != null)
{
if (parentSolution.RootFolder.Items.Count > 0)
{
currentEntry = parentSolution.RootFolder.Items [0] as SolutionItem;
}
parentFolder = parentSolution.RootFolder;
}
}
else
{
SolutionItem item = (SolutionItem)newItem;
parentSolution = parentFolder.ParentSolution;
currentEntry = item;
}
if (btn_new.Label == Gtk.Stock.GoForward)
{
// There are features to show. Go to the next page
if (currentEntry != null)
{
try {
featureList.Fill(parentFolder, currentEntry, SolutionItemFeatures.GetFeatures(parentFolder, currentEntry));
}
catch (Exception ex) {
LoggingService.LogError(ex.ToString());
}
}
notebook.Page++;
btn_new.Label = Gtk.Stock.Ok;
return;
}
}
else
{
// Already in fetatures page
if (!featureList.Validate())
{
return;
}
}
// New combines (not added to parent combines) already have the project as child.
if (!newSolution)
{
// Make sure the new item is saved before adding. In this way the
// version control add-in will be able to put it under version control.
if (currentEntry is SolutionEntityItem)
{
// Inherit the file format from the solution
SolutionEntityItem eitem = (SolutionEntityItem)currentEntry;
eitem.FileFormat = parentFolder.ParentSolution.FileFormat;
IdeApp.ProjectOperations.Save(eitem);
}
parentFolder.AddItem(currentEntry, true);
}
if (notebook.Page == 1)
{
featureList.ApplyFeatures();
}
if (parentFolder != null)
{
IdeApp.ProjectOperations.Save(parentFolder.ParentSolution);
}
else
{
IdeApp.ProjectOperations.Save(newItem);
}
if (openSolution)
{
var op = selectedItem.OpenCreatedSolution();
op.Completed += delegate {
if (op.Success)
{
var sol = IdeApp.Workspace.GetAllSolutions().FirstOrDefault();
if (sol != null)
{
InstallProjectTemplatePackages(sol);
}
}
};
}
else
{
// The item is not a solution being opened, so it is going to be added to
// an existing item. In this case, it must not be disposed by the dialog.
disposeNewItem = false;
if (parentFolder != null)
{
InstallProjectTemplatePackages(parentFolder.ParentSolution);
}
}
Respond(ResponseType.Ok);
}
public SolutionParentViewModel(ISolutionParentViewModel parent, T model) : base(parent, model)
{
Items = new ObservableCollection <SolutionItemViewModel>();
Items.BindCollections(Model.Items, p => { return(SolutionItemViewModel.Create(this, p)); }, (pvm, p) => pvm.Model == p);
AddNewFolderCommand = ReactiveCommand.Create(() =>
{
Model.Solution.AddItem(SolutionFolder.Create("New Folder"), Model);
Model.Solution.Save();
});
AddExistingProjectCommand = ReactiveCommand.Create(async() =>
{
var dlg = new OpenFileDialog();
dlg.Title = "Open Project";
var extensions = new List <string>();
var shell = IoC.Get <IShell>();
foreach (var projectType in shell.ProjectTypes)
{
extensions.AddRange(projectType.Extensions);
}
dlg.Filters.Add(new FileDialogFilter {
Name = "AvalonStudio Project", Extensions = extensions
});
if (Platform.PlatformIdentifier == Platforms.PlatformID.Win32NT)
{
dlg.InitialDirectory = Model.Solution.CurrentDirectory;
}
else
{
dlg.InitialFileName = Model.Solution.CurrentDirectory;
}
dlg.AllowMultiple = false;
var result = await dlg.ShowAsync();
if (result != null && !string.IsNullOrEmpty(result.FirstOrDefault()))
{
var proj = await Project.LoadProjectFileAsync(Model.Solution, result[0]);
if (proj != null)
{
Model.Solution.AddItem(proj, Model);
Model.Solution.Save();
}
}
});
AddNewProjectCommand = ReactiveCommand.Create(() =>
{
var shell = IoC.Get <IShell>();
shell.ModalDialog = new NewProjectDialogViewModel(Model);
shell.ModalDialog.ShowDialog();
});
RemoveCommand = ReactiveCommand.Create(() =>
{
Model.Solution.RemoveItem(Model);
Model.Solution.Save();
});
}
internal void WriteFileInternal(SlnFile sln, Solution solution, ProgressMonitor monitor)
{
SolutionFolder c = solution.RootFolder;
// Delete data for projects that have been removed from the solution
var currentProjects = new HashSet <string> (solution.GetAllItems <SolutionFolderItem> ().Select(it => it.ItemId));
var removedProjects = new HashSet <string> ();
if (solution.LoadedProjects != null)
{
removedProjects.UnionWith(solution.LoadedProjects.Except(currentProjects));
}
var unknownProjects = new HashSet <string> (sln.Projects.Select(p => p.Id).Except(removedProjects).Except(currentProjects));
foreach (var p in removedProjects)
{
var ps = sln.Projects.GetProject(p);
if (ps != null)
{
sln.Projects.Remove(ps);
}
var pc = sln.ProjectConfigurationsSection.GetPropertySet(p, true);
if (pc != null)
{
sln.ProjectConfigurationsSection.Remove(pc);
}
}
var secNested = sln.Sections.GetSection("NestedProjects");
if (secNested != null)
{
foreach (var np in secNested.Properties.ToArray())
{
if (removedProjects.Contains(np.Key) || removedProjects.Contains(np.Value))
{
secNested.Properties.Remove(np.Key);
}
}
}
solution.LoadedProjects = currentProjects;
//Write the projects
using (monitor.BeginTask(GettextCatalog.GetString("Saving projects"), 1)) {
monitor.BeginStep();
WriteProjects(c, sln, monitor, unknownProjects);
}
//FIXME: SolutionConfigurations?
var pset = sln.SolutionConfigurationsSection;
foreach (SolutionConfiguration config in solution.Configurations)
{
var cid = ToSlnConfigurationId(config);
pset.SetValue(cid, cid);
}
WriteProjectConfigurations(solution, sln);
//Write Nested Projects
ICollection <SolutionFolder> folders = solution.RootFolder.GetAllItems <SolutionFolder> ().ToList();
if (folders.Count > 1)
{
// If folders ==1, that's the root folder
var sec = sln.Sections.GetSection("NestedProjects", SlnSectionType.PreProcess);
if (sec == null)
{
sec = sln.Sections.GetOrCreateSection("NestedProjects", SlnSectionType.PreProcess);
sec.SkipIfEmpty = true; // don't write the section if there are no nested projects after all
}
foreach (SolutionFolder folder in folders)
{
if (folder.IsRoot)
{
continue;
}
WriteNestedProjects(folder, solution.RootFolder, sec);
}
// Remove items which don't have a parent folder
var toRemove = solution.GetAllItems <SolutionFolderItem> ().Where(it => it.ParentFolder == solution.RootFolder);
foreach (var it in toRemove)
{
sec.Properties.Remove(it.ItemId);
}
}
// Write custom properties for configurations
foreach (SolutionConfiguration conf in solution.Configurations)
{
string secId = "MonoDevelopProperties." + conf.Id;
var sec = sln.Sections.GetOrCreateSection(secId, SlnSectionType.PreProcess);
solution.WriteConfigurationData(monitor, sec.Properties, conf);
if (sec.IsEmpty)
{
sln.Sections.Remove(sec);
}
}
}
public Widget CreateFeatureEditor(SolutionFolder parentCombine, SolutionItem entry)
{
return(new GettextFeatureWidget());
}
public async Task <ProcessedTemplateResult> ProcessTemplate(SolutionTemplate template, NewProjectConfiguration config, SolutionFolder parentFolder)
{
IProjectTemplatingProvider provider = GetTemplatingProviderForTemplate(template);
if (provider != null)
{
var result = await provider.ProcessTemplate(template, config, parentFolder);
if (result.WorkspaceItems.Any())
{
RecentTemplates.AddTemplate(template);
}
return(result);
}
return(null);
}
public object ReadFile(FilePath fileName, bool hasParentSolution, ProgressMonitor monitor)
{
FilePath basePath = fileName.ParentDirectory;
MonoMakefile mkfile = new MonoMakefile(fileName);
string aname = mkfile.GetVariable("LIBRARY");
if (aname == null)
{
aname = mkfile.GetVariable("PROGRAM");
}
if (!string.IsNullOrEmpty(aname))
{
monitor.BeginTask("Loading '" + fileName + "'", 0);
var project = Services.ProjectService.CreateProject("C#");
project.FileName = fileName;
var ext = new MonoMakefileProjectExtension();
project.AttachExtension(ext);
ext.Read(mkfile);
monitor.EndTask();
return(project);
}
string subdirs;
StringBuilder subdirsBuilder = new StringBuilder();
subdirsBuilder.Append(mkfile.GetVariable("common_dirs"));
if (subdirsBuilder.Length != 0)
{
subdirsBuilder.Append("\t");
subdirsBuilder.Append(mkfile.GetVariable("net_2_0_dirs"));
}
if (subdirsBuilder.Length == 0)
{
subdirsBuilder.Append(mkfile.GetVariable("SUBDIRS"));
}
subdirs = subdirsBuilder.ToString();
if (subdirs != null && (subdirs = subdirs.Trim(' ', '\t')) != "")
{
object retObject;
SolutionFolder folder;
if (!hasParentSolution)
{
Solution sol = new Solution();
sol.AttachExtension(new MonoMakefileSolutionExtension());
sol.FileName = fileName;
folder = sol.RootFolder;
retObject = sol;
foreach (string conf in MonoMakefile.MonoConfigurations)
{
SolutionConfiguration sc = new SolutionConfiguration(conf);
sol.Configurations.Add(sc);
}
}
else
{
folder = new SolutionFolder();
folder.Name = Path.GetFileName(Path.GetDirectoryName(fileName));
retObject = folder;
}
subdirs = subdirs.Replace('\t', ' ');
string[] dirs = subdirs.Split(' ');
monitor.BeginTask("Loading '" + fileName + "'", dirs.Length);
HashSet <string> added = new HashSet <string> ();
foreach (string dir in dirs)
{
if (!added.Add(dir))
{
continue;
}
monitor.Step(1);
if (dir == null)
{
continue;
}
string tdir = dir.Trim();
if (tdir == "")
{
continue;
}
string mfile = Path.Combine(Path.Combine(basePath, tdir), "Makefile");
if (File.Exists(mfile) && CanRead(mfile, typeof(SolutionItem)))
{
SolutionFolderItem it = (SolutionFolderItem)ReadFile(mfile, true, monitor);
folder.Items.Add(it);
}
}
monitor.EndTask();
return(retObject);
}
return(null);
}
void CreateStartupModes(Solution sol)
{
// Initialize the startup modes
ReadOnlyCollection <SolutionFolder> folders = sol.GetAllSolutionItems <SolutionFolder> ();
foreach (SolutionFolder folder in folders)
{
CombineStartupMode startupMode = new CombineStartupMode();
startupMode.SingleStartup = true;
startupMode.StartEntryName = null;
foreach (SolutionItem it in folder.Items)
{
startupMode.AddEntry(it.Name);
}
folder.ExtendedProperties ["StartMode"] = startupMode;
}
// Get the list of startup items
IEnumerable <SolutionEntityItem> items;
if (sol.SingleStartup)
{
items = new SolutionEntityItem [] { sol.StartupItem }
}
;
else
{
items = sol.MultiStartupItems;
}
// Setup the startup modes
foreach (SolutionEntityItem it in items)
{
if (it == null)
{
continue;
}
SolutionFolder folder = it.ParentFolder;
SolutionItem prevItem = it;
while (folder != null)
{
CombineStartupMode startupMode = (CombineStartupMode)folder.ExtendedProperties ["StartMode"];
if (startupMode.SingleStartup)
{
// If a start entry is already set, convert to multi startup mode
if (startupMode.StartEntryName == null)
{
startupMode.StartEntryName = prevItem.Name;
}
else if (startupMode.StartEntryName != prevItem.Name)
{
startupMode.SingleStartup = false;
startupMode.MakeExecutable(startupMode.StartEntryName);
startupMode.MakeExecutable(prevItem.Name);
}
}
else
{
// Already multi startup, just add the new item
startupMode.MakeExecutable(prevItem.Name);
}
prevItem = folder;
folder = folder.ParentFolder;
}
}
// Set the startup item for folders which don't have one
foreach (SolutionFolder folder in folders)
{
CombineStartupMode startupMode = (CombineStartupMode)folder.ExtendedProperties ["StartMode"];
if (startupMode.SingleStartup && startupMode.StartEntryName == null)
{
if (folder.Items.Count > 0)
{
startupMode.StartEntryName = folder.Items [0].Name;
}
}
}
}
public ProcessedTemplateResult ProcessTemplate(SolutionTemplate template, NewProjectConfiguration config, SolutionFolder parentFolder)
{
IProjectTemplatingProvider provider = GetTemplatingProviderForTemplate(template);
if (provider != null)
{
return(provider.ProcessTemplate(template, config, parentFolder));
}
return(null);
}
public override void Execute()
{
DTE dte = GetService <DTE>(true);
int success = 0;
int failures = 0;
int overwritten = 0;
//is item selected, then copy only the item
if (dte.SelectedItems.Count > 0)
{
foreach (SelectedItem item in dte.SelectedItems)
{
if (item is ProjectItem)
{
DeploymentHelpers.QuickDeployItem(dte, item as ProjectItem, ref success, ref failures, ref overwritten);
Helpers.LogMessage(dte, dte, "*** Quick Deploy finished: " + success.ToString() + " successfully (" + overwritten.ToString() + " overwrites), " + failures.ToString() + " failed ***" + Environment.NewLine);
}
else if (item.ProjectItem is ProjectItem)
{
DeploymentHelpers.QuickDeployItem(dte, item.ProjectItem as ProjectItem, ref success, ref failures, ref overwritten);
Helpers.LogMessage(dte, dte, "*** Quick Deploy finished: " + success.ToString() + " successfully (" + overwritten.ToString() + " overwrites), " + failures.ToString() + " failed ***" + Environment.NewLine);
}
else if (item.Project != null)
{
if (item.Project.Object is SolutionFolder)
{
//solution folder selected
SolutionFolder sfolder = item.Project.Object as SolutionFolder;
foreach (ProjectItem pitem in sfolder.Parent.ProjectItems)
{
if (pitem.Object is Project)
{
DeploymentHelpers.QuickDeploy(dte, pitem.Object as Project);
}
}
}
else
{
//project selected
DeploymentHelpers.QuickDeploy(dte, item.Project);
}
}
else if ((item.Project == null) && (item.ProjectItem == null))
{
//solution selected
List <Project> projects = Helpers.GetSelectedDeploymentProjects(dte);
foreach (Project project in projects)
{
//deployEachProject
DeploymentHelpers.QuickDeploy(dte, project);
}
}
}
}
else
{
List <Project> projects = Helpers.GetSelectedDeploymentProjects(dte);
foreach (Project project in projects)
{
//deployEachProject
DeploymentHelpers.QuickDeploy(dte, project);
}
}
}
public AddEntryEventArgs(SolutionFolder combine, string fileName)
{
this.combine = combine;
this.fileName = fileName;
}
public SolutionItem AddSolutionItem (SolutionFolder parentFolder)
{
SolutionItem res = null;
var dlg = new SelectFileDialog () {
Action = Gtk.FileChooserAction.Open,
CurrentFolder = parentFolder.BaseDirectory,
SelectMultiple = false,
};
dlg.AddAllFilesFilter ();
dlg.DefaultFilter = dlg.AddFilter (GettextCatalog.GetString ("Project Files"), "*.*proj", "*.mdp");
if (dlg.Run ()) {
try {
res = AddSolutionItem (parentFolder, dlg.SelectedFile);
} catch (Exception ex) {
MessageService.ShowException (ex, GettextCatalog.GetString ("The file '{0}' could not be loaded.", dlg.SelectedFile));
}
}
if (res != null)
IdeApp.Workspace.Save ();
return res;
}
public Gtk.Widget CreateFeatureEditor(SolutionFolder parentCombine, SolutionItem entry)
{
Gtk.Label label = new Gtk.Label(GettextCatalog.GetString("A new local Git Repository for the solution will be created"));
label.Show();
return(label);
}
public SolutionFolderFileNode(FilePath path, SolutionFolder parent)
{
this.Path = path;
this.parent = parent;
}
public static SolutionFolderTestGroup CreateTest(SolutionFolder c)
{
return(new SolutionFolderTestGroup(c));
}
void OpenEvent(object sender, EventArgs e)
{
if (!btn_new.Sensitive)
{
return;
}
if (notebook.Page == 0)
{
if (!CreateProject())
{
return;
}
Solution parentSolution = null;
if (parentFolder == null)
{
WorkspaceItem item = (WorkspaceItem)newItem;
parentSolution = item as Solution;
if (parentSolution != null)
{
if (parentSolution.RootFolder.Items.Count > 0)
{
currentEntry = parentSolution.RootFolder.Items [0] as SolutionItem;
}
parentFolder = parentSolution.RootFolder;
}
}
else
{
SolutionItem item = (SolutionItem)newItem;
parentSolution = parentFolder.ParentSolution;
currentEntry = item;
}
if (btn_new.Label == Gtk.Stock.GoForward)
{
// There are features to show. Go to the next page
if (currentEntry != null)
{
try {
featureList.Fill(parentFolder, currentEntry, SolutionItemFeatures.GetFeatures(parentFolder, currentEntry));
}
catch (Exception ex) {
LoggingService.LogError(ex.ToString());
}
}
notebook.Page++;
btn_new.Label = Gtk.Stock.Ok;
return;
}
}
else
{
// Already in fetatures page
if (!featureList.Validate())
{
return;
}
}
// New combines (not added to parent combines) already have the project as child.
if (!newSolution)
{
// Make sure the new item is saved before adding. In this way the
// version control add-in will be able to put it under version control.
if (currentEntry is SolutionEntityItem)
{
// Inherit the file format from the solution
SolutionEntityItem eitem = (SolutionEntityItem)currentEntry;
eitem.FileFormat = parentFolder.ParentSolution.FileFormat;
IdeApp.ProjectOperations.Save(eitem);
}
parentFolder.AddItem(currentEntry, true);
}
if (notebook.Page == 1)
{
featureList.ApplyFeatures();
}
if (parentFolder != null)
{
IdeApp.ProjectOperations.Save(parentFolder.ParentSolution);
}
else
{
IdeApp.ProjectOperations.Save(newItem);
}
if (openSolution)
{
selectedItem.OpenCreatedSolution();
}
Respond(ResponseType.Ok);
}
public bool IsEnabled(SolutionFolder parentCombine, SolutionItem entry)
{
return(entry is TranslationProject);
}
public void CtorTest1()
{
var f = new SolutionFolder("MyFolder1", ".gnt\\gnt.core", ".gnt\\packages.config");
Assert.Equal
(
new SolutionFolder()
{
header = new ProjectItem()
{
name = "MyFolder1",
EpType = ProjectType.SlnFolder,
pType = "{2150E333-8FDC-42A3-9474-1A3956D46DE8}",
pGuid = f.header.pGuid,
path = f.header.path,
fullPath = f.header.fullPath,
},
items = new List <RawText>()
{
".gnt\\gnt.core", ".gnt\\packages.config"
}
},
f
);
Assert.Equal(2, f.items.Count());
Assert.Equal((RawText)".gnt\\gnt.core", f.items.ElementAt(0));
Assert.Equal((RawText)".gnt\\packages.config", f.items.ElementAt(1));
f = new SolutionFolder("MyFolder1", ".gnt\\gnt.core");
Assert.Equal
(
new SolutionFolder()
{
header = new ProjectItem()
{
name = "MyFolder1",
EpType = ProjectType.SlnFolder,
pType = "{2150E333-8FDC-42A3-9474-1A3956D46DE8}",
pGuid = f.header.pGuid,
path = f.header.path,
fullPath = f.header.fullPath,
},
items = new List <RawText>()
{
".gnt\\gnt.core"
}
},
f
);
Assert.Single(f.items);
Assert.Equal((RawText)".gnt\\gnt.core", f.items.ElementAt(0));
f = new SolutionFolder("MyFolder1");
Assert.Equal
(
new SolutionFolder()
{
header = new ProjectItem()
{
name = "MyFolder1",
EpType = ProjectType.SlnFolder,
pType = "{2150E333-8FDC-42A3-9474-1A3956D46DE8}",
pGuid = f.header.pGuid,
path = f.header.path,
fullPath = f.header.fullPath,
},
items = new List <RawText>()
{
}
},
f
);
Assert.Empty(f.items);
}
public object ReadFile(FilePath fileName, bool hasParentSolution, IProgressMonitor monitor)
{
FilePath basePath = fileName.ParentDirectory;
MonoMakefile mkfile = new MonoMakefile(fileName);
string aname = mkfile.GetVariable("LIBRARY");
if (aname == null)
{
aname = mkfile.GetVariable("PROGRAM");
}
try {
ProjectExtensionUtil.BeginLoadOperation();
if (aname != null)
{
// It is a project
monitor.BeginTask("Loading '" + fileName + "'", 0);
DotNetAssemblyProject project = new DotNetAssemblyProject("C#");
MonoSolutionItemHandler handler = new MonoSolutionItemHandler(project);
ProjectExtensionUtil.InstallHandler(handler, project);
project.Name = Path.GetFileName(basePath);
handler.Read(mkfile);
monitor.EndTask();
return(project);
}
else
{
string subdirs;
StringBuilder subdirsBuilder = new StringBuilder();
subdirsBuilder.Append(mkfile.GetVariable("common_dirs"));
if (subdirsBuilder.Length != 0)
{
subdirsBuilder.Append("\t");
subdirsBuilder.Append(mkfile.GetVariable("net_2_0_dirs"));
}
if (subdirsBuilder.Length == 0)
{
subdirsBuilder.Append(mkfile.GetVariable("SUBDIRS"));
}
subdirs = subdirsBuilder.ToString();
if (subdirs != null && (subdirs = subdirs.Trim(' ', '\t')) != "")
{
object retObject;
SolutionFolder folder;
if (!hasParentSolution)
{
Solution sol = new Solution();
sol.ConvertToFormat(Services.ProjectService.FileFormats.GetFileFormat("MonoMakefile"), false);
sol.FileName = fileName;
folder = sol.RootFolder;
retObject = sol;
foreach (string conf in MonoMakefileFormat.Configurations)
{
SolutionConfiguration sc = new SolutionConfiguration(conf);
sol.Configurations.Add(sc);
}
}
else
{
folder = new SolutionFolder();
folder.Name = Path.GetFileName(Path.GetDirectoryName(fileName));
retObject = folder;
}
subdirs = subdirs.Replace('\t', ' ');
string[] dirs = subdirs.Split(' ');
monitor.BeginTask("Loading '" + fileName + "'", dirs.Length);
Hashtable added = new Hashtable();
foreach (string dir in dirs)
{
if (added.Contains(dir))
{
continue;
}
added.Add(dir, dir);
monitor.Step(1);
if (dir == null)
{
continue;
}
string tdir = dir.Trim();
if (tdir == "")
{
continue;
}
string mfile = Path.Combine(Path.Combine(basePath, tdir), "Makefile");
if (File.Exists(mfile) && CanReadFile(mfile, typeof(SolutionItem)))
{
SolutionItem it = (SolutionItem)ReadFile(mfile, true, monitor);
folder.Items.Add(it);
}
}
monitor.EndTask();
return(retObject);
}
}
} finally {
ProjectExtensionUtil.EndLoadOperation();
}
return(null);
}
void AddProject(PackagingProject project)
{
string pname = project.Name;
SolutionFolder c = project.ParentFolder;
while (c != null)
{
pname = c.Name + " / " + pname;
if (c.IsRoot)
{
break;
}
c = c.ParentFolder;
}
// Get a list of packages that can contain the new project
ArrayList list = new ArrayList();
foreach (Package p in project.Packages)
{
if (p.PackageBuilder.CanBuild(entry))
{
list.Add(p);
}
}
string label;
Gtk.VBox vbox;
if (list.Count > 0)
{
label = GettextCatalog.GetString("Add the new project to the Packaging Project '{0}'", pname);
Gtk.CheckButton checkAddNew = new Gtk.CheckButton(label);
checkAddNew.Show();
box.PackStart(checkAddNew, false, false, 0);
Gtk.Widget hbox;
AddBox(box, out hbox, out vbox);
checkAddNew.Toggled += delegate
{
hbox.Visible = checkAddNew.Active;
if (!checkAddNew.Active)
{
DisableChecks(hbox);
}
};
// Options for adding the project to existing packages
label = GettextCatalog.GetString("Add the project to existing packages");
Gtk.CheckButton checkAddExist = new Gtk.CheckButton(label);
checkAddExist.Show();
vbox.PackStart(checkAddExist, false, false, 0);
Gtk.VBox vboxPacks;
Gtk.Widget thbox;
AddBox(vbox, out thbox, out vboxPacks);
checkAddExist.Toggled += delegate
{
thbox.Visible = checkAddExist.Active;
if (!checkAddExist.Active)
{
DisableChecks(thbox);
}
};
foreach (Package p in list)
{
label = p.Name;
if (label != p.PackageBuilder.Description)
{
label += " (" + p.PackageBuilder.Description + ")";
}
Gtk.CheckButton checkPackage = new Gtk.CheckButton(label);
checkPackage.Show();
vboxPacks.PackStart(checkPackage, false, false, 0);
RegisterCheck(checkPackage, project, p);
}
// Options for creating new packages
label = GettextCatalog.GetString("Create new packages for the project");
AddCreatePackageSection(vbox, label, project, true);
}
else
{
label = GettextCatalog.GetString("Add new packages for this project in the packaging project '{0}'", pname);
AddCreatePackageSection(box, label, project, true);
}
}
public void CtorTest7()
{
var f0 = new SolutionFolder("dir1");
var f = new SolutionFolder
(
"{EE7DD6B7-56F4-478D-8745-3D204D915473}", "MyFolder4", f0,
(new RawText[] { ".gnt\\gnt.core" }).AsEnumerable()
);
Assert.Equal
(
new SolutionFolder()
{
header = new ProjectItem()
{
name = "MyFolder4",
EpType = ProjectType.SlnFolder,
pType = "{2150E333-8FDC-42A3-9474-1A3956D46DE8}",
pGuid = "{EE7DD6B7-56F4-478D-8745-3D204D915473}",
parent = f0,
path = f.header.path,
fullPath = f.header.fullPath,
},
items = new List <RawText>()
{
".gnt\\gnt.core"
}
},
f
);
Assert.Single(f.items);
Assert.Equal((RawText)".gnt\\gnt.core", f.items.ElementAt(0));
f = new SolutionFolder
(
"{EE7DD6B7-56F4-478D-8745-3D204D915473}", "MyFolder1", f0,
".gnt\\gnt.core", ".gnt\\packages.config"
);
Assert.Equal
(
new SolutionFolder()
{
header = new ProjectItem()
{
name = "MyFolder1",
EpType = ProjectType.SlnFolder,
pType = "{2150E333-8FDC-42A3-9474-1A3956D46DE8}",
pGuid = "{EE7DD6B7-56F4-478D-8745-3D204D915473}",
parent = f0,
path = f.header.path,
fullPath = f.header.fullPath,
},
items = new List <RawText>()
{
".gnt\\gnt.core", ".gnt\\packages.config"
}
},
f
);
Assert.Equal(2, f.items.Count());
Assert.Equal((RawText)".gnt\\gnt.core", f.items.ElementAt(0));
Assert.Equal((RawText)".gnt\\packages.config", f.items.ElementAt(1));
f = new SolutionFolder("{EE7DD6B7-56F4-478D-8745-3D204D915473}", "MyFolder2", f0, ".gnt\\gnt.core");
Assert.Equal
(
new SolutionFolder()
{
header = new ProjectItem()
{
name = "MyFolder2",
EpType = ProjectType.SlnFolder,
pType = "{2150E333-8FDC-42A3-9474-1A3956D46DE8}",
pGuid = "{EE7DD6B7-56F4-478D-8745-3D204D915473}",
parent = f0,
path = f.header.path,
fullPath = f.header.fullPath,
},
items = new List <RawText>()
{
".gnt\\gnt.core"
}
},
f
);
Assert.Single(f.items);
Assert.Equal((RawText)".gnt\\gnt.core", f.items.ElementAt(0));
f = new SolutionFolder("{5D5C7878-22BE-4E5B-BD96-6CBBAC614AD3}", "MyFolder3", f0);
Assert.Equal
(
new SolutionFolder()
{
header = new ProjectItem()
{
name = "MyFolder3",
EpType = ProjectType.SlnFolder,
pType = "{2150E333-8FDC-42A3-9474-1A3956D46DE8}",
pGuid = "{5D5C7878-22BE-4E5B-BD96-6CBBAC614AD3}",
parent = f0,
path = f.header.path,
fullPath = f.header.fullPath,
},
items = new List <RawText>()
{
}
},
f
);
Assert.Empty(f.items);
}
private string Generate(
Solution solution,
IReadOnlyList <Solution.Configuration> solutionConfigurations,
string solutionPath,
string solutionFile,
bool addMasterBff,
out bool updated
)
{
// reset current solution state
_rootSolutionFolders.Clear();
_solutionFolders.Clear();
FileInfo solutionFileInfo = new FileInfo(Util.GetCapitalizedPath(solutionPath + Path.DirectorySeparatorChar + solutionFile + SolutionExtension));
string solutionGuid = Util.BuildGuid(solutionFileInfo.FullName, solution.SharpmakeCsPath);
DevEnv devEnv = solutionConfigurations[0].Target.GetFragment <DevEnv>();
List <Solution.ResolvedProject> solutionProjects = ResolveSolutionProjects(solution, solutionConfigurations);
if (solutionProjects.Count == 0)
{
updated = solutionFileInfo.Exists;
if (updated)
{
Util.TryDeleteFile(solutionFileInfo.FullName);
}
return(solutionFileInfo.FullName);
}
List <Solution.ResolvedProject> resolvedPathReferences = ResolveReferencesByPath(solutionProjects, solutionConfigurations[0].ProjectReferencesByPath);
var guidlist = solutionProjects.Select(p => p.UserData["Guid"]);
resolvedPathReferences = resolvedPathReferences.Where(r => !guidlist.Contains(r.UserData["Guid"])).ToList();
var fileGenerator = new FileGenerator();
// write solution header
switch (devEnv)
{
case DevEnv.vs2010: fileGenerator.Write(Template.Solution.HeaderBeginVs2010); break;
case DevEnv.vs2012: fileGenerator.Write(Template.Solution.HeaderBeginVs2012); break;
case DevEnv.vs2013: fileGenerator.Write(Template.Solution.HeaderBeginVs2013); break;
case DevEnv.vs2015: fileGenerator.Write(Template.Solution.HeaderBeginVs2015); break;
case DevEnv.vs2017: fileGenerator.Write(Template.Solution.HeaderBeginVs2017); break;
case DevEnv.vs2019: fileGenerator.Write(Template.Solution.HeaderBeginVs2019); break;
default:
Console.WriteLine("Unsupported DevEnv for solution " + solutionConfigurations[0].Target.GetFragment <DevEnv>());
break;
}
SolutionFolder masterBffFolder = null;
if (addMasterBff)
{
masterBffFolder = GetSolutionFolder(solution.FastBuildMasterBffSolutionFolder);
if (masterBffFolder == null)
{
throw new Error("FastBuildMasterBffSolutionFolder needs to be set in solution " + solutionFile);
}
}
// Write all needed folders before the projects to make sure the proper startup project is selected.
// Ensure folders are always in the same order to avoid random shuffles
_solutionFolders.Sort((a, b) =>
{
int nameComparison = string.Compare(a.Name, b.Name, StringComparison.InvariantCultureIgnoreCase);
if (nameComparison != 0)
{
return(nameComparison);
}
return(a.Guid.CompareTo(b.Guid));
});
foreach (SolutionFolder folder in _solutionFolders)
{
using (fileGenerator.Declare("folderName", folder.Name))
using (fileGenerator.Declare("folderGuid", folder.Guid.ToString().ToUpper()))
{
fileGenerator.Write(Template.Solution.ProjectFolder);
if (masterBffFolder == folder)
{
var bffFilesPaths = new SortedSet <string>(new FileSystemStringComparer());
foreach (var conf in solutionConfigurations)
{
string masterBffFilePath = conf.MasterBffFilePath + FastBuildSettings.FastBuildConfigFileExtension;
bffFilesPaths.Add(Util.PathGetRelative(solutionPath, masterBffFilePath));
bffFilesPaths.Add(Util.PathGetRelative(solutionPath, FastBuild.MasterBff.GetGlobalBffConfigFileName(masterBffFilePath)));
}
// This always needs to be created so make sure it's there.
bffFilesPaths.Add(solutionFile + FastBuildSettings.FastBuildConfigFileExtension);
fileGenerator.Write(Template.Solution.SolutionItemBegin);
{
foreach (var path in bffFilesPaths)
{
using (fileGenerator.Declare("solutionItemPath", path))
fileGenerator.Write(Template.Solution.SolutionItem);
}
}
fileGenerator.Write(Template.Solution.ProjectSectionEnd);
}
fileGenerator.Write(Template.Solution.ProjectEnd);
}
}
Solution.ResolvedProject fastBuildAllProjectForSolutionDependency = null;
if (solution.FastBuildAllSlnDependencyFromExe)
{
var fastBuildAllProjects = solutionProjects.Where(p => p.Project.IsFastBuildAll).ToArray();
if (fastBuildAllProjects.Length > 1)
{
throw new Error("More than one FastBuildAll project");
}
if (fastBuildAllProjects.Length == 1)
{
fastBuildAllProjectForSolutionDependency = fastBuildAllProjects[0];
}
}
using (fileGenerator.Declare("solution", solution))
using (fileGenerator.Declare("solutionGuid", solutionGuid))
{
foreach (Solution.ResolvedProject resolvedProject in solutionProjects.Concat(resolvedPathReferences).Distinct(new Solution.ResolvedProjectGuidComparer()))
{
FileInfo projectFileInfo = new FileInfo(resolvedProject.ProjectFile);
using (fileGenerator.Declare("project", resolvedProject.Project))
using (fileGenerator.Declare("projectName", resolvedProject.ProjectName))
using (fileGenerator.Declare("projectFile", Util.PathGetRelative(solutionFileInfo.Directory.FullName, projectFileInfo.FullName)))
using (fileGenerator.Declare("projectGuid", resolvedProject.UserData["Guid"]))
using (fileGenerator.Declare("projectTypeGuid", resolvedProject.UserData["TypeGuid"]))
{
fileGenerator.Write(Template.Solution.ProjectBegin);
Strings buildDepsGuids = new Strings(resolvedProject.Configurations.SelectMany(
c => c.GenericBuildDependencies.Select(
p => p.ProjectGuid ?? ReadGuidFromProjectFile(p.ProjectFullFileNameWithExtension)
)
));
if (fastBuildAllProjectForSolutionDependency != null)
{
bool writeDependencyToFastBuildAll = (resolvedProject.Configurations.Any(conf => conf.IsFastBuild && conf.Output == Project.Configuration.OutputType.Exe)) ||
solution.ProjectsDependingOnFastBuildAllForThisSolution.Contains(resolvedProject.Project);
if (writeDependencyToFastBuildAll)
{
buildDepsGuids.Add(fastBuildAllProjectForSolutionDependency.UserData["Guid"] as string);
}
}
if (buildDepsGuids.Any())
{
fileGenerator.Write(Template.Solution.ProjectDependencyBegin);
foreach (string guid in buildDepsGuids)
{
using (fileGenerator.Declare("projectDependencyGuid", guid))
fileGenerator.Write(Template.Solution.ProjectDependency);
}
fileGenerator.Write(Template.Solution.ProjectSectionEnd);
}
fileGenerator.Write(Template.Solution.ProjectEnd);
}
}
}
// Write extra solution items
// TODO: What happens if we define an existing folder?
foreach (var items in solution.ExtraItems)
{
using (fileGenerator.Declare("folderName", items.Key))
using (fileGenerator.Declare("folderGuid", Util.BuildGuid(items.Key)))
using (fileGenerator.Declare("solution", solution))
{
fileGenerator.Write(Template.Solution.ProjectFolder);
{
fileGenerator.Write(Template.Solution.SolutionItemBegin);
foreach (string file in items.Value)
{
using (fileGenerator.Declare("solutionItemPath", Util.PathGetRelative(solutionPath, file)))
fileGenerator.Write(Template.Solution.SolutionItem);
}
fileGenerator.Write(Template.Solution.ProjectSectionEnd);
}
fileGenerator.Write(Template.Solution.ProjectEnd);
}
}
fileGenerator.Write(Template.Solution.GlobalBegin);
// Write source code control information
if (solution.PerforceRootPath != null)
{
List <Solution.ResolvedProject> sccProjects = new List <Solution.ResolvedProject>();
foreach (Solution.ResolvedProject resolvedProject in solutionProjects)
{
if (resolvedProject.Project.PerforceRootPath != null)
{
sccProjects.Add(resolvedProject);
}
else
{
_builder.LogWriteLine(@"warning: cannot bind solution {0} to perforce, PerforceRootPath for project '{1}' is not set.", solutionFileInfo.Name, resolvedProject.Project.ClassName);
}
}
if (sccProjects.Count == solutionProjects.Count)
{
using (fileGenerator.Declare("sccNumberOfProjects", sccProjects.Count))
{
fileGenerator.Write(Template.Solution.GlobalSectionSolutionSourceCodeControlBegin);
}
for (int i = 0; i < sccProjects.Count; ++i)
{
Solution.ResolvedProject resolvedProject = sccProjects[i];
FileInfo projectFileInfo = new FileInfo(resolvedProject.ProjectFile);
//SccProjectUniqueName7 = ..\\..\\extern\\techgroup\\framework\\gear\\private\\compilers\\win32\\vc9\\gear_win32_compile.vcproj
string sccProjectUniqueName = Util.PathGetRelative(solutionFileInfo.Directory.FullName, projectFileInfo.FullName).Replace("\\", "\\\\");
//SccProjectTopLevelParentUniqueName7 = guildlib.sln
string sccProjectTopLevelParentUniqueName = solutionFileInfo.Name;
// sln to perforce file
//SccLocalPath7 = ..\\..\\extern\\techgroup\\framework\\gear
string sccLocalPath = Util.PathGetRelative(solutionPath, resolvedProject.Project.PerforceRootPath).Replace("\\", "\\\\");
//SccProjectFilePathRelativizedFromConnection7 = private\\compilers\\win32\\vc9\\
string sccProjectFilePathRelativizedFromConnection = Util.PathGetRelative(resolvedProject.Project.PerforceRootPath, projectFileInfo.DirectoryName).Trim('.', '\\').Replace("\\", "\\\\");
using (fileGenerator.Declare("i", i))
using (fileGenerator.Declare("sccProjectUniqueName", sccProjectUniqueName))
using (fileGenerator.Declare("sccProjectTopLevelParentUniqueName", sccProjectTopLevelParentUniqueName))
using (fileGenerator.Declare("sccLocalPath", sccLocalPath))
using (fileGenerator.Declare("sccProjectFilePathRelativizedFromConnection", sccProjectFilePathRelativizedFromConnection))
{
fileGenerator.Write(Template.Solution.GlobalSectionSolutionSourceCodeControlProject);
}
}
fileGenerator.Write(Template.Solution.GlobalSectionSolutionSourceCodeControlEnd);
}
}
// write solution configurations
string visualStudioExe = GetVisualStudioIdePath(devEnv) + Util.WindowsSeparator + "devenv.com";
var configurationSectionNames = new List <string>();
bool containsMultiDotNetFramework = solutionConfigurations.All(sc => sc.Target.HaveFragment <DotNetFramework>()) &&
solutionConfigurations.Select(sc => sc.Target.GetFragment <DotNetFramework>()).Distinct().Count() > 1;
var multiDotNetFrameworkConfigurationNames = new HashSet <string>();
fileGenerator.Write(Template.Solution.GlobalSectionSolutionConfigurationBegin);
foreach (Solution.Configuration solutionConfiguration in solutionConfigurations)
{
string configurationName;
string category;
if (solution.MergePlatformConfiguration)
{
configurationName = solutionConfiguration.PlatformName + "-" + solutionConfiguration.Name;
category = "All Platforms";
}
else
{
configurationName = solutionConfiguration.Name;
category = solutionConfiguration.PlatformName;
}
if (containsMultiDotNetFramework)
{
if (multiDotNetFrameworkConfigurationNames.Contains(configurationName))
{
continue;
}
multiDotNetFrameworkConfigurationNames.Add(configurationName);
}
using (fileGenerator.Declare("configurationName", configurationName))
using (fileGenerator.Declare("category", category))
{
configurationSectionNames.Add(fileGenerator.Resolver.Resolve(Template.Solution.GlobalSectionSolutionConfiguration));
}
// set the compile command line
if (File.Exists(visualStudioExe))
{
solutionConfiguration.CompileCommandLine = string.Format(@"""{0}"" ""{1}"" /build ""{2}|{3}""",
visualStudioExe, solutionFileInfo.FullName, configurationName, category);
}
}
configurationSectionNames.Sort();
VerifySectionNamesDuplicates(solutionFileInfo.FullName, solutionConfigurations, configurationSectionNames);
foreach (string configurationSectionName in configurationSectionNames)
{
fileGenerator.Write(configurationSectionName);
}
fileGenerator.Write(Template.Solution.GlobalSectionSolutionConfigurationEnd);
// write all project target and match then to a solution target
fileGenerator.Write(Template.Solution.GlobalSectionProjectConfigurationBegin);
var solutionConfigurationFastBuildBuilt = new Dictionary <Solution.Configuration, List <string> >();
foreach (Solution.ResolvedProject solutionProject in solutionProjects)
{
if (containsMultiDotNetFramework)
{
multiDotNetFrameworkConfigurationNames.Clear();
}
foreach (Solution.Configuration solutionConfiguration in solutionConfigurations)
{
ITarget solutionTarget = solutionConfiguration.Target;
ITarget projectTarget = null;
Solution.Configuration.IncludedProjectInfo includedProject = solutionConfiguration.GetProject(solutionProject.Project.GetType());
bool perfectMatch = includedProject != null && solutionProject.Configurations.Contains(includedProject.Configuration);
if (perfectMatch)
{
projectTarget = includedProject.Target;
}
else
{
// try to find the target in the project that is the closest match from the solution one
int maxEqualFragments = 0;
int[] solutionTargetValues = solutionTarget.GetFragmentsValue();
Platform previousPlatform = Platform._reserved1;
foreach (var conf in solutionProject.Configurations)
{
Platform currentTargetPlatform = conf.Target.GetPlatform();
int[] candidateTargetValues = conf.Target.GetFragmentsValue();
if (solutionTargetValues.Length != candidateTargetValues.Length)
{
continue;
}
int equalFragments = 0;
for (int i = 0; i < solutionTargetValues.Length; ++i)
{
if ((solutionTargetValues[i] & candidateTargetValues[i]) != 0)
{
equalFragments++;
}
}
if ((equalFragments == maxEqualFragments && currentTargetPlatform < previousPlatform) || equalFragments > maxEqualFragments)
{
projectTarget = conf.Target;
maxEqualFragments = equalFragments;
previousPlatform = currentTargetPlatform;
}
}
// last resort: if we didn't find a good enough match, fallback to TargetDefault
if (projectTarget == null)
{
projectTarget = solutionProject.TargetDefault;
}
}
Project.Configuration projectConf = solutionProject.Project.GetConfiguration(projectTarget);
if (includedProject != null && includedProject.Configuration.IsFastBuild)
{
solutionConfigurationFastBuildBuilt.GetValueOrAdd(solutionConfiguration, new List <string>());
}
Platform projectPlatform = projectTarget.GetPlatform();
string configurationName;
string category;
if (solution.MergePlatformConfiguration)
{
configurationName = solutionConfiguration.PlatformName + "-" + solutionConfiguration.Name;
category = "All Platforms";
}
else
{
configurationName = solutionConfiguration.Name;
category = solutionConfiguration.PlatformName;
}
if (containsMultiDotNetFramework)
{
if (multiDotNetFrameworkConfigurationNames.Contains(configurationName))
{
continue;
}
multiDotNetFrameworkConfigurationNames.Add(configurationName);
}
using (fileGenerator.Declare("solutionConf", solutionConfiguration))
using (fileGenerator.Declare("projectGuid", solutionProject.UserData["Guid"]))
using (fileGenerator.Declare("projectConf", projectConf))
using (fileGenerator.Declare("projectPlatform", Util.GetPlatformString(projectPlatform, solutionProject.Project, solutionConfiguration.Target, true)))
using (fileGenerator.Declare("category", category))
using (fileGenerator.Declare("configurationName", configurationName))
{
bool build = false;
if (solution is PythonSolution)
{
// nothing is built in python solutions
}
else if (perfectMatch)
{
build = includedProject.ToBuild == Solution.Configuration.IncludedProjectInfo.Build.Yes;
// for fastbuild, only build the projects that cannot be built through dependency chain
if (!projectConf.IsFastBuild)
{
build |= includedProject.ToBuild == Solution.Configuration.IncludedProjectInfo.Build.YesThroughDependency;
}
else
{
if (build)
{
solutionConfigurationFastBuildBuilt[solutionConfiguration].Add(projectConf.Project.Name + " " + projectConf.Name);
}
}
}
fileGenerator.Write(Template.Solution.GlobalSectionProjectConfigurationActive);
if (build)
{
fileGenerator.Write(Template.Solution.GlobalSectionProjectConfigurationBuild);
bool deployProject = includedProject.Project.DeployProject || includedProject.Configuration.DeployProject;
if (deployProject)
{
fileGenerator.Write(Template.Solution.GlobalSectionProjectConfigurationDeploy);
}
}
}
}
}
foreach (var fb in solutionConfigurationFastBuildBuilt)
{
var solutionConfiguration = fb.Key;
if (fb.Value.Count == 0)
{
Builder.Instance.LogErrorLine($"{solutionFile} - {solutionConfiguration.Name}|{solutionConfiguration.PlatformName} - has no FastBuild projects to build.");
}
else if (solution.GenerateFastBuildAllProject && fb.Value.Count > 1)
{
Builder.Instance.LogErrorLine($"{solutionFile} - {solutionConfiguration.Name}|{solutionConfiguration.PlatformName} - has more than one FastBuild project to build ({string.Join(";", fb.Value)}).");
}
}
fileGenerator.Write(Template.Solution.GlobalSectionProjectConfigurationEnd);
fileGenerator.Write(Template.Solution.SolutionProperties);
// Write nested folders
if (_solutionFolders.Count != 0)
{
fileGenerator.Write(Template.Solution.NestedProjectBegin);
foreach (SolutionFolder folder in _solutionFolders)
{
if (folder.Parent != null)
{
using (fileGenerator.Declare("nestedChildGuid", folder.Guid.ToString().ToUpper()))
using (fileGenerator.Declare("nestedParentGuid", folder.Parent.Guid.ToString().ToUpper()))
{
fileGenerator.Write(Template.Solution.NestedProjectItem);
}
}
}
foreach (Solution.ResolvedProject resolvedProject in solutionProjects.Concat(resolvedPathReferences))
{
SolutionFolder folder = resolvedProject.UserData["Folder"] as SolutionFolder;
if (folder != null)
{
using (fileGenerator.Declare("nestedChildGuid", resolvedProject.UserData["Guid"].ToString().ToUpper()))
using (fileGenerator.Declare("nestedParentGuid", folder.Guid.ToString().ToUpper()))
{
fileGenerator.Write(Template.Solution.NestedProjectItem);
}
}
}
fileGenerator.Write(Template.Solution.NestedProjectEnd);
}
fileGenerator.Write(Template.Solution.GlobalEnd);
// Write the solution file
updated = _builder.Context.WriteGeneratedFile(solution.GetType(), solutionFileInfo, fileGenerator.ToMemoryStream());
solution.PostGenerationCallback?.Invoke(solutionPath, solutionFile, SolutionExtension);
return(solutionFileInfo.FullName);
}
public void CtorTest6()
{
var f = new SolutionFolder
(
"{EE7DD6B7-56F4-478D-8745-3D204D915473}", "MyFolder1",
new RawText[] { ".gnt\\gnt.core" }
);
Assert.Equal
(
new SolutionFolder()
{
header = new ProjectItem()
{
name = "MyFolder1",
EpType = ProjectType.SlnFolder,
pType = "{2150E333-8FDC-42A3-9474-1A3956D46DE8}",
pGuid = "{EE7DD6B7-56F4-478D-8745-3D204D915473}",
path = f.header.path,
fullPath = f.header.fullPath,
},
items = new List <RawText>()
{
".gnt\\gnt.core"
}
},
f
);
Assert.Single(f.items);
Assert.Equal((RawText)".gnt\\gnt.core", f.items.ElementAt(0));
f = new SolutionFolder("{EE7DD6B7-56F4-478D-8745-3D204D915473}", "MyFolder1", new RawText[] { });
Assert.Equal
(
new SolutionFolder()
{
header = new ProjectItem()
{
name = "MyFolder1",
EpType = ProjectType.SlnFolder,
pType = "{2150E333-8FDC-42A3-9474-1A3956D46DE8}",
pGuid = "{EE7DD6B7-56F4-478D-8745-3D204D915473}",
path = f.header.path,
fullPath = f.header.fullPath,
},
items = new List <RawText>()
{
}
},
f
);
Assert.Empty(f.items);
f = new SolutionFolder
(
"{EE7DD6B7-56F4-478D-8745-3D204D915473}", "MyFolder1",
(new RawText[] { ".gnt\\gnt.core" }).AsEnumerable()
);
Assert.Equal
(
new SolutionFolder()
{
header = new ProjectItem()
{
name = "MyFolder1",
EpType = ProjectType.SlnFolder,
pType = "{2150E333-8FDC-42A3-9474-1A3956D46DE8}",
pGuid = "{EE7DD6B7-56F4-478D-8745-3D204D915473}",
path = f.header.path,
fullPath = f.header.fullPath,
},
items = new List <RawText>()
{
".gnt\\gnt.core"
}
},
f
);
Assert.Single(f.items);
Assert.Equal((RawText)".gnt\\gnt.core", f.items.ElementAt(0));
}
public void ApplyFeature(SolutionFolder parentCombine, SolutionItem entry, Widget editor)
{
((GettextFeatureWidget)editor).ApplyFeature(parentCombine, entry);
}
public void CtorTest5()
{
var f = new SolutionFolder(
"{EE7DD6B7-56F4-478D-8745-3D204D915473}", "MyFolder1",
new RawText[] { ".gnt\\gnt.core", ".gnt\\packages.config" }
);
Assert.Equal
(
new SolutionFolder()
{
header = new ProjectItem()
{
name = "MyFolder1",
EpType = ProjectType.SlnFolder,
pType = "{2150E333-8FDC-42A3-9474-1A3956D46DE8}",
pGuid = "{EE7DD6B7-56F4-478D-8745-3D204D915473}",
path = f.header.path,
fullPath = f.header.fullPath,
},
items = new List <RawText>()
{
".gnt\\gnt.core", ".gnt\\packages.config"
}
},
f
);
Assert.Equal(2, f.items.Count());
Assert.Equal((RawText)".gnt\\gnt.core", f.items.ElementAt(0));
Assert.Equal((RawText)".gnt\\packages.config", f.items.ElementAt(1));
var f0 = new SolutionFolder();
f = new SolutionFolder
(
"{EE7DD6B7-56F4-478D-8745-3D204D915473}",
"MyFolder1",
f0,
".gnt\\gnt.core", ".gnt\\packages.config"
);
Assert.Equal
(
new SolutionFolder()
{
header = new ProjectItem()
{
name = "MyFolder1",
EpType = ProjectType.SlnFolder,
pType = "{2150E333-8FDC-42A3-9474-1A3956D46DE8}",
pGuid = "{EE7DD6B7-56F4-478D-8745-3D204D915473}",
path = f.header.path,
parent = f0,
fullPath = f.header.fullPath,
},
items = new List <RawText>()
{
".gnt\\gnt.core", ".gnt\\packages.config"
}
},
f
);
Assert.Equal(2, f.items.Count());
Assert.Equal((RawText)".gnt\\gnt.core", f.items.ElementAt(0));
Assert.Equal((RawText)".gnt\\packages.config", f.items.ElementAt(1));
}
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> ();
var solDirectory = Path.GetDirectoryName(sol.FileName);
foreach (SlnProject sec in sln.Projects)
{
// Valid guid?
if (!Guid.TryParse(sec.TypeGuid, out _))
{
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(solDirectory, f));
}
lock (items)
items.Add(projectGuid, sfolder);
monitor.Step(1);
continue;
}
if (projectPath.StartsWith("http://", StringComparison.Ordinal))
{
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(solDirectory, 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;
switch (e)
{
case UserException ex:
LoggingService.LogError("{0}: {1}", ex.Message, ex.Details);
monitor.ReportError(string.Format("{0}{1}{1}{2}", ex.Message, Environment.NewLine, ex.Details), null);
break;
case UnknownSolutionItemTypeException ux:
LoggingService.LogError("{0}: {1}", ux.Message, projectPath);
break;
default:
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));
break;
}
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);
}, TaskScheduler.Default);
loadTasks.Add(ft);
// Limit the number of concurrent tasks. Por solutions with many projects, spawning one thread per
// project makes the whole load process slower.
loadTasks.RemoveAll(t => t.IsCompleted);
if (loadTasks.Count > 4)
{
Task.WaitAny(loadTasks.ToArray());
}
}
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.", StringComparison.Ordinal))
{
int i = name.IndexOf('.');
LoadMonoDevelopConfigurationProperties(name.Substring(i + 1), e, sol, monitor);
}
}
monitor.EndTask();
}
public async Task <ProcessedTemplateResult> ProcessTemplate(SolutionTemplate template, NewProjectConfiguration config, SolutionFolder parentFolder)
{
var templateInfo = ((MicrosoftTemplateEngineSolutionTemplate)template).templateInfo;
var workspaceItems = new List <IWorkspaceFileObject> ();
var result = await templateCreator.InstantiateAsync(
templateInfo,
config.ProjectName,
config.GetValidProjectName(),
config.ProjectLocation,
new Dictionary <string, string> (),
true,
false);
if (result.ResultInfo.PrimaryOutputs.Any())
{
foreach (var res in result.ResultInfo.PrimaryOutputs)
{
var fullPath = Path.Combine(config.ProjectLocation, res.Path);
//This happens if some project is excluded by modifiers, e.g. Test project disabled in wizard settings by user
if (!File.Exists(fullPath))
{
continue;
}
workspaceItems.Add(await MonoDevelop.Projects.Services.ProjectService.ReadSolutionItem(new Core.ProgressMonitor(), fullPath));
}
}
else
{
//TODO: Remove this code once https://github.com/dotnet/templating/pull/342 is released in NuGet feed and we bump NuGet version of templating engine
foreach (var path in Directory.GetFiles(config.ProjectLocation, "*.*proj", SearchOption.AllDirectories))
{
if (path.EndsWith(".csproj", StringComparison.OrdinalIgnoreCase) || path.EndsWith(".fsproj", StringComparison.OrdinalIgnoreCase) || path.EndsWith(".vbproj", StringComparison.OrdinalIgnoreCase))
{
workspaceItems.Add(await MonoDevelop.Projects.Services.ProjectService.ReadSolutionItem(new Core.ProgressMonitor(), path));
}
}
}
var metadata = new Dictionary <string, string> ();
metadata ["Id"] = templateInfo.Identity;
metadata ["Name"] = templateInfo.Name;
metadata ["Language"] = template.Language;
metadata ["Platform"] = string.Join(";", templateInfo.Classifications);
TemplateCounter.Inc(1, null, metadata);
MicrosoftTemplateEngineProcessedTemplateResult processResult;
if (parentFolder == null)
{
var solution = new Solution();
solution.SetLocation(config.SolutionLocation, config.SolutionName);
foreach (var item in workspaceItems.Cast <SolutionFolderItem> ())
{
IConfigurationTarget configurationTarget = item as IConfigurationTarget;
if (configurationTarget != null)
{
foreach (ItemConfiguration configuration in configurationTarget.Configurations)
{
bool flag = false;
foreach (SolutionConfiguration solutionCollection in solution.Configurations)
{
if (solutionCollection.Id == configuration.Id)
{
flag = true;
}
}
if (!flag)
{
solution.AddConfiguration(configuration.Id, true);
}
}
}
solution.RootFolder.AddItem(item);
}
processResult = new MicrosoftTemplateEngineProcessedTemplateResult(new [] { solution }, solution.FileName, config.ProjectLocation);
}
else
{
processResult = new MicrosoftTemplateEngineProcessedTemplateResult(workspaceItems.ToArray(), parentFolder.ParentSolution.FileName, config.ProjectLocation);
}
// Format all source files generated during the project creation
foreach (var p in workspaceItems.OfType <Project> ())
{
foreach (var file in p.Files)
{
await FormatFile(p, file.FilePath);
}
}
return(processResult);
}
public override void ActivateMultipleItems()
{
SolutionFolder folder = CurrentNode.DataItem as SolutionFolder;
IdeApp.ProjectOperations.ShowOptions(folder);
}
public string Validate(SolutionFolder parentCombine, SolutionItem entry, Gtk.Widget editor)
{
return(null);
}
public SolutionItem CreateProject (SolutionFolder parentFolder)
{
string basePath = parentFolder != null ? parentFolder.BaseDirectory : null;
NewProjectDialog npdlg = new NewProjectDialog (parentFolder, false, basePath);
if (MessageService.ShowCustomDialog (npdlg) == (int)Gtk.ResponseType.Ok) {
var item = npdlg.NewItem as SolutionItem;
if ((item is Project) && ProjectCreated != null)
ProjectCreated (this, new ProjectCreatedEventArgs (item as Project));
return item;
}
return null;
}
public override bool HasChildNodes(ITreeBuilder builder, object dataObject)
{
SolutionFolder sf = (SolutionFolder)dataObject;
return(sf.Items.Count > 0 || sf.Files.Count > 0);
}
public SolutionItem AddSolutionItem (SolutionFolder folder, string entryFileName)
{
AddEntryEventArgs args = new AddEntryEventArgs (folder, entryFileName);
if (AddingEntryToCombine != null)
AddingEntryToCombine (this, args);
if (args.Cancel)
return null;
using (IProgressMonitor monitor = IdeApp.Workbench.ProgressMonitors.GetProjectLoadProgressMonitor (true)) {
return folder.AddItem (monitor, args.FileName, true);
}
}
public override object GetParentObject(object dataObject)
{
SolutionFolder sf = (SolutionFolder)dataObject;
return(sf.IsRoot || sf.ParentFolder.IsRoot ? (object)sf.ParentSolution : (object)sf.ParentFolder);
}
