public void CreateProject(string projectPath, string projectName)
{
IProjectTemplate projectTemplate = (
from template in this.serviceProvider.ProjectManager().TemplateManager.ProjectTemplates
where template.Identifier.Equals("Microsoft.Blend.WPFApplication")
select template).First <IProjectTemplate>();
IProject project = this.serviceProvider.ProjectManager().CreateProjectTemplate(projectPath, projectName, projectTemplate, null).FirstOrDefault <INamedProject>() as IProject;
if (project != null)
{
IDocumentType item = this.serviceProvider.DocumentTypes()[DocumentTypeNamesHelper.Xaml];
ICodeDocumentType codeDocumentType = this.serviceProvider.DocumentTypes().CSharpDocumentType();
List <DocumentCreationInfo> documentCreationInfos = new List <DocumentCreationInfo>();
DocumentCreationInfo documentCreationInfo = new DocumentCreationInfo()
{
DocumentType = item,
TargetPath = Path.Combine(project.ProjectRoot.Path, "TestUserControl.xaml")
};
documentCreationInfos.Add(documentCreationInfo);
DocumentCreationInfo documentCreationInfo1 = new DocumentCreationInfo()
{
DocumentType = codeDocumentType,
TargetPath = Path.Combine(project.ProjectRoot.Path, "TestUserControl.xaml.cs")
};
documentCreationInfos.Add(documentCreationInfo1);
project.AddItems(documentCreationInfos);
project.StartupItem.OpenView(true);
}
}
public void ReadProjectTemplate_ShouldReadProjectTemplate()
{
ITemplateRepository templateGeneratorWriter = new TemplateRepository();
var templateFile = new FileInfo(@"..\..\..\TestData\Templates\RazorClassLibrary\RazorClassLibrary.vstemplate".GetAppPath());
Assert.IsTrue(templateFile.Exists);
IProjectTemplate projectTemplate = templateGeneratorWriter.ReadProjectTemplate(templateFile.FullName);
Assert.AreEqual("RazorClassLibrary\\RazorClassLibrary1.csproj", projectTemplate.ProjectFileName);
Assert.AreEqual(templateFile.Name, projectTemplate.TemplateFileName);
Assert.AreEqual("RazorClassLibrary", projectTemplate.TemplateName);
Assert.AreEqual("<No description available>", projectTemplate.Description);
Assert.AreEqual("CSharp", projectTemplate.ProjectType);
Assert.AreEqual("C#", projectTemplate.LanguageTag);
Assert.AreEqual("", projectTemplate.PlatformTags);
Assert.AreEqual("", projectTemplate.ProjectTypeTags);
Assert.AreEqual("", projectTemplate.ProjectSubType);
Assert.AreEqual(1000, projectTemplate.SortOrder);
Assert.AreEqual(true, projectTemplate.CreateNewFolder);
Assert.AreEqual("RazorClassLibrary", projectTemplate.DefaultName);
Assert.AreEqual(true, projectTemplate.ProvideDefaultName);
Assert.AreEqual(LocationFieldType.Enabled, projectTemplate.LocationField);
Assert.AreEqual(true, projectTemplate.EnableLocationBrowseButton);
Assert.AreEqual(true, projectTemplate.CreateInPlace);
Assert.AreEqual("__TemplateIcon.ico", Path.GetFileName(projectTemplate.IconImagePath));
Assert.AreEqual(null, projectTemplate.PreviewImagePath);
Assert.AreEqual(false, projectTemplate.IsHidden);
Assert.AreEqual(null, projectTemplate.MaxFrameworkVersion);
Assert.AreEqual(null, projectTemplate.RequiredFrameworkVersion);
Assert.AreEqual(null, projectTemplate.FrameworkVersion);
}
/// <summary>
/// Creates a new project
/// </summary>
/// <param name="name">Name of project</param>
/// <param name="path">Path of project file</param>
public void CreateProject(string name, string path, IProjectTemplate template)
{
// If there is an opened project, close it
if (ActiveProject != null)
{
Close();
}
// Create project object
ActiveProject = template.CreateProject();
ActiveProject.Name = name;
ActiveProject.Path = path;
// Save to file
string directory = Path.GetDirectoryName(path);
if (!String.IsNullOrEmpty(directory))
{
Directory.CreateDirectory(Path.GetDirectoryName(path));
}
SaveActiveProject();
// Raise event
if (ActiveProjectChanged != null)
{
ActiveProjectChanged(this, new EventArgs());
}
}
private void WriteTemplateData(StreamWriter sw, IProjectTemplate template)
{
var iconExt = Path.GetExtension(template.IconImagePath);
var previewExt = Path.GetExtension(template.PreviewImagePath);
sw.WriteLine($" <Name>{template.TemplateName.XmlEncode()}</Name>");
sw.WriteLine($" <Description>{template.Description.XmlEncode()}</Description>");
sw.WriteLine($" <DefaultName>{template.DefaultName.XmlEncode()}</DefaultName>");
sw.WriteLine($" <ProjectType>{template.ProjectType ?? "CSharp"}</ProjectType>");
if (Is2019OrNewer)
{
if (!string.IsNullOrEmpty(template.ProjectSubType))
{
sw.WriteLine($" <ProjectSubType>{template.ProjectSubType.XmlEncode()}</ProjectSubType>");
}
if (!string.IsNullOrEmpty(template.LanguageTag) && !template.LanguageTag.Equals("None"))
{
sw.WriteLine($" <LanguageTag>{template.LanguageTag}</LanguageTag>");
}
foreach (var platformTag in template.PlatformTags.GetTags())
{
sw.WriteLine($" <PlatformTag>{platformTag.XmlEncode()}</PlatformTag>");
}
foreach (var projectTypeTag in template.ProjectTypeTags.GetTags())
{
sw.WriteLine($" <ProjectTypeTag>{projectTypeTag.XmlEncode()}</ProjectTypeTag>");
}
}
sw.WriteLine($" <CreateNewFolder>{template.CreateNewFolder.ToString().ToLower()}</CreateNewFolder>");
sw.WriteLine($" <LocationField>{template.LocationField}</LocationField>");
sw.WriteLine($" <EnableLocationBrowseButton>{template.EnableLocationBrowseButton.ToString().ToLower()}</EnableLocationBrowseButton>");
sw.WriteLine($" <SortOrder>{template.SortOrder}</SortOrder>");
sw.WriteLine($" <CreateInPlace>{template.CreateInPlace.ToString().ToLower()}</CreateInPlace>");
sw.WriteLine($" <ProvideDefaultName>{template.ProvideDefaultName.ToString().ToLower()}</ProvideDefaultName>");
if (!string.IsNullOrEmpty(iconExt))
{
sw.WriteLine($" <Icon>__TemplateIcon{iconExt}</Icon>");
}
if (!string.IsNullOrEmpty(previewExt))
{
sw.WriteLine($" <PreviewImage>__PreviewImage{previewExt}</PreviewImage>");
}
sw.WriteLine($" <Hidden>{template.IsHidden.ToString().ToLower()}</Hidden>");
if (!string.IsNullOrEmpty(template.MaxFrameworkVersion))
{
sw.WriteLine($" <MaxFrameworkVersion>{template.MaxFrameworkVersion}</MaxFrameworkVersion>");
}
if (!string.IsNullOrEmpty(template.RequiredFrameworkVersion))
{
sw.WriteLine($" <RequiredFrameworkVersion>{template.RequiredFrameworkVersion}</RequiredFrameworkVersion>");
}
if (!string.IsNullOrEmpty(template.FrameworkVersion))
{
sw.WriteLine($" <FrameworkVersion>{template.FrameworkVersion}</FrameworkVersion>");
}
}
// <UpdateLanguageList>b__8
private bool u003cUpdateLanguageListu003eb__8(IProjectTemplate template)
{
if (!this.projectTemplateCategorySelection.IsTemplateAvailable(template))
{
return(false);
}
return(this.ProjectTemplate.TemplateID.Equals(template.TemplateID, StringComparison.OrdinalIgnoreCase));
}
public void ReadSolutionTemplate_ShouldReadProjectTemplate()
{
ITemplateRepository templateGeneratorWriter = new TemplateRepository();
var templateFile = new FileInfo(TestHelper.TestSolutionTemplateFile);
Assert.IsTrue(templateFile.Exists);
IProjectTemplate solutionTemplate = templateGeneratorWriter.ReadSolutionTemplate(templateFile.FullName);
var allTemplates = solutionTemplate.Children.GetTemplatesFlattened();
Assert.AreEqual(17, allTemplates.Count);
}
public static void CopyTemplateIconsTo(this IProjectTemplate template, string destFolder)
{
//Copy icons
if (!string.IsNullOrEmpty(template.IconImagePath))
{
template.IconImagePath.CopyFileWithExt(Path.Combine(destFolder, "__TemplateIcon.ico"));
}
if (!string.IsNullOrEmpty(template.PreviewImagePath))
{
template.PreviewImagePath.CopyFileWithExt(Path.Combine(destFolder, "__PreviewImage.ico"));
}
}
internal static void AssertProjectTemplate(IProjectTemplate expected, IProjectTemplate actual)
{
var properties = typeof(IProjectTemplate).GetProperties();
foreach (var property in properties)
{
var expectedValue = property.GetValue(expected);
if (expectedValue is IList list)
{
continue;
}
var actualValue = property.GetValue(actual);
if (actualValue != null && (property.Name.Equals("IconImagePath") || property.Name.Equals("PreviewImagePath")))
{
actualValue = Path.GetExtension(actualValue.ToString());
if (expectedValue != null)
{
expectedValue = Path.GetExtension(expectedValue.ToString());
}
}
else if (actualValue != null && property.Name.Equals("ProjectFileName"))
{
actualValue = Path.GetFileName(actualValue.ToString());
expectedValue = Path.GetFileName(expectedValue.ToString());
}
if (property.PropertyType == typeof(string))
{
if (string.IsNullOrEmpty((string)expectedValue))
{
expectedValue = string.Empty;
}
if (string.IsNullOrEmpty((string)actualValue))
{
actualValue = string.Empty;
}
}
Assert.AreEqual(expectedValue, actualValue, $"Property {property.Name} is not equal");
}
Assert.AreEqual(expected.Children.Count, actual.Children.Count);
for (int i = 0; i < expected.Children.Count; i++)
{
var expectedItem = expected.Children[i];
var actualItem = actual.Children[i];
AssertProjectTemplate(expectedItem, actualItem);
}
}
private void ProjectTemplateListBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
IProjectTemplate item;
if (this.ProjectTemplate == null)
{
ICollectionView view = ((CollectionViewSource)this.OuterPanel.Resources["ProjectTemplateViewSource"]).View;
if (view != null && !view.IsEmpty && view.CurrentItem == null)
{
view.MoveCurrentToFirst();
return;
}
}
if (this.ProjectTemplate != null)
{
if (e == null || e.RemovedItems.Count <= 0)
{
item = null;
}
else
{
item = e.RemovedItems[0] as IProjectTemplate;
}
IProjectTemplate projectTemplate = item;
if (projectTemplate == null || this.ProjectName.StartsWith(projectTemplate.DefaultName, StringComparison.CurrentCulture))
{
if (!PathHelper.IsValidPath(this.ProjectPath))
{
this.ProjectName = this.ProjectTemplate.DefaultName;
}
else
{
string defaultName = this.ProjectTemplate.DefaultName;
string str = null;
string projectPath = this.ProjectPath;
this.ProjectName = PathHelper.GetAvailableFileOrDirectoryName(defaultName, str, projectPath, true);
}
this.Description = this.ProjectTemplate.Description;
}
}
if (this.ProjectTemplate != null)
{
this.UpdateStatus(LicensingHelper.GetLicenseGroup(this.ProjectTemplate));
}
this.OnPropertyChanged("CanCreateNewProject");
if (this.ProjectTemplate != null)
{
this.TargetFrameworkVersion = this.targetFrameworkTracker.GetValidSelectedItem(this.ProjectTemplate.ValidPropertyValues("TargetFrameworkVersion"), this.ProjectTemplate.PreferredPropertyValue("TargetFrameworkVersion"));
}
this.UpdateLanguageList();
}
public static ProjectTemplateModel ToModel(this IProjectTemplate item, ProjectTemplateModel parent)
{
var model = new ProjectTemplateModel(item.IsProject, parent, null);
item.CopyTemplateProperties(model);
foreach (var itemChild in item.Children)
{
model.Children.Add(itemChild.ToModel(model));
}
model.SetItemImage();
return(model);
}
public List <IProjectTemplate> GetProjectTemplates(string solutionFile, IProjectTemplate solutionTemplate)
{
_logger.Debug($"{nameof(GetProjectTemplates)} started");
var solutionFileItems = GetSolutionFileItems(solutionFile);
var projectItems = new List <IProjectTemplate>();
foreach (var solutionItem in solutionFileItems)
{
projectItems.Add(
ReadProjectTemplate(Path.GetDirectoryName(solutionFile), solutionItem, solutionTemplate));
}
_logger.Debug($"{nameof(GetProjectTemplates)}: {projectItems.Count} project templates found");
return(projectItems);
}
public void CreateProjectTemplate(IProjectTemplate template, string solutionFolder, string destFolder, bool copyFiles, CancellationToken ct)
{
if (template.IsProject)
{
var projectTemplateFile = new FileInfo(template.GetTemplateFileName(destFolder));
if (!projectTemplateFile.Directory.Exists)
{
projectTemplateFile.Directory.Create();
}
//Copy icons
template.CopyTemplateIconsTo(projectTemplateFile.DirectoryName);
ct.ThrowIfCancellationRequested();
var projectFile = new FileInfo(Path.Combine(solutionFolder, template.ProjectFileName));
var projectFolder = projectFile.Directory.FullName;
using var sw = new StreamWriter(projectTemplateFile.Create());
sw.WriteLine($"<VSTemplate Version=\"{VSTemplateVersion}\" xmlns=\"http://schemas.microsoft.com/developer/vstemplate/2005\" Type=\"Project\">");
sw.WriteLine(" <TemplateData>");
WriteTemplateData(sw, template);
sw.WriteLine(" </TemplateData>");
sw.WriteLine(" <TemplateContent>");
sw.WriteLine($" <Project TargetFileName=\"{projectFile.Name}\" File=\"{projectFile.Name}\" ReplaceParameters=\"true\">");
var blackList = new List <string> {
"bin", "obj", "TestResults", ".*", projectTemplateFile.Name, template.TemplateName + ".zip"
};
WriteFileSystemInfo(sw, projectFile.Directory.FullName, 6, blackList, ct);
if (copyFiles)
{
projectFolder.CopyDirectory(Path.Combine(destFolder, template.TemplateName), blackList, ct);
}
sw.WriteLine(" </Project>");
sw.WriteLine(" </TemplateContent>");
sw.WriteLine("</VSTemplate>");
}
foreach (var child in template.Children)
{
CreateProjectTemplate(child, solutionFolder, destFolder, copyFiles, ct);
}
}
public void Initialize()
{
string testDirectory = Path.Combine(TestContext.DeploymentDirectory, TestContext.TestName);
Directory.CreateDirectory(testDirectory);
Directory.SetCurrentDirectory(testDirectory);
// Set up project manager
ProjectManager = new ProjectManager();
// Set up project template
ProjectTemplate = new TestTemplate();
ProjectManager.RegisterProjectTemplate(ProjectTemplate);
OnInitialize();
}
public static void ReadTemplateData(XmlDocument xmlDoc, IProjectTemplate template, string templateFilePath)
{
var templateDataNodes = xmlDoc.DocumentElement.GetElementsByTagName("TemplateData");
if (templateDataNodes.Count == 0)
{
throw new InvalidDataException($"Template file does not contain TemplateData tag: {templateFilePath}.");
}
var nodes = templateDataNodes.Item(0).ChildNodes.Cast <XmlNode>().ToList();
if (nodes.Count == 0)
{
throw new InvalidDataException($"Template file does not contain TemplateData nodes: {templateFilePath}.");
}
template.SetPropertiesFromNodes(nodes);
template.TemplateName = nodes.FirstOrDefault(x => x.Name.Equals("Name"))?.InnerText;
var iconPath = nodes.FirstOrDefault(x => x.Name.Equals("Icon"))?.InnerText;
if (!string.IsNullOrEmpty(iconPath))
{
template.IconImagePath = Path.Combine(Path.GetDirectoryName(templateFilePath), iconPath);
}
iconPath = nodes.FirstOrDefault(x => x.Name.Equals("PreviewImage"))?.InnerText;
if (!string.IsNullOrEmpty(iconPath))
{
template.PreviewImagePath = Path.Combine(Path.GetDirectoryName(templateFilePath), iconPath);
}
template.IsHidden = nodes.FirstOrDefault(x => x.Name.Equals("Hidden"))?.InnerText.ToBool() ?? false;
if (!Enum.TryParse(nodes.FirstOrDefault(x => x.Name.Equals("LocationField"))?.InnerText, true, out LocationFieldType locationField))
{
locationField = LocationFieldType.Enabled;
}
template.LocationField = locationField;
//Tags
var platformTags = nodes.Where(x => x.Name.Equals("PlatformTag")).Select(x => x.InnerText).ToList();
template.PlatformTags = string.Join(",", platformTags);
var projectTypeTags = nodes.Where(x => x.Name.Equals("ProjectTypeTag")).Select(x => x.InnerText).ToList();
template.ProjectTypeTags = string.Join(",", projectTypeTags);
}
public void CreateProjectTemplate_ShouldBeSame()
{
ITemplateRepository templateGeneratorWriter = new TemplateRepository();
var templateFile = new FileInfo(@"..\..\..\TestData\Templates\RazorClassLibrary\RazorClassLibrary.vstemplate".GetAppPath());
Assert.IsTrue(templateFile.Exists);
IProjectTemplate projectTemplate = templateGeneratorWriter.ReadProjectTemplate(templateFile.FullName);
templateGeneratorWriter.CreateProjectTemplate(projectTemplate, templateFile.Directory.Parent.FullName, _outputDir, false, CancellationToken.None);
var generatedTemplateFile = new FileInfo(projectTemplate.GetTemplateFileName(_outputDir));
IProjectTemplate projectTemplateWritten = templateGeneratorWriter.ReadProjectTemplate(generatedTemplateFile.FullName);
TestHelper.AssertProjectTemplate(projectTemplate, projectTemplateWritten);
}
private void OpenExistingSample(string path, IProjectTemplate sampleTemplate, IProjectManager projectManager)
{
try
{
this.dialogWindow.Opacity = 0.0;
UIThreadDispatcher.Instance.DoEvents();
if (!sampleTemplate.HasProjectFile)
{
if (projectManager.OpenSolution(DocumentReference.Create(path), false, true) == null)
{
return;
}
this.dialogWindow.Close();
}
else
{
string projectFilename = sampleTemplate.ProjectFilename;
string path1 = (string)null;
if (!string.IsNullOrEmpty(projectFilename))
{
string[] strArray = (string[])null;
try
{
strArray = Directory.GetFiles(path, projectFilename, SearchOption.AllDirectories);
}
catch (DirectoryNotFoundException ex)
{
}
if (strArray != null && strArray.Length != 0)
{
path1 = strArray[0];
}
}
if (string.IsNullOrEmpty(path1) || !Microsoft.Expression.Framework.Documents.PathHelper.FileExists(path1) || projectManager.OpenSolution(DocumentReference.Create(path1), false, true) == null)
{
return;
}
this.dialogWindow.Close();
}
}
finally
{
this.dialogWindow.Opacity = 1.0;
}
}
public static ProjectLicenseGroup GetLicenseGroup(IProjectTemplate projectTemplate)
{
TemplateBase templateBase = projectTemplate as TemplateBase;
if (templateBase != null)
{
VSTemplateTemplateData templateData = templateBase.Template.TemplateData;
if (templateData.ExpressionBlendPrototypingEnabled)
{
return(ProjectLicenseGroup.SketchFlow);
}
if (templateData.TemplateID != null && templateData.TemplateID.StartsWith("Microsoft.Blend.WindowsPhone.", StringComparison.Ordinal))
{
return(ProjectLicenseGroup.SilverlightMobile);
}
}
return(ProjectLicenseGroup.WpfSilverlight);
}
public bool IsTemplateAvailable(IProjectTemplate template)
{
if (string.IsNullOrEmpty(template.TemplateGroupID) && base.Parent == null)
{
return(true);
}
if (!this.FullName.Equals(template.TemplateGroupID, StringComparison.OrdinalIgnoreCase) && !this.IsChildTemplateGroupID(template.TemplateGroupID))
{
return(false);
}
string templateGroupID = template.TemplateGroupID;
char[] separator = new char[] { ProjectTemplateCategoryTreeItem.Separator };
if ((int)templateGroupID.Split(separator).Length - base.Depth > template.NumberOfParentCategoriesToRollUp)
{
return(false);
}
return(true);
}
public bool IsTemplateShown(IProjectTemplate template, string projectType)
{
bool flag;
if (!this.IsTemplateAvailable(template))
{
return(false);
}
IProjectTemplate projectTemplate = null;
bool flag1 = false;
using (IEnumerator <IProjectTemplate> enumerator = this.creatableProjectTemplates.GetEnumerator())
{
while (enumerator.MoveNext())
{
IProjectTemplate current = enumerator.Current;
if (!template.TemplateID.Equals(current.TemplateID, StringComparison.OrdinalIgnoreCase) || !this.IsTemplateAvailable(current))
{
continue;
}
if (projectType != null && projectType.Equals(current.ProjectType, StringComparison.OrdinalIgnoreCase))
{
flag1 = true;
if (current == template)
{
flag = true;
return(flag);
}
}
if (projectTemplate != null)
{
continue;
}
projectTemplate = current;
}
if (!flag1 && projectTemplate != null && projectTemplate == template)
{
return(true);
}
return(false);
}
return(flag);
}
/// <summary>
/// Displays the 'create project' dialog and creates a new project
/// </summary>
public void CreateProject()
{
// Create dialog
var dialog = new CreateProjectDialog(this);
dialog.Owner = OwnerWindow;
// Display
bool?res = dialog.ShowDialog();
if (!res.HasValue || !res.Value)
{
return;
}
string selectedName = dialog.SelectedName;
string selectedPath = dialog.SelectedPath;
IProjectTemplate selectedTemplate = dialog.SelectedTemplate;
// Call manager
Manager.CreateProject(selectedName, selectedPath, selectedTemplate);
}
private void WriteProjectTemplateEntry(StreamWriter sw, IProjectTemplate template, string solutionDefaultName, int indent)
{
var padStart = "".PadLeft(indent, ' ');
if (template.IsProject)
{
var projectName = template.TemplateName.GetProjectName(solutionDefaultName);
var templateFileName = $"{template.TemplateName.GetSafePathName()}\\{template.TemplateFileName}";
sw.WriteLine($"{padStart}<ProjectTemplateLink ProjectName=\"{projectName}\">");
sw.WriteLine($"{padStart} {templateFileName}");
sw.WriteLine($"{padStart}</ProjectTemplateLink>");
}
else
{
sw.WriteLine($"{padStart}<SolutionFolder Name=\"{template.TemplateName}\">");
foreach (var child in template.Children)
{
WriteProjectTemplateEntry(sw, child, solutionDefaultName, indent + 2);
}
sw.WriteLine($"{padStart}</SolutionFolder>");
}
}
public void CreateSolutionTemplate(string solutionTemplateFile, IProjectTemplate solutionTemplate, IEnumerable <IProjectTemplate> projectTemplates)
{
using var sw = new StreamWriter(File.Open(solutionTemplateFile, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite));
sw.WriteLine($"<VSTemplate Version=\"{VSTemplateVersion}\" xmlns=\"http://schemas.microsoft.com/developer/vstemplate/2005\" Type=\"ProjectGroup\">");
sw.WriteLine(" <TemplateData>");
WriteTemplateData(sw, solutionTemplate);
sw.WriteLine(" </TemplateData>");
sw.WriteLine(" <TemplateContent>");
sw.WriteLine(" <ProjectCollection>");
var defaultSolutionName = string.IsNullOrWhiteSpace(solutionTemplate.DefaultName)
? solutionTemplate.TemplateName
: solutionTemplate.DefaultName;
foreach (var projectTemplate in projectTemplates)
{
WriteProjectTemplateEntry(sw, projectTemplate, defaultSolutionName, 6);
}
sw.WriteLine(" </ProjectCollection>");
sw.WriteLine(" </TemplateContent>");
sw.WriteLine("</VSTemplate>");
}
public IProjectTemplate FindActualTemplate(IProjectTemplate selectedTemplate, string projectType)
{
IProjectTemplate projectTemplate;
if (selectedTemplate == null)
{
return(null);
}
using (IEnumerator <IProjectTemplate> enumerator = this.creatableProjectTemplates.GetEnumerator())
{
while (enumerator.MoveNext())
{
IProjectTemplate current = enumerator.Current;
if (!this.IsTemplateAvailable(current) || !current.TemplateID.Equals(selectedTemplate.TemplateID, StringComparison.OrdinalIgnoreCase) || !current.TemplateID.Equals(selectedTemplate.TemplateID, StringComparison.OrdinalIgnoreCase) || (!string.IsNullOrEmpty(projectType) || !string.IsNullOrEmpty(current.ProjectType)) && (projectType == null || current.ProjectType == null || !projectType.Equals(current.ProjectType, StringComparison.OrdinalIgnoreCase)))
{
continue;
}
projectTemplate = current;
return(projectTemplate);
}
return(selectedTemplate);
}
return(projectTemplate);
}
private void InitializeProjectTemplates()
{
imageList1.Images.Clear();
// init default project templates
Font f = new Font(FontFamily.GenericSansSerif, 11, FontStyle.Regular);
for (int i = 0; i < GLOBALS.ProjectTemplates.Length; i++)
{
IProjectTemplate template = GLOBALS.ProjectTemplates[i];
ListViewItem lvi = new ListViewItem(template.DisplayText);
lvi.Tag = template;
lvi.Font = f;
if (template.TemplateIcon != null)
{
imageList1.Images.Add(template.DisplayText, template.TemplateIcon);
lvi.ImageKey = template.DisplayText;
}
lstProjTemplate.Items.Add(lvi);
}
}
public void GenerateSolutionTemplate_FromSolutionTemplate()
{
TemplateGeneratorService generator = new TemplateGeneratorService(new TemplateRepository(), _logger);
var templateFile = new FileInfo(TestHelper.TestSolutionTemplateFile);
Assert.IsTrue(templateFile.Exists);
IProjectTemplate solutionTemplate = generator.ReadSolutionTemplate(templateFile.FullName);
var templateOptions = new TemplateOptions
{
TargetFolder = _outputDir,
UseSolution = true,
SolutionTemplate = solutionTemplate,
ProjectTemplates = solutionTemplate.Children,
SolutionFolder = templateFile.DirectoryName
};
generator.GenerateTemplate(templateOptions, CancellationToken.None);
IProjectTemplate generatedTemplate = generator.ReadSolutionTemplate(templateOptions.TargetTemplatePath);
TestHelper.AssertProjectTemplate(solutionTemplate, generatedTemplate);
}
// <UpdateLanguageList>b__a
private static string u003cUpdateLanguageListu003eb__a(IProjectTemplate template)
{
return(template.ProjectType);
}
protected bool GetNewProjectData()
{
IProjectManager projectManager = this.ProjectManager();
CreateProjectDialog createProjectDialog = new CreateProjectDialog(projectManager.TemplateManager.ProjectTemplates, projectManager.TemplateManager, this.DisplayName, this.NewProjectPath, this.CreateNewSolution, base.Services)
{
IsCategoryTreeVisible = (bool)this.configurationObject.GetProperty(BaseNewProjectCommand.LastProjectCategoryTreeVisible, true),
SelectedCategoryFullName = (string)this.configurationObject.GetProperty(BaseNewProjectCommand.LastProjectCategoryTreeItem, "")
};
string property = (string)this.configurationObject.GetProperty(BaseNewProjectCommand.LastProjectLanguageCreated, "");
if (!string.IsNullOrEmpty(property))
{
createProjectDialog.Filter = property;
}
IProjectTemplate projectTemplate = projectManager.TemplateManager.ProjectTemplates.FirstOrDefault <IProjectTemplate>((IProjectTemplate template) => template.Identifier == (string)this.configurationObject.GetProperty(BaseNewProjectCommand.LastProjectTemplateCreated, ""));
if (projectTemplate == null)
{
createProjectDialog.ProjectTemplateListBox.Items.MoveCurrentToFirst();
}
else
{
createProjectDialog.ProjectTemplate = projectTemplate;
}
string str = (string)this.configurationObject.GetProperty(BaseNewProjectCommand.LastProjectTargetFrameworkCreated, "");
if (!string.IsNullOrEmpty(str))
{
createProjectDialog.TargetFrameworkVersion = ProjectPropertyInfo.CreatePropertyValue("TargetFrameworkVersion", str);
}
bool?nullable = createProjectDialog.ShowDialog();
this.configurationObject.SetProperty(BaseNewProjectCommand.LastProjectCategoryTreeVisible, createProjectDialog.IsCategoryTreeVisible);
this.configurationObject.SetProperty(BaseNewProjectCommand.LastProjectCategoryTreeItem, createProjectDialog.SelectedCategoryFullName);
if (!nullable.GetValueOrDefault(false))
{
return(false);
}
string str1 = null;
if (createProjectDialog.ProjectTemplate == null || createProjectDialog.ProjectTemplate.IsPlatformSupported(out str1))
{
this.projectTemplate = createProjectDialog.ProjectTemplate;
this.targetFrameworkVersion = createProjectDialog.TargetFrameworkVersion;
this.projectFolder = createProjectDialog.ProjectPath;
this.projectName = createProjectDialog.ProjectName;
this.projectFilter = createProjectDialog.Filter;
return(true);
}
MessageBoxArgs messageBoxArg = new MessageBoxArgs()
{
Message = str1,
Button = MessageBoxButton.OK,
Image = MessageBoxImage.Hand,
AutomationId = "UnknownProjectTypeErrorDialog"
};
MessageBoxArgs messageBoxArg1 = messageBoxArg;
base.Services.MessageDisplayService().ShowMessage(messageBoxArg1);
return(false);
}
private IProjectTemplate ReadProjectTemplate(string solutionFolder, SolutionProjectItem item, IProjectTemplate parent)
{
_logger.Debug($"{nameof(ReadProjectTemplate)} solutionFolder: {solutionFolder}");
return(_templateGenerator.ReadProjectTemplate(solutionFolder, item, parent));
}
/// <summary>
/// Registers a project template
/// </summary>
/// <param name="template">Project template</param>
public void RegisterProjectTemplate(IProjectTemplate template)
{
_projectTemplates.Add(template);
}
public static LicenseState ProjectLicense(IProjectTemplate template, IServiceProvider services)
{
return(LicensingHelper.ProjectTypeLicense(LicensingHelper.GetLicenseGroup(template), services));
}
