public static IProject LoadProject(ProjectLoadInformation loadInformation)
        {
            if (loadInformation == null)
            {
                throw new ArgumentNullException("loadInformation");
            }

            string           location        = FileUtility.NormalizePath(loadInformation.FileName);
            string           title           = loadInformation.ProjectName;
            IProgressMonitor progressMonitor = loadInformation.ProgressMonitor;

            progressMonitor.CancellationToken.ThrowIfCancellationRequested();

            IProjectBinding binding = ProjectBindingService.GetBindingPerProjectFile(location);
            IProject        newProject;

            if (!(binding != null && binding.HandlingMissingProject) && !File.Exists(location))
            {
                newProject          = new MissingProject(location, title);
                newProject.TypeGuid = loadInformation.TypeGuid;
            }
            else
            {
                if (binding != null)
                {
                    try {
                        newProject = binding.LoadProject(loadInformation);
                    } catch (ProjectLoadException ex) {
                        LoggingService.Warn("Project load error", ex);
                        progressMonitor.ShowingDialog = true;
                        newProject                    = new UnknownProject(location, title, ex.Message, true);
                        newProject.TypeGuid           = loadInformation.TypeGuid;
                        progressMonitor.ShowingDialog = false;
                    } catch (UnauthorizedAccessException ex) {
                        LoggingService.Warn("Project load error", ex);
                        progressMonitor.ShowingDialog = true;
                        newProject                    = new UnknownProject(location, title, ex.Message, true);
                        newProject.TypeGuid           = loadInformation.TypeGuid;
                        progressMonitor.ShowingDialog = false;
                    }
                }
                else
                {
                    string ext = Path.GetExtension(location);
                    if (".proj".Equals(ext, StringComparison.OrdinalIgnoreCase) ||
                        ".build".Equals(ext, StringComparison.OrdinalIgnoreCase))
                    {
                        newProject          = new MSBuildFileProject(location, title);
                        newProject.TypeGuid = loadInformation.TypeGuid;
                    }
                    else
                    {
                        newProject          = new UnknownProject(location, title);
                        newProject.TypeGuid = loadInformation.TypeGuid;
                    }
                }
            }
            return(newProject);
        }
Exemplo n.º 2
0
        public void AddReference()
        {
            foreach (ListViewItem item in SelectedItems)
            {
                IProject        project = (IProject)item.Tag;
                IProjectBinding binding = ProjectBindingService.GetBindingPerLanguageName(project.Language);

                selectDialog.AddReference(
                    project.Name, "Project", project.OutputAssemblyFullPath,
                    new ProjectReferenceProjectItem(selectDialog.ConfigureProject, project)
                    );
            }
        }
Exemplo n.º 3
0
        public IProject LoadProject(ProjectLoadInformation info)
        {
            if (info == null)
            {
                throw new ArgumentNullException("info");
            }
            info.ProgressMonitor.CancellationToken.ThrowIfCancellationRequested();
            ProjectBindingDescriptor descriptor = null;

            if (info.TypeGuid != Guid.Empty)
            {
                descriptor = projectBindings.FirstOrDefault(b => b.TypeGuid == info.TypeGuid);
            }
            if (descriptor == null)
            {
                string extension = info.FileName.GetExtension();
                if (extension.Equals(".proj", StringComparison.OrdinalIgnoreCase) || extension.Equals(".build", StringComparison.OrdinalIgnoreCase))
                {
                    return(new MSBuildFileProject(info));
                }
                descriptor = projectBindings.FirstOrDefault(b => extension.Equals(b.ProjectFileExtension, StringComparison.OrdinalIgnoreCase));
            }
            if (descriptor == null)
            {
                throw new ProjectLoadException(SD.ResourceService.GetString("ICSharpCode.SharpDevelop.Commands.ProjectBrowser.NoBackendForProjectType"));
            }

            // Set type GUID based on file extension
            info.TypeGuid = descriptor.TypeGuid;
            IProjectBinding binding = descriptor.Binding;

            if (binding == null)
            {
                throw new ProjectLoadException(SD.ResourceService.GetString("ICSharpCode.SharpDevelop.Commands.ProjectBrowser.NoBackendForProjectType"));
            }
            if (!binding.HandlingMissingProject && !SD.FileSystem.FileExists(info.FileName))
            {
                throw new FileNotFoundException("Project file not found", info.FileName);
            }
            var result = binding.LoadProject(info);

            if (result == null)
            {
                throw new InvalidOperationException("IProjectBinding.LoadProject() must not return null");
            }

            return(result);
        }
		public ProjectBindingDescriptor(IProjectBinding binding, string language, string projectFileExtension, Guid typeGuid, string[] codeFileExtensions)
		{
			if (binding == null)
				throw new ArgumentNullException("binding");
			if (language == null)
				throw new ArgumentNullException("language");
			if (projectFileExtension == null)
				throw new ArgumentNullException("projectFileExtension");
			if (codeFileExtensions == null)
				throw new ArgumentNullException("codeFileExtensions");
			this.binding = binding;
			this.projectFileExtension = projectFileExtension;
			this.typeGuid = typeGuid;
			this.language = language;
			this.codeFileExtensions = codeFileExtensions;
		}
Exemplo n.º 5
0
 public ProjectBindingDescriptor(IProjectBinding binding, string language, string projectFileExtension, Guid typeGuid, string[] codeFileExtensions)
 {
     if (binding == null)
     {
         throw new ArgumentNullException("binding");
     }
     if (language == null)
     {
         throw new ArgumentNullException("language");
     }
     if (projectFileExtension == null)
     {
         throw new ArgumentNullException("projectFileExtension");
     }
     if (codeFileExtensions == null)
     {
         throw new ArgumentNullException("codeFileExtensions");
     }
     this.binding = binding;
     this.projectFileExtension = projectFileExtension;
     this.typeGuid             = typeGuid;
     this.language             = language;
     this.codeFileExtensions   = codeFileExtensions;
 }
Exemplo n.º 6
0
        //Show prompt, create files from template, create project, execute command, save project
        public IProject CreateProject(ProjectCreateInformation projectCreateInformation, string defaultLanguage)
        {
            // remember old outerProjectBasePath
            string outerProjectBasePath = projectCreateInformation.ProjectBasePath;
            string outerProjectName     = projectCreateInformation.ProjectName;

            try
            {
                projectCreateInformation.ProjectBasePath = Path.Combine(projectCreateInformation.ProjectBasePath, this.relativePath);
                if (!Directory.Exists(projectCreateInformation.ProjectBasePath))
                {
                    Directory.CreateDirectory(projectCreateInformation.ProjectBasePath);
                }

                string language = string.IsNullOrEmpty(languageName) ? defaultLanguage : languageName;
                ProjectBindingDescriptor descriptor   = ProjectBindingService.GetCodonPerLanguageName(language);
                IProjectBinding          languageinfo = (descriptor != null) ? descriptor.Binding : null;

                if (languageinfo == null)
                {
                    MessageService.ShowError(
                        StringParser.Parse("${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.CantCreateProjectWithTypeError}",
                                           new StringTagPair("type", language)));
                    return(null);
                }

                string newProjectName  = StringParser.Parse(name, new StringTagPair("ProjectName", projectCreateInformation.ProjectName));
                string projectLocation = Path.GetFullPath(Path.Combine(projectCreateInformation.ProjectBasePath,
                                                                       newProjectName + ProjectBindingService.GetProjectFileExtension(language)));


                StringBuilder standardNamespace = new StringBuilder();
                // filter 'illegal' chars from standard namespace
                if (newProjectName != null && newProjectName.Length > 0)
                {
                    char ch = '.';
                    for (int i = 0; i < newProjectName.Length; ++i)
                    {
                        if (ch == '.')
                        {
                            // at beginning or after '.', only a letter or '_' is allowed
                            ch = newProjectName[i];
                            if (!Char.IsLetter(ch))
                            {
                                standardNamespace.Append('_');
                            }
                            else
                            {
                                standardNamespace.Append(ch);
                            }
                        }
                        else
                        {
                            ch = newProjectName[i];
                            // can only contain letters, digits or '_'
                            if (!Char.IsLetterOrDigit(ch) && ch != '.')
                            {
                                standardNamespace.Append('_');
                            }
                            else
                            {
                                standardNamespace.Append(ch);
                            }
                        }
                    }
                }

                projectCreateInformation.OutputProjectFileName = projectLocation;
                projectCreateInformation.RootNamespace         = standardNamespace.ToString();
                projectCreateInformation.ProjectName           = newProjectName;

                StringParserPropertyContainer.FileCreation["StandardNamespace"] = projectCreateInformation.RootNamespace;

                if (File.Exists(projectLocation))
                {
                    if (!MessageService.AskQuestion(
                            StringParser.Parse("${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.OverwriteProjectQuestion}",
                                               new StringTagPair("projectLocation", projectLocation)),
                            "${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.OverwriteQuestion.InfoName}"))
                    {
                        return(null);                        //The user doesnt want to overwrite the project...
                    }
                }

                //Show prompt if any of the files exist
                StringBuilder existingFileNames = new StringBuilder();
                foreach (FileDescriptionTemplate file in files)
                {
                    string fileName = Path.Combine(projectCreateInformation.ProjectBasePath, StringParser.Parse(file.Name, new string[, ] {
                        { "ProjectName", projectCreateInformation.ProjectName }
                    }));

                    if (File.Exists(fileName))
                    {
                        if (existingFileNames.Length > 0)
                        {
                            existingFileNames.Append(", ");
                        }
                        existingFileNames.Append(Path.GetFileName(fileName));
                    }
                }

                bool overwriteFiles = true;
                if (existingFileNames.Length > 0)
                {
                    if (!MessageService.AskQuestion(
                            StringParser.Parse("${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.OverwriteQuestion}",
                                               new StringTagPair("fileNames", existingFileNames.ToString())),
                            "${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.OverwriteQuestion.InfoName}"))
                    {
                        overwriteFiles = false;
                    }
                }



                #region Copy files to target directory
                foreach (FileDescriptionTemplate file in files)
                {
                    string fileName = Path.Combine(projectCreateInformation.ProjectBasePath, StringParser.Parse(file.Name, new string[, ] {
                        { "ProjectName", projectCreateInformation.ProjectName }
                    }));
                    if (File.Exists(fileName) && !overwriteFiles)
                    {
                        continue;
                    }

                    try
                    {
                        if (!Directory.Exists(Path.GetDirectoryName(fileName)))
                        {
                            Directory.CreateDirectory(Path.GetDirectoryName(fileName));
                        }
                        if (!String.IsNullOrEmpty(file.BinaryFileName))
                        {
                            // Binary content
                            File.Copy(file.BinaryFileName, fileName);
                        }
                        else
                        {
                            // Textual content
                            StreamWriter sr          = new StreamWriter(File.Create(fileName), ParserService.DefaultFileEncoding);
                            string       fileContent = StringParser.Parse(file.Content, new string[, ] {
                                { "ProjectName", projectCreateInformation.ProjectName }, { "FileName", fileName }
                            });
                            fileContent = StringParser.Parse(fileContent);
                            if (EditorControlService.GlobalOptions.IndentationString != "\t")
                            {
                                fileContent = fileContent.Replace("\t", EditorControlService.GlobalOptions.IndentationString);
                            }
                            sr.Write(fileContent);
                            sr.Close();
                        }
                    }
                    catch (Exception ex)
                    {
                        MessageService.ShowException(ex, "Exception writing " + fileName);
                    }
                }
                #endregion

                #region Create Project
                IProject project;
                try {
                    project = languageinfo.CreateProject(projectCreateInformation);
                } catch (ProjectLoadException ex) {
                    MessageService.ShowError(ex.Message);
                    return(null);
                }
                #endregion

                #region Create Project Items, Imports and Files
                // Add Project items
                if (project is IProjectItemListProvider)
                {
                    foreach (ProjectItem projectItem in projectItems)
                    {
                        ProjectItem newProjectItem = new UnknownProjectItem(
                            project,
                            StringParser.Parse(projectItem.ItemType.ItemName),
                            StringParser.Parse(projectItem.Include)
                            );
                        foreach (string metadataName in projectItem.MetadataNames)
                        {
                            string metadataValue = projectItem.GetMetadata(metadataName);
                            // if the input contains any special MSBuild sequences, don't escape the value
                            // we want to escape only when the special characters are introduced by the StringParser.Parse replacement
                            if (metadataValue.Contains("$(") || metadataValue.Contains("%"))
                            {
                                newProjectItem.SetMetadata(StringParser.Parse(metadataName), StringParser.Parse(metadataValue));
                            }
                            else
                            {
                                newProjectItem.SetEvaluatedMetadata(StringParser.Parse(metadataName), StringParser.Parse(metadataValue));
                            }
                        }
                        ((IProjectItemListProvider)project).AddProjectItem(newProjectItem);
                    }
                }

                // Add Imports
                if (clearExistingImports || projectImports.Count > 0)
                {
                    MSBuildBasedProject msbuildProject = project as MSBuildBasedProject;
                    if (msbuildProject == null)
                    {
                        throw new Exception("<Imports> may be only used in project templates for MSBuildBasedProjects");
                    }
                    try {
                        msbuildProject.PerformUpdateOnProjectFile(
                            delegate {
                            var projectFile = msbuildProject.MSBuildProjectFile;
                            if (clearExistingImports)
                            {
                                foreach (var import in projectFile.Imports.ToArray())
                                {
                                    projectFile.RemoveChild(import);
                                }
                            }
                            foreach (Import projectImport in projectImports)
                            {
                                projectFile.AddImport(projectImport.Key).Condition = projectImport.Value;
                            }
                        });
                    } catch (InvalidProjectFileException ex) {
                        if (string.IsNullOrEmpty(importsFailureMessage))
                        {
                            MessageService.ShowError("Error creating project:\n" + ex.Message);
                        }
                        else
                        {
                            MessageService.ShowError(importsFailureMessage + "\n\n" + ex.Message);
                        }
                        return(null);
                    }
                }

                if (projectProperties.Count > 0)
                {
                    if (!(project is MSBuildBasedProject))
                    {
                        throw new Exception("<PropertyGroup> may be only used in project templates for MSBuildBasedProjects");
                    }

                    foreach (ProjectProperty p in projectProperties)
                    {
                        ((MSBuildBasedProject)project).SetProperty(
                            StringParser.Parse(p.Configuration),
                            StringParser.Parse(p.Platform),
                            StringParser.Parse(p.Name),
                            StringParser.Parse(p.Value),
                            p.Location,
                            p.ValueIsLiteral
                            );
                    }
                }

                // Add Files
                if (project is IProjectItemListProvider)
                {
                    foreach (FileDescriptionTemplate file in files)
                    {
                        string fileName = Path.Combine(projectCreateInformation.ProjectBasePath, StringParser.Parse(file.Name, new string[, ] {
                            { "ProjectName", projectCreateInformation.ProjectName }
                        }));
                        FileProjectItem projectFile = new FileProjectItem(project, project.GetDefaultItemType(fileName));

                        projectFile.Include = FileUtility.GetRelativePath(project.Directory, fileName);

                        file.SetProjectItemProperties(projectFile);

                        ((IProjectItemListProvider)project).AddProjectItem(projectFile);
                    }
                }

                #endregion

                RunCreateActions(project);

                project.ProjectCreationComplete();

                // Save project
                project.Save();


                projectCreateInformation.createdProjects.Add(project);
                ProjectService.OnProjectCreated(new ProjectEventArgs(project));
                return(project);
            }
            finally
            {
                // set back outerProjectBasePath
                projectCreateInformation.ProjectBasePath = outerProjectBasePath;
                projectCreateInformation.ProjectName     = outerProjectName;
            }
        }
Exemplo n.º 7
0
        static void LoadProjectInternal(string fileName)
        {
            if (!Path.IsPathRooted(fileName))
            {
                throw new ArgumentException("Path must be rooted!");
            }
            string solutionFile = Path.ChangeExtension(fileName, ".sln");

            if (File.Exists(solutionFile))
            {
                LoadSolutionInternal(solutionFile);

                if (openSolution != null)
                {
                    bool found = false;
                    foreach (IProject p in openSolution.Projects)
                    {
                        if (FileUtility.IsEqualFileName(fileName, p.FileName))
                        {
                            found = true;
                            break;
                        }
                    }
                    if (found == false)
                    {
                        var parseArgs = new[] { new StringTagPair("SolutionName", Path.GetFileName(solutionFile)), new StringTagPair("ProjectName", Path.GetFileName(fileName)) };
                        int res       = MessageService.ShowCustomDialog(MessageService.ProductName,
                                                                        StringParser.Parse("${res:ICSharpCode.SharpDevelop.Commands.OpenCombine.SolutionDoesNotContainProject}", parseArgs),
                                                                        0, 2,
                                                                        StringParser.Parse("${res:ICSharpCode.SharpDevelop.Commands.OpenCombine.SolutionDoesNotContainProject.AddProjectToSolution}", parseArgs),
                                                                        StringParser.Parse("${res:ICSharpCode.SharpDevelop.Commands.OpenCombine.SolutionDoesNotContainProject.CreateNewSolution}", parseArgs),
                                                                        "${res:Global.IgnoreButtonText}");
                        if (res == 0)
                        {
                            // Add project to solution
                            Commands.AddExitingProjectToSolution.AddProject((ISolutionFolderNode)ProjectBrowserPad.Instance.SolutionNode, fileName);
                            SaveSolution();
                            return;
                        }
                        else if (res == 1)
                        {
                            CloseSolution();
                            try {
                                File.Copy(solutionFile, Path.ChangeExtension(solutionFile, ".old.sln"), true);
                            } catch (IOException) {}
                        }
                        else
                        {
                            // ignore, just open the solution
                            return;
                        }
                    }
                    else
                    {
                        // opened solution instead and correctly found the project
                        return;
                    }
                }
                else
                {
                    // some problem during opening, abort
                    return;
                }
            }
            Solution solution = new Solution(new ProjectChangeWatcher(solutionFile));

            solution.Name = Path.GetFileNameWithoutExtension(fileName);
            IProjectBinding binding = ProjectBindingService.GetBindingPerProjectFile(fileName);
            IProject        project;

            if (binding != null)
            {
                project = ProjectBindingService.LoadProject(new ProjectLoadInformation(solution, fileName, solution.Name));
                if (project is UnknownProject)
                {
                    if (((UnknownProject)project).WarningDisplayedToUser == false)
                    {
                        ((UnknownProject)project).ShowWarningMessageBox();
                    }
                    return;
                }
            }
            else
            {
                MessageService.ShowError(StringParser.Parse("${res:ICSharpCode.SharpDevelop.Commands.OpenCombine.InvalidProjectOrCombine}", new StringTagPair("FileName", fileName)));
                return;
            }
            solution.AddFolder(project);
            ProjectSection configSection = solution.GetSolutionConfigurationsSection();

            foreach (string configuration in project.ConfigurationNames)
            {
                foreach (string platform in project.PlatformNames)
                {
                    string key;
                    if (platform == "AnyCPU")                       // Fix for SD2-786
                    {
                        key = configuration + "|Any CPU";
                    }
                    else
                    {
                        key = configuration + "|" + platform;
                    }
                    configSection.Items.Add(new SolutionItem(key, key));
                }
            }
            solution.FixSolutionConfiguration(new IProject[] { project });

            if (FileUtility.ObservedSave((NamedFileOperationDelegate)solution.Save, solutionFile) == FileOperationResult.OK)
            {
                // only load when saved succesfully
                LoadSolution(solutionFile);
            }
        }
Exemplo n.º 8
0
        //Show prompt, create files from template, create project, execute command, save project
        public bool CreateProject(ProjectTemplateResult templateResults, string defaultLanguage, ISolutionFolder target)
        {
            var      projectCreateOptions = templateResults.Options;
            var      parentSolution       = templateResults.Options.Solution;
            IProject project = null;
            bool     success = false;

            try
            {
                string language = string.IsNullOrEmpty(languageName) ? defaultLanguage : languageName;
                ProjectBindingDescriptor descriptor   = SD.ProjectService.ProjectBindings.FirstOrDefault(b => b.Language == language);
                IProjectBinding          languageinfo = (descriptor != null) ? descriptor.Binding : null;

                if (languageinfo == null)
                {
                    MessageService.ShowError(
                        StringParser.Parse("${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.CantCreateProjectWithTypeError}",
                                           new StringTagPair("type", language)));
                    return(false);
                }

                DirectoryName projectBasePath = GetProjectBasePath(projectCreateOptions);
                string        newProjectName  = StringParser.Parse(name, new StringTagPair("ProjectName", projectCreateOptions.ProjectName));
                Directory.CreateDirectory(projectBasePath);
                FileName projectLocation      = projectBasePath.CombineFile(newProjectName + descriptor.ProjectFileExtension);
                ProjectCreateInformation info = new ProjectCreateInformation(parentSolution, projectLocation);
                info.TargetFramework = projectCreateOptions.TargetFramework;

                StringBuilder standardNamespace = new StringBuilder();
                // filter 'illegal' chars from standard namespace
                if (!string.IsNullOrEmpty(newProjectName))
                {
                    char ch = '.';
                    for (int i = 0; i < newProjectName.Length; ++i)
                    {
                        if (ch == '.')
                        {
                            // at beginning or after '.', only a letter or '_' is allowed
                            ch = newProjectName[i];
                            if (!Char.IsLetter(ch))
                            {
                                standardNamespace.Append('_');
                            }
                            else
                            {
                                standardNamespace.Append(ch);
                            }
                        }
                        else
                        {
                            ch = newProjectName[i];
                            // can only contain letters, digits or '_'
                            if (!Char.IsLetterOrDigit(ch) && ch != '.')
                            {
                                standardNamespace.Append('_');
                            }
                            else
                            {
                                standardNamespace.Append(ch);
                            }
                        }
                    }
                }

                info.TypeGuid      = descriptor.TypeGuid;
                info.RootNamespace = standardNamespace.ToString();
                info.ProjectName   = newProjectName;
                if (!string.IsNullOrEmpty(defaultPlatform))
                {
                    info.ActiveProjectConfiguration = new ConfigurationAndPlatform("Debug", defaultPlatform);
                }

                RunPreCreateActions(info);

                StringParserPropertyContainer.FileCreation["StandardNamespace"] = info.RootNamespace;

                if (File.Exists(projectLocation))
                {
                    if (!MessageService.AskQuestion(
                            StringParser.Parse("${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.OverwriteProjectQuestion}",
                                               new StringTagPair("projectLocation", projectLocation)),
                            "${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.OverwriteQuestion.InfoName}"))
                    {
                        return(false);                        //The user doesnt want to overwrite the project...
                    }
                }

                //Show prompt if any of the files exist
                StringBuilder existingFileNames = new StringBuilder();
                foreach (FileDescriptionTemplate file in files)
                {
                    string fileName = Path.Combine(projectBasePath, StringParser.Parse(file.Name, new StringTagPair("ProjectName", info.ProjectName)));

                    if (File.Exists(fileName))
                    {
                        if (existingFileNames.Length > 0)
                        {
                            existingFileNames.Append(", ");
                        }
                        existingFileNames.Append(Path.GetFileName(fileName));
                    }
                }

                bool overwriteFiles = true;
                if (existingFileNames.Length > 0)
                {
                    if (!MessageService.AskQuestion(
                            StringParser.Parse("${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.OverwriteQuestion}",
                                               new StringTagPair("fileNames", existingFileNames.ToString())),
                            "${res:ICSharpCode.SharpDevelop.Internal.Templates.ProjectDescriptor.OverwriteQuestion.InfoName}"))
                    {
                        overwriteFiles = false;
                    }
                }



                #region Copy files to target directory
                foreach (FileDescriptionTemplate file in files)
                {
                    string fileName = Path.Combine(projectBasePath, StringParser.Parse(file.Name, new StringTagPair("ProjectName", info.ProjectName)));
                    if (File.Exists(fileName) && !overwriteFiles)
                    {
                        continue;
                    }

                    try
                    {
                        if (!Directory.Exists(Path.GetDirectoryName(fileName)))
                        {
                            Directory.CreateDirectory(Path.GetDirectoryName(fileName));
                        }
                        if (!String.IsNullOrEmpty(file.BinaryFileName))
                        {
                            // Binary content
                            File.Copy(file.BinaryFileName, fileName, true);
                        }
                        else
                        {
                            // Textual content
                            StreamWriter sr          = new StreamWriter(File.Create(fileName), SD.FileService.DefaultFileEncoding);
                            string       fileContent = StringParser.Parse(file.Content,
                                                                          new StringTagPair("ProjectName", projectCreateOptions.ProjectName),
                                                                          new StringTagPair("SolutionName", projectCreateOptions.SolutionName),
                                                                          new StringTagPair("FileName", fileName));
                            fileContent = StringParser.Parse(fileContent);
                            if (SD.EditorControlService.GlobalOptions.IndentationString != "\t")
                            {
                                fileContent = fileContent.Replace("\t", SD.EditorControlService.GlobalOptions.IndentationString);
                            }
                            sr.Write(fileContent);
                            sr.Close();
                        }
                    }
                    catch (Exception ex)
                    {
                        MessageService.ShowException(ex, "Exception writing " + fileName);
                    }
                }
                #endregion

                #region Create Project
                try {
                    info.InitializeTypeSystem = false;
                    project = languageinfo.CreateProject(info);
                } catch (ProjectLoadException ex) {
                    MessageService.ShowError(ex.Message);
                    return(false);
                }
                #endregion

                #region Create Project Items, Imports and Files
                // Add Project items
                if (!project.Items.IsReadOnly)
                {
                    foreach (ProjectItem projectItem in projectItems)
                    {
                        ProjectItem newProjectItem = new UnknownProjectItem(
                            project,
                            StringParser.Parse(projectItem.ItemType.ItemName),
                            StringParser.Parse(projectItem.Include,
                                               new StringTagPair("ProjectName", projectCreateOptions.ProjectName),
                                               new StringTagPair("SolutionName", projectCreateOptions.SolutionName))
                            );
                        foreach (string metadataName in projectItem.MetadataNames)
                        {
                            string metadataValue = projectItem.GetMetadata(metadataName);
                            // if the input contains any special MSBuild sequences, don't escape the value
                            // we want to escape only when the special characters are introduced by the StringParser.Parse replacement
                            if (metadataValue.Contains("$(") || metadataValue.Contains("%"))
                            {
                                newProjectItem.SetMetadata(StringParser.Parse(metadataName), StringParser.Parse(metadataValue));
                            }
                            else
                            {
                                newProjectItem.SetEvaluatedMetadata(StringParser.Parse(metadataName), StringParser.Parse(metadataValue));
                            }
                        }
                        project.Items.Add(newProjectItem);
                    }
                }

                // Add properties from <PropertyGroup>
                // This must be done before adding <Imports>, because the import path can refer to properties.
                if (projectProperties.Count > 0)
                {
                    if (!(project is MSBuildBasedProject))
                    {
                        throw new Exception("<PropertyGroup> may be only used in project templates for MSBuildBasedProjects");
                    }

                    foreach (ProjectProperty p in projectProperties)
                    {
                        ((MSBuildBasedProject)project).SetProperty(
                            StringParser.Parse(p.Configuration),
                            StringParser.Parse(p.Platform),
                            StringParser.Parse(p.Name),
                            StringParser.Parse(p.Value),
                            p.Location,
                            p.ValueIsLiteral
                            );
                    }
                }

                // Add Imports
                if (clearExistingImports || projectImports.Count > 0)
                {
                    MSBuildBasedProject msbuildProject = project as MSBuildBasedProject;
                    if (msbuildProject == null)
                    {
                        throw new Exception("<Imports> may be only used in project templates for MSBuildBasedProjects");
                    }
                    try {
                        msbuildProject.PerformUpdateOnProjectFile(
                            delegate {
                            var projectFile = msbuildProject.MSBuildProjectFile;
                            if (clearExistingImports)
                            {
                                foreach (var import in projectFile.Imports.ToArray())
                                {
                                    projectFile.RemoveChild(import);
                                }
                            }
                            foreach (Import projectImport in projectImports)
                            {
                                projectFile.AddImport(projectImport.Key).Condition = projectImport.Value;
                            }
                        });
                    } catch (InvalidProjectFileException ex) {
                        string message;
                        if (string.IsNullOrEmpty(importsFailureMessage))
                        {
                            message = "Error creating project:\n" + ex.Message;
                        }
                        else
                        {
                            message = importsFailureMessage + "\n\n" + ex.Message;
                        }
                        throw new ProjectLoadException(message, ex);
                    }
                }

                // Add Files
                if (!project.Items.IsReadOnly)
                {
                    foreach (FileDescriptionTemplate file in files)
                    {
                        string          fileName    = Path.Combine(projectBasePath, StringParser.Parse(file.Name, new StringTagPair("ProjectName", projectCreateOptions.ProjectName)));
                        FileProjectItem projectFile = new FileProjectItem(project, project.GetDefaultItemType(fileName));

                        projectFile.Include = FileUtility.GetRelativePath(project.Directory, fileName);

                        file.SetProjectItemProperties(projectFile);

                        project.Items.Add(projectFile);
                    }
                }

                #endregion

                RunCreateActions(project);

                project.ProjectCreationComplete();

                // Save project
                project.Save();

                // HACK : close and reload
                var fn = project.FileName;
                project.Dispose();
                ProjectLoadInformation loadInfo = new ProjectLoadInformation(parentSolution, fn, fn.GetFileNameWithoutExtension());
                project = SD.ProjectService.LoadProject(loadInfo);
                target.Items.Add(project);
                project.ProjectLoaded();

                SD.GetRequiredService <IProjectServiceRaiseEvents>().RaiseProjectCreated(new ProjectEventArgs(project));
                templateResults.NewProjects.Add(project);
                success = true;
                return(true);
            } finally {
                if (project != null && !success)
                {
                    project.Dispose();
                }
            }
        }
 public override object BuildItem(object owner, ArrayList subItems, ConditionCollection conditions)
 {
     projectBinding = (IProjectBinding) AddIn.CreateObject (Class);
     return this;
 }