1 /*

     2  * Copyright (c) 2003, 2016, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package jdk.javadoc.internal.doclets.formats.html;

    27 

    28 import java.util.ArrayList;

    29 import java.util.Arrays;

    30 import java.util.List;

    31 

    32 import javax.lang.model.element.Element;

    33 import javax.lang.model.element.TypeElement;

    34 import javax.lang.model.element.VariableElement;

    35 

    36 import jdk.javadoc.internal.doclets.formats.html.markup.HtmlAttr;

    37 import jdk.javadoc.internal.doclets.formats.html.markup.HtmlConstants;

    38 import jdk.javadoc.internal.doclets.formats.html.markup.HtmlStyle;

    39 import jdk.javadoc.internal.doclets.formats.html.markup.HtmlTag;

    40 import jdk.javadoc.internal.doclets.formats.html.markup.HtmlTree;

    41 import jdk.javadoc.internal.doclets.formats.html.markup.StringContent;

    42 import jdk.javadoc.internal.doclets.toolkit.Content;

    43 import jdk.javadoc.internal.doclets.toolkit.EnumConstantWriter;

    44 import jdk.javadoc.internal.doclets.toolkit.MemberSummaryWriter;

    45 

    46 /**

    47  * Writes enum constant documentation in HTML format.

    48  *

    49  *  <p><b>This is NOT part of any supported API.

    50  *  If you write code that depends on this, you do so at your own risk.

    51  *  This code and its internal interfaces are subject to change or

    52  *  deletion without notice.</b>

    53  *

    54  * @author Jamie Ho

    55  * @author Bhavesh Patel (Modified)

    56  */

    57 public class EnumConstantWriterImpl extends AbstractMemberWriter

    58     implements EnumConstantWriter, MemberSummaryWriter {

    59 

    60     public EnumConstantWriterImpl(SubWriterHolderWriter writer, TypeElement typeElement) {

    61         super(writer, typeElement);

    62     }

    63 

    64     public EnumConstantWriterImpl(SubWriterHolderWriter writer) {

    65         super(writer);

    66     }

    67 

    68     /**

    69      * {@inheritDoc}

    70      */

    71     @Override

    72     public Content getMemberSummaryHeader(TypeElement typeElement,

    73             Content memberSummaryTree) {

    74         memberSummaryTree.addContent(HtmlConstants.START_OF_ENUM_CONSTANT_SUMMARY);

    75         Content memberTree = writer.getMemberTreeHeader();

    76         writer.addSummaryHeader(this, typeElement, memberTree);

    77         return memberTree;

    78     }

    79 

    80     /**

    81      * {@inheritDoc}

    82      */

    83     public void addMemberTree(Content memberSummaryTree, Content memberTree) {

    84         writer.addMemberTree(memberSummaryTree, memberTree);

    85     }

    86 

    87     /**

    88      * {@inheritDoc}

    89      */

    90     @Override

    91     public Content getEnumConstantsDetailsTreeHeader(TypeElement typeElement,

    92             Content memberDetailsTree) {

    93         memberDetailsTree.addContent(HtmlConstants.START_OF_ENUM_CONSTANT_DETAILS);

    94         Content enumConstantsDetailsTree = writer.getMemberTreeHeader();

    95         enumConstantsDetailsTree.addContent(writer.getMarkerAnchor(

    96                 SectionName.ENUM_CONSTANT_DETAIL));

    97         Content heading = HtmlTree.HEADING(HtmlConstants.DETAILS_HEADING,

    98                 contents.enumConstantDetailLabel);

    99         enumConstantsDetailsTree.addContent(heading);

   100         return enumConstantsDetailsTree;

   101     }

   102 

   103     /**

   104      * {@inheritDoc}

   105      */

   106     @Override

   107     public Content getEnumConstantsTreeHeader(VariableElement enumConstant,

   108             Content enumConstantsDetailsTree) {

   109         enumConstantsDetailsTree.addContent(

   110                 writer.getMarkerAnchor(name(enumConstant)));

   111         Content enumConstantsTree = writer.getMemberTreeHeader();

   112         Content heading = new HtmlTree(HtmlConstants.MEMBER_HEADING);

   113         heading.addContent(name(enumConstant));

   114         enumConstantsTree.addContent(heading);

   115         return enumConstantsTree;

   116     }

   117 

   118     /**

   119      * {@inheritDoc}

   120      */

   121     @Override

   122     public Content getSignature(VariableElement enumConstant) {

   123         Content pre = new HtmlTree(HtmlTag.PRE);

   124         writer.addAnnotationInfo(enumConstant, pre);

   125         addModifiers(enumConstant, pre);

   126         Content enumConstantLink = writer.getLink(new LinkInfoImpl(

   127                 configuration, LinkInfoImpl.Kind.MEMBER, enumConstant.asType()));

   128         pre.addContent(enumConstantLink);

   129         pre.addContent(" ");

   130         if (configuration.linksource) {

   131             Content enumConstantName = new StringContent(name(enumConstant));

   132             writer.addSrcLink(enumConstant, enumConstantName, pre);

   133         } else {

   134             addName(name(enumConstant), pre);

   135         }

   136         return pre;

   137     }

   138 

   139     /**

   140      * {@inheritDoc}

   141      */

   142     @Override

   143     public void addDeprecated(VariableElement enumConstant, Content enumConstantsTree) {

   144         addDeprecatedInfo(enumConstant, enumConstantsTree);

   145     }

   146 

   147     /**

   148      * {@inheritDoc}

   149      */

   150     @Override

   151     public void addComments(VariableElement enumConstant, Content enumConstantsTree) {

   152         addComment(enumConstant, enumConstantsTree);

   153     }

   154 

   155     /**

   156      * {@inheritDoc}

   157      */

   158     @Override

   159     public void addTags(VariableElement enumConstant, Content enumConstantsTree) {

   160         writer.addTagsInfo(enumConstant, enumConstantsTree);

   161     }

   162 

   163     /**

   164      * {@inheritDoc}

   165      */

   166     @Override

   167     public Content getEnumConstantsDetails(Content enumConstantsDetailsTree) {

   168         if (configuration.allowTag(HtmlTag.SECTION)) {

   169             HtmlTree htmlTree = HtmlTree.SECTION(getMemberTree(enumConstantsDetailsTree));

   170             return htmlTree;

   171         }

   172         return getMemberTree(enumConstantsDetailsTree);

   173     }

   174 

   175     /**

   176      * {@inheritDoc}

   177      */

   178     @Override

   179     public Content getEnumConstants(Content enumConstantsTree,

   180             boolean isLastContent) {

   181         return getMemberTree(enumConstantsTree, isLastContent);

   182     }

   183 

   184     /**

   185      * {@inheritDoc}

   186      */

   187     @Override

   188     public void addSummaryLabel(Content memberTree) {

   189         Content label = HtmlTree.HEADING(HtmlConstants.SUMMARY_HEADING,

   190                 contents.enumConstantSummary);

   191         memberTree.addContent(label);

   192     }

   193 

   194     /**

   195      * {@inheritDoc}

   196      */

   197     @Override

   198     public String getTableSummary() {

   199         return resources.getText("doclet.Member_Table_Summary",

   200                 resources.getText("doclet.Enum_Constant_Summary"),

   201                 resources.getText("doclet.enum_constants"));

   202     }

   203 

   204     /**

   205      * {@inheritDoc}

   206      */

   207     @Override

   208     public Content getCaption() {

   209         return configuration.getContent("doclet.Enum_Constants");

   210     }

   211 

   212     /**

   213      * {@inheritDoc}

   214      */

   215     @Override

   216     public List<String> getSummaryTableHeader(Element member) {

   217         List<String> header = Arrays.asList(resources.getText("doclet.Enum_Constant"),

   218                 resources.getText("doclet.Description"));

   219         return header;

   220     }

   221 

   222     /**

   223      * {@inheritDoc}

   224      */

   225     @Override

   226     public void addSummaryAnchor(TypeElement typeElement, Content memberTree) {

   227         memberTree.addContent(writer.getMarkerAnchor(

   228                 SectionName.ENUM_CONSTANT_SUMMARY));

   229     }

   230 

   231     /**

   232      * {@inheritDoc}

   233      */

   234     @Override

   235     public void addInheritedSummaryAnchor(TypeElement typeElement, Content inheritedTree) {

   236     }

   237 

   238     /**

   239      * {@inheritDoc}

   240      */

   241     @Override

   242     public void addInheritedSummaryLabel(TypeElement typeElement, Content inheritedTree) {

   243     }

   244 

   245     /**

   246      * {@inheritDoc}

   247      */

   248     @Override

   249     protected void addSummaryLink(LinkInfoImpl.Kind context, TypeElement typeElement, Element member,

   250             Content tdSummary) {

   251         Content memberLink = HtmlTree.SPAN(HtmlStyle.memberNameLink,

   252                 writer.getDocLink(context, member, name(member), false));

   253         Content code = HtmlTree.CODE(memberLink);

   254         tdSummary.addContent(code);

   255     }

   256 

   257     /**

   258      * {@inheritDoc}

   259      */

   260     @Override

   261     public void setSummaryColumnStyleAndScope(HtmlTree thTree) {

   262         thTree.addStyle(HtmlStyle.colFirst);

   263         thTree.addAttr(HtmlAttr.SCOPE, "row");

   264     }

   265 

   266     /**

   267      * {@inheritDoc}

   268      */

   269     @Override

   270     protected void addInheritedSummaryLink(TypeElement typeElement, Element member, Content linksTree) {

   271     }

   272 

   273     /**

   274      * {@inheritDoc}

   275      */

   276     @Override

   277     protected void addSummaryType(Element member, Content tdSummaryType) {

   278         //Not applicable.

   279     }

   280 

   281     /**

   282      * {@inheritDoc}

   283      */

   284     @Override

   285     protected Content getDeprecatedLink(Element member) {

   286         String name = utils.getFullyQualifiedName(member) + "." + member.getSimpleName();

   287         return writer.getDocLink(LinkInfoImpl.Kind.MEMBER, member, name);

   288     }

   289 

   290     /**

   291      * {@inheritDoc}

   292      */

   293     @Override

   294     protected Content getNavSummaryLink(TypeElement typeElement, boolean link) {

   295         if (link) {

   296             if (typeElement == null) {

   297                 return writer.getHyperLink(SectionName.ENUM_CONSTANT_SUMMARY,

   298                         contents.navEnum);

   299             } else {

   300                 return writer.getHyperLink(

   301                         SectionName.ENUM_CONSTANTS_INHERITANCE,

   302                         configuration.getClassName(typeElement), contents.navEnum);

   303             }

   304         } else {

   305             return contents.navEnum;

   306         }

   307     }

   308 

   309     /**

   310      * {@inheritDoc}

   311      */

   312     @Override

   313     protected void addNavDetailLink(boolean link, Content liNav) {

   314         if (link) {

   315             liNav.addContent(writer.getHyperLink(

   316                     SectionName.ENUM_CONSTANT_DETAIL,

   317                     contents.navEnum));

   318         } else {

   319             liNav.addContent(contents.navEnum);

   320         }

   321     }

   322 }