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.GetDocumentationSummary(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.GetDocumentationSummary(eve));
}
}
}
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());
}
void CheckDescription()
{
if (descriptionCreated)
{
return;
}
var sb = new StringBuilder();
descriptionCreated = true;
if (Entity is IMethod && ((IMethod)Entity).IsExtensionMethod)
{
sb.Append(GettextCatalog.GetString("(Extension) "));
}
try
{
var amb = new MyAmbience(GetBuilder(Entity.Compilation));
sb.Append(GLib.Markup.EscapeText(amb.ConvertEntity(Entity)));
}
catch (Exception e)
{
sb.Append(e.ToString());
}
var m = (IMember)Entity;
if (m.IsObsolete())
{
sb.AppendLine();
sb.Append(GettextCatalog.GetString("[Obsolete]"));
DisplayFlags |= DisplayFlags.Obsolete;
}
var returnType = m.ReturnType;
if (returnType.Kind == TypeKind.Delegate)
{
sb.AppendLine();
sb.AppendLine(GettextCatalog.GetString("Delegate information"));
sb.Append(ambience.GetString(returnType, OutputFlags.ReformatDelegates | OutputFlags.IncludeReturnType | OutputFlags.IncludeParameters | OutputFlags.IncludeParameterName));
}
string docMarkup = AmbienceService.GetDocumentationMarkup("<summary>" + AmbienceService.GetDocumentationSummary((IMember)Entity) + "</summary>", new AmbienceService.DocumentationFormatOptions
{
Ambience = ambience
});
if (!string.IsNullOrEmpty(docMarkup))
{
sb.AppendLine();
sb.Append(docMarkup);
}
description = sb.ToString();
}
public string GetMethodMarkup(int overload, string[] parameterMarkup, int currentParameter)
{
StringBuilder result = new StringBuilder();
// int curLen = 0;
result.Append(ambience.GetString(indexers[overload].ReturnType, OutputFlags.ClassBrowserEntries));
result.Append(' ');
result.Append("<b>");
result.Append(resolvedExpression);
result.Append("</b>");
result.Append('[');
int parameterCount = 0;
foreach (string parameter in parameterMarkup)
{
if (parameterCount > 0)
{
result.Append(", ");
}
result.Append(parameter);
parameterCount++;
}
result.Append(']');
IParameter 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))
{
Regex paramRegex = new Regex("(\\<param\\s+name\\s*=\\s*\"" + curParameter.Name + "\"\\s*\\>.*?\\</param\\>)", RegexOptions.Compiled);
Match 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());
}
void CheckDescription()
{
if (descriptionCreated)
{
return;
}
var sb = new StringBuilder();
descriptionCreated = true;
if (Entity is IMethod && ((IMethod)Entity).IsExtensionMethod)
{
sb.Append(GettextCatalog.GetString("(Extension) "));
}
sb.Append(ambience.GetString(Entity,
OutputFlags.ClassBrowserEntries | OutputFlags.IncludeReturnType | OutputFlags.IncludeKeywords | OutputFlags.UseFullName | OutputFlags.IncludeParameterName | OutputFlags.IncludeMarkup | (HideExtensionParameter ? OutputFlags.HideExtensionsParameter : OutputFlags.None)));
var m = (IMember)Entity;
if (m.IsObsolete())
{
sb.AppendLine();
sb.Append(GettextCatalog.GetString("[Obsolete]"));
DisplayFlags |= DisplayFlags.Obsolete;
}
var returnType = m.ReturnType;
if (returnType.Kind == TypeKind.Delegate)
{
sb.AppendLine();
sb.AppendLine(GettextCatalog.GetString("Delegate information"));
sb.Append(ambience.GetString(returnType, OutputFlags.ReformatDelegates | OutputFlags.IncludeReturnType | OutputFlags.IncludeParameters | OutputFlags.IncludeParameterName));
}
string docMarkup = AmbienceService.GetDocumentationMarkup("<summary>" + AmbienceService.GetDocumentationSummary((IMember)Entity) + "</summary>", new AmbienceService.DocumentationFormatOptions {
Ambience = ambience
});
if (!string.IsNullOrEmpty(docMarkup))
{
sb.AppendLine();
sb.Append(docMarkup);
}
description = sb.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 void AddOverload(MemberCompletionData overload)
{
if (overloads == null)
{
overloads = new Dictionary <string, CompletionData> ();
}
if (overload.Entity is IMember && Entity is IMember)
{
// filter virtual & overriden members that came from base classes
// note that the overload tree is traversed top down.
var member = Entity as IMember;
if ((member.IsVirtual || member.IsOverride) && member.DeclaringType != null && ((IMember)overload.Entity).DeclaringType != null && member.DeclaringType.ReflectionName != ((IMember)overload.Entity).DeclaringType.ReflectionName)
{
string str1 = ambience.GetString(member as IMember, flags);
string str2 = ambience.GetString(overload.Entity as IMember, flags);
if (str1 == str2)
{
if (string.IsNullOrEmpty(AmbienceService.GetDocumentationSummary((IMember)Entity)) && !string.IsNullOrEmpty(AmbienceService.GetDocumentationSummary((IMember)overload.Entity)))
{
SetMember(overload.Entity as IMember);
}
return;
}
}
string MemberId = (overload.Entity as IMember).GetIdString();
if (Entity is IMethod && overload.Entity is IMethod)
{
string signature1 = ambience.GetString(Entity as IMember, OutputFlags.IncludeParameters | OutputFlags.IncludeGenerics | OutputFlags.GeneralizeGenerics);
string signature2 = ambience.GetString(overload.Entity as IMember, OutputFlags.IncludeParameters | OutputFlags.IncludeGenerics | OutputFlags.GeneralizeGenerics);
if (signature1 == signature2)
{
return;
}
}
if (MemberId != (this.Entity as IMember).GetIdString() && !overloads.ContainsKey(MemberId))
{
// if (((IMethod)overload.Member).IsPartial)
// return;
overloads[MemberId] = overload;
//if any of the overloads is obsolete, we should not mark the item obsolete
if (!(overload.Entity as IMember).IsObsolete())
{
DisplayFlags &= ~DisplayFlags.Obsolete;
}
/*
* //make sure that if there are generic overloads, we show a generic signature
* if (overload.Member is IType && Member is IType && ((IType)Member).TypeParameters.Count == 0 && ((IType)overload.Member).TypeParameters.Count > 0) {
* displayText = overload.DisplayText;
* }
* if (overload.Member is IMethod && Member is IMethod && ((IMethod)Member).TypeParameters.Count == 0 && ((IMethod)overload.Member).TypeParameters.Count > 0) {
* displayText = overload.DisplayText;
* }*/
}
}
// always set the member with the least type parameters as the main member.
// if (Member is ITypeParameterMember && overload.Member is ITypeParameterMember) {
// if (((ITypeParameterMember)Member).TypeParameters.Count > ((ITypeParameterMember)overload.Member).TypeParameters.Count) {
// INode member = Member;
// SetMember (overload.Member);
// overload.Member = member;
// }
// }
}
public override string GetDescription(int overload, int currentParameter)
{
// var flags = OutputFlags.ClassBrowserEntries | OutputFlags.IncludeMarkup | OutputFlags.IncludeGenerics;
//
// string name = delegateType.Name;
// var parameters = new StringBuilder ();
// int curLen = 0;
var sb = new StringBuilder();
if (delegateType.GetDefinition().IsObsolete())
{
sb.AppendLine();
sb.Append(GettextCatalog.GetString("[Obsolete]"));
}
var curParameter = currentParameter >= 0 && currentParameter < delegateMethod.Parameters.Count ? delegateMethod.Parameters [currentParameter] : null;
string docText = AmbienceService.GetDocumentation(delegateType.GetDefinition());
if (!string.IsNullOrEmpty(docText))
{
string text = docText;
if (curParameter != null)
{
Regex paramRegex = new Regex("(\\<param\\s+name\\s*=\\s*\"" + curParameter.Name + "\"\\s*\\>.*?\\</param\\>)", RegexOptions.Compiled);
Match match = paramRegex.Match(docText);
if (match.Success)
{
text = match.Groups [1].Value;
text = "<summary>" + AmbienceService.GetDocumentationSummary(delegateMethod) + "</summary>" + text;
}
}
else
{
text = "<summary>" + AmbienceService.GetDocumentationSummary(delegateMethod) + "</summary>";
}
sb.Append(AmbienceService.GetDocumentationMarkup(text, new AmbienceService.DocumentationFormatOptions
{
HighlightParameter = curParameter != null ? curParameter.Name : null,
Ambience = ambience,
SmallText = true,
BoldHeadings = false
}));
}
if (curParameter != null)
{
var returnType = curParameter.Type;
if (returnType.Kind == TypeKind.Delegate)
{
if (sb.Length > 0)
{
sb.AppendLine();
sb.AppendLine();
}
sb.Append("<small>");
sb.AppendLine(GettextCatalog.GetString("Delegate information"));
sb.Append(ambience.GetString(returnType, OutputFlags.ReformatDelegates | OutputFlags.IncludeReturnType | OutputFlags.IncludeParameters | OutputFlags.IncludeParameterName));
sb.Append("</small>");
}
}
return(sb.ToString());
}
public void GenerateDoc(IMember member)
{
Init(member);
this.member = member;
this.currentType = GetType(member);
DocConfig.Instance.Rules.ForEach(r => r.Run(this));
if (member.CanHaveParameters)
{
this.currentType = "parameter";
foreach (IParameter p in member.Parameters)
{
curName = p.Name;
this.member = member;
SplitWords(p, p.Name);
DocConfig.Instance.Rules.ForEach(r => r.Run(this));
}
}
if (member is IMethod)
{
IMethod method = (IMethod)member;
int count = 1;
foreach (var param in method.TypeParameters)
{
this.currentType = "typeparam";
curName = param.Name;
tags["TypeParam"] = param.Name;
switch (count)
{
case 1:
tags["TypeParamNumber"] = "1st";
break;
case 2:
tags["TypeParamNumber"] = "2nd";
break;
case 3:
tags["TypeParamNumber"] = "3rd";
break;
default:
tags["TypeParamNumber"] = count + "th";
break;
}
count++;
Console.WriteLine("type parameter:" + curName);
DocConfig.Instance.Rules.ForEach(r => r.Run(this));
}
}
IType type;
if (member is IType)
{
type = (IType)member;
}
else
{
type = member.DeclaringType;
}
this.currentType = "exception";
foreach (var exception in visitor.Exceptions)
{
var exceptionType = HelperMethods.ConvertToReturnType(exception);
curName = exceptionType.FullName;
tags["Exception"] = exceptionType.ToInvariantString();
SplitWords(exceptionType, exceptionType.Name);
if (type != null)
{
IType resolvedType = type.SourceProjectDom.SearchType(type, exceptionType);
string sentence = AmbienceService.GetDocumentationSummary(resolvedType).Trim();
if (sentence.StartsWith("<para>") && sentence.EndsWith("</para>"))
{
sentence = sentence.Substring("<para>".Length, sentence.Length - "<para>".Length - "</para>".Length).Trim();
}
if (sentence.StartsWith("Represents the error that occurs when"))
{
sentence = "Is thrown when" + sentence.Substring("Represents the error that occurs when".Length);
}
if (!string.IsNullOrEmpty(sentence))
{
Set("exception", curName, sentence);
}
}
DocConfig.Instance.Rules.ForEach(r => r.Run(this));
}
}
public string GetMethodMarkup(int overload, string[] parameterMarkup, int currentParameter)
{
string name = (this.delegateName ?? (methods[overload].IsConstructor ? ambience.GetString(methods[overload].DeclaringType, OutputFlags.ClassBrowserEntries | OutputFlags.IncludeMarkup | OutputFlags.IncludeGenerics) : methods[overload].Name));
StringBuilder parameters = new StringBuilder();
int curLen = 0;
string prefix = !methods[overload].IsConstructor ? ambience.GetString(methods[overload].ReturnType, OutputFlags.ClassBrowserEntries | OutputFlags.IncludeMarkup | OutputFlags.IncludeGenerics) + " " : "";
foreach (string parameter in parameterMarkup)
{
if (parameters.Length > 0)
{
parameters.Append(", ");
}
string text;
Pango.AttrList attrs;
char ch;
Pango.Global.ParseMarkup(parameter, '_', out attrs, out text, out ch);
if (curLen > 80)
{
parameters.AppendLine();
parameters.Append(new string (' ', (prefix != null ? prefix.Length : 0) + name.Length + 4));
curLen = 0;
}
curLen += text.Length + 2;
parameters.Append(parameter);
}
StringBuilder sb = new StringBuilder();
if (methods[overload].WasExtended)
{
sb.Append(GettextCatalog.GetString("(Extension) "));
}
sb.Append(prefix);
sb.Append("<b>");
sb.Append(name);
sb.Append("</b> (");
sb.Append(parameters.ToString());
sb.Append(")");
if (methods[overload].IsObsolete)
{
sb.AppendLine();
sb.Append(GettextCatalog.GetString("[Obsolete]"));
}
IParameter curParameter = currentParameter >= 0 && currentParameter < methods[overload].Parameters.Count ? methods[overload].Parameters[currentParameter] : null;
string docText = AmbienceService.GetDocumentation(methods[overload]);
if (!string.IsNullOrEmpty(docText))
{
string text = docText;
if (curParameter != null)
{
Regex paramRegex = new Regex("(\\<param\\s+name\\s*=\\s*\"" + curParameter.Name + "\"\\s*\\>.*?\\</param\\>)", RegexOptions.Compiled);
Match match = paramRegex.Match(docText);
if (match.Success)
{
text = match.Groups[1].Value;
text = "<summary>" + AmbienceService.GetDocumentationSummary(methods[overload]) + "</summary>" + text;
}
}
else
{
text = "<summary>" + AmbienceService.GetDocumentationSummary(methods[overload]) + "</summary>";
}
sb.AppendLine();
sb.Append(AmbienceService.GetDocumentationMarkup(text, new AmbienceService.DocumentationFormatOptions {
HighlightParameter = curParameter != null ? curParameter.Name : null,
Ambience = ambience,
SmallText = true
}));
}
return(sb.ToString());
}
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());
}
void CheckDescription()
{
if (descriptionCreated)
{
return;
}
StringBuilder sb = new StringBuilder();
descriptionCreated = true;
if (Member is IMethod && ((IMethod)Member).WasExtended)
{
sb.Append(GettextCatalog.GetString("(Extension) "));
}
sb.Append(ambience.GetString(Member,
OutputFlags.ClassBrowserEntries | OutputFlags.IncludeKeywords | OutputFlags.UseFullName | OutputFlags.IncludeParameterName | OutputFlags.IncludeMarkup
| (HideExtensionParameter ? OutputFlags.HideExtensionsParameter : OutputFlags.None)));
if (Member is IMember)
{
if ((Member as IMember).IsObsolete)
{
sb.AppendLine();
sb.Append(GettextCatalog.GetString("[Obsolete]"));
DisplayFlags |= DisplayFlags.Obsolete;
}
string docMarkup = AmbienceService.GetDocumentationMarkup("<summary>" + AmbienceService.GetDocumentationSummary((IMember)Member) + "</summary>", new AmbienceService.DocumentationFormatOptions {
Ambience = ambience
});
if (!string.IsNullOrEmpty(docMarkup))
{
sb.AppendLine();
sb.Append(docMarkup);
}
}
description = sb.ToString();
}
void CheckDescription()
{
if (descriptionCreated)
{
return;
}
StringBuilder sb = new StringBuilder();
descriptionCreated = true;
if (Member is IMethod && ((IMethod)Member).WasExtended)
{
sb.Append(GettextCatalog.GetString("(Extension) "));
}
sb.Append(ambience.GetString(Member,
OutputFlags.ClassBrowserEntries | OutputFlags.IncludeKeywords | OutputFlags.UseFullName | OutputFlags.IncludeParameterName | OutputFlags.IncludeMarkup | (HideExtensionParameter ? OutputFlags.HideExtensionsParameter : OutputFlags.None)));
if (Member is IMember)
{
var m = (IMember)Member;
if (m.IsObsolete)
{
sb.AppendLine();
sb.Append(GettextCatalog.GetString("[Obsolete]"));
DisplayFlags |= DisplayFlags.Obsolete;
}
var returnType = m.SourceProjectDom != null?m.SourceProjectDom.GetType(m.ReturnType) : null;
if (returnType != null && returnType.ClassType == MonoDevelop.Projects.Dom.ClassType.Delegate)
{
sb.AppendLine();
sb.AppendLine(GettextCatalog.GetString("Delegate information"));
sb.Append(ambience.GetString(returnType, OutputFlags.ReformatDelegates | OutputFlags.IncludeReturnType | OutputFlags.IncludeParameters | OutputFlags.IncludeParameterName));
}
string docMarkup = AmbienceService.GetDocumentationMarkup("<summary>" + AmbienceService.GetDocumentationSummary((IMember)Member) + "</summary>", new AmbienceService.DocumentationFormatOptions {
Ambience = ambience
});
if (!string.IsNullOrEmpty(docMarkup))
{
sb.AppendLine();
sb.Append(docMarkup);
}
}
description = sb.ToString();
}
public string CreateTooltip(IParsedFile unit, 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(object domVisitable, ref string outString) {
// // crop used namespaces.
// if (unit != null) {
// int len = 0;
// foreach (var 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 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(ambience.GetString(method, settings));
if (allMethods.Count > 1)
{
int overloadCount = allMethods.Count - 1;
s.Append(string.Format(GettextCatalog.GetPluralString(" (+{0} overload)", " (+{0} overloads)", overloadCount), overloadCount));
}
doc = 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(ambience.GetString(field.Type, settings));
s.Append(" ");
s.Append(field.Name);
s.Append(" = ");
s.Append(GetConst(field.ConstantValue));
s.Append(";");
}
else
{
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(((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;
s.Append(ambience.GetString(tr.Type, settings));
doc = AmbienceService.GetDocumentationSummary(tr.Type.GetDefinition());
}
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());
}
void AddAspAttributeValueCompletionData(CompletionDataList list, S.XName tagName, S.XName attName, string id)
{
Debug.Assert(tagName.IsValid && tagName.HasPrefix);
Debug.Assert(attName.IsValid && !attName.HasPrefix);
IType controlClass = HasDoc ? refman.GetControlType(tagName.Prefix, tagName.Name) : null;
if (controlClass == null)
{
LoggingService.LogWarning("Could not obtain IType for {0}", tagName.FullName);
var database = WebTypeContext.GetSystemWebDom(project);
controlClass = database.LookupType("System.Web.UI.WebControls", "WebControl");
if (controlClass == null)
{
LoggingService.LogWarning("Could not obtain IType for System.Web.UI.WebControls.WebControl");
return;
}
}
//find the codebehind class
IType codeBehindClass;
ICompilation projectDatabase;
GetCodeBehind(out codeBehindClass, out projectDatabase);
//if it's an event, suggest compatible methods
if (codeBehindClass != null && attName.Name.StartsWith("On"))
{
string eventName = attName.Name.Substring(2);
foreach (IEvent ev in controlClass.GetEvents())
{
if (ev.Name == eventName)
{
var domMethod = BindingService.MDDomToCodeDomMethod(ev);
if (domMethod == null)
{
return;
}
foreach (IMethod 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,
MonoDevelop.DesignerSupport.CodeBehind.GetNonDesignerClass(codeBehindClass))
);
return;
}
}
}
if (projectDatabase == null)
{
projectDatabase = WebTypeContext.GetSystemWebDom(project);
if (projectDatabase == null)
{
LoggingService.LogWarning("Could not obtain type database in AddAspAttributeCompletionData");
return;
}
}
//if it's a property and is an enum or bool, suggest valid values
foreach (IProperty prop in controlClass.GetProperties())
{
if (prop.Name != attName.Name)
{
continue;
}
//boolean completion
if (prop.ReturnType.Equals(projectDatabase.FindType(KnownTypeCode.Boolean)))
{
AddBooleanCompletionData(list);
return;
}
//color completion
if (prop.ReturnType.Equals(projectDatabase.FindType(typeof(System.Drawing.Color))))
{
System.Drawing.ColorConverter 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
IType retCls = prop.ReturnType;
if (retCls != null && retCls.Kind == TypeKind.Enum)
{
foreach (var enumVal in retCls.GetFields())
{
if (enumVal.IsPublic && enumVal.IsStatic)
{
list.Add(enumVal.Name, "md-literal", AmbienceService.GetDocumentationSummary(enumVal));
}
}
return;
}
}
}
/*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 void GetElementCompletions(CompletionDataList list)
{
S.XName parentName = GetParentElementName(0);
//fallback
if (!HasDoc)
{
AddAspBeginExpressions(list);
string aspPrefix = "asp:";
foreach (var cls in WebTypeContext.ListSystemControlClasses(TypeSystemService.GetCompilation(project).LookupType("System.Web.UI", "Control"), project))
{
list.Add(new AspTagCompletionData(aspPrefix, cls));
}
base.GetElementCompletions(list);
return;
}
IType controlClass = null;
if (parentName.HasPrefix)
{
controlClass = refman.GetControlType(parentName.Prefix, parentName.Name);
}
else
{
S.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)
{
AddHtmlTagCompletionData(list, Schema, new S.XName("div"));
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());
base.GetElementCompletions(list);
}
return;
}
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
AddHtmlTagCompletionData(list, Schema, new S.XName("body"));
return;
}
//children of properties
if (childrenAsProperties && (!parentName.HasPrefix || defaultProp != null))
{
if (controlClass.GetProjectContent() == null)
{
LoggingService.LogWarning("IType {0} does not have a SourceProjectDom", controlClass);
return;
}
string propName = defaultProp ?? parentName.Name;
IProperty property =
controlClass.GetProperties()
.Where(x => string.Compare(propName, x.Name, StringComparison.OrdinalIgnoreCase) == 0)
.FirstOrDefault();
if (property == null)
{
return;
}
//sanity checks on attributes
switch (GetPersistenceMode(property))
{
case System.Web.UI.PersistenceMode.Attribute:
case System.Web.UI.PersistenceMode.EncodedInnerDefaultProperty:
return;
case System.Web.UI.PersistenceMode.InnerDefaultProperty:
if (!parentName.HasPrefix)
{
return;
}
break;
case System.Web.UI.PersistenceMode.InnerProperty:
if (parentName.HasPrefix)
{
return;
}
break;
}
//check if allows freeform ASP/HTML content
if (property.ReturnType.ToString() == "System.Web.UI.ITemplate")
{
AddAspBeginExpressions(list);
AddMiscBeginTags(list);
AddHtmlTagCompletionData(list, Schema, new S.XName("body"));
list.AddRange(refman.GetControlCompletionData());
return;
}
//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
IType collectionType = property.ReturnType;
if (collectionType == null)
{
list.AddRange(refman.GetControlCompletionData());
return;
}
string addStr = "Add";
IMethod meth = collectionType.GetMethods()
.Where(m => m.Parameters.Count == 1 && m.Name == addStr).FirstOrDefault();
if (meth != null)
{
IType argType = meth.Parameters [0].Type;
if (argType != null && argType.IsBaseType(argType.GetDefinition().Compilation.LookupType("System.Web.UI", "Control")))
{
list.AddRange(refman.GetControlCompletionData(argType));
return;
}
}
list.AddRange(refman.GetControlCompletionData());
return;
}
//properties as children of controls
if (parentName.HasPrefix && childrenAsProperties)
{
if (controlClass.GetProjectContent() == null)
{
LoggingService.LogWarning("IType {0} does not have a SourceProjectDom", controlClass);
}
foreach (IProperty prop in GetUniqueMembers <IProperty> (controlClass.GetProperties()))
{
if (GetPersistenceMode(prop) != System.Web.UI.PersistenceMode.Attribute)
{
list.Add(prop.Name, prop.GetStockIcon(), AmbienceService.GetDocumentationSummary(prop));
}
}
return;
}
}
