public void CreateEveryProjectTemplate ()
{
var builder = new StringBuilder ();
foreach (var template in ProjectTemplate.ProjectTemplates) {
if (template.Name.Contains ("Gtk#"))
continue;
try {
try { Directory.Delete (TempDir, true); } catch { }
var cinfo = new ProjectCreateInformation {
ProjectBasePath = TempDir,
ProjectName = "ProjectName",
SolutionName = "SolutionName",
SolutionPath = TempDir
};
template.CreateWorkspaceItem (cinfo);
} catch {
builder.AppendFormat ("Could not create a project from the template '{0} / {1}'", template.Category, template.Name);
builder.AppendLine ();
}
}
if (builder.Length > 0)
Assert.Fail (builder.ToString ());
}
/// <summary>
/// Initializes a new instance of the <see cref = "MonobjcProject" /> class.
/// </summary>
/// <param name = "language">The language.</param>
/// <param name = "info">The info.</param>
/// <param name = "projectOptions">The project options.</param>
public MonobjcProject (String language, ProjectCreateInformation info, XmlElement projectOptions) : base(language, info, projectOptions)
{
IDELogger.Log ("MonobjcProject::ctor3");
this.ApplicationType = GetNodeValue (projectOptions, "MacOSApplicationType", MonobjcProjectType.CocoaApplication);
this.ApplicationCategory = GetNodeValue (projectOptions, "MacOSApplicationCategory", String.Empty);
this.BundleId = GetNodeValue (projectOptions, "BundleId", "net.monobjc.application.Test");
this.BundleVersion = GetNodeValue (projectOptions, "BundleVersion", "1.0");
this.MainNibFile = GetNodeValue (projectOptions, "MainNibFile", null);
this.BundleIcon = GetNodeValue (projectOptions, "BundleIcon", null);
this.TargetOSVersion = GetNodeValue (projectOptions, "MacOSVersion", MacOSVersion.MacOS106);
this.Signing = Boolean.Parse (GetNodeValue (projectOptions, "Signing", "false"));
this.SigningIdentity = GetNodeValue (projectOptions, "SigningIdentity", String.Empty);
this.UseEntitlements = Boolean.Parse (GetNodeValue (projectOptions, "UseEntitlements", "false"));
this.OSFrameworks = GetNodeValue (projectOptions, "MacOSFrameworks", String.Empty);
this.TargetOSArch = GetNodeValue (projectOptions, "MacOSArch", MacOSArchitecture.X86);
this.EmbeddedFrameworks = GetNodeValue (projectOptions, "EmbeddedFrameworks", String.Empty);
this.AdditionalAssemblies = GetNodeValue (projectOptions, "AdditionalAssemblies", String.Empty);
this.ExcludedAssemblies = GetNodeValue (projectOptions, "ExcludedAssemblies", String.Empty);
this.AdditionalLibraries = GetNodeValue (projectOptions, "AdditionalLibraries", String.Empty);
this.Archive = Boolean.Parse (GetNodeValue (projectOptions, "Archive", "false"));
this.ArchiveIdentity = GetNodeValue (projectOptions, "ArchiveIdentity", String.Empty);
this.DevelopmentRegion = GetNodeValue (projectOptions, "MacOSDevelopmentRegion", "en");
this.CombineArtwork = Boolean.Parse (GetNodeValue (projectOptions, "CombineArtwork", "false"));
this.Initialize ();
}
public async Task CreatePackagingProjectFromTemplate ()
{
string templateId = "MonoDevelop.Packaging.Project";
var template = ProjectTemplate.ProjectTemplates.FirstOrDefault (t => t.Id == templateId);
var dir = Util.CreateTmpDir (template.Id);
var cinfo = new ProjectCreateInformation {
ProjectBasePath = dir,
ProjectName = "ProjectName",
SolutionName = "SolutionName",
SolutionPath = dir
};
var workspaceItem = template.CreateWorkspaceItem (cinfo);
string solutionFileName = Path.Combine (dir, "SolutionName.sln");
await workspaceItem.SaveAsync (solutionFileName, Util.GetMonitor ());
string projectFileName = Path.Combine (dir, "ProjectName.nuproj");
var project = await MSBuildProject.LoadAsync (projectFileName);
// First element is NuGet.Packaging.props
var import = project.GetAllObjects ().FirstOrDefault () as MSBuildImport;
Assert.AreEqual (import.Project, @"$(NuGetAuthoringPath)\NuGet.Packaging.Authoring.props");
// NuGet.Packaging.targets exists.
import = project.Imports.LastOrDefault () as MSBuildImport;
Assert.AreEqual (import.Project, @"$(NuGetAuthoringPath)\NuGet.Packaging.Authoring.targets");
int count = project.Imports.Count ();
import = project.Imports.Skip (count - 2).FirstOrDefault ();
Assert.AreEqual (import.Project, @"$(MSBuildBinPath)\Microsoft.Common.targets");
}
public Project CreateSingleFileProject (string sourceFile)
{
ProjectCreateInformation info = new ProjectCreateInformation ();
info.ProjectName = Path.GetFileNameWithoutExtension (sourceFile);
info.CombinePath = Path.GetDirectoryName (sourceFile);
info.ProjectBasePath = Path.GetDirectoryName (sourceFile);
string language = string.Empty;
switch (Path.GetExtension (sourceFile))
{
case ".c":
language = "C";
break;
case ".cpp":
language = "CPP";
break;
case ".cxx":
language = "CPP";
break;
}
if (language.Length > 0) {
Project project = new CProject (info, null, language);
project.ProjectFiles.Add (new ProjectFile (sourceFile));
return project;
}
return null;
}
public void CreateEveryProjectTemplate()
{
var builder = new StringBuilder ();
foreach (var template in ProjectTemplate.ProjectTemplates) {
if (template.Name.Contains ("Gtk#"))
continue;
try {
var dir = Util.CreateTmpDir (template.Id);
var cinfo = new ProjectCreateInformation {
ProjectBasePath = dir,
ProjectName = "ProjectName",
SolutionName = "SolutionName",
SolutionPath = dir
};
template.CreateWorkspaceItem (cinfo);
} catch (Exception ex) {
builder.AppendFormat (
"Could not create a project from the template '{0} / {1}': {2}",
template.Category, template.Name, ex
);
builder.AppendLine ();
builder.AppendLine ();
builder.AppendLine (ex.ToString ());
builder.AppendLine ();
}
}
if (builder.Length > 0)
Assert.Fail (builder.ToString ());
}
protected override void OnInitializeFromTemplate (ProjectCreateInformation projectCreateInfo, System.Xml.XmlElement template)
{
base.OnInitializeFromTemplate (projectCreateInfo, template);
// Support more options when creating a VB.NET project:
// 1) support adding vb imports
var assemblyProject = Project;
if (assemblyProject != null) {
var imports = template.GetAttribute ("VBImports");
if (imports != null) {
try {
var importType = Type.GetType ("MonoDevelop.VBNetBinding.Import, MonoDevelop.VBNetBinding");
if (importType != null) {
var importReferences = imports.Split (new [] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var elem in importReferences) {
// use reflection to avoid hard ref
var import = Activator.CreateInstance (importType, elem.Trim ());
assemblyProject.Items.Add ((ProjectItem)import);
}
}
} catch {
// ignore
}
}
}
}
public HaxeProject(ProjectCreateInformation info, XmlElement projectOptions)
: base()
{
if (projectOptions.Attributes ["TargetHXMLFile"] != null)
{
TargetHXMLFile = GetOptionAttribute (info, projectOptions, "TargetHXMLFile");
}
if (projectOptions.Attributes ["AdditionalArguments"] != null)
{
AdditionalArguments = GetOptionAttribute (info, projectOptions, "AdditionalArguments");
}
HaxeProjectConfiguration configuration;
configuration = (HaxeProjectConfiguration)CreateConfiguration ("Debug");
configuration.DebugMode = true;
//configuration.Platform = target;
Configurations.Add (configuration);
configuration = (HaxeProjectConfiguration)CreateConfiguration ("Release");
configuration.DebugMode = false;
//configuration.Platform = target;
Configurations.Add (configuration);
}
protected override string GetDefaultTargetPlatform (ProjectCreateInformation projectCreateInfo)
{
if (CompileTarget == CompileTarget.Library)
return string.Empty;
// Guess a good default platform for the project
if (projectCreateInfo.ParentFolder != null && projectCreateInfo.ParentFolder.ParentSolution != null) {
ItemConfiguration conf = projectCreateInfo.ParentFolder.ParentSolution.GetConfiguration (projectCreateInfo.ActiveConfiguration);
if (conf != null)
return conf.Platform;
else {
string curName, curPlatform, bestPlatform = null;
string sconf = projectCreateInfo.ActiveConfiguration.ToString ();
ItemConfiguration.ParseConfigurationId (sconf, out curName, out curPlatform);
foreach (ItemConfiguration ic in projectCreateInfo.ParentFolder.ParentSolution.Configurations) {
if (ic.Platform == curPlatform)
return curPlatform;
if (ic.Name == curName)
bestPlatform = ic.Platform;
}
if (bestPlatform != null)
return bestPlatform;
}
}
return Services.ProjectService.DefaultPlatformTarget;
}
public PythonProject (string languageName,
ProjectCreateInformation info,
XmlElement projectOptions)
{
PythonConfiguration defaultConfig;
string binPath;
if (!String.Equals (s_ProjectType, languageName)) {
throw new ArgumentException ("Not Python Project");
}
if (info != null) {
binPath = info.BinPath;
this.Name = info.ProjectName;
}
else {
binPath = ".";
}
// Setup our Debug configuration
defaultConfig = CreateConfiguration ("Debug") as PythonConfiguration;
this.Configurations.Add (defaultConfig);
// Setup our Release configuration
defaultConfig = CreateConfiguration ("Release") as PythonConfiguration;
defaultConfig.Optimize = true;
this.Configurations.Add (defaultConfig);
// Setup proper paths for all configurations
foreach (PythonConfiguration config in this.Configurations) {
config.OutputDirectory = Path.Combine (binPath, config.Name);
}
}
public RubyProject(ProjectCreateInformation info,
XmlElement projectOptions, string language)
{
if (info != null) {
Name = info.ProjectName;
}
Configurations.Add (CreateConfiguration ("Default"));
}
protected override void OnInitializeFromTemplate (ProjectCreateInformation projectCreateInfo, XmlElement template)
{
base.OnInitializeFromTemplate (projectCreateInfo, template);
if (template.GetAttribute ("HideGettingStarted")?.ToLower () == "true")
Project.UserProperties.SetValue ("HideGettingStarted", true);
else
showGettingStartedOnce = true;
}
public IodineProject(ProjectCreateInformation info, XmlElement projectOptions)
: this()
{
if (info != null) {
this.Name = info.ProjectName;
}
IodineConfiguration releaseConfig = CreateConfiguration ("Release") as IodineConfiguration;
Configurations.Add (releaseConfig);
}
public ProjectCreateInformation (ProjectCreateInformation projectCreateInformation)
{
projectName = projectCreateInformation.ProjectName;
solutionName = projectCreateInformation.SolutionName;
solutionPath = projectCreateInformation.SolutionPath;
projectBasePath = projectCreateInformation.ProjectBasePath;
ParentFolder = projectCreateInformation.ParentFolder;
ActiveConfiguration = projectCreateInformation.ActiveConfiguration;
}
public OpenFLProject(ProjectCreateInformation info, XmlElement projectOptions)
: base()
{
if (projectOptions.Attributes ["TargetProjectXMLFile"] != null)
{
TargetProjectXMLFile = GetOptionAttribute (info, projectOptions, "TargetProjectXMLFile");
}
if (projectOptions.Attributes ["AdditionalArguments"] != null)
{
AdditionalArguments = GetOptionAttribute (info, projectOptions, "AdditionalArguments");
}
OpenFLProjectConfiguration configuration;
string[] targets = new string[] { "Android", "BlackBerry", "Flash", "HTML5", "iOS", "Linux", "Mac", "webOS", "Windows" };
foreach (string target in targets)
{
configuration = (OpenFLProjectConfiguration)CreateConfiguration ("Debug");
configuration.DebugMode = true;
configuration.Platform = target;
if (target == "iOS")
{
configuration.AdditionalArguments = "-simulator";
}
Configurations.Add (configuration);
}
foreach (string target in targets)
{
configuration = (OpenFLProjectConfiguration)CreateConfiguration ("Release");
configuration.DebugMode = false;
configuration.Platform = target;
if (target == "iOS")
{
configuration.AdditionalArguments = "-simulator";
}
Configurations.Add (configuration);
}
}
public Project CreateSingleFileProject (string sourceFile)
{
ProjectCreateInformation info = new ProjectCreateInformation ();
info.ProjectName = Path.GetFileNameWithoutExtension (sourceFile);
info.SolutionPath = Path.GetDirectoryName (sourceFile);
info.ProjectBasePath = Path.GetDirectoryName (sourceFile);
PythonProject project = new PythonProject (m_Language, info, null);
project.Files.Add (new ProjectFile (sourceFile));
return project;
}
public MonoMacProject (string languageName, ProjectCreateInformation info, XmlElement projectOptions)
: base (languageName, info, projectOptions)
{
Init ();
/* TODO
var mainNibAtt = projectOptions.Attributes ["MainNibFile"];
if (mainNibAtt != null) {
this.mainNibFile = mainNibAtt.InnerText;
}
*/
}
public PythonProject (ProjectCreateInformation info, XmlElement projectOptions)
{
if (info != null) {
Name = info.ProjectName;
Configurations.Add (CreateConfiguration ("Debug"));
Configurations.Add (CreateConfiguration ("Release"));
foreach (PythonCompilerParameters parameter in Configurations) {
parameter.OutputDirectory = Path.Combine (info.BinPath, parameter.Name);
parameter.OutputAssembly = Name;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="GoldAddin.GoldProject"/> class.
/// </summary>
/// <remarks>this constructor is invoked when a new project is created in the IDE</remarks>
public GoldProject(ProjectCreateInformation info, XmlElement projectOptions)
{
init ();
//a project will not build unless at least 1 configuration is set
var config = (GoldProjectConfiguration)(CreateConfiguration ("Release"));
config.DebugMode = false;
config.OutputFormat = GrammarTableFormat.CompiledGrammarTable;
config.GrammarTableName = info.ProjectName;
config.OutputDirectory = info.BinPath;
Configurations.Add(config);
}
public CucumberProject(ProjectCreateInformation info,
XmlElement projectOptions)
{
if (info != null) {
Name = info.ProjectName;
}
CucumberProjectConfiguration configuration =
(CucumberProjectConfiguration)CreateConfiguration ("Default");
Configurations.Add (configuration);
}
public Project CreateSingleFileProject(string sourceFile)
{
var info = new ProjectCreateInformation () {
ProjectName = Path.GetFileNameWithoutExtension (sourceFile),
SolutionPath = Path.GetDirectoryName (sourceFile),
ProjectBasePath = Path.GetDirectoryName (sourceFile),
};
Project project = new CucumberProject (info, null);
project.Files.Add (new ProjectFile (sourceFile));
return project;
}
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 PythonProject(string languageName, ProjectCreateInformation info, XmlElement projectOptions)
{
if (!String.Equals (languageName, ProjectTypeName))
throw new ArgumentException ("Not an IronPython project: " + languageName);
if (info != null) {
Name = info.ProjectName;
}
CreateDefaultConfigurations ();
foreach (PythonConfiguration configuration in Configurations)
configuration.OutputDirectory = info.ProjectBasePath;
}
public Project CreateSingleFileProject (string file)
{
IDotNetLanguageBinding binding = LanguageBindingService.GetBindingPerFileName (file) as IDotNetLanguageBinding;
if (binding != null) {
ProjectCreateInformation info = new ProjectCreateInformation ();
info.ProjectName = Path.GetFileNameWithoutExtension (file);
info.SolutionPath = Path.GetDirectoryName (file);
info.ProjectBasePath = Path.GetDirectoryName (file);
Project project = CreateProject (binding.Language, info, null);
project.Files.Add (new ProjectFile (file));
return project;
}
return null;
}
public Project CreateSingleFileProject (string file)
{
//TODO: get page language
string language = "C#";
var info = new ProjectCreateInformation () {
ProjectName = Path.GetFileNameWithoutExtension (file),
SolutionPath = Path.GetDirectoryName (file),
ProjectBasePath = Path.GetDirectoryName (file),
};
var project = CreateProject (language, info, null);
project.Files.Add (new ProjectFile (file));
return project;
}
public Project CreateSingleFileProject(string sourceFile)
{
ProjectCreateInformation info = new ProjectCreateInformation();
info.ProjectName = Path.GetFileNameWithoutExtension(sourceFile);
//info.CombinePath = Path.GetDirectoryName(sourceFile);
info.SolutionPath = Path.GetDirectoryName(sourceFile);
info.ProjectBasePath = Path.GetDirectoryName(sourceFile);
Project project = null;
project = new HaxeProject(info, null, "Haxe");
project.Files.Add(new ProjectFile(sourceFile));
return project;
}
public Project CreateSingleFileProject(string sourceFile)
{
// Create project information using sourceFile's path
var info = new ProjectCreateInformation()
{
ProjectName = Path.GetFileNameWithoutExtension(sourceFile),
SolutionPath = Path.GetDirectoryName(sourceFile),
ProjectBasePath = Path.GetDirectoryName(sourceFile),
};
var prj = CreateProject(info, null);
prj.AddFile(sourceFile);
return prj;
}
public PHPProject(ProjectCreateInformation info, XmlElement projectOptions, string language)
{
if (info != null) {
Name = info.ProjectName;
}
ProjectConfiguration configuration = new ProjectConfiguration ();
configuration.Name = "Debug";
this.Configurations.Add (configuration);
configuration = new ProjectConfiguration();
configuration.Name = "Release";
this.Configurations.Add (configuration);
}
public MonobjcProject(string languageName, ProjectCreateInformation info, XmlElement projectOptions)
: base(languageName, info, projectOptions)
{
var tags = new [,] { { "ProjectName", info.ProjectName } };
bundleIdentifier = projectOptions.SelectSingleNode("BundleIdentifier").InnerText;
bundleIdentifier = StringParserService.Parse(bundleIdentifier, tags);
bundleDisplayName = projectOptions.SelectSingleNode("BundleDisplayName").InnerText;
bundleDisplayName = StringParserService.Parse(bundleDisplayName, tags);
bundleDevelopmentRegion = projectOptions.SelectSingleNode("BundleDevelopmentRegion").InnerText;
bundleVersion = projectOptions.SelectSingleNode("BundleVersion").InnerText;
}
public Project CreateProject (string language, ProjectCreateInformation info, XmlElement projectOptions)
{
XnaProject project = new XnaProject(language, info, projectOptions);
ProjectCreateInformation contentInfo = new ProjectCreateInformation();
contentInfo.SolutionName = info.SolutionName;
contentInfo.SolutionPath = info.SolutionPath;
contentInfo.ProjectBasePath = info.ProjectBasePath.Combine("Content");
contentInfo.ProjectName = "Content";
ContentProject contentProject = (ContentProject)Services.ProjectService.CreateProject("ContentProject", contentInfo, projectOptions);
FilePath includePath = FilePath.Empty.Combine("Content").Combine(contentProject.FileName);
NestedContentProject nestedContent = new NestedContentProject(contentProject, includePath);
project.NestedContentProjects.Add(nestedContent);
return project;
}
public TypeScriptProject(ProjectCreateInformation info, XmlElement projectOptions)
: this()
{
if (projectOptions.Attributes ["TargetJavaScriptFile"] != null)
TargetJavaScriptFile = GetOptionAttribute (info, projectOptions, "TargetJavaScriptFile");
if (projectOptions.Attributes ["AdditionalArguments"] != null)
AdditionalArguments = GetOptionAttribute (info, projectOptions, "AdditionalArguments");
TypeScriptProjectConfiguration configuration;
configuration = (TypeScriptProjectConfiguration) CreateConfiguration ("Debug");
configuration.DebugMode = true;
Configurations.Add (configuration);
configuration = (TypeScriptProjectConfiguration) CreateConfiguration ("Release");
configuration.DebugMode = false;
Configurations.Add (configuration);
}
public Project CreateProject(string typeAlias, ProjectCreateInformation info, XmlElement projectOptions, params string[] flavorGuids)
{
return(MSBuildProjectService.CreateProject(typeAlias, info, projectOptions, flavorGuids));
}
public Project CreateProject(ProjectCreateInformation info, XmlElement projectOptions)
{
string lang = projectOptions.GetAttribute("language");
return(CreateProject(lang, info, projectOptions));
}
public PortableDotNetProject(string languageName, ProjectCreateInformation projectCreateInfo, XmlElement projectOptions)
: base(languageName, projectCreateInfo, projectOptions)
{
}
protected virtual string GetDefaultTargetPlatform(ProjectCreateInformation projectCreateInfo)
{
return(string.Empty);
}
public DotNetProject(string languageName, ProjectCreateInformation projectCreateInfo, XmlElement projectOptions) : this(languageName)
{
if ((projectOptions != null) && (projectOptions.Attributes["Target"] != null))
{
CompileTarget = (CompileTarget)Enum.Parse(typeof(CompileTarget), projectOptions.Attributes["Target"].Value);
}
else if (IsLibraryBasedProjectType)
{
CompileTarget = CompileTarget.Library;
}
if (this.LanguageBinding != null)
{
LanguageParameters = languageBinding.CreateProjectParameters(projectOptions);
bool externalConsole = false;
string platform = null;
if (projectOptions != null)
{
projectOptions.SetAttribute("DefineDebug", "True");
if (!projectOptions.HasAttribute("Platform"))
{
// Clone the element since we are going to change it
platform = GetDefaultTargetPlatform(projectCreateInfo);
projectOptions = (XmlElement)projectOptions.CloneNode(true);
projectOptions.SetAttribute("Platform", platform);
}
else
{
platform = projectOptions.GetAttribute("Platform");
}
if (projectOptions.GetAttribute("ExternalConsole") == "True")
{
externalConsole = true;
}
}
string platformSuffix = string.IsNullOrEmpty(platform) ? string.Empty : "|" + platform;
DotNetProjectConfiguration configDebug = CreateConfiguration("Debug" + platformSuffix) as DotNetProjectConfiguration;
configDebug.CompilationParameters = languageBinding.CreateCompilationParameters(projectOptions);
configDebug.DebugMode = true;
configDebug.ExternalConsole = externalConsole;
configDebug.PauseConsoleOutput = externalConsole;
Configurations.Add(configDebug);
DotNetProjectConfiguration configRelease = CreateConfiguration("Release" + platformSuffix) as DotNetProjectConfiguration;
if (projectOptions != null)
{
projectOptions.SetAttribute("DefineDebug", "False");
}
configRelease.CompilationParameters = languageBinding.CreateCompilationParameters(projectOptions);
configRelease.DebugMode = false;
configRelease.ExternalConsole = externalConsole;
configRelease.PauseConsoleOutput = externalConsole;
Configurations.Add(configRelease);
}
if ((projectOptions != null) && (projectOptions.Attributes["TargetFrameworkVersion"] != null))
{
targetFrameworkVersion = projectOptions.Attributes["TargetFrameworkVersion"].Value;
}
string binPath;
if (projectCreateInfo != null)
{
Name = projectCreateInfo.ProjectName;
binPath = projectCreateInfo.BinPath;
defaultNamespace = SanitisePotentialNamespace(projectCreateInfo.ProjectName);
}
else
{
binPath = ".";
}
foreach (DotNetProjectConfiguration dotNetProjectConfig in Configurations)
{
dotNetProjectConfig.OutputDirectory = Path.Combine(binPath, dotNetProjectConfig.Name);
if ((projectOptions != null) && (projectOptions.Attributes["PauseConsoleOutput"] != null))
{
dotNetProjectConfig.PauseConsoleOutput = Boolean.Parse(projectOptions.Attributes["PauseConsoleOutput"].Value);
}
if (projectCreateInfo != null)
{
dotNetProjectConfig.OutputAssembly = projectCreateInfo.ProjectName;
}
}
}
public GenericProject(ProjectCreateInformation info, XmlElement projectOptions)
{
Configurations.Add(CreateConfiguration("Default"));
}
internal protected virtual void OnInitializeFromTemplate(ProjectCreateInformation projectCreateInfo, XmlElement template)
{
next.OnInitializeFromTemplate(projectCreateInfo, template);
}
public DotNetAssemblyProject(string languageName, ProjectCreateInformation projectCreateInfo, XmlElement projectOptions) :
base(languageName, projectCreateInfo, projectOptions)
{
}
public Project CreateProject(ProjectCreateInformation info, XmlElement projectOptions)
{
return(new GenericProject(info, projectOptions));
}
protected virtual DotNetProject CreateProject(string languageName, ProjectCreateInformation info, XmlElement projectOptions)
{
return(new DotNetAssemblyProject(languageName, info, projectOptions));
}
public bool CanCreateSolutionItem(string typeAlias, ProjectCreateInformation info, XmlElement projectOptions)
{
return(MSBuildProjectService.CanCreateSolutionItem(typeAlias, info, projectOptions));
}
internal protected virtual string OnGetDefaultTargetPlatform(ProjectCreateInformation projectCreateInfo)
{
return(next.OnGetDefaultTargetPlatform(projectCreateInfo));
}
protected override void OnInitializeFromTemplate(ProjectCreateInformation projectCreateInfo, XmlElement template)
{
Configurations.Add(CreateConfiguration("Default"));
}
