public override void BuildNode(ITreeBuilder treeBuilder, object dataObject, NodeInfo nodeInfo)
{
var project = (Project)dataObject;
nodeInfo.Label = Ambience.EscapeText(project.Name);
nodeInfo.Icon = Context.GetIcon(project.StockIcon);
}
public void FillInspectors(string filter)
{
categories.Clear();
treeStore.Clear();
var grouped = severities.Keys
.GroupBy(node => node.Item2.Category)
.OrderBy(g => g.Key, StringComparer.Ordinal);
foreach (var g in grouped)
{
foreach (var node in g.OrderBy(n => n.Item2.Title.ToString(), StringComparer.CurrentCulture))
{
var title = GettextCatalog.GetString("{0} ({1})", node.Item2.Title, node.Item2.Id);
if (!string.IsNullOrEmpty(filter) && title.IndexOf(filter, StringComparison.CurrentCultureIgnoreCase) < 0)
{
continue;
}
TreeIter categoryIter;
if (!categories.TryGetValue(g.Key, out categoryIter))
{
categoryIter = treeStore.AppendValues("<b>" + g.Key + "</b>", null, null, null);
categories [g.Key] = categoryIter;
}
var desc = node.Item2.Description.ToString();
if (string.IsNullOrEmpty(desc))
{
desc = title;
}
MarkupSearchResult(filter, ref title);
var nodeIter = treeStore.AppendValues(categoryIter, title, node, Ambience.EscapeText(title), Ambience.EscapeText(desc));
}
}
treeviewInspections.ExpandAll();
}
protected override void Run()
{
var editor = IdeApp.Workbench.ActiveDocument?.Editor;
if (editor == null)
{
return;
}
var scopeStack = editor.GetScopeStackAsync(editor.CaretOffset, CancellationToken.None).WaitAndGetResult(CancellationToken.None);
var sb = new StringBuilder();
sb.AppendLine();
foreach (var scope in scopeStack.Reverse())
{
sb.AppendLine(Ambience.EscapeText(scope));
}
var window = new TooltipPopoverWindow();
window.Markup = "<span font='" + FontService.MonospaceFontName + "'>" + sb.ToString() + "</span>";
editor.ShowTooltipWindow(window);
}
public override void BuildNode(ITreeBuilder treeBuilder, object dataObject, NodeInfo nodeInfo)
{
var data = dataObject as IEventSymbol;
nodeInfo.Label = Ambience.EscapeText(((ISymbol)dataObject).ToDisplayString(Ambience.NameFormat));
nodeInfo.Icon = Context.GetIcon(data.GetStockIcon());
}
public void FillInspectors(string filter)
{
categories.Clear();
treeStore.Clear();
var grouped = severities.Keys
.Where(node => node.Item2 == null && (string.IsNullOrEmpty(filter) || node.Item1.Name.IndexOf(filter, StringComparison.OrdinalIgnoreCase) > 0))
.GroupBy(node => node.Item1.GetProvider().SupportedDiagnostics.First().Category)
.OrderBy(g => g.Key, StringComparer.Ordinal);
foreach (var g in grouped)
{
TreeIter categoryIter = treeStore.AppendValues("<b>" + g.Key + "</b>", null, null);
categories [g.Key] = categoryIter;
foreach (var node in g.OrderBy(n => n.Item1.Name, StringComparer.Ordinal))
{
var title = node.Item1.Name;
MarkupSearchResult(filter, ref title);
var nodeIter = treeStore.AppendValues(categoryIter, title, node, Ambience.EscapeText(node.Item1.Name));
if (node.Item1.GetProvider().SupportedDiagnostics.Length > 1)
{
foreach (var subIssue in node.Item1.GetProvider().SupportedDiagnostics)
{
title = subIssue.Title.ToString();
MarkupSearchResult(filter, ref title);
treeStore.AppendValues(nodeIter, title, new Tuple <CodeDiagnosticDescriptor, DiagnosticDescriptor>(node.Item1, subIssue), Ambience.EscapeText(node.Item1.Name));
}
}
}
}
treeviewInspections.ExpandAll();
}
public override void BuildNode(ITreeBuilder treeBuilder, object dataObject, NodeInfo nodeInfo)
{
ClassData classData = dataObject as ClassData;
nodeInfo.Label = Ambience.EscapeText(classData.Class.ToDisplayString(NameFormat));
nodeInfo.Icon = Context.GetIcon(classData.Class.GetStockIcon());
}
public static void AppendTaggedText(this StringBuilder markup, EditorTheme theme, IEnumerable <TaggedText> text, int col, int maxColumn)
{
foreach (var part in text)
{
if (part.Tag != TextTags.Text)
{
markup.Append("<span foreground=\"");
markup.Append(GetThemeColor(theme, GetThemeColor(part.Tag)));
markup.Append("\">");
}
if (maxColumn >= 0 && col + part.Text.Length > maxColumn)
{
AppendAndBreakText(markup, part.Text, col, maxColumn);
col = 0;
}
else
{
markup.Append(Ambience.EscapeText(part.Text));
var lineBreak = part.Text.LastIndexOfAny(new [] { '\n', '\r' });
if (lineBreak >= 0)
{
col += part.Text.Length - lineBreak;
}
else
{
col += part.Text.Length;
}
}
if (part.Tag != TextTags.Text)
{
markup.Append("</span>");
}
}
}
/* public override void GetNodeAttributes (ITreeNavigator parentNode, object dataObject, ref NodeAttributes attributes)
* {
* attributes |= NodeAttributes.UseMarkup;
* }
*/
public override void BuildNode(ITreeBuilder treeBuilder, object dataObject, NodeInfo nodeInfo)
{
UnitTest test = dataObject as UnitTest;
nodeInfo.Icon = test.StatusIcon;
var singleTestSuffix = String.Empty;
if (test is UnitTestGroup unitTestGroup)
{
singleTestSuffix = GetSuffix(unitTestGroup, treeBuilder.Options ["CombineTestNamespaces"]);
}
var title = RemoveGenericArgument(test.Title);
title = test.Title + singleTestSuffix;
if (!string.IsNullOrEmpty(test.ErrorMessage))
{
nodeInfo.Label = Ambience.EscapeText(title);
nodeInfo.StatusMessage = test.ErrorMessage;
nodeInfo.StatusSeverity = Ide.Tasks.TaskSeverity.Error;
return;
}
if (test.Status == TestStatus.Running)
{
nodeInfo.Label = Ambience.EscapeText(title);
return;
}
else if (test.Status == TestStatus.Loading)
{
nodeInfo.Label = Ambience.EscapeText(title) + GettextCatalog.GetString(" (Loading)");
return;
}
else if (test.Status == TestStatus.LoadError)
{
nodeInfo.Label = Ambience.EscapeText(title) + GettextCatalog.GetString(" (Load failed)");
return;
}
else
{
nodeInfo.Label = Ambience.EscapeText(title);
UnitTestResult res = test.GetLastResult();
if (res != null && treeBuilder.Options ["ShowTestCounters"] && (test is UnitTestGroup))
{
nodeInfo.Label += string.Format(GettextCatalog.GetString(" ({0} passed, {1} failed, {2} not run)"), res.Passed, res.ErrorsAndFailures, res.TestsNotRun);
}
if (treeBuilder.Options ["ShowTestTime"])
{
nodeInfo.Label += string.Format(" Time: {0}ms", res.Time.TotalMilliseconds);
}
}
}
public override Window CreateTooltipWindow(TextEditor editor, DocumentContext ctx, TooltipItem item, int offset, Xwt.ModifierKeys modifierState)
{
var result = item.Item as List <Result>;
var sb = new StringBuilder();
foreach (var r in result)
{
var escapedMessage = Ambience.EscapeText(r.Message);
if (sb.Length > 0)
{
sb.AppendLine();
}
if (result.Count > 1)
{
string severity;
HslColor color;
switch (r.Level)
{
case Microsoft.CodeAnalysis.DiagnosticSeverity.Info:
severity = GettextCatalog.GetString("Info");
editor.Options.GetEditorTheme().TryGetColor(EditorThemeColors.UnderlineSuggestion, out color);
break;
case Microsoft.CodeAnalysis.DiagnosticSeverity.Warning:
severity = GettextCatalog.GetString("Warning");
editor.Options.GetEditorTheme().TryGetColor(EditorThemeColors.UnderlineWarning, out color);
break;
case Microsoft.CodeAnalysis.DiagnosticSeverity.Error:
severity = GettextCatalog.GetString("Error");
editor.Options.GetEditorTheme().TryGetColor(EditorThemeColors.UnderlineError, out color);
break;
default:
severity = "?";
editor.Options.GetEditorTheme().TryGetColor(EditorThemeColors.UnderlineSuggestion, out color);
break;
}
sb.AppendFormat("<span foreground ='{2}'font_weight='bold'>{0}</span>: {1}", severity, escapedMessage, color.ToPangoString());
}
else
{
sb.Append(escapedMessage);
}
}
var window = new LanguageItemWindow(CompileErrorTooltipProvider.GetExtensibleTextEditor(editor), modifierState, null, sb.ToString(), null);
if (window.IsEmpty)
{
return(null);
}
return(window);
}
public async Task GetTypes(MonoDevelop.Projects.DotNetProject project)
{
TypeNamesList = new List <string> ();
var ctx = await IdeApp.TypeSystemService.GetCompilationAsync(project);
TypesList = new List <INamedTypeSymbol> (ctx.GetAllTypesInMainAssembly());
foreach (var typeDef in TypesList)
{
TypeNamesList.Add(Ambience.EscapeText(typeDef.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)));
}
}
public override string GetDisplayTextMarkup()
{
var model = ext.ParsedDocument.GetAst <SemanticModel> ();
var result = "<b>" + Ambience.EscapeText(CropGlobal(RoslynCompletionData.SafeMinimalDisplayString(symbol, model, declarationBegin, HideParameters))) + "</b>()";
if (!afterKeyword)
{
result = "new " + result;
}
return(ApplyDiplayFlagsFormatting(result));
}
public static string ClassificationsToMarkup(ITextSnapshot snapshot, IList <ClassificationSpan> classifications, Span?locus)
{
var markup = new StringBuilder();
var theme = DefaultSourceEditorOptions.Instance.GetEditorTheme();
foreach (var part in classifications)
{
//if () { TODO: Check if we hanle new lines
// markup.AppendLine ();
// continue;
//}
markup.Append("<span foreground=\"");
markup.Append(GetThemeColor(theme, GetThemeColor(part.ClassificationType.Classification)));
markup.Append("\">");
if (locus is Span locusSpan && part.Span.Intersection(locusSpan) is SnapshotSpan intersection)
{
if (intersection.Start == part.Span.Start)
{
if (intersection.End == part.Span.End)
{
markup.Append("<b>");
markup.Append(Ambience.EscapeText(snapshot.GetText(part.Span)));
markup.Append("</b>");
}
else
{
markup.Append("<b>");
markup.Append(Ambience.EscapeText(snapshot.GetText(intersection)));
markup.Append("</b>");
markup.Append(Ambience.EscapeText(snapshot.GetText(intersection.End, part.Span.End - intersection.End)));
}
}
else
{
if (intersection.End == part.Span.End)
{
markup.Append(Ambience.EscapeText(snapshot.GetText(part.Span.Start, intersection.Start - part.Span.Start)));
markup.Append("<b>");
markup.Append(Ambience.EscapeText(snapshot.GetText(intersection)));
markup.Append("</b>");
}
else
{
markup.Append(Ambience.EscapeText(snapshot.GetText(part.Span.Start, intersection.Start - part.Span.Start)));
markup.Append("<b>");
markup.Append(Ambience.EscapeText(snapshot.GetText(intersection)));
markup.Append("</b>");
markup.Append(Ambience.EscapeText(snapshot.GetText(intersection.End, part.Span.End - intersection.End)));
}
}
}
public static void AppendTaggedText(this StringBuilder markup, EditorTheme theme, IEnumerable <TaggedText> text)
{
foreach (var part in text)
{
if (part.Tag != TextTags.Text)
{
markup.Append("<span foreground=\"");
markup.Append(GetThemeColor(theme, GetThemeColor(part.Tag)));
markup.Append("\">");
}
markup.Append(Ambience.EscapeText(part.Text));
if (part.Tag != TextTags.Text)
{
markup.Append("</span>");
}
}
}
static void AppendAndBreakText(StringBuilder markup, string text, int col, int maxColumn)
{
var idx = maxColumn - col > 0 && maxColumn - col < text.Length ? text.IndexOf(' ', maxColumn - col) : -1;
if (idx < 0)
{
markup.Append(Ambience.EscapeText(text));
}
else
{
markup.Append(Ambience.EscapeText(text.Substring(0, idx)));
if (idx + 1 >= text.Length)
{
return;
}
markup.AppendLine();
AppendAndBreakText(markup, text.Substring(idx + 1), 0, maxColumn);
}
}
public static void Save(TextWriter writer, EditorTheme theme)
{
writer.WriteLine("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
writer.WriteLine("<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">");
writer.WriteLine("<plist version=\"1.0\">");
writer.WriteLine("<dict>");
writer.WriteLine("\t<key>name</key>");
writer.WriteLine("\t<string>" + Ambience.EscapeText(theme.Name) + "</string>");
writer.WriteLine("\t<key>settings</key>");
writer.WriteLine("\t<array>");
foreach (var setting in theme.Settings)
{
writer.WriteLine("\t\t<dict>");
if (setting.Name != null)
{
writer.WriteLine("\t\t\t<key>name</key>");
writer.WriteLine("\t\t\t<string>" + Ambience.EscapeText(setting.Name) + "</string>");
}
if (setting.Scopes.Count > 0)
{
writer.WriteLine("\t\t\t<key>scope</key>");
writer.WriteLine("\t\t\t<string>" + Ambience.EscapeText(string.Join(", ", setting.Scopes)) + "</string>");
}
if (setting.Settings.Count > 0)
{
writer.WriteLine("\t\t\t<key>settings</key>");
writer.WriteLine("\t\t\t<dict>");
foreach (var kv in setting.Settings)
{
writer.WriteLine("\t\t\t\t<key>" + Ambience.EscapeText(kv.Key) + "</key>");
writer.WriteLine("\t\t\t\t<string>" + Ambience.EscapeText(kv.Value) + "</string>");
}
writer.WriteLine("\t\t\t</dict>");
}
writer.WriteLine("\t\t</dict>");
}
writer.WriteLine("\t</array>");
writer.WriteLine("\t<key>uuid</key>");
writer.WriteLine("\t<string>" + theme.Uuid + "</string>");
writer.WriteLine("</dict>");
writer.WriteLine("</plist>");
}
/* public override void GetNodeAttributes (ITreeNavigator parentNode, object dataObject, ref NodeAttributes attributes)
* {
* attributes |= NodeAttributes.UseMarkup;
* }
*/
public override void BuildNode(ITreeBuilder treeBuilder, object dataObject, NodeInfo nodeInfo)
{
UnitTest test = dataObject as UnitTest;
nodeInfo.Icon = test.StatusIcon;
var title = RemoveGenericArgument(test.Title);
title = test.Title;
if (test.Status == TestStatus.Running)
{
nodeInfo.Label = Ambience.EscapeText(title);
return;
}
else if (test.Status == TestStatus.Loading)
{
nodeInfo.Label = Ambience.EscapeText(title) + GettextCatalog.GetString(" (Loading)");
return;
}
else if (test.Status == TestStatus.LoadError)
{
nodeInfo.Label = Ambience.EscapeText(title) + GettextCatalog.GetString(" (Load failed)");
return;
}
else
{
nodeInfo.Label = Ambience.EscapeText(title);
UnitTestResult res = test.GetLastResult();
if (res != null && treeBuilder.Options ["ShowTestCounters"] && (test is UnitTestGroup))
{
nodeInfo.Label += string.Format(GettextCatalog.GetString(" ({0} passed, {1} failed, {2} not run)"), res.Passed, res.ErrorsAndFailures, res.TestsNotRun);
}
if (treeBuilder.Options ["ShowTestTime"])
{
nodeInfo.Label += string.Format(" Time: {0}ms", res.Time.TotalMilliseconds);
}
}
}
public override string GetDisplayTextMarkup()
{
var model = ext.ParsedDocument.GetAst <SemanticModel> ();
var result = Ambience.EscapeText(SafeMinimalDisplayString(base.Symbol, model, ext.Editor.CaretOffset, Ambience.LabelFormat)) + " {...}";
var idx = result.IndexOf(Symbol.Name, StringComparison.Ordinal);
if (idx >= 0)
{
result =
result.Substring(0, idx) +
"<b>" + Symbol.Name + "</b>" +
result.Substring(idx + Symbol.Name.Length);
}
if (!afterKeyword)
{
result = "partial " + result;
}
return(ApplyDiplayFlagsFormatting(result));
}
public static string ClassificationsToMarkup(ITextSnapshot snapshot, IList <ClassificationSpan> classifications, IParameter currentParameter)
{
var markup = new StringBuilder();
var theme = DefaultSourceEditorOptions.Instance.GetEditorTheme();
Span?locus = currentParameter?.Locus;
bool inDocumentation = false;
for (int i = 0; i < classifications.Count; i++)
{
var part = classifications [i];
if (!inDocumentation)
{
if (part.ClassificationType.Classification == ClassificationTypeNames.Text)
{
inDocumentation = true;
markup.Append("<span font='" + FontService.SansFontName + "' size='small'>");
markup.AppendLine();
}
else
{
markup.Append("<span foreground=\"");
markup.Append(GetThemeColor(theme, GetThemeColor(part.ClassificationType.Classification)));
markup.Append("\">");
}
}
if (locus is Span locusSpan && part.Span.Intersection(locusSpan) is SnapshotSpan intersection)
{
if (intersection.Start == part.Span.Start)
{
if (intersection.End == part.Span.End)
{
markup.Append("<b>");
markup.Append(Ambience.EscapeText(snapshot.GetText(part.Span)));
markup.Append("</b>");
}
else
{
markup.Append("<b>");
markup.Append(Ambience.EscapeText(snapshot.GetText(intersection)));
markup.Append("</b>");
markup.Append(Ambience.EscapeText(snapshot.GetText(intersection.End, part.Span.End - intersection.End)));
}
}
else
{
if (intersection.End == part.Span.End)
{
markup.Append(Ambience.EscapeText(snapshot.GetText(part.Span.Start, intersection.Start - part.Span.Start)));
markup.Append("<b>");
markup.Append(Ambience.EscapeText(snapshot.GetText(intersection)));
markup.Append("</b>");
}
else
{
markup.Append(Ambience.EscapeText(snapshot.GetText(part.Span.Start, intersection.Start - part.Span.Start)));
markup.Append("<b>");
markup.Append(Ambience.EscapeText(snapshot.GetText(intersection)));
markup.Append("</b>");
markup.Append(Ambience.EscapeText(snapshot.GetText(intersection.End, part.Span.End - intersection.End)));
}
}
}
void CreateMarkup(SearchResultWidget widget, TextEditor doc, Editor.IDocumentLine line)
{
int startIndex = 0, endIndex = 0;
int indent = line.GetIndentation(doc).Length;
string lineText;
int col = Offset - line.Offset;
int markupStartOffset = 0;
bool trimStart = false, trimEnd = false;
if (col < indent)
{
trimEnd = line.Length > maximumMarkupLength;
// search result contained part of the indent.
lineText = doc.GetTextAt(line.Offset, Math.Min(maximumMarkupLength, line.Length));
markup = doc.GetMarkup(line.Offset, Math.Min(maximumMarkupLength, line.Length), new MarkupOptions(MarkupFormat.Pango));
}
else
{
// if not crop the indent
var length = line.Length - indent;
if (length > maximumMarkupLength)
{
markupStartOffset = Math.Min(Math.Max(0, col - indent - maximumMarkupLength / 2), line.Length - maximumMarkupLength);
trimEnd = markupStartOffset + maximumMarkupLength < line.Length;
trimStart = markupStartOffset > 0;
length = maximumMarkupLength;
}
lineText = doc.GetTextAt(line.Offset + markupStartOffset + indent, length);
markup = doc.GetMarkup(line.Offset + markupStartOffset + indent, length, new MarkupOptions(MarkupFormat.Pango));
col -= indent;
}
selectedMarkup = Ambience.EscapeText(lineText);
markup = widget.AdjustColors(markup);
if (col >= 0)
{
uint start;
uint end;
try {
start = (uint)TranslateIndexToUTF8(lineText, col - markupStartOffset);
end = (uint)TranslateIndexToUTF8(lineText, Math.Min(lineText.Length, col - markupStartOffset + Length));
} catch (Exception e) {
LoggingService.LogError("Exception while translating index to utf8 (column was:" + col + " search result length:" + Length + " line text:" + lineText + ")", e);
return;
}
startIndex = (int)start;
endIndex = (int)end;
}
try {
var searchColor = GetBackgroundMarkerColor(widget.HighlightStyle);
double b1 = HslColor.Brightness(searchColor);
double b2 = HslColor.Brightness(SearchResultWidget.AdjustColor(widget.Style.Base(Gtk.StateType.Normal), SyntaxHighlightingService.GetColor(widget.HighlightStyle, EditorThemeColors.Foreground)));
double delta = Math.Abs(b1 - b2);
if (delta < 0.1)
{
var color1 = SyntaxHighlightingService.GetColor(widget.HighlightStyle, EditorThemeColors.FindHighlight);
if (color1.L + 0.5 > 1.0)
{
color1.L -= 0.5;
}
else
{
color1.L += 0.5;
}
searchColor = color1;
}
if (startIndex != endIndex)
{
markup = PangoHelper.ColorMarkupBackground(markup, (int)startIndex, (int)endIndex, searchColor);
}
// selected
var selectedSearchColor = widget.Style.Base(Gtk.StateType.Selected);
selectedSearchColor = searchColor.AddLight(-0.2);
selectedMarkup = PangoHelper.ColorMarkupBackground(selectedMarkup, (int)startIndex, (int)endIndex, selectedSearchColor);
} catch (Exception e) {
LoggingService.LogError("Error while setting the text renderer markup to: " + markup, e);
}
markup = markup.Replace("\t", new string (' ', doc.Options.TabSize));
selectedMarkup = selectedMarkup.Replace("\t", new string (' ', doc.Options.TabSize));
if (trimStart)
{
markup = "…" + markup;
selectedMarkup = "…" + selectedMarkup;
}
if (trimEnd)
{
markup += "…";
selectedMarkup += "…";
}
}
public override Control CreateTooltipWindow(TextEditor editor, DocumentContext ctx, TooltipItem item, int offset, Xwt.ModifierKeys modifierState)
{
var result = item.Item as Result;
var window = new LanguageItemWindow(CompileErrorTooltipProvider.GetExtensibleTextEditor(editor), modifierState, null, Ambience.EscapeText(result.Message), null);
if (window.IsEmpty)
{
return(null);
}
return(window);
}
void ResultTextDataFunc(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
{
if (TreeIter.Zero.Equals(iter))
{
return;
}
var textRenderer = (CellRendererText)cell;
var searchResult = (SearchResult)store.GetValue(iter, SearchResultColumn);
if (searchResult == null || searchResult.Offset < 0)
{
textRenderer.Markup = "Invalid search result";
return;
}
string textMarkup = markupCache.FirstOrDefault(t => t.Item1 == searchResult)?.Item2;
bool isSelected = treeviewSearchResults.Selection.IterIsSelected(iter);
if (isSelected)
{
textMarkup = null;
}
if (textMarkup == null)
{
var doc = GetDocument(searchResult);
if (doc == null)
{
textMarkup = "Can't create document for:" + searchResult.FileName;
goto end;
}
int lineNumber, startIndex = 0, endIndex = 0;
try {
lineNumber = doc.OffsetToLineNumber(searchResult.Offset);
} catch (ArgumentOutOfRangeException) {
lineNumber = -1;
textMarkup = "Invalid search result offset";
goto end;
}
var line = doc.GetLine(lineNumber);
if (line == null)
{
textMarkup = "Invalid line number " + lineNumber + " from offset: " + searchResult.Offset;
goto end;
}
int indent = line.GetIndentation(doc).Length;
var lineText = doc.GetTextAt(line.Offset + indent, line.Length - indent);
int col = searchResult.Offset - line.Offset - indent;
// search result contained part of the indent.
if (col + searchResult.Length < lineText.Length)
{
lineText = doc.GetTextAt(line.Offset, line.Length);
}
string markup;
if (isSelected)
{
markup = Ambience.EscapeText(doc.GetTextAt(line.Offset + indent, line.Length - indent));
}
else
{
markup = doc.GetMarkup(line.Offset + indent, line.Length - indent, new MarkupOptions(MarkupFormat.Pango));
markup = AdjustColors(markup);
}
if (col >= 0)
{
uint start;
uint end;
try {
start = (uint)TranslateIndexToUTF8(lineText, col);
end = (uint)TranslateIndexToUTF8(lineText, Math.Min(lineText.Length, col + searchResult.Length));
} catch (Exception e) {
LoggingService.LogError("Exception while translating index to utf8 (column was:" + col + " search result length:" + searchResult.Length + " line text:" + lineText + ")", e);
return;
}
startIndex = (int)start;
endIndex = (int)end;
}
try {
textMarkup = markup;
if (!isSelected)
{
var searchColor = searchResult.GetBackgroundMarkerColor(highlightStyle);
double b1 = HslColor.Brightness(searchColor);
double b2 = HslColor.Brightness(AdjustColor(Style.Base(StateType.Normal), SyntaxHighlightingService.GetColor(highlightStyle, EditorThemeColors.Foreground)));
double delta = Math.Abs(b1 - b2);
if (delta < 0.1)
{
var color1 = SyntaxHighlightingService.GetColor(highlightStyle, EditorThemeColors.FindHighlight);
if (color1.L + 0.5 > 1.0)
{
color1.L -= 0.5;
}
else
{
color1.L += 0.5;
}
searchColor = color1;
}
if (startIndex != endIndex)
{
textMarkup = PangoHelper.ColorMarkupBackground(textMarkup, (int)startIndex, (int)endIndex, searchColor);
}
}
else
{
var searchColor = this.treeviewSearchResults.Style.Base(StateType.Selected);
searchColor = searchColor.AddLight(-0.2);
textMarkup = PangoHelper.ColorMarkupBackground(textMarkup, (int)startIndex, (int)endIndex, searchColor);
}
} catch (Exception e) {
LoggingService.LogError("Error whil setting the text renderer markup to: " + markup, e);
}
end:
textMarkup = textMarkup.Replace("\t", new string (' ', doc.Options.TabSize));
if (!isSelected)
{
markupCache.Add(Tuple.Create(searchResult, textMarkup));
if (markupCache.Count > 100)
{
markupCache.RemoveAt(0);
}
}
}
textRenderer.Markup = textMarkup;
}
public virtual string GetDescriptionMarkupText()
{
return(Ambience.EscapeText(Description));
}
async Task <string> CreateMarkupAsync(SearchResultWidget widget, TextEditor doc, Editor.IDocumentLine line)
{
int startIndex = 0, endIndex = 0;
int indent = line.GetIndentation(doc).Length;
string lineText;
int col = Offset - line.Offset;
int markupStartOffset = 0;
bool trimStart = false, trimEnd = false;
int length;
if (col < indent)
{
trimEnd = line.Length > maximumMarkupLength;
length = Math.Min(maximumMarkupLength, line.Length);
// search result contained part of the indent.
lineText = doc.GetTextAt(line.Offset, length);
}
else
{
// if not crop the indent
length = line.Length - indent;
if (length > maximumMarkupLength)
{
markupStartOffset = Math.Min(Math.Max(0, col - indent - maximumMarkupLength / 2), line.Length - maximumMarkupLength);
trimEnd = markupStartOffset + maximumMarkupLength < line.Length;
trimStart = markupStartOffset > 0;
length = maximumMarkupLength;
}
lineText = doc.GetTextAt(line.Offset + markupStartOffset + indent, length);
col -= indent;
}
if (col >= 0)
{
uint start;
uint end;
try {
start = (uint)TranslateIndexToUTF8(lineText, col - markupStartOffset);
end = (uint)TranslateIndexToUTF8(lineText, Math.Min(lineText.Length, col - markupStartOffset + Length));
} catch (Exception e) {
LoggingService.LogError("Exception while translating index to utf8 (column was:" + col + " search result length:" + Length + " line text:" + lineText + ")", e);
return("");
}
startIndex = (int)start;
endIndex = (int)end;
}
var tabSize = doc.Options.TabSize;
this.markup = this.selectedMarkup = markup = Ambience.EscapeText(lineText);
var searchColor = GetBackgroundMarkerColor(widget.HighlightStyle);
var selectedSearchColor = widget.Style.Base(Gtk.StateType.Selected);
selectedSearchColor = searchColor.AddLight(-0.2);
double b1 = HslColor.Brightness(searchColor);
double b2 = HslColor.Brightness(SearchResultWidget.AdjustColor(widget.Style.Base(Gtk.StateType.Normal), SyntaxHighlightingService.GetColor(widget.HighlightStyle, EditorThemeColors.Foreground)));
// selected
markup = FormatMarkup(PangoHelper.ColorMarkupBackground(selectedMarkup, (int)startIndex, (int)endIndex, searchColor), trimStart, trimEnd, tabSize);
selectedMarkup = FormatMarkup(PangoHelper.ColorMarkupBackground(selectedMarkup, (int)startIndex, (int)endIndex, selectedSearchColor), trimStart, trimEnd, tabSize);
string newMarkup;
using (var markupTimeoutSource = new CancellationTokenSource(150)) {
newMarkup = await doc.GetMarkupAsync(line.Offset + markupStartOffset + indent, length, new MarkupOptions (MarkupFormat.Pango), markupTimeoutSource.Token).ConfigureAwait(false);
newMarkup = widget.AdjustColors(newMarkup);
}
try {
double delta = Math.Abs(b1 - b2);
if (delta < 0.1)
{
var color1 = SyntaxHighlightingService.GetColor(widget.HighlightStyle, EditorThemeColors.FindHighlight);
if (color1.L + 0.5 > 1.0)
{
color1.L -= 0.5;
}
else
{
color1.L += 0.5;
}
searchColor = color1;
}
if (startIndex != endIndex)
{
newMarkup = PangoHelper.ColorMarkupBackground(newMarkup, (int)startIndex, (int)endIndex, searchColor);
}
} catch (Exception e) {
LoggingService.LogError("Error while setting the text renderer markup to: " + newMarkup, e);
}
return(FormatMarkup(newMarkup, trimStart, trimEnd, tabSize));
}
public override async Task <TooltipItem> GetItem(TextEditor editor, DocumentContext ctx, int offset, CancellationToken token = default(CancellationToken))
{
var results = new List <Result> ();
int markerOffset = -1, markerEndOffset = -1;
foreach (var marker in editor.GetTextSegmentMarkersAt(offset))
{
if (marker.Tag is Result result)
{
if (result.Level == Microsoft.CodeAnalysis.DiagnosticSeverity.Hidden && result.InspectionMark == IssueMarker.WavedLine)
{
continue;
}
if (markerOffset < 0)
{
markerOffset = marker.Offset;
markerEndOffset = marker.EndOffset;
}
else
{
markerOffset = Math.Max(markerOffset, marker.Offset);
markerEndOffset = Math.Min(markerEndOffset, marker.EndOffset);
}
results.Add(result);
}
}
if (results.Count == 0)
{
return(null);
}
var sb = StringBuilderCache.Allocate();
sb.Append("<span font='");
sb.Append(FontService.SansFontName);
sb.Append("' size='small'>");
int minOffset = int.MaxValue;
int maxOffset = -1;
bool floatingWidgetShown = false;
for (int i = 0; i < results.Count; i++)
{
var r = results [i];
var escapedMessage = Ambience.EscapeText(r.Message);
if (i > 0)
{
sb.AppendLine();
}
minOffset = Math.Min(minOffset, r.Region.Start);
maxOffset = Math.Max(maxOffset, r.Region.End);
floatingWidgetShown |= r.InspectionMark == IssueMarker.WavedLine;
if (results.Count > 1)
{
string severity;
HslColor color;
switch (r.Level)
{
case Microsoft.CodeAnalysis.DiagnosticSeverity.Info:
severity = GettextCatalog.GetString("Info");
editor.Options.GetEditorTheme().TryGetColor(EditorThemeColors.UnderlineSuggestion, out color);
break;
case Microsoft.CodeAnalysis.DiagnosticSeverity.Warning:
severity = GettextCatalog.GetString("Warning");
editor.Options.GetEditorTheme().TryGetColor(EditorThemeColors.UnderlineWarning, out color);
break;
case Microsoft.CodeAnalysis.DiagnosticSeverity.Error:
severity = GettextCatalog.GetString("Error");
editor.Options.GetEditorTheme().TryGetColor(EditorThemeColors.UnderlineError, out color);
break;
default:
severity = "?";
editor.Options.GetEditorTheme().TryGetColor(EditorThemeColors.UnderlineSuggestion, out color);
break;
}
sb.AppendFormat("<span foreground ='{2}'font_weight='bold'>{0}</span>: {1}", severity, escapedMessage, color.ToPangoString());
}
else
{
sb.Append(escapedMessage);
}
}
sb.Append("</span>");
CodeActions.CodeActionContainer tag = null;
try {
var ad = ctx.AnalysisDocument;
var root = await ad.GetSyntaxRootAsync(token);
if (root.Span.End < offset)
{
LoggingService.LogError($"Error in ResultTooltipProvider.GetItem offset {offset} not inside syntax root {root.Span.End} document length {editor.Length}.");
}
else
{
var codeFixService = Ide.Composition.CompositionManager.GetExportedValue <ICodeFixService> ();
var span = new TextSpan(offset, 0);
var fixes = await codeFixService.GetFixesAsync(ad, span, true, token);
var codeRefactoringService = Ide.Composition.CompositionManager.GetExportedValue <Microsoft.CodeAnalysis.CodeRefactorings.ICodeRefactoringService> ();
var refactorings = await codeRefactoringService.GetRefactoringsAsync(ad, span, token);
tag = new CodeActions.CodeActionContainer(fixes, refactorings)
{
Span = new TextSpan(minOffset, Math.Max(0, maxOffset - minOffset)),
FloatingWidgetShown = floatingWidgetShown
};
}
} catch (AggregateException ae) {
ae.Flatten().Handle(aex => aex is OperationCanceledException);
} catch (OperationCanceledException) {
} catch (TargetInvocationException ex) {
if (!(ex.InnerException is OperationCanceledException))
{
throw;
}
}
if (tag == null)
{
return(null);
}
var tooltipInfo = new TaggedTooltipInformation <CodeActions.CodeActionContainer> {
SignatureMarkup = StringBuilderCache.ReturnAndFree(sb),
Tag = tag
};
return(new TooltipItem(tooltipInfo, markerOffset, markerEndOffset - markerOffset));
}
public RoslynCompletionCategory(ISymbol symbol)
{
this.symbol = symbol;
this.DisplayText = Ambience.EscapeText(symbol.ToDisplayString(MonoDevelop.Ide.TypeSystem.Ambience.NameFormat));
this.Icon = MonoDevelop.Ide.TypeSystem.Stock.GetStockIcon(symbol);
}
