protected override void Run(object tool) { Document doc = IdeApp.Workbench.ActiveDocument; if (doc == null) { return; } string mt = DesktopService.GetMimeTypeForUri(doc.FileName); var formatter = CodeFormatterService.GetFormatter(mt); if (formatter == null) { return; } using (var undo = doc.Editor.OpenUndoGroup()) { var loc = doc.Editor.Caret.Location; var text = formatter.FormatText(doc.Project != null ? doc.Project.Policies : null, doc.Editor.Text); if (text != null) { doc.Editor.Replace(0, doc.Editor.Length, text); doc.Editor.Caret.Location = loc; } } }
static void UpdateCommentTagsForProject(Project project, CancellationToken token) { if (token.IsCancellationRequested) { return; } ProjectCommentTags tags; if (!projectTags.TryGetValue(project, out tags)) { tags = new ProjectCommentTags(); projectTags [project] = tags; } var files = project.Files.Where(x => { var mt = DesktopService.GetMimeTypeForUri(x.FilePath); // FIXME: Handle all language services. // Discard files with known IToDoCommentService implementations return(mt != "text/x-csharp"); }).ToArray(); Task.Run(async() => { try { await tags.UpdateAsync(project, files, token); } catch (OperationCanceledException) { } catch (Exception e) { LoggingService.LogError("Error while updating comment tags.", e); } }); }
IEnumerable <string> GetFileNames(IProgressMonitor monitor, FilterOptions filterOptions) { if (monitor != null) { monitor.Log.WriteLine(GettextCatalog.GetString("Looking in '{0}'", path)); } foreach (string fileMask in filterOptions.FileMask.Split(',', ';')) { string[] files; try { files = Directory.GetFiles(path, fileMask, recurse ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly); } catch (Exception e) { LoggingService.LogError("Can't access path " + path, e); yield break; } foreach (string fileName in files) { if (fileName.StartsWith(".") && !IncludeHiddenFiles) { continue; } if (!IncludeBinaryFiles && !DesktopService.GetMimeTypeIsText(DesktopService.GetMimeTypeForUri(fileName))) { continue; } yield return(fileName); } } }
public static async Task FormatFile(PolicyContainer policies, FilePath file) { string mime = DesktopService.GetMimeTypeForUri(file); if (mime == null) { return; } var formatter = CodeFormatterService.GetFormatter(mime); if (formatter != null) { try { var content = await TextFileUtility.ReadAllTextAsync(file); var formatted = formatter.FormatText(policies, content.Text); if (formatted != null) { TextFileUtility.WriteText(file, formatted, content.Encoding); } } catch (Exception ex) { LoggingService.LogError("File formatting failed", ex); } } }
string TryGetFileType(string name) { if (name.StartsWith(".")) { name = name.Substring(1); } string tmpFile = null; try { tmpFile = System.IO.Path.GetTempFileName(); string f = System.IO.Path.ChangeExtension(tmpFile, "." + name); File.Move(tmpFile, f); tmpFile = f; return(DesktopService.GetMimeTypeForUri(tmpFile)); } catch { return(null); } finally { if (tmpFile != null) { try { if (File.Exists(tmpFile)) { File.Delete(tmpFile); } } catch { } } } }
protected override void Run(object tool) { Document doc = IdeApp.Workbench.ActiveDocument; if (doc == null) { return; } string mt = DesktopService.GetMimeTypeForUri(doc.FileName); Formatter formatter = TextFileService.GetFormatter(mt); if (formatter == null) { return; } doc.TextEditor.BeginAtomicUndo(); int line = doc.TextEditor.CursorLine; int column = doc.TextEditor.CursorColumn; doc.TextEditor.Select(0, doc.TextEditor.TextLength); doc.TextEditor.SelectedText = formatter.FormatText(doc.Project != null ? doc.Project.Policies : null, doc.TextEditor.Text); doc.TextEditor.CursorLine = line; doc.TextEditor.CursorColumn = column; doc.TextEditor.EndAtomicUndo(); }
protected override void Run(object tool) { Document doc = IdeApp.Workbench.ActiveDocument; if (doc == null) { return; } string mt = DesktopService.GetMimeTypeForUri(doc.FileName); var formatter = CodeFormatterService.GetFormatter(mt); if (formatter == null) { return; } if (formatter.SupportsOnTheFlyFormatting) { using (var undo = doc.Editor.OpenUndoGroup()) { formatter.OnTheFlyFormat(doc, 0, doc.Editor.Length); } } else { doc.Editor.Text = formatter.FormatText(doc.Project.Policies, doc.Editor.Text); } }
public void UpdateFileContent(string fileName, string text) { SourceText newText = SourceText.From(text); foreach (var kv in this.projectDataMap) { var projectId = kv.Key; var docId = this.GetDocumentId(projectId, fileName); if (docId != null) { base.OnDocumentTextChanged(docId, newText, PreservationMode.PreserveIdentity); } var monoProject = GetMonoProject(projectId); if (monoProject != null) { var pf = monoProject.GetProjectFile(fileName); if (pf != null) { var mimeType = DesktopService.GetMimeTypeForUri(fileName); if (TypeSystemService.CanParseProjections(monoProject, mimeType, fileName)) { TypeSystemService.ParseProjection(new ParseOptions { Project = monoProject, FileName = fileName, Content = new StringTextSource(text), BuildAction = pf.BuildAction }, mimeType); } } } } }
public static IEnumerable <FileViewer> GetFileViewers(FilePath filePath, Project ownerProject) { string mimeType = DesktopService.GetMimeTypeForUri(filePath); var viewerIds = new HashSet <string> (); foreach (var b in GetDisplayBindings(filePath, mimeType, ownerProject)) { var vb = b as IViewDisplayBinding; if (vb != null) { yield return(new FileViewer(vb)); } else { var eb = (IExternalDisplayBinding)b; var app = eb.GetApplication(filePath, mimeType, ownerProject); if (viewerIds.Add(app.Id)) { yield return(new FileViewer(app)); } } } foreach (var app in DesktopService.GetApplications(filePath)) { if (viewerIds.Add(app.Id)) { yield return(new FileViewer(app)); } } }
static SyntaxHighlightingDefinition GetSyntaxHighlightingDefinitionByMimeType(string mimeType) { foreach (string mt in DesktopService.GetMimeTypeInheritanceChain(mimeType)) { if (mimeType == "application/octet-stream" || mimeType == "text/plain") { return(null); } foreach (var bundle in languageBundles) { foreach (var h in bundle.Highlightings) { foreach (var fe in h.FileTypes) { var uri = fe.StartsWith(".", StringComparison.Ordinal) ? "a" + fe : "a." + fe; var mime = DesktopService.GetMimeTypeForUri(uri); if (mimeType == mime) { return(h); } } } } } return(null); }
protected override void Run(object tool) { Document doc = IdeApp.Workbench.ActiveDocument; if (doc == null) { return; } string mt = DesktopService.GetMimeTypeForUri(doc.FileName); var formatter = CodeFormatterService.GetFormatter(mt); if (formatter == null || !doc.Editor.IsSomethingSelected) { return; } var selection = doc.Editor.SelectionRange; using (var undo = doc.Editor.OpenUndoGroup()) { if (formatter.SupportsOnTheFlyFormatting) { formatter.OnTheFlyFormat(doc, selection.Offset, selection.EndOffset); } else { var pol = doc.Project != null ? doc.Project.Policies : null; string text = formatter.FormatText(pol, doc.Editor.Text, selection.Offset, selection.EndOffset); if (text != null) { doc.Editor.Replace(selection.Offset, selection.Length, text); doc.Editor.SetSelection(selection.Offset, selection.Offset + text.Length - 1); } } } }
async Task <Document> LoadFile(FilePath fileName, ProgressMonitor monitor, DocumentControllerDescription binding, WorkspaceObject project, FileOpenInformation fileInfo) { // Make sure composition manager is ready since ScrollToRequestedCaretLocation will use it await Runtime.GetService <CompositionManager> (); string mimeType = desktopService.GetMimeTypeForUri(fileName); var fileDescriptor = new FileDescriptor(fileName, mimeType, project); try { Counters.OpenDocumentTimer.Trace("Creating content"); DocumentController controller; try { fileInfo.DocumentControllerDescription = binding; controller = fileInfo.DocumentController = await binding.CreateController(fileDescriptor); } catch (InvalidEncodingException iex) { monitor.ReportError(GettextCatalog.GetString("The file '{0}' could not opened. {1}", fileName, iex.Message), null); return(null); } catch (OverflowException) { monitor.ReportError(GettextCatalog.GetString("The file '{0}' could not opened. File too large.", fileName), null); return(null); } if (controller == null) { monitor.ReportError(GettextCatalog.GetString("The file '{0}' could not be opened.", fileName), null); return(null); } Counters.OpenDocumentTimer.Trace("Loading file"); try { await controller.Initialize(fileDescriptor, GetStoredMemento (fileName)); controller.OriginalContentName = fileInfo.OriginalFileName; if (fileInfo.Owner != null) { controller.Owner = fileInfo.Owner; } } catch (InvalidEncodingException iex) { monitor.ReportError(GettextCatalog.GetString("The file '{0}' could not opened. {1}", fileName, iex.Message), iex); return(null); } catch (OverflowException) { monitor.ReportError(GettextCatalog.GetString("The file '{0}' could not opened. File too large.", fileName), null); return(null); } } catch (Exception ex) { monitor.ReportError(GettextCatalog.GetString("The file '{0}' could not be opened.", fileName), ex); return(null); } Counters.OpenDocumentTimer.Trace("Showing view"); var doc = await ShowView(fileInfo); ScrollToRequestedCaretLocation(doc, fileInfo); return(doc); }
public void Load(string fileName) { MainEditor.Document.MimeType = DesktopService.GetMimeTypeForUri(fileName); MainEditor.Document.Text = StringTextSource.ReadFrom(fileName).Text; this.CreateDiff(); Show(); }
public void Load(string fileName) { MainEditor.Document.MimeType = DesktopService.GetMimeTypeForUri(fileName); MainEditor.Document.Text = TextFileUtility.ReadAllText(fileName); this.CreateDiff(); Show(); }
public void AddLastProject(string name, string projectName) { RecentItem recentItem = new RecentItem(RecentFileStorage.ToUri(name), DesktopService.GetMimeTypeForUri(name), projectGroup); recentItem.Private = projectName; recentFiles.AddWithLimit(recentItem, projectGroup, ItemLimit); OnRecentProjectChange(); }
public static Ambience GetAmbienceForFile(string fileName) { if (string.IsNullOrEmpty(fileName)) { return(DefaultAmbience); } return(GetAmbience(DesktopService.GetMimeTypeForUri(fileName))); }
// Returns a stream with the content of the file. // project and language parameters are optional public virtual Stream CreateFileContent(SolutionItem policyParent, Project project, string language, string fileName, string identifier) { Dictionary <string, string> tags = new Dictionary <string, string> (); ModifyTags(policyParent, project, language, identifier, fileName, ref tags); string content = CreateContent(project, tags, language); content = StringParserService.Parse(content, tags); string mime = DesktopService.GetMimeTypeForUri(fileName); CodeFormatter formatter = !string.IsNullOrEmpty(mime) ? CodeFormatterService.GetFormatter(mime) : null; if (formatter != null) { var formatted = formatter.FormatText(policyParent != null ? policyParent.Policies : null, content); if (formatted != null) { content = formatted; } } MemoryStream ms = new MemoryStream(); byte[] data; if (AddStandardHeader) { string header = StandardHeaderService.GetHeader(policyParent, fileName, true); data = System.Text.Encoding.UTF8.GetBytes(header); ms.Write(data, 0, data.Length); } Mono.TextEditor.Document doc = new Mono.TextEditor.Document(); doc.Text = content; TextStylePolicy textPolicy = policyParent != null?policyParent.Policies.Get <TextStylePolicy> ("text/plain") : MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy <TextStylePolicy> ("text/plain"); string eolMarker = TextStylePolicy.GetEolMarker(textPolicy.EolMarker); byte[] eolMarkerBytes = System.Text.Encoding.UTF8.GetBytes(eolMarker); var tabToSpaces = textPolicy.TabsToSpaces? new string (' ', textPolicy.TabWidth) : null; foreach (Mono.TextEditor.LineSegment line in doc.Lines) { var lineText = doc.GetTextAt(line.Offset, line.EditableLength); if (tabToSpaces != null) { lineText = lineText.Replace("\t", tabToSpaces); } data = System.Text.Encoding.UTF8.GetBytes(lineText); ms.Write(data, 0, data.Length); ms.Write(eolMarkerBytes, 0, eolMarkerBytes.Length); } ms.Position = 0; return(ms); }
public static IEnumerable <MemberReference> FindReferences(Solution solution, INode member, IProgressMonitor monitor = null) { ProjectDom dom = null; ICompilationUnit unit = null; IEnumerable <INode> searchNodes = new INode[] { member }; if (member is LocalVariable) { dom = ((LocalVariable)member).DeclaringMember.DeclaringType.SourceProjectDom; unit = ((LocalVariable)member).CompilationUnit; } else if (member is IParameter) { dom = ((IParameter)member).DeclaringMember.DeclaringType.SourceProjectDom; unit = ((IParameter)member).DeclaringMember.DeclaringType.CompilationUnit; } else if (member is IType) { dom = ((IType)member).SourceProjectDom; unit = ((IType)member).CompilationUnit; } else if (member is IMember) { dom = ((IMember)member).DeclaringType.SourceProjectDom; unit = ((IMember)member).DeclaringType.CompilationUnit; searchNodes = CollectMembers(dom, (IMember)member); } string currentMime = null; ReferenceFinder finder = null; foreach (var info in GetFileNames(solution, dom, unit, member, monitor)) { if (monitor != null && monitor.IsCancelRequested) { yield break; } string mime = DesktopService.GetMimeTypeForUri(info.Item2); bool runReferenceFinder = false; if (mime != currentMime) { currentMime = mime; finder = GetReferenceFinder(currentMime); } if (finder == null) { continue; } foreach (var foundReference in finder.FindReferences(info.Item1, info.Item2, searchNodes)) { if (monitor != null && monitor.IsCancelRequested) { yield break; } yield return(foundReference); } } }
public static List <string> GetResolveableNamespaces(RefactoringOptions options, out bool resolveDirect) { IReturnType returnType = null; INRefactoryASTProvider astProvider = RefactoringService.GetASTProvider(DesktopService.GetMimeTypeForUri(options.Document.FileName)); if (options.ResolveResult != null && options.ResolveResult.ResolvedExpression != null) { if (astProvider != null) { returnType = astProvider.ParseTypeReference(options.ResolveResult.ResolvedExpression.Expression).ConvertToReturnType(); } if (returnType == null) { returnType = DomReturnType.GetSharedReturnType(options.ResolveResult.ResolvedExpression.Expression); } } List <string> namespaces; if (options.ResolveResult is UnresolvedMemberResolveResult) { namespaces = new List <string> (); UnresolvedMemberResolveResult unresolvedMemberResolveResult = options.ResolveResult as UnresolvedMemberResolveResult; IType type = unresolvedMemberResolveResult.TargetResolveResult != null?options.Dom.GetType(unresolvedMemberResolveResult.TargetResolveResult.ResolvedType) : null; if (type != null) { List <IType> allExtTypes = DomType.GetAccessibleExtensionTypes(options.Dom, null); foreach (ExtensionMethod method in type.GetExtensionMethods(allExtTypes, unresolvedMemberResolveResult.MemberName)) { string ns = method.OriginalMethod.DeclaringType.Namespace; if (!namespaces.Contains(ns) && !options.Document.CompilationUnit.Usings.Any(u => u.Namespaces.Contains(ns))) { namespaces.Add(ns); } } } resolveDirect = false; } else { namespaces = new List <string> (options.Dom.ResolvePossibleNamespaces(returnType)); resolveDirect = true; } for (int i = 0; i < namespaces.Count; i++) { for (int j = i + 1; j < namespaces.Count; j++) { if (namespaces[j] == namespaces[i]) { namespaces.RemoveAt(j); j--; } } } return(namespaces); }
public void AddLastFile(string name, string project) { RecentItem recentItem = new RecentItem(RecentFileStorage.ToUri(name), DesktopService.GetMimeTypeForUri(name), fileGroup); recentItem.Private = project != null?string.Format("{0} [{1}]", Path.GetFileName(name), project) : Path.GetFileName(name); recentFiles.AddWithLimit(recentItem, fileGroup, ItemLimit); OnRecentFileChange(); }
protected override void Run(object tool) { Document doc = IdeApp.Workbench.ActiveDocument; if (doc == null) { return; } string mt = DesktopService.GetMimeTypeForUri(doc.FileName); var formatter = CodeFormatterService.GetFormatter(mt); if (formatter == null) { return; } Mono.TextEditor.TextSegment selection; var editor = doc.Editor; if (editor.IsSomethingSelected) { selection = editor.SelectionRange; } else { selection = editor.GetLine(editor.Caret.Line).Segment; } using (var undo = editor.OpenUndoGroup()) { var version = editor.Version; if (formatter.SupportsOnTheFlyFormatting) { formatter.OnTheFlyFormat(doc, selection.Offset, selection.EndOffset); } else { var pol = doc.Project != null ? doc.Project.Policies : null; try { string text = formatter.FormatText(pol, editor.Text, selection.Offset, selection.EndOffset); if (text != null) { editor.Replace(selection.Offset, selection.Length, text); } } catch (Exception e) { LoggingService.LogError("Error during format.", e); } } if (editor.IsSomethingSelected) { int newOffset = version.MoveOffsetTo(editor.Version, selection.Offset); int newEndOffset = version.MoveOffsetTo(editor.Version, selection.EndOffset); editor.SetSelection(newOffset, newEndOffset); } } }
public static bool SupportsRefactoring(DotNetProject project) { if (project == null || project.LanguageBinding == null || project.LanguageBinding.GetCodeDomProvider() == null) { return(false); } var testFileName = project.LanguageBinding.GetFileName("test"); return(CodeGenerator.HasGenerator(DesktopService.GetMimeTypeForUri(testFileName))); }
static CodeFormatter GetFormatter(FilePath fileName) { string mime = DesktopService.GetMimeTypeForUri(fileName); if (mime != null) { return(CodeFormatterService.GetFormatter(mime)); } return(null); }
void Add(string grp, string fileName, string displayName) { var mime = DesktopService.GetMimeTypeForUri(fileName); var uri = RecentFileStorage.ToUri(fileName); var recentItem = new RecentItem(uri, mime, grp) { Private = displayName }; recentFiles.AddWithLimit(recentItem, grp, ItemLimit); }
static bool CanGenerateAnalysisContextForNonCompileable(MonoDevelop.Projects.Project p, MonoDevelop.Projects.ProjectFile f) { var mimeType = DesktopService.GetMimeTypeForUri(f.FilePath); var node = TypeSystemService.GetTypeSystemParserNode(mimeType, f.BuildAction); if (node?.Parser == null) { return(false); } return(node.Parser.CanGenerateAnalysisDocument(mimeType, f.BuildAction, p.SupportedLanguages)); }
public void Load(string fileName) { MainEditor.Document.MimeType = DesktopService.GetMimeTypeForUri(fileName); MainEditor.Document.Text = System.IO.File.ReadAllText(fileName); this.CreateDiff(); MainEditor.Document.TextReplaced += delegate { this.UpdateDiff(); }; Show(); }
protected virtual bool CreateFile(FileDescriptionTemplate newfile, SolutionItem policyParent, Project project, string directory, string language, string name) { if (project != null) { if (newfile.AddToProject(policyParent, project, language, directory, name)) { newfile.Show(); return(true); } } else { SingleFileDescriptionTemplate singleFile = newfile as SingleFileDescriptionTemplate; if (singleFile == null) { throw new InvalidOperationException("Single file template expected"); } if (directory != null) { string fileName = singleFile.SaveFile(policyParent, project, language, directory, name); if (fileName != null) { IdeApp.Workbench.OpenDocument(fileName); return(true); } } else { string fileName = singleFile.GetFileName(policyParent, project, language, directory, name); Stream stream = singleFile.CreateFileContent(policyParent, project, language, fileName, name); // Guess the mime type of the new file string fn = Path.GetTempFileName(); string ext = Path.GetExtension(fileName); int n = 0; while (File.Exists(fn + n + ext)) { n++; } FileService.MoveFile(fn, fn + n + ext); string mimeType = DesktopService.GetMimeTypeForUri(fn + n + ext); FileService.DeleteFile(fn + n + ext); if (mimeType == null || mimeType == "") { mimeType = "text"; } IdeApp.Workbench.NewDocument(fileName, mimeType, stream); return(true); } } return(false); }
public void SetFileName(string file) { if (file != fileName) { fileName = file; if (fileName != null) { mimeType = DesktopService.GetMimeTypeForUri(fileName); } NotifyChanged(); } }
void OnClosed(object s, EventArgs a) { closed = true; ClearTasks(); string currentParseFile = FileName; Project curentParseProject = Project; if (window is SdiWorkspaceWindow) { ((SdiWorkspaceWindow)window).DetachFromPathedDocument(); } window.Closed -= OnClosed; window.ActiveViewContentChanged -= OnActiveViewContentChanged; if (IdeApp.Workspace != null) { IdeApp.Workspace.ItemRemovedFromSolution -= OnEntryRemoved; } try { OnClosed(a); } catch (Exception ex) { LoggingService.LogError("Exception while calling OnClosed.", ex); } while (editorExtension != null) { try { editorExtension.Dispose(); } catch (Exception ex) { LoggingService.LogError("Exception while disposing extension:" + editorExtension, ex); } editorExtension = editorExtension.Next as TextEditorExtension; } // Parse the file when the document is closed. In this way if the document // is closed without saving the changes, the saved compilation unit // information will be restored if (currentParseFile != null) { System.Threading.ThreadPool.QueueUserWorkItem(delegate { // Don't access Document properties from the thread ProjectDomService.Parse(curentParseProject, currentParseFile, DesktopService.GetMimeTypeForUri(currentParseFile)); }); } if (fileDom != null) { ProjectDomService.RemoveFileDom(FileName); fileDom = null; } Counters.OpenDocuments--; }
public IEnumerable <BaseCodeIssueProvider> GetIssueProviders(ProjectFile file) { return(RefactoringService.GetInspectors(DesktopService.GetMimeTypeForUri(file.Name)) .Where(provider => { var severity = provider.GetSeverity(); if (severity == Severity.None || !provider.GetIsEnabled()) { return false; } return true; })); }