Add the navigation summary link.

@param members members to be linked
@param visibleMemberMap the visible inherited members map
@param liNav the content tree to which the navigation summary link will be added
162486
protected void addNavSummaryLink(SortedSet<? extends Element> members,
            VisibleMemberMap visibleMemberMap, Content liNav) {
        if (!members.isEmpty()) {
            liNav.addContent(getNavSummaryLink(null, true));
            return;
        }

        TypeElement superClass = utils.getSuperClass(typeElement);
        while (superClass != null) {
            if (visibleMemberMap.hasMembers(superClass)) {
                liNav.addContent(getNavSummaryLink(superClass, true));
                return;
            }
            superClass = utils.getSuperClass(superClass);
        }
        liNav.addContent(getNavSummaryLink(null, false));
    }
968998
public void addMemberTags(ExecutableElement member, Content methodsContentTree) {
        Content tagContent = new ContentBuilder();
        TagletManager tagletManager =
            configuration.tagletManager;
        TagletWriter.genTagOutput(tagletManager, member,
            tagletManager.getSerializedFormTaglets(),
            writer.getTagletWriterInstance(false), tagContent);
        Content dlTags = new HtmlTree(HtmlTag.DL);
        dlTags.addContent(tagContent);
        methodsContentTree.addContent(dlTags);
        if (name(member).compareTo("writeExternal") == 0
                && utils.getSerialDataTrees(member).isEmpty()) {
            serialWarning(member, "doclet.MissingSerialDataTag",
                utils.getFullyQualifiedName(member.getEnclosingElement()), name(member));
        }
    }
877368
private void buildSummary(MemberSummaryWriter writer,
            VisibleMemberMap visibleMemberMap, LinkedList<Content> summaryTreeList) {
        List<ProgramElementDoc> members = new ArrayList<ProgramElementDoc>(visibleMemberMap.getLeafClassMembers(
                configuration));
        if (members.size() > 0) {
            Collections.sort(members);
            List<Content> tableContents = new LinkedList<Content>();
            for (int i = 0; i < members.size(); i++) {
                ProgramElementDoc member = members.get(i);
                final ProgramElementDoc propertyDoc =
                            visibleMemberMap.getPropertyMemberDoc(member);
                if (propertyDoc != null) {
                    processProperty(visibleMemberMap, member, propertyDoc);
                }
                Tag[] firstSentenceTags = member.firstSentenceTags();
                if (member instanceof MethodDoc && firstSentenceTags.length == 0) {
                    //Inherit comments from overriden or implemented method if
                    //necessary.
                    DocFinder.Output inheritedDoc =
                            DocFinder.search(new DocFinder.Input((MethodDoc) member));
                    if (inheritedDoc.holder != null
                            && inheritedDoc.holder.firstSentenceTags().length > 0) {
                        firstSentenceTags = inheritedDoc.holder.firstSentenceTags();
                    }
                }
                writer.addMemberSummary(classDoc, member, firstSentenceTags,
                        tableContents, i);
            }
            summaryTreeList.add(writer.getSummaryTableTree(classDoc, tableContents));
        }
    }
39309
function UMLCollaborationView() {
        UMLGeneralNodeView.apply(this, arguments);

        /** @member {UMLTemplateParameterCompartmentView} */
        this.templateParameterCompartment = new UMLTemplateParameterCompartmentView();
        this.templateParameterCompartment.selectable = Core.SK_PROPAGATE;
        this.templateParameterCompartment.parentStyle = true;
        this.addSubView(this.templateParameterCompartment);

        this.fillColor = PreferenceManager.get("uml.collaboration.fillColor", "#ffffff") || PreferenceManager.get("view.fillColor", "#ffffff");
    }
1319758
protected void addMemberDesc(MemberDoc member, Content contentTree) {
        ClassDoc containing = member.containingClass();
        String classdesc = utils.getTypeName(
                configuration, containing, true) + " ";
        if (member.isField()) {
            if (member.isStatic()) {
                contentTree.addContent(
                        getResource("doclet.Static_variable_in", classdesc));
            } else {
                contentTree.addContent(
                        getResource("doclet.Variable_in", classdesc));
            }
        } else if (member.isConstructor()) {
            contentTree.addContent(
                    getResource("doclet.Constructor_for", classdesc));
        } else if (member.isMethod()) {
            if (member.isStatic()) {
                contentTree.addContent(
                        getResource("doclet.Static_method_in", classdesc));
            } else {
                contentTree.addContent(
                        getResource("doclet.Method_in", classdesc));
            }
        }
        addPreQualifiedClassLink(LinkInfoImpl.Kind.INDEX, containing,
                false, contentTree);
    }
555028
protected void addReceiverAnnotations(ExecutableMemberDoc member, Type rcvrType,
            AnnotationDesc[] descList, Content tree) {
        writer.addReceiverAnnotationInfo(member, descList, tree);
        tree.addContent(writer.getSpace());
        tree.addContent(rcvrType.typeName());
        LinkInfoImpl linkInfo = new LinkInfoImpl(configuration,
                LinkInfoImpl.Kind.CLASS_SIGNATURE, rcvrType);
        tree.addContent(writer.getTypeParameterLinks(linkInfo));
        tree.addContent(writer.getSpace());
        tree.addContent("this");
    }
518669
public void addSummaryLinkComment(AbstractMemberWriter mw,
            ProgramElementDoc member, Content contentTree) {
        addSummaryLinkComment(mw, member, member.firstSentenceTags(), contentTree);
    }
447886
public void buildAnnotationTypeRequiredMemberSummary(XMLNode node, Content memberSummaryTree) {
        MemberSummaryWriter writer =
                memberSummaryWriters[VisibleMemberMap.ANNOTATION_TYPE_MEMBER_REQUIRED];
        VisibleMemberMap visibleMemberMap =
                visibleMemberMaps[VisibleMemberMap.ANNOTATION_TYPE_MEMBER_REQUIRED];
        addSummary(writer, visibleMemberMap, false, memberSummaryTree);
    }
341699
protected void addSummaryLink(ClassDoc cd, ProgramElementDoc member,
            Content tdSummary) {
        addSummaryLink(LinkInfoImpl.Kind.MEMBER, cd, member, tdSummary);
    }
98805
protected void addSummaryLink(TypeElement typeElement, Element member, Content tdSummary) {
        addSummaryLink(LinkInfoImpl.Kind.MEMBER, typeElement, member, tdSummary);
    }
947731
@Override
    protected void addSummaryLink(LinkInfoImpl.Kind context, TypeElement te, Element member,
            Content tdSummary) {
        ExecutableElement ee = (ExecutableElement)member;
        Content memberLink = HtmlTree.SPAN(HtmlStyle.memberNameLink,
                writer.getDocLink(context, te, ee,
                name(ee), false));
        Content code = HtmlTree.CODE(memberLink);
        addParameters(ee, false, code, name(ee).length() - 1);
        tdSummary.addContent(code);
    }
564316
public void buildFieldsSummary(XMLNode node, Content memberSummaryTree) {
        MemberSummaryWriter writer =
                memberSummaryWriters[VisibleMemberMap.FIELDS];
        VisibleMemberMap visibleMemberMap =
                visibleMemberMaps[VisibleMemberMap.FIELDS];
        addSummary(writer, visibleMemberMap, true, memberSummaryTree);
    }
953483
public void buildMemberSummary(XMLNode node, Content classContentTree) throws Exception {
        Content memberSummaryTree = writer.getMemberTreeHeader();
        configuration.getBuilderFactory().
                getMemberSummaryBuilder(writer).buildChildren(node, memberSummaryTree);
        classContentTree.addContent(writer.getMemberSummaryTree(memberSummaryTree));
    }
850977
private void buildInheritedSummary(MemberSummaryWriter writer,
            VisibleMemberMap visibleMemberMap, LinkedList<Content> summaryTreeList) {
        for (TypeElement inhclass : visibleMemberMap.getVisibleClasses()) {
            if (!(utils.isPublic(inhclass) || utils.isLinkable(inhclass))) {
                continue;
            }
            if (inhclass == typeElement) {
                continue;
            }
            SortedSet<Element> inhmembers = asSortedSet(visibleMemberMap.getMembers(inhclass));
            if (!inhmembers.isEmpty()) {
                Content inheritedTree = writer.getInheritedSummaryHeader(inhclass);
                Content linksTree = writer.getInheritedSummaryLinksTree();
                for (Element member : inhmembers) {
                    TypeElement t= inhclass;
                    if (utils.isPackagePrivate(inhclass) && !utils.isLinkable(inhclass)) {
                        t = typeElement;
                    }
                    writer.addInheritedMemberSummary(t, member, inhmembers.first() == member,
                            inhmembers.last() == member, linksTree);
                }
                inheritedTree.addContent(linksTree);
                summaryTreeList.add(writer.getMemberTree(inheritedTree));
            }
        }
    }
580817
public void buildPropertiesSummary(XMLNode node, Content memberSummaryTree) {
        MemberSummaryWriter writer =
                memberSummaryWriters[VisibleMemberMap.PROPERTIES];
        VisibleMemberMap visibleMemberMap =
                visibleMemberMaps[VisibleMemberMap.PROPERTIES];
        addSummary(writer, visibleMemberMap, true, memberSummaryTree);
    }
765812
public void addMemberHeader(MethodDoc member, Content methodsContentTree) {
        methodsContentTree.addContent(getHead(member));
        methodsContentTree.addContent(getSignature(member));
    }
297102
function UMLUndirectedRelationshipView() {
        UMLGeneralEdgeView.apply(this, arguments);
        this.tailEndStyle = Core.ES_FLAT;
        this.headEndStyle = Core.ES_FLAT;
        this.lineMode = Core.LM_SOLID;

        /** @member {boolean} */
        this.showMultiplicity = true;

        /** @member {boolean} */
        this.showType = true;

        /** @member {EdgeLabelView} */
        this.tailRoleNameLabel = new EdgeLabelView();
        this.tailRoleNameLabel.hostEdge = this;
        this.tailRoleNameLabel.edgePosition = Core.EP_TAIL;
        this.tailRoleNameLabel.alpha = Math.PI / 6;
        this.tailRoleNameLabel.distance = 30;
        this.addSubView(this.tailRoleNameLabel);

        /** @member {EdgeLabelView} */
        this.tailPropertyLabel = new EdgeLabelView();
        this.tailPropertyLabel.hostEdge = this;
        this.tailPropertyLabel.edgePosition = Core.EP_TAIL;
        this.tailPropertyLabel.alpha = Math.PI / 4;
        this.tailPropertyLabel.distance = 40;
        this.addSubView(this.tailPropertyLabel);

        /** @member {EdgeLabelView} */
        this.tailMultiplicityLabel = new EdgeLabelView();
        this.tailMultiplicityLabel.hostEdge = this;
        this.tailMultiplicityLabel.edgePosition = Core.EP_TAIL;
        this.tailMultiplicityLabel.alpha = -Math.PI / 6;
        this.tailMultiplicityLabel.distance = 25;
        this.addSubView(this.tailMultiplicityLabel);

        /** @member {EdgeLabelView} */
        this.headRoleNameLabel = new EdgeLabelView();
        this.headRoleNameLabel.hostEdge = this;
        this.headRoleNameLabel.edgePosition = Core.EP_HEAD;
        this.headRoleNameLabel.alpha = -Math.PI / 6;
        this.headRoleNameLabel.distance = 30;
        this.addSubView(this.headRoleNameLabel);

        /** @member {EdgeLabelView} */
        this.headPropertyLabel = new EdgeLabelView();
        this.headPropertyLabel.hostEdge = this;
        this.headPropertyLabel.edgePosition = Core.EP_HEAD;
        this.headPropertyLabel.alpha = -Math.PI / 4;
        this.headPropertyLabel.distance = 40;
        this.addSubView(this.headPropertyLabel);

        /** @member {EdgeLabelView} */
        this.headMultiplicityLabel = new EdgeLabelView();
        this.headMultiplicityLabel.hostEdge = this;
        this.headMultiplicityLabel.edgePosition = Core.EP_HEAD;
        this.headMultiplicityLabel.alpha = Math.PI / 6;
        this.headMultiplicityLabel.distance = 25;
        this.addSubView(this.headMultiplicityLabel);
    }