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