public LanguageItemWindow (ILanguageItem item, IParserContext ctx, Ambience ambience,
string errorInformations) : base (WindowType.Popup)
{
Name = "gtk-tooltips";
// Approximate value for usual case
StringBuilder s = new StringBuilder(150);
if (item != null) {
if (item is IParameter) {
s.Append ("<small><i>");
s.Append (paramStr);
s.Append ("</i></small>\n");
s.Append (ambience.Convert ((IParameter)item, WindowConversionFlags));
} else if (item is LocalVariable) {
s.Append ("<small><i>");
s.Append (localStr);
s.Append ("</i></small>\n");
s.Append (ambience.Convert ((LocalVariable)item, WindowConversionFlags));
} else if (item is IField) {
s.Append ("<small><i>");
s.Append (fieldStr);
s.Append ("</i></small>\n");
s.Append (ambience.Convert ((IField)item, WindowConversionFlags));
} else if (item is IProperty) {
s.Append ("<small><i>");
s.Append (propertyStr);
s.Append ("</i></small>\n");
s.Append (ambience.Convert ((IProperty)item, WindowConversionFlags));
} else if (item is Namespace) {
s.Append ("namespace <b>");
s.Append (item.Name);
s.Append ("</b>");
} else
s.Append (ambience.Convert (item, WindowConversionFlags));
string doc = GetDocumentation (item.Documentation).Trim ('\n');
if (!string.IsNullOrEmpty (doc)) {
s.Append ("\n<small>");
s.Append (doc);
s.Append ("</small>");
}
}
if (!string.IsNullOrEmpty (errorInformations)) {
if (s.Length != 0)
s.Append ("\n\n");
s.Append ("<small>");
s.Append (errorInformations);
s.Append ("</small>");
}
Label lab = new Label ();
lab.Markup = s.ToString ();
lab.Xalign = 0;
lab.Xpad = 3;
lab.Ypad = 3;
Add (lab);
}
void OutlineTreeTextFunc(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
{
CellRendererText txtRenderer = (CellRendererText)cell;
object o = model.GetValue(iter, 0);
Ambience am = GetAmbience();
if (o is IEntity)
{
txtRenderer.Text = am.GetString((IEntity)o, OutputFlags.ClassBrowserEntries);
}
else if (o is FoldingRegion)
{
string name = ((FoldingRegion)o).Name.Trim();
if (string.IsNullOrEmpty(name))
{
name = "#region";
}
txtRenderer.Text = name;
}
}
string IAssemblyBrowserNodeBuilder.GetDocumentationMarkup(ITreeNavigator navigator)
{
var method = (IUnresolvedMethod)navigator.DataItem;
var resolved = Resolve(navigator, method);
if (GetMainAssembly(navigator) == null)
{
return(StringTextSource.ReadFrom(method.Region.FileName).Text);
}
StringBuilder result = new StringBuilder();
result.Append("<big>");
result.Append(MonoDevelop.Ide.TypeSystem.Ambience.EscapeText(Ambience.ConvertSymbol(resolved)));
result.Append("</big>");
result.AppendLine();
//result.Append (AmbienceService.GetDocumentationMarkup (resolved, AmbienceService.GetDocumentation (resolved), options));
return(result.ToString());
}
string IAssemblyBrowserNodeBuilder.GetDocumentationMarkup(ITreeNavigator navigator)
{
DomCecilMethod method = navigator.DataItem as DomCecilMethod;
StringBuilder result = new StringBuilder();
result.Append("<big>");
result.Append(Ambience.GetString(method, OutputFlags.AssemblyBrowserDescription));
result.Append("</big>");
result.AppendLine();
AmbienceService.DocumentationFormatOptions options = new AmbienceService.DocumentationFormatOptions();
options.MaxLineLength = -1;
options.BigHeadings = true;
options.Ambience = Ambience;
result.AppendLine();
result.Append(AmbienceService.GetDocumentationMarkup(AmbienceService.GetDocumentation(method), options));
return(result.ToString());
}
string IAssemblyBrowserNodeBuilder.GetDocumentationMarkup(ITreeNavigator navigator)
{
var property = (IUnresolvedProperty)navigator.DataItem;
var resolved = Resolve(navigator, property);
StringBuilder result = new StringBuilder();
result.Append("<big>");
result.Append(Ambience.GetString(resolved, OutputFlags.AssemblyBrowserDescription));
result.Append("</big>");
result.AppendLine();
AmbienceService.DocumentationFormatOptions options = new AmbienceService.DocumentationFormatOptions();
options.MaxLineLength = -1;
options.BigHeadings = true;
options.Ambience = Ambience;
result.AppendLine();
result.Append(AmbienceService.GetDocumentationMarkup(resolved, AmbienceService.GetDocumentation(resolved), options));
return(result.ToString());
}
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.LineBreak)
{
markup.AppendLine();
col = 0;
continue;
}
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 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);
}
}
}
private void Main_DoUpdate(On.Terraria.Main.orig_DoUpdate orig, Main self, GameTime gameTime)
{
GeneralHelpers.ClickHandling();
GeneralHelpers.UpdateButtons();
orig(self, gameTime);
var aLoader = Ambience.Instance;
Ambience.DoUpdate_Ambience();
Ambience.UpdateVolume();
if (Main.gameMenu)
{
return;
}
Player player = Main.player[Main.myPlayer]?.GetModPlayer <FootstepsPlayer>().player;
// soundInstancer.Condition = player.ZoneSkyHeight;
if (Main.hasFocus)
{
delta_lastPos_playerBottom = lastPlayerPositionOnGround - player.Bottom.Y;
// Main.NewText(delta_lastPos_playerBottom);
if (ModContent.GetInstance <AmbientConfigServer>().newSplashes)
{
if (player.velocity.Y <= 0 || player.teleporting)
{
lastPlayerPositionOnGround = player.Bottom.Y;
}
// Main.NewText(player.fallStart - player.Bottom.Y);
if (delta_lastPos_playerBottom > -300)
{
Main.soundSplash[0] = Ambience.SplashNew;
}
else if (delta_lastPos_playerBottom <= -300)
{
Main.soundSplash[0] = GetSound($"{Ambience.AmbientPath}/environment/liquid/entity_splash_heavy");
}
}
}
Ambience.ClampAll();
}
string IAssemblyBrowserNodeBuilder.GetDecompiledCode(ITreeNavigator navigator)
{
IProperty property = (IProperty)navigator.DataItem;
StringBuilder result = new StringBuilder();
result.Append(DomMethodNodeBuilder.GetAttributes(Ambience, property.Attributes));
result.Append(Ambience.GetString(property, DomTypeNodeBuilder.settings));
result.Append("{"); result.AppendLine();
DomCecilProperty cecilProperty = property as DomCecilProperty;
if (property.HasGet)
{
result.Append("\t");
if (property.GetterModifier != property.Modifiers)
{
result.Append("<span style=\"keyword.modifier\">");
result.Append(Ambience.GetString(property.GetterModifier));
result.Append("</span> ");
}
result.Append("<b>get</b> {"); result.AppendLine();
result.Append(DomMethodNodeBuilder.Decompile(cecilProperty.GetMethod as DomCecilMethod, true).Replace("\t", "\t\t"));
result.Append("\t}"); result.AppendLine();
}
if (property.HasSet)
{
result.Append("\t");
if (property.SetterModifier != property.Modifiers)
{
result.Append("<span style=\"keyword.modifier\">");
result.Append(Ambience.GetString(property.SetterModifier));
result.Append("</span> ");
}
result.Append("<b>set</b> {"); result.AppendLine();
result.Append(DomMethodNodeBuilder.Decompile(cecilProperty.SetMethod as DomCecilMethod, true).Replace("\t", "\t\t"));
result.Append("\t}"); result.AppendLine();
}
result.Append("}");
return(result.ToString());
}
public static void AppendTaggedText(this StringBuilder markup, EditorTheme theme, IEnumerable <TaggedText> text)
{
foreach (var part in text)
{
if (part.Tag == TextTags.LineBreak)
{
markup.AppendLine();
continue;
}
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>");
}
}
}
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 string GetDisassembly(ITreeNavigator navigator)
{
bool publicOnly = navigator.Options ["PublicApiOnly"];
Namespace ns = (Namespace)navigator.DataItem;
StringBuilder result = new StringBuilder();
if (!String.IsNullOrEmpty(ns.Name))
{
result.Append("<span style=\"keyword.namespace\">namespace</span> ");
result.Append("<span style=\"text\">");
result.Append(ns.Name);
result.Append("</span>");
result.AppendLine();
result.Append("<span style=\"text\">{</span>");
result.AppendLine();
}
foreach (IType type in ns.Types)
{
if (publicOnly && !type.IsPublic)
{
continue;
}
if (!String.IsNullOrEmpty(ns.Name))
{
result.Append("\t");
}
result.Append(Ambience.GetString(type, DomTypeNodeBuilder.settings));
result.AppendLine();
}
if (!String.IsNullOrEmpty(ns.Name))
{
result.Append("<span style=\"text\">}</span>");
result.AppendLine();
}
return(result.ToString());
}
void AddAspAttributeValueCompletionData(CompletionDataList list, XName tagName, XName attName, string id)
{
Debug.Assert(tagName.IsValid && tagName.HasPrefix);
Debug.Assert(attName.IsValid && !attName.HasPrefix);
INamedTypeSymbol controlClass = refman.GetControlType(tagName.Prefix, tagName.Name);
if (controlClass == null)
{
return;
}
//find the codebehind class
INamedTypeSymbol codeBehindClass;
GetCodeBehind(out codeBehindClass);
//if it's an event, suggest compatible methods
if (codeBehindClass != null && attName.Name.StartsWith("On", StringComparison.Ordinal))
{
string eventName = attName.Name.Substring(2);
foreach (IEventSymbol ev in controlClass.GetAccessibleMembersInThisAndBaseTypes <IEventSymbol> (controlClass))
{
if (ev.Name == eventName)
{
var domMethod = BindingService.MDDomToCodeDomMethod(ev);
if (domMethod == null)
{
return;
}
foreach (IMethodSymbol meth
in BindingService.GetCompatibleMethodsInClass(codeBehindClass, ev))
{
list.Add(meth.Name, "md-method",
GettextCatalog.GetString("A compatible method in the CodeBehind class"));
}
string suggestedIdentifier = ev.Name;
if (id != null)
{
suggestedIdentifier = id + "_" + suggestedIdentifier;
}
else
{
suggestedIdentifier = tagName.Name + "_" + suggestedIdentifier;
}
domMethod.Name = BindingService.GenerateIdentifierUniqueInClass
(codeBehindClass, suggestedIdentifier);
domMethod.Attributes = (domMethod.Attributes & ~System.CodeDom.MemberAttributes.AccessMask)
| System.CodeDom.MemberAttributes.Family;
list.Add(
new SuggestedHandlerCompletionData(project, domMethod, codeBehindClass,
CodeBehind.GetNonDesignerClassLocation(codeBehindClass))
);
return;
}
}
}
//if it's a property and is an enum or bool, suggest valid values
foreach (IPropertySymbol prop in GetAllMembers <IPropertySymbol> (controlClass))
{
if (prop.Name != attName.Name)
{
continue;
}
//boolean completion
if (prop.GetReturnType().Equals(refman.Compilation.GetTypeByMetadataName("System.Boolean")))
{
AddBooleanCompletionData(list);
return;
}
//color completion
if (prop.GetReturnType().Equals(refman.Compilation.GetTypeByMetadataName("System.Drawing.Color")))
{
var conv = new System.Drawing.ColorConverter();
foreach (System.Drawing.Color c in conv.GetStandardValues(null))
{
if (c.IsSystemColor)
{
continue;
}
string hexcol = string.Format("#{0:x2}{1:x2}{2:x2}", c.R, c.G, c.B);
list.Add(c.Name, hexcol);
}
return;
}
//enum completion
var retCls = prop.GetReturnType() as INamedTypeSymbol;
if (retCls != null && retCls.TypeKind == TypeKind.Enum)
{
foreach (var enumVal in GetAllMembers <IFieldSymbol> (retCls))
{
if (enumVal.DeclaredAccessibility == Accessibility.Public && enumVal.IsStatic)
{
list.Add(enumVal.Name, "md-literal", Ambience.GetSummaryMarkup(enumVal));
}
}
return;
}
}
}
public virtual string GetDescriptionMarkupText()
{
return(Ambience.EscapeText(Description));
}
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();
}
// TODO: Roslyn port
// public override ParameterHintingResult HandleParameterCompletionAsync (CodeCompletionContext completionContext, char completionChar)
// {
///* if (Tracker.Engine.CurrentState is AspNetExpressionState && documentBuilder != null && localDocumentInfo != null) {
// return documentBuilder.HandleParameterCompletion (defaultDocument, completionContext, documentInfo, localDocumentInfo, completionChar);
// }*/
//
// return base.HandleParameterCompletionAsync (completionContext, completionChar);
// }
/*public override void RunParameterCompletionCommand ()
* {
* if (localDocumentInfo == null) {
* base.RunParameterCompletionCommand ();
* return;
* }
* var doc = document;
* document = localDocumentInfo.HiddenDocument;
* var cw = CompletionWidget;
* CompletionWidget = documentBuilder.CreateCompletionWidget (localDocumentInfo);
* try {
* base.RunParameterCompletionCommand ();
* } finally {
* document = doc;
* CompletionWidget = cw;
* }
* }*/
protected override async Task <CompletionDataList> GetElementCompletions(CancellationToken token)
{
var list = new CompletionDataList();
XName parentName = GetParentElementName(0);
INamedTypeSymbol controlClass = null;
if (parentName.HasPrefix)
{
controlClass = refman.GetControlType(parentName.Prefix, parentName.Name);
}
else
{
XName grandparentName = GetParentElementName(1);
if (grandparentName.IsValid && grandparentName.HasPrefix)
{
controlClass = refman.GetControlType(grandparentName.Prefix, grandparentName.Name);
}
}
//we're just in HTML
if (controlClass == null)
{
//root element?
if (!parentName.IsValid)
{
if (aspDoc.Info.Subtype == WebSubtype.WebControl)
{
await AddHtmlTagCompletionData(list, Schema, new XName ("div"), token);
AddAspBeginExpressions(list);
list.AddRange(refman.GetControlCompletionData());
AddMiscBeginTags(list);
}
else if (!string.IsNullOrEmpty(aspDoc.Info.MasterPageFile))
{
//FIXME: add the actual region names
list.Add(new CompletionData("asp:Content"));
}
}
else
{
AddAspBeginExpressions(list);
list.AddRange(refman.GetControlCompletionData());
list.AddRange(await base.GetElementCompletions(token));
}
return(list);
}
string defaultProp;
bool childrenAsProperties = AreChildrenAsProperties(controlClass, out defaultProp);
if (defaultProp != null && defaultProp.Length == 0)
{
defaultProp = null;
}
//parent permits child controls directly
if (!childrenAsProperties)
{
AddAspBeginExpressions(list);
list.AddRange(refman.GetControlCompletionData());
AddMiscBeginTags(list);
//TODO: get correct parent for Content tags
await AddHtmlTagCompletionData(list, Schema, new XName ("body"), token);
return(list);
}
//children of properties
if (childrenAsProperties && (!parentName.HasPrefix || defaultProp != null))
{
string propName = defaultProp ?? parentName.Name;
IPropertySymbol property =
controlClass.GetMembers().OfType <IPropertySymbol> ()
.FirstOrDefault(x => string.Equals(propName, x.Name, StringComparison.OrdinalIgnoreCase));
if (property == null)
{
return(list);
}
//sanity checks on attributes
switch (GetPersistenceMode(property))
{
case System.Web.UI.PersistenceMode.Attribute:
case System.Web.UI.PersistenceMode.EncodedInnerDefaultProperty:
return(list);
case System.Web.UI.PersistenceMode.InnerDefaultProperty:
if (!parentName.HasPrefix)
{
return(list);
}
break;
case System.Web.UI.PersistenceMode.InnerProperty:
if (parentName.HasPrefix)
{
return(list);
}
break;
}
//check if allows freeform ASP/HTML content
if (property.GetReturnType().GetFullName() == "System.Web.UI.ITemplate")
{
AddAspBeginExpressions(list);
AddMiscBeginTags(list);
await AddHtmlTagCompletionData(list, Schema, new XName ("body"), token);
list.AddRange(refman.GetControlCompletionData());
return(list);
}
//FIXME:unfortunately ASP.NET doesn't seem to have enough type information / attributes
//to be able to resolve the correct child types here
//so we assume it's a list and have a quick hack to find arguments of strongly typed ILists
ITypeSymbol collectionType = property.GetReturnType();
if (collectionType == null)
{
list.AddRange(refman.GetControlCompletionData());
return(list);
}
string addStr = "Add";
IMethodSymbol meth = collectionType.GetMembers().OfType <IMethodSymbol> ().FirstOrDefault(m => m.Parameters.Length == 1 && m.Name == addStr);
if (meth != null)
{
var argType = meth.Parameters [0].Type as INamedTypeSymbol;
INamedTypeSymbol type = refman.Compilation.GetTypeByMetadataName("System.Web.UI.Control");
if (argType != null && type != null && argType.IsDerivedFromClass(type))
{
list.AddRange(refman.GetControlCompletionData(argType));
return(list);
}
}
list.AddRange(refman.GetControlCompletionData());
return(list);
}
//properties as children of controls
if (parentName.HasPrefix && childrenAsProperties)
{
foreach (IPropertySymbol prop in GetUniqueMembers <IPropertySymbol> (controlClass.GetMembers().OfType <IPropertySymbol> ()))
{
if (GetPersistenceMode(prop) != System.Web.UI.PersistenceMode.Attribute)
{
list.Add(prop.Name, prop.GetStockIcon(), Ambience.GetSummaryMarkup(prop));
}
}
}
return(list);
}
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;
}
IEnumerator RandomOneshotPlayer(AudioSourcePRO s, Ambience.AmbienceSetting setting, Ambience ambience, bool immediate = false)
{
if (immediate)
{
//yield return new WaitForSeconds(setting.Delay());
}
if (!s.isPlaying)
{
s.Play(0);
}
yield return(new WaitForSeconds(setting.Delay()));
StartCoroutine(RandomPlayer(s, setting, ambience));
}
public override List <Change> PerformChanges(RefactoringOptions options, object prop)
{
List <Change> result = new List <Change> ();
ExtractMethodParameters param = (ExtractMethodParameters)prop;
TextEditorData data = options.GetTextEditorData();
INRefactoryASTProvider provider = options.GetASTProvider();
IResolver resolver = options.GetResolver();
ICSharpCode.NRefactory.Ast.INode node = Analyze(options, param, false);
if (param.VariablesToGenerate.Count > 0)
{
TextReplaceChange varGen = new TextReplaceChange();
varGen.Description = GettextCatalog.GetString("Generate some temporary variables");
varGen.FileName = options.Document.FileName;
LineSegment line = data.Document.GetLine(Math.Max(0, data.Document.OffsetToLineNumber(data.SelectionRange.Offset) - 1));
varGen.Offset = line.Offset + line.EditableLength;
varGen.InsertedText = Environment.NewLine + options.GetWhitespaces(line.Offset);
foreach (VariableDescriptor var in param.VariablesToGenerate)
{
TypeReference tr = options.ShortenTypeName(var.ReturnType).ConvertToTypeReference();
varGen.InsertedText += provider.OutputNode(options.Dom, new LocalVariableDeclaration(new VariableDeclaration(var.Name, null, tr))).Trim();
}
result.Add(varGen);
}
InvocationExpression invocation = new InvocationExpression(new IdentifierExpression(param.Name));
foreach (VariableDescriptor var in param.Parameters)
{
if (!param.OneChangedVariable && param.ChangedVariables.Contains(var.Name))
{
FieldDirection fieldDirection = FieldDirection.Ref;
VariableDescriptor outsideVar = null;
if (param.VariablesOutside.TryGetValue(var.Name, out outsideVar) && (var.GetsAssigned || param.VariablesToGenerate.Where(v => v.Name == var.Name).Any()))
{
if (!outsideVar.GetsAssigned)
{
fieldDirection = FieldDirection.Out;
}
}
invocation.Arguments.Add(new DirectionExpression(fieldDirection, new IdentifierExpression(var.Name)));
}
else
{
invocation.Arguments.Add(new IdentifierExpression(var.Name));
}
}
// string mimeType = DesktopService.GetMimeTypeForUri (options.Document.FileName);
TypeReference returnType = new TypeReference("System.Void", true);
ICSharpCode.NRefactory.Ast.INode outputNode;
if (param.OneChangedVariable)
{
string name = param.ChangedVariables.First();
returnType = options.ShortenTypeName(param.Variables.Find(v => v.Name == name).ReturnType).ConvertToTypeReference();
if (param.OutsideVariableList.Any(v => v.Name == name && !v.IsDefined))
{
LocalVariableDeclaration varDecl = new LocalVariableDeclaration(returnType);
varDecl.Variables.Add(new VariableDeclaration(name, invocation));
outputNode = varDecl;
}
else
{
outputNode = new ExpressionStatement(new AssignmentExpression(new IdentifierExpression(name), ICSharpCode.NRefactory.Ast.AssignmentOperatorType.Assign, invocation));
}
}
else
{
outputNode = node is BlockStatement ? (ICSharpCode.NRefactory.Ast.INode) new ExpressionStatement(invocation) : invocation;
}
TextReplaceChange replacement = new TextReplaceChange();
replacement.Description = string.Format(GettextCatalog.GetString("Substitute selected statement(s) with call to {0}"), param.Name);
replacement.FileName = options.Document.FileName;
replacement.Offset = options.Document.TextEditor.SelectionStartPosition;
replacement.RemovedChars = options.Document.TextEditor.SelectionEndPosition - options.Document.TextEditor.SelectionStartPosition;
replacement.MoveCaretToReplace = true;
LineSegment line1 = data.Document.GetLineByOffset(options.Document.TextEditor.SelectionEndPosition);
if (options.Document.TextEditor.SelectionEndPosition == line1.Offset)
{
if (line1.Offset > 0)
{
LineSegment line2 = data.Document.GetLineByOffset(line1.Offset - 1);
replacement.RemovedChars -= line2.DelimiterLength;
}
}
replacement.InsertedText = options.GetWhitespaces(options.Document.TextEditor.SelectionStartPosition) + provider.OutputNode(options.Dom, outputNode).Trim();
result.Add(replacement);
TextReplaceChange insertNewMethod = new TextReplaceChange();
insertNewMethod.FileName = options.Document.FileName;
insertNewMethod.Description = string.Format(GettextCatalog.GetString("Create new method {0} from selected statement(s)"), param.Name);
insertNewMethod.RemovedChars = param.InsertionPoint.LineBefore == NewLineInsertion.Eol ? 0 : param.InsertionPoint.Location.Column;
insertNewMethod.Offset = data.Document.LocationToOffset(param.InsertionPoint.Location) - insertNewMethod.RemovedChars;
ExtractMethodAstTransformer transformer = new ExtractMethodAstTransformer(param.VariablesToGenerate);
node.AcceptVisitor(transformer, null);
if (!param.OneChangedVariable && node is Expression)
{
ResolveResult resolveResult = resolver.Resolve(new ExpressionResult("(" + provider.OutputNode(options.Dom, node) + ")"), new DomLocation(options.Document.TextEditor.CursorLine, options.Document.TextEditor.CursorColumn));
if (resolveResult.ResolvedType != null)
{
returnType = options.ShortenTypeName(resolveResult.ResolvedType).ConvertToTypeReference();
}
}
MethodDeclaration methodDecl = new MethodDeclaration();
methodDecl.Name = param.Name;
methodDecl.Modifier = param.Modifiers;
methodDecl.TypeReference = returnType;
if (!param.ReferencesMember)
{
methodDecl.Modifier |= ICSharpCode.NRefactory.Ast.Modifiers.Static;
}
if (node is BlockStatement)
{
methodDecl.Body = new BlockStatement();
methodDecl.Body.AddChild(new EmptyStatement());
if (param.OneChangedVariable)
{
methodDecl.Body.AddChild(new ReturnStatement(new IdentifierExpression(param.ChangedVariables.First())));
}
}
else if (node is Expression)
{
methodDecl.Body = new BlockStatement();
methodDecl.Body.AddChild(new ReturnStatement(node as Expression));
}
foreach (VariableDescriptor var in param.VariablesToDefine)
{
BlockStatement block = methodDecl.Body;
LocalVariableDeclaration varDecl = new LocalVariableDeclaration(options.ShortenTypeName(var.ReturnType).ConvertToTypeReference());
varDecl.Variables.Add(new VariableDeclaration(var.Name));
block.Children.Insert(0, varDecl);
}
foreach (VariableDescriptor var in param.Parameters)
{
TypeReference typeReference = options.ShortenTypeName(var.ReturnType).ConvertToTypeReference();
ParameterDeclarationExpression pde = new ParameterDeclarationExpression(typeReference, var.Name);
if (!param.OneChangedVariable)
{
if (param.ChangedVariables.Contains(var.Name))
{
pde.ParamModifier = ICSharpCode.NRefactory.Ast.ParameterModifiers.Ref;
}
if (param.VariablesToGenerate.Where(v => v.Name == var.Name).Any())
{
pde.ParamModifier = ICSharpCode.NRefactory.Ast.ParameterModifiers.Out;
}
VariableDescriptor outsideVar = null;
if (var.GetsAssigned && param.VariablesOutside.TryGetValue(var.Name, out outsideVar))
{
if (!outsideVar.GetsAssigned)
{
pde.ParamModifier = ICSharpCode.NRefactory.Ast.ParameterModifiers.Out;
}
}
}
methodDecl.Parameters.Add(pde);
}
string indent = options.GetIndent(param.DeclaringMember);
StringBuilder methodText = new StringBuilder();
switch (param.InsertionPoint.LineBefore)
{
case NewLineInsertion.Eol:
methodText.AppendLine();
break;
case NewLineInsertion.BlankLine:
methodText.Append(indent);
methodText.AppendLine();
break;
}
if (param.GenerateComment)
{
methodText.Append(indent);
methodText.AppendLine("/// <summary>");
methodText.Append(indent);
methodText.AppendLine("/// TODO: write a comment.");
methodText.Append(indent);
methodText.AppendLine("/// </summary>");
Ambience ambience = AmbienceService.GetAmbienceForFile(options.Document.FileName);
foreach (ParameterDeclarationExpression pde in methodDecl.Parameters)
{
methodText.Append(indent);
methodText.Append("/// <param name=\"");
methodText.Append(pde.ParameterName);
methodText.Append("\"> A ");
methodText.Append(ambience.GetString(pde.TypeReference.ConvertToReturnType(), OutputFlags.IncludeGenerics | OutputFlags.UseFullName));
methodText.Append(" </param>");
methodText.AppendLine();
}
if (methodDecl.TypeReference.Type != "System.Void")
{
methodText.Append(indent);
methodText.AppendLine("/// <returns>");
methodText.Append(indent);
methodText.Append("/// A ");
methodText.AppendLine(ambience.GetString(methodDecl.TypeReference.ConvertToReturnType(), OutputFlags.IncludeGenerics | OutputFlags.UseFullName));
methodText.Append(indent);
methodText.AppendLine("/// </returns>");
}
}
methodText.Append(indent);
if (node is BlockStatement)
{
string text = provider.OutputNode(options.Dom, methodDecl, indent).Trim();
int emptyStatementMarker = text.LastIndexOf(';');
if (param.OneChangedVariable)
{
emptyStatementMarker = text.LastIndexOf(';', emptyStatementMarker - 1);
}
StringBuilder sb = new StringBuilder();
sb.Append(text.Substring(0, emptyStatementMarker));
sb.Append(AddIndent(param.Text, indent + "\t"));
sb.Append(text.Substring(emptyStatementMarker + 1));
methodText.Append(sb.ToString());
}
else
{
methodText.Append(provider.OutputNode(options.Dom, methodDecl, options.GetIndent(param.DeclaringMember)).Trim());
}
switch (param.InsertionPoint.LineAfter)
{
case NewLineInsertion.Eol:
methodText.AppendLine();
break;
case NewLineInsertion.BlankLine:
methodText.AppendLine();
methodText.AppendLine();
methodText.Append(indent);
break;
}
insertNewMethod.InsertedText = methodText.ToString();
result.Add(insertNewMethod);
return(result);
}
// Yoinked from C# binding
void UpdatePath(object sender, Mono.TextEditor.DocumentLocationEventArgs e)
{
var unit = Document.CompilationUnit;
var textEditorData = Document.Editor;
if (unit == null)
{
return;
}
var loc = textEditorData.Caret.Location;
IType type = unit.GetTypeAt(loc.Line, loc.Column);
List <PathEntry> result = new List <PathEntry> ();
Ambience amb = GetAmbience();
IMember member = null;
INode node = (INode)unit;
if (type != null && type.ClassType != ClassType.Delegate)
{
member = type.GetMemberAt(loc.Line, loc.Column);
}
if (null != member)
{
node = member;
}
else if (null != type)
{
node = type;
}
while (node != null)
{
PathEntry entry;
if (node is ICompilationUnit)
{
if (!Document.ParsedDocument.UserRegions.Any())
{
break;
}
FoldingRegion reg = Document.ParsedDocument.UserRegions.LastOrDefault(r => r.Region.Contains(loc.Line, loc.Column));
if (reg == null)
{
entry = new PathEntry(GettextCatalog.GetString("No region"));
}
else
{
entry = new PathEntry(CompilationUnitDataProvider.Pixbuf, reg.Name);
}
entry.Position = EntryPosition.Right;
}
else
{
entry = new PathEntry(ImageService.GetPixbuf(((IMember)node).StockIcon, Gtk.IconSize.Menu), amb.GetString((IMember)node, OutputFlags.IncludeGenerics | OutputFlags.IncludeParameters | OutputFlags.ReformatDelegates));
}
entry.Tag = node;
result.Insert(0, entry);
node = node.Parent;
}
PathEntry noSelection = null;
if (type == null)
{
noSelection = new PathEntry(GettextCatalog.GetString("No selection"))
{
Tag = new CustomNode(Document.CompilationUnit)
};
}
else if (member == null && type.ClassType != ClassType.Delegate)
{
noSelection = new PathEntry(GettextCatalog.GetString("No selection"))
{
Tag = new CustomNode(type)
}
}
;
if (noSelection != null)
{
result.Add(noSelection);
}
var prev = CurrentPath;
CurrentPath = result.ToArray();
OnPathChanged(this, new DocumentPathChangedEventArgs(prev));
}
public static async Task <long> Get_Data(int pastHours, string sensorId, long lastUpdatedTicks)
{
SensorContext db = new SensorContext();
long itemTicks = 0;
try
{
var resources = ResourceLoader.GetForCurrentView("Resources");
var blobStorageKey = resources.GetString("BlobStorageKey");
string storageConnection = "DefaultEndpointsProtocol=https;AccountName=envirodata;AccountKey=" + blobStorageKey;
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(storageConnection);
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference(sensorId);
BlobContinuationToken myToken = new BlobContinuationToken();
BlobContinuationToken continuationToken = null;
List <IListBlobItem> results = new List <IListBlobItem>();
do
{
var response = await container.ListBlobsSegmentedAsync(continuationToken);
continuationToken = response.ContinuationToken;
results.AddRange(response.Results);
}while (continuationToken != null);
TimeSpan pastSpan = new TimeSpan(0, pastHours, 0, 0);
long fromTicks = DateTime.Now.Subtract(pastSpan).Ticks;
Sensor sensor;
string currentId = "";
bool erasePreImport = false;
if (erasePreImport)
{
db.AmbientDataSample.RemoveRange(db.AmbientDataSample);
db.SaveChanges();
}
foreach (IListBlobItem item in results)
{
itemTicks = Convert.ToInt64(item.Uri.ToString().Split('_')[1].Split('.')[0]);
if (itemTicks > fromTicks && itemTicks > lastUpdatedTicks)
{
string blobText = await(item as CloudBlockBlob).DownloadTextAsync();
JArray jsonContent = JsonConvert.DeserializeObject(blobText) as JArray;
List <Ambience> ambBunch = new List <Ambience>();
foreach (JToken entry in jsonContent)
{
JObject myAmb = entry.ToObject <JObject>();
currentId = myAmb.GetValue("ID").ToString();
sensor = db.Sensors.Where(x => x.SensorId.ToString().Equals(myAmb.GetValue("sensorID").ToString())).FirstOrDefault();
if (sensor == null) // move out of foreach loop
{
try
{
sensor = new Sensor {
SensorId = new Guid(myAmb.GetValue("sensorID").ToString()), Title = "generic", Location = "Here"
};
db.Sensors.Add(sensor);
db.SaveChanges();
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
if (!currentId.Equals("0"))
{
Ambience myAmbience = new Ambience();
myAmbience.AmbienceId = (int)myAmb.GetValue("ID"); //.ToObject<int>();
myAmbience.captureTime = DateTime.Parse(myAmb.GetValue("captureTime").ToString());
myAmbience.temperature = myAmb.GetValue("temperature").ToObject <decimal>();
myAmbience.humidity = myAmb.GetValue("humidity").ToObject <decimal>();
myAmbience.Sensor = sensor;
ambBunch.Add(myAmbience);
}
}
db.AmbientDataSample.AddRange(ambBunch);
db.SaveChanges();
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
return(itemTicks);
}
public OverridesImplementsDialog(MonoDevelop.Ide.Gui.Document editor, IType cls)
{
this.Build();
this.editor = editor;
this.cls = cls;
// FIXME: title
Title = GettextCatalog.GetString("Override and/or implement members");
store = new TreeStore(typeof(bool), typeof(Gdk.Pixbuf), typeof(string), typeof(bool), typeof(IMember));
// Column #1
TreeViewColumn nameCol = new TreeViewColumn();
nameCol.Title = GettextCatalog.GetString("Name");
nameCol.Expand = true;
nameCol.Resizable = true;
CellRendererToggle cbRenderer = new CellRendererToggle();
cbRenderer.Activatable = true;
cbRenderer.Toggled += OnSelectToggled;
nameCol.PackStart(cbRenderer, false);
nameCol.AddAttribute(cbRenderer, "active", colCheckedIndex);
CellRendererPixbuf iconRenderer = new CellRendererPixbuf();
nameCol.PackStart(iconRenderer, false);
nameCol.AddAttribute(iconRenderer, "pixbuf", colIconIndex);
CellRendererText nameRenderer = new CellRendererText();
nameRenderer.Ellipsize = Pango.EllipsizeMode.End;
nameCol.PackStart(nameRenderer, true);
nameCol.AddAttribute(nameRenderer, "text", colNameIndex);
treeview.AppendColumn(nameCol);
// Column #2
CellRendererToggle explicitRenderer = new CellRendererToggle();
explicitRenderer.Activatable = true;
explicitRenderer.Xalign = 0.0f;
explicitRenderer.Toggled += OnExplicitToggled;
TreeViewColumn explicitCol = new TreeViewColumn();
explicitCol.Title = GettextCatalog.GetString("Explicit");
explicitCol.PackStart(explicitRenderer, true);
explicitCol.SetCellDataFunc(explicitRenderer, new TreeCellDataFunc(RenderExplicitCheckbox));
explicitCol.AddAttribute(explicitRenderer, "active", colExplicitIndex);
treeview.AppendColumn(explicitCol);
store.SetSortColumnId(colNameIndex, SortType.Ascending);
treeview.Model = store;
buttonCancel.Clicked += OnCancelClicked;
buttonOk.Clicked += OnOKClicked;
buttonSelectAll.Clicked += delegate { SelectAll(true); };
buttonUnselectAll.Clicked += delegate { SelectAll(false); };
refactorer = IdeApp.Workspace.GetCodeRefactorer(IdeApp.ProjectOperations.CurrentSelectedSolution);
ambience = AmbienceService.GetAmbienceForFile(cls.CompilationUnit.FileName);
PopulateTreeView();
UpdateOKButton();
}
TooltipInformation CreateTooltip(ToolTipData data, int offset, Ambience ambience, Gdk.ModifierType modifierState)
{
ResolveResult result = data.Result;
var doc = IdeApp.Workbench.ActiveDocument;
if (doc == null)
{
return(null);
}
bool createFooter = (modifierState & Gdk.ModifierType.Mod1Mask) != 0;
var file = doc.ParsedDocument.ParsedFile as CSharpUnresolvedFile;
if (file == null)
{
return(null);
}
try {
if (result is AliasNamespaceResolveResult)
{
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
return(sig.GetAliasedNamespaceTooltip((AliasNamespaceResolveResult)result));
}
if (result is AliasTypeResolveResult)
{
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
return(sig.GetAliasedTypeTooltip((AliasTypeResolveResult)result));
}
if (data.Node is TypeOfExpression)
{
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
return(sig.GetTypeOfTooltip((TypeOfExpression)data.Node, result as TypeOfResolveResult));
}
if (data.Node is PrimitiveType && data.Node.Parent is Constraint)
{
var t = (PrimitiveType)data.Node;
if (t.Keyword == "class" || t.Keyword == "new" || t.Keyword == "struct")
{
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
return(sig.GetConstraintTooltip(t.Keyword));
}
return(null);
}
if (data.Node is ExternAliasDeclaration)
{
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
return(sig.GetExternAliasTooltip((ExternAliasDeclaration)data.Node, doc.Project as DotNetProject));
}
if (result == null && data.Node is CSharpTokenNode)
{
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
return(sig.GetKeywordTooltip(data.Node));
}
if (data.Node is PrimitiveType && ((PrimitiveType)data.Node).KnownTypeCode == KnownTypeCode.Void)
{
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
return(sig.GetKeywordTooltip("void", null));
}
if (data.Node is NullReferenceExpression)
{
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
return(sig.GetKeywordTooltip("null", null));
}
if (result is UnknownIdentifierResolveResult)
{
return(new TooltipInformation()
{
SignatureMarkup = string.Format("error CS0103: The name `{0}' does not exist in the current context", ((UnknownIdentifierResolveResult)result).Identifier)
});
}
else if (result is UnknownMemberResolveResult)
{
var ur = (UnknownMemberResolveResult)result;
if (ur.TargetType.Kind != TypeKind.Unknown)
{
return(new TooltipInformation()
{
SignatureMarkup = string.Format("error CS0117: `{0}' does not contain a definition for `{1}'", ur.TargetType.FullName, ur.MemberName)
});
}
}
else if (result.IsError)
{
return(new TooltipInformation()
{
SignatureMarkup = "Unknown resolve error."
});
}
if (result is LocalResolveResult)
{
var lr = (LocalResolveResult)result;
var tooltipInfo = new TooltipInformation();
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
tooltipInfo.SignatureMarkup = sig.GetLocalVariableMarkup(lr.Variable);
return(tooltipInfo);
}
else if (result is MethodGroupResolveResult)
{
var mrr = (MethodGroupResolveResult)result;
var allMethods = new List <IMethod> (mrr.Methods);
foreach (var l in mrr.GetExtensionMethods())
{
allMethods.AddRange(l);
}
var method = allMethods.FirstOrDefault();
if (method != null)
{
return(MemberCompletionData.CreateTooltipInformation(
doc.Compilation,
file,
doc.Editor,
doc.GetFormattingPolicy(),
method,
false,
createFooter));
}
}
else if (result is CSharpInvocationResolveResult)
{
var invocationResult = (CSharpInvocationResolveResult)result;
var member = (IMember)invocationResult.ReducedMethod ?? invocationResult.Member;
return(MemberCompletionData.CreateTooltipInformation(
doc.Compilation,
file,
doc.Editor,
doc.GetFormattingPolicy(),
member,
false,
createFooter));
}
else if (result is MemberResolveResult)
{
var member = ((MemberResolveResult)result).Member;
return(MemberCompletionData.CreateTooltipInformation(
doc.Compilation,
file,
doc.Editor,
doc.GetFormattingPolicy(),
member,
false,
createFooter));
}
else if (result is NamespaceResolveResult)
{
var tooltipInfo = new TooltipInformation();
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
try {
tooltipInfo.SignatureMarkup = sig.GetMarkup(((NamespaceResolveResult)result).Namespace);
} catch (Exception e) {
LoggingService.LogError("Got exception while creating markup for :" + ((NamespaceResolveResult)result).Namespace, e);
return(new TooltipInformation());
}
return(tooltipInfo);
}
else if (result is OperatorResolveResult)
{
var or = result as OperatorResolveResult;
var tooltipInfo = new TooltipInformation();
var resolver = file.GetResolver(doc.Compilation, doc.Editor.Caret.Location);
var sig = new SignatureMarkupCreator(resolver, doc.GetFormattingPolicy().CreateOptions());
sig.BreakLineAfterReturnType = false;
try {
tooltipInfo.SignatureMarkup = sig.GetMarkup(or.UserDefinedOperatorMethod);
} catch (Exception e) {
LoggingService.LogError("Got exception while creating markup for :" + ((NamespaceResolveResult)result).Namespace, e);
return(new TooltipInformation());
}
return(tooltipInfo);
}
else
{
return(MemberCompletionData.CreateTooltipInformation(
doc.Compilation,
file,
doc.Editor,
doc.GetFormattingPolicy(),
result.Type,
false,
createFooter));
}
} catch (Exception e) {
LoggingService.LogError("Error while creating tooltip.", e);
return(null);
}
return(null);
}
public string CreateTooltip(ProjectDom dom, ICompilationUnit unit, MonoDevelop.Projects.Dom.ResolveResult result, string errorInformations, Ambience ambience, Gdk.ModifierType modifierState)
{
OutputSettings settings = new OutputSettings(OutputFlags.ClassBrowserEntries | OutputFlags.IncludeParameterName | OutputFlags.IncludeKeywords | OutputFlags.IncludeMarkup | OutputFlags.UseFullName);
if ((Gdk.ModifierType.ShiftMask & modifierState) == Gdk.ModifierType.ShiftMask)
{
settings.EmitNameCallback = delegate(INode domVisitable, ref string outString) {
// crop used namespaces.
if (unit != null)
{
int len = 0;
foreach (IUsing u in unit.Usings)
{
foreach (string ns in u.Namespaces)
{
if (outString.StartsWith(ns + "."))
{
len = Math.Max(len, ns.Length + 1);
}
}
}
string newName = outString.Substring(len);
int count = 0;
// check if there is a name clash.
if (dom.GetType(newName) != null)
{
count++;
}
foreach (IUsing u in unit.Usings)
{
foreach (string ns in u.Namespaces)
{
if (dom.GetType(ns + "." + newName) != null)
{
count++;
}
}
}
if (len > 0 && count == 1)
{
outString = newName;
}
}
};
}
// Approximate value for usual case
StringBuilder s = new StringBuilder(150);
string doc = null;
if (result != null)
{
if (result is AggregatedResolveResult)
{
result = ((AggregatedResolveResult)result).PrimaryResult;
}
if (result is ParameterResolveResult)
{
s.Append("<small><i>");
s.Append(paramStr);
s.Append("</i></small>\n");
s.Append(ambience.GetString(((ParameterResolveResult)result).Parameter, settings));
}
else if (result is LocalVariableResolveResult)
{
s.Append("<small><i>");
s.Append(localStr);
s.Append("</i></small>\n");
s.Append(ambience.GetString(((LocalVariableResolveResult)result).ResolvedType, settings));
s.Append(" ");
s.Append(((LocalVariableResolveResult)result).LocalVariable.Name);
}
else if (result is UnresolvedMemberResolveResult)
{
s.Append(String.Format(GettextCatalog.GetString("Unresolved member '{0}'"), ((UnresolvedMemberResolveResult)result).MemberName));
}
else if (result is MethodResolveResult)
{
MethodResolveResult mrr = (MethodResolveResult)result;
s.Append("<small><i>");
s.Append(methodStr);
s.Append("</i></small>\n");
s.Append(ambience.GetString(mrr.MostLikelyMethod, settings));
if (mrr.Methods.Count > 1)
{
int overloadCount = mrr.Methods.Count - 1;
s.Append(string.Format(GettextCatalog.GetPluralString(" (+{0} overload)", " (+{0} overloads)", overloadCount), overloadCount));
}
doc = AmbienceService.GetDocumentationSummary(((MethodResolveResult)result).MostLikelyMethod);
}
else if (result is MemberResolveResult)
{
IMember member = ((MemberResolveResult)result).ResolvedMember;
if (member == null)
{
IReturnType returnType = ((MemberResolveResult)result).ResolvedType;
if (returnType != null)
{
IType type = dom.GetType(returnType);
if (type != null)
{
s.Append("<small><i>");
s.Append(typeStr);
s.Append("</i></small>\n");
s.Append(ambience.GetString(type, settings));
doc = AmbienceService.GetDocumentationSummary(type);
}
}
}
else
{
if (member is IField)
{
s.Append("<small><i>");
s.Append(fieldStr);
s.Append("</i></small>\n");
}
else if (member is IProperty)
{
s.Append("<small><i>");
s.Append(propertyStr);
s.Append("</i></small>\n");
}
s.Append(ambience.GetString(member, settings));
doc = AmbienceService.GetDocumentationSummary(member);
}
}
else if (result is NamespaceResolveResult)
{
s.Append("<small><i>");
s.Append(namespaceStr);
s.Append("</i></small>\n");
s.Append(ambience.GetString(new Namespace(((NamespaceResolveResult)result).Namespace), settings));
}
else
{
s.Append(ambience.GetString(result.ResolvedType, settings));
}
if (!string.IsNullOrEmpty(doc))
{
s.Append("\n<small>");
s.Append(AmbienceService.GetDocumentationMarkup("<summary>" + doc + "</summary>"));
s.Append("</small>");
}
}
if (!string.IsNullOrEmpty(errorInformations))
{
if (s.Length != 0)
{
s.Append("\n\n");
}
s.Append("<small>");
s.Append(errorInformations);
s.Append("</small>");
}
return(s.ToString());
}
public string CreateTooltip(ResolveResult result, int offset, Ambience ambience)
{
var doc = IdeApp.Workbench.ActiveDocument;
if (doc == null)
{
return(null);
}
try {
OutputSettings settings = new OutputSettings(OutputFlags.ClassBrowserEntries | OutputFlags.IncludeParameterName | OutputFlags.IncludeKeywords | OutputFlags.IncludeMarkup | OutputFlags.UseFullName);
// Approximate value for usual case
StringBuilder s = new StringBuilder(150);
string documentation = null;
if (result is UnknownIdentifierResolveResult)
{
s.Append(String.Format(GettextCatalog.GetString("Unresolved identifier '{0}'"), ((UnknownIdentifierResolveResult)result).Identifier));
}
else if (result.IsError)
{
s.Append(GettextCatalog.GetString("Resolve error."));
}
else if (result is LocalResolveResult)
{
var lr = (LocalResolveResult)result;
s.Append("<small><i>");
s.Append(lr.IsParameter ? paramStr : localStr);
s.Append("</i></small>\n");
s.Append(ambience.GetString(lr.Variable.Type, settings));
s.Append(" ");
s.Append(lr.Variable.Name);
}
else if (result is MethodGroupResolveResult)
{
var mrr = (MethodGroupResolveResult)result;
s.Append("<small><i>");
s.Append(methodStr);
s.Append("</i></small>\n");
var allMethods = new List <IMethod> (mrr.Methods);
foreach (var l in mrr.GetExtensionMethods())
{
allMethods.AddRange(l);
}
var method = allMethods.FirstOrDefault();
if (method != null)
{
s.Append(GLib.Markup.EscapeText(TextEditorResolverProvider.CreateAmbience(doc, offset, method.Compilation).ConvertEntity(method)));
if (allMethods.Count > 1)
{
int overloadCount = allMethods.Count - 1;
s.Append(string.Format(GettextCatalog.GetPluralString(" (+{0} overload)", " (+{0} overloads)", overloadCount), overloadCount));
}
documentation = AmbienceService.GetDocumentationSummary(method);
}
}
else if (result is MemberResolveResult)
{
var member = ((MemberResolveResult)result).Member;
s.Append("<small><i>");
s.Append(GetString(member));
s.Append("</i></small>\n");
var field = member as IField;
if (field != null && field.IsConst)
{
s.Append(GLib.Markup.EscapeText(TextEditorResolverProvider.CreateAmbience(doc, offset, field.Compilation).ConvertType(field.Type)));
s.Append(" ");
s.Append(field.Name);
s.Append(" = ");
s.Append(GetConst(field.ConstantValue));
s.Append(";");
}
else
{
s.Append(GLib.Markup.EscapeText(TextEditorResolverProvider.CreateAmbience(doc, offset, member.Compilation).ConvertEntity(member)));
}
documentation = AmbienceService.GetDocumentationSummary(member);
}
else if (result is NamespaceResolveResult)
{
s.Append("<small><i>");
s.Append(namespaceStr);
s.Append("</i></small>\n");
s.Append(ambience.GetString(((NamespaceResolveResult)result).NamespaceName, settings));
}
else
{
var tr = result;
var typeString = GetString(tr.Type);
if (!string.IsNullOrEmpty(typeString))
{
s.Append("<small><i>");
s.Append(typeString);
s.Append("</i></small>\n");
}
settings.OutputFlags |= OutputFlags.UseFullName | OutputFlags.UseFullInnerTypeName;
s.Append(ambience.GetString(tr.Type, settings));
documentation = AmbienceService.GetDocumentationSummary(tr.Type.GetDefinition());
}
if (!string.IsNullOrEmpty(documentation))
{
s.Append("\n<small>");
s.Append(AmbienceService.GetDocumentationMarkup("<summary>" + documentation + "</summary>"));
s.Append("</small>");
}
return(s.ToString());
} catch (Exception e) {
LoggingService.LogError("Error while creating tooltip.", e);
return(null);
}
}
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);
}
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();
}
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));
}
internal static Task <TooltipInformation> CreateTooltipInformation(MonoDevelop.Ide.Editor.TextEditor editor, MonoDevelop.Ide.Editor.DocumentContext ctx, ISymbol sym, int currentParameter, bool smartWrap, CancellationToken cancelToken)
{
var tooltipInfo = new TooltipInformation();
var sig = new SignatureMarkupCreator(ctx, editor != null ? editor.CaretOffset : 0);
sig.HighlightParameter = currentParameter;
sig.BreakLineAfterReturnType = smartWrap;
return(Task.Run(() => {
if (cancelToken.IsCancellationRequested)
{
return null;
}
try {
tooltipInfo.SignatureMarkup = sig.GetMarkup(sym);
} catch (Exception e) {
LoggingService.LogError("Got exception while creating markup for :" + sym, e);
return new TooltipInformation();
}
tooltipInfo.SummaryMarkup = Ambience.GetSummaryMarkup(sym) ?? "";
if (cancelToken.IsCancellationRequested)
{
return null;
}
if (sym is IMethodSymbol)
{
var method = (IMethodSymbol)sym;
if (method.IsExtensionMethod && method.ReducedFrom != null && method.ReducedFrom.ContainingType != null)
{
tooltipInfo.AddCategory(GettextCatalog.GetString("Extension Method from"), method.ReducedFrom.ContainingType.Name);
}
}
int paramIndex = currentParameter;
// if (Symbol is IMethodSymbol && ((IMethodSymbol)Symbol).IsExtensionMethod)
// paramIndex++;
var list = GetParameterList(sym);
paramIndex = Math.Min(list.Length - 1, paramIndex);
var curParameter = paramIndex >= 0 && paramIndex < list.Length ? list [paramIndex] : null;
if (curParameter != null)
{
string docText = Ambience.GetDocumentation(sym);
if (!string.IsNullOrEmpty(docText))
{
string text = docText;
Regex paramRegex = new Regex("(\\<param\\s+name\\s*=\\s*\"" + curParameter.Name + "\"\\s*\\>.*?\\</param\\>)", RegexOptions.Compiled);
Match match = paramRegex.Match(docText);
if (match.Success)
{
text = Ambience.GetDocumentationMarkup(sym, match.Groups [1].Value);
if (!string.IsNullOrWhiteSpace(text))
{
tooltipInfo.AddCategory(GettextCatalog.GetString("Parameter"), text);
}
}
}
if (curParameter.Type.TypeKind == TypeKind.Delegate)
{
tooltipInfo.AddCategory(GettextCatalog.GetString("Delegate Info"), sig.GetDelegateInfo(curParameter.Type));
}
}
return tooltipInfo;
}));
}
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)));
}
}
}
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));
}
