Example #1
0
        // component logic

        public override void Apply(XmlDocument document, string key)
        {
            // XmlNodeList link_nodes = document.SelectNodes("//referenceLink");
            XPathNodeIterator linkIterator = document.CreateNavigator().Select(referenceLinkExpression);

            XPathNavigator[] linkNodes = BuildComponentUtilities.ConvertNodeIteratorToArray(linkIterator);

            foreach (XPathNavigator linkNode in linkNodes)
            {
                // extract link information
                ReferenceLinkInfo2 link = ReferenceLinkInfo2.Create(linkNode);

                if (link == null)
                {
                    WriteMessage(MessageLevel.Warn, "Invalid referenceLink element.");
                }
                else
                {
                    // determine target, link type, and display options
                    string         targetId = link.Target;
                    DisplayOptions options  = link.DisplayOptions;
                    LinkType2      type     = LinkType2.None;

                    Target target = GetTarget(targetId);
                    if (target == null)
                    {
                        // no such target known; set link type to none and warn
                        type = LinkType2.None;
                        WriteMessage(MessageLevel.Warn, String.Format("Unknown reference link target '{0}'.", targetId));
                    }
                    else
                    {
                        // if overload is prefered and found, change targetId and make link options hide parameters
                        if (link.PreferOverload)
                        {
                            bool isConversionOperator = false;

                            MethodTarget method = target as MethodTarget;
                            if (method != null)
                            {
                                isConversionOperator = method.conversionOperator;
                            }

                            MemberTarget member = target as MemberTarget;

                            // if conversion operator is found, always link to individual topic.
                            if ((member != null) && (!String.IsNullOrEmpty(member.OverloadId)) && !isConversionOperator)
                            {
                                Target overloadTarget = targets[member.OverloadId];
                                if (overloadTarget != null)
                                {
                                    target   = overloadTarget;
                                    targetId = overloadTarget.Id;
                                }
                            }

                            // if individual conversion operator is found, always display parameters.
                            if (isConversionOperator && member != null && (!string.IsNullOrEmpty(member.OverloadId)))
                            {
                                options = options | DisplayOptions.ShowParameters;
                            }
                            else
                            {
                                options = options & ~DisplayOptions.ShowParameters;
                            }
                        }

                        // get stored link type
                        type = target.DefaultLinkType;

                        // if link type is local or index, determine which
                        if (type == LinkType2.LocalOrIndex)
                        {
                            if ((key != null) && targets.Contains(key) && (target.Container == targets[key].Container))
                            {
                                type = LinkType2.Local;
                            }
                            else
                            {
                                type = LinkType2.Index;
                            }
                        }
                    }

                    // links to this page are not live
                    if (targetId == key)
                    {
                        type = LinkType2.Self;
                    }
                    else if ((target != null) && (key != null) && targets.Contains(key) && (target.File == targets[key].File))
                    {
                        type = LinkType2.Self;
                    }

                    // get msdn or external endpoint, if needed
                    string externalUrl = null;
                    if (type == LinkType2.Msdn || type == LinkType2.External)
                    {
                        externalUrl = ResolveExternalUrl(targetId, type);
                        if (String.IsNullOrEmpty(externalUrl))
                        {
                            type = LinkType2.None;
                        }
                    }

                    // write opening link tag and target info
                    XmlWriter writer = linkNode.InsertAfter();
                    switch (type)
                    {
                    case LinkType2.None:
                        writer.WriteStartElement("span");
                        writer.WriteAttributeString("class", "nolink");
                        break;

                    case LinkType2.Self:
                        writer.WriteStartElement("span");
                        writer.WriteAttributeString("class", "selflink");
                        break;

                    case LinkType2.Local:
                        // format link with prefix and/or postfix
                        string href = String.Format(hrefFormat, target.File);

                        // make link relative, if we have a baseUrl
                        if (baseUrl != null)
                        {
                            href = BuildComponentUtilities.GetRelativePath(href, BuildComponentUtilities.EvalXPathExpr(document, baseUrl, "key", key));
                        }

                        writer.WriteStartElement("a");
                        writer.WriteAttributeString("href", href);
                        break;

                    case LinkType2.Index:
                        writer.WriteStartElement("mshelp", "link", "http://msdn.microsoft.com/mshelp");
                        writer.WriteAttributeString("keywords", targetId);
                        writer.WriteAttributeString("tabindex", "0");
                        break;

                    case LinkType2.Msdn:
                    case LinkType2.External:
                        writer.WriteStartElement("a");
                        writer.WriteAttributeString("href", externalUrl);
                        writer.WriteAttributeString("target", linkTarget);
                        break;
                    }

                    // write the link text
                    if (String.IsNullOrEmpty(link.DisplayTarget))
                    {
                        if (link.Contents == null)
                        {
                            if (target != null)
                            {
                                resolver.WriteTarget(target, options, writer);
                            }
                            else
                            {
                                //Console.WriteLine("Attemting to create reference");
                                Reference reference = TextReferenceUtilities.CreateReference(targetId);
                                //Console.WriteLine("Returned");
                                if (reference is InvalidReference)
                                {
                                    WriteMessage(MessageLevel.Warn, String.Format("Invalid reference link target '{0}'.", targetId));
                                }
                                resolver.WriteReference(reference, options, writer);
                            }
                        }
                        else
                        {
                            // write contents to writer
                            link.Contents.WriteSubtree(writer);
                        }
                    }
                    else
                    {
                        //Console.WriteLine("Display target = {0}", link.DisplayTarget);
                        if ((String.Compare(link.DisplayTarget, "content", true) == 0) && (link.Contents != null))
                        {
                            // Use the contents as an XML representation of the display target

                            //Console.WriteLine(link.Contents.NodeType);
                            Reference reference = XmlTargetCollectionUtilities.CreateReference(link.Contents);
                            //Console.WriteLine(reference.GetType().FullName);
                            resolver.WriteReference(reference, options, writer);
                        }
                        if ((String.Compare(link.DisplayTarget, "format", true) == 0) && (link.Contents != null))
                        {
                            // Use the contents as a format string for the display target

                            string format = link.Contents.OuterXml;
                            //Console.WriteLine("format = {0}", format);

                            string       input     = null;
                            StringWriter textStore = new StringWriter();
                            try {
                                XmlWriterSettings settings = new XmlWriterSettings();
                                settings.ConformanceLevel = ConformanceLevel.Fragment;

                                XmlWriter xmlStore = XmlWriter.Create(textStore, settings);
                                try {
                                    if (target != null)
                                    {
                                        resolver.WriteTarget(target, options, xmlStore);
                                    }
                                    else
                                    {
                                        Reference reference = TextReferenceUtilities.CreateReference(targetId);
                                        resolver.WriteReference(reference, options, xmlStore);
                                    }
                                } finally {
                                    xmlStore.Close();
                                }
                                input = textStore.ToString();
                            } finally {
                                textStore.Close();
                            }
                            //Console.WriteLine("input = {0}", input);

                            string output = String.Format(format, input);
                            //Console.WriteLine("output = {0}", output);

                            XmlDocumentFragment fragment = document.CreateDocumentFragment();
                            fragment.InnerXml = output;
                            fragment.WriteTo(writer);

                            //writer.WriteRaw(output);
                        }
                        else if ((String.Compare(link.DisplayTarget, "extension", true) == 0) && (link.Contents != null))
                        {
                            Reference extMethodReference = XmlTargetCollectionUtilities.CreateExtensionMethodReference(link.Contents);
                            resolver.WriteReference(extMethodReference, options, writer);
                        }
                        else
                        {
                            // Use the display target value as a CER for the display target

                            TextReferenceUtilities.SetGenericContext(key);
                            Reference reference = TextReferenceUtilities.CreateReference(link.DisplayTarget);
                            //Console.WriteLine("Reference is {0}", reference.GetType().FullName);
                            resolver.WriteReference(reference, options, writer);
                        }
                    }

                    // write the closing link tag
                    writer.WriteEndElement();
                    writer.Close();
                }

                // delete the original tag
                linkNode.DeleteSelf();
            }
        }
Example #2
0
        public static ReferenceLinkInfo2 Create(XPathNavigator element)
        {
            if (element == null)
            {
                throw new ArgumentNullException("element");
            }

            ReferenceLinkInfo2 info = new ReferenceLinkInfo2();

            info.target = element.GetAttribute("target", String.Empty);
            if (String.IsNullOrEmpty(info.target))
            {
                return(null);
            }

            info.displayTarget = element.GetAttribute("display-target", String.Empty);

            string showContainer = element.GetAttribute("show-container", String.Empty);

            if (String.IsNullOrEmpty(showContainer))
            {
                showContainer = element.GetAttribute("qualified", String.Empty);
            }
            if (!String.IsNullOrEmpty(showContainer))
            {
                if (String.Compare(showContainer, Boolean.TrueString, true) == 0)
                {
                    info.options = info.options | DisplayOptions.ShowContainer;
                }
                else if (String.Compare(showContainer, Boolean.FalseString, true) == 0)
                {
                    info.options = info.options & ~DisplayOptions.ShowContainer;
                }
                else
                {
                    return(null);
                }
            }

            string showTemplates = element.GetAttribute("show-templates", String.Empty);

            if (!String.IsNullOrEmpty(showTemplates))
            {
                if (String.Compare(showTemplates, Boolean.TrueString, true) == 0)
                {
                    info.options = info.options | DisplayOptions.ShowTemplates;
                }
                else if (String.Compare(showTemplates, Boolean.FalseString, true) == 0)
                {
                    info.options = info.options & ~DisplayOptions.ShowTemplates;
                }
                else
                {
                    return(null);
                }
            }

            string showParameters = element.GetAttribute("show-parameters", String.Empty);

            if (!String.IsNullOrEmpty(showParameters))
            {
                if (String.Compare(showParameters, Boolean.TrueString, true) == 0)
                {
                    info.options = info.options | DisplayOptions.ShowParameters;
                }
                else if (String.Compare(showParameters, Boolean.FalseString, true) == 0)
                {
                    info.options = info.options & ~DisplayOptions.ShowParameters;
                }
                else
                {
                    return(null);
                }
            }


            string preferOverload = element.GetAttribute("prefer-overload", String.Empty);

            if (String.IsNullOrEmpty(preferOverload))
            {
                preferOverload = element.GetAttribute("auto-upgrade", String.Empty);
            }
            if (!String.IsNullOrEmpty(preferOverload))
            {
                if (String.Compare(preferOverload, Boolean.TrueString, true) == 0)
                {
                    info.preferOverload = true;
                }
                else if (String.Compare(preferOverload, Boolean.FalseString, true) == 0)
                {
                    info.preferOverload = false;
                }
                else
                {
                    return(null);
                }
            }

            info.contents = element.Clone();
            if (!info.contents.MoveToFirstChild())
            {
                info.contents = null;
            }

            return(info);
        }
        public static ReferenceLinkInfo2 Create (XPathNavigator element) {
            if (element == null) throw new ArgumentNullException("element");

            ReferenceLinkInfo2 info = new ReferenceLinkInfo2();

            info.target = element.GetAttribute("target", String.Empty);
            if (String.IsNullOrEmpty(info.target)) return(null);

            info.displayTarget = element.GetAttribute("display-target", String.Empty);

            string showContainer = element.GetAttribute("show-container", String.Empty);
            if (String.IsNullOrEmpty(showContainer)) showContainer = element.GetAttribute("qualified", String.Empty);
            if (!String.IsNullOrEmpty(showContainer)) {
                if (String.Compare(showContainer, Boolean.TrueString, true) == 0) {
                    info.options = info.options | DisplayOptions.ShowContainer;
                } else if (String.Compare(showContainer, Boolean.FalseString, true) == 0) {
                    info.options = info.options & ~DisplayOptions.ShowContainer;
                } else {
                    return(null);
                }
            }
            
            string showTemplates = element.GetAttribute("show-templates", String.Empty);
            if (!String.IsNullOrEmpty(showTemplates)) {
                if (String.Compare(showTemplates, Boolean.TrueString, true) == 0) {
                    info.options = info.options | DisplayOptions.ShowTemplates;
                } else if (String.Compare(showTemplates, Boolean.FalseString, true) == 0) {
                    info.options = info.options & ~DisplayOptions.ShowTemplates;
                } else {
                    return(null);
                }
            }

            string showParameters = element.GetAttribute("show-parameters", String.Empty);
            if (!String.IsNullOrEmpty(showParameters)) {
                if (String.Compare(showParameters, Boolean.TrueString, true) == 0) {
                    info.options = info.options | DisplayOptions.ShowParameters;
                } else if (String.Compare(showParameters, Boolean.FalseString, true) == 0) {
                    info.options = info.options & ~DisplayOptions.ShowParameters;
                } else {
                    return(null);
                }
            }


            string preferOverload = element.GetAttribute("prefer-overload", String.Empty);
            if (String.IsNullOrEmpty(preferOverload)) preferOverload = element.GetAttribute("auto-upgrade", String.Empty);
            if (!String.IsNullOrEmpty(preferOverload)) {
                if (String.Compare(preferOverload, Boolean.TrueString, true) == 0) {
                    info.preferOverload = true;
                } else if (String.Compare(preferOverload, Boolean.FalseString, true) == 0) {
                    info.preferOverload = false;
                } else {
                    return(null);
                }
            }

            info.contents = element.Clone();
            if (!info.contents.MoveToFirstChild()) info.contents = null;

            return(info);
        }