Exemplo n.º 1
0
 public ProjectCreator(List <ProjectRequest> requests, ProjectTemplateInfo projectTemplate, IMessageBoxService messageBoxService)
 {
     _messageBoxService = messageBoxService;
     Requests           = requests;
     ProjectTemplate    = projectTemplate;
     SuccessfulRequests = new List <Tuple <ProjectRequest, FileBasedProject> >();
 }
Exemplo n.º 2
0
        public NewProjectDialog()
        {
            this.InitializeComponent();
            this.templateView_Resize(this, EventArgs.Empty);             // Trigger update tile size

            this.folderModel                     = new FolderBrowserTreeModel(EditorHelper.GlobalProjectTemplateDirectory);
            this.folderModel.Filter              = s => Directory.Exists(s); // Only show directories
            this.folderView.Model                = this.folderModel;
            this.folderViewControlName.DrawText += this.folderViewControlName_DrawText;

            this.selectedTemplatePath = this.folderModel.BasePath;

            // Create hardcoded templates
            this.templateEmpty             = new ProjectTemplateInfo();
            this.templateEmpty.Icon        = GeneralResCache.ImageTemplateEmpty;
            this.templateEmpty.Name        = GeneralRes.Template_Empty_Name;
            this.templateEmpty.Description = GeneralRes.Template_Empty_Desc;
            this.templateEmpty.SpecialTag  = ProjectTemplateInfo.SpecialInfo.Empty;

            this.templateCurrent             = new ProjectTemplateInfo();
            this.templateCurrent.Icon        = GeneralResCache.ImageTemplateCurrent;
            this.templateCurrent.Name        = GeneralRes.Template_Current_Name;
            this.templateCurrent.Description = GeneralRes.Template_Current_Desc;
            this.templateCurrent.SpecialTag  = ProjectTemplateInfo.SpecialInfo.Current;

            // Hilde folder selector, if empty
            if (!Directory.Exists(this.folderModel.BasePath) || Directory.GetDirectories(this.folderModel.BasePath).Length == 0)
            {
                this.folderView.Enabled = false;
                this.splitFolderTemplate.Panel1Collapsed = true;
            }

            this.UpdateTemplateList();
        }
Exemplo n.º 3
0
		public NewProjectDialog()
		{
			this.InitializeComponent();
			this.templateView_Resize(this, EventArgs.Empty); // Trigger update tile size

			this.folderModel = new FolderBrowserTreeModel(EditorHelper.GlobalProjectTemplateDirectory);
			this.folderModel.Filter = s => Directory.Exists(s); // Only show directories
			this.folderView.Model = this.folderModel;
			this.folderViewControlName.DrawText += this.folderViewControlName_DrawText;

			this.selectedTemplatePath = this.folderModel.BasePath;

			// Create hardcoded templates
			this.templateEmpty = new ProjectTemplateInfo();
			this.templateEmpty.Icon = EditorRes.GeneralResCache.ImageTemplateEmpty;
			this.templateEmpty.Name = EditorRes.GeneralRes.Template_Empty_Name;
			this.templateEmpty.Description = EditorRes.GeneralRes.Template_Empty_Desc;
			this.templateEmpty.SpecialTag = ProjectTemplateInfo.SpecialInfo.Empty;

			this.templateCurrent = new ProjectTemplateInfo();
			this.templateCurrent.Icon = EditorRes.GeneralResCache.ImageTemplateCurrent;
			this.templateCurrent.Name = EditorRes.GeneralRes.Template_Current_Name;
			this.templateCurrent.Description = EditorRes.GeneralRes.Template_Current_Desc;
			this.templateCurrent.SpecialTag = ProjectTemplateInfo.SpecialInfo.Current;

			// Hilde folder selector, if empty
			if (!Directory.Exists(this.folderModel.BasePath) || Directory.GetDirectories(this.folderModel.BasePath).Length == 0)
			{
				this.folderView.Enabled = false;
				this.splitFolderTemplate.Panel1Collapsed = true;
			}

			this.UpdateTemplateList();
		}
Exemplo n.º 4
0
 /// <summary>
 /// Adds the project if.
 /// </summary>
 /// <param name="condition">if set to <c>true</c> [condition].</param>
 /// <param name="projectTemplateInfo">The project template information.</param>
 protected void AddProjectIf(
     bool condition,
     ProjectTemplateInfo projectTemplateInfo)
 {
     if (condition)
     {
         this.ProjectTemplateInfos.Add(projectTemplateInfo);
     }
 }
Exemplo n.º 5
0
        /// <summary>
        /// Fixes the information p list.
        /// </summary>
        /// <param name="projectTemplateInfo">The project template information.</param>
        public void FixInfoPList(ProjectTemplateInfo projectTemplateInfo)
        {
            TraceService.WriteLine("ApplicationService::FixInfoPlist");

            IProjectService iosProjectService = this.visualStudioService.iOSProjectService;

            if (iosProjectService != null)
            {
                if (projectTemplateInfo != null)
                {
                    IProjectItemService projectItemService = iosProjectService.GetProjectItem("Info.plist");

                    if (projectItemService != null)
                    {
                        XDocument doc = XDocument.Load(projectItemService.FileName);

                        if (doc.Root != null)
                        {
                            XElement element = doc.Root.Element("dict");

                            if (element != null)
                            {
                                //// first look for the elements

                                XElement childElement = element.Elements("key").FirstOrDefault(x => x.Value == "CFBundleDisplayName");

                                if (childElement == null)
                                {
                                    element.Add(new XElement("key", "CFBundleDisplayName"));
                                    element.Add(new XElement("string", iosProjectService.Name));
                                }

                                childElement = element.Elements("key").FirstOrDefault(x => x.Value == "CFBundleVersion");

                                if (childElement == null)
                                {
                                    element.Add(new XElement("key", "CFBundleVersion"));
                                    element.Add(new XElement("string", "1.0"));
                                }

                                childElement = element.Elements("key").FirstOrDefault(x => x.Value == "CFBundleIdentifier");

                                if (childElement == null)
                                {
                                    element.Add(new XElement("key", "CFBundleIdentifier"));
                                    element.Add(new XElement("string", "1"));
                                }
                            }

                            doc.Save(projectItemService.FileName);
                        }
                    }
                }
            }
        }
        /// <summary>
        /// Translates the specified from.
        /// </summary>
        /// <param name="from">From.</param>
        /// <returns>A ProjectTemplateInfo.</returns>
        public ProjectTemplateInfo Translate(XElement from)
        {
            string projectName = from.GetSafeAttributeStringValue("Name");

            ProjectTemplateInfo projectTemplateInfo = new ProjectTemplateInfo
            {
                Name          = projectName,
                ItemTemplates = this.GetTextTemplates(projectName, projectName, from)
            };

            return(projectTemplateInfo);
        }
Exemplo n.º 7
0
        protected void UpdateTemplateList()
        {
            this.templateView.BeginUpdate();
            this.templateView.Items.Clear();
            this.imageListTemplateView.Images.Clear();

            // Scan for template files
            string[] templateFiles = Directory.Exists(this.selectedTemplatePath) ? Directory.GetFiles(this.selectedTemplatePath, "*.zip", SearchOption.TopDirectoryOnly) : new string[0];
            List <ProjectTemplateInfo> templateEntries = new List <ProjectTemplateInfo>();

            foreach (string templateFile in templateFiles)
            {
                try
                {
                    ProjectTemplateInfo entry = new ProjectTemplateInfo(templateFile);
                    templateEntries.Add(entry);
                }
                catch (Exception e)
                {
                    Log.Editor.WriteError("Can't load project template {0} because an error occurred in the process: {1}", templateFile, Log.Exception(e));
                }
            }

            // Add hardcoded templates
            if (this.selectedTemplatePath == this.folderModel.BasePath)
            {
                templateEntries.Insert(0, this.templateCurrent);
                templateEntries.Insert(0, this.templateEmpty);
            }

            // Add template entries to view
            foreach (ProjectTemplateInfo entry in templateEntries)
            {
                Bitmap icon = entry.Icon;
                if (icon != null)
                {
                    if (icon.Size != this.imageListTemplateView.ImageSize)
                    {
                        icon = icon.Rescale(this.imageListTemplateView.ImageSize.Width, this.imageListTemplateView.ImageSize.Height);
                    }
                    this.imageListTemplateView.Images.Add(entry.FilePath ?? entry.Name, icon);
                }

                ListViewItem item = new ListViewItem(new string[] { entry.Name, entry.Description }, entry.FilePath ?? entry.Name);
                item.Tag         = entry;
                item.ToolTipText = entry.Description;
                this.templateView.Items.Add(item);
            }

            this.templateView.Sort();
            this.templateView.EndUpdate();
        }
Exemplo n.º 8
0
        public ProjectTemplateInfo SetTemplateInfo(string filePath, string templateName)
        {
            var templatePath        = Path.Combine(filePath, templateName);
            var projectTemplateInfo = new ProjectTemplateInfo
            {
                Description = "Default template",
                Name        = "Default",
                Id          = Guid.NewGuid(),
                Uri         = new Uri(templatePath)
            };

            return(projectTemplateInfo);
        }
        public static string GetProjectLocation(this ProjectTemplateInfo projectTemplate)
        {
            var pathToTemplate = projectTemplate.Uri.LocalPath;
            var templateXml    = XElement.Load(pathToTemplate);
            var settingsGroup  =
                templateXml.Descendants("SettingsGroup")
                .Where(s => s.Attribute("Id").Value.Equals("ProjectTemplateSettings"));
            var location =
                settingsGroup.Descendants("Setting")
                .Where(id => id.Attribute("Id").Value.Equals("ProjectLocation"))
                .Select(l => l.Value).FirstOrDefault();

            return(location);
        }
Exemplo n.º 10
0
        private ProjectRequest CreateProjectRequest(ProjectTemplateInfo templateInfo, DirectoryInfo directory,
                                                    string path)
        {
            var projectRequest = new ProjectRequest();

            if (directory.Name != "AcceptedRequests")
            {
                projectRequest.Name            = directory.Name;
                projectRequest.Path            = path;
                projectRequest.ProjectTemplate = templateInfo;
                projectRequest.Files           = Directory.GetFiles(directory.FullName, "*", SearchOption.AllDirectories);
            }
            return(projectRequest);
        }
Exemplo n.º 11
0
		protected void UpdateTemplateList()
		{
			this.templateView.BeginUpdate();
			this.templateView.Items.Clear();
			this.imageListTemplateView.Images.Clear();

			// Scan for template files
			string[] templateFiles = Directory.Exists(this.selectedTemplatePath) ? Directory.GetFiles(this.selectedTemplatePath, "*.zip", SearchOption.TopDirectoryOnly) : new string[0];
			List<ProjectTemplateInfo> templateEntries = new List<ProjectTemplateInfo>();
			foreach (string templateFile in templateFiles)
			{
				try
				{
					ProjectTemplateInfo entry = new ProjectTemplateInfo(templateFile);
					templateEntries.Add(entry);
				}
				catch (Exception e)
				{
					Log.Editor.WriteError("Can't load project template {0} because an error occured in the process: {1}", templateFile, Log.Exception(e));
				}
			}

			// Add hardcoded templates
			if (this.selectedTemplatePath == this.folderModel.BasePath)
			{
				templateEntries.Insert(0, this.templateCurrent);
				templateEntries.Insert(0, this.templateEmpty);
			}

			// Add template entries to view
			foreach (ProjectTemplateInfo entry in templateEntries)
			{
				Bitmap icon = entry.Icon;
				if (icon != null)
				{
					if (icon.Size != this.imageListTemplateView.ImageSize)
						icon = icon.Rescale(this.imageListTemplateView.ImageSize.Width, this.imageListTemplateView.ImageSize.Height);
					this.imageListTemplateView.Images.Add(entry.FilePath ?? entry.Name, icon);
				}

				ListViewItem item = new ListViewItem(new string[] { entry.Name, entry.Description }, entry.FilePath ?? entry.Name);
				item.Tag = entry;
				item.ToolTipText = entry.Description;
				this.templateView.Items.Add(item);
			}

			this.templateView.Sort();
			this.templateView.EndUpdate();
		}
Exemplo n.º 12
0
        public void ReadTemplate()
        {
            ProjectTemplateInfo test_template = ProjectTemplateInfo.Deserialize(new DirectoryInfo(".\\Project Templates\\Test template"));

            Assert.AreEqual(test_template.Name, "TestTemplate");
            //read private member by reflection
            List <FileInfo> files =
                typeof(ProjectTemplateInfo).GetField("files",
                                                     BindingFlags.Instance | BindingFlags.NonPublic).GetValue(test_template) as List <FileInfo>;

            foreach (FileInfo file in files)
            {
                //Assert
            }
        }
Exemplo n.º 13
0
        /// <summary>
        /// Gets the core tests project.
        /// </summary>
        /// <param name="nugetCommands">The nuget commands.</param>
        /// <param name="preSelect">if set to <c>true</c> [pre select].</param>
        /// <param name="projectSuffix">The project suffix.</param>
        /// <param name="projectType">Type of the project.</param>
        /// <returns>A ProjectTemplateInfo.</returns>
        internal ProjectTemplateInfo GetPlatformTestsProject(
            IEnumerable <string> nugetCommands,
            bool preSelect,
            string projectSuffix,
            string projectType)
        {
            ProjectTemplateInfo projectTemplateInfo = this.GetPlatFormTestsProject(
                FrameworkType.MvvmCrossAndXamarinForms,
                this.SettingsService.TestingFramework,
                nugetCommands,
                preSelect,
                projectSuffix,
                projectType);

            return(projectTemplateInfo);
        }
Exemplo n.º 14
0
 private void textBoxTemplate_TextChanged(object sender, EventArgs e)
 {
     if (this.textBoxTemplate.Text == this.templateEmpty.Name)
     {
         this.selectedTemplate = this.templateEmpty;
     }
     else if (this.textBoxTemplate.Text == this.templateCurrent.Name)
     {
         this.selectedTemplate = this.templateCurrent;
     }
     else
     {
         try { this.selectedTemplate = new ProjectTemplateInfo(this.textBoxTemplate.Text); }
         catch (Exception) { this.selectedTemplate = null; }
     }
 }
Exemplo n.º 15
0
        private void templateView_SelectedIndexChanged(object sender, EventArgs e)
        {
            ProjectTemplateInfo entry = this.templateView.SelectedItems.Count > 0 ? this.templateView.SelectedItems[0].Tag as ProjectTemplateInfo : null;

            if (entry == null)
            {
                return;
            }

            if (entry.FilePath == null)
            {
                this.textBoxTemplate.Text = entry.Name;
            }
            else
            {
                this.textBoxTemplate.Text = entry.FilePath;
            }
        }
Exemplo n.º 16
0
        /// <summary>
        /// Gets the forms tests project.
        /// </summary>
        /// <returns>A ProjectTemplateInfo.</returns>
        internal ProjectTemplateInfo GetFormsTestsProject()
        {
            ProjectTemplateInfo projectTemplateInfo = this.GetTestsProject(
                FrameworkType.XamarinForms,
                this.SettingsService.TestingFramework,
                this.nugetCommandsService.GetTestCommands(),
                this.SettingsService.AddXamarinFormsTestsProject,
                this.SettingsService.XamarinFormsTestsProjectSuffix,
                ProjectType.XamarinFormsTests.GetDescription());

            //// TODO : lets do this properly :-)
            projectTemplateInfo.ReferenceCoreProject         = false;
            projectTemplateInfo.ReferenceXamarinFormsProject = true;

            if (this.SettingsService.CreatePlatformTestProjects == false)
            {
                projectTemplateInfo.PreSelected = false;
            }

            return(projectTemplateInfo);
        }
Exemplo n.º 17
0
        /// <summary>
        /// Gets the platform tests project.
        /// </summary>
        /// <param name="frameworkType">Type of the framework.</param>
        /// <param name="testingFramework">The testing framework.</param>
        /// <param name="nugetCommands">The nuget commands.</param>
        /// <param name="preSelect">if set to <c>true</c> [pre select].</param>
        /// <param name="projectSuffix">The project suffix.</param>
        /// <param name="projectType">Type of the project.</param>
        protected ProjectTemplateInfo GetPlatFormTestsProject(
            FrameworkType frameworkType,
            string testingFramework,
            IEnumerable <string> nugetCommands,
            bool preSelect,
            string projectSuffix,
            string projectType)
        {
            ProjectTemplateInfo projectTemplateInfo = this.GetTestsProject(
                frameworkType,
                testingFramework,
                nugetCommands,
                preSelect,
                projectSuffix,
                projectType);

            projectTemplateInfo.ReferenceCoreProject     = false;
            projectTemplateInfo.ReferencePlatformProject = true;

            return(projectTemplateInfo);
        }
Exemplo n.º 18
0
        /// <summary>
        /// Adds the project.
        /// </summary>
        /// <param name="path">The path.</param>
        /// <param name="projectInfo">The project info.</param>
        internal void TryToAddProject(
            string path,
            ProjectTemplateInfo projectInfo)
        {
            TraceService.WriteLine("ProjectsService::TryToAddProject  project=" + projectInfo.Name);

            //// Project may actually already exist - if so just skip it!

            string projectPath = $@"{path}\{projectInfo.Name}\";

            if (this.FileSystem.Directory.Exists(projectPath) == false)
            {
                TraceService.WriteDebugLine(projectInfo.Name + " " + projectPath + " added to the solution.");

                this.AddProject(projectInfo, projectPath);
            }
            else
            {
                TraceService.WriteError("Directory " + projectPath + " not empty");
            }
        }
Exemplo n.º 19
0
        /// <summary>
        /// Gets the project items.
        /// </summary>
        /// <param name="frameworkType">Type of the framework.</param>
        /// <param name="projectType">Type of the project.</param>
        /// <returns>A list of TextTemplateInfos.</returns>
        protected IEnumerable <TextTemplateInfo> GetProjectItems(
            FrameworkType frameworkType,
            ProjectType projectType)
        {
            string uri = string.Empty;

            switch (frameworkType)
            {
            case FrameworkType.NoFramework:
                uri = this.SettingsService.NoFrameworkProjectsUri;
                break;

            case FrameworkType.MvvmCross:
                uri = this.SettingsService.MvvmCrossProjectsUri;
                break;

            case FrameworkType.XamarinForms:
                uri = this.SettingsService.XamarinFormsProjectsUri;
                break;

            case FrameworkType.MvvmCrossAndXamarinForms:
                uri = this.SettingsService.MvvmCrossAndXamarinFormsProjectsUri;
                break;
            }

            if (uri != string.Empty)
            {
                IEnumerable <ProjectTemplateInfo> projectTemplateInfos = this.GetPojectTemplateInfos(uri);

                ProjectTemplateInfo projectTemplateInfo = projectTemplateInfos.FirstOrDefault(x => x.Name == projectType.ToString());

                if (projectTemplateInfo != null)
                {
                    return(projectTemplateInfo.ItemTemplates);
                }
            }

            return(new List <TextTemplateInfo>());
        }
Exemplo n.º 20
0
        /// <summary>
        /// Adds the project.
        /// </summary>
        /// <param name="projectInfo">The project info.</param>
        /// <param name="projectPath">The project path.</param>
        internal void AddProject(
            ProjectTemplateInfo projectInfo,
            string projectPath)
        {
            TraceService.WriteLine("ProjectsService::AddProject projectPath=" + projectPath + "templateName = " + projectInfo.TemplateName);

            try
            {
                string template = this.visualStudioService.SolutionService.GetProjectTemplate(projectInfo.TemplateName);

                TraceService.WriteLine("Template=" + template);

                //// add to TestProjects subfolder if applicable,
                if (this.SettingsService.CreateTestProjectsSolutionFolder && projectInfo.Name.EndsWith("Tests"))
                {
                    this.visualStudioService.SolutionService.AddProjectToSubFolder(
                        this.SettingsService.TestProjectsSolutionFolderName,
                        projectPath,
                        template,
                        projectInfo.Name);
                }
                else
                {
                    this.visualStudioService.SolutionService.AddProjectToSolution(projectPath, template, projectInfo.Name);
                }

                this.Messages.Add(projectInfo.Name + " project successfully added. (template " + projectInfo.TemplateName + ")");
            }
            catch (Exception exception)
            {
                TraceService.WriteError("error adding project exception=" + exception.Message);
                TraceService.WriteError("projectPath=" + projectPath);
                TraceService.WriteError("projectInfo.TemplateName=" + projectInfo.TemplateName);

                this.Messages.Add("ERROR " + projectInfo.Name + " not added. exception " + exception.Message + " (template " + projectInfo.TemplateName + ")");
            }
        }
Exemplo n.º 21
0
 public ProjectCreator(ProjectRequest projectRequest, ProjectTemplateInfo projectTemplate, IMessageBoxService messageBoxService)
 {
     _projectRequest    = projectRequest;
     _messageBoxService = messageBoxService;
     ProjectTemplate    = projectTemplate;
 }
Exemplo n.º 22
0
        /// <summary>
        /// Adds the project.
        /// </summary>
        /// <param name="path">The path.</param>
        /// <param name="projectInfo">The project information.</param>
        internal void AddProject(
            string path,
            ProjectTemplateInfo projectInfo)
        {
            string message = $"ProjectsService::AddProjectIf project {projectInfo.Name}";

            TraceService.WriteLine(message);

            this.SettingsService.ActiveProject = projectInfo.FriendlyName;

            this.TryToAddProject(path, projectInfo);

            //// add reference to core project

            IProjectService coreProjectService = this.visualStudioService.CoreProjectService;

            IProjectService projectService = this.visualStudioService.GetProjectServiceBySuffix(projectInfo.ProjectSuffix);

            if (coreProjectService != null &&
                projectService != null &&
                projectInfo.ReferenceCoreProject)
            {
                if (projectService.Name != coreProjectService.Name)
                {
                    projectService.AddProjectReference(coreProjectService);
                }
                else
                {
                    TraceService.WriteError("Attemped to reference project to its self project=" + projectService.Name);
                }
            }

            //// now add references to xamarin forms if required.

            if (projectInfo.ReferenceXamarinFormsProject)
            {
                IProjectService formsProjectService = this.visualStudioService.XamarinFormsProjectService;

                if (formsProjectService != null &&
                    projectService != null)
                {
                    if (projectService.Name != formsProjectService.Name)
                    {
                        projectService.AddProjectReference(formsProjectService);
                    }
                    else
                    {
                        TraceService.WriteError("Attemped to reference project to its self project=" + projectService.Name);
                    }
                }
            }

            //// now add reference to the plaform project from the test platform project

            if (projectInfo.ReferencePlatformProject)
            {
                //// TODO : tidy this up a little bit!
                IProjectService platformProjectService = this.visualStudioService.GetProjectServiceBySuffix(
                    projectInfo.ProjectSuffix.Replace(".Tests", string.Empty));

                if (platformProjectService != null &&
                    projectService != null)
                {
                    //// for some reason cant add project reference to windows store project !!
                    //// as no one is developing mvvmcross windows store apps dont worry about it :-)
                    try
                    {
                        projectService.AddProjectReference(platformProjectService);
                    }
                    catch (Exception exception)
                    {
                        TraceService.WriteError("Unable to add project reference to " + platformProjectService.Name + " exception=" + exception.Message);
                    }
                }
            }

            if (projectInfo.ItemTemplates != null &&
                projectInfo.ItemTemplates.Any() &&
                projectService != null)
            {
                foreach (TextTemplateInfo textTemplateInfo in projectInfo.ItemTemplates)
                {
                    textTemplateInfo.Tokens = this.tokensTranslator.Translate(projectService);
                }

                this.textTemplatingService.AddTextTemplates(
                    "Adding items to project " + projectService.Name,
                    projectInfo.ItemTemplates);
            }
        }
Exemplo n.º 23
0
 public ProjectCreator(List <ProjectRequest> requests, ProjectTemplateInfo projectTemplate)
 {
     Requests           = requests;
     ProjectTemplate    = projectTemplate;
     SuccessfulRequests = new List <Tuple <ProjectRequest, FileBasedProject> >();
 }
Exemplo n.º 24
0
		private void textBoxTemplate_TextChanged(object sender, EventArgs e)
		{
			if (this.textBoxTemplate.Text == this.templateEmpty.Name)
				this.selectedTemplate = this.templateEmpty;
			else if (this.textBoxTemplate.Text == this.templateCurrent.Name)
				this.selectedTemplate = this.templateCurrent;
			else
			{
				try { this.selectedTemplate = new ProjectTemplateInfo(this.textBoxTemplate.Text); } 
				catch (Exception) { this.selectedTemplate = null; }
			}
			this.UpdateInputValid();
		}
Exemplo n.º 25
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ApplyTemplate"/> class.
 /// </summary>
 /// <param name="templateInfo">The template information.</param>
 public ApplyTemplate(ProjectTemplateInfo templateInfo) : this("*" + templateInfo.Name)
 {
     this.Name = "*" + templateInfo.Name;
     this.Uri = templateInfo.Uri;
     this.Id = templateInfo.Id;
 }
 /// <summary>
 /// Adds the template.
 /// </summary>
 /// <param name="projectTemplateInfo">The project template info.</param>
 public void AddTemplate(ProjectTemplateInfo projectTemplateInfo)
 {
     this.mvxListView1.AddTemplate(projectTemplateInfo);
 }
Exemplo n.º 27
0
 /// <summary>
 /// Gets the required template.
 /// </summary>
 /// <param name="projectInfo">The project info.</param>
 internal void GetRequiredTemplate(ProjectTemplateInfo projectInfo)
 {
     projectInfo.Name = this.Project + projectInfo.ProjectSuffix;
 }
Exemplo n.º 28
0
 public ProjectCreator(ProjectRequest projectRequest, ProjectTemplateInfo projectTemplate)
 {
     _projectRequest = projectRequest;
     ProjectTemplate = projectTemplate;
 }
Exemplo n.º 29
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ApplyTemplate"/> class.
 /// </summary>
 /// <param name="templateInfo">The template information.</param>
 public ApplyTemplate(ProjectTemplateInfo templateInfo) : this("*" + templateInfo.Name)
 {
     Name = "*" + templateInfo.Name;
     Uri  = templateInfo.Uri;
     Id   = templateInfo.Id;
 }