public override void Compile(ICompileContext context, IProjectItem projectItem)
{
var rendering = projectItem as Rendering;
if (rendering == null)
{
return;
}
var project = rendering.Project;
var snapshot = rendering.Snapshots.First();
var snapshotTextNode = new SnapshotTextNode(snapshot);
var guid = StringHelper.GetGuid(project, rendering.ItemPath);
var item = context.Factory.Item(project, snapshotTextNode, guid, rendering.DatabaseName, rendering.ItemName, rendering.ItemPath, rendering.TemplateIdOrPath);
item.ItemNameProperty.AddSourceTextNode(new FileNameTextNode(rendering.ItemName, snapshot));
item.OverwriteWhenMerging = true;
var field = context.Factory.Field(item, snapshotTextNode, "Path", rendering.FilePath);
field.ValueProperty.Flags = SourcePropertyFlags.IsFileName;
item.Fields.Add(field);
item.References.Add(new FileReference(item, field.ValueProperty));
if (rendering.Placeholders.Any())
{
var placeholdersField = context.Factory.Field(item, TextNode.Empty, "Place Holders", string.Join(",", rendering.Placeholders));
item.Fields.Add(placeholdersField);
}
var addedItem = rendering.Project.AddOrMerge(item);
rendering.RenderingItemUri = addedItem.Uri;
}
public override void Emit(IEmitContext context, IProjectItem projectItem)
{
var unicornFile = projectItem as UnicornFile;
Assert.Cast(unicornFile, nameof(unicornFile));
var snapshot = unicornFile.Snapshots.First();
// todo: use real Unicorn configuration instead of hacking it
var log = new TraceLogger(context.Trace);
var logger = new DefaultDeserializerLogger(log);
var fieldFilter = new AllFieldFilter();
var defaultDeserializer = new DefaultDeserializer(logger, fieldFilter);
// todo: file has already been read and parsed - do not read it again
var formatter = new YamlSerializationFormatter(null, null);
using (var stream = new FileStream(snapshot.SourceFile.AbsoluteFileName, FileMode.Open))
{
var serializedItem = formatter.ReadSerializedItem(stream, unicornFile.ShortName);
if (string.IsNullOrEmpty(serializedItem.DatabaseName))
{
serializedItem.DatabaseName = unicornFile.DatabaseName;
}
try
{
defaultDeserializer.Deserialize(serializedItem);
}
catch (Exception ex)
{
throw new RetryableEmitException(Texts.Failed_to_deserialize_item, unicornFile.Snapshots.First(), ex.Message);
}
}
}
public FolderModel(IProjectItem parent, string name)
{
Parent = parent;
Name = name;
RelativePath = Path.Combine(parent.RelativePath, name) + "/";
Children = new List<IProjectItem>();
}
public override void Compile(ICompileContext context, IProjectItem projectItem)
{
var serializationFile = projectItem as SerializationFile;
if (serializationFile == null)
{
return;
}
var textDocument = (ITextSnapshot)serializationFile.Snapshots.First();
var rootTextNode = textDocument.Root;
if (rootTextNode == TextNode.Empty)
{
context.Trace.TraceError(Msg.C1050, Texts.Document_is_not_valid, textDocument.SourceFile.AbsoluteFileName, TextSpan.Empty);
return;
}
var lines = textDocument.SourceFile.ReadAsLines();
var itemBuilder = context.Factory.ItemBuilder();
ParseItem(context, textDocument, itemBuilder, lines, 0);
var item = itemBuilder.Build(serializationFile.Project, rootTextNode);
item.IsEmittable = false;
var addedItem = serializationFile.Project.AddOrMerge(item);
serializationFile.SerializationItemUri = addedItem.Uri;
}
/// <summary>
/// Initializes a new instance of the <see cref="RuleViewModel" /> class.
/// </summary>
/// <param name="rootProject">The root project this rule belongs to.</param>
/// <param name="rule">The rule.</param>
/// <param name="visualStudioService">The visual studio service.</param>
/// <param name="uiVisualizerService">The UI visualizer service.</param>
/// <exception cref="ArgumentNullException">The <paramref name="rootProject" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="rootProject" /> is <c>null</c>.</exception>
public RuleViewModel(RootProject rootProject, Rule rule, IVisualStudioService visualStudioService, IUIVisualizerService uiVisualizerService)
{
Argument.IsNotNull(() => rootProject);
Argument.IsNotNull(() => rule);
Argument.IsNotNull(() => visualStudioService);
Argument.IsNotNull(() => uiVisualizerService);
_uiVisualizerService = uiVisualizerService;
var project = visualStudioService.GetProjectByName(rootProject.Name);
if (project != null)
{
_rootProjectItem = new ProjectItem(project);
}
Rule = rule;
RuleTypes = Enum<RuleType>.ToList();
ProjectTypes = new ObservableCollection<SelectableProjectType>();
foreach (var projectType in ProjectTypeHelper.GetAvailableProjectTypes())
{
bool isSelected = rule.ProjectTypes.Contains(projectType);
var selectableProjectType = new SelectableProjectType(projectType, isSelected);
this.SubscribeToWeakPropertyChangedEvent(selectableProjectType, OnSelectableProjectTypePropertyChanged);
ProjectTypes.Add(selectableProjectType);
}
SelectProjectItem = new Command(OnSelectProjectItemExecute, OnSelectProjectItemCanExecute);
}
/// <summary>
/// Searches directories of the project items project file and the parents thereof to see
/// if a Settings file exists.
/// </summary>
/// <param name="projectItem">
/// File being examined.
/// </param>
/// <returns>
/// Path to the settings file.
/// </returns>
public string FindSettingsFilePath(IProjectItem projectItem)
{
StyleCopTrace.In(projectItem);
string cacheKey = string.Format("{0}::{1}", "FindSettingsFilePath", projectItem.Location.FullPath.ToLowerInvariant());
string settings;
if (StringCache.TryGetValue(cacheKey, out settings))
{
StyleCopTrace.Out();
return settings;
}
IProject projectFile = projectItem.GetProject();
string result = this.FindSettingsFilePath(projectFile);
// TODO: This is adding a watcher for settings.stylecop in the folder of the source file
// This is creating a watcher for *ALL* source files that are monitored!
this.AddWatcherForSettingsFile(projectItem.Location.FullPath);
StringCache[cacheKey] = result;
return StyleCopTrace.Out(result);
}
bool IMvcQuickFixTemplateProvider.IsAvailable(IProjectItem context)
{
// ReSharper will suggest the "default" quickfix items for MVC-like projects, which include ASPX views generation.
// ASPX views are not used in Nancy, so we return false here to prevent R# from suggesting them.
return false;
}
protected override void Merge(IProjectItem newProjectItem, bool overwrite)
{
base.Merge(newProjectItem, overwrite);
var newItemBase = newProjectItem as DatabaseProjectItem;
Assert.Cast(newItemBase, nameof(newItemBase));
if (overwrite)
{
ItemNameProperty.SetValue(newItemBase.ItemNameProperty);
ItemIdOrPath = newItemBase.ItemIdOrPath;
DatabaseName = newItemBase.DatabaseName;
}
if (!string.IsNullOrEmpty(newItemBase.DatabaseName))
{
DatabaseName = newItemBase.DatabaseName;
}
if (!string.IsNullOrEmpty(newItemBase.Icon))
{
IconProperty.SetValue(newItemBase.IconProperty, SetValueOptions.DisableUpdates);
}
IsEmittable = IsEmittable || newItemBase.IsEmittable;
IsImport = IsImport || newItemBase.IsImport;
References.AddRange(newItemBase.References);
}
public override void Compile(ICompileContext context, IProjectItem projectItem)
{
var include = context.Configuration.GetString(Constants.Configuration.BuildProjectCompileBinFilesInclude);
if (string.IsNullOrEmpty(include))
{
return;
}
var binFile = projectItem as BinFile;
Assert.Cast(binFile, nameof(binFile));
var exclude = context.Configuration.GetString(Constants.Configuration.BuildProjectCompileBinFilesExclude);
var pathMatcher = new PathMatcher(include, exclude);
if (!pathMatcher.IsMatch(binFile.FilePath))
{
return;
}
try
{
var assembly = Assembly.LoadFrom(binFile.Snapshots.First().SourceFile.AbsoluteFileName);
foreach (var type in assembly.GetExportedTypes())
{
context.Pipelines.Resolve<BinFileCompilerPipeline>().Execute(context, binFile, type);
}
}
catch (Exception ex)
{
context.Trace.TraceError(Msg.C1059, ex.Message, binFile.FilePath);
}
}
protected override void ParseRenderingReferences(ItemParseContext context, ICollection<IReference> references, IProjectItem projectItem, ITextNode renderingTextNode)
{
var childNode = renderingTextNode.ChildNodes.FirstOrDefault();
if (childNode != null)
{
base.ParseRenderingReferences(context, references, projectItem, childNode);
}
}
public override void Emit(IEmitContext context, IProjectItem projectItem)
{
var item = projectItem as Item;
Assert.Cast(item, nameof(item));
if (!item.IsEmittable || item.IsImport)
{
return;
}
var templateIdOrPath = ResolveTemplateIdOrPath(item);
if (string.IsNullOrEmpty(templateIdOrPath))
{
throw new RetryableEmitException(Texts.Template_missing, TraceHelper.GetTextNode(item.TemplateIdOrPathProperty, item.ItemNameProperty), item.TemplateIdOrPath);
}
var database = Factory.GetDatabase(item.DatabaseName);
var templateItem = database.GetItem(templateIdOrPath);
if (string.IsNullOrEmpty(templateIdOrPath))
{
throw new RetryableEmitException(Texts.Template_missing, TraceHelper.GetTextNode(item.TemplateIdOrPathProperty), item.TemplateIdOrPath);
}
var template = TemplateManager.GetTemplate(templateItem.ID, templateItem.Database);
if (template == null)
{
throw new RetryableEmitException(Texts.Template_missing, TraceHelper.GetTextNode(item.TemplateIdOrPathProperty), item.TemplateIdOrPath);
}
// todo: convert to pipeline
ValidateFields(database, template, item);
var itemWriter = new ItemWriter
{
Snapshot = item.Snapshots.First(),
DatabaseName = item.DatabaseName,
Guid = projectItem.Uri.Guid,
ItemName = item.ItemName,
ItemIdOrPath = item.ItemIdOrPath,
TemplateIdOrPath = templateIdOrPath
};
foreach (var field in item.Fields)
{
var templateField = template.GetField(field.FieldName);
if (templateField == null)
{
throw new RetryableEmitException(Texts.Template_field_missing, TraceHelper.GetTextNode(field.FieldNameProperty, item.ItemNameProperty), field.FieldName);
}
var fieldWriter = new FieldWriter(field.FieldIdProperty, field.FieldNameProperty, field.Language, field.Version, field.CompiledValue);
itemWriter.Fields.Add(fieldWriter);
}
var dataItem = itemWriter.Write(context);
Check(context, item, dataItem);
}
public override void Emit(IEmitContext context, IProjectItem projectItem)
{
var configFile = (ConfigFile)projectItem;
var destinationFileName = FileUtil.MapPath(configFile.FilePath);
context.FileSystem.CreateDirectoryFromFileName(destinationFileName);
context.FileSystem.Copy(projectItem.Snapshots.First().SourceFile.AbsoluteFileName, destinationFileName, context.ForceUpdate);
}
public DocumentModel(IProjectItem parent, string name, int numberOfLines)
{
Parent = parent;
Name = name;
RelativePath = Path.Combine(parent.RelativePath, name); ;
NumberOfLines = numberOfLines;
Children = new List<IProjectItem>();
Tokens = new List<Token>();
}
/// <summary>
/// Initializes a new instance of the <see cref="SelectProjectItemViewModel" /> class.
/// </summary>
/// <param name="rootProjectItem">The root Project Item.</param>
/// <exception cref="ArgumentNullException">The <paramref name="rootProjectItem" /> is <c>null</c>.</exception>
public SelectProjectItemViewModel(IProjectItem rootProjectItem)
{
Argument.IsNotNull("rootProjectItem", rootProjectItem);
RootProjectItems = new List<IProjectItem>();
foreach (var projectItem in rootProjectItem.ProjectItems)
{
RootProjectItems.Add(projectItem);
}
}
public TextItemViewModel(IProjectItem item)
{
Item = item;
Title = "Item: " + Item.Name;
MenuItems = new BindableCollection<MenuItemViewModel> {
new MenuItemViewModel {
Header = "_hello"
}
};
}
public override bool CanCompile(ICompileContext context, IProjectItem projectItem)
{
var item = projectItem as Item;
if (item == null)
{
return false;
}
return item.SourceTextNodes.Select(n => n.GetAttributeValue("Template.CreateFromFields")).Any(value => string.Equals(value, "true", StringComparison.OrdinalIgnoreCase));
}
protected void RemoveProjectItemNode(IProjectItem projectItem)
{
foreach (ItemNode node in Nodes)
{
if (node is IProjectItemNode && ((IProjectItemNode)node).ProjectItem == projectItem)
{
node.Delete();
return;
}
}
}
public ProjectItem(EnvDTE.ProjectItem projectItem, IProjectItem parent = null)
{
Argument.IsNotNull("projectItem", projectItem);
Initialize(projectItem.GetObjectName(), projectItem.IsFolder() ? ProjectItemType.Folder : ProjectItemType.File, parent);
foreach (EnvDTE.ProjectItem subProjectItem in projectItem.ProjectItems)
{
ProjectItems.Add(new ProjectItem(subProjectItem, this));
}
}
public override void Emit(IEmitContext context, IProjectItem projectItem)
{
var template = (Template)projectItem;
if (!template.IsEmittable || template.IsImport)
{
return;
}
var templateWriter = new TemplateWriter(template);
templateWriter.Write(context);
}
public override void Compile(ICompileContext context, IProjectItem projectItem)
{
var item = projectItem as Item;
Assert.Cast(item, nameof(item));
var fileName = item.GetValue<string>(LayoutPage)?.Trim() ?? string.Empty;
if (string.IsNullOrEmpty(fileName))
{
return;
}
var property = item.GetProperty<string>(LayoutPage);
// find page html file
var rendering = item.Project.Files.FirstOrDefault(i => string.Equals(i.FilePath, fileName, StringComparison.OrdinalIgnoreCase));
if (rendering == null)
{
context.Trace.TraceError(Msg.C1047, Texts.Rendering_reference_not_found, TraceHelper.GetTextNode(property), fileName);
}
// find MvcLayout
var layoutItem = item.Project.ProjectItems.OfType<Item>().FirstOrDefault(i => i.ItemIdOrPath == "/sitecore/layout/Layouts/MvcLayout");
if (layoutItem == null)
{
context.Trace.TraceError(Msg.C1048, Texts.Layout_reference_not_found, TraceHelper.GetTextNode(property), "/sitecore/layout/Layouts/MvcLayout");
}
if (rendering == null || layoutItem == null)
{
return;
}
var sourceFile = rendering.Snapshots.First().SourceFile;
var writer = new StringWriter();
var output = new XmlTextWriter(writer);
output.Formatting = Formatting.Indented;
var buildContext = new BuildContext(context, sourceFile, output, item, layoutItem);
var literalRendering = FindRendering(buildContext, "Literal", string.Empty, TextSpan.Empty);
if (literalRendering == null)
{
return;
}
buildContext.Placeholder = layoutItem["Place Holders"];
buildContext.LiteralRendering = literalRendering;
ParseHtml(buildContext);
SetRenderingsField(buildContext, buildContext.Item, writer.ToString());
}
public override void Emit(IEmitContext context, IProjectItem projectItem)
{
var binFile = (BinFile)projectItem;
var destinationFileName = FileUtil.MapPath(binFile.FilePath);
if (!CanCopyBinFile(context, binFile, destinationFileName))
{
return;
}
context.FileSystem.CreateDirectory(Path.GetDirectoryName(destinationFileName) ?? string.Empty);
context.FileSystem.Copy(projectItem.Snapshots.First().SourceFile.AbsoluteFileName, destinationFileName, context.ForceUpdate);
}
private Language InferLanguage(IProjectItem document) {
try {
var language = InferLanguageFromContent(document);
if (language != null) return language.Value;
}
catch (Exception) { }
try {
var language = InferLanguageFromCodebehindExtension(document);
if (language != null) return language.Value;
}
catch (Exception) { }
return Language.CSharp;
}
protected override string GetPlaceholders(LayoutCompileContext context, ITextNode renderingTextNode, IProjectItem projectItem)
{
var childTextNode = renderingTextNode;
/*
if (childTextNode.ParentNode != null && childTextNode.ParentNode.Key == "Renderings")
{
childTextNode = childTextNode.ChildNodes.FirstOrDefault();
if (childTextNode == null)
{
return string.Empty;
}
}
*/
return base.GetPlaceholders(context, childTextNode, projectItem);
}
public override void Compile(ICompileContext context, IProjectItem projectItem)
{
var unicornFile = projectItem as UnicornFile;
Assert.Cast(unicornFile, nameof(unicornFile));
var snapshot = unicornFile.Snapshots.First();
try
{
CompileUnicornFile(context, snapshot, unicornFile);
}
catch (NotImplementedException)
{
// using stub Sitecore.Kernel assembly in unit tests
}
}
private static Language? InferLanguageFromContent(IProjectItem document) {
using (var reader = new StreamReader(((IDocumentProjectItem)document).GetContents())) {
var regex = new Regex(@"<%@.*Language=""(?<lang>[^""]*)"".*%>");
string line;
while ((line = reader.ReadLine()) != null) {
var match = regex.Match(line).Groups["lang"];
if (match.Success) {
switch (match.Value.ToLowerInvariant()) {
case "c#": return Language.CSharp;
case "vb": return Language.VB;
}
}
}
}
return null;
}
/// <summary>
/// 添加项到项目
/// </summary>
public static bool AppendItem(IProjectItem item, bool performMove)
{
string folderName = ProjectHost.CurrentProject.Root;
if (!ProjectItemType.References.Contains(item.ItemType))
{
var copiedFileName = Path.Combine(folderName, Path.GetFileName(item.FileName));
}
if (!AppendItem(item, folderName, performMove))
{
throw new ProjectHostException("添加文件到项目失败.");
}
return true;
}
public static IWalker GetWalker(IProjectItem parent, Document document, ReferencesourceLinkProvider refSourceLinkProvider)
{
var fileExtension = Path.GetExtension(document.FilePath);
if (String.IsNullOrEmpty(fileExtension))
{
return null;
}
if (fileExtension == ".cs")
{
return new DocumentWalker<CSWalkerUtils>(parent, document, refSourceLinkProvider, (w) => new CSWalkerUtils(w));
}
else if (fileExtension == ".vb")
{
return new DocumentWalker<VBWalkerUtils>(parent, document, refSourceLinkProvider, (w) => new VBWalkerUtils(w));
}
return null;
}
public override void Emit(IEmitContext context, IProjectItem projectItem)
{
var itemModel = (SerializationFile)projectItem;
try
{
var item = DoLoadItem(itemModel.Snapshots.First().SourceFile.AbsoluteFileName, LoadOptions);
if (item == null)
{
throw new RetryableEmitException(Texts.Failed_to_deserialize_item, itemModel.Snapshots.First(), "Item not created");
}
}
catch (Exception ex)
{
throw new RetryableEmitException(Texts.Failed_to_deserialize_item, itemModel.Snapshots.First(), ex.Message);
}
}
public override void Emit(IEmitContext context, IProjectItem projectItem)
{
var template = (Template)projectItem;
if (!template.IsEmittable || template.IsImport)
{
return;
}
var templateWriter = new TemplateWriter(template);
var dataItem = templateWriter.Write(context);
if (dataItem != null)
{
Check(context, template, dataItem);
}
}
public override void Emit(IEmitContext context, IProjectItem projectItem)
{
var mediaFile = (MediaFile)projectItem;
var mediaItem = context.Project.FindQualifiedItem(mediaFile.MediaItemUri) as Projects.Items.Item;
if (mediaItem == null)
{
context.Trace.TraceError(Msg.E1004, Texts.Media_item_not_found, new SnapshotTextNode(mediaFile.Snapshots.First()), mediaFile.MediaItemUri.Guid.Format());
return;
}
if (mediaFile.UploadMedia)
{
UploadFile(context, mediaItem, mediaFile);
return;
}
CopyFile(context, mediaFile);
}
public void Open(IProjectItem item)
{
_eventAggregator.Publish(new OpenItemCommand(item));
}
public override void CloseDocument(IProjectItem projectItem, IProject project)
{
this.codeProjectService.GetCodeProject(project).DeactivateEditing(projectItem.DocumentReference);
}
private void Init(ProjectItemRenameError error, IProjectItem projectItem, string attemptedName)
{
this.Error = error;
this.ProjectItem = projectItem;
this.AttemptedName = attemptedName;
}
public WarningItem(IProjectItem item, string propertyName, string format)
{
this.item = item;
this.propertyName = propertyName;
this.format = format;
}
public virtual void RemoveChild(IProjectItem child)
{
child.Parent = null;
this.children.Remove(child);
}
public override int CompareTo(IProjectItem other)
{
return(Name.CompareTo(other.Name));
}
public LayoutReference([NotNull] IProjectItem owner, [NotNull] SourceProperty <string> sourceProperty, [NotNull] string referenceText, [NotNull] string databaseName) : base(owner, sourceProperty, referenceText, databaseName)
{
}
public Task <ProjectItem> SetItemTypeOfOwnedSourceItemAsync(IProjectItem projectItem, string newItemType)
{
return(GetMsBuildItemByProjectItem(projectItem));
}
public void SetTreeRoot(IProjectItem item)
{
projectControl.SetRoot(item);
}
private IProjectItem AddItemDuringLoad(IDocumentType documentType, Microsoft.Expression.Framework.Documents.DocumentReference documentReference, IProjectItem parentItem)
{
IProjectItem projectItem = base.FindItem(documentReference) ?? documentType.CreateProjectItem(this, documentReference, base.Services);
return(this.AddItemDuringLoad(projectItem, parentItem));
}
protected override void ProcessNewlyAddedProjectItem(IProjectItem projectItem)
{
this.PlaceItemInFolder(projectItem);
base.OnItemAdded(new ProjectItemEventArgs(projectItem));
}
public void UpdateProperties(IProjectItem item)
{
UpdateMenus();
}
public void UpdateTreeItem(IProjectItem item)
{
}
public void AddTreeItem(IProjectItem item)
{
projectview1.AddItem(projectview1.GetBaseIter(), item.OriginalPath, item.Exists, false, expand, _controller.GetFullPath(item.OriginalPath));
}
public void AddItem(IProjectItem citem)
{
AddItem(_treeRoot, citem, citem.OriginalPath, "");
}
public void AddTreeItem(IProjectItem item)
{
projectControl.AddItem(item);
}
public bool Remove(IProjectItem projectItem) => ProjectItems.Remove(projectItem);
public void RemoveTreeItem(IProjectItem item)
{
projectControl.RemoveItem(item);
}
public void AddNewFile(IProjectItem projectItem)
{
CreateAndFillWithContentFile(projectItem.FilePath, projectItem.Content);
AddFileToProjest(projectItem.ProjectPath, projectItem.FilePath);
}
public void UpdateTreeItem(IProjectItem item)
{
projectControl.UpdateItem(item);
}
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 Task <ProjectItem> RenameOwnedSourceItemAsync(IProjectItem projectItem, string newValue)
{
return(GetMsBuildItemByProjectItem(projectItem));
}
public override bool CanCompile(ICompileContext context, IProjectItem projectItem) => projectItem is MediaFile;
private void CacheStateIfNecessary()
{
if (this.eventHandlers != null)
{
return;
}
this.eventHandlers = (ICollection <EventHandlerModel>) new List <EventHandlerModel>();
this.solution = this.designerContext.ProjectManager.CurrentSolution;
this.project = ProjectHelper.GetProject(this.designerContext.ProjectManager, this.document.DocumentContext);
if (this.project == null)
{
return;
}
ITypeId typeId = (ITypeId)this.document.XamlDocument.CodeBehindClass;
if (typeId == null)
{
this.state = EventsModel.State.NoCodeBehind;
}
else
{
if (this.node == null)
{
return;
}
IProjectItem projectItem = this.project.FindItem(this.document.DocumentReference);
if (projectItem == null)
{
return;
}
IProjectItem codeBehindItem = projectItem.CodeBehindItem;
if (codeBehindItem == null)
{
this.state = EventsModel.State.NoCodeBehind;
}
else
{
ICodeGeneratorHost codeGeneratorHost = codeBehindItem.DocumentType as ICodeGeneratorHost;
if (codeGeneratorHost == null)
{
return;
}
ITypeDeclaration typeInFile = this.designerContext.CodeModelService.FindTypeInFile((object)this.solution, (object)codeBehindItem, (IEnumerable <string>)EventsModel.Model.GetProjectItemPath(codeBehindItem), typeId.FullName);
CodeDomProvider codeDomProvider = codeGeneratorHost.CodeDomProvider;
EventHandlerProvider eventHandlerProvider = new EventHandlerProvider(this.designerContext, this.document, typeInFile);
this.state = EventsModel.State.Enabled;
IProjectContext projectContext = this.document.ProjectContext;
IType type = this.node.Type;
List <EventInformation> list = new List <EventInformation>(EventInformation.GetEventsForType((ITypeResolver)projectContext, type, MemberType.LocalEvent));
EventDescriptorCollection events = TypeUtilities.GetEvents(type.RuntimeType);
list.Sort(new Comparison <EventInformation>(EventInformation.CompareNames));
foreach (EventInformation eventInfo in list)
{
EventDescriptor eventDescriptor = events[eventInfo.EventName];
AttributeCollection eventAttributes = eventDescriptor != null?TypeUtilities.GetAttributes((MemberDescriptor)eventDescriptor) : (AttributeCollection)null;
this.eventHandlers.Add(new EventHandlerModel(eventInfo, this.node, codeDomProvider, (IEventHandlerProvider)eventHandlerProvider, eventAttributes));
}
}
}
}
public Task RemoveAsync(IProjectItem item, DeleteOptions deleteOptions = DeleteOptions.None)
{
return(RemoveAsync(item.ItemType, item.UnevaluatedInclude, deleteOptions));
}
async public void snippets_ProjectItems()
{
#region Reference layout project items
//A layout project item is an item that appears in the Layouts folder in the Catalog pane
//Reference all the layout project items
IEnumerable <LayoutProjectItem> layouts = Project.Current.GetItems <LayoutProjectItem>();
//Or reference a specific layout project item by name
LayoutProjectItem layoutItem = Project.Current.GetItems <LayoutProjectItem>().FirstOrDefault(item => item.Name.Equals("MyLayout"));
#endregion
#region Open a layout project item in a new view
//A layout project item may be in a project but it may not be open in a view and/or active
//First get the layout associated with the layout project item
Layout layout = layoutItem.GetLayout();
//Open a new pane
ILayoutPane iNewLayoutPane = await ProApp.Panes.CreateLayoutPaneAsync(layout);
#endregion
#region Activate an already open layout view
//A layout view may exist but it may not be active
//Iterate through each pane in the application and check to see if the layout is already open and if so, activate it
foreach (var pane in ProApp.Panes)
{
var layoutPane = pane as ILayoutPane;
if (layoutPane == null) //if not a layout view, continue to the next pane
{
continue;
}
if (layoutPane.LayoutView.Layout == layout) //if there is a match, activate the view
{
(layoutPane as Pane).Activate();
return;
}
}
#endregion
#region Reference the active layout view
//First check to see if the current, active view is a layout view. If it is, use it
LayoutView activeLayoutView = LayoutView.Active;
if (activeLayoutView != null)
{
// use activeLayoutView
}
#endregion
#region Create a new, basic layout and open it
//Create a new layout project item layout in the project
Layout newLayout = await QueuedTask.Run <Layout>(() =>
{
newLayout = LayoutFactory.Instance.CreateLayout(8.5, 11, LinearUnit.Inches);
newLayout.SetName("New 8.5x11 Layout");
return(newLayout);
});
//Open new layout on the GUI thread
await ProApp.Panes.CreateLayoutPaneAsync(newLayout);
#endregion
#region Create a new layout using a modified CIM and open it
//Create a new layout project item layout in the project
Layout newCIMLayout = await QueuedTask.Run <Layout>(() =>
{
//Set up a CIM page
CIMPage newPage = new CIMPage
{
//required parameters
Width = 8.5,
Height = 11,
Units = LinearUnit.Inches,
//optional rulers
ShowRulers = true,
SmallestRulerDivision = 0.5,
//optional guides
ShowGuides = true
};
CIMGuide guide1 = new CIMGuide
{
Position = 1,
Orientation = Orientation.Vertical
};
CIMGuide guide2 = new CIMGuide
{
Position = 6.5,
Orientation = Orientation.Vertical
};
CIMGuide guide3 = new CIMGuide
{
Position = 1,
Orientation = Orientation.Horizontal
};
CIMGuide guide4 = new CIMGuide
{
Position = 10,
Orientation = Orientation.Horizontal
};
List <CIMGuide> guideList = new List <CIMGuide>
{
guide1,
guide2,
guide3,
guide4
};
newPage.Guides = guideList.ToArray();
//Create a new page
newCIMLayout = LayoutFactory.Instance.CreateLayout(newPage);
newCIMLayout.SetName("New 8.5x11 Layout");
return(newCIMLayout);
});
//Open new layout on the GUI thread
await ProApp.Panes.CreateLayoutPaneAsync(newCIMLayout);
#endregion
#region Import a pagx into a project
//Create a layout project item from importing a pagx file
IProjectItem pagx = ItemFactory.Instance.Create(@"C:\Temp\Layout.pagx") as IProjectItem;
Project.Current.AddItem(pagx);
#endregion
#region Remove a layout project item
//Remove a layout from the project completely
Project.Current.RemoveItem(layoutItem);
#endregion
}
private IDocument CreateDocument(IProjectItem projectItem, IProject project, Stream stream, Encoding encoding, bool isReadOnly)
{
return((IDocument) new CodeDocument(projectItem.DocumentReference, isReadOnly, encoding, stream, this.CodeDomProvider, this, this.codeProjectService, this.codeProjectService.GetCodeProject(project), project, this.viewService, this.windowService));
}
public IEnumerable <IRuleViolation> Evaluate(IProjectItem target)
{
return(Enumerable.Empty <RuleViolation>());
}
public abstract int CompareTo(IProjectItem other);
public ProjectItemEventArgs(IProjectItem projectItem)
{
this.projectItem = projectItem;
}
