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);
}
void HandlePolicyChanged(object sender, MonoDevelop.Projects.Policies.PolicyChangedEventArgs args)
{
var mimeTypes = DesktopService.GetMimeTypeInheritanceChain(textEditor.MimeType);
var currentPolicy = policyContainer.Get <TextStylePolicy> (mimeTypes);
textEditor.Options = DefaultSourceEditorOptions.Instance.WithTextStyle(currentPolicy);
}
public static void Format(TextEditor editor, DocumentContext context, int startOffset, int endOffset, bool exact = true, OptionSet optionSet = null)
{
var policyParent = context.Project != null ? context.Project.Policies : PolicyService.DefaultPolicies;
var mimeTypeChain = DesktopService.GetMimeTypeInheritanceChain(CSharpFormatter.MimeType);
Format(policyParent, mimeTypeChain, editor, context, startOffset, endOffset, exact, optionSet: optionSet);
}
public static void Format(MonoDevelop.Ide.Gui.Document data, int startOffset, int endOffset, bool exact = true)
{
var policyParent = data.Project != null ? data.Project.Policies : PolicyService.DefaultPolicies;
var mimeTypeChain = DesktopService.GetMimeTypeInheritanceChain(CSharpFormatter.MimeType);
Format(policyParent, mimeTypeChain, data, startOffset, endOffset, exact);
}
public void UpdateStyleParent(Project styleParent, string mimeType)
{
if (styleParent != null && policyContainer == styleParent.Policies && mimeType == lastMimeType)
{
return;
}
lastMimeType = mimeType;
if (policyContainer != null)
{
policyContainer.PolicyChanged -= HandlePolicyChanged;
}
if (string.IsNullOrEmpty(mimeType))
{
mimeType = "text/plain";
}
this.mimeTypes = DesktopService.GetMimeTypeInheritanceChain(mimeType);
if (styleParent != null)
{
policyContainer = styleParent.Policies;
}
else
{
policyContainer = MonoDevelop.Projects.Policies.PolicyService.DefaultPolicies;
}
currentPolicy = policyContainer.Get <TextStylePolicy> (mimeTypes);
policyContainer.PolicyChanged += HandlePolicyChanged;
if (changed != null)
{
this.changed(this, EventArgs.Empty);
}
}
MimeTypePanelData AddPanel(string mt)
{
var chain = new List <string> (DesktopService.GetMimeTypeInheritanceChain(mt).Where(x => mimeTypesWithPolicies.Contains(x)));
if (chain.Count == 0)
{
return(null);
}
MimeTypePanelData data = new MimeTypePanelData();
OptionsDialogSection sec = new MimetypeOptionsDialogSection(mt);
sec.Fill = true;
data.Section = sec;
data.MimeType = mt;
data.TypeDescription = DesktopService.GetMimeTypeDescription(mt);
if (string.IsNullOrEmpty(data.TypeDescription))
{
data.TypeDescription = mt;
}
data.DataObject = DataObject;
data.PolicyContainer = policyContainer;
sec.Label = data.TypeDescription;
LoadPolicyTypeData(data, mt, chain);
typeSections [mt] = data;
ParentDialog.AddChildSection(this, sec, data);
return(data);
}
async Task UpdateStyleParent(MonoDevelop.Projects.Project styleParent, string mimeType)
{
RemovePolicyChangeHandler();
if (string.IsNullOrEmpty(mimeType))
{
mimeType = "text/plain";
}
var mimeTypes = DesktopService.GetMimeTypeInheritanceChain(mimeType);
if (styleParent != null)
{
policyContainer = styleParent.Policies;
}
else
{
policyContainer = MonoDevelop.Projects.Policies.PolicyService.DefaultPolicies;
}
var currentPolicy = policyContainer.Get <TextStylePolicy> (mimeTypes);
policyContainer.PolicyChanged += HandlePolicyChanged;
((DefaultSourceEditorOptions)textEditor.Options).UpdateStylePolicy(currentPolicy);
var context = await EditorConfigService.GetEditorConfigContext(textEditor.FileName, default(CancellationToken));
if (context == null)
{
return;
}
((DefaultSourceEditorOptions)textEditor.Options).SetContext(context);
}
public static void Format(MonoDevelop.Ide.Gui.Document data, ProjectDom dom, DomLocation location, bool correctBlankLines, bool runAferCR = false)
{
PolicyContainer policyParent = dom != null && dom.Project != null ? dom.Project.Policies : PolicyService.DefaultPolicies;
var mimeTypeChain = DesktopService.GetMimeTypeInheritanceChain(CSharpFormatter.MimeType);
Format(policyParent, mimeTypeChain, data, dom, location, correctBlankLines, runAferCR);
}
void IMimeTypePolicyOptionsPanel.InitializePolicy(PolicyContainer policyContainer, string mimeType, bool isExactMimeType)
{
this.mimeType = mimeType;
this.policyContainer = policyContainer;
this.isExactMimeType = isExactMimeType;
mimeTypeScopes = DesktopService.GetMimeTypeInheritanceChain(mimeType);
}
public List <ReferenceSegment> Decompile(TextEditorData data, ITreeNavigator navigator, bool publicOnly)
{
if (DomMethodNodeBuilder.HandleSourceCodeEntity(navigator, data))
{
return(null);
}
var type = CecilLoader.GetCecilObject((IUnresolvedTypeDefinition)navigator.DataItem);
if (type == null)
{
return(null);
}
var types = DesktopService.GetMimeTypeInheritanceChain(data.Document.MimeType);
var codePolicy = MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy <MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy> (types);
var settings = new DecompilerSettings()
{
AnonymousMethods = true,
AutomaticEvents = true,
AutomaticProperties = true,
ForEachStatement = true,
LockStatement = true,
CSharpFormattingOptions = codePolicy.CreateOptions(),
HideNonPublicMembers = publicOnly
};
return(DomMethodNodeBuilder.Decompile(data, DomMethodNodeBuilder.GetModule(navigator), type, builder => {
builder.AddType(type);
}, settings));
}
public static List <ReferenceSegment> Decompile(TextEditorData data, ModuleDefinition module, TypeDefinition currentType, Action <AstBuilder> setData)
{
try {
var types = DesktopService.GetMimeTypeInheritanceChain(data.Document.MimeType);
var codePolicy = MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy <MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy> (types);
var context = new DecompilerContext(module);
var source = new CancellationTokenSource();
context.CancellationToken = source.Token;
context.CurrentType = currentType;
context.Settings = new DecompilerSettings()
{
AnonymousMethods = true,
AutomaticEvents = true,
AutomaticProperties = true,
ForEachStatement = true,
LockStatement = true
};
AstBuilder astBuilder = new AstBuilder(context);
setData(astBuilder);
astBuilder.RunTransformations(o => false);
var output = new ColoredCSharpFormatter(data.Document);
astBuilder.GenerateCode(output, codePolicy.CreateOptions());
output.SetDocumentData();
return(output.ReferencedSegments);
} catch (Exception e) {
data.Text = "Decompilation failed: \n" + e;
}
return(null);
}
public static DecompilerSettings GetDecompilerSettings(TextEditor data, bool publicOnly = false)
{
var types = DesktopService.GetMimeTypeInheritanceChain(data.MimeType);
var codePolicy = MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy <MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy> (types);
var settings = DomTypeNodeBuilder.CreateDecompilerSettings(publicOnly, codePolicy);
return(settings);
}
public static List <ReferenceSegment> Decompile(TextEditorData data, ModuleDefinition module, TypeDefinition currentType, Action <AstBuilder> setData)
{
var types = DesktopService.GetMimeTypeInheritanceChain(data.Document.MimeType);
var codePolicy = MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy <MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy> (types);
var settings = DomTypeNodeBuilder.CreateDecompilerSettings(false, codePolicy);
return(Decompile(data, module, currentType, setData, settings));
}
public static void FormatStatmentAt(MonoDevelop.Ide.Gui.Document data, DocumentLocation location)
{
var offset = data.Editor.LocationToOffset(location);
var policyParent = data.Project != null ? data.Project.Policies : PolicyService.DefaultPolicies;
var mimeTypeChain = DesktopService.GetMimeTypeInheritanceChain(CSharpFormatter.MimeType);
Format(policyParent, mimeTypeChain, data, offset, offset, false, true);
}
protected override ITextSource FormatImplementation(PolicyContainer policyParent, string mimeType, ITextSource input, int startOffset, int length)
{
var chain = DesktopService.GetMimeTypeInheritanceChain(mimeType);
var policy = policyParent.Get <CSharpFormattingPolicy> (chain);
var textPolicy = policyParent.Get <TextStylePolicy> (chain);
return(new StringTextSource(FormatText(policy.CreateOptions(textPolicy), input.Text, startOffset, startOffset + length)));
}
public static void FormatStatmentAt(TextEditor editor, DocumentContext context, MonoDevelop.Ide.Editor.DocumentLocation location, OptionSet optionSet = null)
{
var offset = editor.LocationToOffset(location);
var policyParent = context.Project != null ? context.Project.Policies : PolicyService.DefaultPolicies;
var mimeTypeChain = DesktopService.GetMimeTypeInheritanceChain(CSharpFormatter.MimeType);
Format(policyParent, mimeTypeChain, editor, context, offset, offset, false, true, optionSet: optionSet);
}
public static string SaveFormattedXml(PolicyContainer policies, AddinDescription adesc)
{
XmlDocument doc = adesc.SaveToXml();
TextStylePolicy textPolicy = policies.Get <TextStylePolicy> (DesktopService.GetMimeTypeInheritanceChain("application/x-addin+xml"));
XmlFormattingPolicy xmlPolicy = policies.Get <XmlFormattingPolicy> (DesktopService.GetMimeTypeInheritanceChain("application/x-addin+xml"));
return(XmlFormatter.FormatXml(textPolicy, xmlPolicy, doc.OuterXml));
}
public static bool IsMimeTypeHandled(string mimeType)
{
foreach (var m in DesktopService.GetMimeTypeInheritanceChain(mimeType))
{
if (m == TextXmlMimeType || m == ApplicationXmlMimeType)
{
return(true);
}
}
return(false);
}
internal static TypeSystemParserNode GetTypeSystemParserNode(string mimeType, string buildAction)
{
foreach (var mt in DesktopService.GetMimeTypeInheritanceChain(mimeType))
{
var provider = Parsers.FirstOrDefault(p => p.CanParse(mt, buildAction));
if (provider != null)
{
return(provider);
}
}
return(null);
}
public static IFoldingParser GetFoldingParser(string mimeType)
{
foreach (var mt in DesktopService.GetMimeTypeInheritanceChain(mimeType))
{
var node = FoldingParsers.FirstOrDefault(n => n.MimeType == mt);
if (node != null)
{
return(node.CreateInstance() as IFoldingParser);
}
}
return(null);
}
protected override Core.Text.ITextSource FormatImplementation(PolicyContainer policyParent, string mimeType, Core.Text.ITextSource input, int startOffset, int length)
{
if (policyParent == null)
{
policyParent = PolicyService.DefaultPolicies;
}
var mimeTypeInheritanceChain = DesktopService.GetMimeTypeInheritanceChain(mimeType).ToList();
var txtPol = policyParent.Get <TextStylePolicy> (mimeTypeInheritanceChain);
var xmlPol = policyParent.Get <XmlFormattingPolicy> (mimeTypeInheritanceChain);
return(new StringTextSource(FormatXml(txtPol, xmlPol, input.Text)));
}
//returns all valid extensions in order of most to least specific
static IEnumerable <TextEditorExtensionNode> GetEditorExtensions(TextEditor editor, string extensionPoint)
{
var returned = new HashSet <TextEditorExtensionNode> ();
//get the nodes from the extensioncontext rather than the addinmanager
//so that custom conditions supported by the editor are respected
var nodes = editor.ExtensionContext.GetExtensionNodes <TextEditorExtensionNode> (extensionPoint);
//file extensions are cheaper to check than mimetypes, check them first
//this means exact file extensions take precedence over mimetypes regardless
//of node ordering but it's not a big deal
var extension = string.IsNullOrEmpty(editor.FileName) ? null : Path.GetExtension(editor.FileName);
foreach (var node in nodes)
{
if (MatchAny(extension, node.FileExtensions))
{
returned.Add(node);
yield return(node);
}
}
//check mimetypes, from most to least specific
var mimeChain = DesktopService.GetMimeTypeInheritanceChain(editor.MimeType);
foreach (var mime in mimeChain)
{
foreach (var node in nodes)
{
if (!returned.Contains(node) && MatchAny(mime, node.MimeTypes))
{
returned.Add(node);
yield return(node);
}
}
}
//finally, return any remaining nodes that don't have restrictions at all
foreach (var node in nodes)
{
if (!returned.Contains(node) && NullOrEmpty(node.MimeTypes) && NullOrEmpty(node.FileExtensions))
{
yield return(node);
}
}
bool MatchAny(string value, string [] matches) =>
matches != null && matches.Length > 0 &&
matches.Any(m => string.Equals(m, value, StringComparison.OrdinalIgnoreCase));
bool NullOrEmpty(string [] arr) => arr == null || arr.Length == 0;
}
protected override string InternalFormat(PolicyContainer policyParent, string mimeType, string input, int startOffset, int endOffset)
{
IEnumerable <string> mtypes = DesktopService.GetMimeTypeInheritanceChain(mimeType);
TextStylePolicy currentPolicy = policyParent != null
? policyParent.Get <TextStylePolicy> (mtypes)
: MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy <TextStylePolicy> (mtypes);
input = input ?? "";
int line = 0, col = 0;
string eolMarker = currentPolicy.GetEolMarker();
StringBuilder result = new StringBuilder();
for (int i = startOffset; i <= endOffset; i++)
{
char ch = input[i];
switch (ch)
{
case '\t':
if (currentPolicy.TabsToSpaces)
{
int tabWidth = GetNextTabstop(col, currentPolicy.TabWidth) - col;
result.Append(new string (' ', tabWidth));
col += tabWidth;
}
else
{
goto default;
}
break;
case '\r':
if (i + 1 < input.Length && input[i + 1] == '\n')
{
i++;
}
goto case '\n';
case '\n':
result.Append(eolMarker);
line++;
col = 0;
break;
default:
result.Append(ch);
col++;
break;
}
}
return(result.ToString());
}
static bool IsMimeTypeHandled(string mimeType)
{
foreach (var m in DesktopService.GetMimeTypeInheritanceChain(mimeType))
{
if (m == TextXmlMimeType || m == ApplicationXmlMimeType)
{
return(true);
}
if (m == MonoDevelop.XmlEditor.MSBuild.MSBuildTextEditorExtension.MSBuildMimeType)
{
return(false);
}
}
return(false);
}
public string OutputNode(ProjectDom dom, AstNode node, string indent)
{
StringWriter w = new StringWriter();
var policyParent = dom != null && dom.Project != null ? dom.Project.Policies : null;
IEnumerable <string> types = DesktopService.GetMimeTypeInheritanceChain(CSharpFormatter.MimeType);
CSharpFormattingPolicy codePolicy = policyParent != null?policyParent.Get <CSharpFormattingPolicy> (types) : MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy <CSharpFormattingPolicy> (types);
var formatter = new TextWriterOutputFormatter(w);
int col = GetColumn(indent, 0, 4);
formatter.Indentation = System.Math.Max(0, col / 4);
OutputVisitor visitor = new OutputVisitor(formatter, codePolicy.CreateOptions());
node.AcceptVisitor(visitor, null);
return(w.ToString());
}
public void UpdateStyleParent (Project styleParent, string mimeType)
{
if (policyContainer != null)
policyContainer.PolicyChanged -= HandlePolicyChanged;
if (string.IsNullOrEmpty (mimeType))
mimeType = "text/plain";
this.mimeTypes = DesktopService.GetMimeTypeInheritanceChain (mimeType);
if (styleParent != null)
policyContainer = styleParent.Policies;
else
policyContainer = MonoDevelop.Projects.Policies.PolicyService.DefaultPolicies;
currentPolicy = policyContainer.Get<TextStylePolicy> (mimeTypes);
policyContainer.PolicyChanged += HandlePolicyChanged;
}
public static List <ReferenceSegment> Decompile(TextEditorData data, ModuleDefinition module, TypeDefinition currentType, Action <AstBuilder> setData)
{
var types = DesktopService.GetMimeTypeInheritanceChain(data.Document.MimeType);
var codePolicy = MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy <MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy> (types);
DecompilerSettings settings = new DecompilerSettings()
{
AnonymousMethods = true,
AutomaticEvents = true,
AutomaticProperties = true,
ForEachStatement = true,
LockStatement = true,
ShowXmlDocumentation = true,
CSharpFormattingOptions = codePolicy.CreateOptions()
};
return(Decompile(data, module, currentType, setData, settings));
}
public static string[] GetCommentTags(string fileName)
{
//Document doc = IdeApp.Workbench.ActiveDocument;
string loadedMimeType = DesktopService.GetMimeTypeForUri(fileName);
SyntaxMode mode = null;
foreach (string mt in DesktopService.GetMimeTypeInheritanceChain(loadedMimeType))
{
mode = SyntaxModeService.GetSyntaxMode(mt);
if (mode != null)
{
break;
}
}
if (mode == null)
{
return(null);
}
List <string> ctags;
if (mode.Properties.TryGetValue("LineComment", out ctags) && ctags.Count > 0)
{
return(new string [] { ctags [0] });
}
List <string> tags = new List <string> ();
if (mode.Properties.TryGetValue("BlockCommentStart", out ctags))
{
tags.Add(ctags [0]);
}
if (mode.Properties.TryGetValue("BlockCommentEnd", out ctags))
{
tags.Add(ctags [0]);
}
if (tags.Count == 2)
{
return(tags.ToArray());
}
else
{
return(null);
}
}
protected override void Initialize()
{
base.Initialize();
// This extension needs to be turned off if the webtooling addin json extension is present.
// That addin defines a "text/x-json" mimeType that has multiple levels of inheritance.
var mimeChain = DesktopService.GetMimeTypeInheritanceChain("text/x-json").ToList();
jsonExtensionInstalled = (mimeChain.Count > 2);
if (!jsonExtensionInstalled)
{
IStateMachineIndentEngine indentEngine;
indentEngine = new JSonIndentEngine(Editor, DocumentContext);
stateTracker = new CacheIndentEngine(indentEngine);
Editor.IndentationTracker = new JSonIndentationTracker(Editor, stateTracker);
}
}
void UpdateExample(string example)
{
string text;
if (!string.IsNullOrEmpty(example))
{
text = Environment.NewLine != "\n" ? example.Replace("\n", Environment.NewLine) : example;
}
else
{
text = "";
}
var types = DesktopService.GetMimeTypeInheritanceChain(MonoDevelop.CSharp.Formatting.CSharpFormatter.MimeType);
var textPolicy = MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy <TextStylePolicy> (types);
texteditor.Text = CSharpFormatter.FormatText(profile, textPolicy, text, 0, text.Length);
}