public MockOpenedFile(string fileName, bool isUntitled) { base.FileName = FileName.Create(fileName); base.IsUntitled = isUntitled; }
static void AddTask(string fileName, string message, int column, int line, TaskType taskType) { TaskService.Add(new Task(FileName.Create(fileName), message, column, line, taskType)); }
void listViewHyperlinkClick(object sender, RoutedEventArgs e) { RecentOpenItem item = (RecentOpenItem)((Hyperlink)sender).Tag; SD.ProjectService.OpenSolutionOrProject(FileName.Create(item.Path)); }
public ProvidedDocumentInformation(IDocument document, string fileName, int currentOffset) { this.document = document; this.fileName = FileName.Create(fileName); this.endOffset = this.currentOffset = currentOffset; }
public ITextSource GetFileContent(string fileName) { return(GetFileContent(FileName.Create(fileName))); }
public static bool IsOpen(string fileName) { return(SD.FileService.IsOpen(FileName.Create(fileName))); }
/// <summary> /// Opens a view content for the specified file /// or returns the existing view content for the file if it is already open. /// </summary> /// <param name="fileName">The name of the file to open.</param> /// <param name="switchToOpenedView">Specifies whether to switch to the view for the specified file.</param> /// <returns>The existing or opened <see cref="IViewContent"/> for the specified file.</returns> public static IViewContent OpenFile(string fileName, bool switchToOpenedView) { return(SD.FileService.OpenFile(FileName.Create(fileName), switchToOpenedView)); }
/// <summary> /// This method can be used in three modes: /// 1. Find references to classes (parentClass = targetClass, member = null, fileName = null) /// 2. Find references to members (parentClass = parent, member = member, fileName = null) /// 3. Find references to local variables (parentClass = parent, member = local var as field, fileName = parent.CompilationUnit.FileName) /// </summary> static List <Reference> RunFindReferences(IClass ownerClass, IMember member, string fileName, IProgressMonitor progressMonitor) { if (ParserService.LoadSolutionProjectsThreadRunning) { if (progressMonitor != null) { progressMonitor.ShowingDialog = true; } MessageService.ShowMessage("${res:SharpDevelop.Refactoring.LoadSolutionProjectsThreadRunning}"); if (progressMonitor != null) { progressMonitor.ShowingDialog = false; } return(null); } CancellationToken ct = progressMonitor != null ? progressMonitor.CancellationToken : CancellationToken.None; List <ProjectItem> files; if (!string.IsNullOrEmpty(fileName)) { // search just in given file files = new List <ProjectItem>(); files.Add(FindItem(fileName)); } else { // search in all possible files ownerClass = ownerClass.GetCompoundClass(); files = GetPossibleFiles(ownerClass, member); } ParseableFileContentFinder finder = new ParseableFileContentFinder(); List <Reference> references = new List <Reference>(); if (progressMonitor != null) { progressMonitor.TaskName = StringParser.Parse("${res:SharpDevelop.Refactoring.FindingReferences}"); } foreach (ProjectItem item in files) { FileName itemFileName = FileName.Create(item.FileName); if (progressMonitor != null) { progressMonitor.Progress += 1.0 / files.Count; if (ct.IsCancellationRequested) { return(null); } } // Don't read files we don't have a parser for. // This avoids loading huge files (e.g. sdps) when we have no intention of parsing them. if (ParserService.GetParser(itemFileName) != null) { ITextBuffer content = finder.Create(itemFileName); if (content != null) { try { AddReferences(references, ownerClass, member, itemFileName, content.Text, ct); } catch (OperationCanceledException ex) { if (ex.CancellationToken == ct) { return(null); } else { throw; } } } } } return(references); }
/// <summary> /// Shows the OpenWith dialog for the specified file. /// </summary> static void OpenWith(string fileName) { SD.FileService.ShowOpenWithDialog(new [] { FileName.Create(fileName) }); }
bool IsInScope(Task item) { IClass current = GetCurrentClass(); IClass itemClass = GetCurrentClass(item); switch (this.selectedScopeIndex) { case 0: // Solution if (ProjectService.OpenSolution != null) { foreach (AbstractProject proj in ProjectService.OpenSolution.Projects) { if (proj.FindFile(item.FileName) != null) { return(true); } } } return(false); case 1: // Project return(ProjectService.CurrentProject != null && ProjectService.CurrentProject.FindFile(item.FileName) != null); case 2: // All open documents return(WorkbenchSingleton.Workbench.ViewContentCollection.OfType <ITextEditorProvider>().Any(provider => item.FileName == provider.TextEditor.FileName)); case 3: // Document return(WorkbenchSingleton.Workbench.ActiveViewContent != null && WorkbenchSingleton.Workbench.ActiveViewContent.PrimaryFileName == FileName.Create(item.FileName)); case 4: // Namespace return(current != null && itemClass != null && current.Namespace == itemClass.Namespace); case 5: // Class/Module return(current != null && itemClass != null && current == itemClass); } return(true); }
void classComboBoxSelectionChanged(object sender, SelectionChangedEventArgs e) { // The selected class was changed. // Update the list of member items to be the list of members of the current class. EntityItem item = classComboBox.SelectedItem as EntityItem; IUnresolvedTypeDefinition selectedClass = item != null ? item.Entity as IUnresolvedTypeDefinition : null; memberItems = new List <EntityItem>(); if (selectedClass != null) { ICompilation compilation = SD.ParserService.GetCompilationForFile(FileName.Create(selectedClass.UnresolvedFile.FileName)); var context = new SimpleTypeResolveContext(compilation.MainAssembly); ITypeDefinition compoundClass = selectedClass.Resolve(context).GetDefinition(); if (compoundClass != null) { var ambience = compilation.GetAmbience(); foreach (var member in compoundClass.Members) { if (member.IsSynthetic) { continue; } bool isInSamePart = string.Equals(member.Region.FileName, selectedClass.Region.FileName, StringComparison.OrdinalIgnoreCase); memberItems.Add(new EntityItem(member, ambience) { IsInSamePart = isInSamePart }); } memberItems.Sort(); if (jumpOnSelectionChange) { SD.AnalyticsMonitor.TrackFeature(GetType(), "JumpToClass"); JumpTo(item, selectedClass.Region); } } } membersComboBox.ItemsSource = memberItems; }
FileProjectItem GetFileFromMSBuildProject(string fileName) { return(msbuildProject.Items.Single(item => item.FileName == FileName.Create(fileName)) as FileProjectItem); }
ProjectItem GetFileProjectItemInMSBuildProject(string fileName) { return(msbuildProject.Items.SingleOrDefault(item => item.FileName == FileName.Create(fileName))); }
ProjectItem GetFirstServiceReferenceFileInMSBuildProject(ServiceReferenceFileName fileName) { return(msbuildProject.Items.SingleOrDefault(item => item.FileName == FileName.Create(fileName.Path))); }
public static void CopyDirectory(string directoryName, DirectoryNode node, bool includeInProject) { directoryName = FileUtility.NormalizePath(directoryName); string copiedFileName = Path.Combine(node.Directory, Path.GetFileName(directoryName)); LoggingService.Debug("Copy " + directoryName + " to " + copiedFileName); if (!FileUtility.IsEqualFileName(directoryName, copiedFileName)) { if (includeInProject && ProjectService.OpenSolution != null) { // get ProjectItems in source directory foreach (IProject project in ProjectService.OpenSolution.Projects) { if (!FileUtility.IsBaseDirectory(project.Directory, directoryName)) { continue; } LoggingService.Debug("Searching for child items in " + project.Name); foreach (ProjectItem item in project.Items) { FileProjectItem fileItem = item as FileProjectItem; if (fileItem == null) { continue; } string virtualFullName = Path.Combine(project.Directory, fileItem.VirtualName); if (FileUtility.IsBaseDirectory(directoryName, virtualFullName)) { if (item.ItemType == ItemType.Folder && FileUtility.IsEqualFileName(directoryName, virtualFullName)) { continue; } LoggingService.Debug("Found file " + virtualFullName); FileProjectItem newItem = new FileProjectItem(node.Project, fileItem.ItemType); if (FileUtility.IsBaseDirectory(directoryName, fileItem.FileName)) { newItem.FileName = FileName.Create(FileUtility.RenameBaseDirectory(fileItem.FileName, directoryName, copiedFileName)); } else { newItem.FileName = fileItem.FileName; } fileItem.CopyMetadataTo(newItem); if (fileItem.IsLink) { string newVirtualFullName = FileUtility.RenameBaseDirectory(virtualFullName, directoryName, copiedFileName); fileItem.SetEvaluatedMetadata("Link", FileUtility.GetRelativePath(node.Project.Directory, newVirtualFullName)); } ProjectService.AddProjectItem(node.Project, newItem); } } } } FileService.CopyFile(directoryName, copiedFileName, true, false); DirectoryNode newNode = new DirectoryNode(copiedFileName); newNode.InsertSorted(node); if (includeInProject) { IncludeFileInProject.IncludeDirectoryNode(newNode, false); } newNode.Expanding(); } else if (includeInProject) { foreach (TreeNode childNode in node.Nodes) { if (childNode is DirectoryNode) { DirectoryNode directoryNode = (DirectoryNode)childNode; if (FileUtility.IsEqualFileName(directoryNode.Directory, copiedFileName)) { IncludeFileInProject.IncludeDirectoryNode(directoryNode, true); } } } } }
public IList <ReferenceProjectItem> ResolveAssemblyReferences( MSBuildBasedProject baseProject, ReferenceProjectItem[] additionalReferences, bool resolveOnlyAdditionalReferences, bool logErrorsToOutputPad) { ProjectInstance project = baseProject.CreateProjectInstance(); project.SetProperty("BuildingProject", "false"); project.SetProperty("DesignTimeBuild", "true"); List <ProjectItemInstance> references = ( from item in project.Items where ItemType.ReferenceItemTypes.Contains(new ItemType(item.ItemType)) select item ).ToList(); List <ReferenceProjectItem> referenceProjectItems; if (resolveOnlyAdditionalReferences) { // Remove existing references from project foreach (ProjectItemInstance reference in references) { project.RemoveItem(reference); } references.Clear(); referenceProjectItems = new List <ReferenceProjectItem>(); } else { // Remove the "Private" meta data. // This is necessary to detect the default value for "Private" foreach (ProjectItemInstance reference in references) { reference.RemoveMetadata("Private"); } referenceProjectItems = baseProject.Items.OfType <ReferenceProjectItem>().ToList(); } if (additionalReferences != null) { referenceProjectItems.AddRange(additionalReferences); foreach (ReferenceProjectItem item in additionalReferences) { references.Add(project.AddItem("Reference", item.Include)); } } List <string> targets = new List <string>(); if (baseProject.MinimumSolutionVersion >= SolutionFormatVersion.VS2010) { targets.Add("ResolveReferences"); targets.Add("DesignTimeResolveAssemblyReferences"); } else { targets.Add("ResolveAssemblyReferences"); } BuildRequestData requestData = new BuildRequestData(project, targets.ToArray(), new HostServices()); List <ILogger> loggers = new List <ILogger>(); //loggers.Add(new ConsoleLogger(LoggerVerbosity.Diagnostic)); if (logErrorsToOutputPad) { loggers.Add(new SimpleErrorLogger()); } lock (MSBuildInternals.SolutionProjectCollectionLock) { BuildParameters parameters = new BuildParameters(baseProject.MSBuildProjectCollection); parameters.Loggers = loggers; //LoggingService.Debug("Started build for ResolveAssemblyReferences"); BuildResult result = BuildManager.DefaultBuildManager.Build(parameters, requestData); if (result == null) { throw new InvalidOperationException("BuildResult is null"); } //LoggingService.Debug("Build for ResolveAssemblyReferences finished: " + result.OverallResult); } IEnumerable <ProjectItemInstance> resolvedAssemblyProjectItems = project.GetItems("_ResolveAssemblyReferenceResolvedFiles"); var query = from msbuildItem in resolvedAssemblyProjectItems where msbuildItem.GetMetadataValue("ReferenceSourceTarget") != "ProjectReference" let originalInclude = msbuildItem.GetMetadataValue("OriginalItemSpec") join item in referenceProjectItems.Where(p => p.ItemType != ItemType.ProjectReference) on originalInclude equals item.Include into referenceItems select new { OriginalInclude = originalInclude, AssemblyName = new DomAssemblyName(msbuildItem.GetMetadataValue("FusionName")), FullPath = FileUtility.GetAbsolutePath(baseProject.Directory, msbuildItem.GetMetadataValue("Identity")), Redist = msbuildItem.GetMetadataValue("Redist"), CopyLocal = bool.Parse(msbuildItem.GetMetadataValue("CopyLocal")), ReferenceItems = referenceItems }; // HACK: mscorlib is reported twice for portable library projects (even if we don't specify it as additionalReference) query = query.DistinctBy(asm => asm.FullPath); List <ReferenceProjectItem> resolvedAssemblies = new List <ReferenceProjectItem>(); List <ReferenceProjectItem> handledReferenceItems = new List <ReferenceProjectItem>(); foreach (var assembly in query) { //LoggingService.Debug("Got information about " + assembly.OriginalInclude + "; fullpath=" + assembly.FullPath); foreach (var referenceItem in assembly.ReferenceItems) { referenceItem.AssemblyName = assembly.AssemblyName; referenceItem.FileName = FileName.Create(assembly.FullPath); referenceItem.Redist = assembly.Redist; referenceItem.DefaultCopyLocalValue = assembly.CopyLocal; handledReferenceItems.Add(referenceItem); } ReferenceProjectItem firstItem = assembly.ReferenceItems.FirstOrDefault(); if (firstItem != null) { resolvedAssemblies.Add(firstItem); } else { resolvedAssemblies.Add(new ReferenceProjectItem(baseProject, assembly.OriginalInclude) { FileName = FileName.Create(assembly.FullPath) }); } } // Add any assemblies that weren't resolved yet. This is important - for example, this adds back project references. foreach (var referenceItem in referenceProjectItems.Except(handledReferenceItems)) { resolvedAssemblies.Add(referenceItem); } return(resolvedAssemblies); }
/// <summary> /// Opens the specified file and jumps to the specified file position. /// Line and column start counting at 1. /// </summary> public static IViewContent JumpToFilePosition(string fileName, int line, int column) { return(SD.FileService.JumpToFilePosition(FileName.Create(fileName), line, column)); }
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) { if (value is string) { string[] v = ((string)value).Split('|'); FileName fileName = FileName.Create(v[1]); int lineNumber = int.Parse(v[2], culture); int columnNumber = int.Parse(v[3], culture); if (lineNumber < 0) { return(null); } if (columnNumber < 0) { return(null); } SDBookmark bookmark; switch (v[0]) { case "Breakpoint": Debugging.BreakpointAction action = Debugging.BreakpointAction.Break; string scriptLanguage = ""; string script = ""; action = (Debugging.BreakpointAction)Enum.Parse(typeof(Debugging.BreakpointAction), v[5]); scriptLanguage = v[6]; script = v[7]; var bbm = new Debugging.BreakpointBookmark(fileName, new Location(columnNumber, lineNumber), action, scriptLanguage, script); bbm.IsEnabled = bool.Parse(v[4]); bbm.Action = action; bbm.ScriptLanguage = scriptLanguage; bbm.Condition = script; bookmark = bbm; break; case "PinBookmark": var pin = new PinBookmark(fileName, new Location(columnNumber, lineNumber)); pin.Comment = v[4]; pin.PinPosition = new Point { X = double.Parse(v[5], culture), Y = double.Parse(v[6], culture) }; // pop-up nodes pin.SavedNodes = new System.Collections.Generic.List <Tuple <string, string, string> >(); for (int i = 7; i < v.Length; i += 3) { pin.SavedNodes.Add(new Tuple <string, string, string>(v[i], v[i + 1], v[i + 2])); } bookmark = pin; break; default: bookmark = new Bookmark(fileName, new Location(columnNumber, lineNumber)); break; } return(bookmark); } else { return(base.ConvertFrom(context, culture, value)); } }
/// <summary> /// Opens a view content for the specified file and switches to the opened view /// or switches to and returns the existing view content for the file if it is already open. /// </summary> /// <param name="fileName">The name of the file to open.</param> /// <returns>The existing or opened <see cref="IViewContent"/> for the specified file.</returns> public static IViewContent OpenFile(string fileName) { return(SD.FileService.OpenFile(FileName.Create(fileName))); }
public static FileProjectItem GetFile(MSBuildBasedProject project, string fileName) { return(project.FindFile(FileName.Create(fileName))); }
public void AddItem(string fileName) { var newItem = folder.AddFile(FileName.Create(fileName)); new SolutionItemNode(newItem).InsertSorted(this); }
public static void LoadProject(string fileName) { SD.ProjectService.OpenSolutionOrProject(FileName.Create(fileName)); //FileUtility.ObservedLoad(LoadProjectInternal, fileName); }
TestableFileProjectItem(TestableProject project, string fileName) : base(project, ItemType.None) { this.TestableProject = project; this.fileName = FileName.Create(fileName); }
public static bool HasProjectLoader(string fileName) { return(SD.ProjectService.IsSolutionOrProjectFile(FileName.Create(fileName))); }
/// <summary> /// Gets an opened file, or returns null if the file is not opened. /// </summary> public static OpenedFile GetOpenedFile(string fileName) { return(GetOpenedFile(FileName.Create(fileName))); }
public static void LoadSolutionOrProject(string fileName) { SD.ProjectService.OpenSolutionOrProject(FileName.Create(fileName)); }
public static FileName GetConsoleAppFileName() { return(FileName.Create(typeof(ICSharpCode.NAntAddIn.Tests.ConsoleApp.ConsoleApp).Assembly.Location)); }
void AddCodeCoverageFile(string fileName) { string coverageXml = "<CodeCoverage></CodeCoverage>"; AddCodeCoverageFile(FileName.Create(fileName), coverageXml); }
public void Run(IList <string> fileList) { bool didLoadSolutionOrFile = false; NavigationService.SuspendLogging(); foreach (string file in fileList) { LoggingService.Info("Open file " + file); didLoadSolutionOrFile = true; try { var fullFileName = FileName.Create(Path.GetFullPath(file)); if (SD.ProjectService.IsSolutionOrProjectFile(fullFileName)) { SD.ProjectService.OpenSolutionOrProject(fullFileName); } else { SharpDevelop.FileService.OpenFile(fullFileName); } } catch (Exception e) { MessageService.ShowException(e, "unable to open file " + file); } } // load previous solution if (!didLoadSolutionOrFile && SD.PropertyService.Get("SharpDevelop.LoadPrevProjectOnStartup", false)) { if (SD.FileService.RecentOpen.RecentProjects.Count > 0) { try { SD.ProjectService.OpenSolutionOrProject(SD.FileService.RecentOpen.RecentProjects[0]); didLoadSolutionOrFile = true; } catch (Exception ex) { MessageService.ShowException(ex); } } } if (!didLoadSolutionOrFile) { foreach (ICommand command in AddInTree.BuildItems <ICommand>("/SharpDevelop/Workbench/AutostartNothingLoaded", null, false)) { try { command.Execute(null); } catch (Exception ex) { MessageService.ShowException(ex); } } StartPreloadThread(); } NavigationService.ResumeLogging(); ((ParserService)SD.ParserService).StartParserThread(); // // finally run the workbench window ... app.Run(SD.Workbench.MainWindow); // save the workbench memento in the ide properties try { SD.PropertyService.SetNestedProperties(workbenchMemento, ((WpfWorkbench)SD.Workbench).CreateMemento()); } catch (Exception e) { MessageService.ShowException(e, "Exception while saving workbench state."); } }
HighlightedLine DoHighlightLine(int lineNumber, IDocumentLine documentLine, CachedLine cachedLine, ITextSourceVersion newVersion) { if (parseInfo == null) { if (forceParseOnNextRefresh) { forceParseOnNextRefresh = false; parseInfo = SD.ParserService.Parse(FileName.Create(document.FileName), document) as CSharpFullParseInformation; } else { parseInfo = SD.ParserService.GetCachedParseInformation(FileName.Create(document.FileName), newVersion) as CSharpFullParseInformation; } } if (parseInfo == null) { if (invalidLines != null && !invalidLines.Contains(documentLine)) { invalidLines.Add(documentLine); //Debug.WriteLine("Semantic highlighting for line {0} - marking as invalid", lineNumber); } if (cachedLine != null) { // If there's a cached version, adjust it to the latest document changes and return it. // This avoids flickering when changing a line that contains semantic highlighting. cachedLine.Update(newVersion); #if DEBUG cachedLine.HighlightedLine.ValidateInvariants(); #endif return(cachedLine.HighlightedLine); } else { return(null); } } if (visitor.Resolver == null) { var compilation = SD.ParserService.GetCompilationForFile(parseInfo.FileName); visitor.Resolver = parseInfo.GetResolver(compilation); } line = new HighlightedLine(document, documentLine); this.lineNumber = lineNumber; visitor.UpdateLineInformation(lineNumber); if (Debugger.IsAttached) { parseInfo.SyntaxTree.AcceptVisitor(visitor); #if DEBUG line.ValidateInvariants(); #endif } else { try { parseInfo.SyntaxTree.AcceptVisitor(visitor); #if DEBUG line.ValidateInvariants(); #endif } catch (Exception ex) { hasCrashed = true; throw new ApplicationException("Error highlighting line " + lineNumber, ex); } } //Debug.WriteLine("Semantic highlighting for line {0} - added {1} sections", lineNumber, line.Sections.Count); if (cachedLines != null && document.Version != null) { cachedLines.Add(new CachedLine(line, document.Version)); } return(line); }