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)); }