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 static string MakeSafeIdentifier(ICodeDocumentType codeDocumentType, string identifier, bool escape)
{
if (codeDocumentType.Name != "Javascript")
{
char[] chrArray = new char[] { '\u005F' };
identifier = Microsoft.Expression.Project.Build.CodeGenerator.FixUpIdentifier(identifier, chrArray);
}
else
{
char[] chrArray1 = new char[] { '\u005F', '$' };
identifier = Microsoft.Expression.Project.Build.CodeGenerator.FixUpIdentifier(identifier, chrArray1);
}
if (escape)
{
ICodeGeneratorHost codeGeneratorHost = codeDocumentType as ICodeGeneratorHost;
if (codeGeneratorHost != null)
{
identifier = codeGeneratorHost.CodeDomProvider.CreateEscapedIdentifier(identifier);
}
}
if (identifier == "_" && codeDocumentType.Name == "VB")
{
return("__");
}
return(identifier);
}
public static string GetApplicationNamespaceName(ICodeDocumentType codeDocumentType, IProject project)
{
string str = Microsoft.Expression.Project.Build.CodeGenerator.GenerateIdentifierFromPath(codeDocumentType, project.DocumentReference.Path);
if (!string.IsNullOrEmpty(str))
{
return(str);
}
return("Application");
}
private ICodeDocumentType GetCodeDocumentTypeFromProject(IProjectStore projectStore)
{
ICodeDocumentType codeDocumentType;
string extension = Path.GetExtension(projectStore.DocumentReference.Path);
using (IEnumerator <IDocumentType> enumerator = this.Services.DocumentTypes().GetEnumerator())
{
while (enumerator.MoveNext())
{
ICodeDocumentType current = enumerator.Current as ICodeDocumentType;
if (current == null || StringComparer.OrdinalIgnoreCase.Compare(extension, current.ProjectFileExtension) != 0)
{
continue;
}
codeDocumentType = current;
return(codeDocumentType);
}
return(null);
}
return(codeDocumentType);
}
public static string GenerateIdentifierFromPath(ICodeDocumentType codeDocumentType, string fullPath)
{
string fileName;
if (!Microsoft.Expression.Framework.Documents.PathHelper.DirectoryExists(fullPath))
{
fileName = Path.GetFileName(fullPath);
if (fileName.Length > 1)
{
int num = fileName.IndexOf('.', 1);
if (num > 0)
{
fileName = fileName.Substring(0, num);
}
}
}
else
{
fileName = (new DirectoryInfo(fullPath)).Name;
}
return(Microsoft.Expression.Project.Build.CodeGenerator.MakeSafeIdentifier(codeDocumentType, fileName, false));
}
public static string GetSceneClassName(ICodeDocumentType codeDocumentType, IDocumentItem documentItem)
{
return(Microsoft.Expression.Project.Build.CodeGenerator.GenerateIdentifierFromPath(codeDocumentType, documentItem.DocumentReference.Path));
}
public new static IProject Create(IProjectStore projectStore, ICodeDocumentType codeDocumentType, IProjectType projectType, IServiceProvider serviceProvider)
{
return((IProject)KnownProjectBase.TryCreate((Func <KnownProjectBase>)(() => (KnownProjectBase) new WpfProject(projectStore, codeDocumentType, projectType, serviceProvider))));
}
private SilverlightProject(IProjectStore projectStore, ICodeDocumentType codeDocumentType, IProjectType projectType, IServiceProvider serviceProvider)
: base(projectStore, codeDocumentType, projectType, serviceProvider)
{
this.webServerService = serviceProvider.GetService <IWebServerService>();
}
public IEnumerable <INamedProject> CreateProjects(string name, string path, IEnumerable <TemplateArgument> templateArguments, IServiceProvider serviceProvider)
{
Uri uri;
IEnumerable <INamedProject> namedProjects;
ICodeDocumentType codeDocumentType = base.GetCodeDocumentType(serviceProvider);
if (templateArguments != null)
{
templateArguments = templateArguments.Concat <TemplateArgument>(TemplateManager.GetDefaultArguments(serviceProvider.ExpressionInformationService()));
}
else
{
templateArguments = TemplateManager.GetDefaultArguments(serviceProvider.ExpressionInformationService());
}
TemplateArgument templateArgument = new TemplateArgument("projectname", name);
if (!base.Template.TemplateData.CreateNewFolderSpecified || base.Template.TemplateData.CreateNewFolder)
{
path = Microsoft.Expression.Framework.Documents.PathHelper.ResolveCombinedPath(path, name);
Directory.CreateDirectory(path);
}
List <INamedProject> namedProjects1 = new List <INamedProject>();
Uri uri1 = null;
try
{
uri1 = new Uri(Microsoft.Expression.Framework.Documents.PathHelper.EnsurePathEndsInDirectorySeparator(path));
}
catch (UriFormatException uriFormatException)
{
namedProjects = namedProjects1;
return(namedProjects);
}
List <Uri> uris = new List <Uri>();
List <ProjectTemplate.FileToOpen> fileToOpens = new List <ProjectTemplate.FileToOpen>();
List <ProjectTemplate.SourceDestination> sourceDestinations = new List <ProjectTemplate.SourceDestination>();
string str = CodeGenerator.MakeSafeIdentifier(codeDocumentType, name, false);
string str1 = CodeGenerator.MakeSafeIdentifier(codeDocumentType, name, true);
TemplateArgument templateArgument1 = new TemplateArgument("safeprojectname", str);
TemplateArgument templateArgument2 = new TemplateArgument("safeprojectname", str1);
TemplateArgument templateArgument3 = new TemplateArgument("assemblyname", name);
TemplateArgument templateArgument4 = new TemplateArgument("safeassemblyname", name.Replace(' ', '\u005F'));
using (ProjectPathHelper.TemporaryDirectory temporaryDirectory = new ProjectPathHelper.TemporaryDirectory(true))
{
foreach (VSTemplateTemplateContentProject templateProject in this.TemplateProjects)
{
if (!string.IsNullOrEmpty(templateProject.File))
{
string targetFileName = templateProject.TargetFileName;
if (string.IsNullOrEmpty(targetFileName))
{
targetFileName = string.Concat(name, Path.GetExtension(templateProject.File));
}
TemplateArgument[] templateArgumentArray = new TemplateArgument[] { templateArgument, templateArgument1, templateArgument3, templateArgument4 };
IEnumerable <TemplateArgument> templateArguments1 = templateArguments.Concat <TemplateArgument>(templateArgumentArray);
uri = base.ResolveFileUri(targetFileName, uri1);
string str2 = TemplateParser.ReplaceTemplateArguments(uri.LocalPath, templateArguments1);
uri = new Uri(str2);
if (!string.IsNullOrEmpty(templateProject.File) && !base.IsDirectory(templateProject.File))
{
Uri uri2 = new Uri(temporaryDirectory.GenerateTemporaryFileName());
base.CreateFile(templateProject.File, base.TemplateLocation, uri2, templateProject.ReplaceParameters, templateArguments1);
ProjectTemplate.SourceDestination sourceDestination = new ProjectTemplate.SourceDestination()
{
Source = uri2,
Destination = uri
};
sourceDestinations.Add(sourceDestination);
}
}
else
{
uri = uri1;
}
foreach (Microsoft.Expression.Project.Templates.ProjectItem projectItem in templateProject.Items.OfType <Microsoft.Expression.Project.Templates.ProjectItem>())
{
string value = projectItem.TargetFileName;
if (string.IsNullOrEmpty(value))
{
value = projectItem.Value;
}
int num = projectItem.Value.IndexOf('.');
string str3 = (num != -1 ? projectItem.Value.Remove(num) : projectItem.Value);
bool flag = Path.GetExtension(projectItem.Value).Equals(codeDocumentType.DefaultFileExtension, StringComparison.OrdinalIgnoreCase);
string str4 = CodeGenerator.MakeSafeIdentifier(codeDocumentType, str3, flag);
TemplateArgument[] templateArgumentArray1 = new TemplateArgument[] { templateArgument, templateArgument3, templateArgument4, null, null, null };
templateArgumentArray1[3] = (flag ? templateArgument2 : templateArgument1);
templateArgumentArray1[4] = new TemplateArgument("safeitemname", str4);
templateArgumentArray1[5] = new TemplateArgument("safeitemrootname", str4);
TemplateArgument[] templateArgumentArray2 = templateArgumentArray1;
string str5 = TemplateParser.ReplaceTemplateArguments(value, templateArguments.Concat <TemplateArgument>(templateArgumentArray2));
Uri uri3 = base.ResolveFileUri(str5, uri1);
Uri uri4 = new Uri(temporaryDirectory.GenerateTemporaryFileName());
if (!base.CreateFile(projectItem.Value, base.TemplateLocation, uri4, projectItem.ReplaceParameters, templateArguments.Concat <TemplateArgument>(templateArgumentArray2)))
{
continue;
}
if (projectItem.OpenInEditorSpecified && projectItem.OpenInEditor)
{
ProjectTemplate.FileToOpen fileToOpen = new ProjectTemplate.FileToOpen()
{
ProjectFile = uri,
ProjectItem = uri3
};
fileToOpens.Add(fileToOpen);
}
ProjectTemplate.SourceDestination sourceDestination1 = new ProjectTemplate.SourceDestination()
{
Source = uri4,
Destination = uri3
};
sourceDestinations.Add(sourceDestination1);
}
uris.Add(uri);
}
foreach (ProjectTemplate.SourceDestination sourceDestination2 in sourceDestinations)
{
string localPath = sourceDestination2.Destination.LocalPath;
if (!Microsoft.Expression.Framework.Documents.PathHelper.FileOrDirectoryExists(localPath))
{
continue;
}
IMessageDisplayService messageDisplayService = serviceProvider.MessageDisplayService();
CultureInfo currentUICulture = CultureInfo.CurrentUICulture;
string cannotCreateTemplateDirectoryOrFileExistsMessage = StringTable.CannotCreateTemplateDirectoryOrFileExistsMessage;
object[] objArray = new object[] { localPath };
messageDisplayService.ShowError(string.Format(currentUICulture, cannotCreateTemplateDirectoryOrFileExistsMessage, objArray));
namedProjects = namedProjects1;
return(namedProjects);
}
foreach (ProjectTemplate.SourceDestination sourceDestination3 in sourceDestinations)
{
base.CreateFile(sourceDestination3.Source.LocalPath, new Uri(Path.GetDirectoryName(sourceDestination3.Source.LocalPath)), sourceDestination3.Destination, false, Enumerable.Empty <TemplateArgument>());
}
foreach (Uri uri5 in uris)
{
DocumentReference documentReference = DocumentReference.Create(uri5.LocalPath);
IProjectStore projectStore = null;
INamedProject namedProject = null;
try
{
projectStore = ProjectStoreHelper.CreateProjectStore(documentReference, serviceProvider, ProjectStoreHelper.DefaultProjectCreationChain);
namedProject = serviceProvider.ProjectManager().AddProject(projectStore);
}
finally
{
if (namedProject == null && projectStore != null)
{
projectStore.Dispose();
}
}
if (namedProject == null)
{
continue;
}
namedProjects1.Add(namedProject);
}
foreach (ProjectTemplate.FileToOpen fileToOpen1 in fileToOpens)
{
ISolution currentSolution = serviceProvider.ProjectManager().CurrentSolution;
if (currentSolution == null)
{
continue;
}
IProject project = currentSolution.Projects.FindMatchByUrl <IProject>(fileToOpen1.ProjectFile.LocalPath);
if (project == null)
{
continue;
}
IProjectItem projectItem1 = project.Items.FindMatchByUrl <IProjectItem>(fileToOpen1.ProjectItem.LocalPath);
if (projectItem1 == null)
{
continue;
}
projectItem1.OpenView(true);
}
return(namedProjects1);
}
return(namedProjects);
}
public abstract INamedProject CreateProject(IProjectStore projectStore, ICodeDocumentType codeDocumentType, IServiceProvider serviceProvider);
protected WindowsExecutableProject(IProjectStore projectStore, ICodeDocumentType codeDocumentType, IProjectType projectType, IServiceProvider serviceProvider) : base(projectStore, codeDocumentType, projectType, serviceProvider)
{
}
public IEnumerable <IProjectItem> CreateProjectItems(string name, string targetFolder, IProject project, IEnumerable <TemplateArgument> templateArguments, CreationOptions creationOptions, out List <IProjectItem> itemsToOpen, IServiceProvider serviceProvider)
{
Uri uri;
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
ICodeDocumentType codeDocumentType = base.GetCodeDocumentType(serviceProvider);
if (templateArguments != null)
{
templateArguments = templateArguments.Concat <TemplateArgument>(TemplateManager.GetDefaultArguments(serviceProvider.ExpressionInformationService()));
}
else
{
templateArguments = TemplateManager.GetDefaultArguments(serviceProvider.ExpressionInformationService());
}
IEnumerable <IProjectItem> projectItems = Enumerable.Empty <IProjectItem>();
itemsToOpen = new List <IProjectItem>();
using (ProjectPathHelper.TemporaryDirectory temporaryDirectory = new ProjectPathHelper.TemporaryDirectory(true))
{
Uri uri1 = new Uri(Microsoft.Expression.Framework.Documents.PathHelper.EnsurePathEndsInDirectorySeparator(temporaryDirectory.Path));
List <DocumentCreationInfo> documentCreationInfos = new List <DocumentCreationInfo>();
List <string> strs = new List <string>();
bool flag = false;
foreach (VSTemplateTemplateContentProjectItem templateProjectItem in this.TemplateProjectItems)
{
if (!templateProjectItem.OpenInEditorSpecified)
{
continue;
}
flag = true;
break;
}
bool flag1 = false;
string str = CodeGenerator.MakeSafeIdentifier(codeDocumentType, project.DocumentReference.DisplayNameShort, flag1);
bool flag2 = true;
string str1 = CodeGenerator.MakeSafeIdentifier(codeDocumentType, project.DocumentReference.DisplayNameShort, flag2);
TemplateArgument templateArgument = new TemplateArgument("safeprojectname", str);
TemplateArgument templateArgument1 = new TemplateArgument("safeprojectname", str1);
TemplateArgument templateArgument2 = new TemplateArgument("assemblyname", project.DocumentReference.DisplayNameShort);
TemplateArgument templateArgument3 = new TemplateArgument("safeassemblyname", project.DocumentReference.DisplayNameShort.Replace(' ', '\u005F'));
foreach (VSTemplateTemplateContentProjectItem vSTemplateTemplateContentProjectItem in this.TemplateProjectItems)
{
string targetFileName = vSTemplateTemplateContentProjectItem.TargetFileName;
if (string.IsNullOrEmpty(targetFileName))
{
targetFileName = vSTemplateTemplateContentProjectItem.Value;
}
TemplateArgument[] templateArgumentArray = new TemplateArgument[] { new TemplateArgument("fileinputname", Path.GetFileNameWithoutExtension(name)), new TemplateArgument("fileinputextension", Path.GetExtension(name)) };
IEnumerable <TemplateArgument> templateArguments1 = templateArgumentArray;
targetFileName = TemplateParser.ReplaceTemplateArguments(targetFileName, templateArguments1);
templateArguments1 = templateArguments1.Concat <TemplateArgument>(templateArguments);
bool flag3 = Path.GetExtension(vSTemplateTemplateContentProjectItem.Value).Equals(codeDocumentType.DefaultFileExtension, StringComparison.OrdinalIgnoreCase);
string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(Microsoft.Expression.Framework.Documents.PathHelper.GetFileOrDirectoryName(targetFileName));
if (serviceProvider.DocumentTypeManager().DocumentTypes[DocumentTypeNamesHelper.Xaml].IsDocumentTypeOf(fileNameWithoutExtension))
{
fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileNameWithoutExtension);
}
string str2 = CodeGenerator.MakeSafeIdentifier(codeDocumentType, fileNameWithoutExtension, flag3);
IEnumerable <TemplateArgument> templateArguments2 = templateArguments1;
TemplateArgument[] templateArgumentArray1 = new TemplateArgument[] { new TemplateArgument("rootnamespace", project.DefaultNamespaceName), new TemplateArgument("projectname", project.DocumentReference.DisplayNameShort), templateArgument2, templateArgument3, null, null, null, null };
templateArgumentArray1[4] = (flag3 ? templateArgument1 : templateArgument);
templateArgumentArray1[5] = new TemplateArgument("safeitemname", str2);
templateArgumentArray1[6] = new TemplateArgument("safeitemrootname", str2);
templateArgumentArray1[7] = new TemplateArgument("culture", (string.IsNullOrEmpty(project.UICulture) ? CultureInfo.CurrentUICulture.ToString() : project.UICulture));
templateArguments1 = templateArguments2.Concat <TemplateArgument>(templateArgumentArray1);
try
{
uri = base.ResolveFileUri(targetFileName, uri1);
}
catch (UriFormatException uriFormatException)
{
continue;
}
IDocumentType documentType = project.GetDocumentType(targetFileName);
foreach (IDocumentType documentType1 in serviceProvider.DocumentTypeManager().DocumentTypes)
{
if (vSTemplateTemplateContentProjectItem.SubType != documentType1.Name)
{
continue;
}
documentType = documentType1;
}
if (!base.CreateFile(vSTemplateTemplateContentProjectItem.Value, base.TemplateLocation, uri, vSTemplateTemplateContentProjectItem.ReplaceParameters, templateArguments1))
{
continue;
}
string str3 = ProjectItemTemplate.AdjustTargetFolder(targetFolder, uri1.LocalPath, uri.LocalPath);
DocumentCreationInfo documentCreationInfo = new DocumentCreationInfo()
{
SourcePath = uri.LocalPath,
TargetFolder = str3,
DocumentType = documentType,
CreationOptions = creationOptions
};
documentCreationInfos.Add(documentCreationInfo);
if (!flag)
{
if (strs.Count > 0)
{
continue;
}
strs.Add(Path.Combine(str3, Path.GetFileName(uri.LocalPath)));
}
else
{
if (!vSTemplateTemplateContentProjectItem.OpenInEditor)
{
continue;
}
strs.Add(Path.Combine(str3, Path.GetFileName(uri.LocalPath)));
}
}
if (documentCreationInfos.Count > 0)
{
projectItems = project.AddItems(documentCreationInfos);
}
if (projectItems.Any <IProjectItem>())
{
for (int i = 0; i < strs.Count; i++)
{
IProjectItem projectItem = projectItems.FirstOrDefault <IProjectItem>((IProjectItem item) => item.DocumentReference.Path.Equals(strs[i], StringComparison.OrdinalIgnoreCase));
if (projectItem != null)
{
itemsToOpen.Add(projectItem);
}
}
projectItems = projectItems.Concat <IProjectItem>(this.AddAssemblies(project));
}
}
if (base.BuildOnLoad)
{
IProjectManager projectManager = serviceProvider.ProjectManager();
IProjectBuildContext activeBuildTarget = projectManager.ActiveBuildTarget;
projectManager.BuildManager.Build(activeBuildTarget, null, true);
KnownProjectBase knownProjectBase = project as KnownProjectBase;
if (knownProjectBase != null)
{
knownProjectBase.CheckForChangedOrDeletedItems();
}
}
return(projectItems);
}
public override INamedProject CreateProject(IProjectStore projectStore, ICodeDocumentType codeDocumentType, IServiceProvider serviceProvider)
{
return(WindowsExecutableProject.Create(projectStore, codeDocumentType, this, serviceProvider));
}
protected XamlProject(IProjectStore projectStore, ICodeDocumentType codeDocumentType, IProjectType projectType, IServiceProvider serviceProvider)
: base(projectStore, codeDocumentType, projectType, serviceProvider)
{
}
protected ExecutableProjectBase(Microsoft.Expression.Project.IProjectStore projectStore, ICodeDocumentType codeDocumentType, IProjectType projectType, IServiceProvider serviceProvider) : base(projectStore, codeDocumentType, projectType, serviceProvider)
{
}
public override INamedProject CreateProject(IProjectStore projectStore, ICodeDocumentType codeDocumentType, IServiceProvider serviceProvider)
{
return((INamedProject)WpfProject.Create(projectStore, codeDocumentType, (IProjectType)this, serviceProvider));
}
public override INamedProject CreateProject(IProjectStore projectStore, ICodeDocumentType codeDocumentType, IServiceProvider serviceProvider)
{
return(WebApplicationProject.Create(projectStore, codeDocumentType, this, serviceProvider));
}
public static IProject Create(IProjectStore projectStore, ICodeDocumentType codeDocumentType, IProjectType projectType, IServiceProvider serviceProvider)
{
return(KnownProjectBase.TryCreate(() => new WebApplicationProject(projectStore, codeDocumentType, projectType, serviceProvider)));
}
public override INamedProject CreateProject(IProjectStore projectStore, ICodeDocumentType codeDocumentType, IServiceProvider serviceProvider)
{
return(new UnknownProject(projectStore, serviceProvider));
}
public static new IProject Create(IProjectStore projectStore, ICodeDocumentType codeDocumentType, IProjectType projectType, IServiceProvider serviceProvider)
{
return(KnownProjectBase.TryCreate(() => new SilverlightProject(projectStore, codeDocumentType, projectType, serviceProvider)));
}
private WpfProject(IProjectStore projectStore, ICodeDocumentType codeDocumentType, IProjectType projectType, IServiceProvider serviceProvider)
: base(projectStore, codeDocumentType, projectType, serviceProvider)
{
}
