public void Run(AstNode node)
{
if (node is EntityDeclaration)
{
IMemberRef mr = node.Annotation <IMemberRef>();
if (mr != null && mr.Module != null)
{
var xmldoc = XmlDocLoader.LoadDocumentation(mr.Module);
if (xmldoc != null)
{
string doc = xmldoc.GetDocumentation(XmlDocKeyProvider.GetKey(mr, stringBuilder));
if (!string.IsNullOrEmpty(doc))
{
InsertXmlDocumentation(node, doc);
}
}
}
if (!(node is TypeDeclaration))
{
return; // don't recurse into attributed nodes, except for type definitions
}
}
foreach (AstNode child in node.Children)
{
Run(child);
}
}
static TextBlock CreateTextBlockForEntity(IEntity resolved)
{
XmlDocRenderer renderer = new XmlDocRenderer();
renderer.AppendText(MainWindow.Instance.CurrentLanguage.GetTooltip(resolved));
try {
if (resolved.ParentModule == null || resolved.ParentModule.PEFile == null)
{
return(null);
}
var docProvider = XmlDocLoader.LoadDocumentation(resolved.ParentModule.PEFile);
if (docProvider != null)
{
string documentation = docProvider.GetDocumentation(resolved.GetIdString());
if (documentation != null)
{
renderer.AppendText(Environment.NewLine);
renderer.AddXmlDocumentation(documentation);
}
}
} catch (XmlException) {
// ignore
}
return(renderer.CreateTextBlock());
}
static IEnumerable <string> GetXmlDocComments(IMemberRef mr, StringBuilder sb)
{
if (mr == null || mr.Module == null)
{
yield break;
}
var xmldoc = XmlDocLoader.LoadDocumentation(mr.Module);
if (xmldoc == null)
{
yield break;
}
string doc = xmldoc.GetDocumentation(XmlDocKeyProvider.GetKey(mr, sb));
if (string.IsNullOrEmpty(doc))
{
yield break;
}
foreach (var info in new XmlDocLine(doc))
{
sb.Clear();
if (info != null)
{
sb.Append(' ');
info.Value.WriteTo(sb);
}
yield return(sb.ToString());
}
}
object Create(IDocumentViewerToolTipProviderContext context, SourceParameter parameter)
{
var provider = context.Create();
provider.SetImage(parameter);
context.Decompiler.WriteToolTip(provider.Output, parameter);
provider.CreateNewOutput();
var method = parameter.Parameter.Method;
try {
var docProvider = XmlDocLoader.LoadDocumentation(method.Module);
if (docProvider is not null)
{
if (!provider.Output.WriteXmlDocParameter(GetDocumentation(docProvider, method), parameter.Name))
{
var owner = method.DeclaringType;
while (owner is not null)
{
if (provider.Output.WriteXmlDocParameter(GetDocumentation(docProvider, owner), parameter.Name))
{
break;
}
owner = owner.DeclaringType;
}
}
}
}
catch (XmlException) {
}
return(provider.Create());
}
static FlowDocument CreateTooltipForEntity(IEntity resolved)
{
Language currentLanguage = MainWindow.Instance.CurrentLanguage;
DocumentationUIBuilder renderer = new DocumentationUIBuilder(new CSharpAmbience(), currentLanguage.SyntaxHighlighting);
RichText richText = currentLanguage.GetRichTextTooltip(resolved);
renderer.AddSignatureBlock(richText.Text, richText.ToRichTextModel());
try {
if (resolved.ParentModule == null || resolved.ParentModule.PEFile == null)
{
return(null);
}
var docProvider = XmlDocLoader.LoadDocumentation(resolved.ParentModule.PEFile);
if (docProvider != null)
{
string documentation = docProvider.GetDocumentation(resolved.GetIdString());
if (documentation != null)
{
renderer.AddXmlDocumentation(documentation, resolved, ResolveReference);
}
}
} catch (XmlException) {
// ignore
}
return(renderer.CreateDocument());
IEntity ResolveReference(string idString)
{
return(MainWindow.FindEntityInRelevantAssemblies(idString, MainWindow.Instance.CurrentAssemblyList.GetAssemblies()));
}
}
object Create(IDocumentViewerToolTipProviderContext context, GenericParam gp)
{
var provider = context.Create();
provider.SetImage(gp);
context.Decompiler.WriteToolTip(provider.Output, gp, null);
provider.CreateNewOutput();
try {
var docProvider = XmlDocLoader.LoadDocumentation(gp.Module);
if (docProvider is not null)
{
if (!provider.Output.WriteXmlDocGeneric(GetDocumentation(docProvider, gp.Owner), gp.Name) && gp.Owner is TypeDef)
{
// If there's no doc available, use the parent class' documentation if this
// is a generic type parameter (and not a generic method parameter).
var owner = ((TypeDef)gp.Owner).DeclaringType;
while (owner is not null)
{
if (provider.Output.WriteXmlDocGeneric(GetDocumentation(docProvider, owner), gp.Name))
{
break;
}
owner = owner.DeclaringType;
}
}
}
}
catch (XmlException) {
}
return(provider.Create());
}
internal static string GetDocumentation(this IEntity entity)
{
var docProvider = XmlDocLoader.LoadDocumentation(entity.ParentModule.PEFile);
if (docProvider == null)
{
return(null);
}
return(docProvider.GetDocumentation(entity));
}
public MainWindow()
{
InitializeComponent();
SetExceptionHandler();
IApplication app = new XMLApplication();
XmlDocLoader.LoadXmlDocuments(app);
NavModel = new NavigationModel(this);
NavigationToolbar.Set_NavModel(NavModel);
App = app;
NavModel.GoTo_Documents();
}
private object GenerateTooltip(ReferenceSegment segment)
{
if (segment.Reference is Mono.Cecil.Cil.OpCode)
{
Mono.Cecil.Cil.OpCode code = (Mono.Cecil.Cil.OpCode)segment.Reference;
string encodedName = code.Code.ToString();
string opCodeHex = code.Size > 1 ? string.Format("0x{0:x2}{1:x2}", code.Op1, code.Op2) : string.Format("0x{0:x2}", code.Op2);
XmlDocumentationProvider docProvider = XmlDocLoader.MscorlibDocumentation;
if (docProvider != null)
{
string documentation = docProvider.GetDocumentation("F:System.Reflection.Emit.OpCodes." + encodedName);
if (documentation != null)
{
XmlDocRenderer renderer = new XmlDocRenderer();
renderer.AppendText(string.Format("{0} ({1}) - ", code.Name, opCodeHex));
renderer.AddXmlDocumentation(documentation);
return(renderer.CreateTextBlock());
}
}
return(string.Format("{0} ({1})", code.Name, opCodeHex));
}
else if (segment.Reference is MemberReference)
{
MemberReference mr = (MemberReference)segment.Reference;
// if possible, resolve the reference
if (mr is TypeReference)
{
mr = ((TypeReference)mr).Resolve() ?? mr;
}
else if (mr is MethodReference)
{
mr = ((MethodReference)mr).Resolve() ?? mr;
}
XmlDocRenderer renderer = new XmlDocRenderer();
renderer.AppendText(MainWindow.Instance.CurrentLanguage.GetTooltip(mr));
try {
XmlDocumentationProvider docProvider = XmlDocLoader.LoadDocumentation(mr.Module);
if (docProvider != null)
{
string documentation = docProvider.GetDocumentation(XmlDocKeyProvider.GetKey(mr));
if (documentation != null)
{
renderer.AppendText(Environment.NewLine);
renderer.AddXmlDocumentation(documentation);
}
}
} catch (XmlException) {
// ignore
}
return(renderer.CreateTextBlock());
}
return(null);
}
static IEnumerable<string> GetXmlDocComments(IMemberRef mr)
{
if (mr == null || mr.Module == null)
yield break;
var xmldoc = XmlDocLoader.LoadDocumentation(mr.Module);
if (xmldoc == null)
yield break;
string doc = xmldoc.GetDocumentation(XmlDocKeyProvider.GetKey(mr));
if (doc == null)
yield break;
foreach (var line in AddXmlDocTransform.GetXmlDocLines(new StringReader(doc)))
yield return line;
}
public void Run(AstNode rootNode, TransformContext context)
{
if (!context.Settings.ShowXmlDocumentation)
{
return;
}
try {
var xmldoc = XmlDocLoader.LoadDocumentation(context.TypeSystem.ModuleDefinition);
if (xmldoc == null)
{
return;
}
foreach (var entity in rootNode.DescendantsAndSelf.OfType <EntityDeclaration>())
{
var symbol = entity.GetSymbol();
Mono.Cecil.MemberReference mr;
switch (symbol)
{
case IMember member:
mr = context.TypeSystem.GetCecil(member);
break;
case IType type:
mr = context.TypeSystem.GetCecil(type.GetDefinition());
break;
default:
continue;
}
if (mr == null)
{
continue;
}
string doc = xmldoc.GetDocumentation(XmlDocKeyProvider.GetKey(mr));
if (doc != null)
{
InsertXmlDocumentation(entity, new StringReader(doc));
}
}
} catch (XmlException ex) {
string[] msg = (" Exception while reading XmlDoc: " + ex).Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
var insertionPoint = rootNode.FirstChild;
for (int i = 0; i < msg.Length; i++)
{
rootNode.InsertChildBefore(insertionPoint, new Comment(msg[i], CommentType.Documentation), Roles.Comment);
}
}
}
bool TryGetDocumentation(IEntity entity, out XElement documentation)
{
if (entity is null)
{
documentation = null;
return(false);
}
if (!documentationProviders.TryGetValue(entity.ParentModule, out IDocumentationProvider documentationProvider))
{
documentationProvider = XmlDocLoader.LoadDocumentation(entity.ParentModule.PEFile);
documentationProviders.Add(entity.ParentModule, documentationProvider);
}
documentation = ConvertToDocumentation(documentationProvider?.GetDocumentation(entity));
if (documentation.HasInheritDoc(out XElement inheritDoc))
{
string referenceName = inheritDoc.GetReferenceName();
if (referenceName is null)
{
XElement baseDocumentation = null;
if (entity is ITypeDefinition type)
{
type.GetBaseTypeDefinitions().FirstOrDefault(t => TryGetDocumentation(t, out baseDocumentation));
}
else
{
string id = entity.GetIdString().Substring(entity.DeclaringTypeDefinition.GetIdString().Length);
entity
.DeclaringTypeDefinition
.GetBaseTypeDefinitions()
.SelectMany(t => t.Members)
.FirstOrDefault(e => e.GetIdString().Substring(e.DeclaringTypeDefinition.GetIdString().Length) == id && TryGetDocumentation(e, out baseDocumentation));
}
documentation = baseDocumentation;
}
else
{
return(TryGetDocumentation(IdStringProvider.FindEntity(referenceName, _resolver), out documentation));
}
}
return(documentation != null);
}
object Create(IDocumentViewerToolTipProviderContext context, IVariable v, string name)
{
var provider = context.Create();
provider.SetImage(v);
if (v == null)
{
if (name == null)
{
return(null);
}
provider.Output.Write(BoxedTextColor.Text, string.Format("(local variable) {0}", name));
return(provider.Create());
}
context.Decompiler.WriteToolTip(provider.Output, v, name);
provider.CreateNewOutput();
if (v is Parameter)
{
var method = ((Parameter)v).Method;
try {
var docProvider = XmlDocLoader.LoadDocumentation(method.Module);
if (docProvider != null)
{
if (!provider.Output.WriteXmlDocParameter(GetDocumentation(docProvider, method), v.Name))
{
var owner = method.DeclaringType;
while (owner != null)
{
if (provider.Output.WriteXmlDocParameter(GetDocumentation(docProvider, owner), v.Name))
{
break;
}
owner = owner.DeclaringType;
}
}
}
}
catch (XmlException) {
}
}
return(provider.Create());
}
object Create(IToolTipContentCreatorContext context, IVariable v, string name)
{
var creator = context.Create();
creator.SetImage(v);
if (v == null)
{
if (name == null)
{
return(null);
}
creator.Output.Write(string.Format("(local variable) {0}", name), TextTokenKind.Text);
return(creator.Create());
}
context.Language.WriteToolTip(creator.Output, v, name);
creator.CreateNewOutput();
if (v is Parameter)
{
var method = ((Parameter)v).Method;
try {
var docProvider = XmlDocLoader.LoadDocumentation(method.Module);
if (docProvider != null)
{
if (!creator.Output.WriteXmlDocParameter(GetDocumentation(docProvider, method), v.Name))
{
var owner = method.DeclaringType;
while (owner != null)
{
if (creator.Output.WriteXmlDocParameter(GetDocumentation(docProvider, owner), v.Name))
{
break;
}
owner = owner.DeclaringType;
}
}
}
}
catch (XmlException) {
}
}
return(creator.Create());
}
protected override string GetDocumentationForSymbol(string documentationMemberID, CultureInfo preferredCulture, CancellationToken cancellationToken)
{
if (!hasLoaded)
{
lock (this) {
if (!hasLoaded)
{
try {
xmlDocumentationProvider = XmlDocLoader.LoadDocumentation(this, filename);
}
catch (ArgumentException) {
}
}
hasLoaded = true;
}
}
return(xmlDocumentationProvider?.GetDocumentation(documentationMemberID));
}
object Create(IToolTipContentCreatorContext context, IMemberRef @ref)
{
var creator = context.Create();
var resolvedRef = Resolve(@ref) ?? @ref;
creator.SetImage(resolvedRef);
context.Language.WriteToolTip(creator.Output, @ref, null);
creator.CreateNewOutput();
try {
if (resolvedRef is IMemberDef)
{
var docProvider = XmlDocLoader.LoadDocumentation(resolvedRef.Module);
if (docProvider != null)
{
creator.Output.WriteXmlDoc(GetDocumentation(docProvider, resolvedRef));
}
}
}
catch (XmlException) {
}
return(creator.Create());
}
object Create(IDocumentViewerToolTipProviderContext context, IMemberRef @ref)
{
var provider = context.Create();
var resolvedRef = Resolve(@ref) ?? @ref;
provider.SetImage(resolvedRef);
context.Decompiler.WriteToolTip(provider.Output, @ref, null);
provider.CreateNewOutput();
try {
if (resolvedRef is IMemberDef)
{
var docProvider = XmlDocLoader.LoadDocumentation(resolvedRef.Module);
if (docProvider is not null)
{
provider.Output.WriteXmlDoc(GetDocumentation(docProvider, resolvedRef));
}
}
}
catch (XmlException) {
}
return(provider.Create());
}
void TextViewMouseHover(object sender, MouseEventArgs e)
{
TextViewPosition?position = textEditor.TextArea.TextView.GetPosition(e.GetPosition(textEditor.TextArea.TextView) + textEditor.TextArea.TextView.ScrollOffset);
if (position == null)
{
return;
}
int offset = textEditor.Document.GetOffset(position.Value.Location);
if (referenceElementGenerator.References == null)
{
return;
}
ReferenceSegment seg = referenceElementGenerator.References.FindSegmentsContaining(offset).FirstOrDefault();
if (seg == null)
{
return;
}
object content = GenerateTooltip(seg);
if (tooltip != null)
{
tooltip.IsOpen = false;
}
if (content != null)
{
tooltip = new ToolTip()
{
Content = content, IsOpen = true
}
}
;
}
object GenerateTooltip(ReferenceSegment segment)
{
if (segment.Reference is Mono.Cecil.Cil.OpCode)
{
Mono.Cecil.Cil.OpCode code = (Mono.Cecil.Cil.OpCode)segment.Reference;
string encodedName = code.Code.ToString();
string opCodeHex = code.Size > 1 ? string.Format("0x{0:x2}{1:x2}", code.Op1, code.Op2) : string.Format("0x{0:x2}", code.Op2);
XmlDocumentationProvider docProvider = XmlDocLoader.MscorlibDocumentation;
if (docProvider != null)
{
string documentation = docProvider.GetDocumentation("F:System.Reflection.Emit.OpCodes." + encodedName);
if (documentation != null)
{
XmlDocRenderer renderer = new XmlDocRenderer();
renderer.AppendText(string.Format("{0} ({1}) - ", code.Name, opCodeHex));
renderer.AddXmlDocumentation(documentation);
return(renderer.CreateTextBlock());
}
}
return(string.Format("{0} ({1})", code.Name, opCodeHex));
}
else if (segment.Reference is MemberReference)
{
MemberReference mr = (MemberReference)segment.Reference;
// if possible, resolve the reference
if (mr is TypeReference)
{
mr = ((TypeReference)mr).Resolve() ?? mr;
}
else if (mr is MethodReference)
{
mr = ((MethodReference)mr).Resolve() ?? mr;
}
XmlDocRenderer renderer = new XmlDocRenderer();
renderer.AppendText(MainWindow.Instance.CurrentLanguage.GetTooltip(mr));
try {
XmlDocumentationProvider docProvider = XmlDocLoader.LoadDocumentation(mr.Module);
if (docProvider != null)
{
string documentation = docProvider.GetDocumentation(XmlDocKeyProvider.GetKey(mr));
if (documentation != null)
{
renderer.AppendText(Environment.NewLine);
renderer.AddXmlDocumentation(documentation);
}
}
} catch (XmlException) {
// ignore
}
return(renderer.CreateTextBlock());
}
return(null);
}