public static FlowDocument CreateTooltip(IEntity entity, bool useFullyQualifiedMemberNames = true)
{
var ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.ShowDeclaringType;
if (useFullyQualifiedMemberNames)
{
ambience.ConversionFlags |= ConversionFlags.UseFullyQualifiedEntityNames;
}
string header = ambience.ConvertSymbol(entity);
var documentation = XmlDocumentationElement.Get(entity);
ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList;
DocumentationUIBuilder b = new DocumentationUIBuilder(ambience);
b.AddCodeBlock(header, keepLargeMargin: true);
if (documentation != null)
{
foreach (var child in documentation.Children)
{
b.AddDocumentationElement(child);
}
}
return(b.CreateFlowDocument());
}
public void Initialize(Gtk.TreeView treeView)
{
TreeViewColumn column = new TreeViewColumn();
CellRendererToggle toggleRenderer = new CellRendererToggle();
toggleRenderer.Toggled += ToggleRendererToggled;
column.PackStart(toggleRenderer, false);
column.AddAttribute(toggleRenderer, "active", 0);
var pixbufRenderer = new CellRendererPixbuf();
column.PackStart(pixbufRenderer, false);
column.AddAttribute(pixbufRenderer, "pixbuf", 1);
CellRendererText textRenderer = new CellRendererText();
column.PackStart(textRenderer, true);
column.AddAttribute(textRenderer, "text", 2);
column.Expand = true;
treeView.AppendColumn(column);
Ambience ambience = AmbienceService.GetAmbienceForFile(options.Document.FileName);
foreach (IBaseMember member in GetValidMembers())
{
Store.AppendValues(false, ImageService.GetPixbuf(member.StockIcon, IconSize.Menu), ambience.GetString(member, member.MemberType == MemberType.Parameter ? OutputFlags.IncludeParameterName : OutputFlags.ClassBrowserEntries), member);
}
treeView.Model = store;
}
public override string ToString()
{
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList;
return(ambience.Convert(c));
}
public CodeCompletionItem(IEntity entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
this.entity = entity;
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = entity is IClass ? ConversionFlags.ShowTypeParameterList : ConversionFlags.None;
this.Text = ambience.Convert(entity);
ambience.ConversionFlags = ConversionFlags.StandardConversionFlags;
if (entity is IClass)
{
// Show fully qualified Type name (called UseFullyQualifiedMemberNames though)
ambience.ConversionFlags |= ConversionFlags.UseFullyQualifiedMemberNames;
}
description = ambience.Convert(entity);
this.Image = ClassBrowserIconService.GetIcon(entity);
this.Overloads = 1;
this.InsertGenericArguments = false;
this.Priority = CodeCompletionDataUsageCache.GetPriority(entity.DotNetName, true);
}
public TypeDataProvider(MonoDevelop.Projects.DotNetProject project)
{
var dom = MonoDevelop.Projects.Dom.Parser.ProjectDomService.GetProjectDom(project);
List = new List <MonoDevelop.Projects.Dom.IType> (dom.Types);
this.ambience = AmbienceService.GetAmbienceForLanguage(project.LanguageName);
}
void AddControlMembers(CompletionDataList list, IType controlClass,
Dictionary <string, string> existingAtts)
{
//add atts only if they're not already in the tag
foreach (var prop in GetUniqueMembers <IProperty> (controlClass.GetProperties()))
{
if (prop.Accessibility == Accessibility.Public && (existingAtts == null || !existingAtts.ContainsKey(prop.Name)))
{
if (GetPersistenceMode(prop) == System.Web.UI.PersistenceMode.Attribute)
{
list.Add(prop.Name, prop.GetStockIcon(), AmbienceService.GetSummaryMarkup(prop));
}
}
}
//similarly add events
foreach (var eve in GetUniqueMembers <IEvent> (controlClass.GetEvents()))
{
string eveName = "On" + eve.Name;
if (eve.Accessibility == Accessibility.Public && (existingAtts == null || !existingAtts.ContainsKey(eveName)))
{
list.Add(eveName, eve.GetStockIcon(), AmbienceService.GetSummaryMarkup(eve));
}
}
}
public TypeDataProvider(MonoDevelop.Projects.DotNetProject project)
{
var ctx = TypeSystemService.GetCompilation(project);
List = new List <ITypeDefinition> (ctx.MainAssembly.GetAllTypeDefinitions());
this.ambience = AmbienceService.GetAmbience(project.LanguageName);
}
protected virtual IAmbience GetAmbience()
{
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList;
return(ambience);
}
public string GetDescription(int overload, int currentParameter)
{
StringBuilder result = new StringBuilder();
var curParameter = currentParameter >= 0 && currentParameter < indexers [overload].Parameters.Count ? indexers [overload].Parameters [currentParameter] : null;
if (curParameter != null)
{
string docText = AmbienceService.GetDocumentation(indexers [overload]);
if (!string.IsNullOrEmpty(docText))
{
var paramRegex = new Regex("(\\<param\\s+name\\s*=\\s*\"" + curParameter.Name + "\"\\s*\\>.*?\\</param\\>)", RegexOptions.Compiled);
var match = paramRegex.Match(docText);
if (match.Success)
{
result.AppendLine();
string text = match.Groups [1].Value;
text = "<summary>" + AmbienceService.GetDocumentationSummary(indexers [overload]) + "</summary>" + text;
result.Append(AmbienceService.GetDocumentationMarkup(text, new AmbienceService.DocumentationFormatOptions {
HighlightParameter = curParameter.Name,
MaxLineLength = 60
}));
}
}
}
return(result.ToString());
}
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);
}
protected IAmbience GetAmbience()
{
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.None;
return(ambience);
}
public override void BuildNode(ITreeBuilder treeBuilder, object dataObject, ref string label, ref Gdk.Pixbuf icon, ref Gdk.Pixbuf closedIcon)
{
IEvent data = dataObject as IEvent;
label = AmbienceService.GetAmbience(data).GetString(data, OutputFlags.ClassBrowserEntries | OutputFlags.IncludeMarkup);
icon = Context.GetIcon(data.StockIcon);
}
string IAssemblyBrowserNodeBuilder.GetDocumentationMarkup(ITreeNavigator navigator)
{
var method = (IUnresolvedMethod)navigator.DataItem;
var resolved = Resolve(navigator, method);
if (GetMainAssembly(navigator) == null)
{
return(Mono.TextEditor.Utils.TextFileUtility.ReadAllText(method.Region.FileName));
}
StringBuilder result = new StringBuilder();
result.Append("<big>");
result.Append(Ambience.GetString(resolved, OutputFlags.AssemblyBrowserDescription | OutputFlags.IncludeConstraints));
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 override string ToString()
{
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.ShowParameterNames;
return(ambience.Convert(property));
}
public override string ToString()
{
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.None;
return(ambience.Convert(evt));
}
protected override Gtk.Window CreateTooltipWindow(TextEditor editor, int offset, Gdk.ModifierType modifierState, TooltipItem item)
{
//create a message string from all the results
var results = (IList <Result>)item.Item;
var sb = new StringBuilder();
bool first = false;
foreach (var r in results)
{
if (!first)
{
first = true;
}
else
{
sb.AppendLine();
}
sb.Append(r.Level.ToString());
sb.Append(": ");
sb.Append(AmbienceService.EscapeText(r.Message));
}
//FIXME: use a nicer, more specialized tooltip window, with results formatting and hints about
// commands and stuff
var win = new LanguageItemWindow((ExtensibleTextEditor)editor, modifierState, null, sb.ToString(), null);
if (win.IsEmpty)
{
return(null);
}
return(win);
}
void FindOverrides(object sender, EventArgs e)
{
MenuCommand item = (MenuCommand)sender;
IMember member = (IMember)item.Tag;
IEnumerable <IClass> derivedClasses = RefactoringService.FindDerivedClasses(member.DeclaringType, ParserService.AllProjectContents, false);
List <SearchResultMatch> results = new List <SearchResultMatch>();
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedMemberNames | ConversionFlags.ShowTypeParameterList;
foreach (IClass derivedClass in derivedClasses)
{
if (derivedClass.CompilationUnit == null)
{
continue;
}
if (derivedClass.CompilationUnit.FileName == null)
{
continue;
}
IMember m = MemberLookupHelper.FindSimilarMember(derivedClass, member);
if (m != null && !m.Region.IsEmpty)
{
string matchText = ambience.Convert(m);
SearchResultMatch res = new SimpleSearchResultMatch(matchText, new TextLocation(m.Region.BeginColumn - 1, m.Region.BeginLine - 1));
res.ProvidedDocumentInformation = FindReferencesAndRenameHelper.GetDocumentInformation(m.DeclaringType.CompilationUnit.FileName);
results.Add(res);
}
}
SearchResultPanel.Instance.ShowSearchResults(new SearchResult(
StringParser.Parse("${res:SharpDevelop.Refactoring.OverridesOf}", new string[, ] {
{ "Name", member.Name }
}),
results
));
}
public override string ToString()
{
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.ShowReturnType | ConversionFlags.ShowModifiers;
return(ambience.Convert(field));
}
static string GetName(IMember member, ConversionFlags flags)
{
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = flags | ConversionFlags.ShowParameterNames | ConversionFlags.ShowTypeParameterList;
return(ambience.Convert(member));
}
public string GetComponentTypeOf(Func <string, string> callback, string varName)
{
if (callback == null)
{
return("var");
}
string var = callback(varName);
ITextEditorResolver textEditorResolver = CurrentContext.Document.GetContent <ITextEditorResolver> ();
if (textEditorResolver != null)
{
ResolveResult result = textEditorResolver.GetLanguageItem(CurrentContext.Document.TextEditor.CursorPosition, var);
if (result != null)
{
IReturnType componentType = DomType.GetComponentType(CurrentContext.ProjectDom, result.ResolvedType);
if (componentType != null)
{
Ambience ambience = AmbienceService.GetAmbience(CurrentContext.Template.MimeType);
return(ambience != null?ambience.GetString(componentType, OutputFlags.IncludeGenerics) : componentType.ToInvariantString());
}
}
}
return("var");
}
public override TooltipInformation CreateTooltipInformation(bool smartWrap)
{
var tt = base.CreateTooltipInformation(smartWrap);
tt.SignatureMarkup = member.Name;
tt.SummaryMarkup = AmbienceService.GetSummaryMarkup(member);
return(tt);
}
public override TooltipInformation CreateTooltipInformation(bool smartWrap)
{
var tt = base.CreateTooltipInformation(smartWrap);
tt.SignatureMarkup = cls.FullName;
tt.SummaryMarkup = AmbienceService.GetSummaryMarkup(cls.GetDefinition());
return(tt);
}
public ImportSymbolCompletionData(MonoDevelop.Ide.Gui.Document doc, ImportSymbolCache cache, IType type)
{
this.doc = doc;
this.cache = cache;
// this.data = doc.Editor;
this.ambience = AmbienceService.GetAmbience(doc.Editor.MimeType);
this.type = type;
this.unit = doc.ParsedDocument;
}
protected Ambience GetAmbience()
{
CheckInitialized();
IViewContent view = document.Window.ViewContent;
string file = view.IsUntitled ? view.UntitledName : view.ContentName;
return(AmbienceService.GetAmbienceForFile(file));
}
void AddClasses(ArrayList items, ICollection <IClass> classes)
{
foreach (IClass c in classes)
{
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedMemberNames | ConversionFlags.ShowTypeParameterList;
items.Add(new ComboBoxItem(c, ambience.Convert(c), ClassBrowserIconService.GetIcon(c), true));
AddClasses(items, c.InnerClasses);
}
}
public ImportSymbolCompletionData(MonoDevelop.Ide.Gui.Document doc, ImportSymbolCache cache, IType type)
{
this.doc = doc;
this.cache = cache;
// this.data = doc.Editor;
this.ambience = AmbienceService.GetAmbience(doc.Editor.MimeType);
this.type = type;
this.unit = doc.ParsedDocument;
this.DisplayFlags |= ICSharpCode.NRefactory.Completion.DisplayFlags.IsImportCompletion;
}
public override TooltipInformation CreateTooltipInformation(bool smartWrap)
{
var tti = new TooltipInformation();
tti.SignatureMarkup = "<i>(Module)</i> " + Module.ModuleName;
tti.SummaryMarkup = AmbienceService.EscapeText(Module.Description);
tti.FooterMarkup = Module.FileName;
return(tti);
}
public ImportSymbolCompletionData(MonoDevelop.Ide.Gui.Document doc, ImportSymbolCache cache, ProjectDom dom, IType type)
{
this.doc = doc;
this.cache = cache;
this.dom = dom;
this.data = doc.Editor;
this.ambience = doc.Project != null ? doc.Project.Ambience : AmbienceService.GetAmbienceForFile(doc.FileName);
this.type = type;
this.unit = doc.CompilationUnit;
}
public override string ToString()
{
if (cachedStringRepresentation == null)
{
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.ShowParameterNames;
cachedStringRepresentation = ambience.Convert(method);
}
return(cachedStringRepresentation);
}
public LanguageItemWindow(ExtensibleTextEditor ed, Gdk.ModifierType modifierState, ResolveResult result, string errorInformations, ICompilationUnit unit)
{
ProjectDom dom = ed.ProjectDom;
Ambience ambience = AmbienceService.GetAmbience(ed.Document.MimeType);
string tooltip = null;
if (result != null && ed.TextEditorResolverProvider != null)
{
tooltip = ed.TextEditorResolverProvider.CreateTooltip(dom, unit, result, errorInformations, ambience, modifierState);
if (result.ResolveErrors.Count > 0)
{
StringBuilder sb = new StringBuilder();
sb.Append(tooltip);
sb.AppendLine();
sb.AppendLine();
sb.AppendLine(GettextCatalog.GetPluralString("Error:", "Errors:", result.ResolveErrors.Count));
for (int i = 0; i < result.ResolveErrors.Count; i++)
{
sb.Append('\t');
sb.Append(result.ResolveErrors[i]);
if (i + 1 < result.ResolveErrors.Count)
{
sb.AppendLine();
}
}
tooltip = sb.ToString();
}
}
else
{
tooltip = errorInformations;
}
if (string.IsNullOrEmpty(tooltip))
{
IsEmpty = true;
return;
}
var label = new MonoDevelop.Components.FixedWidthWrapLabel()
{
Wrap = Pango.WrapMode.WordChar,
Indent = -20,
BreakOnCamelCasing = true,
BreakOnPunctuation = true,
Markup = tooltip,
};
this.BorderWidth = 3;
Add(label);
UpdateFont(label);
EnableTransparencyControl = true;
}
