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