object Create(IToolTipContentCreatorContext context, GenericParam gp)
        {
            var creator = context.Create();
            creator.SetImage(gp);

            context.Language.WriteToolTip(creator.Output, gp, null);

            creator.CreateNewOutput();
            try {
                var docProvider = XmlDocLoader.LoadDocumentation(gp.Module);
                if (docProvider != null) {
                    if (!creator.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 != null) {
                            if (creator.Output.WriteXmlDocGeneric(GetDocumentation(docProvider, owner), gp.Name))
                                break;
                            owner = owner.DeclaringType;
                        }
                    }
                }
            }
            catch (XmlException) {
            }

            return creator.Create();
        }
		public object Create(IToolTipContentCreatorContext context, object @ref) {
			var bref = @ref as BamlToolTipReference;
			if (bref != null) {
				var creator = context.Create();
				creator.Output.Write(bref.String, TextTokenKind.Text);
				return creator.Create();
			}

			return null;
		}
示例#3
0
		public object Create(IToolTipContentCreatorContext context, object @ref) {
			// This reference is added to the "decompiled" code by ModuleChildNode.Decompile()
			var sref = @ref as StringInfoReference;
			if (sref != null) {
				var creator = context.Create();
				creator.Output.Write(sref.Message, TextTokenKind.String);
				return creator.Create();
			}

			return null;
		}
		public object Create(IToolTipContentCreatorContext context, object @ref) {
			if (@ref is GenericParam)
				return Create(context, (GenericParam)@ref);
			if (@ref is IMemberRef)
				return Create(context, (IMemberRef)@ref);
			if (@ref is Parameter)
				return Create(context, (Parameter)@ref);
			if (@ref is IILVariable)
				return Create(context, (IILVariable)@ref);
			if (@ref is OpCode)
				return Create(context, (OpCode)@ref);
			return null;
		}
        object Create(IToolTipContentCreatorContext context, OpCode opCode)
        {
            var creator = context.Create();

            var s = ILLanguageHelper.GetOpCodeDocumentation(opCode);
            string opCodeHex = opCode.Size > 1 ? string.Format("0x{0:X4}", opCode.Value) : string.Format("0x{0:X2}", opCode.Value);
            creator.Output.Write(opCode.Name, TextTokenKind.OpCode);
            creator.Output.WriteSpace();
            creator.Output.Write("(", TextTokenKind.Operator);
            creator.Output.Write(opCodeHex, TextTokenKind.Number);
            creator.Output.Write(")", TextTokenKind.Operator);
            if (s != null) {
                creator.Output.Write(" - ", TextTokenKind.Text);
                creator.Output.Write(s, TextTokenKind.Text);
            }

            return creator.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();
        }
 object Create(IToolTipContentCreatorContext context, IILVariable local)
 {
     return Create(context, local.OriginalVariable, local.Name);
 }
 object Create(IToolTipContentCreatorContext context, Parameter p)
 {
     return Create(context, p, null);
 }
        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();
        }