IProject CreateCSharpProject()
{
var createInfo = new ProjectCreateInformation();
createInfo.Solution = new Solution(new MockProjectChangeWatcher());
createInfo.OutputProjectFileName = @"d:\projects\MyProject\MyProject.csproj";
return new MSBuildBasedProject(createInfo);
}
public WixProject(ProjectCreateInformation info)
: base(info)
{
SetProperty("OutputType", "Package");
AddWixTargetsPathProperties();
AddImport(DefaultTargetsFile, null);
}
public NewProjectsCreated(
ProjectCreateInformation createInfo,
OpenMSBuildProjects openProjects)
{
this.createInfo = createInfo;
this.openProjects = openProjects;
}
public void SetUpFixture()
{
WixBindingTestsHelper.InitMSBuildEngine();
// create the project.
ProjectCreateInformation info = new ProjectCreateInformation();
info.Solution = new Solution();
info.ProjectName = "Test";
info.OutputProjectFileName = @"C:\Projects\Test\Test.wixproj";
wixProject = new WixProjectWithOverriddenSave(info);
// Add wix library item.
wixLibraryItem = new WixLibraryProjectItem(wixProject);
wixLibraryItem.Include = @"..\..\first.wixlib";
ProjectService.AddProjectItem(wixProject, wixLibraryItem);
// Run Initialize on the WixLibraryFolderNode, which is
// equivalent to expanding the node, so it adds it children. Cannot
// call ExtTreeNode.Expanding since this relies on the tree node
// being visible.
WixLibraryFolderNodeTester nodeTester = new WixLibraryFolderNodeTester(wixProject);
nodeTester.RunInitialize();
wixLibraryFolderNode = (WixLibraryFolderNode)nodeTester;
wixLibraryNode = (WixLibraryNode)wixLibraryFolderNode.Nodes[0];
}
public static MSBuildBasedProject CreateCSharpProject()
{
var createInfo = new ProjectCreateInformation();
createInfo.Solution = new Solution(MockRepository.GenerateStub<IProjectChangeWatcher>());
createInfo.OutputProjectFileName = @"d:\projects\MyProject\MyProject.csproj";
return new MSBuildBasedProject(createInfo);
}
protected override void OnInitializeFromTemplate (ProjectCreateInformation projectCreateInfo, XmlElement projectOptions)
{
base.OnInitializeFromTemplate (projectCreateInfo, projectOptions);
languageName = projectOptions.GetAttribute ("language");
string templateDefaultNamespace = GetDefaultNamespace (projectCreateInfo, projectOptions);
DefaultNamespace = templateDefaultNamespace ?? projectCreateInfo.ProjectName;
}
public static TestableProject CreateProject(string fileName, string projectName)
{
var createInfo = new ProjectCreateInformation();
createInfo.Solution = new Solution(null);
createInfo.ProjectName = projectName;
createInfo.OutputProjectFileName = fileName;
return new TestableProject(createInfo);
}
public static TestableProject CreateProject()
{
var info = new ProjectCreateInformation();
info.Solution = new Solution();
info.OutputProjectFileName = @"d:\projects\MyProject\MyProject.csproj";
info.ProjectName = "MyProject";
return new TestableProject(info);
}
void RunCommandWithProjectCreateInfoAsOwner(List<TestableProject> projects)
{
var createInfo = new ProjectCreateInformation(projects);
createInfo.Solution = projects[0].ParentSolution;
command.FakeProjectService.FakeOpenProjects.AddRange(projects);
RunCommandWithProjectCreateInfoAsOwner(createInfo);
}
public void SetUpFixture()
{
projectBinding = new RubyProjectBinding();
ProjectCreateInformation createInfo = new ProjectCreateInformation();
createInfo.ProjectName = "Ruby";
createInfo.OutputProjectFileName = @"C:\Projects\Ruby.rbproj";
createInfo.Solution = new Solution();
project = projectBinding.CreateProject(createInfo) as RubyProject;
}
public void IsTestProjectWhenPassedRubyPythonProjectReturnsTrue()
{
ProjectCreateInformation createInfo = new ProjectCreateInformation();
createInfo.Solution = new Solution(new MockProjectChangeWatcher());
createInfo.OutputProjectFileName = @"C:\projects\test.rbproj";
RubyProject project = new RubyProject(createInfo);
Assert.IsTrue(testFramework.IsTestProject(project));
}
public FSharpProject(ProjectCreateInformation info) : base(info)
{
try {
base.AddImport(@"$(MSBuildExtensionsPath32)\..\Microsoft F#\v4.0\Microsoft.FSharp.Targets", null);
base.ReevaluateIfNecessary(); // provoke exception if import is invalid
} catch (InvalidProjectFileException ex) {
throw new ProjectLoadException("Please ensure that the F# compiler is installed on your computer.\n\n" + ex.Message, ex);
}
}
protected override void Create(ProjectCreateInformation information)
{
base.Create(information);
SetProperty("Debug", null, "DefineConstants", "DEBUG;TRACE",
PropertyStorageLocations.ConfigurationSpecific, false);
SetProperty("Release", null, "DefineConstants", "TRACE",
PropertyStorageLocations.ConfigurationSpecific, false);
}
public void SetUpFixture()
{
projectBinding = new PythonProjectBinding();
ProjectCreateInformation createInfo = new ProjectCreateInformation();
createInfo.ProjectName = "Python";
createInfo.OutputProjectFileName = @"C:\Projects\Python.pyproj";
createInfo.Solution = new Solution(new MockProjectChangeWatcher());
project = projectBinding.CreateProject(createInfo) as PythonProject;
}
public void IsTestProjectReturnsTrueForPythonProject()
{
ProjectCreateInformation createInfo = new ProjectCreateInformation();
createInfo.Solution = new Solution();
createInfo.OutputProjectFileName = @"C:\projects\test.pyproj";
PythonProject project = new PythonProject(createInfo);
Assert.IsTrue(testFramework.IsTestProject(project));
}
public LSharpProject(ProjectCreateInformation info)
: base(info)
{
Init();
SetProperty("Debug", null, "DefineConstants", "DEBUG;TRACE",
PropertyStorageLocations.ConfigurationSpecific, false);
SetProperty("Release", null, "DefineConstants", "TRACE",
PropertyStorageLocations.ConfigurationSpecific, false);
}
public void SetUpFixture()
{
info = new ProjectCreateInformation();
info.Solution = new Solution(new MockProjectChangeWatcher());
info.ProjectName = "Test";
info.OutputProjectFileName = @"C:\Projects\Test\Test.rbproj";
info.RootNamespace = "Test";
project = new RubyProject(info);
}
protected override IProject CreateTestProject()
{
ProjectCreateInformation info = new ProjectCreateInformation();
info.ProjectName = "Test";
info.RootNamespace = "Test";
info.OutputProjectFileName = Path.Combine(Path.GetTempPath(), "Test.vbproj");
info.Solution = this.Solution;
VBNetProject p = new VBNetProject(info);
return p;
}
public void SetUpFixture()
{
WixBindingTestsHelper.InitMSBuildEngine();
info = new ProjectCreateInformation();
info.Solution = new Solution();
info.ProjectName = "Test";
info.OutputProjectFileName = @"C:\Projects\Test\Test.wixproj";
info.RootNamespace = "Test";
project = new WixProject(info);
}
public WixProject(ProjectCreateInformation info)
: base(info)
{
SetProperty("OutputType", "Package");
string wixToolPath = @"$(SharpDevelopBinPath)\Tools\Wix";
AddGuardedProperty("WixToolPath", wixToolPath);
AddGuardedProperty("WixTargetsPath", @"$(WixToolPath)\wix.targets");
AddGuardedProperty("WixTasksPath", @"$(WixToolPath)\WixTasks.dll");
this.AddImport(DefaultTargetsFile, null);
}
SnippetCompilerProject(ProjectCreateInformation createInfo)
: base(createInfo)
{
this.Parent = createInfo.Solution;
this.AddImport(DefaultTargetsFile, null);
SetProperty("Debug", null, "CheckForOverflowUnderflow", "True", PropertyStorageLocations.ConfigurationSpecific, true);
SetProperty("Release", null, "CheckForOverflowUnderflow", "False", PropertyStorageLocations.ConfigurationSpecific, true);
SetProperty("Debug", null, "DefineConstants", "DEBUG;TRACE", PropertyStorageLocations.ConfigurationSpecific, false);
SetProperty("Release", null, "DefineConstants", "TRACE", PropertyStorageLocations.ConfigurationSpecific, false);
}
public VBNetProject(ProjectCreateInformation info)
: base(info)
{
InitVB();
this.AddImport(DefaultTargetsFile, null);
SetProperty("Debug", null, "DefineConstants", "DEBUG=1,TRACE=1",
PropertyStorageLocations.ConfigurationSpecific, true);
SetProperty("Release", null, "DefineConstants", "TRACE=1",
PropertyStorageLocations.ConfigurationSpecific, true);
}
public void SetUpFixture()
{
PythonMSBuildEngineHelper.InitMSBuildEngine();
info = new ProjectCreateInformation();
info.Solution = new Solution();
info.ProjectName = "Test";
info.OutputProjectFileName = @"C:\Projects\Test\Test.pyproj";
info.RootNamespace = "Test";
project = new PythonProject(info);
}
public CppProject(ProjectCreateInformation info)
: base(info)
{
try {
AddImport(DefaultPropsFile, null);
AddImport(PropsFile, null);
AddImport(DefaultTargetsFile, null);
AddProjectConfigurationsItemGroup();
base.ReevaluateIfNecessary(); // provoke exception if import is invalid
} catch (InvalidProjectFileException ex) {
throw new ProjectLoadException("Please ensure that the Windows SDK is installed on your computer.\n\n" + ex.Message, ex);
}
}
/// <summary>
/// Creates a WixProject that contains no WixObject or WixLibrary items.
/// </summary>
public static WixProject CreateEmptyWixProject()
{
// Make sure the MSBuildEngine is initialised correctly.
InitMSBuildEngine();
// create the project.
ProjectCreateInformation info = new ProjectCreateInformation();
info.Solution = new Solution(new MockProjectChangeWatcher());
info.ProjectName = "Test";
info.OutputProjectFileName = @"C:\Projects\Test\Test.wixproj";
return new DummyWixProject(info);
}
public AimProject(ProjectCreateInformation info) : base(info)
{
// Inicializa a classe
Init();
// Adiciona os TargetsFile
AddImport(@"$(MSBuildBinPath)\Microsoft.CSharp.Targets", null);
// Inclui a referência ao iView durante a criação de um novo projeto
// Assembly aimAssembly = Assembly.GetAssembly(typeof(AimProject));
// string aimAssemblyPath = Path.GetDirectoryName(aimAssembly.Location);
// string aimAssemblyFullName = Path.Combine(aimAssemblyPath, "Aimirim.iView.dll");
// ReferenceProjectItem rpi = new ReferenceProjectItem(this, "Aimirim.iView");
// rpi.HintPath = aimAssemblyFullName;
// ProjectService.AddProjectItem(this, rpi);
}
protected virtual IProject CreateProject(DirectoryName targetProjectDirectory, IProject sourceProject)
{
ProjectBindingDescriptor descriptor = ProjectBindingService.GetCodonPerLanguageName(TargetLanguageName);
if (descriptor == null || descriptor.Binding == null)
throw new InvalidOperationException("Cannot get Language Binding for " + TargetLanguageName);
string projectName = sourceProject.Name + ".Converted";
FileName fileName = FileName.Create(Path.Combine(targetProjectDirectory, projectName + descriptor.ProjectFileExtension));
ProjectCreateInformation info = new ProjectCreateInformation(sourceProject.ParentSolution, fileName);
info.RootNamespace = sourceProject.RootNamespace;
return descriptor.Binding.CreateProject(info);
}
protected override void Create(ProjectCreateInformation information)
{
base.Create(information);
this.AddImport(DefaultTargetsFile, null);
SetProperty("Debug", null, "CheckForOverflowUnderflow", "True",
PropertyStorageLocations.ConfigurationSpecific, true);
SetProperty("Release", null, "CheckForOverflowUnderflow", "False",
PropertyStorageLocations.ConfigurationSpecific, true);
SetProperty("Debug", null, "DefineConstants", "DEBUG;TRACE",
PropertyStorageLocations.ConfigurationSpecific, false);
SetProperty("Release", null, "DefineConstants", "TRACE",
PropertyStorageLocations.ConfigurationSpecific, false);
}
public void SetUp()
{
PythonMSBuildEngineHelper.InitMSBuildEngine();
ProjectCreateInformation info = new ProjectCreateInformation();
info.Solution = new Solution(new MockProjectChangeWatcher());
info.ProjectName = "Test";
info.OutputProjectFileName = @"C:\Projects\Test\Test.pyproj";
info.RootNamespace = "Test";
project = new PythonProject(info);
appSettingsPanel = new DerivedApplicationSettingsPanel();
appSettingsPanel.Owner = project;
appSettingsPanel.LoadPanelContents();
}
public static TestableProject CreateTestProject(string name)
{
Solution solution = new Solution(new MockProjectChangeWatcher());
solution.FileName = @"d:\projects\Test\TestSolution.sln";
ProjectCreateInformation createInfo = new ProjectCreateInformation();
createInfo.Solution = solution;
createInfo.ProjectName = name;
createInfo.SolutionPath = @"d:\projects\Test";
createInfo.ProjectBasePath = @"d:\projects\Test\TestProject";
createInfo.OutputProjectFileName = @"d:\projects\Test\TestProject\TestProject.csproj";
var project = new TestableProject(createInfo);
project.Parent = solution;
return project;
}
public Task InitializeItem(SolutionFolderItem policyParent, ProjectCreateInformation projectCreateInformation, string defaultLanguage, SolutionItem item)
{
return(Task.CompletedTask);
}
public CProject(ProjectCreateInformation info,
XmlElement projectOptions, string language)
{
Init();
string binPath = ".";
if (info != null)
{
Name = info.ProjectName;
binPath = info.BinPath;
}
switch (language)
{
case "C":
this.language = Language.C;
break;
case "CPP":
this.language = Language.CPP;
break;
case "Objective C":
this.language = Language.OBJC;
break;
case "Objective C++":
this.language = Language.OBJCPP;
break;
}
Compiler = null; // use default compiler depending on language
CProjectConfiguration configuration =
(CProjectConfiguration)CreateConfiguration("Debug");
configuration.DefineSymbols = "DEBUG MONODEVELOP";
configuration.DebugMode = true;
Configurations.Add(configuration);
configuration =
(CProjectConfiguration)CreateConfiguration("Release");
configuration.DebugMode = false;
configuration.OptimizationLevel = 3;
configuration.DefineSymbols = "MONODEVELOP";
Configurations.Add(configuration);
foreach (CProjectConfiguration c in Configurations)
{
c.OutputDirectory = Path.Combine(binPath, c.Id);
c.SourceDirectory = info.ProjectBasePath;
c.Output = Name;
if (projectOptions != null)
{
if (projectOptions.Attributes["Target"] != null)
{
c.CompileTarget = (CBinding.CompileTarget)Enum.Parse(
typeof(CBinding.CompileTarget),
projectOptions.Attributes["Target"].InnerText);
}
if (projectOptions.GetAttribute("ExternalConsole") == "True")
{
c.ExternalConsole = true;
c.PauseConsoleOutput = true;
}
if (projectOptions.Attributes["PauseConsoleOutput"] != null)
{
c.PauseConsoleOutput = bool.Parse(
projectOptions.Attributes["PauseConsoleOutput"].InnerText);
}
if (projectOptions.Attributes["CompilerArgs"].InnerText != null)
{
c.ExtraCompilerArguments = projectOptions.Attributes["CompilerArgs"].InnerText;
}
if (projectOptions.Attributes["LinkerArgs"].InnerText != null)
{
c.ExtraLinkerArguments = projectOptions.Attributes["LinkerArgs"].InnerText;
}
}
}
}
public PythonProject(ProjectCreateInformation info)
: base(info)
{
AddImport(DefaultTargetsFile, null);
}
public void AddPackageReferenceForCreatedProject(Project project, ProjectDescriptor projectDescriptor, ProjectCreateInformation createInfo)
{
var packageReference = new PackageReferencesForCreatedProject(project.Name, projectDescriptor.GetPackageReferences(createInfo));
packageReferencesForCreatedProjects.Add(packageReference);
}
public AspMvcProject(string languageName, ProjectCreateInformation info, XmlElement projectOptions)
: base(languageName, info, projectOptions)
{
}
public DProject(ProjectCreateInformation info, XmlElement projectOptions)
{
referenceCollection = new DefaultDReferencesCollection(this);
Init();
string binPath = ".";
if (info != null)
{
Name = info.ProjectName;
BaseDirectory = info.ProjectBasePath;
if (info.BinPath != null)
{
binPath = info.BinPath;
}
}
var compTarget = DCompileTarget.Executable;
var outputPrefix = "";
if (projectOptions != null)
{
// Set project's target type to the one which has been defined in the project template
if (projectOptions.Attributes["Target"] != null)
{
compTarget = (DCompileTarget)Enum.Parse(
typeof(DCompileTarget),
projectOptions.Attributes["Target"].InnerText);
}
// Set project's compiler
if (projectOptions.Attributes["Compiler"] != null)
{
UsedCompilerVendor = projectOptions.Attributes["Compiler"].InnerText;
}
// Non Windows-OS require a 'lib' prefix as library name -- like libphobos2.a
if (compTarget == DCompileTarget.StaticLibrary || compTarget == DCompileTarget.SharedLibrary && !OS.IsWindows)
{
outputPrefix = "lib";
}
}
var libs = new List <string> ();
if (projectOptions != null)
{
foreach (XmlNode lib in projectOptions.GetElementsByTagName("Lib"))
{
if (!string.IsNullOrWhiteSpace(lib.InnerText))
{
libs.Add(lib.InnerText);
}
}
}
// Create a debug configuration
var cfg = CreateConfiguration("Debug") as DProjectConfiguration;
cfg.ExtraLibraries.AddRange(libs);
cfg.DebugMode = true;
Configurations.Add(cfg);
// Create a release configuration
cfg = CreateConfiguration("Release") as DProjectConfiguration;
cfg.ExtraLibraries.AddRange(libs);
cfg.DebugMode = false;
Configurations.Add(cfg);
// Create unittest configuration
var unittestConfig = CreateConfiguration("Unittest") as DProjectConfiguration;
unittestConfig.ExtraLibraries.AddRange(libs);
unittestConfig.DebugMode = true;
unittestConfig.UnittestMode = true;
Configurations.Add(unittestConfig);
// Prepare all configurations
foreach (DProjectConfiguration c in Configurations)
{
c.ExternalConsole = true;
c.CompileTarget = compTarget;
c.OutputDirectory = Path.Combine(this.GetRelativeChildPath(binPath), c.Id);
c.ObjectDirectory += Path.DirectorySeparatorChar + c.Id;
c.Output = outputPrefix + Name;
c.UpdateGlobalVersionIdentifiers();
if (projectOptions != null)
{
// Set extra compiler&linker args
if (projectOptions.Attributes ["CompilerArgs"].InnerText != null)
{
c.ExtraCompilerArguments += projectOptions.Attributes ["CompilerArgs"].InnerText;
}
if (projectOptions.Attributes ["LinkerArgs"].InnerText != null)
{
c.ExtraLinkerArguments += projectOptions.Attributes ["LinkerArgs"].InnerText;
}
if (projectOptions.GetAttribute("ExternalConsole") == "True")
{
c.ExternalConsole = true;
c.PauseConsoleOutput = true;
}
if (projectOptions.Attributes ["PauseConsoleOutput"] != null)
{
c.PauseConsoleOutput = bool.Parse(
projectOptions.Attributes ["PauseConsoleOutput"].InnerText);
}
}
}
}
static ProjectCreateInformation GetItemSpecificCreateInfo(ISolutionItemDescriptor descriptor, ProjectCreateInformation cInfo)
{
var entry = descriptor as ICustomProjectCIEntry;
if (entry != null)
{
return(entry.CreateProjectCI(cInfo));
}
return(cInfo);
}
static IEnumerable <ISolutionItemDescriptor> GetItemsToCreate(SolutionDescriptor solutionDescriptor, ProjectCreateInformation cInfo)
{
foreach (ISolutionItemDescriptor descriptor in solutionDescriptor.EntryDescriptors)
{
var projectDescriptor = descriptor as ProjectDescriptor;
if ((projectDescriptor != null) && !projectDescriptor.ShouldCreateProject(cInfo))
{
// Skip.
}
else
{
yield return(descriptor);
}
}
}
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);
itemCreateInfo.TemplateInitializationCallback = p => solutionItemDescriptor.InitializeItem(policyParent, itemCreateInfo, this.languagename, p);
SolutionItem solutionEntryItem = solutionItemDescriptor.CreateItem(itemCreateInfo, this.languagename);
if (solutionEntryItem != null)
{
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 async Task AddSharedProjectForPCLProject()
{
string templateId = "MonoDevelop.CSharp.PortableLibrary";
var template = ProjectTemplate.ProjectTemplates.FirstOrDefault(t => t.Id == templateId);
var dir = Util.CreateTmpDir("AddSharedProjectForPCLProject");
var cinfo = new ProjectCreateInformation {
ProjectBasePath = Path.Combine(dir, "MyProject"),
ProjectName = "MyProject",
SolutionName = "Solution",
SolutionPath = dir
};
var solution = await template.CreateWorkspaceItem(cinfo) as Solution;
string solutionFileName = Path.Combine(dir, "Solution.sln");
await solution.SaveAsync(solutionFileName, Util.GetMonitor());
var pclProject = solution.GetAllProjects().OfType <DotNetProject> ().First();
// Add NuGet package metadata to PCL project.
var metadata = new NuGetPackageMetadata();
metadata.Load(pclProject);
metadata.Id = "MyPackage";
metadata.Authors = "Authors";
metadata.Owners = "Owners";
metadata.Version = "1.2.3";
metadata.UpdateProject(pclProject);
// Add another csharp file to the pclProject in a subdirectory.
string anotherCSharpFileName = pclProject.BaseDirectory.Combine("src", "AnotherClass.cs");
Directory.CreateDirectory(Path.GetDirectoryName(anotherCSharpFileName));
File.WriteAllText(anotherCSharpFileName, "class AnotherClass {}");
pclProject.AddFile(anotherCSharpFileName);
await pclProject.SaveAsync(Util.GetMonitor());
// Add platform implementation.
var viewModel = new TestableAddPlatformImplementationViewModel(pclProject);
viewModel.CreateAndroidProject = true;
viewModel.CreateSharedProject = true;
viewModel.CreateIOSProject = true;
await viewModel.CreateProjects(Util.GetMonitor());
// Verify projects created as expected.
solution = (Solution)await Ide.Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solutionFileName);
pclProject = solution.GetAllProjects().OfType <DotNetProject> ().FirstOrDefault(p => p.Name == "MyProject");
// Solution contains Shared project.
var sharedProject = solution.GetAllProjects().OfType <SharedAssetsProject> ().FirstOrDefault(p => p.Name == "MyProject.Shared");
Assert.AreEqual("MyProject.Shared.shproj", sharedProject.FileName.FileName);
// PCL project references the Shared project.
var projectReference = pclProject.References.Single(r => r.ResolveProject(solution) == sharedProject);
Assert.IsNotNull(projectReference);
// Solution contains NuGet packaging project.
var nugetProject = solution.GetAllProjects().FirstOrDefault(p => p.Name == "MyProject.NuGet") as PackagingProject;
Assert.AreEqual("MyProject.NuGet.nuproj", nugetProject.FileName.FileName);
// NuGet packaging project references PCL project.
projectReference = nugetProject.References.Single(r => r.ResolveProject(solution) == pclProject);
Assert.IsNotNull(projectReference);
// Android project references shared project
var androidProject = solution.GetAllProjects().OfType <DotNetProject> ().FirstOrDefault(p => p.Name == "MyProject.Android");
projectReference = androidProject.References.Single(r => r.ResolveProject(solution) == sharedProject);
Assert.IsNotNull(projectReference);
// iOS project references shared project
var iosProject = solution.GetAllProjects().OfType <DotNetProject> ().FirstOrDefault(p => p.Name == "MyProject.iOS");
projectReference = iosProject.References.Single(r => r.ResolveProject(solution) == sharedProject);
Assert.IsNotNull(projectReference);
// NuGet packaging project contains metadata from PCL project.
metadata = nugetProject.GetPackageMetadata();
Assert.AreEqual("MyPackage", metadata.Id);
Assert.AreEqual("1.2.3", metadata.Version);
Assert.AreEqual("Authors", metadata.Authors);
Assert.AreEqual("Owners", metadata.Owners);
// NuGet packaging metadata is removed from PCL project.
metadata = new NuGetPackageMetadata();
metadata.Load(pclProject);
Assert.IsTrue(metadata.IsEmpty());
// PCL project should only have the assembly info file directly in the project.
Assert.IsTrue(pclProject.MSBuildProject.GetAllItems().Any(item => item.Include.Contains("AssemblyInfo.cs")));
Assert.IsFalse(pclProject.MSBuildProject.GetAllItems().Any(item => item.Include.Contains("MyClass.cs")));
Assert.IsFalse(pclProject.MSBuildProject.GetAllItems().Any(item => item.Include.Contains("AnotherClass.cs")));
string assemblyInfoFileName = pclProject.BaseDirectory.Combine("Properties", "AssemblyInfo.cs");
Assert.IsTrue(File.Exists(assemblyInfoFileName));
string csharpFileName = pclProject.BaseDirectory.Combine("MyClass.cs");
Assert.IsFalse(File.Exists(csharpFileName));
Assert.IsFalse(File.Exists(anotherCSharpFileName));
// Shared project should have files from PCL project.
string copiedCSharpFileName = sharedProject.BaseDirectory.Combine("MyClass.cs");
Assert.That(sharedProject.Files.Select(f => f.FilePath.ToString()), Contains.Item(copiedCSharpFileName));
Assert.IsTrue(File.Exists(copiedCSharpFileName));
string copiedAnotherCSharpFileName = sharedProject.BaseDirectory.Combine("src", "AnotherClass.cs");
Assert.That(sharedProject.Files.Select(f => f.FilePath.ToString()), Contains.Item(copiedAnotherCSharpFileName));
Assert.IsTrue(File.Exists(copiedAnotherCSharpFileName));
string copiedAssemblyInfoFileName = sharedProject.BaseDirectory.Combine("Properties", "AssemblyInfo.cs");
Assert.That(sharedProject.Files.Select(f => f.FilePath.ToString()), Has.No.Member(copiedAssemblyInfoFileName));
Assert.IsFalse(File.Exists(copiedAssemblyInfoFileName));
var expectedBaseDirectory = pclProject.BaseDirectory.ParentDirectory;
Assert.AreEqual(expectedBaseDirectory.Combine("MyProject.Android", "MyProject.Android.csproj"), androidProject.FileName);
Assert.AreEqual(expectedBaseDirectory.Combine("MyProject.iOS", "MyProject.iOS.csproj"), iosProject.FileName);
Assert.AreEqual(expectedBaseDirectory.Combine("MyProject.NuGet", "MyProject.NuGet.nuproj"), nugetProject.FileName);
Assert.AreEqual(expectedBaseDirectory.Combine("MyProject.Shared", "MyProject.Shared.shproj"), sharedProject.FileName);
// DefaultNamespace is the same for all projects.
Assert.AreEqual("MyProject", androidProject.DefaultNamespace);
Assert.AreEqual("MyProject", iosProject.DefaultNamespace);
Assert.AreEqual("MyProject", pclProject.DefaultNamespace);
Assert.AreEqual("MyProject", sharedProject.DefaultNamespace);
// OutputAssemblyName is the same for PCL, iOS and Android project.
Assert.IsTrue(androidProject.Configurations.OfType <DotNetProjectConfiguration> ().All(config => config.OutputAssembly == "MyProject"));
Assert.IsTrue(iosProject.Configurations.OfType <DotNetProjectConfiguration> ().All(config => config.OutputAssembly == "MyProject"));
Assert.IsTrue(pclProject.Configurations.OfType <DotNetProjectConfiguration> ().All(config => config.OutputAssembly == "MyProject"));
// iOS and Android project should have an AssemblyInfo file.
Assert.IsTrue(androidProject.MSBuildProject.GetAllItems().Any(item => item.Include.Contains("AssemblyInfo.cs")));
Assert.IsTrue(iosProject.MSBuildProject.GetAllItems().Any(item => item.Include.Contains("AssemblyInfo.cs")));
}
protected override void OnInitializeFromTemplate(ProjectCreateInformation projectCreateInfo, XmlElement projectOptions)
{
base.OnInitializeFromTemplate(projectCreateInfo, projectOptions);
languageName = projectOptions.GetAttribute("language");
DefaultNamespace = projectCreateInfo.ProjectName;
}
//Show prompt, create files from template, create project, execute command, save project
public bool CreateProject(ProjectTemplateResult templateResults, string defaultLanguage, ISolutionFolder target)
{
var projectCreateOptions = templateResults.Options;
var parentSolution = templateResults.Options.Solution;
IProject project = null;
bool success = false;
try
{
string language = string.IsNullOrEmpty(languageName) ? defaultLanguage : languageName;
ProjectBindingDescriptor descriptor = SD.ProjectService.ProjectBindings.FirstOrDefault(b => b.Language == language);
IProjectBinding languageinfo = (descriptor != null) ? descriptor.Binding : null;
if (languageinfo == null)
{
MessageService.ShowError(
StringParser.Parse("${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.CantCreateProjectWithTypeError}",
new StringTagPair("type", language)));
return(false);
}
DirectoryName projectBasePath = GetProjectBasePath(projectCreateOptions);
string newProjectName = StringParser.Parse(name, new StringTagPair("ProjectName", projectCreateOptions.ProjectName));
Directory.CreateDirectory(projectBasePath);
FileName projectLocation = projectBasePath.CombineFile(newProjectName + descriptor.ProjectFileExtension);
ProjectCreateInformation info = new ProjectCreateInformation(parentSolution, projectLocation);
info.TargetFramework = projectCreateOptions.TargetFramework;
StringBuilder standardNamespace = new StringBuilder();
// filter 'illegal' chars from standard namespace
if (!string.IsNullOrEmpty(newProjectName))
{
char ch = '.';
for (int i = 0; i < newProjectName.Length; ++i)
{
if (ch == '.')
{
// at beginning or after '.', only a letter or '_' is allowed
ch = newProjectName[i];
if (!Char.IsLetter(ch))
{
standardNamespace.Append('_');
}
else
{
standardNamespace.Append(ch);
}
}
else
{
ch = newProjectName[i];
// can only contain letters, digits or '_'
if (!Char.IsLetterOrDigit(ch) && ch != '.')
{
standardNamespace.Append('_');
}
else
{
standardNamespace.Append(ch);
}
}
}
}
info.TypeGuid = descriptor.TypeGuid;
info.RootNamespace = standardNamespace.ToString();
info.ProjectName = newProjectName;
if (!string.IsNullOrEmpty(defaultPlatform))
{
info.ActiveProjectConfiguration = new ConfigurationAndPlatform("Debug", defaultPlatform);
}
RunPreCreateActions(info);
StringParserPropertyContainer.FileCreation["StandardNamespace"] = info.RootNamespace;
if (File.Exists(projectLocation))
{
if (!MessageService.AskQuestion(
StringParser.Parse("${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.OverwriteProjectQuestion}",
new StringTagPair("projectLocation", projectLocation)),
"${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.OverwriteQuestion.InfoName}"))
{
return(false); //The user doesnt want to overwrite the project...
}
}
//Show prompt if any of the files exist
StringBuilder existingFileNames = new StringBuilder();
foreach (FileDescriptionTemplate file in files)
{
string fileName = Path.Combine(projectBasePath, StringParser.Parse(file.Name, new StringTagPair("ProjectName", info.ProjectName)));
if (File.Exists(fileName))
{
if (existingFileNames.Length > 0)
{
existingFileNames.Append(", ");
}
existingFileNames.Append(Path.GetFileName(fileName));
}
}
bool overwriteFiles = true;
if (existingFileNames.Length > 0)
{
if (!MessageService.AskQuestion(
StringParser.Parse("${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.OverwriteQuestion}",
new StringTagPair("fileNames", existingFileNames.ToString())),
"${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.OverwriteQuestion.InfoName}"))
{
overwriteFiles = false;
}
}
#region Copy files to target directory
foreach (FileDescriptionTemplate file in files)
{
string fileName = Path.Combine(projectBasePath, StringParser.Parse(file.Name, new StringTagPair("ProjectName", info.ProjectName)));
if (File.Exists(fileName) && !overwriteFiles)
{
continue;
}
try
{
if (!Directory.Exists(Path.GetDirectoryName(fileName)))
{
Directory.CreateDirectory(Path.GetDirectoryName(fileName));
}
if (!String.IsNullOrEmpty(file.BinaryFileName))
{
// Binary content
File.Copy(file.BinaryFileName, fileName, true);
}
else
{
// Textual content
StreamWriter sr = new StreamWriter(File.Create(fileName), SD.FileService.DefaultFileEncoding);
string fileContent = StringParser.Parse(file.Content,
new StringTagPair("ProjectName", projectCreateOptions.ProjectName),
new StringTagPair("SolutionName", projectCreateOptions.SolutionName),
new StringTagPair("FileName", fileName));
fileContent = StringParser.Parse(fileContent);
if (SD.EditorControlService.GlobalOptions.IndentationString != "\t")
{
fileContent = fileContent.Replace("\t", SD.EditorControlService.GlobalOptions.IndentationString);
}
sr.Write(fileContent);
sr.Close();
}
}
catch (Exception ex)
{
MessageService.ShowException(ex, "Exception writing " + fileName);
}
}
#endregion
// Create Project
info.InitializeTypeSystem = false;
project = languageinfo.CreateProject(info);
#region Create Project Items, Imports and Files
// Add Project items
if (!project.Items.IsReadOnly)
{
foreach (ProjectItem projectItem in projectItems)
{
ProjectItem newProjectItem = new UnknownProjectItem(
project,
StringParser.Parse(projectItem.ItemType.ItemName),
StringParser.Parse(projectItem.Include,
new StringTagPair("ProjectName", projectCreateOptions.ProjectName),
new StringTagPair("SolutionName", projectCreateOptions.SolutionName))
);
foreach (string metadataName in projectItem.MetadataNames)
{
string metadataValue = projectItem.GetMetadata(metadataName);
// if the input contains any special MSBuild sequences, don't escape the value
// we want to escape only when the special characters are introduced by the StringParser.Parse replacement
if (metadataValue.Contains("$(") || metadataValue.Contains("%"))
{
newProjectItem.SetMetadata(StringParser.Parse(metadataName), StringParser.Parse(metadataValue));
}
else
{
newProjectItem.SetEvaluatedMetadata(StringParser.Parse(metadataName), StringParser.Parse(metadataValue));
}
}
project.Items.Add(newProjectItem);
}
}
// Add properties from <PropertyGroup>
// This must be done before adding <Imports>, because the import path can refer to properties.
if (projectProperties.Count > 0)
{
if (!(project is MSBuildBasedProject))
{
throw new Exception("<PropertyGroup> may be only used in project templates for MSBuildBasedProjects");
}
foreach (ProjectProperty p in projectProperties)
{
((MSBuildBasedProject)project).SetProperty(
StringParser.Parse(p.Configuration),
StringParser.Parse(p.Platform),
StringParser.Parse(p.Name),
StringParser.Parse(p.Value),
p.Location,
p.ValueIsLiteral
);
}
}
// Add Imports
if (clearExistingImports || projectImports.Count > 0)
{
MSBuildBasedProject msbuildProject = project as MSBuildBasedProject;
if (msbuildProject == null)
{
throw new Exception("<Imports> may be only used in project templates for MSBuildBasedProjects");
}
try {
msbuildProject.PerformUpdateOnProjectFile(
delegate {
var projectFile = msbuildProject.MSBuildProjectFile;
if (clearExistingImports)
{
foreach (var import in projectFile.Imports.ToArray())
{
projectFile.RemoveChild(import);
}
}
foreach (Import projectImport in projectImports)
{
projectFile.AddImport(projectImport.Key).Condition = projectImport.Value;
}
});
} catch (InvalidProjectFileException ex) {
string message;
if (string.IsNullOrEmpty(importsFailureMessage))
{
message = "Error creating project:\n" + ex.Message;
}
else
{
message = importsFailureMessage + "\n\n" + ex.Message;
}
throw new ProjectLoadException(message, ex);
}
}
// Add Files
if (!project.Items.IsReadOnly)
{
foreach (FileDescriptionTemplate file in files)
{
string fileName = Path.Combine(projectBasePath, StringParser.Parse(file.Name, new StringTagPair("ProjectName", projectCreateOptions.ProjectName)));
FileProjectItem projectFile = new FileProjectItem(project, project.GetDefaultItemType(fileName));
projectFile.Include = FileUtility.GetRelativePath(project.Directory, fileName);
file.SetProjectItemProperties(projectFile);
project.Items.Add(projectFile);
}
}
#endregion
RunCreateActions(project);
project.ProjectCreationComplete();
// Save project
project.Save();
// HACK : close and reload
var fn = project.FileName;
project.Dispose();
ProjectLoadInformation loadInfo = new ProjectLoadInformation(parentSolution, fn, fn.GetFileNameWithoutExtension());
project = SD.ProjectService.LoadProject(loadInfo);
target.Items.Add(project);
project.ProjectLoaded();
SD.GetRequiredService <IProjectServiceRaiseEvents>().RaiseProjectCreated(new ProjectEventArgs(project));
templateResults.NewProjects.Add(project);
success = true;
return(true);
} finally {
if (project != null && !success)
{
project.Dispose();
}
}
}
public async Task AddAndroidProjectForPCLProject()
{
string templateId = "MonoDevelop.CSharp.PortableLibrary";
var template = ProjectTemplate.ProjectTemplates.FirstOrDefault(t => t.Id == templateId);
var dir = Util.CreateTmpDir("AddAndroidProjectForPCLProject");
var cinfo = new ProjectCreateInformation {
ProjectBasePath = Path.Combine(dir, "MyProject"),
ProjectName = "MyProject",
SolutionName = "Solution",
SolutionPath = dir
};
var solution = await template.CreateWorkspaceItem(cinfo) as Solution;
string solutionFileName = Path.Combine(dir, "Solution.sln");
await solution.SaveAsync(solutionFileName, Util.GetMonitor());
var pclProject = solution.GetAllProjects().OfType <DotNetProject> ().First();
// Add NuGet package metadata to PCL project.
var metadata = new NuGetPackageMetadata();
metadata.Load(pclProject);
metadata.Id = "MyPackage";
metadata.Authors = "Authors";
metadata.Owners = "Owners";
metadata.Version = "1.2.3";
metadata.UpdateProject(pclProject);
await pclProject.SaveAsync(Util.GetMonitor());
// Add platform implementation.
var viewModel = new TestableAddPlatformImplementationViewModel(pclProject);
viewModel.CreateAndroidProject = true;
viewModel.CreateSharedProject = false;
viewModel.CreateIOSProject = false;
await viewModel.CreateProjects(Util.GetMonitor());
// Verify projects created as expected.
solution = (Solution)await Ide.Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solutionFileName);
pclProject = solution.GetAllProjects().OfType <DotNetProject> ().FirstOrDefault(p => p.Name == "MyProject");
// Solution contains Android project.
var androidProject = solution.GetAllProjects().FirstOrDefault(p => p.Name == "MyProject.Android");
Assert.That(androidProject.GetTypeTags(), Contains.Item("MonoDroid"));
Assert.AreEqual("MyProject.Android.csproj", androidProject.FileName.FileName);
// Solution contains NuGet packaging project.
var nugetProject = solution.GetAllProjects().FirstOrDefault(p => p.Name == "MyProject.NuGet") as PackagingProject;
Assert.AreEqual("MonoDevelop.Packaging.PackagingProject", nugetProject.GetType().FullName);
Assert.AreEqual("MyProject.NuGet.nuproj", nugetProject.FileName.FileName);
// NuGet packaging project references Android project.
var androidProjectReference = nugetProject.References.Single(r => r.ResolveProject(solution) == androidProject);
Assert.IsNotNull(androidProjectReference);
// NuGet packaging project references PCL project.
var projectReference = nugetProject.References.Single(r => r.ResolveProject(solution) == pclProject);
Assert.IsNotNull(projectReference);
// NuGet packaging project contains metadata from PCL project.
metadata = nugetProject.GetPackageMetadata();
Assert.AreEqual("MyPackage", metadata.Id);
Assert.AreEqual("1.2.3", metadata.Version);
Assert.AreEqual("Authors", metadata.Authors);
Assert.AreEqual("Owners", metadata.Owners);
// NuGet packaging metadata is removed from PCL project.
metadata = new NuGetPackageMetadata();
metadata.Load(pclProject);
Assert.IsTrue(metadata.IsEmpty());
// Configurations created for Android and NuGet packaging project.
foreach (var config in solution.Configurations)
{
Assert.That(androidProject.GetConfigurations(), Contains.Item(config.Id));
Assert.That(nugetProject.GetConfigurations(), Contains.Item(config.Id));
}
// DefaultNamespace is the same for all projects.
Assert.AreEqual("MyProject", ((DotNetProject)androidProject).DefaultNamespace);
Assert.AreEqual("MyProject", ((DotNetProject)pclProject).DefaultNamespace);
}
public WixProjectWithOverriddenSave(ProjectCreateInformation info) : base(info)
{
}
bool CreateProject()
{
if (templateView.CurrentlySelected != null)
{
PropertyService.Set("Dialogs.NewProjectDialog.LastSelectedCategory", ((ProjectTemplate)templateView.CurrentlySelected).Category);
recentIds.Remove(templateView.CurrentlySelected.Id);
recentIds.Insert(0, templateView.CurrentlySelected.Id);
if (recentIds.Count > 15)
{
recentIds.RemoveAt(recentIds.Count - 1);
}
string strRecent = string.Join(",", recentIds.ToArray());
PropertyService.Set("Dialogs.NewProjectDialog.RecentTemplates", strRecent);
PropertyService.SaveProperties();
//PropertyService.Set("Dialogs.NewProjectDialog.LargeImages", ((RadioButton)ControlDictionary["largeIconsRadioButton"]).Checked);
}
string solution = txt_subdirectory.Text;
string name = txt_name.Text;
string location = ProjectLocation;
if (solution.Equals(""))
{
solution = name; //This was empty when adding after first combine
}
if (
!FileService.IsValidPath(solution) ||
!FileService.IsValidFileName(name) ||
name.IndexOf(' ') >= 0 ||
!FileService.IsValidPath(location))
{
MessageService.ShowError(GettextCatalog.GetString("Illegal project name.\nOnly use letters, digits, '.' or '_'."));
return(false);
}
if (parentFolder != null && parentFolder.ParentSolution.FindProjectByName(name) != null)
{
MessageService.ShowError(GettextCatalog.GetString("A Project with that name is already in your Project Space"));
return(false);
}
PropertyService.Set(
"MonoDevelop.Core.Gui.Dialogs.NewProjectDialog.AutoCreateProjectSubdir",
CreateSolutionDirectory);
if (templateView.CurrentlySelected == null || name.Length == 0)
{
return(false);
}
ProjectTemplate item = (ProjectTemplate)templateView.CurrentlySelected;
try {
System.IO.Directory.CreateDirectory(location);
} catch (IOException) {
MessageService.ShowError(GettextCatalog.GetString("Could not create directory {0}. File already exists.", location));
return(false);
} catch (UnauthorizedAccessException) {
MessageService.ShowError(GettextCatalog.GetString("You do not have permission to create to {0}", location));
return(false);
}
try {
ProjectCreateInformation cinfo = CreateProjectCreateInformation();
if (newSolution)
{
newItem = item.CreateWorkspaceItem(cinfo);
}
else
{
newItem = item.CreateProject(parentFolder, cinfo);
}
} catch (UserException ex) {
MessageService.ShowError(ex.Message, ex.Details);
return(false);
} catch (Exception ex) {
MessageService.ShowException(ex, GettextCatalog.GetString("The project could not be created"));
return(false);
}
selectedItem = item;
return(true);
}
void SavePackageReferences(SolutionItem solutionEntryItem, ISolutionItemDescriptor descriptor, ProjectCreateInformation cInfo)
{
if ((solutionEntryItem is Project) && (descriptor is ProjectDescriptor))
{
var projectPackageReferences = new PackageReferencesForCreatedProject(((Project)solutionEntryItem).Name, ((ProjectDescriptor)descriptor).GetPackageReferences(cInfo));
packageReferencesForCreatedProjects.Add(projectPackageReferences);
}
}
public Project CreateProject(ProjectCreateInformation info, XmlElement projectOptions)
{
string lang = projectOptions.GetAttribute("language");
return(CreateProject(lang, info, projectOptions));
}
public IProject CreateProject(ProjectCreateInformation info)
{
return(new BooProject(info));
}
public DummyWixProject(ProjectCreateInformation info) : base(info)
{
}
public Project CreateProject(ProjectCreateInformation info, System.Xml.XmlElement projectOptions)
{
return(new SharedAssetsProject(info, projectOptions));
}
public IProject CreateProject(ProjectCreateInformation info)
{
info.ActiveProjectConfiguration = new ConfigurationAndPlatform("Debug", "Win32");
return(new CppProject(info));
}
void CreateNewProjectsCreated(ProjectCreateInformation createInfo)
{
fakeProjectService = new FakePackageManagementProjectService();
newProjectsCreated = new NewProjectsCreated(createInfo, fakeProjectService);
}
public ValaProject(ProjectCreateInformation info,
XmlElement projectOptions, string language)
{
Init();
string binPath = ".";
if (info != null)
{
Name = info.ProjectName;
binPath = info.BinPath;
}
Compiler = null;
ValaProjectConfiguration configuration =
(ValaProjectConfiguration)CreateConfiguration("Debug");
configuration.DebugMode = true;
((ValaCompilationParameters)configuration.CompilationParameters).DefineSymbols = "DEBUG MONODEVELOP";
Configurations.Add(configuration);
configuration =
(ValaProjectConfiguration)CreateConfiguration("Release");
configuration.DebugMode = false;
((ValaCompilationParameters)configuration.CompilationParameters).OptimizationLevel = 3;
((ValaCompilationParameters)configuration.CompilationParameters).DefineSymbols = "MONODEVELOP";
Configurations.Add(configuration);
foreach (ValaProjectConfiguration c in Configurations)
{
c.OutputDirectory = Path.Combine(binPath, c.Name);
c.SourceDirectory = info.ProjectBasePath;
c.Output = Name;
ValaCompilationParameters parameters = c.CompilationParameters as ValaCompilationParameters;
if (projectOptions != null)
{
if (projectOptions.Attributes["Target"] != null)
{
c.CompileTarget = (ValaBinding.CompileTarget)Enum.Parse(
typeof(ValaBinding.CompileTarget),
projectOptions.Attributes["Target"].InnerText);
}
if (projectOptions.Attributes["PauseConsoleOutput"] != null)
{
c.PauseConsoleOutput = bool.Parse(
projectOptions.Attributes["PauseConsoleOutput"].InnerText);
}
if (projectOptions.Attributes["CompilerArgs"].InnerText != null)
{
if (parameters != null)
{
parameters.ExtraCompilerArguments = projectOptions.Attributes["CompilerArgs"].InnerText;
}
}
if (projectOptions.Attributes["Packages"].InnerText != null)
{
List <ProjectPackage> packs = new List <ProjectPackage>();
foreach (string pack in projectOptions.Attributes["Packages"].InnerText.Split('|'))
{
packs.Add(new ProjectPackage(
string.Format("{0}{1}{2}.vapi",
vapidir,
Path.DirectorySeparatorChar,
pack)));
}
packages.AddRange(packs);
}
}
}
}
public SmartQuantProject(string languageName, ProjectCreateInformation projectCreateInfo, XmlElement projectOptions) : base(languageName, projectCreateInfo, projectOptions)
{
}
public XobotProject(string language, ProjectCreateInformation info, XmlElement options)
: base(language, info, options)
{
Init();
}
void CreateProject()
{
if (categoryTreeView.SelectedNode != null)
{
PropertyService.Set("Dialogs.NewProjectDialog.LastSelectedCategory", TreeViewHelper.GetPath(categoryTreeView.SelectedNode));
PropertyService.Set("Dialogs.NewProjectDialog.CategoryTreeState", TreeViewHelper.GetViewStateString(categoryTreeView));
PropertyService.Set("Dialogs.NewProjectDialog.LargeImages", largeIconsRadioButton.Checked);
}
string solution = solutionNameTextBox.Text.Trim();
string name = nameTextBox.Text.Trim();
string location = locationTextBox.Text.Trim();
string projectNameError = CheckProjectName(solution, name, location);
if (projectNameError != null)
{
MessageService.ShowError(projectNameError);
return;
}
if (templateListView.SelectedItems.Count == 1 && locationTextBox.Text.Length > 0 && solutionNameTextBox.Text.Length > 0)
{
TemplateItem item = (TemplateItem)templateListView.SelectedItems[0];
try {
System.IO.Directory.CreateDirectory(NewProjectDirectory);
} catch (Exception) {
MessageService.ShowError("${res:ICSharpCode.SharpDevelop.Gui.Dialogs.NewProjectDialog.CantCreateDirectoryError}");
return;
}
ProjectCreateInformation cinfo = new ProjectCreateInformation();
if (!createNewSolution)
{
cinfo.Solution = ProjectService.OpenSolution;
cinfo.SolutionPath = Path.GetDirectoryName(cinfo.Solution.FileName);
cinfo.SolutionName = cinfo.Solution.Name;
}
else
{
cinfo.SolutionPath = NewSolutionDirectory;
}
if (item.Template.HasSupportedTargetFrameworks)
{
cinfo.TargetFramework = (TargetFramework)targetFrameworkComboBox.SelectedItem;
PropertyService.Set("Dialogs.NewProjectDialog.TargetFramework", cinfo.TargetFramework.Name);
}
cinfo.ProjectBasePath = NewProjectDirectory;
cinfo.SolutionName = solution;
cinfo.ProjectName = name;
NewSolutionLocation = item.Template.CreateProject(cinfo);
if (NewSolutionLocation == null || NewSolutionLocation.Length == 0)
{
return;
}
NewProjectLocation = cinfo.createdProjects.Count > 0 ? cinfo.createdProjects[0].FileName : "";
if (createNewSolution)
{
ProjectService.LoadSolution(NewSolutionLocation);
}
else
{
AddExistingProjectToSolution.AddProject(SolutionFolderNode, NewProjectLocation);
ProjectService.SaveSolution();
}
item.Template.RunOpenActions(cinfo);
DialogResult = DialogResult.OK;
}
}
public RubyProject(ProjectCreateInformation info)
: base(info)
{
base.MSBuildProjectFile.AddTarget("Build");
}
// icon view event handlers
void SelectedIndexChange(object sender, EventArgs e)
{
try {
btn_new.Sensitive = true;
txt_name.Sensitive = true;
txt_subdirectory.Sensitive = true;
chk_combine_directory.Sensitive = true;
entry_location.Sensitive = true;
if (templateView.CurrentlySelected != null)
{
ProjectTemplate ptemplate = (ProjectTemplate)templateView.CurrentlySelected;
lbl_template_descr.Text = StringParserService.Parse(ptemplate.Description);
labelTemplateTitle.Markup = "<b>" + GLib.Markup.EscapeText(ptemplate.Name) + "</b>";
if (ptemplate.SolutionDescriptor.EntryDescriptors.Length == 0)
{
txt_subdirectory.Sensitive = false;
chk_combine_directory.Sensitive = false;
lbl_subdirectory.Sensitive = false;
btn_new.Label = Gtk.Stock.Ok;
}
else
{
lbl_subdirectory.Sensitive = true;
txt_subdirectory.Text = txt_name.Text;
ProjectCreateInformation cinfo = CreateProjectCreateInformation();
if (ptemplate.HasItemFeatures(parentFolder, cinfo))
{
btn_new.Label = Gtk.Stock.GoForward;
}
else
{
btn_new.Label = Gtk.Stock.Ok;
}
}
}
else
{
lbl_template_descr.Text = String.Empty;
labelTemplateTitle.Text = "";
}
PathChanged(null, null);
btn_new.GrabDefault();
} catch (Exception ex) {
txt_name.Sensitive = false;
btn_new.Sensitive = false;
txt_subdirectory.Sensitive = false;
chk_combine_directory.Sensitive = false;
entry_location.Sensitive = false;
while (ex is TargetInvocationException)
{
ex = ((TargetInvocationException)ex).InnerException;
}
if (ex is UserException)
{
var user = (UserException)ex;
MessageService.ShowError(user.Message, user.Details);
}
else
{
MessageService.ShowException(ex);
};
}
}
public Project CreateProject(ProjectCreateInformation info, XmlElement projectOptions)
{
return(new PythonProject(Name, info, projectOptions));
}
public TestableProject(ProjectCreateInformation createInfo)
: base(createInfo)
{
}
