public static TooltipInformation CreateTooltipInformation(ICompilation compilation, CSharpUnresolvedFile file, TextEditorData textEditorData, MonoDevelop.PlayScript.Formatting.PlayScriptFormattingPolicy formattingPolicy, IParameterizedMember entity, int currentParameter, bool smartWrap) { var tooltipInfo = new TooltipInformation(); var resolver = file.GetResolver(compilation, textEditorData.Caret.Location); var sig = new SignatureMarkupCreator(resolver, formattingPolicy.CreateOptions()); sig.HighlightParameter = currentParameter; sig.BreakLineAfterReturnType = smartWrap; try { tooltipInfo.SignatureMarkup = sig.GetMarkup(entity); } catch (Exception e) { LoggingService.LogError("Got exception while creating markup for :" + entity, e); return(new TooltipInformation()); } tooltipInfo.SummaryMarkup = AmbienceService.GetSummaryMarkup(entity) ?? ""; if (entity is IMethod) { var method = (IMethod)entity; if (method.IsExtensionMethod) { tooltipInfo.AddCategory(GettextCatalog.GetString("Extension Method from"), method.DeclaringTypeDefinition.FullName); } } int paramIndex = currentParameter; if (entity is IMethod && ((IMethod)entity).IsExtensionMethod) { paramIndex++; } paramIndex = Math.Min(entity.Parameters.Count - 1, paramIndex); var curParameter = paramIndex >= 0 && paramIndex < entity.Parameters.Count ? entity.Parameters [paramIndex] : null; if (curParameter != null) { string docText = AmbienceService.GetDocumentation(entity); 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 = AmbienceService.GetDocumentationMarkup(entity, match.Groups [1].Value); if (!string.IsNullOrWhiteSpace(text)) { tooltipInfo.AddCategory(GettextCatalog.GetString("Parameter"), text); } } } if (curParameter.Type.Kind == TypeKind.Delegate) { tooltipInfo.AddCategory(GettextCatalog.GetString("Delegate Info"), sig.GetDelegateInfo(curParameter.Type)); } } return(tooltipInfo); }
public override TooltipInformation CreateTooltipInformation(int overload, int currentParameter, bool smartWrap) { TooltipInformation info = new TooltipInformation(); string[] args = Overloads[overload].Split(",".ToCharArray()); string markup = ""; string comma = ""; int current = 1; foreach (string arg in args) { if (current == currentParameter) { markup += string.Format("{0}<b><i>{1}</i></b>", comma, arg); } else { markup += string.Format("{0}{1}", comma, arg); }; comma = ", "; current++; } info.SignatureMarkup = FuncName + "(" + FuncArgs + ")"; info.AddCategory("Parameters", string.Format("{0}( {1} )", FuncName, markup)); return(info); //return base.CreateTooltipInformation(overload, currentParameter, smartWrap); }
public static Task <TooltipInformation> CreateTooltipInformation(CancellationToken ctoken, MonoDevelop.Ide.Editor.TextEditor editor, MonoDevelop.Ide.Editor.DocumentContext ctx, ISymbol entity, bool smartWrap, bool createFooter = false, SemanticModel model = null) { if (ctx != null) { if (ctx.ParsedDocument == null || ctx.AnalysisDocument == null) { LoggingService.LogError("Signature markup creator created with invalid context." + Environment.NewLine + Environment.StackTrace); } } var tooltipInfo = new TooltipInformation(); // if (resolver == null) // resolver = file != null ? file.GetResolver (compilation, textEditorData.Caret.Location) : new CSharpResolver (compilation); var sig = new SignatureMarkupCreator(ctx, editor != null ? editor.CaretOffset : 0); sig.SemanticModel = model; sig.BreakLineAfterReturnType = smartWrap; return(Task.Run(() => { if (ctoken.IsCancellationRequested) { return null; } try { tooltipInfo.SignatureMarkup = sig.GetMarkup(entity); } catch (Exception e) { LoggingService.LogError("Got exception while creating markup for :" + entity, e); return new TooltipInformation(); } if (ctoken.IsCancellationRequested) { return null; } tooltipInfo.SummaryMarkup = Ambience.GetSummaryMarkup(entity) ?? ""; // if (entity is IMember) { // var evt = (IMember)entity; // if (evt.ReturnType.Kind == TypeKind.Delegate) { // tooltipInfo.AddCategory (GettextCatalog.GetString ("Delegate Info"), sig.GetDelegateInfo (evt.ReturnType)); // } // } if (entity is IMethodSymbol) { var method = (IMethodSymbol)entity; if (method.IsExtensionMethod) { tooltipInfo.AddCategory(GettextCatalog.GetString("Extension Method from"), method.ContainingType.Name); } } if (createFooter) { tooltipInfo.FooterMarkup = sig.CreateFooter(entity); } return tooltipInfo; })); }
public static TooltipInformation CreateTooltipInformation(ICompilation compilation, CSharpUnresolvedFile file, CSharpResolver resolver, TextEditorData textEditorData, MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy formattingPolicy, IEntity entity, bool smartWrap, bool createFooter = false) { var tooltipInfo = new TooltipInformation(); if (resolver == null) { resolver = file != null?file.GetResolver(compilation, textEditorData.Caret.Location) : new CSharpResolver(compilation); } var sig = new SignatureMarkupCreator(resolver, formattingPolicy.CreateOptions()); sig.BreakLineAfterReturnType = smartWrap; try { tooltipInfo.SignatureMarkup = sig.GetMarkup(entity); } catch (Exception e) { LoggingService.LogError("Got exception while creating markup for :" + entity, e); return(new TooltipInformation()); } tooltipInfo.SummaryMarkup = AmbienceService.GetSummaryMarkup(entity) ?? ""; if (entity is IMember) { var evt = (IMember)entity; if (evt.ReturnType.Kind == TypeKind.Delegate) { tooltipInfo.AddCategory(GettextCatalog.GetString("Delegate Info"), sig.GetDelegateInfo(evt.ReturnType)); } } if (entity is IMethod) { var method = (IMethod)entity; if (method.IsExtensionMethod) { tooltipInfo.AddCategory(GettextCatalog.GetString("Extension Method from"), method.DeclaringTypeDefinition.FullName); } } if (createFooter) { tooltipInfo.FooterMarkup = sig.CreateFooter(entity); } return(tooltipInfo); }
static void CreateTooltipBody(TooltipMarkupGen markupGen, DNode dn, TooltipInformation tti) { string summary; Dictionary <string, string> categories; markupGen.GenToolTipBody(dn, out summary, out categories); tti.SummaryMarkup = summary; if (categories != null) { foreach (var kv in categories) { tti.AddCategory(kv.Key, kv.Value); } } }
public static Task <TooltipInformation> CreateTooltipInformation(CancellationToken ctoken, MonoDevelop.Ide.Editor.TextEditor editor, MonoDevelop.Ide.Editor.DocumentContext ctx, ISymbol entity, bool smartWrap, bool createFooter = false, SemanticModel model = null) { if (entity == null) { return(TaskUtil.Default <TooltipInformation> ()); } var tooltipInfo = new TooltipInformation(); var sig = new SignatureMarkupCreator(ctx, editor != null ? editor.CaretOffset : 0); sig.SemanticModel = model; sig.BreakLineAfterReturnType = smartWrap; return(Task.Run(() => { if (ctoken.IsCancellationRequested) { return null; } try { tooltipInfo.SignatureMarkup = sig.GetMarkup(entity); } catch (Exception e) { LoggingService.LogError("Got exception while creating markup for :" + entity, e); return new TooltipInformation(); } if (ctoken.IsCancellationRequested) { return null; } tooltipInfo.SummaryMarkup = Ambience.GetSummaryMarkup(entity) ?? ""; if (entity is IMethodSymbol) { var method = (IMethodSymbol)entity; if (method.IsExtensionMethod) { tooltipInfo.AddCategory(GettextCatalog.GetString("Extension Method from"), method.ContainingType.Name); } } if (createFooter) { tooltipInfo.FooterMarkup = sig.CreateFooter(entity); } return tooltipInfo; })); }
public static TooltipInformation CreateTooltipInformation(ICompilation compilation, CSharpUnresolvedFile file, TextEditorData textEditorData, MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy formattingPolicy, IType type, bool smartWrap, bool createFooter = false) { var tooltipInfo = new TooltipInformation(); if (type.Kind == TypeKind.Unknown) { return(tooltipInfo); } var resolver = file != null?file.GetResolver(compilation, textEditorData.Caret.Location) : new CSharpResolver(compilation); var sig = new SignatureMarkupCreator(resolver, formattingPolicy.CreateOptions()); sig.BreakLineAfterReturnType = smartWrap; try { tooltipInfo.SignatureMarkup = sig.GetMarkup(type.IsParameterized ? type.GetDefinition() : type); } catch (Exception e) { LoggingService.LogError("Got exception while creating markup for :" + type, e); return(new TooltipInformation()); } if (type.IsParameterized) { var typeInfo = new StringBuilder(); for (int i = 0; i < type.TypeParameterCount; i++) { typeInfo.AppendLine(type.GetDefinition().TypeParameters [i].Name + " is " + sig.GetTypeReferenceString(type.TypeArguments [i])); } tooltipInfo.AddCategory("Type Parameters", typeInfo.ToString()); } var def = type.GetDefinition(); if (def != null) { if (createFooter) { tooltipInfo.FooterMarkup = sig.CreateFooter(def); } tooltipInfo.SummaryMarkup = AmbienceService.GetSummaryMarkup(def) ?? ""; } return(tooltipInfo); }
public static TooltipInformation Generate(DMethod dm, bool isTemplateParamInsight = false, int currentParam = -1) { var tti = new TooltipInformation(); var sb = new StringBuilder("<i>("); string name; switch (dm.SpecialType) { case DMethod.MethodType.Constructor: sb.Append("Constructor"); name = dm.Parent.Name; break; case DMethod.MethodType.Destructor: sb.Append("Destructor"); name = dm.Parent.Name; break; case DMethod.MethodType.Allocator: sb.Append("Allocator"); name = dm.Parent.Name; break; default: sb.Append("Method"); name = dm.Name; break; } sb.Append(")</i> "); if (dm.Type != null) { sb.Append(dm.Type.ToString(true)); sb.Append(" "); } else if (dm.Attributes != null && dm.Attributes.Count != 0) { foreach (var attr in dm.Attributes) { var m = attr as Modifier; if (m != null && DTokens.StorageClass[m.Token]) { sb.Append(DTokens.GetTokenString(m.Token)); sb.Append(" "); break; } } } sb.Append(name); /*TODO: Show attributes? * if (dm.Attributes != null && dm.Attributes.Count > 0) * s = dm.AttributeString + ' '; */ // Template parameters if (dm.TemplateParameters != null && dm.TemplateParameters.Length > 0) { sb.Append("("); for (int i = 0; i < dm.TemplateParameters.Length; i++) { var p = dm.TemplateParameters[i]; if (isTemplateParamInsight && i == currentParam) { sb.Append("<u>"); tti.AddCategory(p.Name, p.ToString()); sb.Append(p.ToString()); sb.Append("</u>"); } else { sb.Append(p.ToString()); } if (i < dm.TemplateParameters.Length - 1) { sb.Append(","); } } sb.Append(")"); } // Parameters sb.Append("("); for (int i = 0; i < dm.Parameters.Count; i++) { var p = dm.Parameters[i] as DNode; if (!isTemplateParamInsight && i == currentParam) { sb.Append("<u>"); if (!string.IsNullOrEmpty(p.Description)) { tti.AddCategory(p.Name, p.Description); } sb.Append(p.ToString(true, false)); sb.Append("</u>"); } else { sb.Append(p.ToString(true, false)); } if (i < dm.Parameters.Count - 1) { sb.Append(","); } } sb.Append(")"); tti.SignatureMarkup = sb.ToString(); tti.SummaryMarkup = dm.Description; tti.FooterMarkup = dm.ToString(); return(tti); }
public static TooltipInformation CreateTooltipInformation(ICompilation compilation, CSharpUnresolvedFile file, CSharpResolver resolver, TextEditorData textEditorData, MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy formattingPolicy, IEntity entity, bool smartWrap, bool createFooter = false) { var tooltipInfo = new TooltipInformation(); if (resolver == null) { resolver = file != null?file.GetResolver(compilation, textEditorData.Caret.Location) : new CSharpResolver(compilation); } var sig = new SignatureMarkupCreator(resolver, formattingPolicy.CreateOptions()); sig.BreakLineAfterReturnType = smartWrap; try { tooltipInfo.SignatureMarkup = sig.GetMarkup(entity); } catch (Exception e) { LoggingService.LogError("Got exception while creating markup for :" + entity, e); return(new TooltipInformation()); } tooltipInfo.SummaryMarkup = AmbienceService.GetSummaryMarkup(entity) ?? ""; if (entity is IMember) { var evt = (IMember)entity; if (evt.ReturnType.Kind == TypeKind.Delegate) { tooltipInfo.AddCategory(GettextCatalog.GetString("Delegate Info"), sig.GetDelegateInfo(evt.ReturnType)); } } if (entity is IMethod) { var method = (IMethod)entity; if (method.IsExtensionMethod) { tooltipInfo.AddCategory(GettextCatalog.GetString("Extension Method from"), method.DeclaringTypeDefinition.FullName); } } if (createFooter) { if (entity is IType) { var type = entity as IType; var def = type.GetDefinition(); if (def != null) { if (!string.IsNullOrEmpty(def.ParentAssembly.AssemblyName)) { var project = def.GetSourceProject(); if (project != null) { var relPath = FileService.AbsoluteToRelativePath(project.BaseDirectory, def.Region.FileName); tooltipInfo.FooterMarkup = "<small>" + GettextCatalog.GetString("Project:\t{0}", AmbienceService.EscapeText(def.ParentAssembly.AssemblyName)) + "</small>" + Environment.NewLine + "<small>" + GettextCatalog.GetString("File:\t\t{0} (line {1})", AmbienceService.EscapeText(relPath), def.Region.Begin.Line) + "</small>"; } } } } else if (entity.DeclaringTypeDefinition != null) { var project = entity.DeclaringTypeDefinition.GetSourceProject(); if (project != null) { var relPath = FileService.AbsoluteToRelativePath(project.BaseDirectory, entity.Region.FileName); tooltipInfo.FooterMarkup = "<small>" + GettextCatalog.GetString("Project:\t{0}", AmbienceService.EscapeText(project.Name)) + "</small>" + Environment.NewLine + "<small>" + GettextCatalog.GetString("From:\t{0}", AmbienceService.EscapeText(entity.DeclaringType.FullName)) + "</small>" + Environment.NewLine + "<small>" + GettextCatalog.GetString("File:\t\t{0} (line {1})", AmbienceService.EscapeText(relPath), entity.Region.Begin.Line) + "</small>"; } } } return(tooltipInfo); }
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; })); }