archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-28 15:24:43 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

6851834: Javadoc doclet needs a structured approach to generate the output HTML

Browse source 
Reviewed-by: jjg
This commit is contained in:
Bhavesh Patel 2010-12-01 11:02:38 -08:00
parent 6edf2ff9a3
commit 275e77646d
148 changed files with 12175 additions and 7441 deletions
Download patch file Download diff file Expand all files Collapse all files

179
langtools/src/share/classes/com/sun/tools/doclets/formats/html/AbstractExecutableMemberWriter.java
View file

@ -26,12 +26,16 @@
package com.sun.tools.doclets.formats.html;
import com.sun.javadoc.*;
import com.sun.tools.doclets.formats.html.markup.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
/**
* Print method and constructor info.
*
* @author Robert Field
* @author Atul M Dambalkar
* @author Bhavesh Patel (Modified)
*/
public abstract class AbstractExecutableMemberWriter extends AbstractMemberWriter {
@ -45,82 +49,111 @@ public abstract class AbstractExecutableMemberWriter extends AbstractMemberWrite
}
/**
* Write the type parameters for the executable member.
* Add the type parameters for the executable member.
*
* @param member the member to write type parameters for.
* @param htmltree the content tree to which the parameters will be added.
* @return the display length required to write this information.
*/
protected int writeTypeParameters(ExecutableMemberDoc member) {
protected int addTypeParameters(ExecutableMemberDoc member, Content htmltree) {
LinkInfoImpl linkInfo = new LinkInfoImpl(
LinkInfoImpl.CONTEXT_MEMBER_TYPE_PARAMS, member, false);
String typeParameters = writer.getTypeParameterLinks(linkInfo);
if (linkInfo.displayLength > 0) {
writer.print(typeParameters + " ");
Content linkContent = new RawHtml(typeParameters);
htmltree.addContent(linkContent);
htmltree.addContent(writer.getSpace());
writer.displayLength += linkInfo.displayLength + 1;
}
return linkInfo.displayLength;
}
protected void writeSignature(ExecutableMemberDoc member) {
writer.displayLength = 0;
writer.pre();
writer.writeAnnotationInfo(member);
printModifiers(member);
writeTypeParameters(member);
if (configuration().linksource &&
member.position().line() != classdoc.position().line()) {
writer.printSrcLink(member, member.name());
} else {
strong(member.name());
}
writeParameters(member);
writeExceptions(member);
writer.preEnd();
}
protected void writeDeprecatedLink(ProgramElementDoc member) {
/**
* {@inheritDoc}
*/
protected Content getDeprecatedLink(ProgramElementDoc member) {
ExecutableMemberDoc emd = (ExecutableMemberDoc)member;
writer.printDocLink(LinkInfoImpl.CONTEXT_MEMBER, (MemberDoc) emd,
emd.qualifiedName() + emd.flatSignature(), false);
return writer.getDocLink(LinkInfoImpl.CONTEXT_MEMBER, (MemberDoc) emd,
emd.qualifiedName() + emd.flatSignature());
}
protected void writeSummaryLink(int context, ClassDoc cd, ProgramElementDoc member) {
/**
* Add the summary link for the member.
*
* @param context the id of the context where the link will be printed
* @param classDoc the classDoc that we should link to
* @param member the member being linked to
* @param tdSummary the content tree to which the link will be added
*/
protected void addSummaryLink(int context, ClassDoc cd, ProgramElementDoc member,
Content tdSummary) {
ExecutableMemberDoc emd = (ExecutableMemberDoc)member;
String name = emd.name();
writer.strong();
writer.printDocLink(context, cd, (MemberDoc) emd,
name, false);
writer.strongEnd();
Content strong = HtmlTree.STRONG(new RawHtml(
writer.getDocLink(context, cd, (MemberDoc) emd,
name, false)));
Content code = HtmlTree.CODE(strong);
writer.displayLength = name.length();
writeParameters(emd, false);
addParameters(emd, false, code);
tdSummary.addContent(code);
}
protected void writeInheritedSummaryLink(ClassDoc cd,
ProgramElementDoc member) {
writer.printDocLink(LinkInfoImpl.CONTEXT_MEMBER, cd, (MemberDoc) member,
member.name(), false);
/**
* Add the inherited summary link for the member.
*
* @param classDoc the classDoc that we should link to
* @param member the member being linked to
* @param linksTree the content tree to which the link will be added
*/
protected void addInheritedSummaryLink(ClassDoc cd,
ProgramElementDoc member, Content linksTree) {
linksTree.addContent(new RawHtml(
writer.getDocLink(LinkInfoImpl.CONTEXT_MEMBER, cd, (MemberDoc) member,
member.name(), false)));
}
protected void writeParam(ExecutableMemberDoc member, Parameter param,
boolean isVarArg) {
/**
* Add the parameter for the executable member.
*
* @param member the member to write parameter for.
* @param param the parameter that needs to be written.
* @param isVarArg true if this is a link to var arg.
* @param tree the content tree to which the parameter information will be added.
*/
protected void addParam(ExecutableMemberDoc member, Parameter param,
boolean isVarArg, Content tree) {
if (param.type() != null) {
writer.printLink(new LinkInfoImpl(
Content link = new RawHtml(writer.getLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_EXECUTABLE_MEMBER_PARAM, param.type(),
isVarArg));
isVarArg)));
tree.addContent(link);
}
if(param.name().length() > 0) {
writer.space();
writer.print(param.name());
tree.addContent(writer.getSpace());
tree.addContent(param.name());
}
}
protected void writeParameters(ExecutableMemberDoc member) {
writeParameters(member, true);
/**
* Add all the parameters for the executable member.
*
* @param member the member to write parameters for.
* @param tree the content tree to which the parameters information will be added.
*/
protected void addParameters(ExecutableMemberDoc member, Content htmltree) {
addParameters(member, true, htmltree);
}
protected void writeParameters(ExecutableMemberDoc member,
boolean includeAnnotations) {
print('(');
/**
* Add all the parameters for the executable member.
*
* @param member the member to write parameters for.
* @param includeAnnotations true if annotation information needs to be added.
* @param tree the content tree to which the parameters information will be added.
*/
protected void addParameters(ExecutableMemberDoc member,
boolean includeAnnotations, Content htmltree) {
htmltree.addContent("(");
Parameter[] params = member.parameters();
String indent = makeSpace(writer.displayLength);
if (configuration().linksource) {
@ -133,36 +166,45 @@ public abstract class AbstractExecutableMemberWriter extends AbstractMemberWrite
if (!param.name().startsWith("this$")) {
if (includeAnnotations) {
boolean foundAnnotations =
writer.writeAnnotationInfo(indent.length(), member, param);
writer.addAnnotationInfo(indent.length(),
member, param, htmltree);
if (foundAnnotations) {
writer.println();
writer.print(indent);
htmltree.addContent(DocletConstants.NL);
htmltree.addContent(indent);
}
}
writeParam(member, param,
(paramstart == params.length - 1) && member.isVarArgs());
addParam(member, param,
(paramstart == params.length - 1) && member.isVarArgs(), htmltree);
break;
}
}
for (int i = paramstart + 1; i < params.length; i++) {
writer.print(',');
writer.println();
writer.print(indent);
htmltree.addContent(",");
htmltree.addContent(DocletConstants.NL);
htmltree.addContent(indent);
if (includeAnnotations) {
boolean foundAnnotations =
writer.writeAnnotationInfo(indent.length(), member, params[i]);
writer.addAnnotationInfo(indent.length(), member, params[i],
htmltree);
if (foundAnnotations) {
writer.println();
writer.print(indent);
htmltree.addContent(DocletConstants.NL);
htmltree.addContent(indent);
}
}
writeParam(member, params[i], (i == params.length - 1) && member.isVarArgs());
addParam(member, params[i], (i == params.length - 1) && member.isVarArgs(),
htmltree);
}
writer.print(')');
htmltree.addContent(")");
}
protected void writeExceptions(ExecutableMemberDoc member) {
/**
* Add exceptions for the executable member.
*
* @param member the member to write exceptions for.
* @param htmltree the content tree to which the exceptions information will be added.
*/
protected void addExceptions(ExecutableMemberDoc member, Content htmltree) {
Type[] exceptions = member.thrownExceptionTypes();
if(exceptions.length > 0) {
LinkInfoImpl memberTypeParam = new LinkInfoImpl(
@ -173,17 +215,20 @@ public abstract class AbstractExecutableMemberWriter extends AbstractMemberWrite
0 : memberTypeParam.displayLength + 1;
String indent = makeSpace(modifierString(member).length() +
member.name().length() + retlen - 4);
writer.println();
writer.print(indent);
writer.print("throws ");
htmltree.addContent(DocletConstants.NL);
htmltree.addContent(indent);
htmltree.addContent("throws ");
indent += " ";
writer.printLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_MEMBER, exceptions[0]));
Content link = new RawHtml(writer.getLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_MEMBER, exceptions[0])));
htmltree.addContent(link);
for(int i = 1; i < exceptions.length; i++) {
writer.println(",");
writer.print(indent);
writer.printLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_MEMBER, exceptions[i]));
htmltree.addContent(",");
htmltree.addContent(DocletConstants.NL);
htmltree.addContent(indent);
Content exceptionLink = new RawHtml(writer.getLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_MEMBER, exceptions[i])));
htmltree.addContent(exceptionLink);
}
}
}

187
langtools/src/share/classes/com/sun/tools/doclets/formats/html/AbstractIndexWriter.java
View file

@ -30,6 +30,8 @@ import java.util.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.formats.html.markup.*;
import com.sun.tools.doclets.internal.toolkit.*;
/**
* Generate Index for all the Member Names with Indexing in
@ -39,6 +41,7 @@ import com.sun.tools.doclets.internal.toolkit.util.*;
*
* @see IndexBuilder
* @author Atul M Dambalkar
* @author Bhavesh Patel (Modified)
*/
public class AbstractIndexWriter extends HtmlDocletWriter {
@ -78,175 +81,187 @@ public class AbstractIndexWriter extends HtmlDocletWriter {
}
/**
* Print the text "Index" in strong format in the navigation bar.
* Get the index label for navigation bar.
*
* @return a content tree for the tree label
*/
protected void navLinkIndex() {
navCellRevStart();
fontStyle("NavBarFont1Rev");
strongText("doclet.Index");
fontEnd();
navCellEnd();
protected Content getNavLinkIndex() {
Content li = HtmlTree.LI(HtmlStyle.navBarCell1Rev, indexLabel);
return li;
}
/**
* Generate the member information for the unicode character along with the
* Add the member information for the unicode character along with the
* list of the members.
*
* @param unicode Unicode for which member list information to be generated.
* @param memberlist List of members for the unicode character.
* @param unicode Unicode for which member list information to be generated
* @param memberlist List of members for the unicode character
* @param contentTree the content tree to which the information will be added
*/
protected void generateContents(Character unicode, List<? extends Doc> memberlist) {
anchor("_" + unicode + "_");
h2();
strong(unicode.toString());
h2End();
protected void addContents(Character unicode, List<? extends Doc> memberlist,
Content contentTree) {
contentTree.addContent(getMarkerAnchor("_" + unicode + "_"));
Content headContent = new StringContent(unicode.toString());
Content heading = HtmlTree.HEADING(HtmlConstants.CONTENT_HEADING, false,
HtmlStyle.title, headContent);
contentTree.addContent(heading);
int memberListSize = memberlist.size();
// Display the list only if there are elements to be displayed.
if (memberListSize > 0) {
dl();
Content dl = new HtmlTree(HtmlTag.DL);
for (int i = 0; i < memberListSize; i++) {
Doc element = memberlist.get(i);
if (element instanceof MemberDoc) {
printDescription((MemberDoc)element);
addDescription((MemberDoc)element, dl);
} else if (element instanceof ClassDoc) {
printDescription((ClassDoc)element);
addDescription((ClassDoc)element, dl);
} else if (element instanceof PackageDoc) {
printDescription((PackageDoc)element);
addDescription((PackageDoc)element, dl);
}
}
dlEnd();
contentTree.addContent(dl);
}
hr();
}
/**
* Print one line summary comment for the package.
* Add one line summary comment for the package.
*
* @param pkg PackageDoc passed.
* @param pkg the package to be documented
* @param dlTree the content tree to which the description will be added
*/
protected void printDescription(PackageDoc pkg) {
dt();
printPackageLink(pkg, Util.getPackageName(pkg), true);
print(" - ");
print(configuration.getText("doclet.package") + " " + pkg.name());
dtEnd();
dd();
printSummaryComment(pkg);
ddEnd();
protected void addDescription(PackageDoc pkg, Content dlTree) {
Content link = getPackageLink(pkg, new StringContent(Util.getPackageName(pkg)));
Content dt = HtmlTree.DT(link);
dt.addContent(" - ");
dt.addContent(getResource("doclet.package"));
dt.addContent(" " + pkg.name());
dlTree.addContent(dt);
Content dd = new HtmlTree(HtmlTag.DD);
addSummaryComment(pkg, dd);
dlTree.addContent(dd);
}
/**
* Print one line summary comment for the class.
* Add one line summary comment for the class.
*
* @param cd ClassDoc passed.
* @param cd the class being documented
* @param dlTree the content tree to which the description will be added
*/
protected void printDescription(ClassDoc cd) {
dt();
printLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_INDEX, cd, true));
print(" - ");
printClassInfo(cd);
dtEnd();
dd();
printComment(cd);
ddEnd();
protected void addDescription(ClassDoc cd, Content dlTree) {
Content link = new RawHtml(
getLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_INDEX, cd, true)));
Content dt = HtmlTree.DT(link);
dt.addContent(" - ");
addClassInfo(cd, dt);
dlTree.addContent(dt);
Content dd = new HtmlTree(HtmlTag.DD);
addComment(cd, dd);
dlTree.addContent(dd);
}
/**
* Print the classkind(class, interface, exception, error of the class
* Add the classkind(class, interface, exception, error of the class
* passed.
*
* @param cd ClassDoc.
* @param cd the class being documented
* @param contentTree the content tree to which the class info will be added
*/
protected void printClassInfo(ClassDoc cd) {
print(configuration.getText("doclet.in",
protected void addClassInfo(ClassDoc cd, Content contentTree) {
contentTree.addContent(getResource("doclet.in",
Util.getTypeName(configuration, cd, false),
getPackageLink(cd.containingPackage(),
getPackageLinkString(cd.containingPackage(),
Util.getPackageName(cd.containingPackage()), false)));
}
/**
* Generate Description for Class, Field, Method or Constructor.
* for Java.* Packages Class Members.
* Add description for Class, Field, Method or Constructor.
*
* @param member MemberDoc for the member of the Class Kind.
* @see com.sun.javadoc.MemberDoc
* @param member MemberDoc for the member of the Class Kind
* @param dlTree the content tree to which the description will be added
*/
protected void printDescription(MemberDoc member) {
protected void addDescription(MemberDoc member, Content dlTree) {
String name = (member instanceof ExecutableMemberDoc)?
member.name() + ((ExecutableMemberDoc)member).flatSignature() :
member.name();
if (name.indexOf("<") != -1 || name.indexOf(">") != -1) {
name = Util.escapeHtmlChars(name);
}
ClassDoc containing = member.containingClass();
dt();
printDocLink(LinkInfoImpl.CONTEXT_INDEX, member, name, true);
println(" - ");
printMemberDesc(member);
println();
dtEnd();
dd();
printComment(member);
ddEnd();
println();
Content span = HtmlTree.SPAN(HtmlStyle.strong,
getDocLink(LinkInfoImpl.CONTEXT_INDEX, member, name));
Content dt = HtmlTree.DT(span);
dt.addContent(" - ");
addMemberDesc(member, dt);
dlTree.addContent(dt);
Content dd = new HtmlTree(HtmlTag.DD);
addComment(member, dd);
dlTree.addContent(dd);
}
/**
* Print comment for each element in the index. If the element is deprecated
* Add comment for each element in the index. If the element is deprecated
* and it has a @deprecated tag, use that comment. Else if the containing
* class for this element is deprecated, then add the word "Deprecated." at
* the start and then print the normal comment.
*
* @param element Index element.
* @param element Index element
* @param contentTree the content tree to which the comment will be added
*/
protected void printComment(ProgramElementDoc element) {
protected void addComment(ProgramElementDoc element, Content contentTree) {
Tag[] tags;
Content span = HtmlTree.SPAN(HtmlStyle.strong, deprecatedPhrase);
HtmlTree div = new HtmlTree(HtmlTag.DIV);
div.addStyle(HtmlStyle.block);
if (Util.isDeprecated(element)) {
strongText("doclet.Deprecated"); space();
div.addContent(span);
if ((tags = element.tags("deprecated")).length > 0)
printInlineDeprecatedComment(element, tags[0]);
addInlineDeprecatedComment(element, tags[0], div);
contentTree.addContent(div);
} else {
ClassDoc cont = element.containingClass();
while (cont != null) {
if (Util.isDeprecated(cont)) {
strongText("doclet.Deprecated"); space();
div.addContent(span);
contentTree.addContent(div);
break;
}
cont = cont.containingClass();
}
printSummaryComment(element);
addSummaryComment(element, contentTree);
}
}
/**
* Print description about the Static Varible/Method/Constructor for a
* Add description about the Static Varible/Method/Constructor for a
* member.
*
* @param member MemberDoc for the member within the Class Kind.
* @see com.sun.javadoc.MemberDoc
* @param member MemberDoc for the member within the Class Kind
* @param contentTree the content tree to which the member description will be added
*/
protected void printMemberDesc(MemberDoc member) {
protected void addMemberDesc(MemberDoc member, Content contentTree) {
ClassDoc containing = member.containingClass();
String classdesc = Util.getTypeName(configuration, containing, true) + " " +
getPreQualifiedClassLink(LinkInfoImpl.CONTEXT_INDEX, containing,
false);
String classdesc = Util.getTypeName(
configuration, containing, true) + " ";
if (member.isField()) {
if (member.isStatic()) {
printText("doclet.Static_variable_in", classdesc);
contentTree.addContent(
getResource("doclet.Static_variable_in", classdesc));
} else {
printText("doclet.Variable_in", classdesc);
contentTree.addContent(
getResource("doclet.Variable_in", classdesc));
}
} else if (member.isConstructor()) {
printText("doclet.Constructor_for", classdesc);
contentTree.addContent(
getResource("doclet.Constructor_for", classdesc));
} else if (member.isMethod()) {
if (member.isStatic()) {
printText("doclet.Static_method_in", classdesc);
contentTree.addContent(
getResource("doclet.Static_method_in", classdesc));
} else {
printText("doclet.Method_in", classdesc);
contentTree.addContent(
getResource("doclet.Method_in", classdesc));
}
}
addPreQualifiedClassLink(LinkInfoImpl.CONTEXT_INDEX, containing,
false, contentTree);
}
}

581
langtools/src/share/classes/com/sun/tools/doclets/formats/html/AbstractMemberWriter.java
View file

@ -25,10 +25,11 @@
package com.sun.tools.doclets.formats.html;
import java.lang.reflect.Modifier;
import java.util.*;
import java.lang.reflect.Modifier;
import com.sun.javadoc.*;
import com.sun.tools.doclets.formats.html.markup.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.taglets.*;
@ -60,36 +61,125 @@ public abstract class AbstractMemberWriter {
/*** abstracts ***/
public abstract void printSummaryLabel();
/**
* Add the summary label for the member.
*
* @param memberTree the content tree to which the label will be added
*/
public abstract void addSummaryLabel(Content memberTree);
public abstract void printTableSummary();
/**
* Get the summary for the member summary table.
*
* @return a string for the table summary
*/
public abstract String getTableSummary();
public abstract void printSummaryTableHeader(ProgramElementDoc member);
/**
* Get the caption for the member summary table.
*
* @return a string for the table caption
*/
public abstract String getCaption();
public abstract void printInheritedSummaryLabel(ClassDoc cd);
/**
* Get the summary table header for the member.
*
* @param member the member to be documented
* @return the summary table header
*/
public abstract String[] getSummaryTableHeader(ProgramElementDoc member);
public abstract void printSummaryAnchor(ClassDoc cd);
/**
* Add inherited summary lable for the member.
*
* @param cd the class doc to which to link to
* @param inheritedTree the content tree to which the inherited summary label will be added
*/
public abstract void addInheritedSummaryLabel(ClassDoc cd, Content inheritedTree);
public abstract void printInheritedSummaryAnchor(ClassDoc cd);
/**
* Add the anchor for the summary section of the member.
*
* @param cd the class doc to be documented
* @param memberTree the content tree to which the summary anchor will be added
*/
public abstract void addSummaryAnchor(ClassDoc cd, Content memberTree);
protected abstract void printSummaryType(ProgramElementDoc member);
/**
* Add the anchor for the inherited summary section of the member.
*
* @param cd the class doc to be documented
* @param inheritedTree the content tree to which the inherited summary anchor will be added
*/
public abstract void addInheritedSummaryAnchor(ClassDoc cd, Content inheritedTree);
protected void writeSummaryLink(ClassDoc cd, ProgramElementDoc member) {
writeSummaryLink(LinkInfoImpl.CONTEXT_MEMBER, cd, member);
/**
* Add the summary type for the member.
*
* @param member the member to be documented
* @param tdSummaryType the content tree to which the type will be added
*/
protected abstract void addSummaryType(ProgramElementDoc member,
Content tdSummaryType);
/**
* Add the summary link for the member.
*
* @param cd the class doc to be documented
* @param member the member to be documented
* @param tdSummary the content tree to which the link will be added
*/
protected void addSummaryLink(ClassDoc cd, ProgramElementDoc member,
Content tdSummary) {
addSummaryLink(LinkInfoImpl.CONTEXT_MEMBER, cd, member, tdSummary);
}
protected abstract void writeSummaryLink(int context,
ClassDoc cd,
ProgramElementDoc member);
/**
* Add the summary link for the member.
*
* @param context the id of the context where the link will be printed
* @param cd the class doc to be documented
* @param member the member to be documented
* @param tdSummary the content tree to which the summary link will be added
*/
protected abstract void addSummaryLink(int context,
ClassDoc cd, ProgramElementDoc member, Content tdSummary);
protected abstract void writeInheritedSummaryLink(ClassDoc cd,
ProgramElementDoc member);
/**
* Add the inherited summary link for the member.
*
* @param cd the class doc to be documented
* @param member the member to be documented
* @param linksTree the content tree to which the inherited summary link will be added
*/
protected abstract void addInheritedSummaryLink(ClassDoc cd,
ProgramElementDoc member, Content linksTree);
protected abstract void writeDeprecatedLink(ProgramElementDoc member);
/**
* Get the deprecated link.
*
* @param member the member being linked to
* @return a content tree representing the link
*/
protected abstract Content getDeprecatedLink(ProgramElementDoc member);
protected abstract void printNavSummaryLink(ClassDoc cd, boolean link);
/**
* Get the navigation summary link.
*
* @param cd the class doc to be documented
* @param link true if its a link else the label to be printed
* @return a content tree for the navigation summary link.
*/
protected abstract Content getNavSummaryLink(ClassDoc cd, boolean link);
protected abstract void printNavDetailLink(boolean link);
/**
* Add the navigation detail link.
*
* @param link true if its a link else the label to be printed
* @param liNav the content tree to which the navigation detail link will be added
*/
protected abstract void addNavDetailLink(boolean link, Content liNav);
/*** ***/
@ -108,6 +198,17 @@ public abstract class AbstractMemberWriter {
writer.displayLength += str.length();
}
/**
* Add the member name to the content tree and modifies the display length.
*
* @param name the member name to be added to the content tree.
* @param htmltree the content tree to which the name will be added.
*/
protected void addName(String name, Content htmltree) {
htmltree.addContent(name);
writer.displayLength += name.length();
}
/**
* Return a string describing the access modifier flags.
* Don't include native or synchronized.
@ -131,7 +232,13 @@ public abstract class AbstractMemberWriter {
return type;
}
protected void printModifiers(MemberDoc member) {
/**
* Add the modifier for the member.
*
* @param member the member for which teh modifier will be added.
* @param htmltree the content tree to which the modifier information will be added.
*/
protected void addModifiers(MemberDoc member, Content htmltree) {
String mod = modifierString(member);
// According to JLS, we should not be showing public modifier for
// interface methods.
@ -141,8 +248,8 @@ public abstract class AbstractMemberWriter {
mod = Util.replaceText(mod, "public", "").trim();
}
if(mod.length() > 0) {
print(mod);
print(' ');
htmltree.addContent(mod);
htmltree.addContent(writer.getSpace());
}
}
@ -158,66 +265,43 @@ public abstract class AbstractMemberWriter {
}
/**
* Print 'static' if static and type link.
*/
protected void printStaticAndType(boolean isStatic, Type type) {
writer.printTypeSummaryHeader();
if (isStatic) {
print("static");
}
writer.space();
if (type != null) {
writer.printLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_MEMBER,
type));
}
writer.printTypeSummaryFooter();
}
/**
* Print the modifier and type for the member in the member summary.
* Add the modifier and type for the member in the member summary.
*
* @param member the member to print the type for.
* @param type the type to print.
* @param member the member to add the type for
* @param type the type to add
* @param tdSummaryType the content tree to which the modified and type will be added
*/
protected void printModifierAndType(ProgramElementDoc member, Type type) {
writer.printTypeSummaryHeader();
printModifier(member);
protected void addModifierAndType(ProgramElementDoc member, Type type,
Content tdSummaryType) {
HtmlTree code = new HtmlTree(HtmlTag.CODE);
addModifier(member, code);
if (type == null) {
writer.space();
if (member.isClass()) {
print("class");
code.addContent("class");
} else {
print("interface");
code.addContent("interface");
}
code.addContent(writer.getSpace());
} else {
if (member instanceof ExecutableMemberDoc &&
((ExecutableMemberDoc) member).typeParameters().length > 0) {
//Code to avoid ugly wrapping in member summary table.
writer.table(0,0,0);
writer.trAlignVAlign("right", "");
writer.tdNowrap();
writer.font("-1");
writer.code();
int displayLength = ((AbstractExecutableMemberWriter) this).
writeTypeParameters((ExecutableMemberDoc) member);
int displayLength = ((AbstractExecutableMemberWriter) this).addTypeParameters(
(ExecutableMemberDoc) member, code);
if (displayLength > 10) {
writer.br();
code.addContent(new HtmlTree(HtmlTag.BR));
}
writer.printLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_SUMMARY_RETURN_TYPE, type));
writer.codeEnd();
writer.fontEnd();
writer.tdEnd();
writer.trEnd();
writer.tableEnd();
code.addContent(new RawHtml(
writer.getLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_SUMMARY_RETURN_TYPE, type))));
} else {
writer.space();
writer.printLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_SUMMARY_RETURN_TYPE, type));
code.addContent(new RawHtml(
writer.getLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_SUMMARY_RETURN_TYPE, type))));
}
}
writer.printTypeSummaryFooter();
tdSummaryType.addContent(code);
}
private void printModifier(ProgramElementDoc member) {
@ -238,25 +322,53 @@ public abstract class AbstractMemberWriter {
}
/**
* Print the deprecated output for the given member.
* Add the modifier for the member.
*
* @param member the member being documented.
* @param member the member to add the type for
* @param code the content tree to which the modified will be added
*/
protected void printDeprecated(ProgramElementDoc member) {
String output = (new DeprecatedTaglet()).getTagletOutput(member,
writer.getTagletWriterInstance(false)).toString().trim();
if (!output.isEmpty()) {
writer.printMemberDetailsListStartTag();
writer.print(output);
private void addModifier(ProgramElementDoc member, Content code) {
if (member.isProtected()) {
code.addContent("protected ");
} else if (member.isPrivate()) {
code.addContent("private ");
} else if (!member.isPublic()) { // Package private
code.addContent(configuration().getText("doclet.Package_private"));
code.addContent(" ");
}
if (member.isMethod() && ((MethodDoc)member).isAbstract()) {
code.addContent("abstract ");
}
if (member.isStatic()) {
code.addContent("static ");
}
}
protected void printComment(ProgramElementDoc member) {
/**
* Add the deprecated information for the given member.
*
* @param member the member being documented.
* @param contentTree the content tree to which the deprecated information will be added.
*/
protected void addDeprecatedInfo(ProgramElementDoc member, Content contentTree) {
String output = (new DeprecatedTaglet()).getTagletOutput(member,
writer.getTagletWriterInstance(false)).toString().trim();
if (!output.isEmpty()) {
Content deprecatedContent = new RawHtml(output);
Content div = HtmlTree.DIV(HtmlStyle.block, deprecatedContent);
contentTree.addContent(div);
}
}
/**
* Add the comment for the given member.
*
* @param member the member being documented.
* @param contentTree the content tree to which the comment will be added.
*/
protected void addComment(ProgramElementDoc member, Content htmltree) {
if (member.inlineTags().length > 0) {
writer.printMemberDetailsListStartTag();
writer.dd();
writer.printInlineComment(member);
writer.ddEnd();
writer.addInlineComment(member, htmltree);
}
}
@ -264,64 +376,16 @@ public abstract class AbstractMemberWriter {
return member.name();
}
protected void printHead(MemberDoc member) {
writer.h3();
writer.print(member.name());
writer.h3End();
}
protected void printFullComment(ProgramElementDoc member) {
if(configuration().nocomment){
return;
}
writer.dl();
print(((TagletOutputImpl)
(new DeprecatedTaglet()).getTagletOutput(member,
writer.getTagletWriterInstance(false))).toString());
printCommentAndTags(member);
writer.dlEnd();
}
protected void printCommentAndTags(ProgramElementDoc member) {
printComment(member);
writer.printTags(member);
}
/**
* Write the member footer.
* Get the header for the section.
*
* @param member the member being documented.
* @return a header content for the section.
*/
protected void printMemberFooter() {
writer.printMemberDetailsListEndTag();
assert !writer.getMemberDetailsListPrinted();
}
/**
* Forward to containing writer
*/
public void printSummaryHeader(ClassDoc cd) {
printedSummaryHeader = true;
writer.printSummaryHeader(this, cd);
}
/**
* Forward to containing writer
*/
public void printInheritedSummaryHeader(ClassDoc cd) {
writer.printInheritedSummaryHeader(this, cd);
}
/**
* Forward to containing writer
*/
public void printInheritedSummaryFooter(ClassDoc cd) {
writer.printInheritedSummaryFooter(this, cd);
}
/**
* Forward to containing writer
*/
public void printSummaryFooter(ClassDoc cd) {
writer.printSummaryFooter(this, cd);
protected Content getHead(MemberDoc member) {
Content memberContent = new RawHtml(member.name());
Content heading = HtmlTree.HEADING(HtmlConstants.MEMBER_HEADING, memberContent);
return heading;
}
/**
@ -340,102 +404,134 @@ public abstract class AbstractMemberWriter {
return true;
}
/**
* Generate the code for listing the deprecated APIs. Create the table
* format for listing the API. Call methods from the sub-class to complete
* the generation.
* Add deprecated information to the documentation tree
*
* @param deprmembers list of deprecated members
* @param headingKey the caption for the deprecated members table
* @param tableSummary the summary for the deprecated members table
* @param tableHeader table headers for the deprecated members table
* @param contentTree the content tree to which the deprecated members table will be added
*/
protected void printDeprecatedAPI(List<Doc> deprmembers, String headingKey, String tableSummary, String[] tableHeader) {
protected void addDeprecatedAPI(List<Doc> deprmembers, String headingKey,
String tableSummary, String[] tableHeader, Content contentTree) {
if (deprmembers.size() > 0) {
writer.tableIndexSummary(tableSummary);
writer.tableCaptionStart();
writer.printText(headingKey);
writer.tableCaptionEnd();
writer.summaryTableHeader(tableHeader, "col");
Content table = HtmlTree.TABLE(0, 3, 0, tableSummary,
writer.getTableCaption(configuration().getText(headingKey)));
table.addContent(writer.getSummaryTableHeader(tableHeader, "col"));
Content tbody = new HtmlTree(HtmlTag.TBODY);
for (int i = 0; i < deprmembers.size(); i++) {
ProgramElementDoc member =(ProgramElementDoc)deprmembers.get(i);
writer.trBgcolorStyle("white", "TableRowColor");
writer.summaryRow(0);
writeDeprecatedLink(member);
writer.br();
writer.printNbsps();
HtmlTree td = HtmlTree.TD(HtmlStyle.colOne, getDeprecatedLink(member));
if (member.tags("deprecated").length > 0)
writer.printInlineDeprecatedComment(member, member.tags("deprecated")[0]);
writer.space();
writer.summaryRowEnd();
writer.trEnd();
writer.addInlineDeprecatedComment(member,
member.tags("deprecated")[0], td);
HtmlTree tr = HtmlTree.TR(td);
if (i%2 == 0)
tr.addStyle(HtmlStyle.altColor);
else
tr.addStyle(HtmlStyle.rowColor);
tbody.addContent(tr);
}
writer.tableEnd();
writer.space();
writer.p();
table.addContent(tbody);
Content li = HtmlTree.LI(HtmlStyle.blockList, table);
Content ul = HtmlTree.UL(HtmlStyle.blockList, li);
contentTree.addContent(ul);
}
}
/**
* Print use info.
* Add use information to the documentation tree.
*
* @param mems list of program elements for which the use information will be added
* @param heading the section heading
* @param tableSummary the summary for the use table
* @param contentTree the content tree to which the use information will be added
*/
protected void printUseInfo(List<? extends ProgramElementDoc> mems, String heading, String tableSummary) {
protected void addUseInfo(List<? extends ProgramElementDoc> mems,
String heading, String tableSummary, Content contentTree) {
if (mems == null) {
return;
}
List<? extends ProgramElementDoc> members = mems;
boolean printedUseTableHeader = false;
if (members.size() > 0) {
writer.tableIndexSummary(tableSummary);
writer.tableSubCaptionStart();
writer.print(heading);
writer.tableCaptionEnd();
for (Iterator<? extends ProgramElementDoc> it = members.iterator(); it.hasNext(); ) {
Content table = HtmlTree.TABLE(0, 3, 0, tableSummary,
writer.getTableCaption(heading));
Content tbody = new HtmlTree(HtmlTag.TBODY);
Iterator<? extends ProgramElementDoc> it = members.iterator();
for (int i = 0; it.hasNext(); i++) {
ProgramElementDoc pgmdoc = it.next();
ClassDoc cd = pgmdoc.containingClass();
if (!printedUseTableHeader) {
// Passing ProgramElementDoc helps decides printing
// interface or class header in case of nested classes.
this.printSummaryTableHeader(pgmdoc);
table.addContent(writer.getSummaryTableHeader(
this.getSummaryTableHeader(pgmdoc), "col"));
printedUseTableHeader = true;
}
writer.printSummaryLinkType(this, pgmdoc);
HtmlTree tr = new HtmlTree(HtmlTag.TR);
if (i % 2 == 0) {
tr.addStyle(HtmlStyle.altColor);
} else {
tr.addStyle(HtmlStyle.rowColor);
}
HtmlTree tdFirst = new HtmlTree(HtmlTag.TD);
tdFirst.addStyle(HtmlStyle.colFirst);
writer.addSummaryType(this, pgmdoc, tdFirst);
tr.addContent(tdFirst);
HtmlTree tdLast = new HtmlTree(HtmlTag.TD);
tdLast.addStyle(HtmlStyle.colLast);
if (cd != null && !(pgmdoc instanceof ConstructorDoc)
&& !(pgmdoc instanceof ClassDoc)) {
// Add class context
writer.strong(cd.name() + ".");
HtmlTree name = new HtmlTree(HtmlTag.SPAN);
name.addStyle(HtmlStyle.strong);
name.addContent(cd.name() + ".");
tdLast.addContent(name);
}
writeSummaryLink(
pgmdoc instanceof ClassDoc ?
addSummaryLink(pgmdoc instanceof ClassDoc ?
LinkInfoImpl.CONTEXT_CLASS_USE : LinkInfoImpl.CONTEXT_MEMBER,
cd, pgmdoc);
writer.printSummaryLinkComment(this, pgmdoc);
cd, pgmdoc, tdLast);
writer.addSummaryLinkComment(this, pgmdoc, tdLast);
tr.addContent(tdLast);
tbody.addContent(tr);
}
writer.tableEnd();
writer.space();
writer.p();
table.addContent(tbody);
contentTree.addContent(table);
}
}
protected void navDetailLink(List<?> members) {
printNavDetailLink(members.size() > 0? true: false);
/**
* Add the navigation detail link.
*
* @param members the members to be linked
* @param liNav the content tree to which the navigation detail link will be added
*/
protected void addNavDetailLink(List<?> members, Content liNav) {
addNavDetailLink(members.size() > 0 ? true : false, liNav);
}
protected void navSummaryLink(List<?> members,
VisibleMemberMap visibleMemberMap) {
/**
* 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
*/
protected void addNavSummaryLink(List<?> members,
VisibleMemberMap visibleMemberMap, Content liNav) {
if (members.size() > 0) {
printNavSummaryLink(null, true);
liNav.addContent(getNavSummaryLink(null, true));
return;
} else {
}
ClassDoc icd = classdoc.superclass();
while (icd != null) {
List<?> inhmembers = visibleMemberMap.getMembersFor(icd);
if (inhmembers.size() > 0) {
printNavSummaryLink(icd, true);
liNav.addContent(getNavSummaryLink(icd, true));
return;
}
icd = icd.superclass();
}
}
printNavSummaryLink(null, false);
liNav.addContent(getNavSummaryLink(null, false));
}
protected void serialWarning(SourcePosition pos, String key, String a1, String a2) {
@ -453,12 +549,109 @@ public abstract class AbstractMemberWriter {
}
/**
* {@inheritDoc}
* Add the member summary for the given class.
*
* @param classDoc the class that is being documented
* @param member the member being documented
* @param firstSentenceTags the first sentence tags to be added to the summary
* @param tableTree the content tree to which the documentation will be added
* @param counter the counter for determing style for the table row
*/
public void writeMemberSummary(ClassDoc classDoc, ProgramElementDoc member,
Tag[] firstSentenceTags, boolean isFirst, boolean isLast) {
writer.printSummaryLinkType(this, member);
writeSummaryLink(classDoc, member);
writer.printSummaryLinkComment(this, member, firstSentenceTags);
public void addMemberSummary(ClassDoc classDoc, ProgramElementDoc member,
Tag[] firstSentenceTags, Content tableTree, int counter) {
HtmlTree tdSummaryType = new HtmlTree(HtmlTag.TD);
tdSummaryType.addStyle(HtmlStyle.colFirst);
writer.addSummaryType(this, member, tdSummaryType);
HtmlTree tdSummary = new HtmlTree(HtmlTag.TD);
setSummaryColumnStyle(tdSummary);
addSummaryLink(classDoc, member, tdSummary);
writer.addSummaryLinkComment(this, member, firstSentenceTags, tdSummary);
HtmlTree tr = HtmlTree.TR(tdSummaryType);
tr.addContent(tdSummary);
if (counter%2 == 0)
tr.addStyle(HtmlStyle.altColor);
else
tr.addStyle(HtmlStyle.rowColor);
tableTree.addContent(tr);
}
/**
* Set the style for the summary column.
*
* @param tdTree the column for which the style will be set
*/
public void setSummaryColumnStyle(HtmlTree tdTree) {
tdTree.addStyle(HtmlStyle.colLast);
}
/**
* Add inherited member summary for the given class and member.
*
* @param classDoc the class the inherited member belongs to
* @param nestedClass the inherited member that is summarized
* @param isFirst true if this is the first member in the list
* @param isLast true if this is the last member in the list
* @param linksTree the content tree to which the summary will be added
*/
public void addInheritedMemberSummary(ClassDoc classDoc,
ProgramElementDoc nestedClass, boolean isFirst, boolean isLast,
Content linksTree) {
writer.addInheritedMemberSummary(this, classDoc, nestedClass, isFirst,
linksTree);
}
/**
* Get the inherited summary header for the given class.
*
* @param classDoc the class the inherited member belongs to
* @return a content tree for the inherited summary header
*/
public Content getInheritedSummaryHeader(ClassDoc classDoc) {
Content inheritedTree = writer.getMemberTreeHeader();
writer.addInheritedSummaryHeader(this, classDoc, inheritedTree);
return inheritedTree;
}
/**
* Get the inherited summary links tree.
*
* @return a content tree for the inherited summary links
*/
public Content getInheritedSummaryLinksTree() {
return new HtmlTree(HtmlTag.CODE);
}
/**
* Get the summary table tree for the given class.
*
* @param classDoc the class for which the summary table is generated
* @return a content tree for the summary table
*/
public Content getSummaryTableTree(ClassDoc classDoc) {
return writer.getSummaryTableTree(this, classDoc);
}
/**
* Get the member tree to be documented.
*
* @param memberTree the content tree of member to be documented
* @return a content tree that will be added to the class documentation
*/
public Content getMemberTree(Content memberTree) {
return writer.getMemberTree(memberTree);
}
/**
* Get the member tree to be documented.
*
* @param memberTree the content tree of member to be documented
* @param isLastContent true if the content to be added is the last content
* @return a content tree that will be added to the class documentation
*/
public Content getMemberTree(Content memberTree, boolean isLastContent) {
if (isLastContent)
return HtmlTree.UL(HtmlStyle.blockListLast, memberTree);
else
return HtmlTree.UL(HtmlStyle.blockList, memberTree);
}
}

144
langtools/src/share/classes/com/sun/tools/doclets/formats/html/AbstractPackageIndexWriter.java
View file

@ -25,9 +25,11 @@
package com.sun.tools.doclets.formats.html;
import com.sun.javadoc.*;
import java.io.*;
import java.util.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.formats.html.markup.*;
import com.sun.tools.doclets.internal.toolkit.*;
/**
* Abstract class to generate the overview files in
@ -56,105 +58,127 @@ public abstract class AbstractPackageIndexWriter extends HtmlDocletWriter {
packages = configuration.packages;
}
protected abstract void printNavigationBarHeader();
protected abstract void printNavigationBarFooter();
protected abstract void printOverviewHeader();
protected abstract void printIndexHeader(String text, String tableSummary);
protected abstract void printIndexRow(PackageDoc pkg);
protected abstract void printIndexFooter();
/**
* Adds the navigation bar header to the documentation tree.
*
* @param body the document tree to which the navigation bar header will be added
*/
protected abstract void addNavigationBarHeader(Content body);
/**
* Generate the contants in the package index file. Call appropriate
* Adds the navigation bar footer to the documentation tree.
*
* @param body the document tree to which the navigation bar footer will be added
*/
protected abstract void addNavigationBarFooter(Content body);
/**
* Adds the overview header to the documentation tree.
*
* @param body the document tree to which the overview header will be added
*/
protected abstract void addOverviewHeader(Content body);
/**
* Adds the packages list to the documentation tree.
*
* @param packages an array of packagedoc objects
* @param text caption for the table
* @param tableSummary summary for the table
* @param body the document tree to which the packages list will be added
*/
protected abstract void addPackagesList(PackageDoc[] packages, String text,
String tableSummary, Content body);
/**
* Generate and prints the contents in the package index file. Call appropriate
* methods from the sub-class in order to generate Frame or Non
* Frame format.
*
* @param title the title of the window.
* @param includeScript boolean set true if windowtitle script is to be included
*/
protected void generatePackageIndexFile(String title, boolean includeScript) throws IOException {
protected void buildPackageIndexFile(String title, boolean includeScript) throws IOException {
String windowOverview = configuration.getText(title);
printHtmlHeader(windowOverview,
configuration.metakeywords.getOverviewMetaKeywords(title,
configuration.doctitle),
includeScript);
printNavigationBarHeader();
printOverviewHeader();
generateIndex();
printOverview();
printNavigationBarFooter();
printBodyHtmlEnd();
Content body = getBody(includeScript, getWindowTitle(windowOverview));
addNavigationBarHeader(body);
addOverviewHeader(body);
addIndex(body);
addOverview(body);
addNavigationBarFooter(body);
printHtmlDocument(configuration.metakeywords.getOverviewMetaKeywords(title,
configuration.doctitle), includeScript, body);
}
/**
* Default to no overview, overwrite to add overview.
* Default to no overview, override to add overview.
*
* @param body the document tree to which the overview will be added
*/
protected void printOverview() throws IOException {
protected void addOverview(Content body) throws IOException {
}
/**
* Generate the frame or non-frame package index.
* Adds the frame or non-frame package index to the documentation tree.
*
* @param body the document tree to which the index will be added
*/
protected void generateIndex() {
printIndexContents(packages, "doclet.Package_Summary",
protected void addIndex(Content body) {
addIndexContents(packages, "doclet.Package_Summary",
configuration.getText("doclet.Member_Table_Summary",
configuration.getText("doclet.Package_Summary"),
configuration.getText("doclet.packages")));
configuration.getText("doclet.packages")), body);
}
/**
* Generate code for package index contents. Call appropriate methods from
* the sub-classes.
* Adds package index contents. Call appropriate methods from
* the sub-classes. Adds it to the body HtmlTree
*
* @param packages Array of packages to be documented.
* @param text String which will be used as the heading.
* @param packages array of packages to be documented
* @param text string which will be used as the heading
* @param tableSummary summary for the table
* @param body the document tree to which the index contents will be added
*/
protected void printIndexContents(PackageDoc[] packages, String text, String tableSummary) {
protected void addIndexContents(PackageDoc[] packages, String text,
String tableSummary, Content body) {
if (packages.length > 0) {
Arrays.sort(packages);
printIndexHeader(text, tableSummary);
printAllClassesPackagesLink();
for(int i = 0; i < packages.length; i++) {
if (packages[i] != null) {
printIndexRow(packages[i]);
}
}
printIndexFooter();
addAllClassesLink(body);
addPackagesList(packages, text, tableSummary, body);
}
}
/**
* Print the doctitle, if it is specified on the command line.
* Adds the doctitle to the documentation tree, if it is specified on the command line.
*
* @param body the document tree to which the title will be added
*/
protected void printConfigurationTitle() {
protected void addConfigurationTitle(Content body) {
if (configuration.doctitle.length() > 0) {
center();
h1(configuration.doctitle);
centerEnd();
Content title = new RawHtml(configuration.doctitle);
Content heading = HtmlTree.HEADING(HtmlConstants.TITLE_HEADING,
HtmlStyle.title, title);
Content div = HtmlTree.DIV(HtmlStyle.header, heading);
body.addContent(div);
}
}
/**
* Highlight "Overview" in the strong format, in the navigation bar as this
* is the overview page.
* Returns highlighted "Overview", in the navigation bar as this is the
* overview page.
*
* @return a Content object to be added to the documentation tree
*/
protected void navLinkContents() {
navCellRevStart();
fontStyle("NavBarFont1Rev");
strongText("doclet.Overview");
fontEnd();
navCellEnd();
protected Content getNavLinkContents() {
Content li = HtmlTree.LI(HtmlStyle.navBarCell1Rev, overviewLabel);
return li;
}
/**
* Do nothing. This will be overridden in PackageIndexFrameWriter.
*
* @param body the document tree to which the all classes link will be added
*/
protected void printAllClassesPackagesLink() {
protected void addAllClassesLink(Content body) {
}
}

120
langtools/src/share/classes/com/sun/tools/doclets/formats/html/AbstractTreeWriter.java
View file

@ -25,11 +25,12 @@
package com.sun.tools.doclets.formats.html;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.javadoc.*;
import java.io.*;
import java.util.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.formats.html.markup.*;
import com.sun.javadoc.*;
/**
* Abstract class to print the class hierarchy page for all the Classes. This
@ -46,6 +47,8 @@ public abstract class AbstractTreeWriter extends HtmlDocletWriter {
*/
protected final ClassTree classtree;
private static final String LI_CIRCLE = "circle";
/**
* Constructor initilises classtree variable. This constructor will be used
* while generating global tree file "overview-tree.html".
@ -87,55 +90,64 @@ public abstract class AbstractTreeWriter extends HtmlDocletWriter {
}
/**
* Generate each level of the class tree. For each sub-class or
* Add each level of the class tree. For each sub-class or
* sub-interface indents the next level information.
* Recurses itself to generate subclasses info.
* To iterate is human, to recurse is divine - L. Peter Deutsch.
* Recurses itself to add subclasses info.
*
* @param parent the superclass or superinterface of the list.
* @param list list of the sub-classes at this level.
* @param isEnum true if we are generating a tree for enums.
* @param parent the superclass or superinterface of the list
* @param list list of the sub-classes at this level
* @param isEnum true if we are generating a tree for enums
* @param contentTree the content tree to which the level information will be added
*/
protected void generateLevelInfo(ClassDoc parent, List<ClassDoc> list,
boolean isEnum) {
if (list.size() > 0) {
ul();
for (int i = 0; i < list.size(); i++) {
protected void addLevelInfo(ClassDoc parent, List<ClassDoc> list,
boolean isEnum, Content contentTree) {
int size = list.size();
if (size > 0) {
Content ul = new HtmlTree(HtmlTag.UL);
for (int i = 0; i < size; i++) {
ClassDoc local = list.get(i);
printPartialInfo(local);
printExtendsImplements(parent, local);
generateLevelInfo(local, classtree.subs(local, isEnum),
isEnum); // Recurse
HtmlTree li = new HtmlTree(HtmlTag.LI);
li.addAttr(HtmlAttr.TYPE, LI_CIRCLE);
addPartialInfo(local, li);
addExtendsImplements(parent, local, li);
addLevelInfo(local, classtree.subs(local, isEnum),
isEnum, li); // Recurse
ul.addContent(li);
}
ulEnd();
contentTree.addContent(ul);
}
}
/**
* Generate the heading for the tree depending upon tree type if it's a
* Class Tree or Interface tree and also print the tree.
* Add the heading for the tree depending upon tree type if it's a
* Class Tree or Interface tree.
*
* @param list List of classes which are at the most base level, all the
* other classes in this run will derive from these classes.
* @param heading Heading for the tree.
* other classes in this run will derive from these classes
* @param heading heading for the tree
* @param div the content tree to which the tree will be added
*/
protected void generateTree(List<ClassDoc> list, String heading) {
protected void addTree(List<ClassDoc> list, String heading, Content div) {
if (list.size() > 0) {
ClassDoc firstClassDoc = list.get(0);
printTreeHeading(heading);
generateLevelInfo(!firstClassDoc.isInterface()? firstClassDoc : null,
list,
list == classtree.baseEnums());
Content headingContent = getResource(heading);
div.addContent(HtmlTree.HEADING(HtmlConstants.CONTENT_HEADING, true,
headingContent));
addLevelInfo(!firstClassDoc.isInterface()? firstClassDoc : null,
list, list == classtree.baseEnums(), div);
}
}
/**
* Print the information regarding the classes which this class extends or
* Add information regarding the classes which this class extends or
* implements.
*
* @param cd The classdoc under consideration.
* @param parent the parent class of the class being documented
* @param cd the classdoc under consideration
* @param contentTree the content tree to which the information will be added
*/
protected void printExtendsImplements(ClassDoc parent, ClassDoc cd) {
protected void addExtendsImplements(ClassDoc parent, ClassDoc cd,
Content contentTree) {
ClassDoc[] interfaces = cd.interfaces();
if (interfaces.length > (cd.isInterface()? 1 : 0)) {
Arrays.sort(interfaces);
@ -148,53 +160,43 @@ public abstract class AbstractTreeWriter extends HtmlDocletWriter {
}
if (counter == 0) {
if (cd.isInterface()) {
print(" (" + configuration.getText("doclet.also") + " extends ");
contentTree.addContent(" (");
contentTree.addContent(getResource("doclet.also"));
contentTree.addContent(" extends ");
} else {
print(" (implements ");
contentTree.addContent(" (implements ");
}
} else {
print(", ");
contentTree.addContent(", ");
}
printPreQualifiedClassLink(LinkInfoImpl.CONTEXT_TREE,
interfaces[i]);
addPreQualifiedClassLink(LinkInfoImpl.CONTEXT_TREE,
interfaces[i], contentTree);
counter++;
}
}
if (counter > 0) {
println(")");
contentTree.addContent(")");
}
}
}
/**
* Print information about the class kind, if it's a "class" or "interface".
* Add information about the class kind, if it's a "class" or "interface".
*
* @param cd classdoc.
* @param cd the class being documented
* @param contentTree the content tree to which the information will be added
*/
protected void printPartialInfo(ClassDoc cd) {
li("circle");
printPreQualifiedStrongClassLink(LinkInfoImpl.CONTEXT_TREE, cd);
protected void addPartialInfo(ClassDoc cd, Content contentTree) {
addPreQualifiedStrongClassLink(LinkInfoImpl.CONTEXT_TREE, cd, contentTree);
}
/**
* Print the heading for the tree.
* Get the tree label for the navigation bar.
*
* @param heading Heading for the tree.
* @return a content tree for the tree label
*/
protected void printTreeHeading(String heading) {
h2();
println(configuration.getText(heading));
h2End();
}
/**
* Highlight "Tree" word in the navigation bar, since this is the tree page.
*/
protected void navLinkTree() {
navCellRevStart();
fontStyle("NavBarFont1Rev");
strongText("doclet.Tree");
fontEnd();
navCellEnd();
protected Content getNavLinkTree() {
Content li = HtmlTree.LI(HtmlStyle.navBarCell1Rev, treeLabel);
return li;
}
}

86
langtools/src/share/classes/com/sun/tools/doclets/formats/html/AllClassesFrameWriter.java
View file

@ -25,11 +25,14 @@
package com.sun.tools.doclets.formats.html;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.javadoc.*;
import java.io.*;
import java.util.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.formats.html.markup.*;
/**
* Generate the file with list of all the classes in this run. This page will be
* used in the left-hand bottom frame, when "All Classes" link is clicked in
@ -38,6 +41,7 @@ import java.util.*;
*
* @author Atul M Dambalkar
* @author Doug Kramer
* @author Bhavesh Patel (Modified)
*/
public class AllClassesFrameWriter extends HtmlDocletWriter {
@ -56,6 +60,11 @@ public class AllClassesFrameWriter extends HtmlDocletWriter {
*/
protected IndexBuilder indexbuilder;
/**
* BR tag to be used within a document tree.
*/
final HtmlTree BR = new HtmlTree(HtmlTag.BR);
/**
* Construct AllClassesFrameWriter object. Also initilises the indexbuilder
* variable in this class.
@ -84,12 +93,12 @@ public class AllClassesFrameWriter extends HtmlDocletWriter {
try {
allclassgen = new AllClassesFrameWriter(configuration,
filename, indexbuilder);
allclassgen.generateAllClassesFile(true);
allclassgen.buildAllClassesFile(true);
allclassgen.close();
filename = OUTPUT_FILE_NAME_NOFRAMES;
allclassgen = new AllClassesFrameWriter(configuration,
filename, indexbuilder);
allclassgen.generateAllClassesFile(false);
allclassgen.buildAllClassesFile(false);
allclassgen.close();
} catch (IOException exc) {
configuration.standardmessage.
@ -100,30 +109,34 @@ public class AllClassesFrameWriter extends HtmlDocletWriter {
}
/**
* Print all the classes in table format in the file.
* Print all the classes in the file.
* @param wantFrames True if we want frames.
*/
protected void generateAllClassesFile(boolean wantFrames) throws IOException {
protected void buildAllClassesFile(boolean wantFrames) throws IOException {
String label = configuration.getText("doclet.All_Classes");
printHtmlHeader(label, null, false);
printAllClassesTableHeader();
printAllClasses(wantFrames);
printAllClassesTableFooter();
printBodyHtmlEnd();
Content body = getBody(false, getWindowTitle(label));
Content heading = HtmlTree.HEADING(HtmlConstants.TITLE_HEADING,
HtmlStyle.bar, allclassesLabel);
body.addContent(heading);
Content ul = new HtmlTree(HtmlTag.UL);
// Generate the class links and add it to the tdFont tree.
addAllClasses(ul, wantFrames);
Content div = HtmlTree.DIV(HtmlStyle.indexContainer, ul);
body.addContent(div);
printHtmlDocument(null, false, body);
}
/**
* Use the sorted index of all the classes and print all the classes.
* Use the sorted index of all the classes and add all the classes to the
* content list.
*
* @param content HtmlTree content to which all classes information will be added
* @param wantFrames True if we want frames.
*/
protected void printAllClasses(boolean wantFrames) {
protected void addAllClasses(Content content, boolean wantFrames) {
for (int i = 0; i < indexbuilder.elements().length; i++) {
Character unicode = (Character)((indexbuilder.elements())[i]);
generateContents(indexbuilder.getMemberList(unicode), wantFrames);
addContents(indexbuilder.getMemberList(unicode), wantFrames, content);
}
}
@ -136,46 +149,25 @@ public class AllClassesFrameWriter extends HtmlDocletWriter {
*
* @param classlist Sorted list of classes.
* @param wantFrames True if we want frames.
* @param content HtmlTree content to which the links will be added
*/
protected void generateContents(List<Doc> classlist, boolean wantFrames) {
protected void addContents(List<Doc> classlist, boolean wantFrames,
Content content) {
for (int i = 0; i < classlist.size(); i++) {
ClassDoc cd = (ClassDoc)classlist.get(i);
if (!Util.isCoreClass(cd)) {
continue;
}
String label = italicsClassName(cd, false);
Content linkContent;
if(wantFrames){
printLink(new LinkInfoImpl(LinkInfoImpl.ALL_CLASSES_FRAME, cd,
label, "classFrame")
);
linkContent = new RawHtml(getLink(new LinkInfoImpl(
LinkInfoImpl.ALL_CLASSES_FRAME, cd, label, "classFrame")));
} else {
printLink(new LinkInfoImpl(cd, label));
linkContent = new RawHtml(getLink(new LinkInfoImpl(cd, label)));
}
br();
Content li = HtmlTree.LI(linkContent);
content.addContent(li);
}
}
/**
* Print the heading "All Classes" and also print Html table tag.
*/
protected void printAllClassesTableHeader() {
fontSizeStyle("+1", "FrameHeadingFont");
strongText("doclet.All_Classes");
fontEnd();
br();
table();
tr();
tdNowrap();
fontStyle("FrameItemFont");
}
/**
* Print Html closing table tag.
*/
protected void printAllClassesTableFooter() {
fontEnd();
tdEnd();
trEnd();
tableEnd();
}
}

71
langtools/src/share/classes/com/sun/tools/doclets/formats/html/AnnotationTypeOptionalMemberWriterImpl.java
View file

@ -28,6 +28,7 @@ package com.sun.tools.doclets.formats.html;
import java.io.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.formats.html.markup.*;
import com.sun.tools.doclets.internal.toolkit.*;
/**
@ -54,29 +55,26 @@ public class AnnotationTypeOptionalMemberWriterImpl extends
/**
* {@inheritDoc}
*/
public void writeMemberSummaryHeader(ClassDoc classDoc) {
writer.println("<!-- =========== ANNOTATION TYPE OPTIONAL MEMBER SUMMARY =========== -->");
writer.println();
writer.printSummaryHeader(this, classDoc);
public Content getMemberSummaryHeader(ClassDoc classDoc,
Content memberSummaryTree) {
memberSummaryTree.addContent(
HtmlConstants.START_OF_ANNOTATION_TYPE_OPTIONAL_MEMBER_SUMMARY);
Content memberTree = writer.getMemberTreeHeader();
writer.addSummaryHeader(this, classDoc, memberTree);
return memberTree;
}
/**
* {@inheritDoc}
*/
public void writeDefaultValueInfo(MemberDoc member) {
public void addDefaultValueInfo(MemberDoc member, Content annotationDocTree) {
if (((AnnotationTypeElementDoc) member).defaultValue() != null) {
writer.printMemberDetailsListStartTag();
writer.dd();
writer.dl();
writer.dt();
writer.strong(ConfigurationImpl.getInstance().
getText("doclet.Default"));
writer.dtEnd();
writer.dd();
writer.print(((AnnotationTypeElementDoc) member).defaultValue());
writer.ddEnd();
writer.dlEnd();
writer.ddEnd();
Content dt = HtmlTree.DT(writer.getResource("doclet.Default"));
Content dl = HtmlTree.DL(dt);
Content dd = HtmlTree.DD(new StringContent(
((AnnotationTypeElementDoc) member).defaultValue().toString()));
dl.addContent(dd);
annotationDocTree.addContent(dl);
}
}
@ -90,45 +88,58 @@ public class AnnotationTypeOptionalMemberWriterImpl extends
/**
* {@inheritDoc}
*/
public void printSummaryLabel() {
writer.printText("doclet.Annotation_Type_Optional_Member_Summary");
public void addSummaryLabel(Content memberTree) {
Content label = HtmlTree.HEADING(HtmlConstants.SUMMARY_HEADING,
writer.getResource("doclet.Annotation_Type_Optional_Member_Summary"));
memberTree.addContent(label);
}
/**
* {@inheritDoc}
*/
public void printTableSummary() {
writer.tableIndexSummary(configuration().getText("doclet.Member_Table_Summary",
public String getTableSummary() {
return configuration().getText("doclet.Member_Table_Summary",
configuration().getText("doclet.Annotation_Type_Optional_Member_Summary"),
configuration().getText("doclet.annotation_type_optional_members")));
configuration().getText("doclet.annotation_type_optional_members"));
}
public void printSummaryTableHeader(ProgramElementDoc member) {
/**
* {@inheritDoc}
*/
public String getCaption() {
return configuration().getText("doclet.Annotation_Type_Optional_Members");
}
/**
* {@inheritDoc}
*/
public String[] getSummaryTableHeader(ProgramElementDoc member) {
String[] header = new String[] {
writer.getModifierTypeHeader(),
configuration().getText("doclet.0_and_1",
configuration().getText("doclet.Annotation_Type_Optional_Member"),
configuration().getText("doclet.Description"))
};
writer.summaryTableHeader(header, "col");
return header;
}
/**
* {@inheritDoc}
*/
public void printSummaryAnchor(ClassDoc cd) {
writer.anchor("annotation_type_optional_element_summary");
public void addSummaryAnchor(ClassDoc cd, Content memberTree) {
memberTree.addContent(writer.getMarkerAnchor(
"annotation_type_optional_element_summary"));
}
/**
* {@inheritDoc}
*/
protected void printNavSummaryLink(ClassDoc cd, boolean link) {
protected Content getNavSummaryLink(ClassDoc cd, boolean link) {
if (link) {
writer.printHyperLink("", "annotation_type_optional_element_summary",
configuration().getText("doclet.navAnnotationTypeOptionalMember"));
return writer.getHyperLink("", "annotation_type_optional_element_summary",
writer.getResource("doclet.navAnnotationTypeOptionalMember"));
} else {
writer.printText("doclet.navAnnotationTypeOptionalMember");
return writer.getResource("doclet.navAnnotationTypeOptionalMember");
}
}
}

234
langtools/src/share/classes/com/sun/tools/doclets/formats/html/AnnotationTypeRequiredMemberWriterImpl.java
View file

@ -28,6 +28,7 @@ package com.sun.tools.doclets.formats.html;
import java.io.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.formats.html.markup.*;
import com.sun.tools.doclets.internal.toolkit.*;
/**
@ -51,122 +52,102 @@ public class AnnotationTypeRequiredMemberWriterImpl extends AbstractMemberWriter
}
/**
* Write the annotation type member summary header for the given class.
*
* @param classDoc the class the summary belongs to.
* {@inheritDoc}
*/
public void writeMemberSummaryHeader(ClassDoc classDoc) {
writer.println("<!-- =========== ANNOTATION TYPE REQUIRED MEMBER SUMMARY =========== -->");
writer.println();
writer.printSummaryHeader(this, classDoc);
}
/**
* Write the annotation type member summary footer for the given class.
*
* @param classDoc the class the summary belongs to.
*/
public void writeMemberSummaryFooter(ClassDoc classDoc) {
writer.printSummaryFooter(this, classDoc);
public Content getMemberSummaryHeader(ClassDoc classDoc,
Content memberSummaryTree) {
memberSummaryTree.addContent(
HtmlConstants.START_OF_ANNOTATION_TYPE_REQUIRED_MEMBER_SUMMARY);
Content memberTree = writer.getMemberTreeHeader();
writer.addSummaryHeader(this, classDoc, memberTree);
return memberTree;
}
/**
* {@inheritDoc}
*/
public void writeInheritedMemberSummaryHeader(ClassDoc classDoc) {
//Not appliable.
public void addAnnotationDetailsTreeHeader(ClassDoc classDoc,
Content memberDetailsTree) {
if (!writer.printedAnnotationHeading) {
memberDetailsTree.addContent(writer.getMarkerAnchor(
"annotation_type_element_detail"));
Content heading = HtmlTree.HEADING(HtmlConstants.DETAILS_HEADING,
writer.annotationTypeDetailsLabel);
memberDetailsTree.addContent(heading);
writer.printedAnnotationHeading = true;
}
}
/**
* {@inheritDoc}
*/
public void writeInheritedMemberSummary(ClassDoc classDoc,
ProgramElementDoc member, boolean isFirst, boolean isLast) {
//Not appliable.
public Content getAnnotationDocTreeHeader(MemberDoc member,
Content annotationDetailsTree) {
annotationDetailsTree.addContent(
writer.getMarkerAnchor(member.name() +
((ExecutableMemberDoc) member).signature()));
Content annotationDocTree = writer.getMemberTreeHeader();
Content heading = new HtmlTree(HtmlConstants.MEMBER_HEADING);
heading.addContent(member.name());
annotationDocTree.addContent(heading);
return annotationDocTree;
}
/**
* {@inheritDoc}
*/
public void writeInheritedMemberSummaryFooter(ClassDoc classDoc) {
//Not appliable.
}
/**
* {@inheritDoc}
*/
public void writeHeader(ClassDoc classDoc, String header) {
writer.println();
writer.println("<!-- ============ ANNOTATION TYPE MEMBER DETAIL =========== -->");
writer.println();
writer.anchor("annotation_type_element_detail");
writer.printTableHeadingBackground(header);
writer.println();
}
/**
* {@inheritDoc}
*/
public void writeMemberHeader(MemberDoc member, boolean isFirst) {
if (! isFirst) {
writer.printMemberHeader();
writer.println("");
}
writer.anchor(member.name() + ((ExecutableMemberDoc) member).signature());
writer.h3();
writer.print(member.name());
writer.h3End();
}
/**
* {@inheritDoc}
*/
public void writeSignature(MemberDoc member) {
writer.pre();
writer.writeAnnotationInfo(member);
printModifiers(member);
writer.printLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_MEMBER,
getType(member)));
print(' ');
public Content getSignature(MemberDoc member) {
Content pre = new HtmlTree(HtmlTag.PRE);
writer.addAnnotationInfo(member, pre);
addModifiers(member, pre);
Content link = new RawHtml(
writer.getLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_MEMBER,
getType(member))));
pre.addContent(link);
pre.addContent(writer.getSpace());
if (configuration().linksource) {
writer.printSrcLink(member, member.name());
Content memberName = new StringContent(member.name());
writer.addSrcLink(member, memberName, pre);
} else {
strong(member.name());
addName(member.name(), pre);
}
writer.preEnd();
assert !writer.getMemberDetailsListPrinted();
return pre;
}
/**
* {@inheritDoc}
*/
public void writeComments(MemberDoc member) {
printComment(member);
public void addDeprecated(MemberDoc member, Content annotationDocTree) {
addDeprecatedInfo(member, annotationDocTree);
}
/**
* Write the tag output for the given member.
*
* @param member the member being documented.
* {@inheritDoc}
*/
public void writeTags(MemberDoc member) {
writer.printTags(member);
public void addComments(MemberDoc member, Content annotationDocTree) {
addComment(member, annotationDocTree);
}
/**
* Write the annotation type member footer.
* {@inheritDoc}
*/
public void writeMemberFooter() {
printMemberFooter();
public void addTags(MemberDoc member, Content annotationDocTree) {
writer.addTagsInfo(member, annotationDocTree);
}
/**
* Write the footer for the annotation type member documentation.
*
* @param classDoc the class that the annotation type member belong to.
* {@inheritDoc}
*/
public void writeFooter(ClassDoc classDoc) {
//No footer to write for annotation type member documentation
public Content getAnnotationDetails(Content annotationDetailsTree) {
return getMemberTree(annotationDetailsTree);
}
/**
* {@inheritDoc}
*/
public Content getAnnotationDoc(Content annotationDocTree,
boolean isLastContent) {
return getMemberTree(annotationDocTree, isLastContent);
}
/**
@ -179,113 +160,120 @@ public class AnnotationTypeRequiredMemberWriterImpl extends AbstractMemberWriter
/**
* {@inheritDoc}
*/
public void printSummaryLabel() {
writer.printText("doclet.Annotation_Type_Required_Member_Summary");
public void addSummaryLabel(Content memberTree) {
Content label = HtmlTree.HEADING(HtmlConstants.SUMMARY_HEADING,
writer.getResource("doclet.Annotation_Type_Required_Member_Summary"));
memberTree.addContent(label);
}
/**
* {@inheritDoc}
*/
public void printTableSummary() {
writer.tableIndexSummary(configuration().getText("doclet.Member_Table_Summary",
public String getTableSummary() {
return configuration().getText("doclet.Member_Table_Summary",
configuration().getText("doclet.Annotation_Type_Required_Member_Summary"),
configuration().getText("doclet.annotation_type_required_members")));
configuration().getText("doclet.annotation_type_required_members"));
}
public void printSummaryTableHeader(ProgramElementDoc member) {
/**
* {@inheritDoc}
*/
public String getCaption() {
return configuration().getText("doclet.Annotation_Type_Required_Members");
}
/**
* {@inheritDoc}
*/
public String[] getSummaryTableHeader(ProgramElementDoc member) {
String[] header = new String[] {
writer.getModifierTypeHeader(),
configuration().getText("doclet.0_and_1",
configuration().getText("doclet.Annotation_Type_Required_Member"),
configuration().getText("doclet.Description"))
};
writer.summaryTableHeader(header, "col");
return header;
}
/**
* {@inheritDoc}
*/
public void printSummaryAnchor(ClassDoc cd) {
writer.anchor("annotation_type_required_element_summary");
public void addSummaryAnchor(ClassDoc cd, Content memberTree) {
memberTree.addContent(writer.getMarkerAnchor(
"annotation_type_required_element_summary"));
}
/**
* {@inheritDoc}
*/
public void printInheritedSummaryAnchor(ClassDoc cd) {
} // no such
/**
* {@inheritDoc}
*/
public void printInheritedSummaryLabel(ClassDoc cd) {
// no such
public void addInheritedSummaryAnchor(ClassDoc cd, Content inheritedTree) {
}
/**
* {@inheritDoc}
*/
protected void writeSummaryLink(int context, ClassDoc cd, ProgramElementDoc member) {
writer.strong();
writer.printDocLink(context, (MemberDoc) member, member.name(), false);
writer.strongEnd();
public void addInheritedSummaryLabel(ClassDoc cd, Content inheritedTree) {
}
/**
* {@inheritDoc}
*/
protected void writeInheritedSummaryLink(ClassDoc cd,
ProgramElementDoc member) {
protected void addSummaryLink(int context, ClassDoc cd, ProgramElementDoc member,
Content tdSummary) {
Content strong = HtmlTree.STRONG(new RawHtml(
writer.getDocLink(context, (MemberDoc) member, member.name(), false)));
Content code = HtmlTree.CODE(strong);
tdSummary.addContent(code);
}
/**
* {@inheritDoc}
*/
protected void addInheritedSummaryLink(ClassDoc cd,
ProgramElementDoc member, Content linksTree) {
//Not applicable.
}
/**
* {@inheritDoc}
*/
protected void printSummaryType(ProgramElementDoc member) {
protected void addSummaryType(ProgramElementDoc member, Content tdSummaryType) {
MemberDoc m = (MemberDoc)member;
printModifierAndType(m, getType(m));
addModifierAndType(m, getType(m), tdSummaryType);
}
/**
* {@inheritDoc}
*/
protected void writeDeprecatedLink(ProgramElementDoc member) {
writer.printDocLink(LinkInfoImpl.CONTEXT_MEMBER,
(MemberDoc) member, ((MemberDoc)member).qualifiedName(), false);
protected Content getDeprecatedLink(ProgramElementDoc member) {
return writer.getDocLink(LinkInfoImpl.CONTEXT_MEMBER,
(MemberDoc) member, ((MemberDoc)member).qualifiedName());
}
/**
* {@inheritDoc}
*/
protected void printNavSummaryLink(ClassDoc cd, boolean link) {
protected Content getNavSummaryLink(ClassDoc cd, boolean link) {
if (link) {
writer.printHyperLink("", "annotation_type_required_element_summary",
configuration().getText("doclet.navAnnotationTypeRequiredMember"));
return writer.getHyperLink("", "annotation_type_required_element_summary",
writer.getResource("doclet.navAnnotationTypeRequiredMember"));
} else {
writer.printText("doclet.navAnnotationTypeRequiredMember");
return writer.getResource("doclet.navAnnotationTypeRequiredMember");
}
}
/**
* {@inheritDoc}
*/
protected void printNavDetailLink(boolean link) {
protected void addNavDetailLink(boolean link, Content liNav) {
if (link) {
writer.printHyperLink("", "annotation_type_element_detail",
configuration().getText("doclet.navAnnotationTypeMember"));
liNav.addContent(writer.getHyperLink("", "annotation_type_element_detail",
writer.getResource("doclet.navAnnotationTypeMember")));
} else {
writer.printText("doclet.navAnnotationTypeMember");
liNav.addContent(writer.getResource("doclet.navAnnotationTypeMember"));
}
}
/**
* {@inheritDoc}
*/
public void writeDeprecated(MemberDoc member) {
printDeprecated(member);
}
private Type getType(MemberDoc member) {
if (member instanceof FieldDoc) {
return ((FieldDoc) member).type();

365
langtools/src/share/classes/com/sun/tools/doclets/formats/html/AnnotationTypeWriterImpl.java
View file

@ -29,6 +29,7 @@ import com.sun.javadoc.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.builders.*;
import com.sun.tools.doclets.formats.html.markup.*;
/**
* Generate the Class Information Page.
@ -40,6 +41,7 @@ import com.sun.tools.doclets.internal.toolkit.builders.*;
*
* @author Atul M Dambalkar
* @author Robert Field
* @author Bhavesh Patel (Modified)
*/
public class AnnotationTypeWriterImpl extends SubWriterHolderWriter
implements AnnotationTypeWriter {
@ -69,126 +71,168 @@ public class AnnotationTypeWriterImpl extends SubWriterHolderWriter
}
/**
* Print this package link
* Get this package link.
*
* @return a content tree for the package link
*/
protected void navLinkPackage() {
navCellStart();
printHyperLink("package-summary.html", "",
configuration.getText("doclet.Package"), true, "NavBarFont1");
navCellEnd();
protected Content getNavLinkPackage() {
Content linkContent = getHyperLink("package-summary.html", "",
packageLabel);
Content li = HtmlTree.LI(linkContent);
return li;
}
/**
* Print class page indicator
* Get the class link.
*
* @return a content tree for the class link
*/
protected void navLinkClass() {
navCellRevStart();
fontStyle("NavBarFont1Rev");
strongText("doclet.Class");
fontEnd();
navCellEnd();
protected Content getNavLinkClass() {
Content li = HtmlTree.LI(HtmlStyle.navBarCell1Rev, classLabel);
return li;
}
/**
* Print class use link
* Get the class use link.
*
* @return a content tree for the class use link
*/
protected void navLinkClassUse() {
navCellStart();
printHyperLink("class-use/" + filename, "",
configuration.getText("doclet.navClassUse"), true, "NavBarFont1");
navCellEnd();
protected Content getNavLinkClassUse() {
Content linkContent = getHyperLink("class-use/" + filename, "", useLabel);
Content li = HtmlTree.LI(linkContent);
return li;
}
/**
* Print previous package link
* Get link to previous class.
*
* @return a content tree for the previous class link
*/
protected void navLinkPrevious() {
if (prev == null) {
printText("doclet.Prev_Class");
} else {
printLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_CLASS,
prev.asClassDoc(), "",
configuration.getText("doclet.Prev_Class"), true));
public Content getNavLinkPrevious() {
Content li;
if (prev != null) {
Content prevLink = new RawHtml(getLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_CLASS, prev.asClassDoc(), "",
configuration.getText("doclet.Prev_Class"), true)));
li = HtmlTree.LI(prevLink);
}
else
li = HtmlTree.LI(prevclassLabel);
return li;
}
/**
* Print next package link
* Get link to next class.
*
* @return a content tree for the next class link
*/
protected void navLinkNext() {
if (next == null) {
printText("doclet.Next_Class");
} else {
printLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_CLASS,
next.asClassDoc(), "",
configuration.getText("doclet.Next_Class"), true));
public Content getNavLinkNext() {
Content li;
if (next != null) {
Content nextLink = new RawHtml(getLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_CLASS, next.asClassDoc(), "",
configuration.getText("doclet.Next_Class"), true)));
li = HtmlTree.LI(nextLink);
}
else
li = HtmlTree.LI(nextclassLabel);
return li;
}
/**
* {@inheritDoc}
*/
public void writeHeader(String header) {
public Content getHeader(String header) {
String pkgname = (annotationType.containingPackage() != null)?
annotationType.containingPackage().name(): "";
String clname = annotationType.name();
printHtmlHeader(clname,
configuration.metakeywords.getMetaKeywords(annotationType), true);
printTop();
navLinks(true);
hr();
println("<!-- ======== START OF CLASS DATA ======== -->");
h2();
Content bodyTree = getBody(true, getWindowTitle(clname));
addTop(bodyTree);
addNavLinks(true, bodyTree);
bodyTree.addContent(HtmlConstants.START_OF_CLASS_DATA);
HtmlTree div = new HtmlTree(HtmlTag.DIV);
div.addStyle(HtmlStyle.header);
if (pkgname.length() > 0) {
font("-1"); print(pkgname); fontEnd(); br();
Content pkgNameContent = new StringContent(pkgname);
Content pkgNamePara = HtmlTree.P(HtmlStyle.subTitle, pkgNameContent);
div.addContent(pkgNamePara);
}
print(header + getTypeParameterLinks(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_CLASS_HEADER,
annotationType, false)));
h2End();
LinkInfoImpl linkInfo = new LinkInfoImpl(
LinkInfoImpl.CONTEXT_CLASS_HEADER, annotationType, false);
Content headerContent = new StringContent(header);
Content heading = HtmlTree.HEADING(HtmlConstants.CLASS_PAGE_HEADING, true,
HtmlStyle.title, headerContent);
heading.addContent(new RawHtml(getTypeParameterLinks(linkInfo)));
div.addContent(heading);
bodyTree.addContent(div);
return bodyTree;
}
/**
* {@inheritDoc}
*/
public void writeFooter() {
println("<!-- ========= END OF CLASS DATA ========= -->");
hr();
navLinks(false);
printBottom();
printBodyHtmlEnd();
public Content getAnnotationContentHeader() {
return getContentHeader();
}
/**
* {@inheritDoc}
*/
public void writeAnnotationTypeSignature(String modifiers) {
preNoNewLine();
writeAnnotationInfo(annotationType);
print(modifiers);
String name = annotationType.name() +
getTypeParameterLinks(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_CLASS_SIGNATURE, annotationType, false));
public void addFooter(Content contentTree) {
contentTree.addContent(HtmlConstants.END_OF_CLASS_DATA);
addNavLinks(false, contentTree);
addBottom(contentTree);
}
/**
* {@inheritDoc}
*/
public void printDocument(Content contentTree) {
printHtmlDocument(configuration.metakeywords.getMetaKeywords(annotationType),
true, contentTree);
}
/**
* {@inheritDoc}
*/
public Content getAnnotationInfoTreeHeader() {
return getMemberTreeHeader();
}
/**
* {@inheritDoc}
*/
public Content getAnnotationInfo(Content annotationInfoTree) {
return getMemberTree(HtmlStyle.description, annotationInfoTree);
}
/**
* {@inheritDoc}
*/
public void addAnnotationTypeSignature(String modifiers, Content annotationInfoTree) {
annotationInfoTree.addContent(new HtmlTree(HtmlTag.BR));
Content pre = new HtmlTree(HtmlTag.PRE);
addAnnotationInfo(annotationType, pre);
pre.addContent(modifiers);
LinkInfoImpl linkInfo = new LinkInfoImpl(
LinkInfoImpl.CONTEXT_CLASS_SIGNATURE, annotationType, false);
Content name = new RawHtml (annotationType.name() +
getTypeParameterLinks(linkInfo));
if (configuration().linksource) {
printSrcLink(annotationType, name);
addSrcLink(annotationType, name, pre);
} else {
strong(name);
pre.addContent(HtmlTree.STRONG(name));
}
preEnd();
p();
annotationInfoTree.addContent(pre);
}
/**
* {@inheritDoc}
*/
public void writeAnnotationTypeDescription() {
public void addAnnotationTypeDescription(Content annotationInfoTree) {
if(!configuration.nocomment) {
// generate documentation for the class.
if (annotationType.inlineTags().length > 0) {
printInlineComment(annotationType);
p();
addInlineComment(annotationType, annotationInfoTree);
}
}
}
@ -196,104 +240,120 @@ public class AnnotationTypeWriterImpl extends SubWriterHolderWriter
/**
* {@inheritDoc}
*/
public void writeAnnotationTypeTagInfo() {
boolean needHr = annotationType.elements().length > 0;
public void addAnnotationTypeTagInfo(Content annotationInfoTree) {
if(!configuration.nocomment) {
// Print Information about all the tags here
printTags(annotationType);
if (needHr) {
hr();
}
p();
} else if (needHr) {
hr();
addTagsInfo(annotationType, annotationInfoTree);
}
}
/**
* {@inheritDoc}
*/
public void writeAnnotationTypeDeprecationInfo() {
hr();
public void addAnnotationTypeDeprecationInfo(Content annotationInfoTree) {
Content hr = new HtmlTree(HtmlTag.HR);
annotationInfoTree.addContent(hr);
Tag[] deprs = annotationType.tags("deprecated");
if (Util.isDeprecated(annotationType)) {
strongText("doclet.Deprecated");
Content strong = HtmlTree.STRONG(deprecatedPhrase);
Content div = HtmlTree.DIV(HtmlStyle.block, strong);
if (deprs.length > 0) {
Tag[] commentTags = deprs[0].inlineTags();
if (commentTags.length > 0) {
space();
printInlineDeprecatedComment(annotationType, deprs[0]);
div.addContent(getSpace());
addInlineDeprecatedComment(annotationType, deprs[0], div);
}
}
p();
annotationInfoTree.addContent(div);
}
}
protected void navLinkTree() {
navCellStart();
printHyperLink("package-tree.html", "",
configuration.getText("doclet.Tree"), true, "NavBarFont1");
navCellEnd();
/**
* {@inheritDoc}
*/
public void addAnnotationDetailsMarker(Content memberDetails) {
memberDetails.addContent(HtmlConstants.START_OF_ANNOTATION_TYPE_DETAILS);
}
protected void printSummaryDetailLinks() {
/**
* {@inheritDoc}
*/
protected Content getNavLinkTree() {
Content treeLinkContent = getHyperLink("package-tree.html",
"", treeLabel, "", "");
Content li = HtmlTree.LI(treeLinkContent);
return li;
}
/**
* Add summary details to the navigation bar.
*
* @param subDiv the content tree to which the summary detail links will be added
*/
protected void addSummaryDetailLinks(Content subDiv) {
try {
tr();
tdVAlignClass("top", "NavBarCell3");
font("-2");
print(" ");
navSummaryLinks();
fontEnd();
tdEnd();
tdVAlignClass("top", "NavBarCell3");
font("-2");
navDetailLinks();
fontEnd();
tdEnd();
trEnd();
Content div = HtmlTree.DIV(getNavSummaryLinks());
div.addContent(getNavDetailLinks());
subDiv.addContent(div);
} catch (Exception e) {
e.printStackTrace();
throw new DocletAbortException();
}
}
protected void navSummaryLinks() throws Exception {
printText("doclet.Summary");
space();
/**
* Get summary links for navigation bar.
*
* @return the content tree for the navigation summary links
*/
protected Content getNavSummaryLinks() throws Exception {
Content li = HtmlTree.LI(summaryLabel);
li.addContent(getSpace());
Content ulNav = HtmlTree.UL(HtmlStyle.subNavList, li);
MemberSummaryBuilder memberSummaryBuilder = (MemberSummaryBuilder)
configuration.getBuilderFactory().getMemberSummaryBuilder(this);
writeNavSummaryLink(memberSummaryBuilder,
Content liNavReq = new HtmlTree(HtmlTag.LI);
addNavSummaryLink(memberSummaryBuilder,
"doclet.navAnnotationTypeRequiredMember",
VisibleMemberMap.ANNOTATION_TYPE_MEMBER_REQUIRED);
navGap();
writeNavSummaryLink(memberSummaryBuilder,
VisibleMemberMap.ANNOTATION_TYPE_MEMBER_REQUIRED, liNavReq);
addNavGap(liNavReq);
ulNav.addContent(liNavReq);
Content liNavOpt = new HtmlTree(HtmlTag.LI);
addNavSummaryLink(memberSummaryBuilder,
"doclet.navAnnotationTypeOptionalMember",
VisibleMemberMap.ANNOTATION_TYPE_MEMBER_OPTIONAL);
VisibleMemberMap.ANNOTATION_TYPE_MEMBER_OPTIONAL, liNavOpt);
ulNav.addContent(liNavOpt);
return ulNav;
}
private void writeNavSummaryLink(MemberSummaryBuilder builder,
String label, int type) {
/**
* Add the navigation summary link.
*
* @param builder builder for the member to be documented
* @param label the label for the navigation
* @param type type to be documented
* @param liNav the content tree to which the navigation summary link will be added
*/
protected void addNavSummaryLink(MemberSummaryBuilder builder,
String label, int type, Content liNav) {
AbstractMemberWriter writer = ((AbstractMemberWriter) builder.
getMemberSummaryWriter(type));
if (writer == null) {
printText(label);
liNav.addContent(getResource(label));
} else {
writer.printNavSummaryLink(null,
! builder.getVisibleMemberMap(type).noVisibleMembers());
liNav.addContent(writer.getNavSummaryLink(null,
! builder.getVisibleMemberMap(type).noVisibleMembers()));
}
}
/**
* Method navDetailLinks
*
* @throws Exception
* Get detail links for the navigation bar.
*
* @return the content tree for the detail links
*/
protected void navDetailLinks() throws Exception {
printText("doclet.Detail");
space();
protected Content getNavDetailLinks() throws Exception {
Content li = HtmlTree.LI(detailLabel);
li.addContent(getSpace());
Content ulNav = HtmlTree.UL(HtmlStyle.subNavList, li);
MemberSummaryBuilder memberSummaryBuilder = (MemberSummaryBuilder)
configuration.getBuilderFactory().getMemberSummaryBuilder(this);
AbstractMemberWriter writerOptional =
@ -303,41 +363,29 @@ public class AnnotationTypeWriterImpl extends SubWriterHolderWriter
((AbstractMemberWriter) memberSummaryBuilder.
getMemberSummaryWriter(VisibleMemberMap.ANNOTATION_TYPE_MEMBER_REQUIRED));
if (writerOptional != null){
writerOptional.printNavDetailLink(annotationType.elements().length > 0);
Content liNavOpt = new HtmlTree(HtmlTag.LI);
writerOptional.addNavDetailLink(annotationType.elements().length > 0, liNavOpt);
ulNav.addContent(liNavOpt);
} else if (writerRequired != null){
writerRequired.printNavDetailLink(annotationType.elements().length > 0);
Content liNavReq = new HtmlTree(HtmlTag.LI);
writerRequired.addNavDetailLink(annotationType.elements().length > 0, liNavReq);
ulNav.addContent(liNavReq);
} else {
printText("doclet.navAnnotationTypeMember");
Content liNav = HtmlTree.LI(getResource("doclet.navAnnotationTypeMember"));
ulNav.addContent(liNav);
}
}
protected void navGap() {
space();
print('|');
space();
return ulNav;
}
/**
* If this is an inner class or interface, write the enclosing class or
* interface.
* Add gap between navigation bar elements.
*
* @param liNav the content tree to which the gap will be added
*/
public void writeNestedClassInfo() {
ClassDoc outerClass = annotationType.containingClass();
if (outerClass != null) {
dl();
dt();
if (annotationType.isInterface()) {
strongText("doclet.Enclosing_Interface");
} else {
strongText("doclet.Enclosing_Class");
}
dtEnd();
dd();
printLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_CLASS, outerClass,
false));
ddEnd();
dlEnd();
}
protected void addNavGap(Content liNav) {
liNav.addContent(getSpace());
liNav.addContent("|");
liNav.addContent(getSpace());
}
/**
@ -346,11 +394,4 @@ public class AnnotationTypeWriterImpl extends SubWriterHolderWriter
public AnnotationTypeDoc getAnnotationTypeDoc() {
return annotationType;
}
/**
* {@inheritDoc}
*/
public void completeMemberSummaryBuild() {
p();
}
}

400
langtools/src/share/classes/com/sun/tools/doclets/formats/html/ClassUseWriter.java
View file

@ -25,10 +25,12 @@
package com.sun.tools.doclets.formats.html;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.javadoc.*;
import java.io.*;
import java.util.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.formats.html.markup.*;
import com.sun.tools.doclets.internal.toolkit.*;
/**
* Generate class usage information.
@ -207,257 +209,301 @@ public class ClassUseWriter extends SubWriterHolderWriter {
}
/**
* Print the class use list.
* Generate the class use list.
*/
protected void generateClassUseFile() throws IOException {
printClassUseHeader();
Content body = getClassUseHeader();
HtmlTree div = new HtmlTree(HtmlTag.DIV);
div.addStyle(HtmlStyle.classUseContainer);
if (pkgSet.size() > 0) {
generateClassUse();
addClassUse(div);
} else {
printText("doclet.ClassUse_No.usage.of.0",
classdoc.qualifiedName());
p();
div.addContent(getResource("doclet.ClassUse_No.usage.of.0",
classdoc.qualifiedName()));
}
body.addContent(div);
addNavLinks(false, body);
addBottom(body);
printHtmlDocument(null, true, body);
}
printClassUseFooter();
}
protected void generateClassUse() throws IOException {
/**
* Add the class use documentation.
*
* @param contentTree the content tree to which the class use information will be added
*/
protected void addClassUse(Content contentTree) throws IOException {
HtmlTree ul = new HtmlTree(HtmlTag.UL);
ul.addStyle(HtmlStyle.blockList);
if (configuration.packages.length > 1) {
generatePackageList();
generatePackageAnnotationList();
addPackageList(ul);
addPackageAnnotationList(ul);
}
generateClassList();
addClassList(ul);
contentTree.addContent(ul);
}
protected void generatePackageList() throws IOException {
tableIndexSummary(useTableSummary);
tableCaptionStart();
printText("doclet.ClassUse_Packages.that.use.0",
/**
* Add the packages list that use the given class.
*
* @param contentTree the content tree to which the packages list will be added
*/
protected void addPackageList(Content contentTree) throws IOException {
Content table = HtmlTree.TABLE(0, 3, 0, useTableSummary,
getTableCaption(configuration().getText(
"doclet.ClassUse_Packages.that.use.0",
getLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_CLASS_USE_HEADER, classdoc,
false)));
tableCaptionEnd();
summaryTableHeader(packageTableHeader, "col");
for (Iterator<PackageDoc> it = pkgSet.iterator(); it.hasNext();) {
false)))));
table.addContent(getSummaryTableHeader(packageTableHeader, "col"));
Content tbody = new HtmlTree(HtmlTag.TBODY);
Iterator<PackageDoc> it = pkgSet.iterator();
for (int i = 0; it.hasNext(); i++) {
PackageDoc pkg = it.next();
generatePackageUse(pkg);
HtmlTree tr = new HtmlTree(HtmlTag.TR);
if (i % 2 == 0) {
tr.addStyle(HtmlStyle.altColor);
} else {
tr.addStyle(HtmlStyle.rowColor);
}
tableEnd();
space();
p();
addPackageUse(pkg, tr);
tbody.addContent(tr);
}
table.addContent(tbody);
Content li = HtmlTree.LI(HtmlStyle.blockList, table);
contentTree.addContent(li);
}
protected void generatePackageAnnotationList() throws IOException {
/**
* Add the package annotation list.
*
* @param contentTree the content tree to which the package annotation list will be added
*/
protected void addPackageAnnotationList(Content contentTree) throws IOException {
if ((!classdoc.isAnnotationType()) ||
pkgToPackageAnnotations == null ||
pkgToPackageAnnotations.size() == 0)
pkgToPackageAnnotations.size() == 0) {
return;
tableIndexSummary(useTableSummary);
tableCaptionStart();
printText("doclet.ClassUse_PackageAnnotation",
getLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_CLASS_USE_HEADER, classdoc,
false)));
tableCaptionEnd();
summaryTableHeader(packageTableHeader, "col");
for (Iterator<PackageDoc> it = pkgToPackageAnnotations.iterator(); it.hasNext();) {
PackageDoc pkg = it.next();
trBgcolorStyle("white", "TableRowColor");
summaryRow(0);
//Just want an anchor here.
printPackageLink(pkg, pkg.name(), true);
summaryRowEnd();
summaryRow(0);
printSummaryComment(pkg);
space();
summaryRowEnd();
trEnd();
}
tableEnd();
space();
p();
Content table = HtmlTree.TABLE(0, 3, 0, useTableSummary,
getTableCaption(configuration().getText(
"doclet.ClassUse_PackageAnnotation",
getLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_CLASS_USE_HEADER, classdoc,
false)))));
table.addContent(getSummaryTableHeader(packageTableHeader, "col"));
Content tbody = new HtmlTree(HtmlTag.TBODY);
Iterator<PackageDoc> it = pkgToPackageAnnotations.iterator();
for (int i = 0; it.hasNext(); i++) {
PackageDoc pkg = it.next();
HtmlTree tr = new HtmlTree(HtmlTag.TR);
if (i % 2 == 0) {
tr.addStyle(HtmlStyle.altColor);
} else {
tr.addStyle(HtmlStyle.rowColor);
}
Content tdFirst = HtmlTree.TD(HtmlStyle.colFirst,
getPackageLink(pkg, new StringContent(pkg.name())));
tr.addContent(tdFirst);
HtmlTree tdLast = new HtmlTree(HtmlTag.TD);
tdLast.addStyle(HtmlStyle.colLast);
if (pkg != null) {
addSummaryComment(pkg, tdLast);
} else {
tdLast.addContent(getSpace());
}
tr.addContent(tdLast);
tbody.addContent(tr);
}
table.addContent(tbody);
Content li = HtmlTree.LI(HtmlStyle.blockList, table);
contentTree.addContent(li);
}
protected void generateClassList() throws IOException {
/**
* Add the class list that use the given class.
*
* @param contentTree the content tree to which the class list will be added
*/
protected void addClassList(Content contentTree) throws IOException {
HtmlTree ul = new HtmlTree(HtmlTag.UL);
ul.addStyle(HtmlStyle.blockList);
for (Iterator<PackageDoc> it = pkgSet.iterator(); it.hasNext();) {
PackageDoc pkg = it.next();
anchor(pkg.name());
tableIndexSummary();
tableHeaderStart("#CCCCFF");
printText("doclet.ClassUse_Uses.of.0.in.1",
Content li = HtmlTree.LI(HtmlStyle.blockList, getMarkerAnchor(pkg.name()));
Content link = new RawHtml(
configuration.getText("doclet.ClassUse_Uses.of.0.in.1",
getLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_CLASS_USE_HEADER,
classdoc, false)),
getPackageLink(pkg, Util.getPackageName(pkg), false));
tableHeaderEnd();
tableEnd();
space();
p();
generateClassUse(pkg);
getPackageLinkString(pkg, Util.getPackageName(pkg), false)));
Content heading = HtmlTree.HEADING(HtmlConstants.SUMMARY_HEADING, link);
li.addContent(heading);
addClassUse(pkg, li);
ul.addContent(li);
}
Content li = HtmlTree.LI(HtmlStyle.blockList, ul);
contentTree.addContent(li);
}
/**
* Print the package use list.
* Add the package use information.
*
* @param pkg the package that uses the given class
* @param contentTree the content tree to which the package use information will be added
*/
protected void generatePackageUse(PackageDoc pkg) throws IOException {
trBgcolorStyle("white", "TableRowColor");
summaryRow(0);
//Just want an anchor here.
printHyperLink("", pkg.name(), Util.getPackageName(pkg), true);
summaryRowEnd();
summaryRow(0);
printSummaryComment(pkg);
space();
summaryRowEnd();
trEnd();
protected void addPackageUse(PackageDoc pkg, Content contentTree) throws IOException {
Content tdFirst = HtmlTree.TD(HtmlStyle.colFirst,
getHyperLink("", pkg.name(), new StringContent(Util.getPackageName(pkg))));
contentTree.addContent(tdFirst);
HtmlTree tdLast = new HtmlTree(HtmlTag.TD);
tdLast.addStyle(HtmlStyle.colLast);
if (pkg != null)
addSummaryComment(pkg, tdLast);
else
tdLast.addContent(getSpace());
contentTree.addContent(tdLast);
}
/**
* Print the class use list.
* Add the class use information.
*
* @param pkg the package that uses the given class
* @param contentTree the content tree to which the class use information will be added
*/
protected void generateClassUse(PackageDoc pkg) throws IOException {
protected void addClassUse(PackageDoc pkg, Content contentTree) throws IOException {
String classLink = getLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_CLASS_USE_HEADER, classdoc, false));
String pkgLink = getPackageLink(pkg, Util.getPackageName(pkg), false);
classSubWriter.printUseInfo(pkgToClassAnnotations.get(pkg.name()),
String pkgLink = getPackageLinkString(pkg, Util.getPackageName(pkg), false);
classSubWriter.addUseInfo(pkgToClassAnnotations.get(pkg.name()),
configuration.getText("doclet.ClassUse_Annotation", classLink,
pkgLink), classUseTableSummary);
classSubWriter.printUseInfo(pkgToClassTypeParameter.get(pkg.name()),
pkgLink), classUseTableSummary, contentTree);
classSubWriter.addUseInfo(pkgToClassTypeParameter.get(pkg.name()),
configuration.getText("doclet.ClassUse_TypeParameter", classLink,
pkgLink), classUseTableSummary);
classSubWriter.printUseInfo(pkgToSubclass.get(pkg.name()),
pkgLink), classUseTableSummary, contentTree);
classSubWriter.addUseInfo(pkgToSubclass.get(pkg.name()),
configuration.getText("doclet.ClassUse_Subclass", classLink,
pkgLink), subclassUseTableSummary);
classSubWriter.printUseInfo(pkgToSubinterface.get(pkg.name()),
pkgLink), subclassUseTableSummary, contentTree);
classSubWriter.addUseInfo(pkgToSubinterface.get(pkg.name()),
configuration.getText("doclet.ClassUse_Subinterface", classLink,
pkgLink), subinterfaceUseTableSummary);
classSubWriter.printUseInfo(pkgToImplementingClass.get(pkg.name()),
pkgLink), subinterfaceUseTableSummary, contentTree);
classSubWriter.addUseInfo(pkgToImplementingClass.get(pkg.name()),
configuration.getText("doclet.ClassUse_ImplementingClass", classLink,
pkgLink), classUseTableSummary);
fieldSubWriter.printUseInfo(pkgToField.get(pkg.name()),
pkgLink), classUseTableSummary, contentTree);
fieldSubWriter.addUseInfo(pkgToField.get(pkg.name()),
configuration.getText("doclet.ClassUse_Field", classLink,
pkgLink), fieldUseTableSummary);
fieldSubWriter.printUseInfo(pkgToFieldAnnotations.get(pkg.name()),
pkgLink), fieldUseTableSummary, contentTree);
fieldSubWriter.addUseInfo(pkgToFieldAnnotations.get(pkg.name()),
configuration.getText("doclet.ClassUse_FieldAnnotations", classLink,
pkgLink), fieldUseTableSummary);
fieldSubWriter.printUseInfo(pkgToFieldTypeParameter.get(pkg.name()),
pkgLink), fieldUseTableSummary, contentTree);
fieldSubWriter.addUseInfo(pkgToFieldTypeParameter.get(pkg.name()),
configuration.getText("doclet.ClassUse_FieldTypeParameter", classLink,
pkgLink), fieldUseTableSummary);
methodSubWriter.printUseInfo(pkgToMethodAnnotations.get(pkg.name()),
pkgLink), fieldUseTableSummary, contentTree);
methodSubWriter.addUseInfo(pkgToMethodAnnotations.get(pkg.name()),
configuration.getText("doclet.ClassUse_MethodAnnotations", classLink,
pkgLink), methodUseTableSummary);
methodSubWriter.printUseInfo(pkgToMethodParameterAnnotations.get(pkg.name()),
pkgLink), methodUseTableSummary, contentTree);
methodSubWriter.addUseInfo(pkgToMethodParameterAnnotations.get(pkg.name()),
configuration.getText("doclet.ClassUse_MethodParameterAnnotations", classLink,
pkgLink), methodUseTableSummary);
methodSubWriter.printUseInfo(pkgToMethodTypeParameter.get(pkg.name()),
pkgLink), methodUseTableSummary, contentTree);
methodSubWriter.addUseInfo(pkgToMethodTypeParameter.get(pkg.name()),
configuration.getText("doclet.ClassUse_MethodTypeParameter", classLink,
pkgLink), methodUseTableSummary);
methodSubWriter.printUseInfo(pkgToMethodReturn.get(pkg.name()),
pkgLink), methodUseTableSummary, contentTree);
methodSubWriter.addUseInfo(pkgToMethodReturn.get(pkg.name()),
configuration.getText("doclet.ClassUse_MethodReturn", classLink,
pkgLink), methodUseTableSummary);
methodSubWriter.printUseInfo(pkgToMethodReturnTypeParameter.get(pkg.name()),
pkgLink), methodUseTableSummary, contentTree);
methodSubWriter.addUseInfo(pkgToMethodReturnTypeParameter.get(pkg.name()),
configuration.getText("doclet.ClassUse_MethodReturnTypeParameter", classLink,
pkgLink), methodUseTableSummary);
methodSubWriter.printUseInfo(pkgToMethodArgs.get(pkg.name()),
pkgLink), methodUseTableSummary, contentTree);
methodSubWriter.addUseInfo(pkgToMethodArgs.get(pkg.name()),
configuration.getText("doclet.ClassUse_MethodArgs", classLink,
pkgLink), methodUseTableSummary);
methodSubWriter.printUseInfo(pkgToMethodArgTypeParameter.get(pkg.name()),
pkgLink), methodUseTableSummary, contentTree);
methodSubWriter.addUseInfo(pkgToMethodArgTypeParameter.get(pkg.name()),
configuration.getText("doclet.ClassUse_MethodArgsTypeParameters", classLink,
pkgLink), methodUseTableSummary);
methodSubWriter.printUseInfo(pkgToMethodThrows.get(pkg.name()),
pkgLink), methodUseTableSummary, contentTree);
methodSubWriter.addUseInfo(pkgToMethodThrows.get(pkg.name()),
configuration.getText("doclet.ClassUse_MethodThrows", classLink,
pkgLink), methodUseTableSummary);
constrSubWriter.printUseInfo(pkgToConstructorAnnotations.get(pkg.name()),
pkgLink), methodUseTableSummary, contentTree);
constrSubWriter.addUseInfo(pkgToConstructorAnnotations.get(pkg.name()),
configuration.getText("doclet.ClassUse_ConstructorAnnotations", classLink,
pkgLink), constructorUseTableSummary);
constrSubWriter.printUseInfo(pkgToConstructorParameterAnnotations.get(pkg.name()),
pkgLink), constructorUseTableSummary, contentTree);
constrSubWriter.addUseInfo(pkgToConstructorParameterAnnotations.get(pkg.name()),
configuration.getText("doclet.ClassUse_ConstructorParameterAnnotations", classLink,
pkgLink), constructorUseTableSummary);
constrSubWriter.printUseInfo(pkgToConstructorArgs.get(pkg.name()),
pkgLink), constructorUseTableSummary, contentTree);
constrSubWriter.addUseInfo(pkgToConstructorArgs.get(pkg.name()),
configuration.getText("doclet.ClassUse_ConstructorArgs", classLink,
pkgLink), constructorUseTableSummary);
constrSubWriter.printUseInfo(pkgToConstructorArgTypeParameter.get(pkg.name()),
pkgLink), constructorUseTableSummary, contentTree);
constrSubWriter.addUseInfo(pkgToConstructorArgTypeParameter.get(pkg.name()),
configuration.getText("doclet.ClassUse_ConstructorArgsTypeParameters", classLink,
pkgLink), constructorUseTableSummary);
constrSubWriter.printUseInfo(pkgToConstructorThrows.get(pkg.name()),
pkgLink), constructorUseTableSummary, contentTree);
constrSubWriter.addUseInfo(pkgToConstructorThrows.get(pkg.name()),
configuration.getText("doclet.ClassUse_ConstructorThrows", classLink,
pkgLink), constructorUseTableSummary);
pkgLink), constructorUseTableSummary, contentTree);
}
/**
* Print the header for the class use Listing.
* Get the header for the class use Listing.
*
* @return a content tree representing the class use header
*/
protected void printClassUseHeader() {
protected Content getClassUseHeader() {
String cltype = configuration.getText(classdoc.isInterface()?
"doclet.Interface":
"doclet.Class");
"doclet.Interface":"doclet.Class");
String clname = classdoc.qualifiedName();
printHtmlHeader(configuration.getText("doclet.Window_ClassUse_Header",
cltype, clname), null, true);
printTop();
navLinks(true);
hr();
center();
h2();
strongText("doclet.ClassUse_Title", cltype, clname);
h2End();
centerEnd();
String title = configuration.getText("doclet.Window_ClassUse_Header",
cltype, clname);
Content bodyTree = getBody(true, getWindowTitle(title));
addTop(bodyTree);
addNavLinks(true, bodyTree);
Content headContent = getResource("doclet.ClassUse_Title", cltype, clname);
Content heading = HtmlTree.HEADING(HtmlConstants.CLASS_PAGE_HEADING,
true, HtmlStyle.title, headContent);
Content div = HtmlTree.DIV(HtmlStyle.header, heading);
bodyTree.addContent(div);
return bodyTree;
}
/**
* Print the footer for the class use Listing.
* Get this package link.
*
* @return a content tree for the package link
*/
protected void printClassUseFooter() {
hr();
navLinks(false);
printBottom();
printBodyHtmlEnd();
}
/**
* Print this package link
*/
protected void navLinkPackage() {
navCellStart();
printHyperLink("../package-summary.html", "",
configuration.getText("doclet.Package"), true, "NavBarFont1");
navCellEnd();
protected Content getNavLinkPackage() {
Content linkContent = getHyperLink("../package-summary.html", "",
packageLabel);
Content li = HtmlTree.LI(linkContent);
return li;
}
/**
* Print class page indicator
* Get class page link.
*
* @return a content tree for the class page link
*/
protected void navLinkClass() {
navCellStart();
printLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_CLASS_USE_HEADER, classdoc, "",
configuration.getText("doclet.Class"), true, "NavBarFont1"));
navCellEnd();
protected Content getNavLinkClass() {
Content linkContent = new RawHtml(getLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_CLASS_USE_HEADER, classdoc, "",
configuration.getText("doclet.Class"), false)));
Content li = HtmlTree.LI(linkContent);
return li;
}
/**
* Print class use link
* Get the use link.
*
* @return a content tree for the use link
*/
protected void navLinkClassUse() {
navCellRevStart();
fontStyle("NavBarFont1Rev");
strongText("doclet.navClassUse");
fontEnd();
navCellEnd();
protected Content getNavLinkClassUse() {
Content li = HtmlTree.LI(HtmlStyle.navBarCell1Rev, useLabel);
return li;
}
protected void navLinkTree() {
navCellStart();
if (classdoc.containingPackage().isIncluded()) {
printHyperLink("../package-tree.html", "",
configuration.getText("doclet.Tree"), true, "NavBarFont1");
} else {
printHyperLink(relativePath + "overview-tree.html", "",
configuration.getText("doclet.Tree"), true, "NavBarFont1");
/**
* Get the tree link.
*
* @return a content tree for the tree link
*/
protected Content getNavLinkTree() {
Content linkContent = classdoc.containingPackage().isIncluded() ?
getHyperLink("../package-tree.html", "", treeLabel) :
getHyperLink(relativePath + "overview-tree.html", "", treeLabel);
Content li = HtmlTree.LI(linkContent);
return li;
}
navCellEnd();
}
}

585
langtools/src/share/classes/com/sun/tools/doclets/formats/html/ClassWriterImpl.java
View file

@ -32,6 +32,7 @@ import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.builders.*;
import com.sun.tools.doclets.internal.toolkit.taglets.*;
import com.sun.tools.doclets.formats.html.markup.*;
/**
* Generate the Class Information Page.
@ -43,6 +44,7 @@ import com.sun.tools.doclets.internal.toolkit.taglets.*;
*
* @author Atul M Dambalkar
* @author Robert Field
* @author Bhavesh Patel (Modified)
*/
public class ClassWriterImpl extends SubWriterHolderWriter
implements ClassWriter {
@ -76,124 +78,173 @@ public class ClassWriterImpl extends SubWriterHolderWriter
}
/**
* Print this package link
* Get this package link.
*
* @return a content tree for the package link
*/
protected void navLinkPackage() {
navCellStart();
printHyperLink("package-summary.html", "",
configuration.getText("doclet.Package"), true, "NavBarFont1");
navCellEnd();
protected Content getNavLinkPackage() {
Content linkContent = getHyperLink("package-summary.html", "",
packageLabel);
Content li = HtmlTree.LI(linkContent);
return li;
}
/**
* Print class page indicator
* Get the class link.
*
* @return a content tree for the class link
*/
protected void navLinkClass() {
navCellRevStart();
fontStyle("NavBarFont1Rev");
strongText("doclet.Class");
fontEnd();
navCellEnd();
protected Content getNavLinkClass() {
Content li = HtmlTree.LI(HtmlStyle.navBarCell1Rev, classLabel);
return li;
}
/**
* Print class use link
* Get the class use link.
*
* @return a content tree for the class use link
*/
protected void navLinkClassUse() {
navCellStart();
printHyperLink("class-use/" + filename, "",
configuration.getText("doclet.navClassUse"), true, "NavBarFont1");
navCellEnd();
protected Content getNavLinkClassUse() {
Content linkContent = getHyperLink("class-use/" + filename, "", useLabel);
Content li = HtmlTree.LI(linkContent);
return li;
}
/**
* Print previous package link
* Get link to previous class.
*
* @return a content tree for the previous class link
*/
protected void navLinkPrevious() {
if (prev == null) {
printText("doclet.Prev_Class");
} else {
printLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_CLASS, prev, "",
configuration.getText("doclet.Prev_Class"), true));
public Content getNavLinkPrevious() {
Content li;
if (prev != null) {
Content prevLink = new RawHtml(getLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_CLASS, prev, "",
configuration.getText("doclet.Prev_Class"), true)));
li = HtmlTree.LI(prevLink);
}
else
li = HtmlTree.LI(prevclassLabel);
return li;
}
/**
* Print next package link
* Get link to next class.
*
* @return a content tree for the next class link
*/
protected void navLinkNext() {
if (next == null) {
printText("doclet.Next_Class");
} else {
printLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_CLASS, next, "",
configuration.getText("doclet.Next_Class"), true));
public Content getNavLinkNext() {
Content li;
if (next != null) {
Content nextLink = new RawHtml(getLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_CLASS, next, "",
configuration.getText("doclet.Next_Class"), true)));
li = HtmlTree.LI(nextLink);
}
else
li = HtmlTree.LI(nextclassLabel);
return li;
}
/**
* {@inheritDoc}
*/
public void writeHeader(String header) {
public Content getHeader(String header) {
String pkgname = (classDoc.containingPackage() != null)?
classDoc.containingPackage().name(): "";
String clname = classDoc.name();
printHtmlHeader(clname,
configuration.metakeywords.getMetaKeywords(classDoc), true);
printTop();
navLinks(true);
hr();
println("<!-- ======== START OF CLASS DATA ======== -->");
h2();
Content bodyTree = getBody(true, getWindowTitle(clname));
addTop(bodyTree);
addNavLinks(true, bodyTree);
bodyTree.addContent(HtmlConstants.START_OF_CLASS_DATA);
HtmlTree div = new HtmlTree(HtmlTag.DIV);
div.addStyle(HtmlStyle.header);
if (pkgname.length() > 0) {
font("-1"); print(pkgname); fontEnd(); br();
Content pkgNameContent = new StringContent(pkgname);
Content pkgNamePara = HtmlTree.P(HtmlStyle.subTitle, pkgNameContent);
div.addContent(pkgNamePara);
}
LinkInfoImpl linkInfo = new LinkInfoImpl( LinkInfoImpl.CONTEXT_CLASS_HEADER,
classDoc, false);
//Let's not link to ourselves in the header.
linkInfo.linkToSelf = false;
print(header + getTypeParameterLinks(linkInfo));
h2End();
Content headerContent = new StringContent(header);
Content heading = HtmlTree.HEADING(HtmlConstants.CLASS_PAGE_HEADING, true,
HtmlStyle.title, headerContent);
heading.addContent(new RawHtml(getTypeParameterLinks(linkInfo)));
div.addContent(heading);
bodyTree.addContent(div);
return bodyTree;
}
/**
* {@inheritDoc}
*/
public void writeFooter() {
println("<!-- ========= END OF CLASS DATA ========= -->");
hr();
navLinks(false);
printBottom();
printBodyHtmlEnd();
public Content getClassContentHeader() {
return getContentHeader();
}
/**
* {@inheritDoc}
*/
public void writeClassSignature(String modifiers) {
public void addFooter(Content contentTree) {
contentTree.addContent(HtmlConstants.END_OF_CLASS_DATA);
addNavLinks(false, contentTree);
addBottom(contentTree);
}
/**
* {@inheritDoc}
*/
public void printDocument(Content contentTree) {
printHtmlDocument(configuration.metakeywords.getMetaKeywords(classDoc),
true, contentTree);
}
/**
* {@inheritDoc}
*/
public Content getClassInfoTreeHeader() {
return getMemberTreeHeader();
}
/**
* {@inheritDoc}
*/
public Content getClassInfo(Content classInfoTree) {
return getMemberTree(HtmlStyle.description, classInfoTree);
}
/**
* {@inheritDoc}
*/
public void addClassSignature(String modifiers, Content classInfoTree) {
boolean isInterface = classDoc.isInterface();
preNoNewLine();
writeAnnotationInfo(classDoc);
print(modifiers);
classInfoTree.addContent(new HtmlTree(HtmlTag.BR));
Content pre = new HtmlTree(HtmlTag.PRE);
addAnnotationInfo(classDoc, pre);
pre.addContent(modifiers);
LinkInfoImpl linkInfo = new LinkInfoImpl(
LinkInfoImpl.CONTEXT_CLASS_SIGNATURE, classDoc, false);
//Let's not link to ourselves in the signature.
linkInfo.linkToSelf = false;
String name = classDoc.name() +
getTypeParameterLinks(linkInfo);
Content name = new RawHtml (classDoc.name() +
getTypeParameterLinks(linkInfo));
if (configuration().linksource) {
printSrcLink(classDoc, name);
addSrcLink(classDoc, name, pre);
} else {
strong(name);
pre.addContent(HtmlTree.STRONG(name));
}
if (!isInterface) {
Type superclass = Util.getFirstVisibleSuperClass(classDoc,
configuration());
if (superclass != null) {
println();
print("extends ");
printLink(new LinkInfoImpl(
pre.addContent("\n");
pre.addContent("extends ");
Content link = new RawHtml(getLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_CLASS_SIGNATURE_PARENT_NAME,
superclass));
superclass)));
pre.addContent(link);
}
}
Type[] implIntfacs = classDoc.interfaceTypes();
@ -206,30 +257,29 @@ public class ClassWriterImpl extends SubWriterHolderWriter
continue;
}
if (counter == 0) {
println();
print(isInterface? "extends " : "implements ");
pre.addContent("\n");
pre.addContent(isInterface? "extends " : "implements ");
} else {
print(", ");
pre.addContent(", ");
}
printLink(new LinkInfoImpl(
Content link = new RawHtml(getLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_CLASS_SIGNATURE_PARENT_NAME,
implIntfacs[i]));
implIntfacs[i])));
pre.addContent(link);
counter++;
}
}
preEnd();
p();
classInfoTree.addContent(pre);
}
/**
* {@inheritDoc}
*/
public void writeClassDescription() {
public void addClassDescription(Content classInfoTree) {
if(!configuration.nocomment) {
// generate documentation for the class.
if (classDoc.inlineTags().length > 0) {
printInlineComment(classDoc);
p();
addInlineComment(classDoc, classInfoTree);
}
}
}
@ -237,117 +287,104 @@ public class ClassWriterImpl extends SubWriterHolderWriter
/**
* {@inheritDoc}
*/
public void writeClassTagInfo() {
public void addClassTagInfo(Content classInfoTree) {
if(!configuration.nocomment) {
// Print Information about all the tags here
printTags(classDoc);
hr();
p();
} else {
hr();
addTagsInfo(classDoc, classInfoTree);
}
}
/**
* {@inheritDoc}
*/
public void writeClassDeprecationInfo() {
hr();
Tag[] deprs = classDoc.tags("deprecated");
if (Util.isDeprecated(classDoc)) {
strongText("doclet.Deprecated");
if (deprs.length > 0) {
Tag[] commentTags = deprs[0].inlineTags();
if (commentTags.length > 0) {
space();
printInlineDeprecatedComment(classDoc, deprs[0]);
}
}
p();
}
}
/**
* Generate the indent and get the line image for the class tree.
* For user accessibility, the image includes the alt attribute
* "extended by". (This method is not intended for a class
* implementing an interface, where "implemented by" would be required.)
* Get the class hierarchy tree for the given class.
*
* indent integer indicating the number of spaces to indent
* @param type the class to print the hierarchy for
* @return a content tree for class inheritence
*/
private void writeStep(int indent) {
print(spaces(4 * indent - 2));
print("<IMG SRC=\"" + relativepathNoSlash + "/resources/inherit.gif\" " +
"ALT=\"" + configuration.getText("doclet.extended_by") + " \">");
}
/**
* Print the class hierarchy tree for the given class.
* @param type the class to print the hierarchy for.
* @return return the amount that should be indented in
* the next level of the tree.
*/
private int writeTreeForClassHelper(Type type) {
Type sup = Util.getFirstVisibleSuperClass(
private Content getClassInheritenceTree(Type type) {
Type sup;
HtmlTree classTreeUl = new HtmlTree(HtmlTag.UL);
classTreeUl.addStyle(HtmlStyle.inheritance);
Content liTree = null;
do {
sup = Util.getFirstVisibleSuperClass(
type instanceof ClassDoc ? (ClassDoc) type : type.asClassDoc(),
configuration());
int indent = 0;
if (sup != null) {
indent = writeTreeForClassHelper(sup);
writeStep(indent);
HtmlTree ul = new HtmlTree(HtmlTag.UL);
ul.addStyle(HtmlStyle.inheritance);
ul.addContent(getTreeForClassHelper(type));
if (liTree != null)
ul.addContent(liTree);
Content li = HtmlTree.LI(ul);
liTree = li;
type = sup;
}
else
classTreeUl.addContent(getTreeForClassHelper(type));
}
while (sup != null);
if (liTree != null)
classTreeUl.addContent(liTree);
return classTreeUl;
}
/**
* Get the class helper tree for the given class.
*
* @param type the class to print the helper for
* @return a content tree for class helper
*/
private Content getTreeForClassHelper(Type type) {
Content li = new HtmlTree(HtmlTag.LI);
if (type.equals(classDoc)) {
String typeParameters = getTypeParameterLinks(
new LinkInfoImpl(
LinkInfoImpl.CONTEXT_TREE,
new LinkInfoImpl(LinkInfoImpl.CONTEXT_TREE,
classDoc, false));
if (configuration.shouldExcludeQualifier(
classDoc.containingPackage().name())) {
strong(type.asClassDoc().name() + typeParameters);
li.addContent(type.asClassDoc().name());
li.addContent(new RawHtml(typeParameters));
} else {
strong(type.asClassDoc().qualifiedName() + typeParameters);
li.addContent(type.asClassDoc().qualifiedName());
li.addContent(new RawHtml(typeParameters));
}
} else {
print(getLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_CLASS_TREE_PARENT,
Content link = new RawHtml(getLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_CLASS_TREE_PARENT,
type instanceof ClassDoc ? (ClassDoc) type : type,
configuration.getClassName(type.asClassDoc()), false)));
li.addContent(link);
}
println();
return indent + 1;
return li;
}
/**
* Print the class hierarchy tree for this class only.
* {@inheritDoc}
*/
public void writeClassTree() {
public void addClassTree(Content classContentTree) {
if (!classDoc.isClass()) {
return;
}
pre();
writeTreeForClassHelper(classDoc);
preEnd();
classContentTree.addContent(getClassInheritenceTree(classDoc));
}
/**
* Write the type parameter information.
* {@inheritDoc}
*/
public void writeTypeParamInfo() {
public void addTypeParamInfo(Content classInfoTree) {
if (classDoc.typeParamTags().length > 0) {
dl();
dt();
TagletOutput output = (new ParamTaglet()).getTagletOutput(classDoc,
getTagletWriterInstance(false));
print(output.toString());
dtEnd();
dlEnd();
Content typeParam = new RawHtml(output.toString());
Content dl = HtmlTree.DL(typeParam);
classInfoTree.addContent(dl);
}
}
/**
* {@inheritDoc}
*/
public void writeSubClassInfo() {
public void addSubClassInfo(Content classInfoTree) {
if (classDoc.isClass()) {
if (classDoc.qualifiedName().equals("java.lang.Object") ||
classDoc.qualifiedName().equals("org.omg.CORBA.Object")) {
@ -355,13 +392,13 @@ public class ClassWriterImpl extends SubWriterHolderWriter
}
List<ClassDoc> subclasses = classtree.subs(classDoc, false);
if (subclasses.size() > 0) {
dl();
dt();
strongText("doclet.Subclasses");
dtEnd();
writeClassLinks(LinkInfoImpl.CONTEXT_SUBCLASSES,
subclasses);
dlEnd();
Content label = getResource(
"doclet.Subclasses");
Content dt = HtmlTree.DT(label);
Content dl = HtmlTree.DL(dt);
dl.addContent(getClassLinks(LinkInfoImpl.CONTEXT_SUBCLASSES,
subclasses));
classInfoTree.addContent(dl);
}
}
}
@ -369,25 +406,25 @@ public class ClassWriterImpl extends SubWriterHolderWriter
/**
* {@inheritDoc}
*/
public void writeSubInterfacesInfo() {
public void addSubInterfacesInfo(Content classInfoTree) {
if (classDoc.isInterface()) {
List<ClassDoc> subInterfaces = classtree.allSubs(classDoc, false);
if (subInterfaces.size() > 0) {
dl();
dt();
strongText("doclet.Subinterfaces");
dtEnd();
writeClassLinks(LinkInfoImpl.CONTEXT_SUBINTERFACES,
subInterfaces);
dlEnd();
Content label = getResource(
"doclet.Subinterfaces");
Content dt = HtmlTree.DT(label);
Content dl = HtmlTree.DL(dt);
dl.addContent(getClassLinks(LinkInfoImpl.CONTEXT_SUBINTERFACES,
subInterfaces));
classInfoTree.addContent(dl);
}
}
}
/**
* If this is the interface which are the classes, that implement this?
* {@inheritDoc}
*/
public void writeInterfaceUsageInfo () {
public void addInterfaceUsageInfo (Content classInfoTree) {
if (! classDoc.isInterface()) {
return;
}
@ -397,105 +434,160 @@ public class ClassWriterImpl extends SubWriterHolderWriter
}
List<ClassDoc> implcl = classtree.implementingclasses(classDoc);
if (implcl.size() > 0) {
dl();
dt();
strongText("doclet.Implementing_Classes");
dtEnd();
writeClassLinks(LinkInfoImpl.CONTEXT_IMPLEMENTED_CLASSES,
implcl);
dlEnd();
Content label = getResource(
"doclet.Implementing_Classes");
Content dt = HtmlTree.DT(label);
Content dl = HtmlTree.DL(dt);
dl.addContent(getClassLinks(LinkInfoImpl.CONTEXT_IMPLEMENTED_CLASSES,
implcl));
classInfoTree.addContent(dl);
}
}
/**
* {@inheritDoc}
*/
public void writeImplementedInterfacesInfo() {
public void addImplementedInterfacesInfo(Content classInfoTree) {
//NOTE: we really should be using ClassDoc.interfaceTypes() here, but
// it doesn't walk up the tree like we want it to.
List<Type> interfaceArray = Util.getAllInterfaces(classDoc, configuration);
if (classDoc.isClass() && interfaceArray.size() > 0) {
dl();
dt();
strongText("doclet.All_Implemented_Interfaces");
dtEnd();
writeClassLinks(LinkInfoImpl.CONTEXT_IMPLEMENTED_INTERFACES,
interfaceArray);
dlEnd();
Content label = getResource(
"doclet.All_Implemented_Interfaces");
Content dt = HtmlTree.DT(label);
Content dl = HtmlTree.DL(dt);
dl.addContent(getClassLinks(LinkInfoImpl.CONTEXT_IMPLEMENTED_INTERFACES,
interfaceArray));
classInfoTree.addContent(dl);
}
}
/**
* {@inheritDoc}
*/
public void writeSuperInterfacesInfo() {
public void addSuperInterfacesInfo(Content classInfoTree) {
//NOTE: we really should be using ClassDoc.interfaceTypes() here, but
// it doesn't walk up the tree like we want it to.
List<Type> interfaceArray = Util.getAllInterfaces(classDoc, configuration);
if (classDoc.isInterface() && interfaceArray.size() > 0) {
dl();
dt();
strongText("doclet.All_Superinterfaces");
dtEnd();
writeClassLinks(LinkInfoImpl.CONTEXT_SUPER_INTERFACES,
interfaceArray);
dlEnd();
Content label = getResource(
"doclet.All_Superinterfaces");
Content dt = HtmlTree.DT(label);
Content dl = HtmlTree.DL(dt);
dl.addContent(getClassLinks(LinkInfoImpl.CONTEXT_SUPER_INTERFACES,
interfaceArray));
classInfoTree.addContent(dl);
}
}
/**
* Generate links to the given classes.
* {@inheritDoc}
*/
private void writeClassLinks(int context, List<?> list) {
public void addNestedClassInfo(Content classInfoTree) {
ClassDoc outerClass = classDoc.containingClass();
if (outerClass != null) {
Content label;
if (outerClass.isInterface()) {
label = getResource(
"doclet.Enclosing_Interface");
} else {
label = getResource(
"doclet.Enclosing_Class");
}
Content dt = HtmlTree.DT(label);
Content dl = HtmlTree.DL(dt);
Content dd = new HtmlTree(HtmlTag.DD);
dd.addContent(new RawHtml(getLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_CLASS, outerClass,
false))));
dl.addContent(dd);
classInfoTree.addContent(dl);
}
}
/**
* {@inheritDoc}
*/
public void addClassDeprecationInfo(Content classInfoTree) {
Content hr = new HtmlTree(HtmlTag.HR);
classInfoTree.addContent(hr);
Tag[] deprs = classDoc.tags("deprecated");
if (Util.isDeprecated(classDoc)) {
Content strong = HtmlTree.STRONG(deprecatedPhrase);
Content div = HtmlTree.DIV(HtmlStyle.block, strong);
if (deprs.length > 0) {
Tag[] commentTags = deprs[0].inlineTags();
if (commentTags.length > 0) {
div.addContent(getSpace());
addInlineDeprecatedComment(classDoc, deprs[0], div);
}
}
classInfoTree.addContent(div);
}
}
/**
* Get links to the given classes.
*
* @param context the id of the context where the link will be printed
* @param list the list of classes
* @return a content tree for the class list
*/
private Content getClassLinks(int context, List<?> list) {
Object[] typeList = list.toArray();
//Sort the list to be printed.
print(' ');
dd();
Content dd = new HtmlTree(HtmlTag.DD);
for (int i = 0; i < list.size(); i++) {
if (i > 0) {
print(", ");
Content separator = new StringContent(", ");
dd.addContent(separator);
}
if (typeList[i] instanceof ClassDoc) {
printLink(new LinkInfoImpl(context, (ClassDoc)(typeList[i])));
Content link = new RawHtml(getLink(
new LinkInfoImpl(context, (ClassDoc)(typeList[i]))));
dd.addContent(link);
} else {
printLink(new LinkInfoImpl(context, (Type)(typeList[i])));
Content link = new RawHtml(getLink(
new LinkInfoImpl(context, (Type)(typeList[i]))));
dd.addContent(link);
}
}
ddEnd();
return dd;
}
protected void navLinkTree() {
navCellStart();
printHyperLink("package-tree.html", "",
configuration.getText("doclet.Tree"), true, "NavBarFont1");
navCellEnd();
/**
* {@inheritDoc}
*/
protected Content getNavLinkTree() {
Content treeLinkContent = getHyperLink("package-tree.html",
"", treeLabel, "", "");
Content li = HtmlTree.LI(treeLinkContent);
return li;
}
protected void printSummaryDetailLinks() {
/**
* Add summary details to the navigation bar.
*
* @param subDiv the content tree to which the summary detail links will be added
*/
protected void addSummaryDetailLinks(Content subDiv) {
try {
tr();
tdVAlignClass("top", "NavBarCell3");
font("-2");
print(" ");
navSummaryLinks();
fontEnd();
tdEnd();
tdVAlignClass("top", "NavBarCell3");
font("-2");
navDetailLinks();
fontEnd();
tdEnd();
trEnd();
Content div = HtmlTree.DIV(getNavSummaryLinks());
div.addContent(getNavDetailLinks());
subDiv.addContent(div);
} catch (Exception e) {
e.printStackTrace();
throw new DocletAbortException();
}
}
protected void navSummaryLinks() throws Exception {
printText("doclet.Summary");
space();
/**
* Get summary links for navigation bar.
*
* @return the content tree for the navigation summary links
*/
protected Content getNavSummaryLinks() throws Exception {
Content li = HtmlTree.LI(summaryLabel);
li.addContent(getSpace());
Content ulNav = HtmlTree.UL(HtmlStyle.subNavList, li);
MemberSummaryBuilder memberSummaryBuilder = (MemberSummaryBuilder)
configuration.getBuilderFactory().getMemberSummaryBuilder(this);
String[] navLinkLabels = new String[] {
@ -503,6 +595,7 @@ public class ClassWriterImpl extends SubWriterHolderWriter
"doclet.navMethod"
};
for (int i = 0; i < navLinkLabels.length; i++ ) {
Content liNav = new HtmlTree(HtmlTag.LI);
if (i == VisibleMemberMap.ENUM_CONSTANTS && ! classDoc.isEnum()) {
continue;
}
@ -513,27 +606,29 @@ public class ClassWriterImpl extends SubWriterHolderWriter
((AbstractMemberWriter) memberSummaryBuilder.
getMemberSummaryWriter(i));
if (writer == null) {
printText(navLinkLabels[i]);
liNav.addContent(getResource(navLinkLabels[i]));
} else {
writer.navSummaryLink(
writer.addNavSummaryLink(
memberSummaryBuilder.members(i),
memberSummaryBuilder.getVisibleMemberMap(i));
memberSummaryBuilder.getVisibleMemberMap(i), liNav);
}
if (i < navLinkLabels.length-1) {
navGap();
addNavGap(liNav);
}
ulNav.addContent(liNav);
}
return ulNav;
}
/**
* Method navDetailLinks
*
* @throws Exception
* Get detail links for the navigation bar.
*
* @return the content tree for the detail links
*/
protected void navDetailLinks() throws Exception {
printText("doclet.Detail");
space();
protected Content getNavDetailLinks() throws Exception {
Content li = HtmlTree.LI(detailLabel);
li.addContent(getSpace());
Content ulNav = HtmlTree.UL(HtmlStyle.subNavList, li);
MemberSummaryBuilder memberSummaryBuilder = (MemberSummaryBuilder)
configuration.getBuilderFactory().getMemberSummaryBuilder(this);
String[] navLinkLabels = new String[] {
@ -541,6 +636,7 @@ public class ClassWriterImpl extends SubWriterHolderWriter
"doclet.navMethod"
};
for (int i = 1; i < navLinkLabels.length; i++ ) {
Content liNav = new HtmlTree(HtmlTag.LI);
AbstractMemberWriter writer =
((AbstractMemberWriter) memberSummaryBuilder.
getMemberSummaryWriter(i));
@ -551,43 +647,27 @@ public class ClassWriterImpl extends SubWriterHolderWriter
continue;
}
if (writer == null) {
printText(navLinkLabels[i]);
liNav.addContent(getResource(navLinkLabels[i]));
} else {
writer.navDetailLink(memberSummaryBuilder.members(i));
writer.addNavDetailLink(memberSummaryBuilder.members(i), liNav);
}
if (i < navLinkLabels.length - 1) {
navGap();
addNavGap(liNav);
}
ulNav.addContent(liNav);
}
}
protected void navGap() {
space();
print('|');
space();
return ulNav;
}
/**
* If this is an inner class or interface, write the enclosing class or
* interface.
* Add gap between navigation bar elements.
*
* @param liNav the content tree to which the gap will be added
*/
public void writeNestedClassInfo() {
ClassDoc outerClass = classDoc.containingClass();
if (outerClass != null) {
dl();
dt();
if (outerClass.isInterface()) {
strongText("doclet.Enclosing_Interface");
} else {
strongText("doclet.Enclosing_Class");
}
dtEnd();
dd();
printLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_CLASS, outerClass,
false));
ddEnd();
dlEnd();
}
protected void addNavGap(Content liNav) {
liNav.addContent(getSpace());
liNav.addContent("|");
liNav.addContent(getSpace());
}
/**
@ -598,11 +678,4 @@ public class ClassWriterImpl extends SubWriterHolderWriter
public ClassDoc getClassDoc() {
return classDoc;
}
/**
* {@inheritDoc}
*/
public void completeMemberSummaryBuild() {
p();
}
}

306
langtools/src/share/classes/com/sun/tools/doclets/formats/html/ConstantsSummaryWriterImpl.java
View file

@ -25,11 +25,12 @@
package com.sun.tools.doclets.formats.html;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.javadoc.*;
import java.io.*;
import java.util.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.formats.html.markup.*;
/**
* Write the Constants Summary Page in HTML format.
@ -76,67 +77,106 @@ public class ConstantsSummaryWriterImpl extends HtmlDocletWriter
/**
* {@inheritDoc}
*/
public void writeHeader() {
printHtmlHeader(configuration.getText("doclet.Constants_Summary"),
null, true);
printTop();
navLinks(true);
hr();
center();
h1(); printText("doclet.Constants_Summary"); h1End();
centerEnd();
hr(4, "noshade");
public Content getHeader() {
String label = configuration.getText("doclet.Constants_Summary");
Content bodyTree = getBody(true, getWindowTitle(label));
addTop(bodyTree);
addNavLinks(true, bodyTree);
return bodyTree;
}
/**
* {@inheritDoc}
*/
public void writeFooter() {
hr();
navLinks(false);
printBottom();
printBodyHtmlEnd();
public Content getContentsHeader() {
return new HtmlTree(HtmlTag.UL);
}
/**
* {@inheritDoc}
*/
public void writeContentsHeader() {
strong(configuration.getText("doclet.Contents"));
ul();
}
/**
* {@inheritDoc}
*/
public void writeContentsFooter() {
ulEnd();
println();
}
/**
* {@inheritDoc}
*/
public void writeLinkToPackageContent(PackageDoc pkg, String parsedPackageName, Set<String> printedPackageHeaders) {
public void addLinkToPackageContent(PackageDoc pkg, String parsedPackageName,
Set<String> printedPackageHeaders, Content contentListTree) {
String packageName = pkg.name();
//add link to summary
li();
Content link;
if (packageName.length() == 0) {
printHyperLink("#" + DocletConstants.UNNAMED_PACKAGE_ANCHOR,
DocletConstants.DEFAULT_PACKAGE_NAME);
link = getHyperLink("#" + DocletConstants.UNNAMED_PACKAGE_ANCHOR,
"", defaultPackageLabel, "", "");
} else {
printHyperLink("#" + parsedPackageName, parsedPackageName + ".*");
Content packageNameContent = getPackageLabel(parsedPackageName);
packageNameContent.addContent(".*");
link = getHyperLink("#" + parsedPackageName,
"", packageNameContent, "", "");
printedPackageHeaders.add(parsedPackageName);
}
println();
contentListTree.addContent(HtmlTree.LI(link));
}
/**
* {@inheritDoc}
*/
public void writeConstantMembersHeader(ClassDoc cd) {
public Content getContentsList(Content contentListTree) {
Content titleContent = getResource(
"doclet.Constants_Summary");
Content pHeading = HtmlTree.HEADING(HtmlConstants.TITLE_HEADING, true,
HtmlStyle.title, titleContent);
Content div = HtmlTree.DIV(HtmlStyle.header, pHeading);
Content headingContent = getResource(
"doclet.Contents");
div.addContent(HtmlTree.HEADING(HtmlConstants.CONTENT_HEADING, true,
headingContent));
div.addContent(contentListTree);
return div;
}
/**
* {@inheritDoc}
*/
public Content getConstantSummaries() {
HtmlTree summariesDiv = new HtmlTree(HtmlTag.DIV);
summariesDiv.addStyle(HtmlStyle.constantValuesContainer);
return summariesDiv;
}
/**
* {@inheritDoc}
*/
public void addPackageName(PackageDoc pkg, String parsedPackageName,
Content summariesTree) {
Content pkgNameContent;
if (parsedPackageName.length() == 0) {
summariesTree.addContent(getMarkerAnchor(
DocletConstants.UNNAMED_PACKAGE_ANCHOR));
pkgNameContent = defaultPackageLabel;
} else {
summariesTree.addContent(getMarkerAnchor(
parsedPackageName));
pkgNameContent = getPackageLabel(parsedPackageName);
}
Content headingContent = new StringContent(".*");
Content heading = HtmlTree.HEADING(HtmlConstants.PACKAGE_HEADING, true,
pkgNameContent);
heading.addContent(headingContent);
summariesTree.addContent(heading);
}
/**
* {@inheritDoc}
*/
public Content getClassConstantHeader() {
HtmlTree ul = new HtmlTree(HtmlTag.UL);
ul.addStyle(HtmlStyle.blockList);
return ul;
}
/**
* Get the table caption and header for the constant summary table
*
* @param cd classdoc to be documented
* @return constant members header content
*/
public Content getConstantMembersHeader(ClassDoc cd) {
//generate links backward only to public classes.
String classlink = (cd.isPublic() || cd.isProtected())?
getLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_CONSTANT_SUMMARY, cd,
@ -144,112 +184,120 @@ public class ConstantsSummaryWriterImpl extends HtmlDocletWriter
cd.qualifiedName();
String name = cd.containingPackage().name();
if (name.length() > 0) {
writeClassName(name + "." + classlink);
return getClassName(name + "." + classlink);
} else {
writeClassName(classlink);
return getClassName(classlink);
}
}
/**
* Get the class name in the table caption and the table header.
*
* @param classStr the class name to print.
* @return the table caption and header
*/
protected Content getClassName(String classStr) {
Content table = HtmlTree.TABLE(0, 3, 0, constantsTableSummary,
getTableCaption(classStr));
table.addContent(getSummaryTableHeader(constantsTableHeader, "col"));
return table;
}
/**
* {@inheritDoc}
*/
public void writeConstantMembersFooter(ClassDoc cd) {
tableFooter(false);
p();
}
/**
* Print the class name in the table heading.
* @param classStr the heading to print.
*/
protected void writeClassName(String classStr) {
table(1, 3, 0, constantsTableSummary);
tableSubCaptionStart();
write(classStr);
tableCaptionEnd();
summaryTableHeader(constantsTableHeader, "col");
}
private void tableFooter(boolean isHeader) {
fontEnd();
if (isHeader) {
thEnd();
} else {
tdEnd();
}
trEnd();
tableEnd();
p();
}
/**
* {@inheritDoc}
*/
public void writePackageName(PackageDoc pkg, String parsedPackageName) {
String pkgname;
if (parsedPackageName.length() == 0) {
anchor(DocletConstants.UNNAMED_PACKAGE_ANCHOR);
pkgname = DocletConstants.DEFAULT_PACKAGE_NAME;
} else {
anchor(parsedPackageName);
pkgname = parsedPackageName;
}
table(1, "100%", 3, 0);
trBgcolorStyle("#CCCCFF", "TableHeadingColor");
thAlign("left");
font("+2");
write(pkgname + ".*");
tableFooter(true);
}
/**
* {@inheritDoc}
*/
public void writeConstantMembers(ClassDoc cd, List<FieldDoc> fields) {
public void addConstantMembers(ClassDoc cd, List<FieldDoc> fields,
Content classConstantTree) {
currentClassDoc = cd;
Content tbody = new HtmlTree(HtmlTag.TBODY);
for (int i = 0; i < fields.size(); ++i) {
writeConstantMember(fields.get(i));
HtmlTree tr = new HtmlTree(HtmlTag.TR);
if (i%2 == 0)
tr.addStyle(HtmlStyle.altColor);
else
tr.addStyle(HtmlStyle.rowColor);
addConstantMember(fields.get(i), tr);
tbody.addContent(tr);
}
Content table = getConstantMembersHeader(cd);
table.addContent(tbody);
Content li = HtmlTree.LI(HtmlStyle.blockList, table);
classConstantTree.addContent(li);
}
private void writeConstantMember(FieldDoc member) {
trBgcolorStyle("white", "TableRowColor");
anchor(currentClassDoc.qualifiedName() + "." + member.name());
writeTypeColumn(member);
writeNameColumn(member);
writeValue(member);
trEnd();
/**
* Add the row for the constant summary table.
*
* @param member the field to be documented.
* @param trTree an htmltree object for the table row
*/
private void addConstantMember(FieldDoc member, HtmlTree trTree) {
trTree.addContent(getTypeColumn(member));
trTree.addContent(getNameColumn(member));
trTree.addContent(getValue(member));
}
private void writeTypeColumn(FieldDoc member) {
tdAlign("right");
font("-1");
code();
/**
* Get the type column for the constant summary table row.
*
* @param member the field to be documented.
* @return the type column of the constant table row
*/
private Content getTypeColumn(FieldDoc member) {
Content anchor = getMarkerAnchor(currentClassDoc.qualifiedName() +
"." + member.name());
Content tdType = HtmlTree.TD(HtmlStyle.colFirst, anchor);
Content code = new HtmlTree(HtmlTag.CODE);
StringTokenizer mods = new StringTokenizer(member.modifiers());
while(mods.hasMoreTokens()) {
print(mods.nextToken() + "&nbsp;");
Content modifier = new StringContent(mods.nextToken());
code.addContent(modifier);
code.addContent(getSpace());
}
printLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_CONSTANT_SUMMARY,
member.type()));
codeEnd();
fontEnd();
tdEnd();
Content type = new RawHtml(getLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_CONSTANT_SUMMARY, member.type())));
code.addContent(type);
tdType.addContent(code);
return tdType;
}
private void writeNameColumn(FieldDoc member) {
tdAlign("left");
code();
printDocLink(LinkInfoImpl.CONTEXT_CONSTANT_SUMMARY, member,
member.name(), false);
codeEnd();
tdEnd();
/**
* Get the name column for the constant summary table row.
*
* @param member the field to be documented.
* @return the name column of the constant table row
*/
private Content getNameColumn(FieldDoc member) {
Content nameContent = new RawHtml(getDocLink(
LinkInfoImpl.CONTEXT_CONSTANT_SUMMARY, member, member.name(), false));
Content code = HtmlTree.CODE(nameContent);
return HtmlTree.TD(code);
}
private void writeValue(FieldDoc member) {
tdAlign("right");
code();
print(Util.escapeHtmlChars(member.constantValueExpression()));
codeEnd();
tdEnd();
/**
* Get the value column for the constant summary table row.
*
* @param member the field to be documented.
* @return the value column of the constant table row
*/
private Content getValue(FieldDoc member) {
Content valueContent = new StringContent(member.constantValueExpression());
Content code = HtmlTree.CODE(valueContent);
return HtmlTree.TD(HtmlStyle.colLast, code);
}
/**
* {@inheritDoc}
*/
public void addFooter(Content contentTree) {
addNavLinks(false, contentTree);
addBottom(contentTree);
}
/**
* {@inheritDoc}
*/
public void printDocument(Content contentTree) {
printHtmlDocument(null, true, contentTree);
}
}

285
langtools/src/share/classes/com/sun/tools/doclets/formats/html/ConstructorWriterImpl.java
View file

@ -29,6 +29,7 @@ import java.io.*;
import java.util.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.formats.html.markup.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
@ -43,7 +44,6 @@ public class ConstructorWriterImpl extends AbstractExecutableMemberWriter
implements ConstructorWriter, MemberSummaryWriter {
private boolean foundNonPubConstructor = false;
private boolean printedSummaryHeader = false;
/**
* Construct a new ConstructorWriterImpl.
@ -75,125 +75,112 @@ public class ConstructorWriterImpl extends AbstractExecutableMemberWriter
}
/**
* Write the constructors summary header for the given class.
*
* @param classDoc the class the summary belongs to.
* {@inheritDoc}
*/
public void writeMemberSummaryHeader(ClassDoc classDoc) {
printedSummaryHeader = true;
writer.println();
writer.println("<!-- ======== CONSTRUCTOR SUMMARY ======== -->");
writer.println();
writer.printSummaryHeader(this, classDoc);
public Content getMemberSummaryHeader(ClassDoc classDoc,
Content memberSummaryTree) {
memberSummaryTree.addContent(HtmlConstants.START_OF_CONSTRUCTOR_SUMMARY);
Content memberTree = writer.getMemberTreeHeader();
writer.addSummaryHeader(this, classDoc, memberTree);
return memberTree;
}
/**
* Write the constructors summary footer for the given class.
*
* @param classDoc the class the summary belongs to.
* {@inheritDoc}
*/
public void writeMemberSummaryFooter(ClassDoc classDoc) {
writer.printSummaryFooter(this, classDoc);
public Content getConstructorDetailsTreeHeader(ClassDoc classDoc,
Content memberDetailsTree) {
memberDetailsTree.addContent(HtmlConstants.START_OF_CONSTRUCTOR_DETAILS);
Content constructorDetailsTree = writer.getMemberTreeHeader();
constructorDetailsTree.addContent(writer.getMarkerAnchor("constructor_detail"));
Content heading = HtmlTree.HEADING(HtmlConstants.DETAILS_HEADING,
writer.constructorDetailsLabel);
constructorDetailsTree.addContent(heading);
return constructorDetailsTree;
}
/**
* Write the header for the constructor documentation.
*
* @param classDoc the class that the constructors belong to.
* {@inheritDoc}
*/
public void writeHeader(ClassDoc classDoc, String header) {
writer.println();
writer.println("<!-- ========= CONSTRUCTOR DETAIL ======== -->");
writer.println();
writer.anchor("constructor_detail");
writer.printTableHeadingBackground(header);
}
/**
* Write the constructor header for the given constructor.
*
* @param constructor the constructor being documented.
* @param isFirst the flag to indicate whether or not the constructor is the
* first to be documented.
*/
public void writeConstructorHeader(ConstructorDoc constructor, boolean isFirst) {
if (! isFirst) {
writer.printMemberHeader();
}
writer.println();
public Content getConstructorDocTreeHeader(ConstructorDoc constructor,
Content constructorDetailsTree) {
String erasureAnchor;
if ((erasureAnchor = getErasureAnchor(constructor)) != null) {
writer.anchor(erasureAnchor);
constructorDetailsTree.addContent(writer.getMarkerAnchor((erasureAnchor)));
}
writer.anchor(constructor);
writer.h3();
writer.print(constructor.name());
writer.h3End();
constructorDetailsTree.addContent(
writer.getMarkerAnchor(writer.getAnchor(constructor)));
Content constructorDocTree = writer.getMemberTreeHeader();
Content heading = new HtmlTree(HtmlConstants.MEMBER_HEADING);
heading.addContent(constructor.name());
constructorDocTree.addContent(heading);
return constructorDocTree;
}
/**
* Write the signature for the given constructor.
*
* @param constructor the constructor being documented.
* {@inheritDoc}
*/
public void writeSignature(ConstructorDoc constructor) {
public Content getSignature(ConstructorDoc constructor) {
writer.displayLength = 0;
writer.pre();
writer.writeAnnotationInfo(constructor);
printModifiers(constructor);
//printReturnType((ConstructorDoc)constructor);
Content pre = new HtmlTree(HtmlTag.PRE);
writer.addAnnotationInfo(constructor, pre);
addModifiers(constructor, pre);
if (configuration().linksource) {
writer.printSrcLink(constructor, constructor.name());
Content constructorName = new StringContent(constructor.name());
writer.addSrcLink(constructor, constructorName, pre);
} else {
strong(constructor.name());
addName(constructor.name(), pre);
}
writeParameters(constructor);
writeExceptions(constructor);
writer.preEnd();
assert !writer.getMemberDetailsListPrinted();
addParameters(constructor, pre);
addExceptions(constructor, pre);
return pre;
}
/**
* Write the deprecated output for the given constructor.
*
* @param constructor the constructor being documented.
* {@inheritDoc}
*/
public void writeDeprecated(ConstructorDoc constructor) {
printDeprecated(constructor);
@Override
public void setSummaryColumnStyle(HtmlTree tdTree) {
if (foundNonPubConstructor)
tdTree.addStyle(HtmlStyle.colLast);
else
tdTree.addStyle(HtmlStyle.colOne);
}
/**
* Write the comments for the given constructor.
*
* @param constructor the constructor being documented.
* {@inheritDoc}
*/
public void writeComments(ConstructorDoc constructor) {
printComment(constructor);
public void addDeprecated(ConstructorDoc constructor, Content constructorDocTree) {
addDeprecatedInfo(constructor, constructorDocTree);
}
/**
* Write the tag output for the given constructor.
*
* @param constructor the constructor being documented.
* {@inheritDoc}
*/
public void writeTags(ConstructorDoc constructor) {
writer.printTags(constructor);
public void addComments(ConstructorDoc constructor, Content constructorDocTree) {
addComment(constructor, constructorDocTree);
}
/**
* Write the constructor footer.
* {@inheritDoc}
*/
public void writeConstructorFooter() {
printMemberFooter();
public void addTags(ConstructorDoc constructor, Content constructorDocTree) {
writer.addTagsInfo(constructor, constructorDocTree);
}
/**
* Write the footer for the constructor documentation.
*
* @param classDoc the class that the constructors belong to.
* {@inheritDoc}
*/
public void writeFooter(ClassDoc classDoc) {
//No footer to write for constructor documentation
public Content getConstructorDetails(Content constructorDetailsTree) {
return getMemberTree(constructorDetailsTree);
}
/**
* {@inheritDoc}
*/
public Content getConstructorDoc(Content constructorDocTree,
boolean isLastContent) {
return getMemberTree(constructorDocTree, isLastContent);
}
/**
@ -212,17 +199,35 @@ public class ConstructorWriterImpl extends AbstractExecutableMemberWriter
this.foundNonPubConstructor = foundNonPubConstructor;
}
public void printSummaryLabel() {
writer.printText("doclet.Constructor_Summary");
/**
* {@inheritDoc}
*/
public void addSummaryLabel(Content memberTree) {
Content label = HtmlTree.HEADING(HtmlConstants.SUMMARY_HEADING,
writer.getResource("doclet.Constructor_Summary"));
memberTree.addContent(label);
}
public void printTableSummary() {
writer.tableIndexSummary(configuration().getText("doclet.Member_Table_Summary",
/**
* {@inheritDoc}
*/
public String getTableSummary() {
return configuration().getText("doclet.Member_Table_Summary",
configuration().getText("doclet.Constructor_Summary"),
configuration().getText("doclet.constructors")));
configuration().getText("doclet.constructors"));
}
public void printSummaryTableHeader(ProgramElementDoc member) {
/**
* {@inheritDoc}
*/
public String getCaption() {
return configuration().getText("doclet.Constructors");
}
/**
* {@inheritDoc}
*/
public String[] getSummaryTableHeader(ProgramElementDoc member) {
String[] header;
if (foundNonPubConstructor) {
header = new String[] {
@ -239,87 +244,73 @@ public class ConstructorWriterImpl extends AbstractExecutableMemberWriter
configuration().getText("doclet.Description"))
};
}
writer.summaryTableHeader(header, "col");
return header;
}
public void printSummaryAnchor(ClassDoc cd) {
writer.anchor("constructor_summary");
/**
* {@inheritDoc}
*/
public void addSummaryAnchor(ClassDoc cd, Content memberTree) {
memberTree.addContent(writer.getMarkerAnchor("constructor_summary"));
}
public void printInheritedSummaryAnchor(ClassDoc cd) {
} // no such
/**
* {@inheritDoc}
*/
public void addInheritedSummaryAnchor(ClassDoc cd, Content inheritedTree) {
}
public void printInheritedSummaryLabel(ClassDoc cd) {
// no such
/**
* {@inheritDoc}
*/
public void addInheritedSummaryLabel(ClassDoc cd, Content inheritedTree) {
}
public int getMemberKind() {
return VisibleMemberMap.CONSTRUCTORS;
}
protected void navSummaryLink(List<?> members) {
printNavSummaryLink(classdoc,
members.size() > 0? true: false);
}
protected void printNavSummaryLink(ClassDoc cd, boolean link) {
if (link) {
writer.printHyperLink("", "constructor_summary",
ConfigurationImpl.getInstance().getText("doclet.navConstructor"));
} else {
writer.printText("doclet.navConstructor");
}
}
protected void printNavDetailLink(boolean link) {
if (link) {
writer.printHyperLink("", "constructor_detail",
ConfigurationImpl.getInstance().getText("doclet.navConstructor"));
} else {
writer.printText("doclet.navConstructor");
}
}
protected void printSummaryType(ProgramElementDoc member) {
if (foundNonPubConstructor) {
writer.printTypeSummaryHeader();
if (member.isProtected()) {
print("protected ");
} else if (member.isPrivate()) {
print("private ");
} else if (member.isPublic()) {
writer.space();
} else {
writer.printText("doclet.Package_private");
}
writer.printTypeSummaryFooter();
}
}
/**
* Write the inherited member summary header for the given class.
*
* @param classDoc the class the summary belongs to.
* {@inheritDoc}
*/
public void writeInheritedMemberSummaryHeader(ClassDoc classDoc) {
if(! printedSummaryHeader){
//We don't want inherited summary to not be under heading.
writeMemberSummaryHeader(classDoc);
writeMemberSummaryFooter(classDoc);
printedSummaryHeader = true;
protected Content getNavSummaryLink(ClassDoc cd, boolean link) {
if (link) {
return writer.getHyperLink("", "constructor_summary",
writer.getResource("doclet.navConstructor"));
} else {
return writer.getResource("doclet.navConstructor");
}
}
/**
* {@inheritDoc}
*/
public void writeInheritedMemberSummary(ClassDoc classDoc,
ProgramElementDoc member, boolean isFirst, boolean isLast) {}
protected void addNavDetailLink(boolean link, Content liNav) {
if (link) {
liNav.addContent(writer.getHyperLink("", "constructor_detail",
writer.getResource("doclet.navConstructor")));
} else {
liNav.addContent(writer.getResource("doclet.navConstructor"));
}
}
/**
* Write the inherited member summary footer for the given class.
*
* @param classDoc the class the summary belongs to.
* {@inheritDoc}
*/
public void writeInheritedMemberSummaryFooter(ClassDoc classDoc) {}
protected void addSummaryType(ProgramElementDoc member, Content tdSummaryType) {
if (foundNonPubConstructor) {
Content code = new HtmlTree(HtmlTag.CODE);
if (member.isProtected()) {
code.addContent("protected ");
} else if (member.isPrivate()) {
code.addContent("private ");
} else if (member.isPublic()) {
code.addContent(writer.getSpace());
} else {
code.addContent(
configuration().getText("doclet.Package_private"));
}
tdSummaryType.addContent(code);
}
}
}

130
langtools/src/share/classes/com/sun/tools/doclets/formats/html/DeprecatedListWriter.java
View file

@ -25,9 +25,11 @@
package com.sun.tools.doclets.formats.html;
import java.io.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.util.DeprecatedAPIListBuilder;
import com.sun.tools.doclets.internal.toolkit.util.*;
import java.io.*;
import com.sun.tools.doclets.formats.html.markup.*;
/**
* Generate File to list all the deprecated classes and class members with the
@ -125,28 +127,21 @@ public class DeprecatedListWriter extends SubWriterHolderWriter {
}
/**
* Print the deprecated API list. Separately print all class kinds and
* member kinds.
* Generate the deprecated API list.
*
* @param deprapi list of deprecated API built already.
*/
protected void generateDeprecatedListFile(DeprecatedAPIListBuilder deprapi)
throws IOException {
writeHeader();
strong(configuration.getText("doclet.Contents"));
ul();
for (int i = 0; i < DeprecatedAPIListBuilder.NUM_TYPES; i++) {
writeIndexLink(deprapi, i);
}
ulEnd();
println();
Content body = getHeader();
body.addContent(getContentsList(deprapi));
String memberTableSummary;
String[] memberTableHeader = new String[1];
HtmlTree div = new HtmlTree(HtmlTag.DIV);
div.addStyle(HtmlStyle.contentContainer);
for (int i = 0; i < DeprecatedAPIListBuilder.NUM_TYPES; i++) {
if (deprapi.hasDocumentation(i)) {
writeAnchor(deprapi, i);
addAnchor(deprapi, i, div);
memberTableSummary =
configuration.getText("doclet.Member_Table_Summary",
configuration.getText(HEADING_KEYS[i]),
@ -154,66 +149,87 @@ public class DeprecatedListWriter extends SubWriterHolderWriter {
memberTableHeader[0] = configuration.getText("doclet.0_and_1",
configuration.getText(HEADER_KEYS[i]),
configuration.getText("doclet.Description"));
writers[i].printDeprecatedAPI(deprapi.getList(i),
HEADING_KEYS[i], memberTableSummary, memberTableHeader);
writers[i].addDeprecatedAPI(deprapi.getList(i),
HEADING_KEYS[i], memberTableSummary, memberTableHeader, div);
}
}
printDeprecatedFooter();
body.addContent(div);
addNavLinks(false, body);
addBottom(body);
printHtmlDocument(null, true, body);
}
private void writeIndexLink(DeprecatedAPIListBuilder builder,
int type) {
/**
* Add the index link.
*
* @param builder the deprecated list builder
* @param type the type of list being documented
* @param contentTree the content tree to which the index link will be added
*/
private void addIndexLink(DeprecatedAPIListBuilder builder,
int type, Content contentTree) {
if (builder.hasDocumentation(type)) {
li();
printHyperLink("#" + ANCHORS[type],
configuration.getText(HEADING_KEYS[type]));
println();
Content li = HtmlTree.LI(getHyperLink("#" + ANCHORS[type],
getResource(HEADING_KEYS[type])));
contentTree.addContent(li);
}
}
private void writeAnchor(DeprecatedAPIListBuilder builder, int type) {
/**
* Get the contents list.
*
* @param deprapi the deprecated list builder
* @return a content tree for the contents list
*/
public Content getContentsList(DeprecatedAPIListBuilder deprapi) {
Content headContent = getResource("doclet.Deprecated_API");
Content heading = HtmlTree.HEADING(HtmlConstants.TITLE_HEADING, true,
HtmlStyle.title, headContent);
Content div = HtmlTree.DIV(HtmlStyle.header, heading);
Content headingContent = getResource("doclet.Contents");
div.addContent(HtmlTree.HEADING(HtmlConstants.CONTENT_HEADING, true,
headingContent));
Content ul = new HtmlTree(HtmlTag.UL);
for (int i = 0; i < DeprecatedAPIListBuilder.NUM_TYPES; i++) {
addIndexLink(deprapi, i, ul);
}
div.addContent(ul);
return div;
}
/**
* Add the anchor.
*
* @param builder the deprecated list builder
* @param type the type of list being documented
* @param contentTree the content tree to which the anchor will be added
*/
private void addAnchor(DeprecatedAPIListBuilder builder, int type, Content htmlTree) {
if (builder.hasDocumentation(type)) {
anchor(ANCHORS[type]);
htmlTree.addContent(getMarkerAnchor(ANCHORS[type]));
}
}
/**
* Print the navigation bar and header for the deprecated API Listing.
* Get the header for the deprecated API Listing.
*
* @return a content tree for the header
*/
protected void writeHeader() {
printHtmlHeader(configuration.getText("doclet.Window_Deprecated_List"),
null, true);
printTop();
navLinks(true);
hr();
center();
h2();
strongText("doclet.Deprecated_API");
h2End();
centerEnd();
hr(4, "noshade");
public Content getHeader() {
String title = configuration.getText("doclet.Window_Deprecated_List");
Content bodyTree = getBody(true, getWindowTitle(title));
addTop(bodyTree);
addNavLinks(true, bodyTree);
return bodyTree;
}
/**
* Print the navigation bar and the footer for the deprecated API Listing.
* Get the deprecated label.
*
* @return a content tree for the deprecated label
*/
protected void printDeprecatedFooter() {
hr();
navLinks(false);
printBottom();
printBodyHtmlEnd();
}
/**
* Highlight the word "Deprecated" in the navigation bar as this is the same
* page.
*/
protected void navLinkDeprecated() {
navCellRevStart();
fontStyle("NavBarFont1Rev");
strongText("doclet.navDeprecated");
fontEnd();
navCellEnd();
protected Content getNavLinkDeprecated() {
Content li = HtmlTree.LI(HtmlStyle.navBarCell1Rev, deprecatedLabel);
return li;
}
}

257
langtools/src/share/classes/com/sun/tools/doclets/formats/html/EnumConstantWriterImpl.java
View file

@ -28,6 +28,7 @@ package com.sun.tools.doclets.formats.html;
import java.io.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.formats.html.markup.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
@ -40,8 +41,6 @@ import com.sun.tools.doclets.internal.toolkit.util.*;
public class EnumConstantWriterImpl extends AbstractMemberWriter
implements EnumConstantWriter, MemberSummaryWriter {
private boolean printedSummaryHeader = false;
public EnumConstantWriterImpl(SubWriterHolderWriter writer,
ClassDoc classdoc) {
super(writer, classdoc);
@ -52,136 +51,98 @@ public class EnumConstantWriterImpl extends AbstractMemberWriter
}
/**
* Write the enum constant summary header for the given class.
*
* @param classDoc the class the summary belongs to.
* {@inheritDoc}
*/
public void writeMemberSummaryHeader(ClassDoc classDoc) {
printedSummaryHeader = true;
writer.println("<!-- =========== ENUM CONSTANT SUMMARY =========== -->");
writer.println();
writer.printSummaryHeader(this, classDoc);
}
/**
* Write the enum constant summary footer for the given class.
*
* @param classDoc the class the summary belongs to.
*/
public void writeMemberSummaryFooter(ClassDoc classDoc) {
writer.printSummaryFooter(this, classDoc);
}
/**
* Write the inherited enum constant summary header for the given class.
*
* @param classDoc the class the summary belongs to.
*/
public void writeInheritedMemberSummaryHeader(ClassDoc classDoc) {
if(! printedSummaryHeader){
//We don't want inherited summary to not be under heading.
writeMemberSummaryHeader(classDoc);
writeMemberSummaryFooter(classDoc);
printedSummaryHeader = true;
}
writer.printInheritedSummaryHeader(this, classDoc);
public Content getMemberSummaryHeader(ClassDoc classDoc,
Content memberSummaryTree) {
memberSummaryTree.addContent(HtmlConstants.START_OF_ENUM_CONSTANT_SUMMARY);
Content memberTree = writer.getMemberTreeHeader();
writer.addSummaryHeader(this, classDoc, memberTree);
return memberTree;
}
/**
* {@inheritDoc}
*/
public void writeInheritedMemberSummary(ClassDoc classDoc,
ProgramElementDoc enumConstant, boolean isFirst, boolean isLast) {
writer.printInheritedSummaryMember(this, classDoc, enumConstant, isFirst);
}
/**
* Write the inherited enum constant summary footer for the given class.
*
* @param classDoc the class the summary belongs to.
*/
public void writeInheritedMemberSummaryFooter(ClassDoc classDoc) {
writer.printInheritedSummaryFooter(this, classDoc);
public Content getEnumConstantsDetailsTreeHeader(ClassDoc classDoc,
Content memberDetailsTree) {
memberDetailsTree.addContent(HtmlConstants.START_OF_ENUM_CONSTANT_DETAILS);
Content enumConstantsDetailsTree = writer.getMemberTreeHeader();
enumConstantsDetailsTree.addContent(writer.getMarkerAnchor("enum_constant_detail"));
Content heading = HtmlTree.HEADING(HtmlConstants.DETAILS_HEADING,
writer.enumConstantsDetailsLabel);
enumConstantsDetailsTree.addContent(heading);
return enumConstantsDetailsTree;
}
/**
* {@inheritDoc}
*/
public void writeHeader(ClassDoc classDoc, String header) {
writer.println();
writer.println("<!-- ============ ENUM CONSTANT DETAIL =========== -->");
writer.println();
writer.anchor("enum_constant_detail");
writer.printTableHeadingBackground(header);
writer.println();
public Content getEnumConstantsTreeHeader(FieldDoc enumConstant,
Content enumConstantsDetailsTree) {
enumConstantsDetailsTree.addContent(
writer.getMarkerAnchor(enumConstant.name()));
Content enumConstantsTree = writer.getMemberTreeHeader();
Content heading = new HtmlTree(HtmlConstants.MEMBER_HEADING);
heading.addContent(enumConstant.name());
enumConstantsTree.addContent(heading);
return enumConstantsTree;
}
/**
* {@inheritDoc}
*/
public void writeEnumConstantHeader(FieldDoc enumConstant, boolean isFirst) {
if (! isFirst) {
writer.printMemberHeader();
writer.println("");
}
writer.anchor(enumConstant.name());
writer.h3();
writer.print(enumConstant.name());
writer.h3End();
}
/**
* {@inheritDoc}
*/
public void writeSignature(FieldDoc enumConstant) {
writer.pre();
writer.writeAnnotationInfo(enumConstant);
printModifiers(enumConstant);
writer.printLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_MEMBER,
enumConstant.type()));
print(' ');
public Content getSignature(FieldDoc enumConstant) {
Content pre = new HtmlTree(HtmlTag.PRE);
writer.addAnnotationInfo(enumConstant, pre);
addModifiers(enumConstant, pre);
Content enumConstantLink = new RawHtml(writer.getLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_MEMBER,
enumConstant.type())));
pre.addContent(enumConstantLink);
pre.addContent(" ");
if (configuration().linksource) {
writer.printSrcLink(enumConstant, enumConstant.name());
Content enumConstantName = new StringContent(enumConstant.name());
writer.addSrcLink(enumConstant, enumConstantName, pre);
} else {
strong(enumConstant.name());
addName(enumConstant.name(), pre);
}
writer.preEnd();
assert !writer.getMemberDetailsListPrinted();
return pre;
}
/**
* {@inheritDoc}
*/
public void writeDeprecated(FieldDoc enumConstant) {
printDeprecated(enumConstant);
public void addDeprecated(FieldDoc enumConstant, Content enumConstantsTree) {
addDeprecatedInfo(enumConstant, enumConstantsTree);
}
/**
* {@inheritDoc}
*/
public void writeComments(FieldDoc enumConstant) {
printComment(enumConstant);
public void addComments(FieldDoc enumConstant, Content enumConstantsTree) {
addComment(enumConstant, enumConstantsTree);
}
/**
* {@inheritDoc}
*/
public void writeTags(FieldDoc enumConstant) {
writer.printTags(enumConstant);
public void addTags(FieldDoc enumConstant, Content enumConstantsTree) {
writer.addTagsInfo(enumConstant, enumConstantsTree);
}
/**
* {@inheritDoc}
*/
public void writeEnumConstantFooter() {
printMemberFooter();
public Content getEnumConstantsDetails(Content enumConstantsDetailsTree) {
return getMemberTree(enumConstantsDetailsTree);
}
/**
* {@inheritDoc}
*/
public void writeFooter(ClassDoc classDoc) {
//No footer to write for enum constant documentation
public Content getEnumConstants(Content enumConstantsTree,
boolean isLastContent) {
return getMemberTree(enumConstantsTree, isLastContent);
}
/**
@ -195,75 +156,127 @@ public class EnumConstantWriterImpl extends AbstractMemberWriter
return VisibleMemberMap.ENUM_CONSTANTS;
}
public void printSummaryLabel() {
writer.printText("doclet.Enum_Constant_Summary");
/**
* {@inheritDoc}
*/
public void addSummaryLabel(Content memberTree) {
Content label = HtmlTree.HEADING(HtmlConstants.SUMMARY_HEADING,
writer.getResource("doclet.Enum_Constant_Summary"));
memberTree.addContent(label);
}
public void printTableSummary() {
writer.tableIndexSummary(configuration().getText("doclet.Member_Table_Summary",
/**
* {@inheritDoc}
*/
public String getTableSummary() {
return configuration().getText("doclet.Member_Table_Summary",
configuration().getText("doclet.Enum_Constant_Summary"),
configuration().getText("doclet.enum_constants")));
configuration().getText("doclet.enum_constants"));
}
public void printSummaryTableHeader(ProgramElementDoc member) {
/**
* {@inheritDoc}
*/
public String getCaption() {
return configuration().getText("doclet.Enum_Constants");
}
/**
* {@inheritDoc}
*/
public String[] getSummaryTableHeader(ProgramElementDoc member) {
String[] header = new String[] {
configuration().getText("doclet.0_and_1",
configuration().getText("doclet.Enum_Constant"),
configuration().getText("doclet.Description"))
};
writer.summaryTableHeader(header, "col");
return header;
}
public void printSummaryAnchor(ClassDoc cd) {
writer.anchor("enum_constant_summary");
/**
* {@inheritDoc}
*/
public void addSummaryAnchor(ClassDoc cd, Content memberTree) {
memberTree.addContent(writer.getMarkerAnchor("enum_constant_summary"));
}
public void printInheritedSummaryAnchor(ClassDoc cd) {
} // no such
public void printInheritedSummaryLabel(ClassDoc cd) {
// no such
/**
* {@inheritDoc}
*/
public void addInheritedSummaryAnchor(ClassDoc cd, Content inheritedTree) {
}
protected void writeSummaryLink(int context, ClassDoc cd, ProgramElementDoc member) {
writer.strong();
writer.printDocLink(context, (MemberDoc) member, member.name(), false);
writer.strongEnd();
/**
* {@inheritDoc}
*/
public void addInheritedSummaryLabel(ClassDoc cd, Content inheritedTree) {
}
protected void writeInheritedSummaryLink(ClassDoc cd,
ProgramElementDoc member) {
writer.printDocLink(LinkInfoImpl.CONTEXT_MEMBER, (MemberDoc)member,
member.name(), false);
/**
* {@inheritDoc}
*/
protected void addSummaryLink(int context, ClassDoc cd, ProgramElementDoc member,
Content tdSummary) {
Content strong = HtmlTree.STRONG(new RawHtml(
writer.getDocLink(context, (MemberDoc) member, member.name(), false)));
Content code = HtmlTree.CODE(strong);
tdSummary.addContent(code);
}
protected void printSummaryType(ProgramElementDoc member) {
/**
* {@inheritDoc}
*/
@Override
public void setSummaryColumnStyle(HtmlTree tdTree) {
tdTree.addStyle(HtmlStyle.colOne);
}
/**
* {@inheritDoc}
*/
protected void addInheritedSummaryLink(ClassDoc cd,
ProgramElementDoc member, Content linksTree) {
}
/**
* {@inheritDoc}
*/
protected void addSummaryType(ProgramElementDoc member, Content tdSummaryType) {
//Not applicable.
}
protected void writeDeprecatedLink(ProgramElementDoc member) {
writer.printDocLink(LinkInfoImpl.CONTEXT_MEMBER,
(MemberDoc) member, ((FieldDoc)member).qualifiedName(), false);
/**
* {@inheritDoc}
*/
protected Content getDeprecatedLink(ProgramElementDoc member) {
return writer.getDocLink(LinkInfoImpl.CONTEXT_MEMBER,
(MemberDoc) member, ((FieldDoc)member).qualifiedName());
}
protected void printNavSummaryLink(ClassDoc cd, boolean link) {
/**
* {@inheritDoc}
*/
protected Content getNavSummaryLink(ClassDoc cd, boolean link) {
if (link) {
writer.printHyperLink("", (cd == null)?
return writer.getHyperLink("", (cd == null)?
"enum_constant_summary":
"enum_constants_inherited_from_class_" +
configuration().getClassName(cd),
configuration().getText("doclet.navEnum"));
writer.getResource("doclet.navEnum"));
} else {
writer.printText("doclet.navEnum");
return writer.getResource("doclet.navEnum");
}
}
protected void printNavDetailLink(boolean link) {
/**
* {@inheritDoc}
*/
protected void addNavDetailLink(boolean link, Content liNav) {
if (link) {
writer.printHyperLink("", "enum_constant_detail",
configuration().getText("doclet.navEnum"));
liNav.addContent(writer.getHyperLink("", "enum_constant_detail",
writer.getResource("doclet.navEnum")));
} else {
writer.printText("doclet.navEnum");
liNav.addContent(writer.getResource("doclet.navEnum"));
}
}
}

321
langtools/src/share/classes/com/sun/tools/doclets/formats/html/FieldWriterImpl.java
View file

@ -28,6 +28,7 @@ package com.sun.tools.doclets.formats.html;
import java.io.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.formats.html.markup.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
@ -42,8 +43,6 @@ import com.sun.tools.doclets.internal.toolkit.util.*;
public class FieldWriterImpl extends AbstractMemberWriter
implements FieldWriter, MemberSummaryWriter {
private boolean printedSummaryHeader = false;
public FieldWriterImpl(SubWriterHolderWriter writer, ClassDoc classdoc) {
super(writer, classdoc);
}
@ -53,177 +52,118 @@ public class FieldWriterImpl extends AbstractMemberWriter
}
/**
* Write the fields summary header for the given class.
*
* @param classDoc the class the summary belongs to.
* {@inheritDoc}
*/
public void writeMemberSummaryHeader(ClassDoc classDoc) {
printedSummaryHeader = true;
writer.println("<!-- =========== FIELD SUMMARY =========== -->");
writer.println();
writer.printSummaryHeader(this, classDoc);
}
/**
* Write the fields summary footer for the given class.
*
* @param classDoc the class the summary belongs to.
*/
public void writeMemberSummaryFooter(ClassDoc classDoc) {
writer.tableEnd();
writer.space();
}
/**
* Write the inherited fields summary header for the given class.
*
* @param classDoc the class the summary belongs to.
*/
public void writeInheritedMemberSummaryHeader(ClassDoc classDoc) {
if(! printedSummaryHeader){
//We don't want inherited summary to not be under heading.
writeMemberSummaryHeader(classDoc);
writeMemberSummaryFooter(classDoc);
printedSummaryHeader = true;
}
writer.printInheritedSummaryHeader(this, classDoc);
public Content getMemberSummaryHeader(ClassDoc classDoc,
Content memberSummaryTree) {
memberSummaryTree.addContent(HtmlConstants.START_OF_FIELD_SUMMARY);
Content memberTree = writer.getMemberTreeHeader();
writer.addSummaryHeader(this, classDoc, memberTree);
return memberTree;
}
/**
* {@inheritDoc}
*/
public void writeInheritedMemberSummary(ClassDoc classDoc,
ProgramElementDoc field, boolean isFirst, boolean isLast) {
writer.printInheritedSummaryMember(this, classDoc, field, isFirst);
public Content getFieldDetailsTreeHeader(ClassDoc classDoc,
Content memberDetailsTree) {
memberDetailsTree.addContent(HtmlConstants.START_OF_FIELD_DETAILS);
Content fieldDetailsTree = writer.getMemberTreeHeader();
fieldDetailsTree.addContent(writer.getMarkerAnchor("field_detail"));
Content heading = HtmlTree.HEADING(HtmlConstants.DETAILS_HEADING,
writer.fieldDetailsLabel);
fieldDetailsTree.addContent(heading);
return fieldDetailsTree;
}
/**
* Write the inherited fields summary footer for the given class.
*
* @param classDoc the class the summary belongs to.
* {@inheritDoc}
*/
public void writeInheritedMemberSummaryFooter(ClassDoc classDoc) {
writer.printInheritedSummaryFooter(this, classDoc);
public Content getFieldDocTreeHeader(FieldDoc field,
Content fieldDetailsTree) {
fieldDetailsTree.addContent(
writer.getMarkerAnchor(field.name()));
Content fieldDocTree = writer.getMemberTreeHeader();
Content heading = new HtmlTree(HtmlConstants.MEMBER_HEADING);
heading.addContent(field.name());
fieldDocTree.addContent(heading);
return fieldDocTree;
}
/**
* Write the header for the field documentation.
*
* @param classDoc the class that the fields belong to.
* {@inheritDoc}
*/
public void writeHeader(ClassDoc classDoc, String header) {
writer.println();
writer.println("<!-- ============ FIELD DETAIL =========== -->");
writer.println();
writer.anchor("field_detail");
writer.printTableHeadingBackground(header);
writer.println();
}
/**
* Write the field header for the given field.
*
* @param field the field being documented.
* @param isFirst the flag to indicate whether or not the field is the
* first to be documented.
*/
public void writeFieldHeader(FieldDoc field, boolean isFirst) {
if (! isFirst) {
writer.printMemberHeader();
writer.println("");
}
writer.anchor(field.name());
writer.h3();
writer.print(field.name());
writer.h3End();
}
/**
* Write the signature for the given field.
*
* @param field the field being documented.
*/
public void writeSignature(FieldDoc field) {
writer.pre();
writer.writeAnnotationInfo(field);
printModifiers(field);
writer.printLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_MEMBER,
field.type()));
print(' ');
public Content getSignature(FieldDoc field) {
Content pre = new HtmlTree(HtmlTag.PRE);
writer.addAnnotationInfo(field, pre);
addModifiers(field, pre);
Content fieldlink = new RawHtml(writer.getLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_MEMBER,
field.type())));
pre.addContent(fieldlink);
pre.addContent(" ");
if (configuration().linksource) {
writer.printSrcLink(field, field.name());
Content fieldName = new StringContent(field.name());
writer.addSrcLink(field, fieldName, pre);
} else {
strong(field.name());
addName(field.name(), pre);
}
writer.preEnd();
assert !writer.getMemberDetailsListPrinted();
return pre;
}
/**
* Write the deprecated output for the given field.
*
* @param field the field being documented.
* {@inheritDoc}
*/
public void writeDeprecated(FieldDoc field) {
printDeprecated(field);
public void addDeprecated(FieldDoc field, Content fieldDocTree) {
addDeprecatedInfo(field, fieldDocTree);
}
/**
* Write the comments for the given field.
*
* @param field the field being documented.
* {@inheritDoc}
*/
public void writeComments(FieldDoc field) {
public void addComments(FieldDoc field, Content fieldDocTree) {
ClassDoc holder = field.containingClass();
if (field.inlineTags().length > 0) {
writer.printMemberDetailsListStartTag();
if (holder.equals(classdoc) ||
(! (holder.isPublic() || Util.isLinkable(holder, configuration())))) {
writer.dd();
writer.printInlineComment(field);
writer.ddEnd();
writer.addInlineComment(field, fieldDocTree);
} else {
String classlink = writer.codeText(
Content link = new RawHtml(
writer.getDocLink(LinkInfoImpl.CONTEXT_FIELD_DOC_COPY,
holder, field,
holder.isIncluded() ?
holder.typeName() : holder.qualifiedTypeName(),
false));
writer.dd();
writer.strong(configuration().getText(holder.isClass()?
"doclet.Description_From_Class" :
"doclet.Description_From_Interface", classlink));
writer.ddEnd();
writer.dd();
writer.printInlineComment(field);
writer.ddEnd();
Content codeLink = HtmlTree.CODE(link);
Content strong = HtmlTree.STRONG(holder.isClass()?
writer.descfrmClassLabel : writer.descfrmInterfaceLabel);
strong.addContent(writer.getSpace());
strong.addContent(codeLink);
fieldDocTree.addContent(HtmlTree.DIV(HtmlStyle.block, strong));
writer.addInlineComment(field, fieldDocTree);
}
}
}
/**
* Write the tag output for the given field.
*
* @param field the field being documented.
* {@inheritDoc}
*/
public void writeTags(FieldDoc field) {
writer.printTags(field);
public void addTags(FieldDoc field, Content fieldDocTree) {
writer.addTagsInfo(field, fieldDocTree);
}
/**
* Write the field footer.
* {@inheritDoc}
*/
public void writeFieldFooter() {
printMemberFooter();
public Content getFieldDetails(Content fieldDetailsTree) {
return getMemberTree(fieldDetailsTree);
}
/**
* Write the footer for the field documentation.
*
* @param classDoc the class that the fields belong to.
* {@inheritDoc}
*/
public void writeFooter(ClassDoc classDoc) {
//No footer to write for field documentation
public Content getFieldDoc(Content fieldDocTree,
boolean isLastContent) {
return getMemberTree(fieldDocTree, isLastContent);
}
/**
@ -237,85 +177,136 @@ public class FieldWriterImpl extends AbstractMemberWriter
return VisibleMemberMap.FIELDS;
}
public void printSummaryLabel() {
writer.printText("doclet.Field_Summary");
/**
* {@inheritDoc}
*/
public void addSummaryLabel(Content memberTree) {
Content label = HtmlTree.HEADING(HtmlConstants.SUMMARY_HEADING,
writer.getResource("doclet.Field_Summary"));
memberTree.addContent(label);
}
public void printTableSummary() {
writer.tableIndexSummary(configuration().getText("doclet.Member_Table_Summary",
/**
* {@inheritDoc}
*/
public String getTableSummary() {
return configuration().getText("doclet.Member_Table_Summary",
configuration().getText("doclet.Field_Summary"),
configuration().getText("doclet.fields")));
configuration().getText("doclet.fields"));
}
public void printSummaryTableHeader(ProgramElementDoc member) {
/**
* {@inheritDoc}
*/
public String getCaption() {
return configuration().getText("doclet.Fields");
}
/**
* {@inheritDoc}
*/
public String[] getSummaryTableHeader(ProgramElementDoc member) {
String[] header = new String[] {
writer.getModifierTypeHeader(),
configuration().getText("doclet.0_and_1",
configuration().getText("doclet.Field"),
configuration().getText("doclet.Description"))
};
writer.summaryTableHeader(header, "col");
return header;
}
public void printSummaryAnchor(ClassDoc cd) {
writer.anchor("field_summary");
/**
* {@inheritDoc}
*/
public void addSummaryAnchor(ClassDoc cd, Content memberTree) {
memberTree.addContent(writer.getMarkerAnchor("field_summary"));
}
public void printInheritedSummaryAnchor(ClassDoc cd) {
writer.anchor("fields_inherited_from_class_" + configuration().getClassName(cd));
/**
* {@inheritDoc}
*/
public void addInheritedSummaryAnchor(ClassDoc cd, Content inheritedTree) {
inheritedTree.addContent(writer.getMarkerAnchor(
"fields_inherited_from_class_" + configuration().getClassName(cd)));
}
public void printInheritedSummaryLabel(ClassDoc cd) {
String classlink = writer.getPreQualifiedClassLink(
LinkInfoImpl.CONTEXT_MEMBER, cd, false);
writer.strong();
String key = cd.isClass()?
"doclet.Fields_Inherited_From_Class" :
"doclet.Fields_Inherited_From_Interface";
writer.printText(key, classlink);
writer.strongEnd();
/**
* {@inheritDoc}
*/
public void addInheritedSummaryLabel(ClassDoc cd, Content inheritedTree) {
Content classLink = new RawHtml(writer.getPreQualifiedClassLink(
LinkInfoImpl.CONTEXT_MEMBER, cd, false));
Content label = new StringContent(cd.isClass() ?
configuration().getText("doclet.Fields_Inherited_From_Class") :
configuration().getText("doclet.Fields_Inherited_From_Interface"));
Content labelHeading = HtmlTree.HEADING(HtmlConstants.INHERITED_SUMMARY_HEADING,
label);
labelHeading.addContent(writer.getSpace());
labelHeading.addContent(classLink);
inheritedTree.addContent(labelHeading);
}
protected void writeSummaryLink(int context, ClassDoc cd, ProgramElementDoc member) {
writer.strong();
writer.printDocLink(context, cd , (MemberDoc) member, member.name(), false);
writer.strongEnd();
/**
* {@inheritDoc}
*/
protected void addSummaryLink(int context, ClassDoc cd, ProgramElementDoc member,
Content tdSummary) {
Content strong = HtmlTree.STRONG(new RawHtml(
writer.getDocLink(context, cd , (MemberDoc) member, member.name(), false)));
Content code = HtmlTree.CODE(strong);
tdSummary.addContent(code);
}
protected void writeInheritedSummaryLink(ClassDoc cd,
ProgramElementDoc member) {
writer.printDocLink(LinkInfoImpl.CONTEXT_MEMBER, cd, (MemberDoc)member,
member.name(), false);
/**
* {@inheritDoc}
*/
protected void addInheritedSummaryLink(ClassDoc cd,
ProgramElementDoc member, Content linksTree) {
linksTree.addContent(new RawHtml(
writer.getDocLink(LinkInfoImpl.CONTEXT_MEMBER, cd, (MemberDoc)member,
member.name(), false)));
}
protected void printSummaryType(ProgramElementDoc member) {
/**
* {@inheritDoc}
*/
protected void addSummaryType(ProgramElementDoc member, Content tdSummaryType) {
FieldDoc field = (FieldDoc)member;
printModifierAndType(field, field.type());
addModifierAndType(field, field.type(), tdSummaryType);
}
protected void writeDeprecatedLink(ProgramElementDoc member) {
writer.printDocLink(LinkInfoImpl.CONTEXT_MEMBER,
(MemberDoc) member, ((FieldDoc)member).qualifiedName(), false);
/**
* {@inheritDoc}
*/
protected Content getDeprecatedLink(ProgramElementDoc member) {
return writer.getDocLink(LinkInfoImpl.CONTEXT_MEMBER,
(MemberDoc) member, ((FieldDoc)member).qualifiedName());
}
protected void printNavSummaryLink(ClassDoc cd, boolean link) {
/**
* {@inheritDoc}
*/
protected Content getNavSummaryLink(ClassDoc cd, boolean link) {
if (link) {
writer.printHyperLink("", (cd == null)?
return writer.getHyperLink("", (cd == null)?
"field_summary":
"fields_inherited_from_class_" +
configuration().getClassName(cd),
configuration().getText("doclet.navField"));
writer.getResource("doclet.navField"));
} else {
writer.printText("doclet.navField");
return writer.getResource("doclet.navField");
}
}
protected void printNavDetailLink(boolean link) {
/**
* {@inheritDoc}
*/
protected void addNavDetailLink(boolean link, Content liNav) {
if (link) {
writer.printHyperLink("", "field_detail",
configuration().getText("doclet.navField"));
liNav.addContent(writer.getHyperLink("", "field_detail",
writer.getResource("doclet.navField")));
} else {
writer.printText("doclet.navField");
liNav.addContent(writer.getResource("doclet.navField"));
}
}
}

117
langtools/src/share/classes/com/sun/tools/doclets/formats/html/FrameOutputWriter.java
View file

@ -25,8 +25,10 @@
package com.sun.tools.doclets.formats.html;
import com.sun.tools.doclets.internal.toolkit.util.*;
import java.io.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.formats.html.markup.*;
/**
* Generate the documentation in the Html "frame" format in the browser. The
@ -47,6 +49,8 @@ public class FrameOutputWriter extends HtmlDocletWriter {
*/
int noOfPackages;
private final String SCROLL_YES = "yes";
/**
* Constructor to construct FrameOutputWriter object.
*
@ -86,82 +90,93 @@ public class FrameOutputWriter extends HtmlDocletWriter {
* as well as warning if browser is not supporting the Html frames.
*/
protected void generateFrameFile() {
Content frameset = getFrameDetails();
if (configuration.windowtitle.length() > 0) {
printFramesetHeader(configuration.windowtitle, configuration.notimestamp);
printFramesetDocument(configuration.windowtitle, configuration.notimestamp,
frameset);
} else {
printFramesetHeader(configuration.getText("doclet.Generated_Docs_Untitled"),
configuration.notimestamp);
printFramesetDocument(configuration.getText("doclet.Generated_Docs_Untitled"),
configuration.notimestamp, frameset);
}
printFrameDetails();
printFrameFooter();
}
/**
* Generate the code for issueing the warning for a non-frame capable web
* Add the code for issueing the warning for a non-frame capable web
* client. Also provide links to the non-frame version documentation.
*
* @param contentTree the content tree to which the non-frames information will be added
*/
protected void printFrameWarning() {
noFrames();
h2();
printText("doclet.Frame_Alert");
h2End();
p();
printText("doclet.Frame_Warning_Message");
br();
printText("doclet.Link_To");
printHyperLink(configuration.topFile,
configuration.getText("doclet.Non_Frame_Version"));
println("");
noFramesEnd();
protected void addFrameWarning(Content contentTree) {
Content noframes = new HtmlTree(HtmlTag.NOFRAMES);
Content noScript = HtmlTree.NOSCRIPT(
HtmlTree.DIV(getResource("doclet.No_Script_Message")));
noframes.addContent(noScript);
Content noframesHead = HtmlTree.HEADING(HtmlConstants.CONTENT_HEADING,
getResource("doclet.Frame_Alert"));
noframes.addContent(noframesHead);
Content p = HtmlTree.P(getResource("doclet.Frame_Warning_Message"));
noframes.addContent(p);
noframes.addContent(new HtmlTree(HtmlTag.BR));
noframes.addContent(getResource("doclet.Link_To"));
Content link = getHyperLink(configuration.topFile,
getResource("doclet.Non_Frame_Version"));
noframes.addContent(link);
contentTree.addContent(noframes);
}
/**
* Print the frame sizes and their contents.
* Get the frame sizes and their contents.
*
* @return a content tree for the frame details
*/
protected void printFrameDetails() {
// title attribute intentionally made empty so
// 508 tests will not flag it as missing
frameSet("cols=\"20%,80%\" title=\"\" onLoad=\"top.loadFrames()\"");
protected Content getFrameDetails() {
HtmlTree frameset = HtmlTree.FRAMESET("20%,80%", null, "Documentation frame",
"top.loadFrames()");
if (noOfPackages <= 1) {
printAllClassesFrameTag();
addAllClassesFrameTag(frameset);
} else if (noOfPackages > 1) {
frameSet("rows=\"30%,70%\" title=\"\" onLoad=\"top.loadFrames()\"");
printAllPackagesFrameTag();
printAllClassesFrameTag();
frameSetEnd();
HtmlTree leftFrameset = HtmlTree.FRAMESET(null, "30%,70%", "Left frames",
"top.loadFrames()");
addAllPackagesFrameTag(leftFrameset);
addAllClassesFrameTag(leftFrameset);
frameset.addContent(leftFrameset);
}
printClassFrameTag();
printFrameWarning();
frameSetEnd();
addClassFrameTag(frameset);
addFrameWarning(frameset);
return frameset;
}
/**
* Print the FRAME tag for the frame that lists all packages
* Add the FRAME tag for the frame that lists all packages.
*
* @param contentTree the content tree to which the information will be added
*/
private void printAllPackagesFrameTag() {
frame("src=\"overview-frame.html\" name=\"packageListFrame\""
+ " title=\"" + configuration.getText("doclet.All_Packages") + "\"");
private void addAllPackagesFrameTag(Content contentTree) {
HtmlTree frame = HtmlTree.FRAME("overview-frame.html", "packageListFrame",
configuration.getText("doclet.All_Packages"));
contentTree.addContent(frame);
}
/**
* Print the FRAME tag for the frame that lists all classes
* Add the FRAME tag for the frame that lists all classes.
*
* @param contentTree the content tree to which the information will be added
*/
private void printAllClassesFrameTag() {
frame("src=\"" + "allclasses-frame.html" + "\""
+ " name=\"packageFrame\""
+ " title=\"" + configuration.getText("doclet.All_classes_and_interfaces")
+ "\"");
private void addAllClassesFrameTag(Content contentTree) {
HtmlTree frame = HtmlTree.FRAME("allclasses-frame.html", "packageFrame",
configuration.getText("doclet.All_classes_and_interfaces"));
contentTree.addContent(frame);
}
/**
* Print the FRAME tag for the frame that describes the class in detail
* Add the FRAME tag for the frame that describes the class in detail.
*
* @param contentTree the content tree to which the information will be added
*/
private void printClassFrameTag() {
frame("src=\"" + configuration.topFile + "\""
+ " name=\"classFrame\""
+ " title=\""
+ configuration.getText("doclet.Package_class_and_interface_descriptions")
+ "\" scrolling=\"yes\"");
private void addClassFrameTag(Content contentTree) {
HtmlTree frame = HtmlTree.FRAME(configuration.topFile, "classFrame",
configuration.getText("doclet.Package_class_and_interface_descriptions"),
SCROLL_YES);
contentTree.addContent(frame);
}
}

333
langtools/src/share/classes/com/sun/tools/doclets/formats/html/HelpWriter.java
View file

@ -25,8 +25,10 @@
package com.sun.tools.doclets.formats.html;
import com.sun.tools.doclets.internal.toolkit.util.*;
import java.io.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.formats.html.markup.*;
/**
* Generate the Help File for the generated API documentation. The help file
@ -72,159 +74,242 @@ public class HelpWriter extends HtmlDocletWriter {
* Generate the help file contents.
*/
protected void generateHelpFile() {
printHtmlHeader(configuration.getText("doclet.Window_Help_title"),
null, true);
printTop();
navLinks(true); hr();
printHelpFileContents();
navLinks(false);
printBottom();
printBodyHtmlEnd();
String title = configuration.getText("doclet.Window_Help_title");
Content body = getBody(true, getWindowTitle(title));
addTop(body);
addNavLinks(true, body);
addHelpFileContents(body);
addNavLinks(false, body);
addBottom(body);
printHtmlDocument(null, true, body);
}
/**
* Print the help file contents from the resource file. While generating the
* Add the help file contents from the resource file to the content tree. While adding the
* help file contents it also keeps track of user options. If "-notree"
* is used, then the "overview-tree.html" will not get generated and hence
* help information also will not get generated.
* is used, then the "overview-tree.html" will not get added and hence
* help information also will not get added.
*
* @param contentTree the content tree to which the help file contents will be added
*/
protected void printHelpFileContents() {
center(); h1(); printText("doclet.Help_line_1"); h1End(); centerEnd();
printText("doclet.Help_line_2");
protected void addHelpFileContents(Content contentTree) {
Content heading = HtmlTree.HEADING(HtmlConstants.TITLE_HEADING, false, HtmlStyle.title,
getResource("doclet.Help_line_1"));
Content div = HtmlTree.DIV(HtmlStyle.header, heading);
Content line2 = HtmlTree.P(HtmlStyle.subTitle,
getResource("doclet.Help_line_2"));
div.addContent(line2);
contentTree.addContent(div);
HtmlTree ul = new HtmlTree(HtmlTag.UL);
ul.addStyle(HtmlStyle.blockList);
if (configuration.createoverview) {
h3(); printText("doclet.Overview"); h3End();
blockquote(); p();
printText("doclet.Help_line_3",
getHyperLink("overview-summary.html",
Content overviewHeading = HtmlTree.HEADING(HtmlConstants.CONTENT_HEADING,
getResource("doclet.Overview"));
Content liOverview = HtmlTree.LI(HtmlStyle.blockList, overviewHeading);
Content line3 = getResource("doclet.Help_line_3",
getHyperLinkString("overview-summary.html",
configuration.getText("doclet.Overview")));
blockquoteEnd();
Content overviewPara = HtmlTree.P(line3);
liOverview.addContent(overviewPara);
ul.addContent(liOverview);
}
h3(); printText("doclet.Package"); h3End();
blockquote(); p(); printText("doclet.Help_line_4");
ul();
li(); printText("doclet.Interfaces_Italic");
li(); printText("doclet.Classes");
li(); printText("doclet.Enums");
li(); printText("doclet.Exceptions");
li(); printText("doclet.Errors");
li(); printText("doclet.AnnotationTypes");
ulEnd();
blockquoteEnd();
h3(); printText("doclet.Help_line_5"); h3End();
blockquote(); p(); printText("doclet.Help_line_6");
ul();
li(); printText("doclet.Help_line_7");
li(); printText("doclet.Help_line_8");
li(); printText("doclet.Help_line_9");
li(); printText("doclet.Help_line_10");
li(); printText("doclet.Help_line_11");
li(); printText("doclet.Help_line_12");
p();
li(); printText("doclet.Nested_Class_Summary");
li(); printText("doclet.Field_Summary");
li(); printText("doclet.Constructor_Summary");
li(); printText("doclet.Method_Summary");
p();
li(); printText("doclet.Field_Detail");
li(); printText("doclet.Constructor_Detail");
li(); printText("doclet.Method_Detail");
ulEnd();
printText("doclet.Help_line_13");
blockquoteEnd();
Content packageHead = HtmlTree.HEADING(HtmlConstants.CONTENT_HEADING,
getResource("doclet.Package"));
Content liPackage = HtmlTree.LI(HtmlStyle.blockList, packageHead);
Content line4 = getResource("doclet.Help_line_4");
Content packagePara = HtmlTree.P(line4);
liPackage.addContent(packagePara);
HtmlTree ulPackage = new HtmlTree(HtmlTag.UL);
ulPackage.addContent(HtmlTree.LI(
getResource("doclet.Interfaces_Italic")));
ulPackage.addContent(HtmlTree.LI(
getResource("doclet.Classes")));
ulPackage.addContent(HtmlTree.LI(
getResource("doclet.Enums")));
ulPackage.addContent(HtmlTree.LI(
getResource("doclet.Exceptions")));
ulPackage.addContent(HtmlTree.LI(
getResource("doclet.Errors")));
ulPackage.addContent(HtmlTree.LI(
getResource("doclet.AnnotationTypes")));
liPackage.addContent(ulPackage);
ul.addContent(liPackage);
Content classHead = HtmlTree.HEADING(HtmlConstants.CONTENT_HEADING,
getResource("doclet.Help_line_5"));
Content liClass = HtmlTree.LI(HtmlStyle.blockList, classHead);
Content line6 = getResource("doclet.Help_line_6");
Content classPara = HtmlTree.P(line6);
liClass.addContent(classPara);
HtmlTree ul1 = new HtmlTree(HtmlTag.UL);
ul1.addContent(HtmlTree.LI(
getResource("doclet.Help_line_7")));
ul1.addContent(HtmlTree.LI(
getResource("doclet.Help_line_8")));
ul1.addContent(HtmlTree.LI(
getResource("doclet.Help_line_9")));
ul1.addContent(HtmlTree.LI(
getResource("doclet.Help_line_10")));
ul1.addContent(HtmlTree.LI(
getResource("doclet.Help_line_11")));
ul1.addContent(HtmlTree.LI(
getResource("doclet.Help_line_12")));
liClass.addContent(ul1);
HtmlTree ul2 = new HtmlTree(HtmlTag.UL);
ul2.addContent(HtmlTree.LI(
getResource("doclet.Nested_Class_Summary")));
ul2.addContent(HtmlTree.LI(
getResource("doclet.Field_Summary")));
ul2.addContent(HtmlTree.LI(
getResource("doclet.Constructor_Summary")));
ul2.addContent(HtmlTree.LI(
getResource("doclet.Method_Summary")));
liClass.addContent(ul2);
HtmlTree ul3 = new HtmlTree(HtmlTag.UL);
ul3.addContent(HtmlTree.LI(
getResource("doclet.Field_Detail")));
ul3.addContent(HtmlTree.LI(
getResource("doclet.Constructor_Detail")));
ul3.addContent(HtmlTree.LI(
getResource("doclet.Method_Detail")));
liClass.addContent(ul3);
Content line13 = getResource("doclet.Help_line_13");
Content para = HtmlTree.P(line13);
liClass.addContent(para);
ul.addContent(liClass);
//Annotation Types
blockquoteEnd();
h3(); printText("doclet.AnnotationType"); h3End();
blockquote(); p(); printText("doclet.Help_annotation_type_line_1");
ul();
li(); printText("doclet.Help_annotation_type_line_2");
li(); printText("doclet.Help_annotation_type_line_3");
li(); printText("doclet.Annotation_Type_Required_Member_Summary");
li(); printText("doclet.Annotation_Type_Optional_Member_Summary");
li(); printText("doclet.Annotation_Type_Member_Detail");
ulEnd();
blockquoteEnd();
Content aHead = HtmlTree.HEADING(HtmlConstants.CONTENT_HEADING,
getResource("doclet.AnnotationType"));
Content liAnnotation = HtmlTree.LI(HtmlStyle.blockList, aHead);
Content aline1 = getResource("doclet.Help_annotation_type_line_1");
Content aPara = HtmlTree.P(aline1);
liAnnotation.addContent(aPara);
HtmlTree aul = new HtmlTree(HtmlTag.UL);
aul.addContent(HtmlTree.LI(
getResource("doclet.Help_annotation_type_line_2")));
aul.addContent(HtmlTree.LI(
getResource("doclet.Help_annotation_type_line_3")));
aul.addContent(HtmlTree.LI(
getResource("doclet.Annotation_Type_Required_Member_Summary")));
aul.addContent(HtmlTree.LI(
getResource("doclet.Annotation_Type_Optional_Member_Summary")));
aul.addContent(HtmlTree.LI(
getResource("doclet.Annotation_Type_Member_Detail")));
liAnnotation.addContent(aul);
ul.addContent(liAnnotation);
//Enums
blockquoteEnd();
h3(); printText("doclet.Enum"); h3End();
blockquote(); p(); printText("doclet.Help_enum_line_1");
ul();
li(); printText("doclet.Help_enum_line_2");
li(); printText("doclet.Help_enum_line_3");
li(); printText("doclet.Enum_Constant_Summary");
li(); printText("doclet.Enum_Constant_Detail");
ulEnd();
blockquoteEnd();
Content enumHead = HtmlTree.HEADING(HtmlConstants.CONTENT_HEADING,
getResource("doclet.Enum"));
Content liEnum = HtmlTree.LI(HtmlStyle.blockList, enumHead);
Content eline1 = getResource("doclet.Help_enum_line_1");
Content enumPara = HtmlTree.P(eline1);
liEnum.addContent(enumPara);
HtmlTree eul = new HtmlTree(HtmlTag.UL);
eul.addContent(HtmlTree.LI(
getResource("doclet.Help_enum_line_2")));
eul.addContent(HtmlTree.LI(
getResource("doclet.Help_enum_line_3")));
eul.addContent(HtmlTree.LI(
getResource("doclet.Enum_Constant_Summary")));
eul.addContent(HtmlTree.LI(
getResource("doclet.Enum_Constant_Detail")));
liEnum.addContent(eul);
ul.addContent(liEnum);
if (configuration.classuse) {
h3(); printText("doclet.Help_line_14"); h3End();
blockquote();
printText("doclet.Help_line_15");
blockquoteEnd();
Content useHead = HtmlTree.HEADING(HtmlConstants.CONTENT_HEADING,
getResource("doclet.Help_line_14"));
Content liUse = HtmlTree.LI(HtmlStyle.blockList, useHead);
Content line15 = getResource("doclet.Help_line_15");
Content usePara = HtmlTree.P(line15);
liUse.addContent(usePara);
ul.addContent(liUse);
}
if (configuration.createtree) {
h3(); printText("doclet.Help_line_16"); h3End();
blockquote();
printText("doclet.Help_line_17_with_tree_link",
getHyperLink("overview-tree.html",
Content treeHead = HtmlTree.HEADING(HtmlConstants.CONTENT_HEADING,
getResource("doclet.Help_line_16"));
Content liTree = HtmlTree.LI(HtmlStyle.blockList, treeHead);
Content line17 = getResource("doclet.Help_line_17_with_tree_link",
getHyperLinkString("overview-tree.html",
configuration.getText("doclet.Class_Hierarchy")));
ul();
li(); printText("doclet.Help_line_18");
li(); printText("doclet.Help_line_19");
ulEnd();
blockquoteEnd();
Content treePara = HtmlTree.P(line17);
liTree.addContent(treePara);
HtmlTree tul = new HtmlTree(HtmlTag.UL);
tul.addContent(HtmlTree.LI(
getResource("doclet.Help_line_18")));
tul.addContent(HtmlTree.LI(
getResource("doclet.Help_line_19")));
liTree.addContent(tul);
ul.addContent(liTree);
}
if (!(configuration.nodeprecatedlist ||
configuration.nodeprecated)) {
h3(); printText("doclet.Deprecated_API"); h3End();
blockquote();
printText("doclet.Help_line_20_with_deprecated_api_link",
getHyperLink("deprecated-list.html",
Content dHead = HtmlTree.HEADING(HtmlConstants.CONTENT_HEADING,
getResource("doclet.Deprecated_API"));
Content liDeprecated = HtmlTree.LI(HtmlStyle.blockList, dHead);
Content line20 = getResource("doclet.Help_line_20_with_deprecated_api_link",
getHyperLinkString("deprecated-list.html",
configuration.getText("doclet.Deprecated_API")));
blockquoteEnd();
Content dPara = HtmlTree.P(line20);
liDeprecated.addContent(dPara);
ul.addContent(liDeprecated);
}
if (configuration.createindex) {
String indexlink;
if (configuration.splitindex) {
indexlink = getHyperLink("index-files/index-1.html",
indexlink = getHyperLinkString("index-files/index-1.html",
configuration.getText("doclet.Index"));
} else {
indexlink = getHyperLink("index-all.html",
indexlink = getHyperLinkString("index-all.html",
configuration.getText("doclet.Index"));
}
h3(); printText("doclet.Help_line_21"); h3End();
blockquote();
printText("doclet.Help_line_22", indexlink);
blockquoteEnd();
Content indexHead = HtmlTree.HEADING(HtmlConstants.CONTENT_HEADING,
getResource("doclet.Help_line_21"));
Content liIndex = HtmlTree.LI(HtmlStyle.blockList, indexHead);
Content line22 = getResource("doclet.Help_line_22", indexlink);
Content indexPara = HtmlTree.P(line22);
liIndex.addContent(indexPara);
ul.addContent(liIndex);
}
h3(); printText("doclet.Help_line_23"); h3End();
printText("doclet.Help_line_24");
h3(); printText("doclet.Help_line_25"); h3End();
printText("doclet.Help_line_26"); p();
h3(); printText("doclet.Serialized_Form"); h3End();
printText("doclet.Help_line_27"); p();
h3(); printText("doclet.Constants_Summary"); h3End();
printText("doclet.Help_line_28"); p();
font("-1"); em();
printText("doclet.Help_line_29");
emEnd(); fontEnd(); br();
hr();
Content prevHead = HtmlTree.HEADING(HtmlConstants.CONTENT_HEADING,
getResource("doclet.Help_line_23"));
Content liPrev = HtmlTree.LI(HtmlStyle.blockList, prevHead);
Content line24 = getResource("doclet.Help_line_24");
Content prevPara = HtmlTree.P(line24);
liPrev.addContent(prevPara);
ul.addContent(liPrev);
Content frameHead = HtmlTree.HEADING(HtmlConstants.CONTENT_HEADING,
getResource("doclet.Help_line_25"));
Content liFrame = HtmlTree.LI(HtmlStyle.blockList, frameHead);
Content line26 = getResource("doclet.Help_line_26");
Content framePara = HtmlTree.P(line26);
liFrame.addContent(framePara);
ul.addContent(liFrame);
Content sHead = HtmlTree.HEADING(HtmlConstants.CONTENT_HEADING,
getResource("doclet.Serialized_Form"));
Content liSerial = HtmlTree.LI(HtmlStyle.blockList, sHead);
Content line27 = getResource("doclet.Help_line_27");
Content serialPara = HtmlTree.P(line27);
liSerial.addContent(serialPara);
ul.addContent(liSerial);
Content constHead = HtmlTree.HEADING(HtmlConstants.CONTENT_HEADING,
getResource("doclet.Constants_Summary"));
Content liConst = HtmlTree.LI(HtmlStyle.blockList, constHead);
Content line28 = getResource("doclet.Help_line_28");
Content constPara = HtmlTree.P(line28);
liConst.addContent(constPara);
ul.addContent(liConst);
Content divContent = HtmlTree.DIV(HtmlStyle.contentContainer, ul);
Content line29 = HtmlTree.EM(getResource("doclet.Help_line_29"));
divContent.addContent(line29);
contentTree.addContent(divContent);
}
/**
* Highlight the word "Help" in the navigation bar as this is the help file.
* Get the help label.
*
* @return a content tree for the help label
*/
protected void navLinkHelp() {
navCellRevStart();
fontStyle("NavBarFont1Rev");
strongText("doclet.Help");
fontEnd();
navCellEnd();
protected Content getNavLinkHelp() {
Content li = HtmlTree.LI(HtmlStyle.navBarCell1Rev, helpLabel);
return li;
}
}

5
langtools/src/share/classes/com/sun/tools/doclets/formats/html/HtmlDoclet.java
View file

@ -144,8 +144,11 @@ public class HtmlDoclet extends AbstractDoclet {
!configuration.nohelp) {
HelpWriter.generate(configuration);
}
// If a stylesheet file is not specified, copy the default stylesheet.
if (configuration.stylesheetfile.length() == 0) {
StylesheetWriter.generate(configuration);
Util.copyFile(configuration, "stylesheet.css", Util.RESOURCESDIR,
(configdestdir.isEmpty()) ?
System.getProperty("user.dir") : configdestdir, false);
}
}

988
langtools/src/share/classes/com/sun/tools/doclets/formats/html/HtmlDocletWriter.java
View file

File diff suppressed because it is too large Load diff

169
langtools/src/share/classes/com/sun/tools/doclets/formats/html/HtmlSerialFieldWriter.java
View file

@ -31,6 +31,7 @@ import com.sun.javadoc.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.taglets.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.formats.html.markup.*;
/**
* Generate serialized form for serializable fields.
@ -46,8 +47,6 @@ public class HtmlSerialFieldWriter extends FieldWriterImpl
private boolean printedOverallAnchor = false;
private boolean printedFirstMember = false;
public HtmlSerialFieldWriter(SubWriterHolderWriter writer,
ClassDoc classdoc) {
super(writer, classdoc);
@ -69,109 +68,143 @@ public class HtmlSerialFieldWriter extends FieldWriterImpl
}
}
public void writeHeader(String heading) {
/**
* Return the header for serializable fields section.
*
* @return a content tree for the header
*/
public Content getSerializableFieldsHeader() {
HtmlTree ul = new HtmlTree(HtmlTag.UL);
ul.addStyle(HtmlStyle.blockList);
return ul;
}
/**
* Return the header for serializable fields content section.
*
* @param isLastContent true if the cotent being documented is the last content.
* @return a content tree for the header
*/
public Content getFieldsContentHeader(boolean isLastContent) {
HtmlTree li = new HtmlTree(HtmlTag.LI);
if (isLastContent)
li.addStyle(HtmlStyle.blockListLast);
else
li.addStyle(HtmlStyle.blockList);
return li;
}
/**
* Add serializable fields.
*
* @param heading the heading for the section
* @param serializableFieldsTree the tree to be added to the serializable fileds
* content tree
* @return a content tree for the serializable fields content
*/
public Content getSerializableFields(String heading, Content serializableFieldsTree) {
HtmlTree li = new HtmlTree(HtmlTag.LI);
li.addStyle(HtmlStyle.blockList);
if (serializableFieldsTree.isValid()) {
if (!printedOverallAnchor) {
writer.anchor("serializedForm");
li.addContent(writer.getMarkerAnchor("serializedForm"));
printedOverallAnchor = true;
writer.printTableHeadingBackground(heading);
writer.println();
if (heading.equals(
configuration().getText("doclet.Serialized_Form_class"))) {
assert !writer.getMemberDetailsListPrinted();
}
} else {
writer.printTableHeadingBackground(heading);
writer.println();
Content headingContent = new StringContent(heading);
Content serialHeading = HtmlTree.HEADING(HtmlConstants.SERIALIZED_MEMBER_HEADING,
headingContent);
li.addContent(serialHeading);
li.addContent(serializableFieldsTree);
}
return li;
}
public void writeMemberHeader(ClassDoc fieldType, String fieldTypeStr,
String fieldDimensions, String fieldName) {
if (printedFirstMember) {
writer.printMemberHeader();
}
printedFirstMember = true;
writer.h3();
writer.print(fieldName);
writer.h3End();
writer.pre();
/**
* Add the member header.
*
* @param fieldsType the class document to be listed
* @param fieldTypeStr the string for the filed type to be documented
* @param fieldDimensions the dimensions of the field string to be added
* @param firldName name of the field to be added
* @param contentTree the content tree to which the member header will be added
*/
public void addMemberHeader(ClassDoc fieldType, String fieldTypeStr,
String fieldDimensions, String fieldName, Content contentTree) {
Content nameContent = new RawHtml(fieldName);
Content heading = HtmlTree.HEADING(HtmlConstants.MEMBER_HEADING, nameContent);
contentTree.addContent(heading);
Content pre = new HtmlTree(HtmlTag.PRE);
if (fieldType == null) {
writer.print(fieldTypeStr);
pre.addContent(fieldTypeStr);
} else {
writer.printLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_SERIAL_MEMBER,
fieldType));
Content fieldContent = new RawHtml(writer.getLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_SERIAL_MEMBER, fieldType)));
pre.addContent(fieldContent);
}
print(fieldDimensions + ' ');
strong(fieldName);
writer.preEnd();
assert !writer.getMemberDetailsListPrinted();
pre.addContent(fieldDimensions + " ");
pre.addContent(fieldName);
contentTree.addContent(pre);
}
/**
* Write the deprecated information for this member.
* Add the deprecated information for this member.
*
* @param field the field to document.
* @param contentTree the tree to which the deprecated info will be added
*/
public void writeMemberDeprecatedInfo(FieldDoc field) {
printDeprecated(field);
public void addMemberDeprecatedInfo(FieldDoc field, Content contentTree) {
addDeprecatedInfo(field, contentTree);
}
/**
* Write the description text for this member.
* Add the description text for this member.
*
* @param field the field to document.
* @param contentTree the tree to which the deprecated info will be added
*/
public void writeMemberDescription(FieldDoc field) {
public void addMemberDescription(FieldDoc field, Content contentTree) {
if (field.inlineTags().length > 0) {
writer.printMemberDetailsListStartTag();
writer.dd();
writer.printInlineComment(field);
writer.ddEnd();
writer.addInlineComment(field, contentTree);
}
Tag[] tags = field.tags("serial");
if (tags.length > 0) {
writer.printMemberDetailsListStartTag();
writer.dd();
writer.printInlineComment(field, tags[0]);
writer.ddEnd();
writer.addInlineComment(field, tags[0], contentTree);
}
}
/**
* Write the description text for this member represented by the tag.
* Add the description text for this member represented by the tag.
*
* @param serialFieldTag the field to document (represented by tag).
* @param serialFieldTag the field to document (represented by tag)
* @param contentTree the tree to which the deprecated info will be added
*/
public void writeMemberDescription(SerialFieldTag serialFieldTag) {
public void addMemberDescription(SerialFieldTag serialFieldTag, Content contentTree) {
String serialFieldTagDesc = serialFieldTag.description().trim();
if (!serialFieldTagDesc.isEmpty()) {
writer.dl();
writer.dd();
writer.print(serialFieldTagDesc);
writer.ddEnd();
writer.dlEnd();
Content serialFieldContent = new RawHtml(serialFieldTagDesc);
Content div = HtmlTree.DIV(HtmlStyle.block, serialFieldContent);
contentTree.addContent(div);
}
}
/**
* Write the tag information for this member.
* Add the tag information for this member.
*
* @param field the field to document.
* @param contentTree the tree to which the member tags info will be added
*/
public void writeMemberTags(FieldDoc field) {
public void addMemberTags(FieldDoc field, Content contentTree) {
TagletOutputImpl output = new TagletOutputImpl("");
TagletWriter.genTagOuput(configuration().tagletManager, field,
configuration().tagletManager.getCustomTags(field),
writer.getTagletWriterInstance(false), output);
String outputString = output.toString().trim();
Content dlTags = new HtmlTree(HtmlTag.DL);
if (!outputString.isEmpty()) {
writer.printMemberDetailsListStartTag();
writer.dd();
writer.dl();
print(outputString);
writer.dlEnd();
writer.ddEnd();
Content tagContent = new RawHtml(outputString);
dlTags.addContent(tagContent);
}
contentTree.addContent(dlTags);
}
/**
@ -192,24 +225,4 @@ public class HtmlSerialFieldWriter extends FieldWriterImpl
return true;
return false;
}
public void writeMemberFooter() {
printMemberFooter();
}
/**
* Write the footer information. If the serilization overview section was
* printed, check for definition list and close list tag.
*
* @param heading the heading that was written.
*/
public void writeFooter(String heading) {
if (printedOverallAnchor) {
if (heading.equals(
configuration().getText("doclet.Serialized_Form_class"))) {
writer.printMemberDetailsListEndTag();
assert !writer.getMemberDetailsListPrinted();
}
}
}
}

120
langtools/src/share/classes/com/sun/tools/doclets/formats/html/HtmlSerialMethodWriter.java
View file

@ -28,57 +28,119 @@ package com.sun.tools.doclets.formats.html;
import com.sun.javadoc.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.taglets.*;
import com.sun.tools.doclets.formats.html.markup.*;
/**
* Generate serialized form for Serializable/Externalizable methods.
* Documentation denoted by the <code>serialData</code> tag is processed.
*
* @author Joe Fialli
* @author Bhavesh Patel (Modified)
*/
public class HtmlSerialMethodWriter extends MethodWriterImpl implements
SerializedFormWriter.SerialMethodWriter{
private boolean printedFirstMember = false;
public HtmlSerialMethodWriter(SubWriterHolderWriter writer,
ClassDoc classdoc) {
super(writer, classdoc);
}
public void writeHeader(String heading) {
writer.anchor("serialized_methods");
writer.printTableHeadingBackground(heading);
writer.p();
/**
* Return the header for serializable methods section.
*
* @return a content tree for the header
*/
public Content getSerializableMethodsHeader() {
HtmlTree ul = new HtmlTree(HtmlTag.UL);
ul.addStyle(HtmlStyle.blockList);
return ul;
}
public void writeNoCustomizationMsg(String msg) {
writer.print(msg);
writer.p();
/**
* Return the header for serializable methods content section.
*
* @param isLastContent true if the cotent being documented is the last content.
* @return a content tree for the header
*/
public Content getMethodsContentHeader(boolean isLastContent) {
HtmlTree li = new HtmlTree(HtmlTag.LI);
if (isLastContent)
li.addStyle(HtmlStyle.blockListLast);
else
li.addStyle(HtmlStyle.blockList);
return li;
}
public void writeMemberHeader(MethodDoc member) {
if (printedFirstMember) {
writer.printMemberHeader();
}
printedFirstMember = true;
writer.anchor(member);
printHead(member);
writeSignature(member);
/**
* Add serializable methods.
*
* @param heading the heading for the section
* @param serializableMethodContent the tree to be added to the serializable methods
* content tree
* @return a content tree for the serializable methods content
*/
public Content getSerializableMethods(String heading, Content serializableMethodContent) {
Content li = HtmlTree.LI(HtmlStyle.blockList, writer.getMarkerAnchor(
"serialized_methods"));
Content headingContent = new StringContent(heading);
Content serialHeading = HtmlTree.HEADING(HtmlConstants.SERIALIZED_MEMBER_HEADING,
headingContent);
li.addContent(serialHeading);
li.addContent(serializableMethodContent);
return li;
}
public void writeMemberFooter() {
printMemberFooter();
/**
* Return the no customization message.
*
* @param msg the message to be displayed
* @return no customization message content
*/
public Content getNoCustomizationMsg(String msg) {
Content noCustomizationMsg = new StringContent(msg);
return noCustomizationMsg;
}
public void writeDeprecatedMemberInfo(MethodDoc member) {
printDeprecated(member);
/**
* Add the member header.
*
* @param member the method document to be listed
* @param methodsContentTree the content tree to which the member header will be added
*/
public void addMemberHeader(MethodDoc member, Content methodsContentTree) {
methodsContentTree.addContent(writer.getMarkerAnchor(
writer.getAnchor(member)));
methodsContentTree.addContent(getHead(member));
methodsContentTree.addContent(getSignature(member));
}
public void writeMemberDescription(MethodDoc member) {
printComment(member);
/**
* Add the deprecated information for this member.
*
* @param member the method to document.
* @param methodsContentTree the tree to which the deprecated info will be added
*/
public void addDeprecatedMemberInfo(MethodDoc member, Content methodsContentTree) {
addDeprecatedInfo(member, methodsContentTree);
}
public void writeMemberTags(MethodDoc member) {
/**
* Add the description text for this member.
*
* @param member the method to document.
* @param methodsContentTree the tree to which the deprecated info will be added
*/
public void addMemberDescription(MethodDoc member, Content methodsContentTree) {
addComment(member, methodsContentTree);
}
/**
* Add the tag information for this member.
*
* @param member the method to document.
* @param methodsContentTree the tree to which the member tags info will be added
*/
public void addMemberTags(MethodDoc member, Content methodsContentTree) {
TagletOutputImpl output = new TagletOutputImpl("");
TagletManager tagletManager =
ConfigurationImpl.getInstance().tagletManager;
@ -86,14 +148,12 @@ public class HtmlSerialMethodWriter extends MethodWriterImpl implements
tagletManager.getSerializedFormTags(),
writer.getTagletWriterInstance(false), output);
String outputString = output.toString().trim();
Content dlTags = new HtmlTree(HtmlTag.DL);
if (!outputString.isEmpty()) {
writer.printMemberDetailsListStartTag();
writer.dd();
writer.dl();
print(outputString);
writer.dlEnd();
writer.ddEnd();
Content tagContent = new RawHtml(outputString);
dlTags.addContent(tagContent);
}
methodsContentTree.addContent(dlTags);
MethodDoc method = member;
if (method.name().compareTo("writeExternal") == 0
&& method.tags("serialData").length == 0) {

2
langtools/src/share/classes/com/sun/tools/doclets/formats/html/LinkFactoryImpl.java
View file

@ -79,7 +79,7 @@ public class LinkFactoryImpl extends LinkFactory {
String filename = pathString(classLinkInfo);
if (linkInfo.linkToSelf ||
!(linkInfo.classDoc.name() + ".html").equals(m_writer.filename)) {
linkOutput.append(m_writer.getHyperLink(filename,
linkOutput.append(m_writer.getHyperLinkString(filename,
classLinkInfo.where, label.toString(),
classLinkInfo.isStrong, classLinkInfo.styleName,
title, classLinkInfo.target));

376
langtools/src/share/classes/com/sun/tools/doclets/formats/html/MethodWriterImpl.java
View file

@ -28,9 +28,9 @@ package com.sun.tools.doclets.formats.html;
import java.io.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.formats.html.markup.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.taglets.*;
/**
* Writes method documentation in HTML format.
@ -43,8 +43,6 @@ import com.sun.tools.doclets.internal.toolkit.taglets.*;
public class MethodWriterImpl extends AbstractExecutableMemberWriter
implements MethodWriter, MemberSummaryWriter {
private boolean printedSummaryHeader = false;
/**
* Construct a new MethodWriterImpl.
*
@ -65,184 +63,127 @@ public class MethodWriterImpl extends AbstractExecutableMemberWriter
}
/**
* Write the methods summary header for the given class.
*
* @param classDoc the class the summary belongs to.
* {@inheritDoc}
*/
public void writeMemberSummaryHeader(ClassDoc classDoc) {
printedSummaryHeader = true;
writer.println();
writer.println("<!-- ========== METHOD SUMMARY =========== -->");
writer.println();
writer.printSummaryHeader(this, classDoc);
}
/**
* Write the methods summary footer for the given class.
*
* @param classDoc the class the summary belongs to.
*/
public void writeMemberSummaryFooter(ClassDoc classDoc) {
writer.printSummaryFooter(this, classDoc);
}
/**
* Write the inherited methods summary header for the given class.
*
* @param classDoc the class the summary belongs to.
*/
public void writeInheritedMemberSummaryHeader(ClassDoc classDoc) {
if(! printedSummaryHeader){
//We don't want inherited summary to not be under heading.
writeMemberSummaryHeader(classDoc);
writeMemberSummaryFooter(classDoc);
printedSummaryHeader = true;
}
writer.printInheritedSummaryHeader(this, classDoc);
public Content getMemberSummaryHeader(ClassDoc classDoc,
Content memberSummaryTree) {
memberSummaryTree.addContent(HtmlConstants.START_OF_METHOD_SUMMARY);
Content memberTree = writer.getMemberTreeHeader();
writer.addSummaryHeader(this, classDoc, memberTree);
return memberTree;
}
/**
* {@inheritDoc}
*/
public void writeInheritedMemberSummary(ClassDoc classDoc,
ProgramElementDoc method, boolean isFirst, boolean isLast) {
writer.printInheritedSummaryMember(this, classDoc, method, isFirst);
public Content getMethodDetailsTreeHeader(ClassDoc classDoc,
Content memberDetailsTree) {
memberDetailsTree.addContent(HtmlConstants.START_OF_METHOD_DETAILS);
Content methodDetailsTree = writer.getMemberTreeHeader();
methodDetailsTree.addContent(writer.getMarkerAnchor("method_detail"));
Content heading = HtmlTree.HEADING(HtmlConstants.DETAILS_HEADING,
writer.methodDetailsLabel);
methodDetailsTree.addContent(heading);
return methodDetailsTree;
}
/**
* Write the inherited methods summary footer for the given class.
*
* @param classDoc the class the summary belongs to.
* {@inheritDoc}
*/
public void writeInheritedMemberSummaryFooter(ClassDoc classDoc) {
writer.printInheritedSummaryFooter(this, classDoc); ;
}
/**
* Write the header for the method documentation.
*
* @param classDoc the class that the methods belong to.
*/
public void writeHeader(ClassDoc classDoc, String header) {
writer.println();
writer.println("<!-- ============ METHOD DETAIL ========== -->");
writer.println();
writer.anchor("method_detail");
writer.printTableHeadingBackground(header);
}
/**
* Write the method header for the given method.
*
* @param method the method being documented.
* @param isFirst the flag to indicate whether or not the method is the
* first to be documented.
*/
public void writeMethodHeader(MethodDoc method, boolean isFirst) {
if (! isFirst) {
writer.printMemberHeader();
}
writer.println();
public Content getMethodDocTreeHeader(MethodDoc method,
Content methodDetailsTree) {
String erasureAnchor;
if ((erasureAnchor = getErasureAnchor(method)) != null) {
writer.anchor(erasureAnchor);
methodDetailsTree.addContent(writer.getMarkerAnchor((erasureAnchor)));
}
writer.anchor(method);
writer.h3();
writer.print(method.name());
writer.h3End();
methodDetailsTree.addContent(
writer.getMarkerAnchor(writer.getAnchor(method)));
Content methodDocTree = writer.getMemberTreeHeader();
Content heading = new HtmlTree(HtmlConstants.MEMBER_HEADING);
heading.addContent(method.name());
methodDocTree.addContent(heading);
return methodDocTree;
}
/**
* Write the signature for the given method.
* Get the signature for the given method.
*
* @param method the method being documented.
* @return a content object for the signature
*/
public void writeSignature(MethodDoc method) {
public Content getSignature(MethodDoc method) {
writer.displayLength = 0;
writer.pre();
writer.writeAnnotationInfo(method);
printModifiers(method);
writeTypeParameters(method);
printReturnType(method);
Content pre = new HtmlTree(HtmlTag.PRE);
writer.addAnnotationInfo(method, pre);
addModifiers(method, pre);
addTypeParameters(method, pre);
addReturnType(method, pre);
if (configuration().linksource) {
writer.printSrcLink(method, method.name());
Content methodName = new StringContent(method.name());
writer.addSrcLink(method, methodName, pre);
} else {
strong(method.name());
addName(method.name(), pre);
}
writeParameters(method);
writeExceptions(method);
writer.preEnd();
assert !writer.getMemberDetailsListPrinted();
addParameters(method, pre);
addExceptions(method, pre);
return pre;
}
/**
* Write the deprecated output for the given method.
*
* @param method the method being documented.
* {@inheritDoc}
*/
public void writeDeprecated(MethodDoc method) {
printDeprecated(method);
public void addDeprecated(MethodDoc method, Content methodDocTree) {
addDeprecatedInfo(method, methodDocTree);
}
/**
* Write the comments for the given method.
*
* @param method the method being documented.
* {@inheritDoc}
*/
public void writeComments(Type holder, MethodDoc method) {
public void addComments(Type holder, MethodDoc method, Content methodDocTree) {
ClassDoc holderClassDoc = holder.asClassDoc();
if (method.inlineTags().length > 0) {
writer.printMemberDetailsListStartTag();
if (holder.asClassDoc().equals(classdoc) ||
(! (holderClassDoc.isPublic() ||
Util.isLinkable(holderClassDoc, configuration())))) {
writer.dd();
writer.printInlineComment(method);
writer.ddEnd();
writer.addInlineComment(method, methodDocTree);
} else {
String classlink = writer.codeText(
Content link = new RawHtml(
writer.getDocLink(LinkInfoImpl.CONTEXT_METHOD_DOC_COPY,
holder.asClassDoc(), method,
holder.asClassDoc().isIncluded() ?
holder.typeName() : holder.qualifiedTypeName(),
false));
writer.dd();
writer.strongText(holder.asClassDoc().isClass()?
"doclet.Description_From_Class":
"doclet.Description_From_Interface",
classlink);
writer.ddEnd();
writer.dd();
writer.printInlineComment(method);
writer.ddEnd();
Content codelLink = HtmlTree.CODE(link);
Content strong = HtmlTree.STRONG(holder.asClassDoc().isClass()?
writer.descfrmClassLabel : writer.descfrmInterfaceLabel);
strong.addContent(writer.getSpace());
strong.addContent(codelLink);
methodDocTree.addContent(HtmlTree.DIV(HtmlStyle.block, strong));
writer.addInlineComment(method, methodDocTree);
}
}
}
/**
* Write the tag output for the given method.
*
* @param method the method being documented.
* {@inheritDoc}
*/
public void writeTags(MethodDoc method) {
writer.printTags(method);
public void addTags(MethodDoc method, Content methodDocTree) {
writer.addTagsInfo(method, methodDocTree);
}
/**
* Write the method footer.
* {@inheritDoc}
*/
public void writeMethodFooter() {
printMemberFooter();
public Content getMethodDetails(Content methodDetailsTree) {
return getMemberTree(methodDetailsTree);
}
/**
* Write the footer for the method documentation.
*
* @param classDoc the class that the methods belong to.
* {@inheritDoc}
*/
public void writeFooter(ClassDoc classDoc) {
//No footer to write for method documentation
public Content getMethodDoc(Content methodDocTree,
boolean isLastContent) {
return getMemberTree(methodDocTree, isLastContent);
}
/**
@ -256,53 +197,89 @@ public class MethodWriterImpl extends AbstractExecutableMemberWriter
return VisibleMemberMap.METHODS;
}
public void printSummaryLabel() {
writer.printText("doclet.Method_Summary");
/**
* {@inheritDoc}
*/
public void addSummaryLabel(Content memberTree) {
Content label = HtmlTree.HEADING(HtmlConstants.SUMMARY_HEADING,
writer.getResource("doclet.Method_Summary"));
memberTree.addContent(label);
}
public void printTableSummary() {
writer.tableIndexSummary(configuration().getText("doclet.Member_Table_Summary",
/**
* {@inheritDoc}
*/
public String getTableSummary() {
return configuration().getText("doclet.Member_Table_Summary",
configuration().getText("doclet.Method_Summary"),
configuration().getText("doclet.methods")));
configuration().getText("doclet.methods"));
}
public void printSummaryTableHeader(ProgramElementDoc member) {
/**
* {@inheritDoc}
*/
public String getCaption() {
return configuration().getText("doclet.Methods");
}
/**
* {@inheritDoc}
*/
public String[] getSummaryTableHeader(ProgramElementDoc member) {
String[] header = new String[] {
writer.getModifierTypeHeader(),
configuration().getText("doclet.0_and_1",
configuration().getText("doclet.Method"),
configuration().getText("doclet.Description"))
};
writer.summaryTableHeader(header, "col");
return header;
}
public void printSummaryAnchor(ClassDoc cd) {
writer.anchor("method_summary");
/**
* {@inheritDoc}
*/
public void addSummaryAnchor(ClassDoc cd, Content memberTree) {
memberTree.addContent(writer.getMarkerAnchor("method_summary"));
}
public void printInheritedSummaryAnchor(ClassDoc cd) {
writer.anchor("methods_inherited_from_class_" +
ConfigurationImpl.getInstance().getClassName(cd));
/**
* {@inheritDoc}
*/
public void addInheritedSummaryAnchor(ClassDoc cd, Content inheritedTree) {
inheritedTree.addContent(writer.getMarkerAnchor(
"methods_inherited_from_class_" +
configuration().getClassName(cd)));
}
public void printInheritedSummaryLabel(ClassDoc cd) {
String classlink = writer.getPreQualifiedClassLink(
LinkInfoImpl.CONTEXT_MEMBER, cd, false);
writer.strong();
String key = cd.isClass()?
"doclet.Methods_Inherited_From_Class" :
"doclet.Methods_Inherited_From_Interface";
writer.printText(key, classlink);
writer.strongEnd();
/**
* {@inheritDoc}
*/
public void addInheritedSummaryLabel(ClassDoc cd, Content inheritedTree) {
Content classLink = new RawHtml(writer.getPreQualifiedClassLink(
LinkInfoImpl.CONTEXT_MEMBER, cd, false));
Content label = new StringContent(cd.isClass() ?
configuration().getText("doclet.Methods_Inherited_From_Class") :
configuration().getText("doclet.Methods_Inherited_From_Interface"));
Content labelHeading = HtmlTree.HEADING(HtmlConstants.INHERITED_SUMMARY_HEADING,
label);
labelHeading.addContent(writer.getSpace());
labelHeading.addContent(classLink);
inheritedTree.addContent(labelHeading);
}
protected void printSummaryType(ProgramElementDoc member) {
/**
* {@inheritDoc}
*/
protected void addSummaryType(ProgramElementDoc member, Content tdSummaryType) {
MethodDoc meth = (MethodDoc)member;
printModifierAndType(meth, meth.returnType());
addModifierAndType(meth, meth.returnType(), tdSummaryType);
}
protected static void printOverridden(HtmlDocletWriter writer,
Type overriddenType, MethodDoc method) {
/**
* {@inheritDoc}
*/
protected static void addOverridden(HtmlDocletWriter writer,
Type overriddenType, MethodDoc method, Content dl) {
if(writer.configuration.nocomment){
return;
}
@ -317,31 +294,33 @@ public class MethodWriterImpl extends AbstractExecutableMemberWriter
//is not visible so don't document this.
return;
}
String label = "doclet.Overrides";
Content label = writer.overridesLabel;
int context = LinkInfoImpl.CONTEXT_METHOD_OVERRIDES;
if (method != null) {
if(overriddenType.asClassDoc().isAbstract() && method.isAbstract()){
//Abstract method is implemented from abstract class,
//not overridden
label = "doclet.Specified_By";
label = writer.specifiedByLabel;
context = LinkInfoImpl.CONTEXT_METHOD_SPECIFIED_BY;
}
String overriddenTypeLink = writer.codeText(
Content dt = HtmlTree.DT(HtmlTree.STRONG(label));
dl.addContent(dt);
Content overriddenTypeLink = new RawHtml(
writer.getLink(new LinkInfoImpl(context, overriddenType)));
Content codeOverridenTypeLink = HtmlTree.CODE(overriddenTypeLink);
String name = method.name();
writer.dt();
writer.strongText(label);
writer.dtEnd();
writer.dd();
String methLink = writer.codeText(
writer.getLink(
Content methlink = new RawHtml(writer.getLink(
new LinkInfoImpl(LinkInfoImpl.CONTEXT_MEMBER,
overriddenType.asClassDoc(),
writer.getAnchor(method), name, false)
));
writer.printText("doclet.in_class", methLink, overriddenTypeLink);
writer.ddEnd();
writer.getAnchor(method), name, false)));
Content codeMethLink = HtmlTree.CODE(methlink);
Content dd = HtmlTree.DD(codeMethLink);
dd.addContent(writer.getSpace());
dd.addContent(writer.getResource("doclet.in_class"));
dd.addContent(writer.getSpace());
dd.addContent(codeOverridenTypeLink);
dl.addContent(dd);
}
}
@ -363,8 +342,11 @@ public class MethodWriterImpl extends AbstractExecutableMemberWriter
}
}
protected static void printImplementsInfo(HtmlDocletWriter writer,
MethodDoc method) {
/**
* {@inheritDoc}
*/
protected static void addImplementsInfo(HtmlDocletWriter writer,
MethodDoc method, Content dl) {
if(writer.configuration.nocomment){
return;
}
@ -374,50 +356,64 @@ public class MethodWriterImpl extends AbstractExecutableMemberWriter
for (int i = 0; i < implementedMethods.length; i++) {
MethodDoc implementedMeth = implementedMethods[i];
Type intfac = implementedMethodsFinder.getMethodHolder(implementedMeth);
String methlink = "";
String intfaclink = writer.codeText(
writer.getLink(new LinkInfoImpl(
Content intfaclink = new RawHtml(writer.getLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_METHOD_SPECIFIED_BY, intfac)));
writer.dt();
writer.strongText("doclet.Specified_By");
writer.dtEnd();
writer.dd();
methlink = writer.codeText(writer.getDocLink(
Content codeIntfacLink = HtmlTree.CODE(intfaclink);
Content dt = HtmlTree.DT(HtmlTree.STRONG(writer.specifiedByLabel));
dl.addContent(dt);
Content methlink = new RawHtml(writer.getDocLink(
LinkInfoImpl.CONTEXT_MEMBER, implementedMeth,
implementedMeth.name(), false));
writer.printText("doclet.in_interface", methlink, intfaclink);
writer.ddEnd();
Content codeMethLink = HtmlTree.CODE(methlink);
Content dd = HtmlTree.DD(codeMethLink);
dd.addContent(writer.getSpace());
dd.addContent(writer.getResource("doclet.in_interface"));
dd.addContent(writer.getSpace());
dd.addContent(codeIntfacLink);
dl.addContent(dd);
}
}
}
protected void printReturnType(MethodDoc method) {
/**
* Add the return type.
*
* @param method the method being documented.
* @param htmltree the content tree to which the return type will be added
*/
protected void addReturnType(MethodDoc method, Content htmltree) {
Type type = method.returnType();
if (type != null) {
writer.printLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_RETURN_TYPE,
type));
print(' ');
Content linkContent = new RawHtml(writer.getLink(
new LinkInfoImpl(LinkInfoImpl.CONTEXT_RETURN_TYPE, type)));
htmltree.addContent(linkContent);
htmltree.addContent(writer.getSpace());
}
}
protected void printNavSummaryLink(ClassDoc cd, boolean link) {
/**
* {@inheritDoc}
*/
protected Content getNavSummaryLink(ClassDoc cd, boolean link) {
if (link) {
writer.printHyperLink("", (cd == null)?
return writer.getHyperLink("", (cd == null)?
"method_summary":
"methods_inherited_from_class_" +
ConfigurationImpl.getInstance().getClassName(cd),
ConfigurationImpl.getInstance().getText("doclet.navMethod"));
configuration().getClassName(cd),
writer.getResource("doclet.navMethod"));
} else {
writer.printText("doclet.navMethod");
return writer.getResource("doclet.navMethod");
}
}
protected void printNavDetailLink(boolean link) {
/**
* {@inheritDoc}
*/
protected void addNavDetailLink(boolean link, Content liNav) {
if (link) {
writer.printHyperLink("", "method_detail",
ConfigurationImpl.getInstance().getText("doclet.navMethod"));
liNav.addContent(writer.getHyperLink("", "method_detail",
writer.getResource("doclet.navMethod")));
} else {
writer.printText("doclet.navMethod");
liNav.addContent(writer.getResource("doclet.navMethod"));
}
}
}

246
langtools/src/share/classes/com/sun/tools/doclets/formats/html/NestedClassWriterImpl.java
View file

@ -26,8 +26,10 @@
package com.sun.tools.doclets.formats.html;
import java.io.*;
import java.util.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.formats.html.markup.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
@ -42,8 +44,6 @@ import com.sun.tools.doclets.internal.toolkit.util.*;
public class NestedClassWriterImpl extends AbstractMemberWriter
implements MemberSummaryWriter {
private boolean printedSummaryHeader = false;
public NestedClassWriterImpl(SubWriterHolderWriter writer,
ClassDoc classdoc) {
super(writer, classdoc);
@ -53,90 +53,17 @@ public class NestedClassWriterImpl extends AbstractMemberWriter
super(writer);
}
/**
* Write the classes summary header for the given class.
*
* @param classDoc the class the summary belongs to.
*/
public void writeMemberSummaryHeader(ClassDoc classDoc) {
printedSummaryHeader = true;
writer.println("<!-- ======== NESTED CLASS SUMMARY ======== -->");
writer.println();
writer.printSummaryHeader(this, classDoc);
}
/**
* Write the classes summary footer for the given class.
*
* @param classDoc the class the summary belongs to.
*/
public void writeMemberSummaryFooter(ClassDoc classDoc) {
writer.printSummaryFooter(this, classDoc);
}
/**
* Write the inherited classes summary header for the given class.
*
* @param classDoc the class the summary belongs to.
*/
public void writeInheritedMemberSummaryHeader(ClassDoc classDoc) {
if(! printedSummaryHeader){
//We don't want inherited summary to not be under heading.
writeMemberSummaryHeader(classDoc);
writeMemberSummaryFooter(classDoc);
printedSummaryHeader = true;
}
writer.printInheritedSummaryHeader(this, classDoc);
}
/**
* {@inheritDoc}
*/
public void writeInheritedMemberSummary(ClassDoc classDoc,
ProgramElementDoc nestedClass, boolean isFirst, boolean isLast) {
writer.printInheritedSummaryMember(this, classDoc, nestedClass, isFirst);
public Content getMemberSummaryHeader(ClassDoc classDoc,
Content memberSummaryTree) {
memberSummaryTree.addContent(HtmlConstants.START_OF_NESTED_CLASS_SUMMARY);
Content memberTree = writer.getMemberTreeHeader();
writer.addSummaryHeader(this, classDoc, memberTree);
return memberTree;
}
/**
* Write the inherited classes summary footer for the given class.
*
* @param classDoc the class the summary belongs to.
*/
public void writeInheritedMemberSummaryFooter(ClassDoc classDoc) {
writer.printInheritedSummaryFooter(this, classDoc);
writer.println();
}
/**
* Write the header for the nested class documentation.
*
* @param classDoc the class that the classes belong to.
*/
public void writeHeader(ClassDoc classDoc, String header) {
writer.anchor("nested class_detail");
writer.printTableHeadingBackground(header);
}
/**
* Write the nested class header for the given nested class.
*
* @param nestedClass the nested class being documented.
* @param isFirst the flag to indicate whether or not the nested class is the
* first to be documented.
*/
public void writeClassHeader(ClassDoc nestedClass, boolean isFirst) {
if (! isFirst) {
writer.printMemberHeader();
writer.println("");
}
writer.anchor(nestedClass.name());
writer.h3();
writer.print(nestedClass.name());
writer.h3End();
}
/**
* Close the writer.
*/
@ -148,17 +75,35 @@ public class NestedClassWriterImpl extends AbstractMemberWriter
return VisibleMemberMap.INNERCLASSES;
}
public void printSummaryLabel() {
writer.printText("doclet.Nested_Class_Summary");
/**
* {@inheritDoc}
*/
public void addSummaryLabel(Content memberTree) {
Content label = HtmlTree.HEADING(HtmlConstants.SUMMARY_HEADING,
writer.getResource("doclet.Nested_Class_Summary"));
memberTree.addContent(label);
}
public void printTableSummary() {
writer.tableIndexSummary(configuration().getText("doclet.Member_Table_Summary",
/**
* {@inheritDoc}
*/
public String getTableSummary() {
return configuration().getText("doclet.Member_Table_Summary",
configuration().getText("doclet.Nested_Class_Summary"),
configuration().getText("doclet.nested_classes")));
configuration().getText("doclet.nested_classes"));
}
public void printSummaryTableHeader(ProgramElementDoc member) {
/**
* {@inheritDoc}
*/
public String getCaption() {
return configuration().getText("doclet.Nested_Classes");
}
/**
* {@inheritDoc}
*/
public String[] getSummaryTableHeader(ProgramElementDoc member) {
String[] header;
if (member.isInterface()) {
header = new String[] {
@ -176,92 +121,95 @@ public class NestedClassWriterImpl extends AbstractMemberWriter
configuration().getText("doclet.Description"))
};
}
writer.summaryTableHeader(header, "col");
return header;
}
public void printSummaryAnchor(ClassDoc cd) {
writer.anchor("nested_class_summary");
/**
* {@inheritDoc}
*/
public void addSummaryAnchor(ClassDoc cd, Content memberTree) {
memberTree.addContent(writer.getMarkerAnchor("nested_class_summary"));
}
public void printInheritedSummaryAnchor(ClassDoc cd) {
writer.anchor("nested_classes_inherited_from_class_" +
cd.qualifiedName());
/**
* {@inheritDoc}
*/
public void addInheritedSummaryAnchor(ClassDoc cd, Content inheritedTree) {
inheritedTree.addContent(writer.getMarkerAnchor(
"nested_classes_inherited_from_class_" + cd.qualifiedName()));
}
public void printInheritedSummaryLabel(ClassDoc cd) {
String clslink = writer.getPreQualifiedClassLink(
LinkInfoImpl.CONTEXT_MEMBER, cd, false);
writer.strong();
writer.printText(cd.isInterface() ?
"doclet.Nested_Classes_Interface_Inherited_From_Interface" :
"doclet.Nested_Classes_Interfaces_Inherited_From_Class",
clslink);
writer.strongEnd();
/**
* {@inheritDoc}
*/
public void addInheritedSummaryLabel(ClassDoc cd, Content inheritedTree) {
Content classLink = new RawHtml(writer.getPreQualifiedClassLink(
LinkInfoImpl.CONTEXT_MEMBER, cd, false));
Content label = new StringContent(cd.isInterface() ?
configuration().getText("doclet.Nested_Classes_Interface_Inherited_From_Interface") :
configuration().getText("doclet.Nested_Classes_Interfaces_Inherited_From_Class"));
Content labelHeading = HtmlTree.HEADING(HtmlConstants.INHERITED_SUMMARY_HEADING,
label);
labelHeading.addContent(writer.getSpace());
labelHeading.addContent(classLink);
inheritedTree.addContent(labelHeading);
}
protected void writeSummaryLink(int context, ClassDoc cd, ProgramElementDoc member) {
writer.strong();
writer.printLink(new LinkInfoImpl(context, (ClassDoc)member, false));
writer.strongEnd();
/**
* {@inheritDoc}
*/
protected void addSummaryLink(int context, ClassDoc cd, ProgramElementDoc member,
Content tdSummary) {
Content strong = HtmlTree.STRONG(new RawHtml(
writer.getLink(new LinkInfoImpl(context, (ClassDoc)member, false))));
Content code = HtmlTree.CODE(strong);
tdSummary.addContent(code);
}
protected void writeInheritedSummaryLink(ClassDoc cd,
ProgramElementDoc member) {
writer.printLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_MEMBER,
(ClassDoc)member, false));
/**
* {@inheritDoc}
*/
protected void addInheritedSummaryLink(ClassDoc cd,
ProgramElementDoc member, Content linksTree) {
linksTree.addContent(new RawHtml(
writer.getLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_MEMBER,
(ClassDoc)member, false))));
}
protected void printSummaryType(ProgramElementDoc member) {
/**
* {@inheritDoc}
*/
protected void addSummaryType(ProgramElementDoc member,
Content tdSummaryType) {
ClassDoc cd = (ClassDoc)member;
printModifierAndType(cd, null);
addModifierAndType(cd, null, tdSummaryType);
}
protected void printHeader(ClassDoc cd) {
// N.A.
}
protected void printBodyHtmlEnd(ClassDoc cd) {
// N.A.
}
protected void printMember(ProgramElementDoc member) {
// N.A.
}
protected void writeDeprecatedLink(ProgramElementDoc member) {
writer.printQualifiedClassLink(LinkInfoImpl.CONTEXT_MEMBER,
/**
* {@inheritDoc}
*/
protected Content getDeprecatedLink(ProgramElementDoc member) {
return writer.getQualifiedClassLink(LinkInfoImpl.CONTEXT_MEMBER,
(ClassDoc)member);
}
protected void printNavSummaryLink(ClassDoc cd, boolean link) {
/**
* {@inheritDoc}
*/
protected Content getNavSummaryLink(ClassDoc cd, boolean link) {
if (link) {
writer.printHyperLink("", (cd == null) ? "nested_class_summary":
return writer.getHyperLink("", (cd == null) ? "nested_class_summary":
"nested_classes_inherited_from_class_" +
cd.qualifiedName(),
ConfigurationImpl.getInstance().getText("doclet.navNested"));
writer.getResource("doclet.navNested"));
} else {
writer.printText("doclet.navNested");
return writer.getResource("doclet.navNested");
}
}
protected void printNavDetailLink(boolean link) {
}
protected void printMemberLink(ProgramElementDoc member) {
}
protected void printMembersSummaryLink(ClassDoc cd, ClassDoc icd,
boolean link) {
if (link) {
writer.printHyperLink(cd.name() + ".html",
(cd == icd)?
"nested_class_summary":
"nested_classes_inherited_from_class_" +
icd.qualifiedName(),
ConfigurationImpl.getInstance().getText(
"doclet.Nested_Class_Summary"));
} else {
writer.printText("doclet.Nested_Class_Summary");
}
/**
* {@inheritDoc}
*/
protected void addNavDetailLink(boolean link, Content liNav) {
}
}

149
langtools/src/share/classes/com/sun/tools/doclets/formats/html/PackageFrameWriter.java
View file

@ -25,18 +25,20 @@
package com.sun.tools.doclets.formats.html;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.javadoc.*;
import java.io.*;
import java.util.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.formats.html.markup.*;
/**
* Class to generate file for each package contents in the left-hand bottom
* frame. This will list all the Class Kinds in the package. A click on any
* class-kind will update the right-hand frame with the clicked class-kind page.
*
* @author Atul M Dambalkar
* @author Bhavesh Patel (Modified)
*/
public class PackageFrameWriter extends HtmlDocletWriter {
@ -90,10 +92,17 @@ public class PackageFrameWriter extends HtmlDocletWriter {
try {
packgen = new PackageFrameWriter(configuration, packageDoc);
String pkgName = Util.getPackageName(packageDoc);
packgen.printHtmlHeader(pkgName, configuration.metakeywords.getMetaKeywords(packageDoc), false);
packgen.printPackageHeader(pkgName);
packgen.generateClassListing();
packgen.printBodyHtmlEnd();
Content body = packgen.getBody(false, packgen.getWindowTitle(pkgName));
Content pkgNameContent = new StringContent(pkgName);
Content heading = HtmlTree.HEADING(HtmlConstants.TITLE_HEADING, HtmlStyle.bar,
packgen.getTargetPackageLink(packageDoc, "classFrame", pkgNameContent));
body.addContent(heading);
HtmlTree div = new HtmlTree(HtmlTag.DIV);
div.addStyle(HtmlStyle.indexContainer);
packgen.addClassListing(div);
body.addContent(div);
packgen.printHtmlDocument(
configuration.metakeywords.getMetaKeywords(packageDoc), false, body);
packgen.close();
} catch (IOException exc) {
configuration.standardmessage.error(
@ -104,55 +113,58 @@ public class PackageFrameWriter extends HtmlDocletWriter {
}
/**
* Generate class listing for all the classes in this package. Divide class
* Add class listing for all the classes in this package. Divide class
* listing as per the class kind and generate separate listing for
* Classes, Interfaces, Exceptions and Errors.
*
* @param contentTree the content tree to which the listing will be added
*/
protected void generateClassListing() {
protected void addClassListing(Content contentTree) {
Configuration config = configuration();
if (packageDoc.isIncluded()) {
generateClassKindListing(packageDoc.interfaces(),
configuration.getText("doclet.Interfaces"));
generateClassKindListing(packageDoc.ordinaryClasses(),
configuration.getText("doclet.Classes"));
generateClassKindListing(packageDoc.enums(),
configuration.getText("doclet.Enums"));
generateClassKindListing(packageDoc.exceptions(),
configuration.getText("doclet.Exceptions"));
generateClassKindListing(packageDoc.errors(),
configuration.getText("doclet.Errors"));
generateClassKindListing(packageDoc.annotationTypes(),
configuration.getText("doclet.AnnotationTypes"));
addClassKindListing(packageDoc.interfaces(),
getResource("doclet.Interfaces"), contentTree);
addClassKindListing(packageDoc.ordinaryClasses(),
getResource("doclet.Classes"), contentTree);
addClassKindListing(packageDoc.enums(),
getResource("doclet.Enums"), contentTree);
addClassKindListing(packageDoc.exceptions(),
getResource("doclet.Exceptions"), contentTree);
addClassKindListing(packageDoc.errors(),
getResource("doclet.Errors"), contentTree);
addClassKindListing(packageDoc.annotationTypes(),
getResource("doclet.AnnotationTypes"), contentTree);
} else {
String name = Util.getPackageName(packageDoc);
generateClassKindListing(config.classDocCatalog.interfaces(name),
configuration.getText("doclet.Interfaces"));
generateClassKindListing(config.classDocCatalog.ordinaryClasses(name),
configuration.getText("doclet.Classes"));
generateClassKindListing(config.classDocCatalog.enums(name),
configuration.getText("doclet.Enums"));
generateClassKindListing(config.classDocCatalog.exceptions(name),
configuration.getText("doclet.Exceptions"));
generateClassKindListing(config.classDocCatalog.errors(name),
configuration.getText("doclet.Errors"));
generateClassKindListing(config.classDocCatalog.annotationTypes(name),
configuration.getText("doclet.AnnotationTypes"));
addClassKindListing(config.classDocCatalog.interfaces(name),
getResource("doclet.Interfaces"), contentTree);
addClassKindListing(config.classDocCatalog.ordinaryClasses(name),
getResource("doclet.Classes"), contentTree);
addClassKindListing(config.classDocCatalog.enums(name),
getResource("doclet.Enums"), contentTree);
addClassKindListing(config.classDocCatalog.exceptions(name),
getResource("doclet.Exceptions"), contentTree);
addClassKindListing(config.classDocCatalog.errors(name),
getResource("doclet.Errors"), contentTree);
addClassKindListing(config.classDocCatalog.annotationTypes(name),
getResource("doclet.AnnotationTypes"), contentTree);
}
}
/**
* Generate specific class kind listing. Also add label to the listing.
* Add specific class kind listing. Also add label to the listing.
*
* @param arr Array of specific class kinds, namely Class or Interface or
* Exception or Error.
* @param label Label for the listing
* @param arr Array of specific class kinds, namely Class or Interface or Exception or Error
* @param labelContent content tree of the label to be added
* @param contentTree the content tree to which the class kind listing will be added
*/
protected void generateClassKindListing(ClassDoc[] arr, String label) {
protected void addClassKindListing(ClassDoc[] arr, Content labelContent,
Content contentTree) {
if(arr.length > 0) {
Arrays.sort(arr);
printPackageTableHeader();
fontSizeStyle("+1", "FrameHeadingFont");
boolean printedHeader = false;
HtmlTree ul = new HtmlTree(HtmlTag.UL);
ul.addAttr(HtmlAttr.TITLE, labelContent.toString());
for (int i = 0; i < arr.length; i++) {
if (documentedClasses != null &&
!documentedClasses.contains(arr[i])) {
@ -163,54 +175,19 @@ public class PackageFrameWriter extends HtmlDocletWriter {
continue;
}
if (!printedHeader) {
print(label);
fontEnd();
println("&nbsp;");
fontStyle("FrameItemFont");
Content heading = HtmlTree.HEADING(HtmlConstants.CONTENT_HEADING,
true, labelContent);
contentTree.addContent(heading);
printedHeader = true;
}
br();
printLink(new LinkInfoImpl(
LinkInfoImpl.PACKAGE_FRAME,
arr[i],
(arr[i].isInterface() ?
italicsText(arr[i].name()) :
arr[i].name()),"classFrame")
);
Content link = new RawHtml (getLink(new LinkInfoImpl(
LinkInfoImpl.PACKAGE_FRAME, arr[i],
(arr[i].isInterface() ? italicsText(arr[i].name()) :
arr[i].name()),"classFrame")));
Content li = HtmlTree.LI(link);
ul.addContent(li);
}
fontEnd();
printPackageTableFooter();
println();
contentTree.addContent(ul);
}
}
/**
* Print the package link at the top of the class kind listing. Clicking
* this link, package-summary page will appear in the right hand frame.
*
* @param heading Top Heading to be used for the class kind listing.
*/
protected void printPackageHeader(String heading) {
fontSizeStyle("+1", "FrameTitleFont");
printTargetPackageLink(packageDoc, "classFrame", heading);
fontEnd();
}
/**
* The table for the class kind listing.
*/
protected void printPackageTableHeader() {
table();
tr();
tdNowrap();
}
/**
* Closing Html tags for table of class kind listing.
*/
protected void printPackageTableFooter() {
tdEnd();
trEnd();
tableEnd();
}
}

155
langtools/src/share/classes/com/sun/tools/doclets/formats/html/PackageIndexFrameWriter.java
View file

@ -25,10 +25,11 @@
package com.sun.tools.doclets.formats.html;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.javadoc.*;
import java.io.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.formats.html.markup.*;
/**
* Generate the package index for the left-hand frame in the generated output.
@ -58,7 +59,7 @@ public class PackageIndexFrameWriter extends AbstractPackageIndexWriter {
String filename = "overview-frame.html";
try {
packgen = new PackageIndexFrameWriter(configuration, filename);
packgen.generatePackageIndexFile("doclet.Window_Overview", false);
packgen.buildPackageIndexFile("doclet.Window_Overview", false);
packgen.close();
} catch (IOException exc) {
configuration.standardmessage.error(
@ -69,114 +70,86 @@ public class PackageIndexFrameWriter extends AbstractPackageIndexWriter {
}
/**
* Print each package name on separate rows.
*
* @param pd PackageDoc
* {@inheritDoc}
*/
protected void printIndexRow(PackageDoc pd) {
fontStyle("FrameItemFont");
if (pd.name().length() > 0) {
print(getHyperLink(pathString(pd, "package-frame.html"), "",
pd.name(), false, "", "", "packageFrame"));
} else {
print(getHyperLink("package-frame.html", "", "&lt;unnamed package>",
false, "", "", "packageFrame"));
protected void addPackagesList(PackageDoc[] packages, String text,
String tableSummary, Content body) {
Content heading = HtmlTree.HEADING(HtmlConstants.PACKAGE_HEADING, true,
packagesLabel);
Content div = HtmlTree.DIV(HtmlStyle.indexContainer, heading);
HtmlTree ul = new HtmlTree(HtmlTag.UL);
ul.addAttr(HtmlAttr.TITLE, packagesLabel.toString());
for(int i = 0; i < packages.length; i++) {
if (packages[i] != null) {
ul.addContent(getPackage(packages[i]));
}
fontEnd();
br();
}
div.addContent(ul);
body.addContent(div);
}
/**
* Print the "-packagesheader" string in strong format, at top of the page,
* if it is not the empty string. Otherwise print the "-header" string.
* Despite the name, there is actually no navigation bar for this page.
* Gets each package name as a separate link.
*
* @param pd PackageDoc
* @return content for the package link
*/
protected void printNavigationBarHeader() {
printTableHeader(true);
fontSizeStyle("+1", "FrameTitleFont");
if (configuration.packagesheader.length() > 0) {
strong(replaceDocRootDir(configuration.packagesheader));
protected Content getPackage(PackageDoc pd) {
Content packageLinkContent;
Content packageLabel;
if (pd.name().length() > 0) {
packageLabel = getPackageLabel(pd.name());
packageLinkContent = getHyperLink(pathString(pd,
"package-frame.html"), "", packageLabel, "",
"packageFrame");
} else {
strong(replaceDocRootDir(configuration.header));
packageLabel = new RawHtml("&lt;unnamed package&gt;");
packageLinkContent = getHyperLink("package-frame.html",
"", packageLabel, "", "packageFrame");
}
fontEnd();
printTableFooter(true);
Content li = HtmlTree.LI(packageLinkContent);
return li;
}
/**
* {@inheritDoc}
*/
protected void addNavigationBarHeader(Content body) {
Content headerContent;
if (configuration.packagesheader.length() > 0) {
headerContent = new RawHtml(replaceDocRootDir(configuration.packagesheader));
} else {
headerContent = new RawHtml(replaceDocRootDir(configuration.header));
}
Content heading = HtmlTree.HEADING(HtmlConstants.TITLE_HEADING, true,
HtmlStyle.bar, headerContent);
body.addContent(heading);
}
/**
* Do nothing as there is no overview information in this page.
*/
protected void printOverviewHeader() {
protected void addOverviewHeader(Content body) {
}
/**
* Print Html "table" tag for the package index format.
* Adds "All Classes" link for the top of the left-hand frame page to the
* documentation tree.
*
* @param text Text string will not be used in this method.
* @param body the Content object to which the all classes link should be added
*/
protected void printIndexHeader(String text, String tableSummary) {
printTableHeader(false);
protected void addAllClassesLink(Content body) {
Content linkContent = getHyperLink("allclasses-frame.html", "",
allclassesLabel, "", "packageFrame");
Content div = HtmlTree.DIV(HtmlStyle.indexHeader, linkContent);
body.addContent(div);
}
/**
* Print Html closing "table" tag at the end of the package index.
* {@inheritDoc}
*/
protected void printIndexFooter() {
printTableFooter(false);
}
/**
* Print "All Classes" link at the top of the left-hand frame page.
*/
protected void printAllClassesPackagesLink() {
fontStyle("FrameItemFont");
print(getHyperLink("allclasses-frame.html", "",
configuration.getText("doclet.All_Classes"), false, "", "",
"packageFrame"));
fontEnd();
p();
fontSizeStyle("+1", "FrameHeadingFont");
printText("doclet.Packages");
fontEnd();
br();
}
/**
* Just print some space, since there is no navigation bar for this page.
*/
protected void printNavigationBarFooter() {
p();
space();
}
/**
* Print Html closing tags for the table for package index.
*
* @param isHeading true if this is a table for a heading.
*/
private void printTableFooter(boolean isHeading) {
if (isHeading) {
thEnd();
} else {
tdEnd();
}
trEnd();
tableEnd();
}
/**
* Print Html tags for the table for package index.
*
* @param isHeading true if this is a table for a heading.
*/
private void printTableHeader(boolean isHeading) {
table();
tr();
if (isHeading) {
thAlignNowrap("left");
} else {
tdNowrap();
}
protected void addNavigationBarFooter(Content body) {
Content p = HtmlTree.P(getSpace());
body.addContent(p);
}
}

188
langtools/src/share/classes/com/sun/tools/doclets/formats/html/PackageIndexWriter.java
View file

@ -25,10 +25,12 @@
package com.sun.tools.doclets.formats.html;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.javadoc.*;
import java.io.*;
import java.util.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.formats.html.markup.*;
/**
* Generate the package index page "overview-summary.html" for the right-hand
@ -83,7 +85,7 @@ public class PackageIndexWriter extends AbstractPackageIndexWriter {
String filename = "overview-summary.html";
try {
packgen = new PackageIndexWriter(configuration, filename);
packgen.generatePackageIndexFile("doclet.Window_Overview_Summary", true);
packgen.buildPackageIndexFile("doclet.Window_Overview_Summary", true);
packgen.close();
} catch (IOException exc) {
configuration.standardmessage.error(
@ -94,124 +96,140 @@ public class PackageIndexWriter extends AbstractPackageIndexWriter {
}
/**
* Print each package in separate rows in the index table. Generate link
* to each package.
*
* @param pkg Package to which link is to be generated.
*/
protected void printIndexRow(PackageDoc pkg) {
if(pkg != null && pkg.name().length() > 0) {
trBgcolorStyle("white", "TableRowColor");
summaryRow(20);
strong();
printPackageLink(pkg, Util.getPackageName(pkg), false);
strongEnd();
summaryRowEnd();
summaryRow(0);
printSummaryComment(pkg);
summaryRowEnd();
trEnd();
}
}
/**
* Depending upon the grouping information and their titles, generate
* Depending upon the grouping information and their titles, add
* separate table indices for each package group.
*
* @param body the documentation tree to which the index will be added
*/
protected void generateIndex() {
protected void addIndex(Content body) {
for (int i = 0; i < groupList.size(); i++) {
String groupname = groupList.get(i);
List<PackageDoc> list = groupPackageMap.get(groupname);
if (list != null && list.size() > 0) {
printIndexContents(list.toArray(new PackageDoc[list.size()]),
groupname,
configuration.getText("doclet.Member_Table_Summary",
groupname,
configuration.getText("doclet.packages")));
addIndexContents(list.toArray(new PackageDoc[list.size()]),
groupname, configuration.getText("doclet.Member_Table_Summary",
groupname, configuration.getText("doclet.packages")), body);
}
}
}
/**
* Print the overview summary comment for this documentation. Print one line
* {@inheritDoc}
*/
protected void addPackagesList(PackageDoc[] packages, String text,
String tableSummary, Content body) {
Content table = HtmlTree.TABLE(HtmlStyle.overviewSummary, 0, 3, 0, tableSummary,
getTableCaption(text));
table.addContent(getSummaryTableHeader(packageTableHeader, "col"));
Content tbody = new HtmlTree(HtmlTag.TBODY);
addPackagesList(packages, tbody);
table.addContent(tbody);
Content div = HtmlTree.DIV(HtmlStyle.contentContainer, table);
body.addContent(div);
}
/**
* Adds list of packages in the index table. Generate link to each package.
*
* @param packages Packages to which link is to be generated
* @param tbody the documentation tree to which the list will be added
*/
protected void addPackagesList(PackageDoc[] packages, Content tbody) {
for (int i = 0; i < packages.length; i++) {
if (packages[i] != null && packages[i].name().length() > 0) {
Content packageLinkContent = getPackageLink(packages[i],
getPackageName(packages[i]));
Content tdPackage = HtmlTree.TD(HtmlStyle.colFirst, packageLinkContent);
HtmlTree tdSummary = new HtmlTree(HtmlTag.TD);
tdSummary.addStyle(HtmlStyle.colLast);
addSummaryComment(packages[i], tdSummary);
HtmlTree tr = HtmlTree.TR(tdPackage);
tr.addContent(tdSummary);
if (i%2 == 0)
tr.addStyle(HtmlStyle.altColor);
else
tr.addStyle(HtmlStyle.rowColor);
tbody.addContent(tr);
}
}
}
/**
* Adds the overview summary comment for this documentation. Add one line
* summary at the top of the page and generate a link to the description,
* which is generated at the end of this page.
* which is added at the end of this page.
*
* @param body the documentation tree to which the overview header will be added
*/
protected void printOverviewHeader() {
protected void addOverviewHeader(Content body) {
if (root.inlineTags().length > 0) {
printSummaryComment(root);
p();
strong(configuration.getText("doclet.See"));
br();
printNbsps();
printHyperLink("", "overview_description",
configuration.getText("doclet.Description"), true);
p();
HtmlTree p = new HtmlTree(HtmlTag.P);
p.addStyle(HtmlStyle.subTitle);
addSummaryComment(root, p);
Content div = HtmlTree.DIV(HtmlStyle.header, p);
Content see = seeLabel;
see.addContent(" ");
Content descPara = HtmlTree.P(see);
Content descLink = getHyperLink("", "overview_description",
descriptionLabel, "", "");
descPara.addContent(descLink);
div.addContent(descPara);
body.addContent(div);
}
}
/**
* Print Html tags for the table for this package index.
*/
protected void printIndexHeader(String text, String tableSummary) {
tableIndexSummary(tableSummary);
tableCaptionStart();
print(text);
tableCaptionEnd();
summaryTableHeader(packageTableHeader, "col");
}
/**
* Print Html closing tags for the table for this package index.
*/
protected void printIndexFooter() {
tableEnd();
p();
space();
}
/**
* Print the overview comment as provided in the file specified by the
* Adds the overview comment as provided in the file specified by the
* "-overview" option on the command line.
*
* @param htmltree the documentation tree to which the overview comment will
* be added
*/
protected void printOverviewComment() {
protected void addOverviewComment(Content htmltree) {
if (root.inlineTags().length > 0) {
anchor("overview_description");
p();
printInlineComment(root);
p();
htmltree.addContent(getMarkerAnchor("overview_description"));
HtmlTree p = new HtmlTree(HtmlTag.P);
p.addStyle(HtmlStyle.subTitle);
addInlineComment(root, p);
htmltree.addContent(p);
}
}
/**
* Call {@link #printOverviewComment()} and then genrate the tag information
* as provided in the file specified by the "-overview" option on the
* command line.
* Adds the tag information as provided in the file specified by the
* "-overview" option on the command line.
*
* @param body the documentation tree to which the overview will be added
*/
protected void printOverview() throws IOException {
printOverviewComment();
printTags(root);
protected void addOverview(Content body) throws IOException {
HtmlTree div = new HtmlTree(HtmlTag.DIV);
div.addStyle(HtmlStyle.footer);
addOverviewComment(div);
addTagsInfo(root, div);
body.addContent(div);
}
/**
* Print the top text (from the -top option), the upper
* Adds the top text (from the -top option), the upper
* navigation bar, and then the title (from the"-title"
* option), at the top of page.
*
* @body the documentation tree to which the navigation bar header will be added
*/
protected void printNavigationBarHeader() {
printTop();
navLinks(true);
hr();
printConfigurationTitle();
protected void addNavigationBarHeader(Content body) {
addTop(body);
addNavLinks(true, body);
addConfigurationTitle(body);
}
/**
* Print the lower navigation bar and the bottom text
* Adds the lower navigation bar and the bottom text
* (from the -bottom option) at the bottom of page.
*
* @param the documentation tree to which the navigation bar footer will be added
*/
protected void printNavigationBarFooter() {
hr();
navLinks(false);
printBottom();
protected void addNavigationBarFooter(Content body) {
addNavLinks(false, body);
addBottom(body);
}
}

119
langtools/src/share/classes/com/sun/tools/doclets/formats/html/PackageTreeWriter.java
View file

@ -29,12 +29,15 @@ import java.io.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.formats.html.markup.*;
import com.sun.tools.doclets.internal.toolkit.*;
/**
* Class to generate Tree page for a package. The name of the file generated is
* "package-tree.html" and it is generated in the respective package directory.
*
* @author Atul M Dambalkar
* @author Bhavesh Patel (Modified)
*/
public class PackageTreeWriter extends AbstractTreeWriter {
@ -107,94 +110,96 @@ public class PackageTreeWriter extends AbstractTreeWriter {
* Generate a separate tree file for each package.
*/
protected void generatePackageTreeFile() throws IOException {
printHtmlHeader(packagedoc.name() + " "
+ configuration.getText("doclet.Window_Class_Hierarchy"), null, true);
printPackageTreeHeader();
Content body = getPackageTreeHeader();
Content headContent = getResource("doclet.Hierarchy_For_Package",
Util.getPackageName(packagedoc));
Content heading = HtmlTree.HEADING(HtmlConstants.TITLE_HEADING, false,
HtmlStyle.title, headContent);
Content div = HtmlTree.DIV(HtmlStyle.header, heading);
if (configuration.packages.length > 1) {
printLinkToMainTree();
addLinkToMainTree(div);
}
generateTree(classtree.baseclasses(), "doclet.Class_Hierarchy");
generateTree(classtree.baseinterfaces(), "doclet.Interface_Hierarchy");
generateTree(classtree.baseAnnotationTypes(), "doclet.Annotation_Type_Hierarchy");
generateTree(classtree.baseEnums(), "doclet.Enum_Hierarchy");
printPackageTreeFooter();
printBottom();
printBodyHtmlEnd();
body.addContent(div);
HtmlTree divTree = new HtmlTree(HtmlTag.DIV);
divTree.addStyle(HtmlStyle.contentContainer);
addTree(classtree.baseclasses(), "doclet.Class_Hierarchy", divTree);
addTree(classtree.baseinterfaces(), "doclet.Interface_Hierarchy", divTree);
addTree(classtree.baseAnnotationTypes(), "doclet.Annotation_Type_Hierarchy", divTree);
addTree(classtree.baseEnums(), "doclet.Enum_Hierarchy", divTree);
body.addContent(divTree);
addNavLinks(false, body);
addBottom(body);
printHtmlDocument(null, true, body);
}
/**
* Print the navigation bar header for the package tree file.
* Get the package tree header.
*
* @return a content tree for the header
*/
protected void printPackageTreeHeader() {
printTop();
navLinks(true);
hr();
center();
h2(configuration.getText("doclet.Hierarchy_For_Package",
Util.getPackageName(packagedoc)));
centerEnd();
protected Content getPackageTreeHeader() {
String title = packagedoc.name() + " " +
configuration.getText("doclet.Window_Class_Hierarchy");
Content bodyTree = getBody(true, getWindowTitle(title));
addTop(bodyTree);
addNavLinks(true, bodyTree);
return bodyTree;
}
/**
* Generate a link to the tree for all the packages.
* Add a link to the tree for all the packages.
*
* @param div the content tree to which the link will be added
*/
protected void printLinkToMainTree() {
dl();
dt();
strongText("doclet.Package_Hierarchies");
dtEnd();
dd();
navLinkMainTree(configuration.getText("doclet.All_Packages"));
ddEnd();
dlEnd();
hr();
protected void addLinkToMainTree(Content div) {
Content span = HtmlTree.SPAN(HtmlStyle.strong,
getResource("doclet.Package_Hierarchies"));
div.addContent(span);
HtmlTree ul = new HtmlTree (HtmlTag.UL);
ul.addStyle(HtmlStyle.horizontal);
ul.addContent(getNavLinkMainTree(configuration.getText("doclet.All_Packages")));
div.addContent(ul);
}
/**
* Print the navigation bar footer for the package tree file.
* Get link for the previous package tree file.
*
* @return a content tree for the link
*/
protected void printPackageTreeFooter() {
hr();
navLinks(false);
}
/**
* Link for the previous package tree file.
*/
protected void navLinkPrevious() {
protected Content getNavLinkPrevious() {
if (prev == null) {
navLinkPrevious(null);
return getNavLinkPrevious(null);
} else {
String path = DirectoryManager.getRelativePath(packagedoc.name(),
prev.name());
navLinkPrevious(path + "package-tree.html");
return getNavLinkPrevious(path + "package-tree.html");
}
}
/**
* Link for the next package tree file.
* Get link for the next package tree file.
*
* @return a content tree for the link
*/
protected void navLinkNext() {
protected Content getNavLinkNext() {
if (next == null) {
navLinkNext(null);
return getNavLinkNext(null);
} else {
String path = DirectoryManager.getRelativePath(packagedoc.name(),
next.name());
navLinkNext(path + "package-tree.html");
return getNavLinkNext(path + "package-tree.html");
}
}
/**
* Link to the package summary page for the package of this tree.
* Get link to the package summary page for the package of this tree.
*
* @return a content tree for the package link
*/
protected void navLinkPackage() {
navCellStart();
printHyperLink("package-summary.html", "", configuration.getText("doclet.Package"),
true, "NavBarFont1");
navCellEnd();
protected Content getNavLinkPackage() {
Content linkContent = getHyperLink("package-summary.html", "",
packageLabel);
Content li = HtmlTree.LI(linkContent);
return li;
}
}

256
langtools/src/share/classes/com/sun/tools/doclets/formats/html/PackageUseWriter.java
View file

@ -25,10 +25,12 @@
package com.sun.tools.doclets.formats.html;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.javadoc.*;
import java.io.*;
import java.util.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.formats.html.markup.*;
import com.sun.tools.doclets.internal.toolkit.*;
/**
* Generate package usage information.
@ -106,49 +108,74 @@ public class PackageUseWriter extends SubWriterHolderWriter {
/**
* Print the class use list.
* Generate the package use list.
*/
protected void generatePackageUseFile() throws IOException {
printPackageUseHeader();
Content body = getPackageUseHeader();
HtmlTree div = new HtmlTree(HtmlTag.DIV);
div.addStyle(HtmlStyle.contentContainer);
if (usingPackageToUsedClasses.isEmpty()) {
printText("doclet.ClassUse_No.usage.of.0", pkgdoc.name());
p();
div.addContent(getResource(
"doclet.ClassUse_No.usage.of.0", pkgdoc.name()));
} else {
generatePackageUse();
addPackageUse(div);
}
printPackageUseFooter();
body.addContent(div);
addNavLinks(false, body);
addBottom(body);
printHtmlDocument(null, true, body);
}
/**
* Print the class use list.
* Add the package use information.
*
* @param contentTree the content tree to which the package use information will be added
*/
protected void generatePackageUse() throws IOException {
protected void addPackageUse(Content contentTree) throws IOException {
HtmlTree ul = new HtmlTree(HtmlTag.UL);
ul.addStyle(HtmlStyle.blockList);
if (configuration.packages.length > 1) {
generatePackageList();
addPackageList(ul);
}
generateClassList();
addClassList(ul);
contentTree.addContent(ul);
}
protected void generatePackageList() throws IOException {
tableIndexSummary(useTableSummary);
tableCaptionStart();
printText("doclet.ClassUse_Packages.that.use.0",
getPackageLink(pkgdoc, Util.getPackageName(pkgdoc), false));
tableCaptionEnd();
summaryTableHeader(packageTableHeader, "col");
/**
* Add the list of packages that use the given package.
*
* @param contentTree the content tree to which the package list will be added
*/
protected void addPackageList(Content contentTree) throws IOException {
Content table = HtmlTree.TABLE(0, 3, 0, useTableSummary,
getTableCaption(configuration().getText(
"doclet.ClassUse_Packages.that.use.0",
getPackageLinkString(pkgdoc, Util.getPackageName(pkgdoc), false))));
table.addContent(getSummaryTableHeader(packageTableHeader, "col"));
Content tbody = new HtmlTree(HtmlTag.TBODY);
Iterator<String> it = usingPackageToUsedClasses.keySet().iterator();
while (it.hasNext()) {
for (int i = 0; it.hasNext(); i++) {
PackageDoc pkg = configuration.root.packageNamed(it.next());
generatePackageUse(pkg);
HtmlTree tr = new HtmlTree(HtmlTag.TR);
if (i % 2 == 0) {
tr.addStyle(HtmlStyle.altColor);
} else {
tr.addStyle(HtmlStyle.rowColor);
}
tableEnd();
space();
p();
addPackageUse(pkg, tr);
tbody.addContent(tr);
}
table.addContent(tbody);
Content li = HtmlTree.LI(HtmlStyle.blockList, table);
contentTree.addContent(li);
}
protected void generateClassList() throws IOException {
/**
* Add the list of classes that use the given package.
*
* @param contentTree the content tree to which the class list will be added
*/
protected void addClassList(Content contentTree) throws IOException {
String[] classTableHeader = new String[] {
configuration.getText("doclet.0_and_1",
configuration.getText("doclet.Class"),
@ -158,117 +185,126 @@ public class PackageUseWriter extends SubWriterHolderWriter {
while (itp.hasNext()) {
String packageName = itp.next();
PackageDoc usingPackage = configuration.root.packageNamed(packageName);
HtmlTree li = new HtmlTree(HtmlTag.LI);
li.addStyle(HtmlStyle.blockList);
if (usingPackage != null) {
anchor(usingPackage.name());
li.addContent(getMarkerAnchor(usingPackage.name()));
}
tableIndexSummary(configuration.getText("doclet.Use_Table_Summary",
configuration.getText("doclet.classes")));
tableCaptionStart();
printText("doclet.ClassUse_Classes.in.0.used.by.1",
getPackageLink(pkgdoc, Util.getPackageName(pkgdoc), false),
getPackageLink(usingPackage,Util.getPackageName(usingPackage), false));
tableCaptionEnd();
summaryTableHeader(classTableHeader, "col");
String tableSummary = configuration.getText("doclet.Use_Table_Summary",
configuration.getText("doclet.classes"));
Content table = HtmlTree.TABLE(0, 3, 0, tableSummary,
getTableCaption(configuration().getText(
"doclet.ClassUse_Classes.in.0.used.by.1",
getPackageLinkString(pkgdoc, Util.getPackageName(pkgdoc), false),
getPackageLinkString(usingPackage,Util.getPackageName(usingPackage), false))));
table.addContent(getSummaryTableHeader(classTableHeader, "col"));
Content tbody = new HtmlTree(HtmlTag.TBODY);
Iterator<ClassDoc> itc =
usingPackageToUsedClasses.get(packageName).iterator();
while (itc.hasNext()) {
printClassRow(itc.next(), packageName);
for (int i = 0; itc.hasNext(); i++) {
HtmlTree tr = new HtmlTree(HtmlTag.TR);
if (i % 2 == 0) {
tr.addStyle(HtmlStyle.altColor);
} else {
tr.addStyle(HtmlStyle.rowColor);
}
tableEnd();
space();
p();
addClassRow(itc.next(), packageName, tr);
tbody.addContent(tr);
}
table.addContent(tbody);
li.addContent(table);
contentTree.addContent(li);
}
}
protected void printClassRow(ClassDoc usedClass, String packageName) {
/**
* Add a row for the class that uses the given package.
*
* @param usedClass the class that uses the given package
* @param packageName the name of the package to which the class belongs
* @param contentTree the content tree to which the row will be added
*/
protected void addClassRow(ClassDoc usedClass, String packageName,
Content contentTree) {
String path = pathString(usedClass,
"class-use/" + usedClass.name() + ".html");
trBgcolorStyle("white", "TableRowColor");
summaryRow(0);
strong();
printHyperLink(path, packageName, usedClass.name(), true);
strongEnd();
println(); br();
printNbsps();
printIndexComment(usedClass);
summaryRowEnd();
trEnd();
Content td = HtmlTree.TD(HtmlStyle.colOne,
getHyperLink(path, packageName, new StringContent(usedClass.name())));
addIndexComment(usedClass, td);
contentTree.addContent(td);
}
/**
* Print the package use list.
* Add the package use information.
*
* @param pkg the package that used the given package
* @param contentTree the content tree to which the information will be added
*/
protected void generatePackageUse(PackageDoc pkg) throws IOException {
trBgcolorStyle("white", "TableRowColor");
summaryRow(0);
//Just want an anchor here.
printHyperLink("", pkg.name(), Util.getPackageName(pkg), true);
summaryRowEnd();
summaryRow(0);
if (pkg != null) {
printSummaryComment(pkg);
}
space();
summaryRowEnd();
trEnd();
protected void addPackageUse(PackageDoc pkg, Content contentTree) throws IOException {
Content tdFirst = HtmlTree.TD(HtmlStyle.colFirst,
getHyperLink("", pkg.name(), new StringContent(Util.getPackageName(pkg))));
contentTree.addContent(tdFirst);
HtmlTree tdLast = new HtmlTree(HtmlTag.TD);
tdLast.addStyle(HtmlStyle.colLast);
if (pkg != null)
addSummaryComment(pkg, tdLast);
else
tdLast.addContent(getSpace());
contentTree.addContent(tdLast);
}
/**
* Print the header for the class use Listing.
* Get the header for the package use listing.
*
* @return a content tree representing the package use header
*/
protected void printPackageUseHeader() {
String packageLabel = configuration.getText("doclet.Package");
protected Content getPackageUseHeader() {
String packageText = configuration.getText("doclet.Package");
String name = pkgdoc.name();
printHtmlHeader(configuration.getText("doclet.Window_ClassUse_Header",
packageLabel, name), null, true);
printTop();
navLinks(true);
hr();
center();
h2();
strongText("doclet.ClassUse_Title", packageLabel, name);
h2End();
centerEnd();
String title = configuration.getText("doclet.Window_ClassUse_Header",
packageText, name);
Content bodyTree = getBody(true, getWindowTitle(title));
addTop(bodyTree);
addNavLinks(true, bodyTree);
Content headContent = getResource("doclet.ClassUse_Title", packageText, name);
Content heading = HtmlTree.HEADING(HtmlConstants.TITLE_HEADING, true,
HtmlStyle.title, headContent);
Content div = HtmlTree.DIV(HtmlStyle.header, heading);
bodyTree.addContent(div);
return bodyTree;
}
/**
* Print the footer for the class use Listing.
* Get this package link.
*
* @return a content tree for the package link
*/
protected void printPackageUseFooter() {
hr();
navLinks(false);
printBottom();
printBodyHtmlEnd();
}
/**
* Print this package link
*/
protected void navLinkPackage() {
navCellStart();
printHyperLink("package-summary.html", "", configuration.getText("doclet.Package"),
true, "NavBarFont1");
navCellEnd();
protected Content getNavLinkPackage() {
Content linkContent = getHyperLink("package-summary.html", "",
packageLabel);
Content li = HtmlTree.LI(linkContent);
return li;
}
/**
* Print class use link
* Get the use link.
*
* @return a content tree for the use link
*/
protected void navLinkClassUse() {
navCellRevStart();
fontStyle("NavBarFont1Rev");
strongText("doclet.navClassUse");
fontEnd();
navCellEnd();
protected Content getNavLinkClassUse() {
Content li = HtmlTree.LI(HtmlStyle.navBarCell1Rev, useLabel);
return li;
}
protected void navLinkTree() {
navCellStart();
printHyperLink("package-tree.html", "", configuration.getText("doclet.Tree"),
true, "NavBarFont1");
navCellEnd();
/**
* Get the tree link.
*
* @return a content tree for the tree link
*/
protected Content getNavLinkTree() {
Content linkContent = getHyperLink("package-tree.html", "",
treeLabel);
Content li = HtmlTree.LI(linkContent);
return li;
}
}

245
langtools/src/share/classes/com/sun/tools/doclets/formats/html/PackageWriterImpl.java
View file

@ -25,12 +25,12 @@
package com.sun.tools.doclets.formats.html;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.javadoc.*;
import java.io.*;
import java.util.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.formats.html.markup.*;
/**
* Class to generate file for each package contents in the right-hand
@ -98,189 +98,206 @@ public class PackageWriterImpl extends HtmlDocletWriter
/**
* {@inheritDoc}
*/
public void writeSummaryHeader() {}
public Content getPackageHeader(String heading) {
String pkgName = packageDoc.name();
Content bodyTree = getBody(true, getWindowTitle(pkgName));
addTop(bodyTree);
addNavLinks(true, bodyTree);
HtmlTree div = new HtmlTree(HtmlTag.DIV);
div.addStyle(HtmlStyle.header);
Content annotationContent = new HtmlTree(HtmlTag.P);
addAnnotationInfo(packageDoc, annotationContent);
div.addContent(annotationContent);
Content tHeading = HtmlTree.HEADING(HtmlConstants.TITLE_HEADING, true,
HtmlStyle.title, packageLabel);
tHeading.addContent(getSpace());
Content packageHead = new RawHtml(heading);
tHeading.addContent(packageHead);
div.addContent(tHeading);
if (packageDoc.inlineTags().length > 0 && ! configuration.nocomment) {
HtmlTree p = new HtmlTree(HtmlTag.P);
p.addStyle(HtmlStyle.subTitle);
addSummaryComment(packageDoc, p);
div.addContent(p);
Content space = getSpace();
Content descLink = getHyperLink("", "package_description",
descriptionLabel, "", "");
Content descPara = new HtmlTree(HtmlTag.P, seeLabel, space, descLink);
div.addContent(descPara);
}
bodyTree.addContent(div);
return bodyTree;
}
/**
* {@inheritDoc}
*/
public void writeSummaryFooter() {}
public Content getContentHeader() {
HtmlTree div = new HtmlTree(HtmlTag.DIV);
div.addStyle(HtmlStyle.contentContainer);
return div;
}
/**
* {@inheritDoc}
*/
public void writeClassesSummary(ClassDoc[] classes, String label, String tableSummary, String[] tableHeader) {
public Content getSummaryHeader() {
HtmlTree ul = new HtmlTree(HtmlTag.UL);
ul.addStyle(HtmlStyle.blockList);
return ul;
}
/**
* {@inheritDoc}
*/
public void addClassesSummary(ClassDoc[] classes, String label,
String tableSummary, String[] tableHeader, Content summaryContentTree) {
if(classes.length > 0) {
Arrays.sort(classes);
tableIndexSummary(tableSummary);
boolean printedHeading = false;
Content caption = getTableCaption(label);
Content table = HtmlTree.TABLE(HtmlStyle.packageSummary, 0, 3, 0,
tableSummary, caption);
table.addContent(getSummaryTableHeader(tableHeader, "col"));
Content tbody = new HtmlTree(HtmlTag.TBODY);
for (int i = 0; i < classes.length; i++) {
if (!printedHeading) {
printTableCaption(label);
printFirstRow(tableHeader);
printedHeading = true;
}
if (!Util.isCoreClass(classes[i]) ||
!configuration.isGeneratedDoc(classes[i])) {
continue;
}
trBgcolorStyle("white", "TableRowColor");
summaryRow(15);
strong();
printLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_PACKAGE,
classes[i], false));
strongEnd();
summaryRowEnd();
summaryRow(0);
Content classContent = new RawHtml(getLink(new LinkInfoImpl(
LinkInfoImpl.CONTEXT_PACKAGE, classes[i], false)));
Content tdClass = HtmlTree.TD(HtmlStyle.colFirst, classContent);
HtmlTree tr = HtmlTree.TR(tdClass);
if (i%2 == 0)
tr.addStyle(HtmlStyle.altColor);
else
tr.addStyle(HtmlStyle.rowColor);
HtmlTree tdClassDescription = new HtmlTree(HtmlTag.TD);
tdClassDescription.addStyle(HtmlStyle.colLast);
if (Util.isDeprecated(classes[i])) {
strongText("doclet.Deprecated");
tdClassDescription.addContent(deprecatedLabel);
if (classes[i].tags("deprecated").length > 0) {
space();
printSummaryDeprecatedComment(classes[i],
classes[i].tags("deprecated")[0]);
}
} else {
printSummaryComment(classes[i]);
}
summaryRowEnd();
trEnd();
}
tableEnd();
println("&nbsp;");
p();
addSummaryDeprecatedComment(classes[i],
classes[i].tags("deprecated")[0], tdClassDescription);
}
}
/**
* Print the table caption for the class-listing.
*
* @param label label for the Class kind listing.
*/
protected void printTableCaption(String label) {
tableCaptionStart();
print(label);
tableCaptionEnd();
else
addSummaryComment(classes[i], tdClassDescription);
tr.addContent(tdClassDescription);
tbody.addContent(tr);
}
table.addContent(tbody);
Content li = HtmlTree.LI(HtmlStyle.blockList, table);
summaryContentTree.addContent(li);
}
/**
* Print the table heading for the class-listing.
*
* @param tableHeader table header string for the Class listing.
*/
protected void printFirstRow(String[] tableHeader) {
summaryTableHeader(tableHeader, "col");
}
/**
* {@inheritDoc}
*/
public void writePackageDescription() {
public void addPackageDescription(Content packageContentTree) {
if (packageDoc.inlineTags().length > 0) {
anchor("package_description");
h2(configuration.getText("doclet.Package_Description", packageDoc.name()));
p();
printInlineComment(packageDoc);
p();
packageContentTree.addContent(getMarkerAnchor("package_description"));
Content h2Content = new StringContent(
configuration.getText("doclet.Package_Description",
packageDoc.name()));
packageContentTree.addContent(HtmlTree.HEADING(HtmlConstants.PACKAGE_HEADING,
true, h2Content));
addInlineComment(packageDoc, packageContentTree);
}
}
/**
* {@inheritDoc}
*/
public void writePackageTags() {
printTags(packageDoc);
public void addPackageTags(Content packageContentTree) {
addTagsInfo(packageDoc, packageContentTree);
}
/**
* {@inheritDoc}
*/
public void writePackageHeader(String heading) {
String pkgName = packageDoc.name();
printHtmlHeader(pkgName,
configuration.metakeywords.getMetaKeywords(packageDoc), true);
printTop();
navLinks(true);
hr();
writeAnnotationInfo(packageDoc);
h2(configuration.getText("doclet.Package") + " " + heading);
if (packageDoc.inlineTags().length > 0 && ! configuration.nocomment) {
printSummaryComment(packageDoc);
p();
strong(configuration.getText("doclet.See"));
br();
printNbsps();
printHyperLink("", "package_description",
configuration.getText("doclet.Description"), true);
p();
}
public void addPackageFooter(Content contentTree) {
addNavLinks(false, contentTree);
addBottom(contentTree);
}
/**
* {@inheritDoc}
*/
public void writePackageFooter() {
hr();
navLinks(false);
printBottom();
printBodyHtmlEnd();
public void printDocument(Content contentTree) {
printHtmlDocument(configuration.metakeywords.getMetaKeywords(packageDoc),
true, contentTree);
}
/**
* Print "Use" link for this pacakge in the navigation bar.
* Get "Use" link for this pacakge in the navigation bar.
*
* @return a content tree for the class use link
*/
protected void navLinkClassUse() {
navCellStart();
printHyperLink("package-use.html", "", configuration.getText("doclet.navClassUse"),
true, "NavBarFont1");
navCellEnd();
protected Content getNavLinkClassUse() {
Content useLink = getHyperLink("package-use.html", "",
useLabel, "", "");
Content li = HtmlTree.LI(useLink);
return li;
}
/**
* Print "PREV PACKAGE" link in the navigation bar.
* Get "PREV PACKAGE" link in the navigation bar.
*
* @return a content tree for the previous link
*/
protected void navLinkPrevious() {
public Content getNavLinkPrevious() {
Content li;
if (prev == null) {
printText("doclet.Prev_Package");
li = HtmlTree.LI(prevpackageLabel);
} else {
String path = DirectoryManager.getRelativePath(packageDoc.name(),
prev.name());
printHyperLink(path + "package-summary.html", "",
configuration.getText("doclet.Prev_Package"), true);
li = HtmlTree.LI(getHyperLink(path + "package-summary.html", "",
prevpackageLabel, "", ""));
}
return li;
}
/**
* Print "NEXT PACKAGE" link in the navigation bar.
* Get "NEXT PACKAGE" link in the navigation bar.
*
* @return a content tree for the next link
*/
protected void navLinkNext() {
public Content getNavLinkNext() {
Content li;
if (next == null) {
printText("doclet.Next_Package");
li = HtmlTree.LI(nextpackageLabel);
} else {
String path = DirectoryManager.getRelativePath(packageDoc.name(),
next.name());
printHyperLink(path + "package-summary.html", "",
configuration.getText("doclet.Next_Package"), true);
li = HtmlTree.LI(getHyperLink(path + "package-summary.html", "",
nextpackageLabel, "", ""));
}
return li;
}
/**
* Print "Tree" link in the navigation bar. This will be link to the package
* Get "Tree" link in the navigation bar. This will be link to the package
* tree file.
*
* @return a content tree for the tree link
*/
protected void navLinkTree() {
navCellStart();
printHyperLink("package-tree.html", "", configuration.getText("doclet.Tree"),
true, "NavBarFont1");
navCellEnd();
protected Content getNavLinkTree() {
Content useLink = getHyperLink("package-tree.html", "",
treeLabel, "", "");
Content li = HtmlTree.LI(useLink);
return li;
}
/**
* Highlight "Package" in the navigation bar, as this is the package page.
*
* @return a content tree for the package link
*/
protected void navLinkPackage() {
navCellRevStart();
fontStyle("NavBarFont1Rev");
strongText("doclet.Package");
fontEnd();
navCellEnd();
protected Content getNavLinkPackage() {
Content li = HtmlTree.LI(HtmlStyle.navBarCell1Rev, packageLabel);
return li;
}
}

167
langtools/src/share/classes/com/sun/tools/doclets/formats/html/SerializedFormWriterImpl.java
View file

@ -25,8 +25,10 @@
package com.sun.tools.doclets.formats.html;
import com.sun.javadoc.*;
import java.io.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.formats.html.markup.*;
import com.sun.tools.doclets.internal.toolkit.*;
/**
* Generate the Serialized Form Information Page.
@ -64,57 +66,83 @@ public class SerializedFormWriterImpl extends SubWriterHolderWriter
}
/**
* Write the given package header.
* Get the given header.
*
* @param packageName the package header to write.
* @param header the header to write
* @return the body content tree
*/
public void writePackageHeader(String packageName) {
hr(4, "noshade");
tableHeader();
thAlign("center");
font("+2");
strongText("doclet.Package");
print(' ');
strong(packageName);
tableFooter();
public Content getHeader(String header) {
Content bodyTree = getBody(true, getWindowTitle(header));
addTop(bodyTree);
addNavLinks(true, bodyTree);
Content h1Content = new StringContent(header);
Content heading = HtmlTree.HEADING(HtmlConstants.TITLE_HEADING, true,
HtmlStyle.title, h1Content);
Content div = HtmlTree.DIV(HtmlStyle.header, heading);
bodyTree.addContent(div);
return bodyTree;
}
/**
* Write the serial UID info.
* Get the serialized form summaries header.
*
* @param header the header that will show up before the UID.
* @param serialUID the serial UID to print.
* @return the serialized form summary header tree
*/
public void writeSerialUIDInfo(String header, String serialUID) {
strong(header + "&nbsp;");
println(serialUID);
p();
public Content getSerializedSummariesHeader() {
HtmlTree ul = new HtmlTree(HtmlTag.UL);
ul.addStyle(HtmlStyle.blockList);
return ul;
}
/**
* Write the footer.
* Get the package serialized form header.
*
* @return the package serialized form header tree
*/
public void writeFooter() {
p();
hr();
navLinks(false);
printBottom();
printBodyHtmlEnd();
public Content getPackageSerializedHeader() {
HtmlTree li = new HtmlTree(HtmlTag.LI);
li.addStyle(HtmlStyle.blockList);
return li;
}
/**
* Get the given package header.
*
* @param packageName the package header to write
* @return a content tree for the package header
*/
public Content getPackageHeader(String packageName) {
Content heading = HtmlTree.HEADING(HtmlConstants.PACKAGE_HEADING, true,
packageLabel);
heading.addContent(getSpace());
heading.addContent(packageName);
return heading;
}
/**
* Write the serializable class heading.
* Get the serialized class header.
*
* @param classDoc the class being processed.
* @return a content tree for the serialized class header
*/
public void writeClassHeader(ClassDoc classDoc) {
public Content getClassSerializedHeader() {
HtmlTree ul = new HtmlTree(HtmlTag.UL);
ul.addStyle(HtmlStyle.blockList);
return ul;
}
/**
* Get the serializable class heading.
*
* @param classDoc the class being processed
* @return a content tree for the class header
*/
public Content getClassHeader(ClassDoc classDoc) {
String classLink = (classDoc.isPublic() || classDoc.isProtected())?
getLink(new LinkInfoImpl(classDoc,
configuration.getClassName(classDoc))):
classDoc.qualifiedName();
p();
anchor(classDoc.qualifiedName());
Content li = HtmlTree.LI(HtmlStyle.blockList, getMarkerAnchor(
classDoc.qualifiedName()));
String superClassLink =
classDoc.superclassType() != null ?
getLink(new LinkInfoImpl(LinkInfoImpl.CONTEXT_SERIALIZED_FORM,
@ -128,12 +156,77 @@ public class SerializedFormWriterImpl extends SubWriterHolderWriter
configuration.getText(
"doclet.Class_0_extends_implements_serializable", classLink,
superClassLink);
tableHeader();
thAlignColspan("left", 2);
font("+2");
strong(className);
tableFooter();
p();
Content classNameContent = new RawHtml(className);
li.addContent(HtmlTree.HEADING(HtmlConstants.SERIALIZED_MEMBER_HEADING,
classNameContent));
return li;
}
/**
* Get the serial UID info header.
*
* @return a content tree for the serial uid info header
*/
public Content getSerialUIDInfoHeader() {
HtmlTree dl = new HtmlTree(HtmlTag.DL);
dl.addStyle(HtmlStyle.nameValue);
return dl;
}
/**
* Adds the serial UID info.
*
* @param header the header that will show up before the UID.
* @param serialUID the serial UID to print.
* @param serialUidTree the serial UID content tree to which the serial UID
* content will be added
*/
public void addSerialUIDInfo(String header, String serialUID,
Content serialUidTree) {
Content headerContent = new StringContent(header);
serialUidTree.addContent(HtmlTree.DT(headerContent));
Content serialContent = new StringContent(serialUID);
serialUidTree.addContent(HtmlTree.DD(serialContent));
}
/**
* Get the class serialize content header.
*
* @return a content tree for the class serialize content header
*/
public Content getClassContentHeader() {
HtmlTree ul = new HtmlTree(HtmlTag.UL);
ul.addStyle(HtmlStyle.blockList);
return ul;
}
/**
* Get the serialized content tree section.
*
* @param serializedTreeContent the serialized content tree to be added
* @return a div content tree
*/
public Content getSerializedContent(Content serializedTreeContent) {
Content divContent = HtmlTree.DIV(HtmlStyle.serializedFormContainer,
serializedTreeContent);
return divContent;
}
/**
* Add the footer.
*
* @param serializedTree the serialized tree to be added
*/
public void addFooter(Content serializedTree) {
addNavLinks(false, serializedTree);
addBottom(serializedTree);
}
/**
* {@inheritDoc}
*/
public void printDocument(Content serializedTree) {
printHtmlDocument(null, true, serializedTree);
}
private void tableHeader() {

45
langtools/src/share/classes/com/sun/tools/doclets/formats/html/SingleIndexWriter.java
View file

@ -25,9 +25,10 @@
package com.sun.tools.doclets.formats.html;
import com.sun.tools.doclets.internal.toolkit.util.*;
import java.io.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.formats.html.markup.*;
import com.sun.tools.doclets.internal.toolkit.*;
/**
* Generate only one index file for all the Member Names with Indexing in
@ -36,6 +37,7 @@ import java.io.*;
*
* @see java.lang.Character
* @author Atul M Dambalkar
* @author Bhavesh Patel (Modified)
*/
public class SingleIndexWriter extends AbstractIndexWriter {
@ -82,34 +84,35 @@ public class SingleIndexWriter extends AbstractIndexWriter {
* Member Field, Method and Constructor Description.
*/
protected void generateIndexFile() throws IOException {
printHtmlHeader(configuration.getText("doclet.Window_Single_Index"),
null, true);
printTop();
navLinks(true);
printLinksForIndexes();
hr();
String title = configuration.getText("doclet.Window_Single_Index");
Content body = getBody(true, getWindowTitle(title));
addTop(body);
addNavLinks(true, body);
HtmlTree divTree = new HtmlTree(HtmlTag.DIV);
divTree.addStyle(HtmlStyle.contentContainer);
addLinksForIndexes(divTree);
for (int i = 0; i < indexbuilder.elements().length; i++) {
Character unicode = (Character)((indexbuilder.elements())[i]);
generateContents(unicode, indexbuilder.getMemberList(unicode));
addContents(unicode, indexbuilder.getMemberList(unicode), divTree);
}
printLinksForIndexes();
navLinks(false);
printBottom();
printBodyHtmlEnd();
addLinksForIndexes(divTree);
body.addContent(divTree);
addNavLinks(false, body);
addBottom(body);
printHtmlDocument(null, true, body);
}
/**
* Print Links for all the Index Files per unicode character.
* Add links for all the Index Files per unicode character.
*
* @param contentTree the content tree to which the links for indexes will be added
*/
protected void printLinksForIndexes() {
protected void addLinksForIndexes(Content contentTree) {
for (int i = 0; i < indexbuilder.elements().length; i++) {
String unicode = (indexbuilder.elements())[i].toString();
printHyperLink("#_" + unicode + "_", unicode);
print(' ');
contentTree.addContent(
getHyperLink("#_" + unicode + "_", new StringContent(unicode)));
contentTree.addContent(getSpace());
}
}
}

199
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/util/SourceToHTMLConverter.java → langtools/src/share/classes/com/sun/tools/doclets/formats/html/SourceToHTMLConverter.java
View file

@ -23,14 +23,14 @@
* questions.
*/
package com.sun.tools.doclets.internal.toolkit.util;
package com.sun.tools.doclets.formats.html;
import java.io.*;
import java.util.*;
import javax.tools.FileObject;
import com.sun.javadoc.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.formats.html.markup.*;
/**
* Converts Java Source Code to HTML.
@ -40,27 +40,28 @@ import com.sun.tools.doclets.internal.toolkit.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.4
*/
public class SourceToHTMLConverter {
/**
* The background color.
*/
protected static final String BGCOLOR = "white";
/**
* The line number color.
*/
protected static final String LINE_NO_COLOR = "green";
/**
* The number of trailing blank lines at the end of the page.
* This is inserted so that anchors at the bottom of small pages
* can be reached.
*/
protected static final int NUM_BLANK_LINES = 60;
private static final int NUM_BLANK_LINES = 60;
/**
* New line to be added to the documentation.
*/
private static final Content NEW_LINE = new RawHtml(DocletConstants.NL);
/**
* Relative path from the documentation root to the file that is being
* generated.
*/
private static String relativePath = "";
/**
* Source is converted to HTML using static methods below.
@ -69,11 +70,13 @@ public class SourceToHTMLConverter {
/**
* Convert the Classes in the given RootDoc to an HTML.
*
* @param configuration the configuration.
* @param rd the RootDoc to convert.
* @param outputdir the name of the directory to output to.
*/
public static void convertRoot(Configuration configuration, RootDoc rd, String outputdir) {
public static void convertRoot(ConfigurationImpl configuration, RootDoc rd,
String outputdir) {
if (rd == null || outputdir == null) {
return;
}
@ -90,11 +93,13 @@ public class SourceToHTMLConverter {
/**
* Convert the Classes in the given Package to an HTML.
*
* @param configuration the configuration.
* @param pd the Package to convert.
* @param outputdir the name of the directory to output to.
*/
public static void convertPackage(Configuration configuration, PackageDoc pd, String outputdir) {
public static void convertPackage(ConfigurationImpl configuration, PackageDoc pd,
String outputdir) {
if (pd == null || outputdir == null) {
return;
}
@ -107,8 +112,10 @@ public class SourceToHTMLConverter {
/**
* Return the directory write output to for the given package.
*
* @param outputDir the directory to output to.
* @param pd the Package to generate output for.
* @return the package output directory as a String.
*/
private static String getPackageOutputDir(String outputDir, PackageDoc pd) {
return outputDir + File.separator +
@ -117,11 +124,13 @@ public class SourceToHTMLConverter {
/**
* Convert the given Class to an HTML.
*
* @param configuration the configuration.
* @param cd the class to convert.
* @param outputdir the name of the directory to output to.
*/
public static void convertClass(Configuration configuration, ClassDoc cd, String outputdir) {
public static void convertClass(ConfigurationImpl configuration, ClassDoc cd,
String outputdir) {
if (cd == null || outputdir == null) {
return;
}
@ -145,19 +154,23 @@ public class SourceToHTMLConverter {
LineNumberReader reader = new LineNumberReader(r);
int lineno = 1;
String line;
StringBuffer output = new StringBuffer();
relativePath = DirectoryManager.getRelativePath(DocletConstants.SOURCE_OUTPUT_DIR_NAME) +
DirectoryManager.getRelativePath(cd.containingPackage());
Content body = getHeader();
Content pre = new HtmlTree(HtmlTag.PRE);
try {
while ((line = reader.readLine()) != null) {
output.append(formatLine(line, configuration.sourcetab, lineno));
addLineNo(pre, lineno);
addLine(pre, line, configuration.sourcetab, lineno);
lineno++;
}
} finally {
reader.close();
}
output = addLineNumbers(output.toString());
output.insert(0, getHeader(configuration));
output.append(getFooter());
writeToFile(output.toString(), outputdir, cd.name(), configuration);
addBlankLines(pre);
Content div = HtmlTree.DIV(HtmlStyle.sourceContainer, pre);
body.addContent(div);
writeToFile(body, outputdir, cd.name(), configuration);
} catch (Exception e){
e.printStackTrace();
}
@ -165,135 +178,117 @@ public class SourceToHTMLConverter {
/**
* Write the output to the file.
* @param output the string to output.
*
* @param body the documentation content to be written to the file.
* @param outputDir the directory to output to.
* @param className the name of the class that I am converting to HTML.
* @param configuration the Doclet configuration to pass notices to.
*/
private static void writeToFile(String output, String outputDir, String className, Configuration configuration) throws IOException {
private static void writeToFile(Content body, String outputDir,
String className, ConfigurationImpl configuration) throws IOException {
Content htmlDocType = DocType.Transitional();
Content head = new HtmlTree(HtmlTag.HEAD);
head.addContent(HtmlTree.TITLE(new StringContent(
configuration.getText("doclet.Window_Source_title"))));
head.addContent(getStyleSheetProperties(configuration));
Content htmlTree = HtmlTree.HTML(configuration.getLocale().getLanguage(),
head, body);
Content htmlDocument = new HtmlDocument(htmlDocType, htmlTree);
File dir = new File(outputDir);
dir.mkdirs();
File newFile = new File(dir, className + ".html");
configuration.message.notice("doclet.Generating_0", newFile.getPath());
FileOutputStream fout = new FileOutputStream(newFile);
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(fout));
bw.write(output);
bw.write(htmlDocument.toString());
bw.close();
fout.close();
}
/**
* Given a <code>String</code>, add line numbers.
* @param s the text to add line numbers to.
* Returns a link to the stylesheet file.
*
* @return the string buffer with the line numbering for each line.
* @param configuration the doclet configuration for the current run of javadoc
* @return an HtmlTree for the lINK tag which provides the stylesheet location
*/
private static StringBuffer addLineNumbers(String s) {
StringBuffer sb = new StringBuffer();
StringTokenizer st = new StringTokenizer(s, "\n", true);
int lineno = 1;
String current;
while(st.hasMoreTokens()){
current = st.nextToken();
sb.append(current.equals("\n") ?
getHTMLLineNo(lineno) + current :
getHTMLLineNo(lineno) + current + st.nextToken());
lineno++;
public static HtmlTree getStyleSheetProperties(ConfigurationImpl configuration) {
String filename = configuration.stylesheetfile;
if (filename.length() > 0) {
File stylefile = new File(filename);
String parent = stylefile.getParent();
filename = (parent == null)?
filename:
filename.substring(parent.length() + 1);
} else {
filename = "stylesheet.css";
}
return sb;
filename = relativePath + filename;
HtmlTree link = HtmlTree.LINK("stylesheet", "text/css", filename, "Style");
return link;
}
/**
* Get the header.
* @param configuration the Doclet configuration
* @return the header to the output file
*
* @return the header content for the HTML file
*/
protected static String getHeader(Configuration configuration) {
StringBuffer result = new StringBuffer("<HTML lang=\"" + configuration.getLocale().getLanguage() + "\">" + DocletConstants.NL);
result.append("<BODY BGCOLOR=\""+ BGCOLOR + "\">" + DocletConstants.NL);
result.append("<PRE>" + DocletConstants.NL);
return result.toString();
private static Content getHeader() {
return new HtmlTree(HtmlTag.BODY);
}
/**
* Get the footer
* @return the footer to the output file
*/
protected static String getFooter() {
StringBuffer footer = new StringBuffer();
for (int i = 0; i < NUM_BLANK_LINES; i++) {
footer.append(DocletConstants.NL);
}
footer.append("</PRE>" + DocletConstants.NL + "</BODY>" +
DocletConstants.NL + "</HTML>" + DocletConstants.NL);
return footer.toString();
}
/**
* Get the HTML for the lines.
* Add the line numbers for the source code.
*
* @param pre the content tree to which the line number will be added
* @param lineno The line number
* @return the HTML code for the line
*/
protected static String getHTMLLineNo(int lineno) {
StringBuffer result = new StringBuffer("<FONT color=\"" + LINE_NO_COLOR
+ "\">");
private static void addLineNo(Content pre, int lineno) {
HtmlTree span = new HtmlTree(HtmlTag.SPAN);
span.addStyle(HtmlStyle.sourceLineNo);
if (lineno < 10) {
result.append("00" + ((new Integer(lineno)).toString()));
span.addContent("00" + Integer.toString(lineno));
} else if (lineno < 100) {
result.append("0" + ((new Integer(lineno)).toString()));
span.addContent("0" + Integer.toString(lineno));
} else {
result.append((new Integer(lineno)).toString());
span.addContent(Integer.toString(lineno));
}
result.append("</FONT> ");
return result.toString();
pre.addContent(span);
}
/**
* Format a given line of source. <br>
* Note: In the future, we will add special colors for constructs in the
* language.
* Add a line from source to the HTML file that is generated.
*
* @param pre the content tree to which the line will be added.
* @param line the string to format.
* @param tabLength the number of spaces for each tab.
* @param currentLineNo the current number.
*/
protected static String formatLine(String line, int tabLength, int currentLineNo) {
if (line == null) {
return null;
}
private static void addLine(Content pre, String line, int tabLength,
int currentLineNo) {
if (line != null) {
StringBuffer lineBuffer = new StringBuffer(Util.escapeHtmlChars(line));
//Insert an anchor for the line
lineBuffer.append("<a name=\"line." + Integer.toString(currentLineNo) + "\"></a>");
lineBuffer.append(DocletConstants.NL);
Util.replaceTabs(tabLength, lineBuffer);
return lineBuffer.toString();
}
/**
* Given an array of <code>Doc</code>s, add to the given <code>HashMap</code> the
* line numbers and anchors that should be inserted in the output at those lines.
* @param docs the array of <code>Doc</code>s to add anchors for.
* @param hash the <code>HashMap</code> to add to.
*/
protected static void addToHash(Doc[] docs, HashMap<Integer,String> hash) {
if(docs == null) {
return;
}
for(int i = 0; i < docs.length; i++) {
hash.put(docs[i].position().line(), getAnchor(docs[i]));
pre.addContent(new RawHtml(lineBuffer.toString()));
Content anchor = HtmlTree.A_NAME("line." + Integer.toString(currentLineNo));
pre.addContent(anchor);
pre.addContent(NEW_LINE);
}
}
/**
* Given a <code>Doc</code>, return an anchor for it.
* @param d the <code>Doc</code> to check.
* @return an anchor of the form &lt;a name="my_name">&lt;/a>
* Add trailing blank lines at the end of the page.
*
* @param pre the content tree to which the blank lines will be added.
*/
protected static String getAnchor(Doc d) {
return " <a name=\"" + getAnchorName(d) + "\"></a>";
private static void addBlankLines(Content pre) {
for (int i = 0; i < NUM_BLANK_LINES; i++) {
pre.addContent(NEW_LINE);
}
}
/**
* Given a <code>Doc</code>, return an anchor name for it.
*
* @param d the <code>Doc</code> to check.
* @return the name of the anchor.
*/

84
langtools/src/share/classes/com/sun/tools/doclets/formats/html/SplitIndexWriter.java
View file

@ -25,9 +25,10 @@
package com.sun.tools.doclets.formats.html;
import com.sun.tools.doclets.internal.toolkit.util.*;
import java.io.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.formats.html.markup.*;
import com.sun.tools.doclets.internal.toolkit.*;
/**
* Generate Separate Index Files for all the member names with Indexing in
@ -36,6 +37,7 @@ import java.io.*;
*
* @see java.lang.Character
* @author Atul M Dambalkar
* @author Bhavesh Patel (Modified)
*/
public class SplitIndexWriter extends AbstractIndexWriter {
@ -109,56 +111,68 @@ public class SplitIndexWriter extends AbstractIndexWriter {
* index.
*/
protected void generateIndexFile(Character unicode) throws IOException {
printHtmlHeader(configuration.getText("doclet.Window_Split_Index",
unicode.toString()), null, true);
printTop();
navLinks(true);
printLinksForIndexes();
hr();
generateContents(unicode, indexbuilder.getMemberList(unicode));
navLinks(false);
printLinksForIndexes();
printBottom();
printBodyHtmlEnd();
String title = configuration.getText("doclet.Window_Split_Index",
unicode.toString());
Content body = getBody(true, getWindowTitle(title));
addTop(body);
addNavLinks(true, body);
HtmlTree divTree = new HtmlTree(HtmlTag.DIV);
divTree.addStyle(HtmlStyle.contentContainer);
addLinksForIndexes(divTree);
addContents(unicode, indexbuilder.getMemberList(unicode), divTree);
addLinksForIndexes(divTree);
body.addContent(divTree);
addNavLinks(false, body);
addBottom(body);
printHtmlDocument(null, true, body);
}
/**
* Print Links for all the Index Files per unicode character.
* Add links for all the Index Files per unicode character.
*
* @param contentTree the content tree to which the links for indexes will be added
*/
protected void printLinksForIndexes() {
for (int i = 0; i < indexbuilder.elements().length; i++) {
protected void addLinksForIndexes(Content contentTree) {
Object[] unicodeChars = indexbuilder.elements();
for (int i = 0; i < unicodeChars.length; i++) {
int j = i + 1;
printHyperLink("index-" + j + ".html",
indexbuilder.elements()[i].toString());
print(' ');
contentTree.addContent(getHyperLink("index-" + j + ".html",
new StringContent(unicodeChars[i].toString())));
contentTree.addContent(getSpace());
}
}
/**
* Print the previous unicode character index link.
* Get link to the previous unicode character.
*
* @return a content tree for the link
*/
protected void navLinkPrevious() {
public Content getNavLinkPrevious() {
Content prevletterLabel = getResource("doclet.Prev_Letter");
if (prev == -1) {
printText("doclet.Prev_Letter");
} else {
printHyperLink("index-" + prev + ".html", "",
configuration.getText("doclet.Prev_Letter"), true);
return HtmlTree.LI(prevletterLabel);
}
else {
Content prevLink = getHyperLink("index-" + prev + ".html", "",
prevletterLabel);
return HtmlTree.LI(prevLink);
}
}
/**
* Print the next unicode character index link.
* Get link to the next unicode character.
*
* @return a content tree for the link
*/
protected void navLinkNext() {
public Content getNavLinkNext() {
Content nextletterLabel = getResource("doclet.Next_Letter");
if (next == -1) {
printText("doclet.Next_Letter");
} else {
printHyperLink("index-" + next + ".html","",
configuration.getText("doclet.Next_Letter"), true);
return HtmlTree.LI(nextletterLabel);
}
else {
Content nextLink = getHyperLink("index-" + next + ".html","",
nextletterLabel);
return HtmlTree.LI(nextLink);
}
}
}

130
langtools/src/share/classes/com/sun/tools/doclets/formats/html/StylesheetWriter.java
View file

@ -1,130 +0,0 @@
/*
* Copyright (c) 1998, 2005, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.tools.doclets.formats.html;
import com.sun.tools.doclets.internal.toolkit.util.*;
import java.io.*;
/**
* Writes the style sheet for the doclet output.
*
* @author Atul M Dambalkar
* @author Bhavesh Patel (Modified)
*/
public class StylesheetWriter extends HtmlDocletWriter {
/**
* Constructor.
*/
public StylesheetWriter(ConfigurationImpl configuration,
String filename) throws IOException {
super(configuration, filename);
}
/**
* Generate the style file contents.
* @throws DocletAbortException
*/
public static void generate(ConfigurationImpl configuration) {
StylesheetWriter stylegen;
String filename = "";
try {
filename = "stylesheet.css";
stylegen = new StylesheetWriter(configuration, filename);
stylegen.generateStyleFile();
stylegen.close();
} catch (IOException exc) {
configuration.standardmessage.error(
"doclet.exception_encountered",
exc.toString(), filename);
throw new DocletAbortException();
}
}
/**
* Generate the style file contents.
*/
protected void generateStyleFile() {
print("/* "); printText("doclet.Style_line_1"); println(" */");
println("");
print("/* "); printText("doclet.Style_line_2"); println(" */");
println("");
print("/* "); printText("doclet.Style_line_3"); println(" */");
println("body { background-color: #FFFFFF; color:#000000 }");
println("");
print("/* "); printText("doclet.Style_Headings"); println(" */");
println("h1 { font-size: 145% }");
println("");
print("/* "); printText("doclet.Style_line_4"); println(" */");
print(".TableHeadingColor { background: #CCCCFF; color:#000000 }");
print(" /* "); printText("doclet.Style_line_5"); println(" */");
print(".TableSubHeadingColor { background: #EEEEFF; color:#000000 }");
print(" /* "); printText("doclet.Style_line_6"); println(" */");
print(".TableRowColor { background: #FFFFFF; color:#000000 }");
print(" /* "); printText("doclet.Style_line_7"); println(" */");
println("");
print("/* "); printText("doclet.Style_line_8"); println(" */");
println(".FrameTitleFont { font-size: 100%; font-family: Helvetica, Arial, sans-serif; color:#000000 }");
println(".FrameHeadingFont { font-size: 90%; font-family: Helvetica, Arial, sans-serif; color:#000000 }");
println(".FrameItemFont { font-size: 90%; font-family: Helvetica, Arial, sans-serif; color:#000000 }");
println("");
// Removed doclet.Style_line_9 as no longer needed
print("/* "); printText("doclet.Style_line_10"); println(" */");
print(".NavBarCell1 { background-color:#EEEEFF; color:#000000}");
print(" /* "); printText("doclet.Style_line_6"); println(" */");
print(".NavBarCell1Rev { background-color:#00008B; color:#FFFFFF}");
print(" /* "); printText("doclet.Style_line_11"); println(" */");
print(".NavBarFont1 { font-family: Arial, Helvetica, sans-serif; color:#000000;");
println("color:#000000;}");
print(".NavBarFont1Rev { font-family: Arial, Helvetica, sans-serif; color:#FFFFFF;");
println("color:#FFFFFF;}");
println("");
print(".NavBarCell2 { font-family: Arial, Helvetica, sans-serif; ");
println("background-color:#FFFFFF; color:#000000}");
print(".NavBarCell3 { font-family: Arial, Helvetica, sans-serif; ");
println("background-color:#FFFFFF; color:#000000}");
print("/* "); printText("doclet.Style_line_12"); println(" */");
print(".TableCaption { background: #CCCCFF; color:#000000; text-align: left; font-size: 150%; font-weight: bold; border-left: 2px ridge; border-right: 2px ridge; border-top: 2px ridge; padding-left: 5px; }");
print(" /* "); printText("doclet.Style_line_5"); println(" */");
print(".TableSubCaption { background: #EEEEFF; color:#000000; text-align: left; font-weight: bold; border-left: 2px ridge; border-right: 2px ridge; border-top: 2px ridge; padding-left: 5px; }");
print(" /* "); printText("doclet.Style_line_6"); println(" */");
print(".TableHeader { text-align: center; font-size: 80%; font-weight: bold; }");
println("");
}
}

225
langtools/src/share/classes/com/sun/tools/doclets/formats/html/SubWriterHolderWriter.java
View file

@ -25,10 +25,11 @@
package com.sun.tools.doclets.formats.html;
import com.sun.javadoc.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import java.io.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.formats.html.markup.*;
/**
* This abstract class exists to provide functionality needed in the
@ -71,13 +72,31 @@ public abstract class SubWriterHolderWriter extends HtmlDocletWriter {
tdEnd();
}
public void printSummaryHeader(AbstractMemberWriter mw, ClassDoc cd) {
mw.printSummaryAnchor(cd);
mw.printTableSummary();
tableCaptionStart();
mw.printSummaryLabel();
tableCaptionEnd();
mw.printSummaryTableHeader(cd);
/**
* Add the summary header.
*
* @param mw the writer for the member being documented
* @param cd the classdoc to be documented
* @param memberTree the content tree to which the summary header will be added
*/
public void addSummaryHeader(AbstractMemberWriter mw, ClassDoc cd,
Content memberTree) {
mw.addSummaryAnchor(cd, memberTree);
mw.addSummaryLabel(memberTree);
}
/**
* Get the summary table.
*
* @param mw the writer for the member being documented
* @param cd the classdoc to be documented
* @return the content tree for the summary table
*/
public Content getSummaryTableTree(AbstractMemberWriter mw, ClassDoc cd) {
Content table = HtmlTree.TABLE(HtmlStyle.overviewSummary, 0, 3, 0,
mw.getTableSummary(), getTableCaption(mw.getCaption()));
table.addContent(getSummaryTableHeader(mw.getSummaryTableHeader(cd), "col"));
return table;
}
public void printTableHeadingBackground(String str) {
@ -88,15 +107,17 @@ public abstract class SubWriterHolderWriter extends HtmlDocletWriter {
tableEnd();
}
public void printInheritedSummaryHeader(AbstractMemberWriter mw, ClassDoc cd) {
mw.printInheritedSummaryAnchor(cd);
tableIndexSummary();
tableInheritedHeaderStart("#EEEEFF");
mw.printInheritedSummaryLabel(cd);
tableInheritedHeaderEnd();
trBgcolorStyle("white", "TableRowColor");
summaryRow(0);
code();
/**
* Add the inherited summary header.
*
* @param mw the writer for the member being documented
* @param cd the classdoc to be documented
* @param inheritedTree the content tree to which the inherited summary header will be added
*/
public void addInheritedSummaryHeader(AbstractMemberWriter mw, ClassDoc cd,
Content inheritedTree) {
mw.addInheritedSummaryAnchor(cd, inheritedTree);
mw.addInheritedSummaryLabel(cd, inheritedTree);
}
public void printSummaryFooter(AbstractMemberWriter mw, ClassDoc cd) {
@ -112,8 +133,14 @@ public abstract class SubWriterHolderWriter extends HtmlDocletWriter {
space();
}
protected void printIndexComment(Doc member) {
printIndexComment(member, member.firstSentenceTags());
/**
* Add the index comment.
*
* @param member the member being documented
* @param contentTree the content tree to which the comment will be added
*/
protected void addIndexComment(Doc member, Content contentTree) {
addIndexComment(member, member.firstSentenceTags(), contentTree);
}
protected void printIndexComment(Doc member, Tag[] firstSentenceTags) {
@ -134,17 +161,60 @@ public abstract class SubWriterHolderWriter extends HtmlDocletWriter {
printSummaryComment(member, firstSentenceTags);
}
public void printSummaryLinkType(AbstractMemberWriter mw,
ProgramElementDoc member) {
trBgcolorStyle("white", "TableRowColor");
mw.printSummaryType(member);
summaryRow(0);
code();
/**
* Add the index comment.
*
* @param member the member being documented
* @param firstSentenceTags the first sentence tags for the member to be documented
* @param tdSummary the content tree to which the comment will be added
*/
protected void addIndexComment(Doc member, Tag[] firstSentenceTags,
Content tdSummary) {
Tag[] deprs = member.tags("deprecated");
Content div;
if (Util.isDeprecated((ProgramElementDoc) member)) {
Content strong = HtmlTree.STRONG(deprecatedPhrase);
div = HtmlTree.DIV(HtmlStyle.block, strong);
div.addContent(getSpace());
if (deprs.length > 0) {
addInlineDeprecatedComment(member, deprs[0], div);
}
tdSummary.addContent(div);
return;
} else {
ClassDoc cd = ((ProgramElementDoc)member).containingClass();
if (cd != null && Util.isDeprecated(cd)) {
Content strong = HtmlTree.STRONG(deprecatedPhrase);
div = HtmlTree.DIV(HtmlStyle.block, strong);
div.addContent(getSpace());
tdSummary.addContent(div);
}
}
addSummaryComment(member, firstSentenceTags, tdSummary);
}
public void printSummaryLinkComment(AbstractMemberWriter mw,
ProgramElementDoc member) {
printSummaryLinkComment(mw, member, member.firstSentenceTags());
/**
* Add the summary type for the member.
*
* @param mw the writer for the member being documented
* @param member the member to be documented
* @param tdSummaryType the content tree to which the type will be added
*/
public void addSummaryType(AbstractMemberWriter mw, ProgramElementDoc member,
Content tdSummaryType) {
mw.addSummaryType(member, tdSummaryType);
}
/**
* Add the summary link for the member.
*
* @param mw the writer for the member being documented
* @param member the member to be documented
* @param contentTree the content tree to which the link will be added
*/
public void addSummaryLinkComment(AbstractMemberWriter mw,
ProgramElementDoc member, Content contentTree) {
addSummaryLinkComment(mw, member, member.firstSentenceTags(), contentTree);
}
public void printSummaryLinkComment(AbstractMemberWriter mw,
@ -159,12 +229,34 @@ public abstract class SubWriterHolderWriter extends HtmlDocletWriter {
trEnd();
}
public void printInheritedSummaryMember(AbstractMemberWriter mw, ClassDoc cd,
ProgramElementDoc member, boolean isFirst) {
if (! isFirst) {
mw.print(", ");
/**
* Add the summary link comment.
*
* @param mw the writer for the member being documented
* @param member the member being documented
* @param firstSentenceTags the first sentence tags for the member to be documented
* @param tdSummary the content tree to which the comment will be added
*/
public void addSummaryLinkComment(AbstractMemberWriter mw,
ProgramElementDoc member, Tag[] firstSentenceTags, Content tdSummary) {
addIndexComment(member, firstSentenceTags, tdSummary);
}
mw.writeInheritedSummaryLink(cd, member);
/**
* Add the inherited member summary.
*
* @param mw the writer for the member being documented
* @param cd the class being documented
* @param member the member being documented
* @param isFirst true if its the first link being documented
* @param linksTree the content tree to which the summary will be added
*/
public void addInheritedMemberSummary(AbstractMemberWriter mw, ClassDoc cd,
ProgramElementDoc member, boolean isFirst, Content linksTree) {
if (! isFirst) {
linksTree.addContent(", ");
}
mw.addInheritedSummaryLink(cd, member, linksTree);
}
public void printMemberHeader() {
@ -174,4 +266,67 @@ public abstract class SubWriterHolderWriter extends HtmlDocletWriter {
public void printMemberFooter() {
}
/**
* Get the document content header tree
*
* @return a content tree the document content header
*/
public Content getContentHeader() {
HtmlTree div = new HtmlTree(HtmlTag.DIV);
div.addStyle(HtmlStyle.contentContainer);
return div;
}
/**
* Get the member header tree
*
* @return a content tree the member header
*/
public Content getMemberTreeHeader() {
HtmlTree li = new HtmlTree(HtmlTag.LI);
li.addStyle(HtmlStyle.blockList);
return li;
}
/**
* Get the member tree
*
* @param contentTree the tree used to generate the complete member tree
* @return a content tree for the member
*/
public Content getMemberTree(Content contentTree) {
Content ul = HtmlTree.UL(HtmlStyle.blockList, contentTree);
return ul;
}
/**
* Get the member summary tree
*
* @param contentTree the tree used to generate the member summary tree
* @return a content tree for the member summary
*/
public Content getMemberSummaryTree(Content contentTree) {
return getMemberTree(HtmlStyle.summary, contentTree);
}
/**
* Get the member details tree
*
* @param contentTree the tree used to generate the member details tree
* @return a content tree for the member details
*/
public Content getMemberDetailsTree(Content contentTree) {
return getMemberTree(HtmlStyle.details, contentTree);
}
/**
* Get the member tree
*
* @param style the style class to be added to the content tree
* @param contentTree the tree used to generate the complete member tree
*/
public Content getMemberTree(HtmlStyle style, Content contentTree) {
Content div = HtmlTree.DIV(style, getMemberTree(contentTree));
return div;
}
}

69
langtools/src/share/classes/com/sun/tools/doclets/formats/html/TagletWriterImpl.java
View file

@ -70,9 +70,9 @@ public class TagletWriterImpl extends TagletWriter {
Tag[] deprs = doc.tags("deprecated");
if (doc instanceof ClassDoc) {
if (Util.isDeprecated((ProgramElementDoc) doc)) {
output.append("<STRONG>" +
output.append("<span class=\"strong\">" +
ConfigurationImpl.getInstance().
getText("doclet.Deprecated") + "</STRONG>&nbsp;");
getText("doclet.Deprecated") + "</span>&nbsp;");
if (deprs.length > 0) {
Tag[] commentTags = deprs[0].inlineTags();
if (commentTags.length > 0) {
@ -82,30 +82,24 @@ public class TagletWriterImpl extends TagletWriter {
);
}
}
output.append("<p>");
}
} else {
MemberDoc member = (MemberDoc) doc;
if (Util.isDeprecated((ProgramElementDoc) doc)) {
output.append("<DD><STRONG>" +
output.append("<span class=\"strong\">" +
ConfigurationImpl.getInstance().
getText("doclet.Deprecated") + "</STRONG>&nbsp;");
getText("doclet.Deprecated") + "</span>&nbsp;");
if (deprs.length > 0) {
output.append("<I>");
output.append("<i>");
output.append(commentTagsToOutput(null, doc,
deprs[0].inlineTags(), false).toString());
output.append("</I>");
output.append("</i>");
}
if (member instanceof ExecutableMemberDoc) {
output.append(DocletConstants.NL + "<P>" +
DocletConstants.NL);
}
output.append("</DD>");
} else {
if (Util.isDeprecated(member.containingClass())) {
output.append("<DD><STRONG>" +
output.append("<span class=\"strong\">" +
ConfigurationImpl.getInstance().
getText("doclet.Deprecated") + "</STRONG>&nbsp;</DD>");
getText("doclet.Deprecated") + "</span>&nbsp;");
}
}
}
@ -124,8 +118,8 @@ public class TagletWriterImpl extends TagletWriter {
*/
public TagletOutput getParamHeader(String header) {
StringBuffer result = new StringBuffer();
result.append("<DT>");
result.append("<STRONG>" + header + "</STRONG></DT>");
result.append("<dt>");
result.append("<span class=\"strong\">" + header + "</span></dt>");
return new TagletOutputImpl(result.toString());
}
@ -133,8 +127,8 @@ public class TagletWriterImpl extends TagletWriter {
* {@inheritDoc}
*/
public TagletOutput paramTagOutput(ParamTag paramTag, String paramName) {
TagletOutput result = new TagletOutputImpl("<DD><CODE>" + paramName + "</CODE>"
+ " - " + htmlWriter.commentTagsToString(paramTag, null, paramTag.inlineTags(), false) + "</DD>");
TagletOutput result = new TagletOutputImpl("<dd><code>" + paramName + "</code>"
+ " - " + htmlWriter.commentTagsToString(paramTag, null, paramTag.inlineTags(), false) + "</dd>");
return result;
}
@ -142,11 +136,11 @@ public class TagletWriterImpl extends TagletWriter {
* {@inheritDoc}
*/
public TagletOutput returnTagOutput(Tag returnTag) {
TagletOutput result = new TagletOutputImpl(DocletConstants.NL + "<DT>" +
"<STRONG>" + htmlWriter.configuration.getText("doclet.Returns") +
"</STRONG>" + "</DT>" + "<DD>" +
TagletOutput result = new TagletOutputImpl(DocletConstants.NL + "<dt>" +
"<span class=\"strong\">" + htmlWriter.configuration.getText("doclet.Returns") +
"</span>" + "</dt>" + "<dd>" +
htmlWriter.commentTagsToString(returnTag, null, returnTag.inlineTags(),
false) + "</DD>");
false) + "</dd>");
return result;
}
@ -168,7 +162,7 @@ public class TagletWriterImpl extends TagletWriter {
htmlWriter instanceof ClassWriterImpl) {
//Automatically add link to constant values page for constant fields.
result = addSeeHeader(result);
result += htmlWriter.getHyperLink(htmlWriter.relativePath +
result += htmlWriter.getHyperLinkString(htmlWriter.relativePath +
ConfigurationImpl.CONSTANTS_FILE_NAME
+ "#" + ((ClassWriterImpl) htmlWriter).getClassDoc().qualifiedName()
+ "." + ((FieldDoc) holder).name(),
@ -179,18 +173,19 @@ public class TagletWriterImpl extends TagletWriter {
if ((SerializedFormBuilder.serialInclude(holder) &&
SerializedFormBuilder.serialInclude(((ClassDoc)holder).containingPackage()))) {
result = addSeeHeader(result);
result += htmlWriter.getHyperLink(htmlWriter.relativePath + "serialized-form.html",
result += htmlWriter.getHyperLinkString(htmlWriter.relativePath + "serialized-form.html",
((ClassDoc)holder).qualifiedName(), htmlWriter.configuration.getText("doclet.Serialized_Form"), false);
}
}
return result.equals("") ? null : new TagletOutputImpl(result + "</DD>");
return result.equals("") ? null : new TagletOutputImpl(result + "</dd>");
}
private String addSeeHeader(String result) {
if (result != null && result.length() > 0) {
return result + ", " + DocletConstants.NL;
} else {
return "<DT><STRONG>" + htmlWriter.configuration().getText("doclet.See_Also") + "</STRONG></DT><DD>";
return "<dt><span class=\"strong\">" +
htmlWriter.configuration().getText("doclet.See_Also") + "</span></dt><dd>";
}
}
@ -198,15 +193,15 @@ public class TagletWriterImpl extends TagletWriter {
* {@inheritDoc}
*/
public TagletOutput simpleTagOutput(Tag[] simpleTags, String header) {
String result = "<DT><STRONG>" + header + "</STRONG></DT>" + DocletConstants.NL +
" <DD>";
String result = "<dt><span class=\"strong\">" + header + "</span></dt>" + DocletConstants.NL +
" <dd>";
for (int i = 0; i < simpleTags.length; i++) {
if (i > 0) {
result += ", ";
}
result += htmlWriter.commentTagsToString(simpleTags[i], null, simpleTags[i].inlineTags(), false);
}
result += "</DD>" + DocletConstants.NL;
result += "</dd>" + DocletConstants.NL;
return new TagletOutputImpl(result);
}
@ -214,24 +209,24 @@ public class TagletWriterImpl extends TagletWriter {
* {@inheritDoc}
*/
public TagletOutput simpleTagOutput(Tag simpleTag, String header) {
return new TagletOutputImpl("<DT><STRONG>" + header + "</STRONG></DT>" + " <DD>"
return new TagletOutputImpl("<dt><span class=\"strong\">" + header + "</span></dt>" + " <dd>"
+ htmlWriter.commentTagsToString(simpleTag, null, simpleTag.inlineTags(), false)
+ "</DD>" + DocletConstants.NL);
+ "</dd>" + DocletConstants.NL);
}
/**
* {@inheritDoc}
*/
public TagletOutput getThrowsHeader() {
return new TagletOutputImpl(DocletConstants.NL + "<DT>" + "<STRONG>" +
htmlWriter.configuration().getText("doclet.Throws") + "</STRONG></DT>");
return new TagletOutputImpl(DocletConstants.NL + "<dt>" + "<span class=\"strong\">" +
htmlWriter.configuration().getText("doclet.Throws") + "</span></dt>");
}
/**
* {@inheritDoc}
*/
public TagletOutput throwsTagOutput(ThrowsTag throwsTag) {
String result = DocletConstants.NL + "<DD>";
String result = DocletConstants.NL + "<dd>";
result += throwsTag.exceptionType() == null ?
htmlWriter.codeText(throwsTag.exceptionName()) :
htmlWriter.codeText(
@ -243,7 +238,7 @@ public class TagletWriterImpl extends TagletWriter {
if (text != null && text.toString().length() > 0) {
result += " - " + text;
}
result += "</DD>";
result += "</dd>";
return new TagletOutputImpl(result);
}
@ -251,9 +246,9 @@ public class TagletWriterImpl extends TagletWriter {
* {@inheritDoc}
*/
public TagletOutput throwsTagOutput(Type throwsType) {
return new TagletOutputImpl(DocletConstants.NL + "<DD>" +
return new TagletOutputImpl(DocletConstants.NL + "<dd>" +
htmlWriter.codeText(htmlWriter.getLink(
new LinkInfoImpl(LinkInfoImpl.CONTEXT_MEMBER, throwsType))) + "</DD>");
new LinkInfoImpl(LinkInfoImpl.CONTEXT_MEMBER, throwsType))) + "</dd>");
}
/**

103
langtools/src/share/classes/com/sun/tools/doclets/formats/html/TreeWriter.java
View file

@ -29,6 +29,8 @@ import java.io.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.formats.html.markup.*;
import com.sun.tools.doclets.internal.toolkit.*;
/**
* Generate Class Hierarchy page for all the Classes in this run. Use
@ -37,6 +39,7 @@ import com.sun.tools.doclets.internal.toolkit.util.*;
* current or the destination directory.
*
* @author Atul M Dambalkar
* @author Bhavesh Patel (Modified)
*/
public class TreeWriter extends AbstractTreeWriter {
@ -90,86 +93,70 @@ public class TreeWriter extends AbstractTreeWriter {
}
/**
* Print the interface hierarchy and class hierarchy in the file.
* Generate the interface hierarchy and class hierarchy.
*/
public void generateTreeFile() throws IOException {
printHtmlHeader(configuration.getText("doclet.Window_Class_Hierarchy"),
null, true);
printTreeHeader();
printPageHeading();
printPackageTreeLinks();
generateTree(classtree.baseclasses(), "doclet.Class_Hierarchy");
generateTree(classtree.baseinterfaces(), "doclet.Interface_Hierarchy");
generateTree(classtree.baseAnnotationTypes(), "doclet.Annotation_Type_Hierarchy");
generateTree(classtree.baseEnums(), "doclet.Enum_Hierarchy");
printTreeFooter();
Content body = getTreeHeader();
Content headContent = getResource("doclet.Hierarchy_For_All_Packages");
Content heading = HtmlTree.HEADING(HtmlConstants.TITLE_HEADING, false,
HtmlStyle.title, headContent);
Content div = HtmlTree.DIV(HtmlStyle.header, heading);
addPackageTreeLinks(div);
body.addContent(div);
HtmlTree divTree = new HtmlTree(HtmlTag.DIV);
divTree.addStyle(HtmlStyle.contentContainer);
addTree(classtree.baseclasses(), "doclet.Class_Hierarchy", divTree);
addTree(classtree.baseinterfaces(), "doclet.Interface_Hierarchy", divTree);
addTree(classtree.baseAnnotationTypes(), "doclet.Annotation_Type_Hierarchy", divTree);
addTree(classtree.baseEnums(), "doclet.Enum_Hierarchy", divTree);
body.addContent(divTree);
addNavLinks(false, body);
addBottom(body);
printHtmlDocument(null, true, body);
}
/**
* Generate the links to all the package tree files.
* Add the links to all the package tree files.
*
* @param contentTree the content tree to which the links will be added
*/
protected void printPackageTreeLinks() {
protected void addPackageTreeLinks(Content contentTree) {
//Do nothing if only unnamed package is used
if (packages.length == 1 && packages[0].name().length() == 0) {
return;
}
if (!classesonly) {
dl();
dt();
strongText("doclet.Package_Hierarchies");
dtEnd();
dd();
Content span = HtmlTree.SPAN(HtmlStyle.strong,
getResource("doclet.Package_Hierarchies"));
contentTree.addContent(span);
HtmlTree ul = new HtmlTree(HtmlTag.UL);
ul.addStyle(HtmlStyle.horizontal);
for (int i = 0; i < packages.length; i++) {
if (packages[i].name().length() == 0) {
continue;
}
String filename = pathString(packages[i], "package-tree.html");
printHyperLink(filename, "", packages[i].name());
String link = pathString(packages[i], "package-tree.html");
Content li = HtmlTree.LI(getHyperLink(
link, "", new StringContent(packages[i].name())));
if (i < packages.length - 1) {
print(", ");
li.addContent(", ");
}
ul.addContent(li);
}
ddEnd();
dlEnd();
hr();
contentTree.addContent(ul);
}
}
/**
* Print the top text (from the -top option) and
* navigation bar at the top of page.
* Get the tree header.
*
* @return a content tree for the tree header
*/
protected void printTreeHeader() {
printTop();
navLinks(true);
hr();
}
/**
* Print the navigation bar and bottom text (from the -bottom option)
* at the bottom of page.
*/
protected void printTreeFooter() {
hr();
navLinks(false);
printBottom();
printBodyHtmlEnd();
}
/**
* Print the page title "Hierarchy For All Packages" at the top of the tree
* page.
*/
protected void printPageHeading() {
center();
h2();
printText("doclet.Hierarchy_For_All_Packages");
h2End();
centerEnd();
protected Content getTreeHeader() {
String title = configuration.getText("doclet.Window_Class_Hierarchy");
Content bodyTree = getBody(true, getWindowTitle(title));
addTop(bodyTree);
addNavLinks(true, bodyTree);
return bodyTree;
}
}

90
langtools/src/share/classes/com/sun/tools/doclets/formats/html/markup/Comment.java Normal file
View file

@ -0,0 +1,90 @@
/*
* Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.tools.doclets.formats.html.markup;
import com.sun.tools.doclets.internal.toolkit.Content;
import com.sun.tools.doclets.internal.toolkit.util.*;
/**
* Class for generating a comment for HTML pages of javadoc output.
*
* @author Bhavesh Patel
*/
public class Comment extends Content{
private String commentText;
/**
* Constructor to construct a Comment object.
*
* @param comment comment text for the comment
*/
public Comment(String comment) {
commentText = nullCheck(comment);
}
/**
* This method is not supported by the class.
*
* @param content content that needs to be added
* @throws DocletAbortException this method will always throw a
* DocletAbortException because it
* is not supported.
*/
public void addContent(Content content) {
throw new DocletAbortException();
}
/**
* This method is not supported by the class.
*
* @param stringContent string content that needs to be added
* @throws DocletAbortException this method will always throw a
* DocletAbortException because it
* is not supported.
*/
public void addContent(String stringContent) {
throw new DocletAbortException();
}
/**
* {@inheritDoc}
*/
public boolean isEmpty() {
return commentText.isEmpty();
}
/**
* {@inheritDoc}
*/
public void write(StringBuilder contentBuilder) {
if (!endsWithNewLine(contentBuilder))
contentBuilder.append("\n");
contentBuilder.append("<!-- ");
contentBuilder.append(commentText);
contentBuilder.append(" -->\n");
}
}

113
langtools/src/share/classes/com/sun/tools/doclets/formats/html/markup/DocType.java Normal file
View file

@ -0,0 +1,113 @@
/*
* Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.tools.doclets.formats.html.markup;
import com.sun.tools.doclets.internal.toolkit.Content;
import com.sun.tools.doclets.internal.toolkit.util.*;
/**
* Class for generating document type for HTML pages of javadoc output.
*
* @author Bhavesh Patel
*/
public class DocType extends Content{
private String docType;
private static DocType transitional;
private static DocType frameset;
/**
* Constructor to construct a DocType object.
*
* @param type the doctype to be added
*/
private DocType(String type, String dtd) {
docType = "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 " + type +
"//EN\" \"" + dtd + "\">\n";
}
/**
* Construct and return a HTML 4.01 transitional DocType content
*
* @return a content tree for transitional DocType
*/
public static DocType Transitional() {
if (transitional == null)
transitional = new DocType("Transitional", "http://www.w3.org/TR/html4/loose.dtd");
return transitional;
}
/**
* Construct and return a HTML 4.01 frameset DocType content
*
* @return a content tree for frameset DocType
*/
public static DocType Frameset() {
if (frameset == null)
frameset = new DocType("Frameset", "http://www.w3.org/TR/html4/frameset.dtd");
return frameset;
}
/**
* This method is not supported by the class.
*
* @param content content that needs to be added
* @throws DocletAbortException this method will always throw a
* DocletAbortException because it
* is not supported.
*/
public void addContent(Content content) {
throw new DocletAbortException();
}
/**
* This method is not supported by the class.
*
* @param stringContent string content that needs to be added
* @throws DocletAbortException this method will always throw a
* DocletAbortException because it
* is not supported.
*/
public void addContent(String stringContent) {
throw new DocletAbortException();
}
/**
* {@inheritDoc}
*/
public boolean isEmpty() {
return (docType.length() == 0);
}
/**
* {@inheritDoc}
*/
public void write(StringBuilder contentBuilder) {
contentBuilder.append(docType);
}
}

73
langtools/src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlAttr.java Normal file
View file

@ -0,0 +1,73 @@
/*
* Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.tools.doclets.formats.html.markup;
/**
* Enum representing HTML tag attributes.
*
* @author Bhavesh Patel
*/
public enum HtmlAttr {
ALT,
BORDER,
CELLPADDING,
CELLSPACING,
CHARSET,
CLASS,
CLEAR,
COLS,
CONTENT,
HREF,
HTTP_EQUIV("http-equiv"),
ID,
LANG,
NAME,
ONLOAD,
REL,
ROWS,
SCOPE,
SCROLLING,
SRC,
SUMMARY,
TARGET,
TITLE,
TYPE,
WIDTH;
private final String value;
HtmlAttr() {
this.value = name().toLowerCase();
}
HtmlAttr(String name) {
this.value = name;
}
public String toString() {
return value;
}
}

189
langtools/src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlConstants.java Normal file
View file

@ -0,0 +1,189 @@
/*
* Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.tools.doclets.formats.html.markup;
import com.sun.tools.doclets.internal.toolkit.Content;
/**
* Stores constants for Html Doclet.
*
* @author Bhavesh Patel
*/
public class HtmlConstants {
/**
* Marker to identify start of top navigation bar.
*/
public static final Content START_OF_TOP_NAVBAR =
new Comment("========= START OF TOP NAVBAR =======");
/**
* Marker to identify start of bottom navigation bar.
*/
public static final Content START_OF_BOTTOM_NAVBAR =
new Comment("======= START OF BOTTOM NAVBAR ======");
/**
* Marker to identify end of top navigation bar.
*/
public static final Content END_OF_TOP_NAVBAR =
new Comment("========= END OF TOP NAVBAR =========");
/**
* Marker to identify end of bottom navigation bar.
*/
public static final Content END_OF_BOTTOM_NAVBAR =
new Comment("======== END OF BOTTOM NAVBAR =======");
/**
* Marker to identify start of class data.
*/
public static final Content START_OF_CLASS_DATA =
new Comment("======== START OF CLASS DATA ========");
/**
* Marker to identify end of class data.
*/
public static final Content END_OF_CLASS_DATA =
new Comment("========= END OF CLASS DATA =========");
/**
* Marker to identify start of nested class summary.
*/
public static final Content START_OF_NESTED_CLASS_SUMMARY =
new Comment("======== NESTED CLASS SUMMARY ========");
/**
* Marker to identify start of annotation type optional member summary.
*/
public static final Content START_OF_ANNOTATION_TYPE_OPTIONAL_MEMBER_SUMMARY =
new Comment("=========== ANNOTATION TYPE OPTIONAL MEMBER SUMMARY ===========");
/**
* Marker to identify start of annotation type required member summary.
*/
public static final Content START_OF_ANNOTATION_TYPE_REQUIRED_MEMBER_SUMMARY =
new Comment("=========== ANNOTATION TYPE REQUIRED MEMBER SUMMARY ===========");
/**
* Marker to identify start of constructor summary.
*/
public static final Content START_OF_CONSTRUCTOR_SUMMARY =
new Comment("======== CONSTRUCTOR SUMMARY ========");
/**
* Marker to identify start of enum constants summary.
*/
public static final Content START_OF_ENUM_CONSTANT_SUMMARY =
new Comment("=========== ENUM CONSTANT SUMMARY ===========");
/**
* Marker to identify start of field summary.
*/
public static final Content START_OF_FIELD_SUMMARY =
new Comment("=========== FIELD SUMMARY ===========");
/**
* Marker to identify start of method summary.
*/
public static final Content START_OF_METHOD_SUMMARY =
new Comment("========== METHOD SUMMARY ===========");
/**
* Marker to identify start of annotation type details.
*/
public static final Content START_OF_ANNOTATION_TYPE_DETAILS =
new Comment("============ ANNOTATION TYPE MEMBER DETAIL ===========");
/**
* Marker to identify start of method details.
*/
public static final Content START_OF_METHOD_DETAILS =
new Comment("============ METHOD DETAIL ==========");
/**
* Marker to identify start of field details.
*/
public static final Content START_OF_FIELD_DETAILS =
new Comment("============ FIELD DETAIL ===========");
/**
* Marker to identify start of constructor details.
*/
public static final Content START_OF_CONSTRUCTOR_DETAILS =
new Comment("========= CONSTRUCTOR DETAIL ========");
/**
* Marker to identify start of enum constants details.
*/
public static final Content START_OF_ENUM_CONSTANT_DETAILS =
new Comment("============ ENUM CONSTANT DETAIL ===========");
/**
* Html tag for the page title heading.
*/
public static final HtmlTag TITLE_HEADING = HtmlTag.H1;
/**
* Html tag for the class page title heading.
*/
public static final HtmlTag CLASS_PAGE_HEADING = HtmlTag.H2;
/**
* Html tag for the content heading.
*/
public static final HtmlTag CONTENT_HEADING = HtmlTag.H2;
/**
* Html tag for the package name heading.
*/
public static final HtmlTag PACKAGE_HEADING = HtmlTag.H2;
/**
* Html tag for the member summary heading.
*/
public static final HtmlTag SUMMARY_HEADING = HtmlTag.H3;
/**
* Html tag for the inherited member summary heading.
*/
public static final HtmlTag INHERITED_SUMMARY_HEADING = HtmlTag.H3;
/**
* Html tag for the member details heading.
*/
public static final HtmlTag DETAILS_HEADING = HtmlTag.H3;
/**
* Html tag for the serialized member heading.
*/
public static final HtmlTag SERIALIZED_MEMBER_HEADING = HtmlTag.H3;
/**
* Html tag for the member heading.
*/
public static final HtmlTag MEMBER_HEADING = HtmlTag.H4;
}

137
langtools/src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlDocWriter.java
View file

@ -87,7 +87,7 @@ public abstract class HtmlDocWriter extends HtmlWriter {
*/
public void printHyperLink(String link, String where,
String label, boolean strong) {
print(getHyperLink(link, where, label, strong, "", "", ""));
print(getHyperLinkString(link, where, label, strong, "", "", ""));
}
/**
@ -115,7 +115,7 @@ public abstract class HtmlDocWriter extends HtmlWriter {
public void printHyperLink(String link, String where,
String label, boolean strong,
String stylename) {
print(getHyperLink(link, where, label, strong, stylename, "", ""));
print(getHyperLinkString(link, where, label, strong, stylename, "", ""));
}
/**
@ -128,9 +128,9 @@ public abstract class HtmlDocWriter extends HtmlWriter {
* @param strong Boolean that sets label to strong.
* @return String Hyper Link.
*/
public String getHyperLink(String link, String where,
public String getHyperLinkString(String link, String where,
String label, boolean strong) {
return getHyperLink(link, where, label, strong, "", "", "");
return getHyperLinkString(link, where, label, strong, "", "", "");
}
/**
@ -144,10 +144,24 @@ public abstract class HtmlDocWriter extends HtmlWriter {
* @param stylename String style of text defined in style sheet.
* @return String Hyper Link.
*/
public String getHyperLink(String link, String where,
public String getHyperLinkString(String link, String where,
String label, boolean strong,
String stylename) {
return getHyperLink(link, where, label, strong, stylename, "", "");
return getHyperLinkString(link, where, label, strong, stylename, "", "");
}
/**
* Get Html Hyper Link string.
*
* @param link String name of the file.
* @param where Position of the link in the file. Character '#' is not
* needed.
* @param label Tag for the link.
* @return a content tree for the hyper link
*/
public Content getHyperLink(String link, String where,
Content label) {
return getHyperLink(link, where, label, "", "");
}
/**
@ -163,11 +177,11 @@ public abstract class HtmlDocWriter extends HtmlWriter {
* @param target Target frame.
* @return String Hyper Link.
*/
public String getHyperLink(String link, String where,
public String getHyperLinkString(String link, String where,
String label, boolean strong,
String stylename, String title, String target) {
StringBuffer retlink = new StringBuffer();
retlink.append("<A HREF=\"");
retlink.append("<a href=\"");
retlink.append(link);
if (where != null && where.length() != 0) {
retlink.append("#");
@ -187,27 +201,54 @@ public abstract class HtmlDocWriter extends HtmlWriter {
retlink.append("\">");
}
if (strong) {
retlink.append("<STRONG>");
retlink.append("<span class=\"strong\">");
}
retlink.append(label);
if (strong) {
retlink.append("</STRONG>");
retlink.append("</span>");
}
if (stylename != null && stylename.length() != 0) {
retlink.append("</FONT>");
}
retlink.append("</A>");
retlink.append("</a>");
return retlink.toString();
}
/**
* Print link without positioning in the file.
* Get Html Hyper Link.
*
* @param link String name of the file.
* @param where Position of the link in the file. Character '#' is not
* needed.
* @param label Tag for the link.
* @param title String that describes the link's content for accessibility.
* @param target Target frame.
* @return a content tree for the hyper link.
*/
public void printHyperLink(String link, String label) {
print(getHyperLink(link, "", label, false));
public Content getHyperLink(String link, String where,
Content label, String title, String target) {
if (where != null && where.length() != 0) {
link += "#" + where;
}
HtmlTree anchor = HtmlTree.A(link, label);
if (title != null && title.length() != 0) {
anchor.addAttr(HtmlAttr.TITLE, title);
}
if (target != null && target.length() != 0) {
anchor.addAttr(HtmlAttr.TARGET, target);
}
return anchor;
}
/**
* Get a hyperlink to a file.
*
* @param link String name of the file
* @param label Label for the link
* @return a content for the hyperlink to the file
*/
public Content getHyperLink(String link, Content label) {
return getHyperLink(link, "", label);
}
/**
@ -217,8 +258,8 @@ public abstract class HtmlDocWriter extends HtmlWriter {
* @param label Tag for the link.
* @return Strign Hyper link.
*/
public String getHyperLink(String link, String label) {
return getHyperLink(link, "", label, false);
public String getHyperLinkString(String link, String label) {
return getHyperLinkString(link, "", label, false);
}
/**
@ -273,54 +314,32 @@ public abstract class HtmlDocWriter extends HtmlWriter {
* Print the frameset version of the Html file header.
* Called only when generating an HTML frameset file.
*
* @param title Title of this HTML document.
* @param title Title of this HTML document
* @param noTimeStamp If true, don't print time stamp in header
* @param frameset the frameset to be added to the HTML document
*/
public void printFramesetHeader(String title) {
printFramesetHeader(title, false);
}
/**
* Print the frameset version of the Html file header.
* Called only when generating an HTML frameset file.
*
* @param title Title of this HTML document.
* @param noTimeStamp If true, don't print time stamp in header.
*/
public void printFramesetHeader(String title, boolean noTimeStamp) {
println("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 " +
"Frameset//EN\" " +
"\"http://www.w3.org/TR/html4/frameset.dtd\">");
println("<!--NewPage-->");
html();
head();
public void printFramesetDocument(String title, boolean noTimeStamp,
Content frameset) {
Content htmlDocType = DocType.Frameset();
Content htmlComment = new Comment(configuration.getText("doclet.New_Page"));
Content head = new HtmlTree(HtmlTag.HEAD);
if (! noTimeStamp) {
print("<!-- Generated by javadoc on ");
print(today());
println("-->");
Content headComment = new Comment("Generated by javadoc on " + today());
head.addContent(headComment);
}
if (configuration.charset.length() > 0) {
println("<META http-equiv=\"Content-Type\" content=\"text/html; "
+ "charset=" + configuration.charset + "\">");
Content meta = HtmlTree.META("Content-Type", "text/html",
configuration.charset);
head.addContent(meta);
}
title();
println(title);
titleEnd();
//Script to set the classFrame if necessary.
script();
println(" targetPage = \"\" + window.location.search;");
println(" if (targetPage != \"\" && targetPage != \"undefined\")");
println(" targetPage = targetPage.substring(1);");
println(" if (targetPage.indexOf(\":\") != -1)");
println(" targetPage = \"undefined\";");
println(" function loadFrames() {");
println(" if (targetPage != \"\" && targetPage != \"undefined\")");
println(" top.classFrame.location = top.targetPage;");
println(" }");
scriptEnd();
noScript();
noScriptEnd();
headEnd();
Content windowTitle = HtmlTree.TITLE(new StringContent(title));
head.addContent(windowTitle);
head.addContent(getFramesetJavaScript());
Content htmlTree = HtmlTree.HTML(configuration.getLocale().getLanguage(),
head, frameset);
Content htmlDocument = new HtmlDocument(htmlDocType,
htmlComment, htmlTree);
print(htmlDocument.toString());
}
/**

103
langtools/src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlDocument.java Normal file
View file

@ -0,0 +1,103 @@
/*
* Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.tools.doclets.formats.html.markup;
import java.util.*;
import com.sun.tools.doclets.internal.toolkit.Content;
import com.sun.tools.doclets.internal.toolkit.util.*;
/**
* Class for generating an HTML document for javadoc output.
*
* @author Bhavesh Patel
*/
public class HtmlDocument extends Content {
private List<Content> docContent = Collections.<Content>emptyList();
/**
* Constructor to construct an HTML document.
*
* @param docType document type for the HTML document
* @param docComment comment for the document
* @param htmlTree HTML tree of the document
*/
public HtmlDocument(Content docType, Content docComment, Content htmlTree) {
docContent = new ArrayList<Content>();
addContent(nullCheck(docType));
addContent(nullCheck(docComment));
addContent(nullCheck(htmlTree));
}
/**
* Constructor to construct an HTML document.
*
* @param docType document type for the HTML document
* @param htmlTree HTML tree of the document
*/
public HtmlDocument(Content docType, Content htmlTree) {
docContent = new ArrayList<Content>();
addContent(nullCheck(docType));
addContent(nullCheck(htmlTree));
}
/**
* Adds content for the HTML document.
*
* @param htmlContent html content to be added
*/
public void addContent(Content htmlContent) {
if (htmlContent.isValid())
docContent.add(htmlContent);
}
/**
* This method is not supported by the class.
*
* @param stringContent string content that needs to be added
* @throws DocletAbortException this method will always throw a
* DocletAbortException because it
* is not supported.
*/
public void addContent(String stringContent) {
throw new DocletAbortException();
}
/**
* {@inheritDoc}
*/
public boolean isEmpty() {
return (docContent.isEmpty());
}
/**
* {@inheritDoc}
*/
public void write(StringBuilder contentBuilder) {
for (Content c : docContent)
c.write(contentBuilder);
}
}

73
langtools/src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlStyle.java Normal file
View file

@ -0,0 +1,73 @@
/*
* Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.tools.doclets.formats.html.markup;
/**
* Enum representing HTML styles. The name map to values in the CSS file.
*
* @author Bhavesh Patel
*/
public enum HtmlStyle {
aboutLanguage,
altColor,
bar,
block,
blockList,
blockListLast,
bottomNav,
classUseContainer,
colFirst,
colLast,
colOne,
constantValuesContainer,
contentContainer,
description,
details,
header,
horizontal,
footer,
indexContainer,
indexHeader,
inheritance,
legalCopy,
nameValue,
navBarCell1Rev,
navList,
overviewSummary,
packageSummary,
rowColor,
serializedFormContainer,
sourceContainer,
sourceLineNo,
strong,
subNav,
subNavList,
subTitle,
summary,
tabEnd,
title,
topNav;
}

126
langtools/src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlTag.java Normal file
View file

@ -0,0 +1,126 @@
/*
* Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.tools.doclets.formats.html.markup;
/**
* Enum representing HTML tags.
*
* @author Bhavesh Patel
*/
public enum HtmlTag {
A(BlockType.INLINE, EndTag.END),
BLOCKQUOTE,
BODY(BlockType.OTHER, EndTag.END),
BR(BlockType.INLINE, EndTag.NOEND),
CAPTION,
CENTER,
CODE(BlockType.INLINE, EndTag.END),
DD,
DIV,
DL,
DT,
EM(BlockType.INLINE, EndTag.END),
FONT(BlockType.INLINE, EndTag.END),
FRAME(BlockType.OTHER, EndTag.NOEND),
FRAMESET(BlockType.OTHER, EndTag.END),
H1,
H2,
H3,
H4,
H5,
H6,
HEAD(BlockType.OTHER, EndTag.END),
HR(BlockType.BLOCK, EndTag.NOEND),
HTML(BlockType.OTHER, EndTag.END),
I(BlockType.INLINE, EndTag.END),
IMG(BlockType.INLINE, EndTag.NOEND),
LI,
LINK(BlockType.OTHER, EndTag.NOEND),
MENU,
META(BlockType.OTHER, EndTag.NOEND),
NOFRAMES(BlockType.OTHER, EndTag.END),
NOSCRIPT(BlockType.OTHER, EndTag.END),
OL,
P,
PRE,
SCRIPT(BlockType.OTHER, EndTag.END),
SMALL(BlockType.INLINE, EndTag.END),
SPAN(BlockType.INLINE, EndTag.END),
STRONG(BlockType.INLINE, EndTag.END),
TABLE,
TBODY,
TD,
TH,
TITLE(BlockType.OTHER, EndTag.END),
TR,
TT(BlockType.INLINE, EndTag.END),
UL;
protected final BlockType blockType;
protected final EndTag endTag;
private final String value;
/**
* Enum representing the type of HTML element.
*/
protected static enum BlockType {
BLOCK,
INLINE,
OTHER;
}
/**
* Enum representing HTML end tag requirement.
*/
protected static enum EndTag {
END,
NOEND;
}
HtmlTag() {
this(BlockType.BLOCK, EndTag.END);
}
HtmlTag(BlockType blockType, EndTag endTag ) {
this.blockType = blockType;
this.endTag = endTag;
this.value = name().toLowerCase();
}
/**
* Returns true if the end tag is required. This is specific to the standard
* doclet and does not exactly resemble the W3C specifications.
*
* @return true if end tag needs to be displayed else return false
*/
public boolean endTagRequired() {
return (endTag == EndTag.END);
}
public String toString() {
return value;
}
}

777
langtools/src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlTree.java Normal file
View file

@ -0,0 +1,777 @@
/*
* Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.tools.doclets.formats.html.markup;
import java.util.*;
import com.sun.tools.doclets.internal.toolkit.Content;
import com.sun.tools.doclets.internal.toolkit.util.*;
/**
* Class for generating HTML tree for javadoc output.
*
* @author Bhavesh Patel
*/
public class HtmlTree extends Content {
private HtmlTag htmlTag;
private Map<HtmlAttr,String> attrs = Collections.<HtmlAttr,String>emptyMap();
private List<Content> content = Collections.<Content>emptyList();
public static final Content EMPTY = new StringContent("");
/**
* Constructor to construct HtmlTree object.
*
* @param tag HTML tag for the HtmlTree object
*/
public HtmlTree(HtmlTag tag) {
htmlTag = nullCheck(tag);
}
/**
* Constructor to construct HtmlTree object.
*
* @param tag HTML tag for the HtmlTree object
* @param contents contents to be added to the tree
*/
public HtmlTree(HtmlTag tag, Content... contents) {
this(tag);
for (Content content: contents)
addContent(content);
}
/**
* Adds an attribute for the HTML tag.
*
* @param attrName name of the attribute
* @param attrValue value of the attribute
*/
public void addAttr(HtmlAttr attrName, String attrValue) {
if (attrs.isEmpty())
attrs = new LinkedHashMap<HtmlAttr,String>();
attrs.put(nullCheck(attrName), nullCheck(attrValue));
}
/**
* Adds a style for the HTML tag.
*
* @param style style to be added
*/
public void addStyle(HtmlStyle style) {
addAttr(HtmlAttr.CLASS, style.toString());
}
/**
* Adds content for the HTML tag.
*
* @param tagContent tag content to be added
*/
public void addContent(Content tagContent) {
if (tagContent == HtmlTree.EMPTY || tagContent.isValid()) {
if (content.isEmpty())
content = new ArrayList<Content>();
content.add(tagContent);
}
}
/**
* This method adds a string content to the htmltree. If the last content member
* added is a StringContent, append the string to that StringContent or else
* create a new StringContent and add it to the html tree.
*
* @param stringContent string content that needs to be added
*/
public void addContent(String stringContent) {
if (!content.isEmpty()) {
Content lastContent = content.get(content.size() - 1);
if (lastContent instanceof StringContent)
lastContent.addContent(stringContent);
else
addContent(new StringContent(stringContent));
}
else
addContent(new StringContent(stringContent));
}
/**
* Generates an HTML anchor tag.
*
* @param ref reference url for the anchor tag
* @param body content for the anchor tag
* @return an HtmlTree object
*/
public static HtmlTree A(String ref, Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.A, nullCheck(body));
htmltree.addAttr(HtmlAttr.HREF, nullCheck(ref));
return htmltree;
}
/**
* Generates an HTML anchor tag with name attribute and content.
*
* @param name name for the anchor tag
* @param body content for the anchor tag
* @return an HtmlTree object
*/
public static HtmlTree A_NAME(String name, Content body) {
HtmlTree htmltree = HtmlTree.A_NAME(name);
htmltree.addContent(nullCheck(body));
return htmltree;
}
/**
* Generates an HTML anchor tag with name attribute.
*
* @param name name for the anchor tag
* @return an HtmlTree object
*/
public static HtmlTree A_NAME(String name) {
HtmlTree htmltree = new HtmlTree(HtmlTag.A);
htmltree.addAttr(HtmlAttr.NAME, nullCheck(name));
return htmltree;
}
/**
* Generates a CAPTION tag with some content.
*
* @param body content for the tag
* @return an HtmlTree object for the CAPTION tag
*/
public static HtmlTree CAPTION(Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.CAPTION, nullCheck(body));
return htmltree;
}
/**
* Generates a CODE tag with some content.
*
* @param body content for the tag
* @return an HtmlTree object for the CODE tag
*/
public static HtmlTree CODE(Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.CODE, nullCheck(body));
return htmltree;
}
/**
* Generates a DD tag with some content.
*
* @param body content for the tag
* @return an HtmlTree object for the DD tag
*/
public static HtmlTree DD(Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.DD, nullCheck(body));
return htmltree;
}
/**
* Generates a DL tag with some content.
*
* @param body content for the tag
* @return an HtmlTree object for the DL tag
*/
public static HtmlTree DL(Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.DL, nullCheck(body));
return htmltree;
}
/**
* Generates a DIV tag with the style class attributes. It also encloses
* a content.
*
* @param styleClass stylesheet class for the tag
* @param body content for the tag
* @return an HtmlTree object for the DIV tag
*/
public static HtmlTree DIV(HtmlStyle styleClass, Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.DIV, nullCheck(body));
if (styleClass != null)
htmltree.addStyle(styleClass);
return htmltree;
}
/**
* Generates a DIV tag with some content.
*
* @param body content for the tag
* @return an HtmlTree object for the DIV tag
*/
public static HtmlTree DIV(Content body) {
return DIV(null, body);
}
/**
* Generates a DT tag with some content.
*
* @param body content for the tag
* @return an HtmlTree object for the DT tag
*/
public static HtmlTree DT(Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.DT, nullCheck(body));
return htmltree;
}
/**
* Generates a EM tag with some content.
*
* @param body content to be added to the tag
* @return an HtmlTree object for the EM tag
*/
public static HtmlTree EM(Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.EM, nullCheck(body));
return htmltree;
}
/**
* Generates a FRAME tag.
*
* @param src the url of the document to be shown in the frame
* @param name specifies the name of the frame
* @param title the title for the frame
* @param scrolling specifies whether to display scrollbars in the frame
* @return an HtmlTree object for the FRAME tag
*/
public static HtmlTree FRAME(String src, String name, String title, String scrolling) {
HtmlTree htmltree = new HtmlTree(HtmlTag.FRAME);
htmltree.addAttr(HtmlAttr.SRC, nullCheck(src));
htmltree.addAttr(HtmlAttr.NAME, nullCheck(name));
htmltree.addAttr(HtmlAttr.TITLE, nullCheck(title));
if (scrolling != null)
htmltree.addAttr(HtmlAttr.SCROLLING, scrolling);
return htmltree;
}
/**
* Generates a Frame tag.
*
* @param src the url of the document to be shown in the frame
* @param name specifies the name of the frame
* @param title the title for the frame
* @return an HtmlTree object for the SPAN tag
*/
public static HtmlTree FRAME(String src, String name, String title) {
return FRAME(src, name, title, null);
}
/**
* Generates a FRAMESET tag.
*
* @param cols the size of columns in the frameset
* @param rows the size of rows in the frameset
* @param title the title for the frameset
* @param onload the script to run when the document loads
* @return an HtmlTree object for the FRAMESET tag
*/
public static HtmlTree FRAMESET(String cols, String rows, String title, String onload) {
HtmlTree htmltree = new HtmlTree(HtmlTag.FRAMESET);
if (cols != null)
htmltree.addAttr(HtmlAttr.COLS, cols);
if (rows != null)
htmltree.addAttr(HtmlAttr.ROWS, rows);
htmltree.addAttr(HtmlAttr.TITLE, nullCheck(title));
htmltree.addAttr(HtmlAttr.ONLOAD, nullCheck(onload));
return htmltree;
}
/**
* Generates a heading tag (h1 to h6) with the title and style class attributes. It also encloses
* a content.
*
* @param headingTag the heading tag to be generated
* @param printTitle true if title for the tag needs to be printed else false
* @param styleClass stylesheet class for the tag
* @param body content for the tag
* @return an HtmlTree object for the tag
*/
public static HtmlTree HEADING(HtmlTag headingTag, boolean printTitle,
HtmlStyle styleClass, Content body) {
HtmlTree htmltree = new HtmlTree(headingTag, nullCheck(body));
if (printTitle)
htmltree.addAttr(HtmlAttr.TITLE, Util.stripHtml(body.toString()));
if (styleClass != null)
htmltree.addStyle(styleClass);
return htmltree;
}
/**
* Generates a heading tag (h1 to h6) with style class attribute. It also encloses
* a content.
*
* @param headingTag the heading tag to be generated
* @param styleClass stylesheet class for the tag
* @param body content for the tag
* @return an HtmlTree object for the tag
*/
public static HtmlTree HEADING(HtmlTag headingTag, HtmlStyle styleClass, Content body) {
return HEADING(headingTag, false, styleClass, body);
}
/**
* Generates a heading tag (h1 to h6) with the title attribute. It also encloses
* a content.
*
* @param headingTag the heading tag to be generated
* @param printTitle true if the title for the tag needs to be printed else false
* @param body content for the tag
* @return an HtmlTree object for the tag
*/
public static HtmlTree HEADING(HtmlTag headingTag, boolean printTitle, Content body) {
return HEADING(headingTag, printTitle, null, body);
}
/**
* Generates a heading tag (h1 to h6) with some content.
*
* @param headingTag the heading tag to be generated
* @param body content for the tag
* @return an HtmlTree object for the tag
*/
public static HtmlTree HEADING(HtmlTag headingTag, Content body) {
return HEADING(headingTag, false, null, body);
}
/**
* Generates an HTML tag with lang attribute. It also adds head and body
* content to the HTML tree.
*
* @param lang language for the HTML document
* @param head head for the HTML tag
* @param body body for the HTML tag
* @return an HtmlTree object for the HTML tag
*/
public static HtmlTree HTML(String lang, Content head, Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.HTML, nullCheck(head), nullCheck(body));
htmltree.addAttr(HtmlAttr.LANG, nullCheck(lang));
return htmltree;
}
/**
* Generates a I tag with some content.
*
* @param body content for the tag
* @return an HtmlTree object for the I tag
*/
public static HtmlTree I(Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.I, nullCheck(body));
return htmltree;
}
/**
* Generates a LI tag with some content.
*
* @param body content for the tag
* @return an HtmlTree object for the LI tag
*/
public static HtmlTree LI(Content body) {
return LI(null, body);
}
/**
* Generates a LI tag with some content.
*
* @param styleClass style for the tag
* @param body content for the tag
* @return an HtmlTree object for the LI tag
*/
public static HtmlTree LI(HtmlStyle styleClass, Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.LI, nullCheck(body));
if (styleClass != null)
htmltree.addStyle(styleClass);
return htmltree;
}
/**
* Generates a LINK tag with the rel, type, href and title attributes.
*
* @param rel relevance of the link
* @param type type of link
* @param href the path for the link
* @param title title for the link
* @return an HtmlTree object for the LINK tag
*/
public static HtmlTree LINK(String rel, String type, String href, String title) {
HtmlTree htmltree = new HtmlTree(HtmlTag.LINK);
htmltree.addAttr(HtmlAttr.REL, nullCheck(rel));
htmltree.addAttr(HtmlAttr.TYPE, nullCheck(type));
htmltree.addAttr(HtmlAttr.HREF, nullCheck(href));
htmltree.addAttr(HtmlAttr.TITLE, nullCheck(title));
return htmltree;
}
/**
* Generates a META tag with the http-equiv, content and charset attributes.
*
* @param http-equiv http equiv attribute for the META tag
* @param content type of content
* @param charset character set used
* @return an HtmlTree object for the META tag
*/
public static HtmlTree META(String httpEquiv, String content, String charSet) {
HtmlTree htmltree = new HtmlTree(HtmlTag.META);
htmltree.addAttr(HtmlAttr.HTTP_EQUIV, nullCheck(httpEquiv));
htmltree.addAttr(HtmlAttr.CONTENT, nullCheck(content));
htmltree.addAttr(HtmlAttr.CHARSET, nullCheck(charSet));
return htmltree;
}
/**
* Generates a META tag with the name and content attributes.
*
* @param name name attribute
* @param content type of content
* @return an HtmlTree object for the META tag
*/
public static HtmlTree META(String name, String content) {
HtmlTree htmltree = new HtmlTree(HtmlTag.META);
htmltree.addAttr(HtmlAttr.NAME, nullCheck(name));
htmltree.addAttr(HtmlAttr.CONTENT, nullCheck(content));
return htmltree;
}
/**
* Generates a NOSCRIPT tag with some content.
*
* @param body content of the noscript tag
* @return an HtmlTree object for the NOSCRIPT tag
*/
public static HtmlTree NOSCRIPT(Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.NOSCRIPT, nullCheck(body));
return htmltree;
}
/**
* Generates a P tag with some content.
*
* @param body content of the Paragraph tag
* @return an HtmlTree object for the P tag
*/
public static HtmlTree P(Content body) {
return P(null, body);
}
/**
* Generates a P tag with some content.
*
* @param styleClass style of the Paragraph tag
* @param body content of the Paragraph tag
* @return an HtmlTree object for the P tag
*/
public static HtmlTree P(HtmlStyle styleClass, Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.P, nullCheck(body));
if (styleClass != null)
htmltree.addStyle(styleClass);
return htmltree;
}
/**
* Generates a SMALL tag with some content.
*
* @param body content for the tag
* @return an HtmlTree object for the SMALL tag
*/
public static HtmlTree SMALL(Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.SMALL, nullCheck(body));
return htmltree;
}
/**
* Generates a STRONG tag with some content.
*
* @param body content for the tag
* @return an HtmlTree object for the STRONG tag
*/
public static HtmlTree STRONG(Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.STRONG, nullCheck(body));
return htmltree;
}
/**
* Generates a SPAN tag with some content.
*
* @param body content for the tag
* @return an HtmlTree object for the SPAN tag
*/
public static HtmlTree SPAN(Content body) {
return SPAN(null, body);
}
/**
* Generates a SPAN tag with style class attribute and some content.
*
* @param styleClass style class for the tag
* @param body content for the tag
* @return an HtmlTree object for the SPAN tag
*/
public static HtmlTree SPAN(HtmlStyle styleClass, Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.SPAN, nullCheck(body));
if (styleClass != null)
htmltree.addStyle(styleClass);
return htmltree;
}
/**
* Generates a Table tag with border, width and summary attributes and
* some content.
*
* @param border border for the table
* @param width width of the table
* @param summary summary for the table
* @param body content for the table
* @return an HtmlTree object for the TABLE tag
*/
public static HtmlTree TABLE(int border, int width, String summary,
Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.TABLE, nullCheck(body));
htmltree.addAttr(HtmlAttr.BORDER, Integer.toString(border));
htmltree.addAttr(HtmlAttr.WIDTH, Integer.toString(width));
htmltree.addAttr(HtmlAttr.SUMMARY, nullCheck(summary));
return htmltree;
}
/**
* Generates a Table tag with style class, border, cell padding,
* cellspacing and summary attributes and some content.
*
* @param styleClass style of the table
* @param border border for the table
* @param cellPadding cell padding for the table
* @param cellSpacing cell spacing for the table
* @param summary summary for the table
* @param body content for the table
* @return an HtmlTree object for the TABLE tag
*/
public static HtmlTree TABLE(HtmlStyle styleClass, int border, int cellPadding,
int cellSpacing, String summary, Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.TABLE, nullCheck(body));
if (styleClass != null)
htmltree.addStyle(styleClass);
htmltree.addAttr(HtmlAttr.BORDER, Integer.toString(border));
htmltree.addAttr(HtmlAttr.CELLPADDING, Integer.toString(cellPadding));
htmltree.addAttr(HtmlAttr.CELLSPACING, Integer.toString(cellSpacing));
htmltree.addAttr(HtmlAttr.SUMMARY, nullCheck(summary));
return htmltree;
}
/**
* Generates a Table tag with border, cell padding,
* cellspacing and summary attributes and some content.
*
* @param border border for the table
* @param cellPadding cell padding for the table
* @param cellSpacing cell spacing for the table
* @param summary summary for the table
* @param body content for the table
* @return an HtmlTree object for the TABLE tag
*/
public static HtmlTree TABLE(int border, int cellPadding,
int cellSpacing, String summary, Content body) {
return TABLE(null, border, cellPadding, cellSpacing, summary, body);
}
/**
* Generates a TD tag with style class attribute and some content.
*
* @param styleClass style for the tag
* @param body content for the tag
* @return an HtmlTree object for the TD tag
*/
public static HtmlTree TD(HtmlStyle styleClass, Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.TD, nullCheck(body));
if (styleClass != null)
htmltree.addStyle(styleClass);
return htmltree;
}
/**
* Generates a TD tag for an HTML table with some content.
*
* @param body content for the tag
* @return an HtmlTree object for the TD tag
*/
public static HtmlTree TD(Content body) {
return TD(null, body);
}
/**
* Generates a TH tag with style class and scope attributes and some content.
*
* @param styleClass style for the tag
* @param scope scope of the tag
* @param body content for the tag
* @return an HtmlTree object for the TH tag
*/
public static HtmlTree TH(HtmlStyle styleClass, String scope, Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.TH, nullCheck(body));
if (styleClass != null)
htmltree.addStyle(styleClass);
htmltree.addAttr(HtmlAttr.SCOPE, nullCheck(scope));
return htmltree;
}
/**
* Generates a TH tag with scope attribute and some content.
*
* @param scope scope of the tag
* @param body content for the tag
* @return an HtmlTree object for the TH tag
*/
public static HtmlTree TH(String scope, Content body) {
return TH(null, scope, body);
}
/**
* Generates a TITLE tag with some content.
*
* @param body content for the tag
* @return an HtmlTree object for the TITLE tag
*/
public static HtmlTree TITLE(Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.TITLE, nullCheck(body));
return htmltree;
}
/**
* Generates a TR tag for an HTML table with some content.
*
* @param body content for the tag
* @return an HtmlTree object for the TR tag
*/
public static HtmlTree TR(Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.TR, nullCheck(body));
return htmltree;
}
/**
* Generates a UL tag with the style class attribute and some content.
*
* @param styleClass style for the tag
* @param body content for the tag
* @return an HtmlTree object for the UL tag
*/
public static HtmlTree UL(HtmlStyle styleClass, Content body) {
HtmlTree htmltree = new HtmlTree(HtmlTag.UL, nullCheck(body));
htmltree.addStyle(nullCheck(styleClass));
return htmltree;
}
/**
* {@inheritDoc}
*/
public boolean isEmpty() {
return (!hasContent() && !hasAttrs());
}
/**
* Returns true if the HTML tree has content.
*
* @return true if the HTML tree has content else return false
*/
public boolean hasContent() {
return (!content.isEmpty());
}
/**
* Returns true if the HTML tree has attributes.
*
* @return true if the HTML tree has attributes else return false
*/
public boolean hasAttrs() {
return (!attrs.isEmpty());
}
/**
* Returns true if the HTML tree has a specific attribute.
*
* @param attrName name of the attribute to check within the HTML tree
* @return true if the HTML tree has the specified attribute else return false
*/
public boolean hasAttr(HtmlAttr attrName) {
return (attrs.containsKey(attrName));
}
/**
* Returns true if the HTML tree is valid. This check is more specific to
* standard doclet and not exactly similar to W3C specifications. But it
* ensures HTML validation.
*
* @return true if the HTML tree is valid
*/
public boolean isValid() {
switch (htmlTag) {
case A :
return (hasAttr(HtmlAttr.NAME) || (hasAttr(HtmlAttr.HREF) && hasContent()));
case BR :
return (!hasContent() && (!hasAttrs() || hasAttr(HtmlAttr.CLEAR)));
case FRAME :
return (hasAttr(HtmlAttr.SRC) && !hasContent());
case HR :
return (!hasContent());
case IMG :
return (hasAttr(HtmlAttr.SRC) && hasAttr(HtmlAttr.ALT) && !hasContent());
case LINK :
return (hasAttr(HtmlAttr.HREF) && !hasContent());
case META :
return (hasAttr(HtmlAttr.CONTENT) && !hasContent());
default :
return hasContent();
}
}
/**
* Returns true if the element is an inline element.
*
* @return true if the HTML tag is an inline element
*/
public boolean isInline() {
return (htmlTag.blockType == HtmlTag.BlockType.INLINE);
}
/**
* {@inheritDoc}
*/
public void write(StringBuilder contentBuilder) {
if (!isInline() && !endsWithNewLine(contentBuilder))
contentBuilder.append("\n");
String tagString = htmlTag.toString();
contentBuilder.append("<" + tagString);
Iterator<HtmlAttr> iterator = attrs.keySet().iterator();
HtmlAttr key;
String value = "";
while (iterator.hasNext()) {
key = iterator.next();
value = attrs.get(key);
contentBuilder.append(" " + key.toString());
if (!value.isEmpty())
contentBuilder.append("=\"" + value + "\"");
}
contentBuilder.append(">");
for (Content c : content)
c.write(contentBuilder);
if (htmlTag.endTagRequired())
contentBuilder.append("</" + tagString + ">");
if (!isInline())
contentBuilder.append("\n");
}
}

235
langtools/src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlWriter.java
View file

@ -55,7 +55,7 @@ public class HtmlWriter extends PrintWriter {
* URL file separator string("/").
*/
public static final String fileseparator =
DirectoryManager.URL_FILE_SEPERATOR;
DirectoryManager.URL_FILE_SEPARATOR;
/**
* The configuration
@ -82,6 +82,72 @@ public class HtmlWriter extends PrintWriter {
*/
protected final String modifierTypeHeader;
public final Content overviewLabel;
public final Content defaultPackageLabel;
public final Content packageLabel;
public final Content useLabel;
public final Content prevLabel;
public final Content nextLabel;
public final Content prevclassLabel;
public final Content nextclassLabel;
public final Content summaryLabel;
public final Content detailLabel;
public final Content framesLabel;
public final Content noframesLabel;
public final Content treeLabel;
public final Content classLabel;
public final Content deprecatedLabel;
public final Content deprecatedPhrase;
public final Content allclassesLabel;
public final Content indexLabel;
public final Content helpLabel;
public final Content seeLabel;
public final Content descriptionLabel;
public final Content prevpackageLabel;
public final Content nextpackageLabel;
public final Content packagesLabel;
public final Content methodDetailsLabel;
public final Content annotationTypeDetailsLabel;
public final Content fieldDetailsLabel;
public final Content constructorDetailsLabel;
public final Content enumConstantsDetailsLabel;
public final Content specifiedByLabel;
public final Content overridesLabel;
public final Content descfrmClassLabel;
public final Content descfrmInterfaceLabel;
/**
* Constructor.
*
@ -111,6 +177,73 @@ public class HtmlWriter extends PrintWriter {
modifierTypeHeader = configuration.getText("doclet.0_and_1",
configuration.getText("doclet.Modifier"),
configuration.getText("doclet.Type"));
overviewLabel = getResource("doclet.Overview");
defaultPackageLabel = new RawHtml(
DocletConstants.DEFAULT_PACKAGE_NAME);
packageLabel = getResource("doclet.Package");
useLabel = getResource("doclet.navClassUse");
prevLabel = getResource("doclet.Prev");
nextLabel = getResource("doclet.Next");
prevclassLabel = getResource("doclet.Prev_Class");
nextclassLabel = getResource("doclet.Next_Class");
summaryLabel = getResource("doclet.Summary");
detailLabel = getResource("doclet.Detail");
framesLabel = getResource("doclet.FRAMES");
noframesLabel = getResource("doclet.NO_FRAMES");
treeLabel = getResource("doclet.Tree");
classLabel = getResource("doclet.Class");
deprecatedLabel = getResource("doclet.navDeprecated");
deprecatedPhrase = getResource("doclet.Deprecated");
allclassesLabel = getResource("doclet.All_Classes");
indexLabel = getResource("doclet.Index");
helpLabel = getResource("doclet.Help");
seeLabel = getResource("doclet.See");
descriptionLabel = getResource("doclet.Description");
prevpackageLabel = getResource("doclet.Prev_Package");
nextpackageLabel = getResource("doclet.Next_Package");
packagesLabel = getResource("doclet.Packages");
methodDetailsLabel = getResource("doclet.Method_Detail");
annotationTypeDetailsLabel = getResource("doclet.Annotation_Type_Member_Detail");
fieldDetailsLabel = getResource("doclet.Field_Detail");
constructorDetailsLabel = getResource("doclet.Constructor_Detail");
enumConstantsDetailsLabel = getResource("doclet.Enum_Constant_Detail");
specifiedByLabel = getResource("doclet.Specified_By");
overridesLabel = getResource("doclet.Overrides");
descfrmClassLabel = getResource("doclet.Description_From_Class");
descfrmInterfaceLabel = getResource("doclet.Description_From_Interface");
}
/**
* Get the configuration string as a content.
*
* @param key the key to look for in the configuration file
* @return a content tree for the text
*/
public Content getResource(String key) {
return new StringContent(configuration.getText(key));
}
/**
* Get the configuration string as a content.
*
* @param key the key to look for in the configuration file
* @param a1 string argument added to configuration text
* @return a content tree for the text
*/
public Content getResource(String key, String a1) {
return new RawHtml(configuration.getText(key, a1));
}
/**
* Get the configuration string as a content.
*
* @param key the key to look for in the configuration file
* @param a1 string argument added to configuration text
* @param a2 string argument added to configuration text
* @return a content tree for the text
*/
public Content getResource(String key, String a1, String a2) {
return new RawHtml(configuration.getText(key, a1, a2));
}
/**
@ -145,6 +278,48 @@ public class HtmlWriter extends PrintWriter {
}
}
/**
* Returns an HtmlTree for the SCRIPT tag.
*
* @return an HtmlTree for the SCRIPT tag
*/
protected HtmlTree getWinTitleScript(){
HtmlTree script = new HtmlTree(HtmlTag.SCRIPT);
if(winTitle != null && winTitle.length() > 0) {
script.addAttr(HtmlAttr.TYPE, "text/javascript");
String scriptCode = "<!--\n" +
" if (location.href.indexOf('is-external=true') == -1) {\n" +
" parent.document.title=\"" + winTitle + "\";\n" +
" }\n" +
"//-->\n";
RawHtml scriptContent = new RawHtml(scriptCode);
script.addContent(scriptContent);
}
return script;
}
/**
* Returns a content tree for the SCRIPT tag for the main page(index.html).
*
* @return a content for the SCRIPT tag
*/
protected Content getFramesetJavaScript(){
HtmlTree script = new HtmlTree(HtmlTag.SCRIPT);
script.addAttr(HtmlAttr.TYPE, "text/javascript");
String scriptCode = "\n targetPage = \"\" + window.location.search;\n" +
" if (targetPage != \"\" && targetPage != \"undefined\")\n" +
" targetPage = targetPage.substring(1);\n" +
" if (targetPage.indexOf(\":\") != -1)\n" +
" targetPage = \"undefined\";\n" +
" function loadFrames() {\n" +
" if (targetPage != \"\" && targetPage != \"undefined\")\n" +
" top.classFrame.location = top.targetPage;\n" +
" }\n";
RawHtml scriptContent = new RawHtml(scriptCode);
script.addContent(scriptContent);
return script;
}
/**
* Print the Javascript &lt;SCRIPT&gt; start tag with its type
* attribute.
@ -203,6 +378,28 @@ public class HtmlWriter extends PrintWriter {
println(">");
}
/**
* Returns an HtmlTree for the BODY tag.
*
* @param includeScript set true if printing windowtitle script
* @param title title for the window
* @return an HtmlTree for the BODY tag
*/
public HtmlTree getBody(boolean includeScript, String title) {
HtmlTree body = new HtmlTree(HtmlTag.BODY);
// Set window title string which is later printed
this.winTitle = title;
// Don't print windowtitle script for overview-frame, allclasses-frame
// and package-frame
if (includeScript) {
body.addContent(getWinTitleScript());
Content noScript = HtmlTree.NOSCRIPT(
HtmlTree.DIV(getResource("doclet.No_Script_Message")));
body.addContent(noScript);
}
return body;
}
/**
* Print &lt;/BODY&gt; tag. Add a newline character at the end.
*/
@ -228,6 +425,15 @@ public class HtmlWriter extends PrintWriter {
title();
}
/**
* Returns an HtmlTree for the TITLE tag.
*
* @return an HtmlTree for the TITLE tag
*/
public HtmlTree getTitle() {
HtmlTree title = HtmlTree.TITLE(new StringContent(winTitle));
return title;
}
/**
* Print &lt;/TITLE&gt; tag. Add a newline character at the end.
@ -519,17 +725,17 @@ public class HtmlWriter extends PrintWriter {
}
/**
* Return, text passed, with Italics &lt;I&gt; and &lt;/I&gt; tags, surrounding it.
* So if the text passed is "Hi", then string returned will be "&lt;I&gt;Hi&lt;/I&gt;".
* Return, text passed, with Italics &lt;i&gt; and &lt;/i&gt; tags, surrounding it.
* So if the text passed is "Hi", then string returned will be "&lt;i&gt;Hi&lt;/i&gt;".
*
* @param text String to be printed in between &lt;I&gt; and &lt;/I&gt; tags.
*/
public String italicsText(String text) {
return "<I>" + text + "</I>";
return "<i>" + text + "</i>";
}
public String codeText(String text) {
return "<CODE>" + text + "</CODE>";
return "<code>" + text + "</code>";
}
/**
@ -539,6 +745,13 @@ public class HtmlWriter extends PrintWriter {
print("&nbsp;");
}
/**
* Return "&#38;nbsp;", non-breaking space.
*/
public Content getSpace() {
return RawHtml.nbsp;
}
/**
* Print &lt;DL&gt; tag. Add a newline character at the end.
*/
@ -1182,21 +1395,21 @@ public class HtmlWriter extends PrintWriter {
}
/**
* Get the "&lt;CODE&gt;" string.
* Get the "&lt;code&gt;" string.
*
* @return String Return String "&lt;CODE>";
* @return String Return String "&lt;code&gt;";
*/
public String getCode() {
return "<CODE>";
return "<code>";
}
/**
* Get the "&lt;/CODE&gt;" string.
* Get the "&lt;/code&gt;" string.
*
* @return String Return String "&lt;/CODE&gt;";
* @return String Return String "&lt;/code&gt;";
*/
public String getCodeEnd() {
return "</CODE>";
return "</code>";
}
/**

88
langtools/src/share/classes/com/sun/tools/doclets/formats/html/markup/RawHtml.java Normal file
View file

@ -0,0 +1,88 @@
/*
* Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.tools.doclets.formats.html.markup;
import com.sun.tools.doclets.internal.toolkit.Content;
import com.sun.tools.doclets.internal.toolkit.util.*;
/**
* Class for generating raw HTML content to be added to HTML pages of javadoc output.
*
* @author Bhavesh Patel
*/
public class RawHtml extends Content{
private String rawHtmlContent;
public static final Content nbsp = new RawHtml("&nbsp;");
/**
* Constructor to construct a RawHtml object.
*
* @param rawHtml raw HTML text to be added
*/
public RawHtml(String rawHtml) {
rawHtmlContent = nullCheck(rawHtml);
}
/**
* This method is not supported by the class.
*
* @param content content that needs to be added
* @throws DocletAbortException this method will always throw a
* DocletAbortException because it
* is not supported.
*/
public void addContent(Content content) {
throw new DocletAbortException();
}
/**
* This method is not supported by the class.
*
* @param stringContent string content that needs to be added
* @throws DocletAbortException this method will always throw a
* DocletAbortException because it
* is not supported.
*/
public void addContent(String stringContent) {
throw new DocletAbortException();
}
/**
* {@inheritDoc}
*/
public boolean isEmpty() {
return rawHtmlContent.isEmpty();
}
/**
* {@inheritDoc}
*/
public void write(StringBuilder contentBuilder) {
contentBuilder.append(rawHtmlContent);
}
}

99
langtools/src/share/classes/com/sun/tools/doclets/formats/html/markup/StringContent.java Normal file
View file

@ -0,0 +1,99 @@
/*
* Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.tools.doclets.formats.html.markup;
import com.sun.tools.doclets.internal.toolkit.Content;
import com.sun.tools.doclets.internal.toolkit.util.*;
/**
* Class for generating string content for HTML tags of javadoc output.
*
* @author Bhavesh Patel
*/
public class StringContent extends Content{
private StringBuilder stringContent;
/**
* Constructor to construct StringContent object.
*/
public StringContent() {
stringContent = new StringBuilder();
}
/**
* Constructor to construct StringContent object with some initial content.
*
* @param initialContent initial content for the object
*/
public StringContent(String initialContent) {
stringContent = new StringBuilder(
Util.escapeHtmlChars(nullCheck(initialContent)));
}
/**
* This method is not supported by the class.
*
* @param content content that needs to be added
* @throws DocletAbortException this method will always throw a
* DocletAbortException because it
* is not supported.
*/
public void addContent(Content content) {
throw new DocletAbortException();
}
/**
* Adds content for the StringContent object. The method escapes
* HTML characters for the string content that is added.
*
* @param strContent string content to be added
*/
public void addContent(String strContent) {
stringContent.append(Util.escapeHtmlChars(nullCheck(strContent)));
}
/**
* {@inheritDoc}
*/
public boolean isEmpty() {
return (stringContent.length() == 0);
}
/**
* {@inheritDoc}
*/
public String toString() {
return stringContent.toString();
}
/**
* {@inheritDoc}
*/
public void write(StringBuilder contentBuilder) {
contentBuilder.append(stringContent);
}
}

11
langtools/src/share/classes/com/sun/tools/doclets/formats/html/resources/standard.properties
View file

@ -43,6 +43,7 @@ doclet.Window_Single_Index=Index
doclet.Window_Split_Index={0}-Index
doclet.Help=Help
doclet.Skip_navigation_links=Skip navigation links
doclet.New_Page=NewPage
doclet.None=None
doclet.CLASSES=CLASSES
doclet.MEMBERS=MEMBERS
@ -53,7 +54,7 @@ doclet.Deprecated_List=Deprecated List
doclet.Window_Deprecated_List=Deprecated List
doclet.Note_0_is_deprecated=Note: {0} is deprecated.
doclet.Overrides=Overrides:
doclet.in_class={0} in class {1}
doclet.in_class=in class
doclet.0_Fields_and_Methods=&quot;{0}&quot; Fields and Methods
doclet.Index_of_Fields_and_Methods=Index of Fields and Methods
doclet.Static_variable_in=Static variable in {0}
@ -103,7 +104,7 @@ doclet.Other_Packages=Other Packages
doclet.Package_Description=Package {0} Description
doclet.Description=Description
doclet.Specified_By=Specified by:
doclet.in_interface={0} in interface {1}
doclet.in_interface=in interface
doclet.Subclasses=Direct Known Subclasses:
doclet.Subinterfaces=All Known Subinterfaces:
doclet.Implementing_Classes=All Known Implementing Classes:
@ -121,18 +122,20 @@ doclet.Cannot_handle_no_packages=Cannot handle no packages.
doclet.Frame_Alert=Frame Alert
doclet.Overview-Member-Frame=Overview Member Frame
doclet.Frame_Warning_Message=This document is designed to be viewed using the frames feature. If you see this message, you are using a non-frame-capable web client.
doclet.No_Script_Message=JavaScript is disabled on your browser.
doclet.Non_Frame_Version=Non-frame version.
doclet.Frame_Version=Frame version
doclet.Link_To=Link to
doclet.Following_From_Class=Following copied from class: {0}
doclet.Following_From_Interface=Following copied from interface: {0}
doclet.Description_From_Interface=Description copied from interface: {0}
doclet.Description_From_Class=Description copied from class: {0}
doclet.Description_From_Interface=Description copied from interface:
doclet.Description_From_Class=Description copied from class:
doclet.Standard_doclet_invoked=Standard doclet invoked...
doclet.No_Non_Deprecated_Classes_To_Document=No non-deprecated classes found to document.
doclet.Interfaces_Italic=Interfaces (italic)
doclet.Enclosing_Class=Enclosing class:
doclet.Enclosing_Interface=Enclosing interface:
doclet.Window_Source_title=Source code
doclet.Help_title=API Help
doclet.Window_Help_title=API Help
doclet.Help_line_1=How This API Document Is Organized

8
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/AnnotationTypeOptionalMemberWriter.java
View file

@ -35,6 +35,7 @@ import com.sun.javadoc.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
@ -42,7 +43,10 @@ public interface AnnotationTypeOptionalMemberWriter extends
AnnotationTypeRequiredMemberWriter {
/**
* Write the default value documentation.
* Add the the default value documentation.
*
* @param member the member being documented
* @param annotationDocTree content tree to which the default value will be added
*/
public void writeDefaultValueInfo(MemberDoc member);
public void addDefaultValueInfo(MemberDoc member, Content annotationDocTree);
}

64
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/AnnotationTypeRequiredMemberWriter.java
View file

@ -36,67 +36,79 @@ import com.sun.javadoc.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
public interface AnnotationTypeRequiredMemberWriter {
/**
* Write the header for the member documentation.
* Add the annotation type details tree header.
*
* @param classDoc the annotation type that the members belong to.
* @param header the header to write.
* @param classDoc the annotation type being documented
* @param memberDetailsTree the content tree representing member details
*/
public void writeHeader(ClassDoc classDoc, String header);
public void addAnnotationDetailsTreeHeader(ClassDoc classDoc,
Content memberDetailsTree);
/**
* Write the member header for the given member.
* Get the annotation type documentation tree header.
*
* @param member the member being documented.
* @param isFirst the flag to indicate whether or not the member is
* the first to be documented.
* @param member the annotation type being documented
* @param annotationDetailsTree the content tree representing annotation type details
* @return content tree for the annotation type documentation header
*/
public void writeMemberHeader(MemberDoc member, boolean isFirst);
public Content getAnnotationDocTreeHeader(MemberDoc member,
Content annotationDetailsTree);
/**
* Write the signature for the given member.
* Get the annotation type details tree.
*
* @param member the member being documented.
* @param annotationDetailsTree the content tree representing annotation type details
* @return content tree for the annotation type details
*/
public void writeSignature(MemberDoc member);
public Content getAnnotationDetails(Content annotationDetailsTree);
/**
* Write the deprecated output for the given member.
* Get the annotation type documentation.
*
* @param member the member being documented.
* @param annotationDocTree the content tree representing annotation type documentation
* @param isLastContent true if the content to be added is the last content
* @return content tree for the annotation type documentation
*/
public void writeDeprecated(MemberDoc member);
public Content getAnnotationDoc(Content annotationDocTree, boolean isLastContent);
/**
* Write the comments for the given member.
* Get the signature for the given member.
*
* @param member the member being documented.
* @param member the member being documented
* @return content tree for the annotation type signature
*/
public void writeComments(MemberDoc member);
public Content getSignature(MemberDoc member);
/**
* Write the tag output for the given member.
* Add the deprecated output for the given member.
*
* @param member the member being documented.
* @param member the member being documented
* @param annotationDocTree content tree to which the deprecated information will be added
*/
public void writeTags(MemberDoc member);
public void addDeprecated(MemberDoc member, Content annotationDocTree);
/**
* Write the member footer.
* Add the comments for the given member.
*
* @param member the member being documented
* @param annotationDocTree the content tree to which the comments will be added
*/
public void writeMemberFooter();
public void addComments(MemberDoc member, Content annotationDocTree);
/**
* Write the footer for the member documentation.
* Add the tags for the given member.
*
* @param classDoc the class that the member belong to.
* @param member the member being documented
* @param annotationDocTree the content tree to which the tags will be added
*/
public void writeFooter(ClassDoc classDoc);
public void addTags(MemberDoc member, Content annotationDocTree);
/**
* Close the writer.

111
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/AnnotationTypeWriter.java
View file

@ -37,43 +37,122 @@ import com.sun.javadoc.*;
* Do not use it as an API.
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
public interface AnnotationTypeWriter {
/**
* Write the header of the page.
* @param header the header to write.
* Get the header of the page.
*
* @param header the header string to write
* @return a content tree for the header documentation
*/
public void writeHeader(String header);
public Content getHeader(String header);
/**
* Write the signature of the current annotation type.
* Get the annotation content header.
*
* @param modifiers the modifiers for the signature.
* @return annotation content header that needs to be added to the documentation
*/
public void writeAnnotationTypeSignature(String modifiers);
public Content getAnnotationContentHeader();
/**
* Get the annotation information tree header.
*
* @return annotation information tree header that needs to be added to the documentation
*/
public Content getAnnotationInfoTreeHeader();
/**
* Get the annotation information.
*
* @param annotationInfoTree content tree containing the annotation information
* @return a content tree for the annotation
*/
public Content getAnnotationInfo(Content annotationInfoTree);
/**
* Add the signature of the current annotation type.
*
* @param modifiers the modifiers for the signature
* @param annotationInfoTree the annotation content tree to which the signature will be added
*/
public void addAnnotationTypeSignature(String modifiers, Content annotationInfoTree);
/**
* Build the annotation type description.
*
* @param annotationInfoTree content tree to which the description will be added
*/
public void writeAnnotationTypeDescription();
public void addAnnotationTypeDescription(Content annotationInfoTree);
/**
* Write the tag information for the current annotation type.
* Add the tag information for the current annotation type.
*
* @param annotationInfoTree content tree to which the tag information will be added
*/
public void writeAnnotationTypeTagInfo();
public void addAnnotationTypeTagInfo(Content annotationInfoTree);
/**
* If this annotation type is deprecated, write the appropriate information.
* If this annotation is deprecated, add the appropriate information.
*
* @param annotationInfoTree content tree to which the deprecated information will be added
*/
public void writeAnnotationTypeDeprecationInfo();
public void addAnnotationTypeDeprecationInfo (Content annotationInfoTree);
/**
* Write the footer of the page.
* Add the annotation type details marker.
*
* @param memberDetails the content tree representing member details marker
*/
public void writeFooter();
public void addAnnotationDetailsMarker(Content memberDetails);
/**
* Get the member tree header for the annotation type.
*
* @return a content tree for the member tree header
*/
public Content getMemberTreeHeader();
/**
* Get the member tree.
*
* @param memberTree the content tree that will be modified and returned
* @return a content tree for the member
*/
public Content getMemberTree(Content memberTree);
/**
* Get the member summary tree.
*
* @param memberTree the content tree that will be used to build the summary tree
* @return a content tree for the member summary
*/
public Content getMemberSummaryTree(Content memberTree);
/**
* Get the member details tree.
*
* @param memberTree the content tree that will be used to build the details tree
* @return a content tree for the member details
*/
public Content getMemberDetailsTree(Content memberTree);
/**
* Add the footer of the page.
*
* @param contentTree content tree to which the footer will be added
*/
public void addFooter(Content contentTree);
/**
* Print the document.
*
* @param contentTree content tree that will be printed as a document
*/
public void printDocument(Content contentTree);
/**
* Close the writer.
@ -86,10 +165,4 @@ public interface AnnotationTypeWriter {
* @return the AnnotationTypeDoc being documented.
*/
public AnnotationTypeDoc getAnnotationTypeDoc();
/**
* Perform any operations that are necessary when the member summary
* finished building.
*/
public void completeMemberSummaryBuild();
}

202
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/ClassWriter.java
View file

@ -37,85 +37,149 @@ import com.sun.javadoc.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
public interface ClassWriter {
/**
* Write the header of the page.
* @param header the header to write.
*/
public void writeHeader(String header);
/**
* Write the class tree documentation.
*/
public void writeClassTree();
/**
* Write all implemented interfaces if this is a class.
*/
public void writeImplementedInterfacesInfo();
/**
* Write all super interfaces if this is an interface.
*/
public void writeSuperInterfacesInfo();
/**
* Write the type parameter information.
*/
public void writeTypeParamInfo();
/**
* Write all the classes that extend this one.
*/
public void writeSubClassInfo();
/**
* Write all the interfaces that extend this one.
*/
public void writeSubInterfacesInfo();
/**
* If this is an interface, write all classes that implement this
* interface.
*/
public void writeInterfaceUsageInfo ();
/**
* If this is an inner class or interface, write the enclosing class or
* interface.
*/
public void writeNestedClassInfo ();
/**
* If this class is deprecated, write the appropriate information.
*/
public void writeClassDeprecationInfo ();
/**
* Write the signature of the current class.
* Get the header of the page.
*
* @param modifiers the modifiers for the signature.
* @param header the header string to write
* @return header content that needs to be added to the documentation
*/
public void writeClassSignature(String modifiers);
public Content getHeader(String header);
/**
* Get the class content header.
*
* @return class content header that needs to be added to the documentation
*/
public Content getClassContentHeader();
/**
* Add the class tree documentation.
*
* @param classContentTree class content tree to which the documentation will be added
*/
public void addClassTree(Content classContentTree);
/**
* Get the class information tree header.
*
* @return class informaion tree header that needs to be added to the documentation
*/
public Content getClassInfoTreeHeader();
/**
* Add the type parameter information.
*
* @param classInfoTree content tree to which the documentation will be added
*/
public void addTypeParamInfo(Content classInfoTree);
/**
* Add all super interfaces if this is an interface.
*
* @param classInfoTree content tree to which the documentation will be added
*/
public void addSuperInterfacesInfo(Content classInfoTree);
/**
* Add all implemented interfaces if this is a class.
*
* @param classInfoTree content tree to which the documentation will be added
*/
public void addImplementedInterfacesInfo(Content classInfoTree);
/**
* Add all the classes that extend this one.
*
* @param classInfoTree content tree to which the documentation will be added
*/
public void addSubClassInfo(Content classInfoTree);
/**
* Add all the interfaces that extend this one.
*
* @param classInfoTree content tree to which the documentation will be added
*/
public void addSubInterfacesInfo(Content classInfoTree);
/**
* If this is an interface, add all classes that implement this
* interface.
*
* @param classInfoTree content tree to which the documentation will be added
*/
public void addInterfaceUsageInfo(Content classInfoTree);
/**
* If this is an inner class or interface, add the enclosing class or
* interface.
*
* @param classInfoTree content tree to which the documentation will be added
*/
public void addNestedClassInfo (Content classInfoTree);
/**
* Get the class information.
*
* @param classInfoTree content tree conatining the class information
* @return a content tree for the class
*/
public Content getClassInfo(Content classInfoTree);
/**
* If this class is deprecated, add the appropriate information.
*
* @param classInfoTree content tree to which the documentation will be added
*/
public void addClassDeprecationInfo (Content classInfoTree);
/**
* Add the signature of the current class content tree.
*
* @param modifiers the modifiers for the signature
* @param classInfoTree the class content tree to which the signature will be added
*/
public void addClassSignature(String modifiers, Content classInfoTree);
/**
* Build the class description.
*
* @param classInfoTree content tree to which the documentation will be added
*/
public void writeClassDescription();
public void addClassDescription(Content classInfoTree);
/**
* Write the tag information for the current class.
* Add the tag information for the current class.
*
* @param classInfoTree content tree to which the tag information will be added
*/
public void writeClassTagInfo();
public void addClassTagInfo(Content classInfoTree);
/**
* Write the footer of the page.
* Get the member tree header for the class.
*
* @return a content tree for the member tree header
*/
public void writeFooter();
public Content getMemberTreeHeader();
/**
* Add the footer of the page.
*
* @param contentTree content tree to which the footer will be added
*/
public void addFooter(Content contentTree);
/**
* Print the document.
*
* @param contentTree content tree that will be printed as a document
*/
public void printDocument(Content contentTree);
/**
* Close the writer.
@ -130,8 +194,18 @@ public interface ClassWriter {
public ClassDoc getClassDoc();
/**
* Perform any operations that are necessary when the member summary
* finished building.
* Get the member summary tree.
*
* @param memberTree the content tree used to build the summary tree
* @return a content tree for the member summary
*/
public void completeMemberSummaryBuild();
public Content getMemberSummaryTree(Content memberTree);
/**
* Get the member details tree.
*
* @param memberTree the content tree used to build the details tree
* @return a content tree for the member details
*/
public Content getMemberDetailsTree(Content memberTree);
}

86
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/ConstantsSummaryWriter.java
View file

@ -25,9 +25,9 @@
package com.sun.tools.doclets.internal.toolkit;
import com.sun.javadoc.*;
import java.util.*;
import java.io.*;
import com.sun.javadoc.*;
/**
* The interface for writing constants summary output.
@ -37,38 +37,34 @@ import java.io.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
public interface ConstantsSummaryWriter {
/**
* Write the header for the summary.
*/
public abstract void writeHeader();
/**
* Write the footer for the summary.
*/
public abstract void writeFooter();
/**
* Close the writer.
*/
public abstract void close() throws IOException;
/**
* Write the header for the index.
* Get the header for the constant summary documentation.
*
* @return header that needs to be added to the documentation
*/
public abstract void writeContentsHeader();
public abstract Content getHeader();
/**
* Write the footer for the index.
* Get the header for the constant content list.
*
* @return content header that needs to be added to the documentation
*/
public abstract void writeContentsFooter();
public abstract Content getContentsHeader();
/**
* Add the given package name to the index.
* Adds the given package name link to the constant content list tree.
*
* @param pkg the {@link PackageDoc} to index.
* @param parsedPackageName the parsed package name. We only Write the
* first 2 directory levels of the package
@ -77,38 +73,70 @@ public interface ConstantsSummaryWriter {
* @param WriteedPackageHeaders the set of package headers that have already
* been indexed. We don't want to index
* something more than once.
* @param contentListTree the content tree to which the link will be added
*/
public abstract void writeLinkToPackageContent(PackageDoc pkg, String parsedPackageName,
Set<String> WriteedPackageHeaders);
public abstract void addLinkToPackageContent(PackageDoc pkg, String parsedPackageName,
Set<String> WriteedPackageHeaders, Content contentListTree);
/**
* Write the given package name.
* Get the content list to be added to the documentation tree.
*
* @param contentListTree the content that will be added to the list
* @return content list that will be added to the documentation tree
*/
public abstract Content getContentsList(Content contentListTree);
/**
* Get the constant summaries for the document.
*
* @return constant summaries header to be added to the documentation tree
*/
public abstract Content getConstantSummaries();
/**
* Adds the given package name.
*
* @param pkg the {@link PackageDoc} to index.
* @param parsedPackageName the parsed package name. We only Write the
* first 2 directory levels of the package
* name. For example, java.lang.ref would be
* indexed as java.lang.*.
* @param summariesTree the documentation tree to which the package name will
* be written
*/
public abstract void writePackageName(PackageDoc pkg,
String parsedPackageName);
public abstract void addPackageName(PackageDoc pkg,
String parsedPackageName, Content summariesTree);
/**
* Write the heading for the current table of constants for a given class.
* @param cd the class whose constants are being documented.
* Get the class summary header for the constants summary.
*
* @return the header content for the class constants summary
*/
public abstract void writeConstantMembersHeader(ClassDoc cd);
public abstract Content getClassConstantHeader();
/**
* Document the given constants.
* Adds the constant member table to the documentation tree.
*
* @param cd the class whose constants are being documented.
* @param fields the constants being documented.
* @param classConstantTree the documentation tree to which theconstant member
* table content will be added
*/
public abstract void writeConstantMembers(ClassDoc cd, List<FieldDoc> fields);
public abstract void addConstantMembers(ClassDoc cd, List<FieldDoc> fields,
Content classConstantTree);
/**
* Document the given constants.
* @param cd the class whose constants are being documented.
* Adds the footer for the summary documentation.
*
* @param contentTree content tree to which the footer will be added
*/
public abstract void writeConstantMembersFooter(ClassDoc cd);
public abstract void addFooter(Content contentTree);
/**
* Print the constants summary document.
*
* @param contentTree content tree which should be printed
*/
public abstract void printDocument(Content contentTree);
}

65
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/ConstructorWriter.java
View file

@ -36,67 +36,80 @@ import com.sun.javadoc.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
public interface ConstructorWriter {
/**
* Write the header for the constructor documentation.
* Get the constructor details tree header.
*
* @param classDoc the class that the constructors belong to.
* @param header the header to write.
* @param classDoc the class being documented
* @param memberDetailsTree the content tree representing member details
* @return content tree for the constructor details header
*/
public void writeHeader(ClassDoc classDoc, String header);
public Content getConstructorDetailsTreeHeader(ClassDoc classDoc,
Content memberDetailsTree);
/**
* Write the constructor header for the given constructor.
* Get the constructor documentation tree header.
*
* @param constructor the constructor being documented.
* @param isFirst the flag to indicate whether or not the constructor is the
* first to be documented.
* @param constructor the constructor being documented
* @param constructorDetailsTree the content tree representing constructor details
* @return content tree for the constructor documentation header
*/
public void writeConstructorHeader(ConstructorDoc constructor, boolean isFirst);
public Content getConstructorDocTreeHeader(ConstructorDoc constructor,
Content constructorDetailsTree);
/**
* Write the signature for the given constructor.
* Get the signature for the given constructor.
*
* @param constructor the constructor being documented.
* @param constructor the constructor being documented
* @return content tree for the constructor signature
*/
public void writeSignature(ConstructorDoc constructor);
public Content getSignature(ConstructorDoc constructor);
/**
* Write the deprecated output for the given constructor.
* Add the deprecated output for the given constructor.
*
* @param constructor the constructor being documented.
* @param constructor the constructor being documented
* @param constructorDocTree content tree to which the deprecated information will be added
*/
public void writeDeprecated(ConstructorDoc constructor);
public void addDeprecated(ConstructorDoc constructor, Content constructorDocTree);
/**
* Write the comments for the given constructor.
* Add the comments for the given constructor.
*
* @param constructor the constructor being documented.
* @param constructor the constructor being documented
* @param constructorDocTree the content tree to which the comments will be added
*/
public void writeComments(ConstructorDoc constructor);
public void addComments(ConstructorDoc constructor, Content constructorDocTree);
/**
* Write the tag output for the given constructor.
* Add the tags for the given constructor.
*
* @param constructor the constructor being documented.
* @param constructor the constructor being documented
* @param constructorDocTree the content tree to which the tags will be added
*/
public void writeTags(ConstructorDoc constructor);
public void addTags(ConstructorDoc constructor, Content constructorDocTree);
/**
* Write the constructor footer.
* Get the constructor details tree.
*
* @param memberDetailsTree the content tree representing member details
* @return content tree for the constructor details
*/
public void writeConstructorFooter();
public Content getConstructorDetails(Content memberDetailsTree);
/**
* Write the footer for the constructor documentation.
* Get the constructor documentation.
*
* @param classDoc the class that the constructors belong to.
* @param constructorDocTree the content tree representing constructor documentation
* @param isLastContent true if the content to be added is the last content
* @return content tree for the constructor documentation
*/
public void writeFooter(ClassDoc classDoc);
public Content getConstructorDoc(Content constructorDocTree, boolean isLastContent);
/**
* Let the writer know whether a non public constructor was found.

106
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/Content.java Normal file
View file

@ -0,0 +1,106 @@
/*
* Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.tools.doclets.internal.toolkit;
import com.sun.tools.doclets.internal.toolkit.util.*;
/**
* A class to create content for javadoc output pages.
*
* @author Bhavesh Patel
*/
public abstract class Content {
/**
* Returns a string representation of the content.
*
* @return string representation of the content
*/
public String toString() {
StringBuilder contentBuilder = new StringBuilder();
write(contentBuilder);
return contentBuilder.toString();
}
/**
* Adds content to the existing content.
*
* @param content content that needs to be added
*/
public abstract void addContent(Content content);
/**
* Adds a string content to the existing content.
*
* @param stringContent the string content to be added
*/
public abstract void addContent(String stringContent);
/**
* Writes content to a StringBuilder.
*
*/
public abstract void write(StringBuilder contentBuilder);
/**
* Returns true if the content is empty.
*
* @return true if no content to be displayed else return false
*/
public abstract boolean isEmpty();
/**
* Returns true if the content is valid.
*
* @return true if the content is valid else return false
*/
public boolean isValid() {
return !isEmpty();
}
/**
* Checks for null values.
*
* @param t reference type to check for null values
* @return the reference type if not null or else throws a null pointer exception
*/
protected static <T> T nullCheck(T t) {
t.getClass();
return t;
}
/**
* Returns true if the content ends with a newline character. Empty content
* is considered as ending with new line.
*
* @param contentBuilder content to test for newline character at the end
* @return true if the content ends with newline.
*/
public boolean endsWithNewLine(StringBuilder contentBuilder) {
return ((contentBuilder.length() == 0) ||
(contentBuilder.substring(contentBuilder.length() - 1).equals("\n")));
}
}

65
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/EnumConstantWriter.java
View file

@ -36,67 +36,80 @@ import com.sun.javadoc.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
public interface EnumConstantWriter {
/**
* Write the header for the enum constant documentation.
* Get the enum constants details tree header.
*
* @param classDoc the class that the enum constants belong to.
* @param header the header to write.
* @param classDoc the class being documented
* @param memberDetailsTree the content tree representing member details
* @return content tree for the enum constants details header
*/
public void writeHeader(ClassDoc classDoc, String header);
public Content getEnumConstantsDetailsTreeHeader(ClassDoc classDoc,
Content memberDetailsTree);
/**
* Write the enum constant header for the given enum constant.
* Get the enum constants documentation tree header.
*
* @param enumConstant the enum constant being documented.
* @param isFirst the flag to indicate whether or not the enum constant is
* the first to be documented.
* @param enumConstant the enum constant being documented
* @param enumConstantDetailsTree the content tree representing enum constant details
* @return content tree for the enum constant documentation header
*/
public void writeEnumConstantHeader(FieldDoc enumConstant, boolean isFirst);
public Content getEnumConstantsTreeHeader(FieldDoc enumConstant,
Content enumConstantsDetailsTree);
/**
* Write the signature for the given enum constant.
* Get the signature for the given enum constant.
*
* @param enumConstant the enum constant being documented.
* @param enumConstant the enum constant being documented
* @return content tree for the enum constant signature
*/
public void writeSignature(FieldDoc enumConstant);
public Content getSignature(FieldDoc enumConstant);
/**
* Write the deprecated output for the given enum constant.
* Add the deprecated output for the given enum constant.
*
* @param enumConstant the enum constant being documented.
* @param enumConstant the enum constant being documented
* @param enumConstantsTree content tree to which the deprecated information will be added
*/
public void writeDeprecated(FieldDoc enumConstant);
public void addDeprecated(FieldDoc enumConstant, Content enumConstantsTree);
/**
* Write the comments for the given enum constant.
* Add the comments for the given enum constant.
*
* @param enumConstant the enum constant being documented.
* @param enumConstant the enum constant being documented
* @param enumConstantsTree the content tree to which the comments will be added
*/
public void writeComments(FieldDoc enumConstant);
public void addComments(FieldDoc enumConstant, Content enumConstantsTree);
/**
* Write the tag output for the given enum constant.
* Add the tags for the given enum constant.
*
* @param enumConstant the enum constant being documented.
* @param enumConstant the enum constant being documented
* @param enumConstantsTree the content tree to which the tags will be added
*/
public void writeTags(FieldDoc enumConstant);
public void addTags(FieldDoc enumConstant, Content enumConstantsTree);
/**
* Write the enum constant footer.
* Get the enum constants details tree.
*
* @param memberDetailsTree the content tree representing member details
* @return content tree for the enum constant details
*/
public void writeEnumConstantFooter();
public Content getEnumConstantsDetails(Content memberDetailsTree);
/**
* Write the footer for the enum constant documentation.
* Get the enum constants documentation.
*
* @param classDoc the class that the enum constant belong to.
* @param enumConstantsTree the content tree representing enum constants documentation
* @param isLastContent true if the content to be added is the last content
* @return content tree for the enum constants documentation
*/
public void writeFooter(ClassDoc classDoc);
public Content getEnumConstants(Content enumConstantsTree, boolean isLastContent);
/**
* Close the writer.

65
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/FieldWriter.java
View file

@ -36,67 +36,80 @@ import com.sun.javadoc.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
public interface FieldWriter {
/**
* Write the header for the field documentation.
* Get the field details tree header.
*
* @param classDoc the class that the fields belong to.
* @param header the header to write.
* @param classDoc the class being documented
* @param memberDetailsTree the content tree representing member details
* @return content tree for the field details header
*/
public void writeHeader(ClassDoc classDoc, String header);
public Content getFieldDetailsTreeHeader(ClassDoc classDoc,
Content memberDetailsTree);
/**
* Write the field header for the given field.
* Get the field documentation tree header.
*
* @param field the field being documented.
* @param isFirst the flag to indicate whether or not the field is the
* first to be documented.
* @param field the constructor being documented
* @param fieldDetailsTree the content tree representing field details
* @return content tree for the field documentation header
*/
public void writeFieldHeader(FieldDoc field, boolean isFirst);
public Content getFieldDocTreeHeader(FieldDoc field,
Content fieldDetailsTree);
/**
* Write the signature for the given field.
* Get the signature for the given field.
*
* @param field the field being documented.
* @param field the field being documented
* @return content tree for the field signature
*/
public void writeSignature(FieldDoc field);
public Content getSignature(FieldDoc field);
/**
* Write the deprecated output for the given field.
* Add the deprecated output for the given field.
*
* @param field the field being documented.
* @param field the field being documented
* @param fieldDocTree content tree to which the deprecated information will be added
*/
public void writeDeprecated(FieldDoc field);
public void addDeprecated(FieldDoc field, Content fieldDocTree);
/**
* Write the comments for the given field.
* Add the comments for the given field.
*
* @param field the field being documented.
* @param field the field being documented
* @param fieldDocTree the content tree to which the comments will be added
*/
public void writeComments(FieldDoc field);
public void addComments(FieldDoc field, Content fieldDocTree);
/**
* Write the tag output for the given field.
* Add the tags for the given field.
*
* @param field the field being documented.
* @param field the field being documented
* @param fieldDocTree the content tree to which the tags will be added
*/
public void writeTags(FieldDoc field);
public void addTags(FieldDoc field, Content fieldDocTree);
/**
* Write the field footer.
* Get the field details tree.
*
* @param memberDetailsTree the content tree representing member details
* @return content tree for the field details
*/
public void writeFieldFooter();
public Content getFieldDetails(Content memberDetailsTree);
/**
* Write the footer for the field documentation.
* Get the field documentation.
*
* @param classDoc the class that the fields belong to.
* @param fieldDocTree the content tree representing field documentation
* @param isLastContent true if the content to be added is the last content
* @return content tree for the field documentation
*/
public void writeFooter(ClassDoc classDoc);
public Content getFieldDoc(Content fieldDocTree, boolean isLastContent);
/**
* Close the writer.

71
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/MemberSummaryWriter.java
View file

@ -26,6 +26,7 @@
package com.sun.tools.doclets.internal.toolkit;
import java.io.*;
import java.util.*;
import com.sun.javadoc.*;
/**
@ -36,61 +37,77 @@ import com.sun.javadoc.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
public interface MemberSummaryWriter {
/**
* Write the member summary header for the given class.
* Get the member summary header for the given class.
*
* @param classDoc the class the summary belongs to.
* @param classDoc the class the summary belongs to
* @param memberSummaryTree the content tree to which the member summary will be added
* @return a content tree for the member summary header
*/
public void writeMemberSummaryHeader(ClassDoc classDoc);
public Content getMemberSummaryHeader(ClassDoc classDoc,
Content memberSummaryTree);
/**
* Write the member summary for the given class and member.
* Get the summary table for the given class.
*
* @param classDoc the class the summary belongs to.
* @param member the member that I am summarizing.
* @param firstSentenceTags the tags for the sentence being documented.
* @param isFirst true if this is the first member in the list.
* @param isLast true if this the last member being documented.
* @param classDoc the class the summary table belongs to
* @return a content tree for the member summary table
*/
public void writeMemberSummary(ClassDoc classDoc, ProgramElementDoc member,
Tag[] firstSentenceTags, boolean isFirst, boolean isLast);
public Content getSummaryTableTree(ClassDoc classDoc);
/**
* Write the member summary footer for the given class.
* Add the member summary for the given class and member.
*
* @param classDoc the class the summary belongs to.
* @param classDoc the class the summary belongs to
* @param member the member that is documented
* @param firstSentenceTags the tags for the sentence being documented
* @param tableTree the content treeto which the information will be added
* @param counter the counter for determing style for the table row
*/
public void writeMemberSummaryFooter(ClassDoc classDoc);
public void addMemberSummary(ClassDoc classDoc, ProgramElementDoc member,
Tag[] firstSentenceTags, Content tableTree, int counter);
/**
* Write the inherited member summary header for the given class.
* Get the inherited member summary header for the given class.
*
* @param classDoc the class the summary belongs to.
* @param classDoc the class the summary belongs to
* @return a content tree containing the inherited summary header
*/
public void writeInheritedMemberSummaryHeader(ClassDoc classDoc);
public Content getInheritedSummaryHeader(ClassDoc classDoc);
/**
* Write the inherited member summary for the given class and member.
* Add the inherited member summary for the given class and member.
*
* @param classDoc the class the inherited member belongs to.
* @param member the inherited member that I am summarizing.
* @param isFirst true if this is the first member in the list.
* @param isLast true if this is the last member in the list.
* @param classDoc the class the inherited member belongs to
* @param member the inherited member that is being documented
* @param isFirst true if this is the first member in the list
* @param isLast true if this is the last member in the list
* @param linksTree the content tree to which the links will be added
*/
public void writeInheritedMemberSummary(ClassDoc classDoc,
ProgramElementDoc member, boolean isFirst, boolean isLast);
public void addInheritedMemberSummary(ClassDoc classDoc,
ProgramElementDoc member, boolean isFirst, boolean isLast,
Content linksTree);
/**
* Write the inherited member summary footer for the given class.
* Get inherited summary links.
*
* @param classDoc the class the summary belongs to.
* @return a content tree conatining the inherited summary links
*/
public void writeInheritedMemberSummaryFooter(ClassDoc classDoc);
public Content getInheritedSummaryLinksTree();
/**
* Get the member tree.
*
* @param memberTree the content tree representating the member
* @return a content tree for the member
*/
public Content getMemberTree(Content memberTree);
/**
* Close the writer.

67
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/MethodWriter.java
View file

@ -36,68 +36,81 @@ import com.sun.javadoc.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
public interface MethodWriter {
/**
* Write the header for the method documentation.
* Get the method details tree header.
*
* @param classDoc the class that the methods belong to.
* @param header the header to write.
* @param classDoc the class being documented
* @param memberDetailsTree the content tree representing member details
* @return content tree for the method details header
*/
public void writeHeader(ClassDoc classDoc, String header);
public Content getMethodDetailsTreeHeader(ClassDoc classDoc,
Content memberDetailsTree);
/**
* Write the method header for the given method.
* Get the method documentation tree header.
*
* @param method the method being documented.
* @param isFirst the flag to indicate whether or not the method is the
* first to be documented.
* @param method the method being documented
* @param methodDetailsTree the content tree representing method details
* @return content tree for the method documentation header
*/
public void writeMethodHeader(MethodDoc method, boolean isFirst);
public Content getMethodDocTreeHeader(MethodDoc method,
Content methodDetailsTree);
/**
* Write the signature for the given method.
* Get the signature for the given method.
*
* @param method the method being documented.
* @param method the method being documented
* @return content tree for the method signature
*/
public void writeSignature(MethodDoc method);
public Content getSignature(MethodDoc method);
/**
* Write the deprecated output for the given method.
* Add the deprecated output for the given method.
*
* @param method the method being documented.
* @param method the method being documented
* @param methodDocTree content tree to which the deprecated information will be added
*/
public void writeDeprecated(MethodDoc method);
public void addDeprecated(MethodDoc method, Content methodDocTree);
/**
* Write the comments for the given method.
* Add the comments for the given method.
*
* @param holder the holder type (not erasure) of the method.
* @param method the method being documented.
* @param holder the holder type (not erasure) of the method
* @param method the method being documented
* @param methodDocTree the content tree to which the comments will be added
*/
public void writeComments(Type holder, MethodDoc method);
public void addComments(Type holder, MethodDoc method, Content methodDocTree);
/**
* Write the tag output for the given method.
* Add the tags for the given method.
*
* @param method the method being documented.
* @param method the method being documented
* @param methodDocTree the content tree to which the tags will be added
*/
public void writeTags(MethodDoc method);
public void addTags(MethodDoc method, Content methodDocTree);
/**
* Write the method footer.
* Get the method details tree.
*
* @param methodDetailsTree the content tree representing method details
* @return content tree for the method details
*/
public void writeMethodFooter();
public Content getMethodDetails(Content methodDetailsTree);
/**
* Write the footer for the method documentation.
* Get the method documentation.
*
* @param classDoc the class that the methods belong to.
* @param methodDocTree the content tree representing method documentation
* @param isLastContent true if the content to be added is the last content
* @return content tree for the method documentation
*/
public void writeFooter(ClassDoc classDoc);
public Content getMethodDoc(Content methodDocTree, boolean isLastContent);
/**
* Close the writer.

49
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/NestedClassWriter.java
View file

@ -26,7 +26,6 @@
package com.sun.tools.doclets.internal.toolkit;
import java.io.*;
import com.sun.javadoc.*;
/**
* The interface for writing class output.
@ -36,58 +35,12 @@ import com.sun.javadoc.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
public interface NestedClassWriter {
/**
* Write the classes summary header for the given class.
*
* @param nestedClass the class the summary belongs to.
*/
public void writeNestedClassSummaryHeader(ClassDoc nestedClass);
/**
* Write the class summary for the given class and class.
*
* @param classDoc the class the summary belongs to.
* @param nestedClass the nested class that I am summarizing.
*/
public void writeNestedClassSummary(ClassDoc classDoc, ClassDoc nestedClass);
/**
* Write the classes summary footer for the given class.
*
* @param nestedClass the class the summary belongs to.
*/
public void writeNestedClassSummaryFooter(ClassDoc nestedClass);
/**
* Write the inherited classes summary header for the given class.
*
* @param nestedClass the class the summary belongs to.
*/
public void writeInheritedNestedClassSummaryHeader(ClassDoc nestedClass);
/**
* Write the inherited nested class summary for the given class and nested
* class.
*
* @param classDoc the class the inherited nested class belongs to.
* @param nestedClass the inherited nested class that I am summarizing.
* @param isFirst true if this is the first member in the list.
*/
public void writeInheritedNestedClassSummary(ClassDoc classDoc,
ClassDoc nestedClass, boolean isFirst);
/**
* Write the inherited classes summary footer for the given class.
*
* @param nestedClass the class the summary belongs to.
*/
public void writeInheritedNestedClassSummaryFooter(ClassDoc nestedClass);
/**
* Close the writer.
*/

68
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/PackageSummaryWriter.java
View file

@ -36,6 +36,7 @@ import java.io.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
@ -49,45 +50,70 @@ public interface PackageSummaryWriter {
public abstract String getOutputFileName();
/**
* Write the header for the package summary.
* Get the header for the summary.
*
* @param heading Package name.
* @return the header to be added to the content tree
*/
public abstract void writeSummaryHeader();
public abstract Content getPackageHeader(String heading);
/**
* Write the footer for the package summary.
* Get the header for the package content.
*
* @return a content tree for the package content header
*/
public abstract void writeSummaryFooter();
public abstract Content getContentHeader();
/**
* Write the table of classes in this package.
* Get the header for the package summary.
*
* @return a content tree with the package summary header
*/
public abstract Content getSummaryHeader();
/**
* Adds the table of classes to the documentation tree.
*
* @param classes the array of classes to document.
* @param label the label for this table.
* @param tableSummary the summary string for the table
* @param tableHeader array of table headers
* @param summaryContentTree the content tree to which the summaries will be added
*/
public abstract void writeClassesSummary(ClassDoc[] classes, String label, String tableSummary, String[] tableHeader);
public abstract void addClassesSummary(ClassDoc[] classes, String label,
String tableSummary, String[] tableHeader, Content summaryContentTree);
/**
* Write the header for the summary.
* Adds the package description from the "packages.html" file to the documentation
* tree.
*
* @param heading Package name.
* @param packageContentTree the content tree to which the package description
* will be added
*/
public abstract void writePackageHeader(String heading);
public abstract void addPackageDescription(Content packageContentTree);
/**
* Print the package description from the "packages.html" file.
*/
public abstract void writePackageDescription();
/**
* Print the tag information from the "packages.html" file.
*/
public abstract void writePackageTags();
/**
* Write the footer for the summary.
* Adds the tag information from the "packages.html" file to the documentation
* tree.
*
* @param packageContentTree the content tree to which the package tags will
* be added
*/
public abstract void writePackageFooter();
public abstract void addPackageTags(Content packageContentTree);
/**
* Adds the footer to the documentation tree.
*
* @param contentTree the tree to which the footer will be added
*/
public abstract void addPackageFooter(Content contentTree);
/**
* Print the package summary document.
*
* @param contentTree the content tree that will be printed
*/
public abstract void printDocument(Content contentTree);
/**
* Close the writer.

203
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/SerializedFormWriter.java
View file

@ -43,33 +43,73 @@ import com.sun.javadoc.*;
public interface SerializedFormWriter {
/**
* Write the given header.
* Get the header.
*
* @param header the header to write.
* @return the header content tree
*/
public void writeHeader(String header);
public Content getHeader(String header);
/**
* Write the given package header.
* Get the serialized form summaries header.
*
* @param packageName the package header to write.
* @return the serialized form summary header tree
*/
public void writePackageHeader(String packageName);
public Content getSerializedSummariesHeader();
/**
* Write the heading for the serializable class.
* Get the package serialized form header.
*
* @param classDoc the class being processed.
* @return the package serialized form header tree
*/
public void writeClassHeader(ClassDoc classDoc);
public Content getPackageSerializedHeader();
/**
* Write the serial UID info.
* Get the given package header.
*
* @param packageName the package header to write
* @return a content tree for the package header
*/
public Content getPackageHeader(String packageName);
/**
* Get the serialized class header.
*
* @return a content tree for the serialized class header
*/
public Content getClassSerializedHeader();
/**
* Get the heading for the serializable class.
*
* @param classDoc the class being processed
* @return a content tree for the class heading
*/
public Content getClassHeader(ClassDoc classDoc);
/**
* Get the serial UID info header.
*
* @return a content tree for the serial uid info header
*/
public Content getSerialUIDInfoHeader();
/**
* Adds the serial UID info.
*
* @param header the header that will show up before the UID.
* @param serialUID the serial UID to print.
* @param serialUidTree the serial UID tree to which the content will be added.
*/
public void writeSerialUIDInfo(String header, String serialUID);
public void addSerialUIDInfo(String header, String serialUID,
Content serialUidTree);
/**
* Get the class serialize content header.
*
* @return a content tree for the class serialize content header
*/
public Content getClassContentHeader();
/**
* Return an instance of a SerialFieldWriter.
@ -91,9 +131,26 @@ public interface SerializedFormWriter {
public abstract void close() throws IOException;
/**
* Write the footer.
* Get the serialized content.
*
* @param serializedTreeContent content for serialized data
* @return a content tree for serialized information
*/
public void writeFooter();
public Content getSerializedContent(Content serializedTreeContent);
/**
* Add the footer.
*
* @param serializedTree the serialized tree to be added
*/
public void addFooter(Content serializedTree);
/**
* Print the serialized form document.
*
* @param serializedTree the content tree that will be printed
*/
public abstract void printDocument(Content serializedTree);
/**
* Write the serialized form for a given field.
@ -101,56 +158,73 @@ public interface SerializedFormWriter {
public interface SerialFieldWriter {
/**
* Write the given heading.
* Get the serializable field header.
*
* @return serialized fields header content tree
*/
public Content getSerializableFieldsHeader();
/**
* Get the field content header.
*
* @param isLastContent true if this is the last content to be documented
* @return fields header content tree
*/
public Content getFieldsContentHeader(boolean isLastContent);
/**
* Get the fields content.
*
* @param heading the heading to write.
* @param contentTree content tree to which the heading will be added
* @return serializable fields content tree
*/
public void writeHeader(String heading);
public Content getSerializableFields(String heading, Content contentTree);
/**
* Write the deprecated information for this member.
* Adds the deprecated information for this member.
*
* @param field the field to document.
* @param contentTree content tree to which the deprecated information will be added
*/
public void writeMemberDeprecatedInfo(FieldDoc field);
public void addMemberDeprecatedInfo(FieldDoc field, Content contentTree);
/**
* Write the description text for this member.
* Adds the description text for this member.
*
* @param field the field to document.
* @param contentTree content tree to which the member description will be added
*/
public void writeMemberDescription(FieldDoc field);
public void addMemberDescription(FieldDoc field, Content contentTree);
/**
* Write the description text for this member represented by the tag.
* Adds the description text for this member represented by the tag.
*
* @param serialFieldTag the field to document (represented by tag).
* @param contentTree content tree to which the member description will be added
*/
public void writeMemberDescription(SerialFieldTag serialFieldTag);
public void addMemberDescription(SerialFieldTag serialFieldTag, Content contentTree);
/**
* Write the tag information for this member.
* Adds the tag information for this member.
*
* @param field the field to document.
* @param contentTree content tree to which the member tags will be added
*/
public void writeMemberTags(FieldDoc field);
public void addMemberTags(FieldDoc field, Content contentTree);
/**
* Write the member header.
* Adds the member header.
*
* @param fieldType the type of the field.
* @param fieldTypeStr the type of the field in string format. We will
* print this out if we can't link to the type.
* @param fieldDimensions the dimensions of the field.
* @param fieldName the name of the field.
* @param contentTree content tree to which the member header will be added
*/
public void writeMemberHeader(ClassDoc fieldType, String fieldTypeStr,
String fieldDimensions, String fieldName);
/**
* Write the member footer.
*/
public void writeMemberFooter();
public void addMemberHeader(ClassDoc fieldType, String fieldTypeStr,
String fieldDimensions, String fieldName, Content contentTree);
/**
* Check to see if overview details should be printed. If
@ -162,13 +236,6 @@ public interface SerializedFormWriter {
* @return true if overview details need to be printed
*/
public boolean shouldPrintOverview(FieldDoc field);
/**
* Write the footer.
*
* @param heading the heading that was written.
*/
public void writeFooter (String heading);
}
/**
@ -176,45 +243,71 @@ public interface SerializedFormWriter {
*/
public interface SerialMethodWriter {
/**
* Get the serializable method header.
*
* @return serializable methods content tree
*/
public Content getSerializableMethodsHeader();
/**
* Get the method content header.
*
* @param isLastContent true if this is the last content to be documented
* @return methods content tree
*/
public Content getMethodsContentHeader(boolean isLastContent);
/**
* Write the given heading.
*
* @param heading the heading to write.
* @param heading the heading to write
* @param serializableMethodTree content tree which will be added
* @return serializable methods content tree
*/
public void writeHeader(String heading);
public Content getSerializableMethods(String heading, Content serializableMethodTree);
/**
* Write a warning that no serializable methods exist.
*
* @param msg the warning to print.
* @param msg the warning to print
* @return no customization message tree
*/
public void writeNoCustomizationMsg(String msg);
public Content getNoCustomizationMsg(String msg);
/**
* Write the header.
* Adds the header.
*
* @param member the member to write the header for.
* @param member the member to write the header for
* @param methodsContentTree content tree to which the header will be added
*/
public void writeMemberHeader(MethodDoc member);
public void addMemberHeader(MethodDoc member, Content methodsContentTree);
/**
* Write the footer.
* Adds the deprecated information for this member.
*
* @param member the member to write the deprecated information for
* @param methodsContentTree content tree to which the deprecated
* information will be added
*/
public void writeMemberFooter();
public void addDeprecatedMemberInfo(MethodDoc member, Content methodsContentTree);
/**
* Write the deprecated information for this member.
* Adds the description for this member.
*
* @param member the member to write the information for
* @param methodsContentTree content tree to which the member
* information will be added
*/
public void writeDeprecatedMemberInfo(MethodDoc member);
public void addMemberDescription(MethodDoc member, Content methodsContentTree);
/**
* Write the description for this member.
* Adds the tag information for this member.
*
* @param member the member to write the tags information for
* @param methodsContentTree content tree to which the tags
* information will be added
*/
public void writeMemberDescription(MethodDoc member);
/**
* Write the tag information for this member.
*/
public void writeMemberTags(MethodDoc member);
public void addMemberTags(MethodDoc member, Content methodsContentTree);
}
}

15
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/AbstractBuilder.java
View file

@ -95,13 +95,14 @@ public abstract class AbstractBuilder {
* Build the documentation, as specified by the given XML element.
*
* @param node the XML element that specifies which component to document.
* @param contentTree content tree to which the documentation will be added
*/
protected void build(XMLNode node) {
protected void build(XMLNode node, Content contentTree) {
String component = node.name;
try {
invokeMethod("build" + component,
new Class<?>[] { XMLNode.class },
new Object[] { node });
new Class<?>[]{XMLNode.class, Content.class},
new Object[]{node, contentTree});
} catch (NoSuchMethodException e) {
e.printStackTrace();
configuration.root.printError("Unknown element: " + component);
@ -121,10 +122,11 @@ public abstract class AbstractBuilder {
* Build the documentation, as specified by the children of the given XML element.
*
* @param node the XML element that specifies which components to document.
* @param contentTree content tree to which the documentation will be added
*/
protected void buildChildren(XMLNode node) {
protected void buildChildren(XMLNode node, Content contentTree) {
for (XMLNode child : node.children)
build(child);
build(child, contentTree);
}
/**
@ -140,8 +142,7 @@ public abstract class AbstractBuilder {
Object[] params)
throws Exception {
if (DEBUG) {
configuration.root.printError("DEBUG: " + this.getClass().getName()
+ "." + methodName);
configuration.root.printError("DEBUG: " + this.getClass().getName() + "." + methodName);
}
Method method = this.getClass().getMethod(methodName, paramClasses);
method.invoke(this, params);

8
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/AbstractMemberBuilder.java
View file

@ -27,6 +27,7 @@ package com.sun.tools.doclets.internal.toolkit.builders;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import java.util.*;
/**
* The superclass for all member builders. Member builders are only executed
@ -66,12 +67,13 @@ public abstract class AbstractMemberBuilder extends AbstractBuilder {
/**
* Build the sub component if there is anything to document.
*
* @param elements {@inheritDoc}
* @param node the XML element that specifies which components to document.
* @param contentTree content tree to which the documentation will be added
*/
@Override
public void build(XMLNode node) {
public void build(XMLNode node, Content contentTree) {
if (hasMembersToDocument()) {
super.build(node);
super.build(node, contentTree);
}
}

148
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/AnnotationTypeBuilder.java
View file

@ -25,11 +25,11 @@
package com.sun.tools.doclets.internal.toolkit.builders;
import java.io.*;
import java.util.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.javadoc.*;
import java.io.*;
import java.util.*;
/**
* Builds the summary for a given annotation type.
@ -39,6 +39,7 @@ import java.util.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
public class AnnotationTypeBuilder extends AbstractBuilder {
@ -58,6 +59,11 @@ public class AnnotationTypeBuilder extends AbstractBuilder {
*/
private AnnotationTypeWriter writer;
/**
* The content tree for the annotation documentation.
*/
private Content contentTree;
/**
* Construct a new ClassBuilder.
*
@ -92,7 +98,7 @@ public class AnnotationTypeBuilder extends AbstractBuilder {
* {@inheritDoc}
*/
public void build() throws IOException {
build(LayoutParser.getInstance(configuration).parseXML(ROOT));
build(LayoutParser.getInstance(configuration).parseXML(ROOT), contentTree);
}
/**
@ -103,17 +109,23 @@ public class AnnotationTypeBuilder extends AbstractBuilder {
}
/**
* Handles the &lt;AnnotationTypeDoc> tag.
* Build the annotation type documentation.
*
* @param elements the XML elements that specify how to document a class.
* @param node the XML element that specifies which components to document
* @param contentTree the content tree to which the documentation will be added
*/
public void buildAnnotationTypeDoc(XMLNode node) throws Exception {
buildChildren(node);
public void buildAnnotationTypeDoc(XMLNode node, Content contentTree) throws Exception {
contentTree = writer.getHeader(configuration.getText("doclet.AnnotationType") +
" " + annotationTypeDoc.name());
Content annotationContentTree = writer.getAnnotationContentHeader();
buildChildren(node, annotationContentTree);
contentTree.addContent(annotationContentTree);
writer.addFooter(contentTree);
writer.printDocument(contentTree);
writer.close();
copyDocFiles();
}
/**
* Copy the doc files for the current ClassDoc if necessary.
*/
@ -137,86 +149,112 @@ public class AnnotationTypeBuilder extends AbstractBuilder {
}
/**
* Build the header of the page.
* Build the annotation information tree documentation.
*
* @param node the XML element that specifies which components to document
* @param annotationContentTree the content tree to which the documentation will be added
*/
public void buildAnnotationTypeHeader(XMLNode node) {
writer.writeHeader(configuration.getText("doclet.AnnotationType") +
" " + annotationTypeDoc.name());
public void buildAnnotationTypeInfo(XMLNode node, Content annotationContentTree) {
Content annotationInfoTree = writer.getAnnotationInfoTreeHeader();
buildChildren(node, annotationInfoTree);
annotationContentTree.addContent(writer.getAnnotationInfo(annotationInfoTree));
}
/**
* If this class is deprecated, print the appropriate information.
* If this annotation is deprecated, build the appropriate information.
*
* @param node the XML element that specifies which components to document
* @param annotationInfoTree the content tree to which the documentation will be added
*/
public void buildDeprecationInfo (XMLNode node) {
writer.writeAnnotationTypeDeprecationInfo();
public void buildDeprecationInfo (XMLNode node, Content annotationInfoTree) {
writer.addAnnotationTypeDeprecationInfo(annotationInfoTree);
}
/**
* Build the signature of the current annotation type.
*
* @param node the XML element that specifies which components to document
* @param annotationInfoTree the content tree to which the documentation will be added
*/
public void buildAnnotationTypeSignature(XMLNode node) {
public void buildAnnotationTypeSignature(XMLNode node, Content annotationInfoTree) {
StringBuffer modifiers = new StringBuffer(
annotationTypeDoc.modifiers() + " ");
writer.writeAnnotationTypeSignature(
Util.replaceText(
modifiers.toString(), "interface", "@interface"));
writer.addAnnotationTypeSignature(Util.replaceText(
modifiers.toString(), "interface", "@interface"), annotationInfoTree);
}
/**
* Build the class description.
*/
public void buildAnnotationTypeDescription(XMLNode node) {
writer.writeAnnotationTypeDescription();
}
/**
* Build the tag information for the current class.
*/
public void buildAnnotationTypeTagInfo(XMLNode node) {
writer.writeAnnotationTypeTagInfo();
}
/**
* Build the contents of the page.
* Build the annotation type description.
*
* @param elements the XML elements that specify how a member summary is
* documented.
* @param node the XML element that specifies which components to document
* @param annotationInfoTree the content tree to which the documentation will be added
*/
public void buildMemberSummary(XMLNode node) throws Exception {
public void buildAnnotationTypeDescription(XMLNode node, Content annotationInfoTree) {
writer.addAnnotationTypeDescription(annotationInfoTree);
}
/**
* Build the tag information for the current annotation type.
*
* @param node the XML element that specifies which components to document
* @param annotationInfoTree the content tree to which the documentation will be added
*/
public void buildAnnotationTypeTagInfo(XMLNode node, Content annotationInfoTree) {
writer.addAnnotationTypeTagInfo(annotationInfoTree);
}
/**
* Build the member summary contents of the page.
*
* @param node the XML element that specifies which components to document
* @param annotationContentTree the content tree to which the documentation will be added
*/
public void buildMemberSummary(XMLNode node, Content annotationContentTree)
throws Exception {
Content memberSummaryTree = writer.getMemberTreeHeader();
configuration.getBuilderFactory().
getMemberSummaryBuilder(writer).buildChildren(node);
writer.completeMemberSummaryBuild();
getMemberSummaryBuilder(writer).buildChildren(node, memberSummaryTree);
annotationContentTree.addContent(writer.getMemberSummaryTree(memberSummaryTree));
}
/**
* Build the member details contents of the page.
*
* @param node the XML element that specifies which components to document
* @param annotationContentTree the content tree to which the documentation will be added
*/
public void buildAnnotationTypeMemberDetails(XMLNode node, Content annotationContentTree) {
Content memberDetailsTree = writer.getMemberTreeHeader();
buildChildren(node, memberDetailsTree);
if (memberDetailsTree.isValid()) {
Content memberDetails = writer.getMemberTreeHeader();
writer.addAnnotationDetailsMarker(memberDetails);
memberDetails.addContent(writer.getMemberTree(memberDetailsTree));
annotationContentTree.addContent(writer.getMemberDetailsTree(memberDetails));
}
}
/**
* Build the annotation type optional member documentation.
*
* @param elements the XML elements that specify how a annotation type
* members are documented.
* @param node the XML element that specifies which components to document
* @param memberDetailsTree the content tree to which the documentation will be added
*/
public void buildAnnotationTypeOptionalMemberDetails(XMLNode node)
public void buildAnnotationTypeOptionalMemberDetails(XMLNode node, Content memberDetailsTree)
throws Exception {
configuration.getBuilderFactory().
getAnnotationTypeOptionalMemberBuilder(writer).buildChildren(node);
getAnnotationTypeOptionalMemberBuilder(writer).buildChildren(node, memberDetailsTree);
}
/**
* Build the annotation type required member documentation.
*
* @param elements the XML elements that specify how a annotation type
* members are documented.
* @param node the XML element that specifies which components to document
* @param memberDetailsTree the content tree to which the documentation will be added
*/
public void buildAnnotationTypeRequiredMemberDetails(XMLNode node)
public void buildAnnotationTypeRequiredMemberDetails(XMLNode node, Content memberDetailsTree)
throws Exception {
configuration.getBuilderFactory().
getAnnotationTypeRequiredMemberBuilder(writer).buildChildren(node);
}
/**
* Build the footer of the page.
*/
public void buildAnnotationTypeFooter(XMLNode node) {
writer.writeFooter();
getAnnotationTypeRequiredMemberBuilder(writer).buildChildren(node, memberDetailsTree);
}
}

32
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/AnnotationTypeOptionalMemberBuilder.java
View file

@ -25,11 +25,10 @@
package com.sun.tools.doclets.internal.toolkit.builders;
import java.util.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.javadoc.*;
import java.util.*;
/**
* Builds documentation for optional annotation type members.
@ -39,6 +38,7 @@ import java.util.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
public class AnnotationTypeOptionalMemberBuilder extends
@ -90,27 +90,25 @@ public class AnnotationTypeOptionalMemberBuilder extends
}
/**
* Build the member documentation.
* Build the annotation type optional member documentation.
*
* @param elements the XML elements that specify how to construct this
* documentation.
* @param node the XML element that specifies which components to document
* @param memberDetailsTree the content tree to which the documentation will be added
*/
public void buildAnnotationTypeOptionalMember(XMLNode node) {
if (writer == null) {
return;
}
for (currentMemberIndex = 0; currentMemberIndex < members.size();
currentMemberIndex++) {
buildChildren(node);
}
public void buildAnnotationTypeOptionalMember(XMLNode node, Content memberDetailsTree) {
buildAnnotationTypeMember(node, memberDetailsTree);
}
/**
* Document the default value for this optional member.
* Build the default value for this optional member.
*
* @param node the XML element that specifies which components to document
* @param annotationDocTree the content tree to which the documentation will be added
*/
public void buildDefaultValueInfo(XMLNode node) {
((AnnotationTypeOptionalMemberWriter) writer).writeDefaultValueInfo(
(MemberDoc) members.get(currentMemberIndex));
public void buildDefaultValueInfo(XMLNode node, Content annotationDocTree) {
((AnnotationTypeOptionalMemberWriter) writer).addDefaultValueInfo(
(MemberDoc) members.get(currentMemberIndex),
annotationDocTree);
}
/**

95
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/AnnotationTypeRequiredMemberBuilder.java
View file

@ -25,11 +25,10 @@
package com.sun.tools.doclets.internal.toolkit.builders;
import java.util.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.javadoc.*;
import java.util.*;
/**
* Builds documentation for required annotation type members.
@ -39,6 +38,7 @@ import java.util.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
public class AnnotationTypeRequiredMemberBuilder extends AbstractMemberBuilder {
@ -140,82 +140,87 @@ public class AnnotationTypeRequiredMemberBuilder extends AbstractMemberBuilder {
return members.size() > 0;
}
/**
* Build the annotation type required member documentation.
*
* @param node the XML element that specifies which components to document
* @param memberDetailsTree the content tree to which the documentation will be added
*/
public void buildAnnotationTypeRequiredMember(XMLNode node, Content memberDetailsTree) {
buildAnnotationTypeMember(node, memberDetailsTree);
}
/**
* Build the member documentation.
*
* @param elements the XML elements that specify how to construct this
* documentation.
* @param node the XML element that specifies which components to document
* @param memberDetailsTree the content tree to which the documentation will be added
*/
public void buildAnnotationTypeRequiredMember(XMLNode node) {
public void buildAnnotationTypeMember(XMLNode node, Content memberDetailsTree) {
if (writer == null) {
return;
}
for (currentMemberIndex = 0; currentMemberIndex < members.size();
int size = members.size();
if (size > 0) {
writer.addAnnotationDetailsTreeHeader(
classDoc, memberDetailsTree);
for (currentMemberIndex = 0; currentMemberIndex < size;
currentMemberIndex++) {
buildChildren(node);
Content annotationDocTree = writer.getAnnotationDocTreeHeader(
(MemberDoc) members.get(currentMemberIndex),
memberDetailsTree);
buildChildren(node, annotationDocTree);
memberDetailsTree.addContent(writer.getAnnotationDoc(
annotationDocTree, (currentMemberIndex == size - 1)));
}
}
/**
* Build the overall header.
*/
public void buildHeader(XMLNode node) {
writer.writeHeader(classDoc,
configuration.getText("doclet.Annotation_Type_Member_Detail"));
}
/**
* Build the header for the individual members.
*/
public void buildMemberHeader(XMLNode node) {
writer.writeMemberHeader((MemberDoc) members.get(
currentMemberIndex),
currentMemberIndex == 0);
}
/**
* Build the signature.
*
* @param node the XML element that specifies which components to document
* @param annotationDocTree the content tree to which the documentation will be added
*/
public void buildSignature(XMLNode node) {
writer.writeSignature((MemberDoc) members.get(currentMemberIndex));
public void buildSignature(XMLNode node, Content annotationDocTree) {
annotationDocTree.addContent(
writer.getSignature((MemberDoc) members.get(currentMemberIndex)));
}
/**
* Build the deprecation information.
*
* @param node the XML element that specifies which components to document
* @param annotationDocTree the content tree to which the documentation will be added
*/
public void buildDeprecationInfo(XMLNode node) {
writer.writeDeprecated((MemberDoc) members.get(currentMemberIndex));
public void buildDeprecationInfo(XMLNode node, Content annotationDocTree) {
writer.addDeprecated((MemberDoc) members.get(currentMemberIndex),
annotationDocTree);
}
/**
* Build the comments for the member. Do nothing if
* {@link Configuration#nocomment} is set to true.
*
* @param node the XML element that specifies which components to document
* @param annotationDocTree the content tree to which the documentation will be added
*/
public void buildMemberComments(XMLNode node) {
public void buildMemberComments(XMLNode node, Content annotationDocTree) {
if(! configuration.nocomment){
writer.writeComments((MemberDoc) members.get(currentMemberIndex));
writer.addComments((MemberDoc) members.get(currentMemberIndex),
annotationDocTree);
}
}
/**
* Build the tag information.
*
* @param node the XML element that specifies which components to document
* @param annotationDocTree the content tree to which the documentation will be added
*/
public void buildTagInfo(XMLNode node) {
writer.writeTags((MemberDoc) members.get(currentMemberIndex));
}
/**
* Build the footer for the individual member.
*/
public void buildMemberFooter(XMLNode node) {
writer.writeMemberFooter();
}
/**
* Build the overall footer.
*/
public void buildFooter(XMLNode node) {
writer.writeFooter(classDoc);
public void buildTagInfo(XMLNode node, Content annotationDocTree) {
writer.addTags((MemberDoc) members.get(currentMemberIndex),
annotationDocTree);
}
/**

302
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/ClassBuilder.java
View file

@ -25,11 +25,11 @@
package com.sun.tools.doclets.internal.toolkit.builders;
import java.io.*;
import java.util.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.javadoc.*;
import java.io.*;
import java.util.*;
/**
* Builds the summary for a given class.
@ -39,6 +39,7 @@ import java.util.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
public class ClassBuilder extends AbstractBuilder {
@ -68,6 +69,11 @@ public class ClassBuilder extends AbstractBuilder {
*/
private boolean isEnum = false;
/**
* The content tree for the class documentation.
*/
private Content contentTree;
/**
* Construct a new ClassBuilder.
*
@ -108,7 +114,7 @@ public class ClassBuilder extends AbstractBuilder {
* {@inheritDoc}
*/
public void build() throws IOException {
build(LayoutParser.getInstance(configuration).parseXML(ROOT));
build(LayoutParser.getInstance(configuration).parseXML(ROOT), contentTree);
}
/**
@ -121,14 +127,130 @@ public class ClassBuilder extends AbstractBuilder {
/**
* Handles the &lt;ClassDoc> tag.
*
* @param elements the XML elements that specify how to document a class.
* @param node the XML element that specifies which components to document
* @param contentTree the content tree to which the documentation will be added
*/
public void buildClassDoc(XMLNode node) throws Exception {
buildChildren(node);
public void buildClassDoc(XMLNode node, Content contentTree) throws Exception {
String key;
if (isInterface) {
key = "doclet.Interface";
} else if (isEnum) {
key = "doclet.Enum";
} else {
key = "doclet.Class";
}
contentTree = writer.getHeader(configuration.getText(key) + " " +
classDoc.name());
Content classContentTree = writer.getClassContentHeader();
buildChildren(node, classContentTree);
contentTree.addContent(classContentTree);
writer.addFooter(contentTree);
writer.printDocument(contentTree);
writer.close();
copyDocFiles();
}
/**
* Build the class tree documentation.
*
* @param node the XML element that specifies which components to document
* @param classContentTree the content tree to which the documentation will be added
*/
public void buildClassTree(XMLNode node, Content classContentTree) {
writer.addClassTree(classContentTree);
}
/**
* Build the class information tree documentation.
*
* @param node the XML element that specifies which components to document
* @param classContentTree the content tree to which the documentation will be added
*/
public void buildClassInfo(XMLNode node, Content classContentTree) {
Content classInfoTree = writer.getClassInfoTreeHeader();
buildChildren(node, classInfoTree);
classContentTree.addContent(writer.getClassInfo(classInfoTree));
}
/**
* Build the typeparameters of this class.
*
* @param node the XML element that specifies which components to document
* @param classInfoTree the content tree to which the documentation will be added
*/
public void buildTypeParamInfo(XMLNode node, Content classInfoTree) {
writer.addTypeParamInfo(classInfoTree);
}
/**
* If this is an interface, list all super interfaces.
*
* @param node the XML element that specifies which components to document
* @param classInfoTree the content tree to which the documentation will be added
*/
public void buildSuperInterfacesInfo(XMLNode node, Content classInfoTree) {
writer.addSuperInterfacesInfo(classInfoTree);
}
/**
* If this is a class, list all interfaces implemented by this class.
*
* @param node the XML element that specifies which components to document
* @param classInfoTree the content tree to which the documentation will be added
*/
public void buildImplementedInterfacesInfo(XMLNode node, Content classInfoTree) {
writer.addImplementedInterfacesInfo(classInfoTree);
}
/**
* List all the classes extend this one.
*
* @param node the XML element that specifies which components to document
* @param classInfoTree the content tree to which the documentation will be added
*/
public void buildSubClassInfo(XMLNode node, Content classInfoTree) {
writer.addSubClassInfo(classInfoTree);
}
/**
* List all the interfaces that extend this one.
*
* @param node the XML element that specifies which components to document
* @param classInfoTree the content tree to which the documentation will be added
*/
public void buildSubInterfacesInfo(XMLNode node, Content classInfoTree) {
writer.addSubInterfacesInfo(classInfoTree);
}
/**
* If this is an interface, list all classes that implement this interface.
*
* @param node the XML element that specifies which components to document
* @param classInfoTree the content tree to which the documentation will be added
*/
public void buildInterfaceUsageInfo(XMLNode node, Content classInfoTree) {
writer.addInterfaceUsageInfo(classInfoTree);
}
/**
* If this class is deprecated, build the appropriate information.
*
* @param node the XML element that specifies which components to document
* @param classInfoTree the content tree to which the documentation will be added
*/
public void buildDeprecationInfo (XMLNode node, Content classInfoTree) {
writer.addClassDeprecationInfo(classInfoTree);
}
/**
* If this is an inner class or interface, list the enclosing class or interface.
*
* @param node the XML element that specifies which components to document
* @param classInfoTree the content tree to which the documentation will be added
*/
public void buildNestedClassInfo (XMLNode node, Content classInfoTree) {
writer.addNestedClassInfo(classInfoTree);
}
/**
* Copy the doc files for the current ClassDoc if necessary.
@ -151,91 +273,13 @@ public class ClassBuilder extends AbstractBuilder {
}
}
/**
* Build the header of the page.
*/
public void buildClassHeader(XMLNode node) {
String key;
if (isInterface) {
key = "doclet.Interface";
} else if (isEnum) {
key = "doclet.Enum";
} else {
key = "doclet.Class";
}
writer.writeHeader(configuration.getText(key) + " " + classDoc.name());
}
/**
* Build the class tree documentation.
*/
public void buildClassTree(XMLNode node) {
writer.writeClassTree();
}
/**
* If this is a class, list all interfaces
* implemented by this class.
*/
public void buildImplementedInterfacesInfo(XMLNode node) {
writer.writeImplementedInterfacesInfo();
}
/**
* If this is an interface, list all super interfaces.
*/
public void buildSuperInterfacesInfo(XMLNode node) {
writer.writeSuperInterfacesInfo();
}
/**
* List the parameters of this class.
*/
public void buildTypeParamInfo(XMLNode node) {
writer.writeTypeParamInfo();
}
/**
* List all the classes extend this one.
*/
public void buildSubClassInfo(XMLNode node) {
writer.writeSubClassInfo();
}
/**
* List all the interfaces that extend this one.
*/
public void buildSubInterfacesInfo(XMLNode node) {
writer.writeSubInterfacesInfo();
}
/**
* If this is an interface, list all classes that implement this interface.
*/
public void buildInterfaceUsageInfo (XMLNode node) {
writer.writeInterfaceUsageInfo();
}
/**
* If this is an inner class or interface, list the enclosing class or
* interface.
*/
public void buildNestedClassInfo (XMLNode node) {
writer.writeNestedClassInfo();
}
/**
* If this class is deprecated, print the appropriate information.
*/
public void buildDeprecationInfo (XMLNode node) {
writer.writeClassDeprecationInfo();
}
/**
* Build the signature of the current class.
*
* @param node the XML element that specifies which components to document
* @param classInfoTree the content tree to which the documentation will be added
*/
public void buildClassSignature(XMLNode node) {
public void buildClassSignature(XMLNode node, Content classInfoTree) {
StringBuffer modifiers = new StringBuffer(classDoc.modifiers() + " ");
if (isEnum) {
modifiers.append("enum ");
@ -255,81 +299,99 @@ public class ClassBuilder extends AbstractBuilder {
} else if (! isInterface) {
modifiers.append("class ");
}
writer.writeClassSignature(modifiers.toString());
writer.addClassSignature(modifiers.toString(), classInfoTree);
}
/**
* Build the class description.
*
* @param node the XML element that specifies which components to document
* @param classInfoTree the content tree to which the documentation will be added
*/
public void buildClassDescription(XMLNode node) {
writer.writeClassDescription();
public void buildClassDescription(XMLNode node, Content classInfoTree) {
writer.addClassDescription(classInfoTree);
}
/**
* Build the tag information for the current class.
*
* @param node the XML element that specifies which components to document
* @param classInfoTree the content tree to which the documentation will be added
*/
public void buildClassTagInfo(XMLNode node) {
writer.writeClassTagInfo();
public void buildClassTagInfo(XMLNode node, Content classInfoTree) {
writer.addClassTagInfo(classInfoTree);
}
/**
* Build the contents of the page.
* Build the member summary contents of the page.
*
* @param elements the XML elements that specify how a member summary is
* documented.
* @param node the XML element that specifies which components to document
* @param classContentTree the content tree to which the documentation will be added
*/
public void buildMemberSummary(XMLNode node) throws Exception {
public void buildMemberSummary(XMLNode node, Content classContentTree) throws Exception {
Content memberSummaryTree = writer.getMemberTreeHeader();
configuration.getBuilderFactory().
getMemberSummaryBuilder(writer).buildChildren(node);
writer.completeMemberSummaryBuild();
getMemberSummaryBuilder(writer).buildChildren(node, memberSummaryTree);
classContentTree.addContent(writer.getMemberSummaryTree(memberSummaryTree));
}
/**
* Build the member details contents of the page.
*
* @param node the XML element that specifies which components to document
* @param classContentTree the content tree to which the documentation will be added
*/
public void buildMemberDetails(XMLNode node, Content classContentTree) {
Content memberDetailsTree = writer.getMemberTreeHeader();
buildChildren(node, memberDetailsTree);
classContentTree.addContent(writer.getMemberDetailsTree(memberDetailsTree));
}
/**
* Build the enum constants documentation.
*
* @param elements the XML elements that specify how a enum constants are
* documented.
* @param node the XML element that specifies which components to document
* @param memberDetailsTree the content tree to which the documentation will be added
*/
public void buildEnumConstantsDetails(XMLNode node) throws Exception {
public void buildEnumConstantsDetails(XMLNode node,
Content memberDetailsTree) throws Exception {
configuration.getBuilderFactory().
getEnumConstantsBuilder(writer).buildChildren(node);
getEnumConstantsBuilder(writer).buildChildren(node, memberDetailsTree);
}
/**
* Build the field documentation.
*
* @param elements the XML elements that specify how a field is documented.
* @param node the XML element that specifies which components to document
* @param memberDetailsTree the content tree to which the documentation will be added
*/
public void buildFieldDetails(XMLNode node) throws Exception {
public void buildFieldDetails(XMLNode node,
Content memberDetailsTree) throws Exception {
configuration.getBuilderFactory().
getFieldBuilder(writer).buildChildren(node);
getFieldBuilder(writer).buildChildren(node, memberDetailsTree);
}
/**
* Build the constructor documentation.
*
* @param elements the XML elements that specify how to document a
* constructor.
* @param node the XML element that specifies which components to document
* @param memberDetailsTree the content tree to which the documentation will be added
*/
public void buildConstructorDetails(XMLNode node) throws Exception {
public void buildConstructorDetails(XMLNode node,
Content memberDetailsTree) throws Exception {
configuration.getBuilderFactory().
getConstructorBuilder(writer).buildChildren(node);
getConstructorBuilder(writer).buildChildren(node, memberDetailsTree);
}
/**
* Build the method documentation.
*
* @param elements the XML elements that specify how a method is documented.
* @param node the XML element that specifies which components to document
* @param memberDetailsTree the content tree to which the documentation will be added
*/
public void buildMethodDetails(XMLNode node) throws Exception {
public void buildMethodDetails(XMLNode node,
Content memberDetailsTree) throws Exception {
configuration.getBuilderFactory().
getMethodBuilder(writer).buildChildren(node);
}
/**
* Build the footer of the page.
*/
public void buildClassFooter(XMLNode node) {
writer.writeFooter();
getMethodBuilder(writer).buildChildren(node, memberDetailsTree);
}
}

134
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/ConstantsSummaryBuilder.java
View file

@ -25,11 +25,11 @@
package com.sun.tools.doclets.internal.toolkit.builders;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.javadoc.*;
import java.io.*;
import java.util.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.*;
/**
* Builds the Constants Summary Page.
@ -39,6 +39,7 @@ import java.util.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
public class ConstantsSummaryBuilder extends AbstractBuilder {
@ -79,6 +80,11 @@ public class ConstantsSummaryBuilder extends AbstractBuilder {
*/
private ClassDoc currentClass;
/**
* The content tree for the constant summary documentation.
*/
private Content contentTree;
/**
* Construct a new ConstantsSummaryBuilder.
*
@ -113,7 +119,7 @@ public class ConstantsSummaryBuilder extends AbstractBuilder {
//Doclet does not support this output.
return;
}
build(LayoutParser.getInstance(configuration).parseXML(ROOT));
build(LayoutParser.getInstance(configuration).parseXML(ROOT), contentTree);
}
/**
@ -126,85 +132,85 @@ public class ConstantsSummaryBuilder extends AbstractBuilder {
/**
* Build the constant summary.
*
* @param elements the list of elements describing constant summary
* documentation.
* @param node the XML element that specifies which components to document
* @param contentTree the content tree to which the documentation will be added
*/
public void buildConstantSummary(XMLNode node) throws Exception {
buildChildren(node);
public void buildConstantSummary(XMLNode node, Content contentTree) throws Exception {
contentTree = writer.getHeader();
buildChildren(node, contentTree);
writer.addFooter(contentTree);
writer.printDocument(contentTree);
writer.close();
}
/**
* Build the header.
* Build the list of packages.
*
* @param node the XML element that specifies which components to document
* @param contentTree the content tree to which the content list will be added
*/
public void buildHeader(XMLNode node) {
writer.writeHeader();
}
/**
* Build the footer.
*/
public void buildFooter(XMLNode node) {
writer.writeFooter();
}
/**
* Build the table of contents.
*/
public void buildContents(XMLNode node) {
writer.writeContentsHeader();
public void buildContents(XMLNode node, Content contentTree) {
Content contentListTree = writer.getContentsHeader();
PackageDoc[] packages = configuration.packages;
printedPackageHeaders = new HashSet<String>();
for (int i = 0; i < packages.length; i++) {
if (hasConstantField(packages[i]) && ! hasPrintedPackageIndex(packages[i].name())) {
writer.writeLinkToPackageContent(packages[i],
writer.addLinkToPackageContent(packages[i],
parsePackageName(packages[i].name()),
printedPackageHeaders);
printedPackageHeaders, contentListTree);
}
}
writer.writeContentsFooter();
contentTree.addContent(writer.getContentsList(contentListTree));
}
/**
* Build the summary for each documented package.
*
* @param elements the XML elements that represent the components
* of documentation for each package.
* @param node the XML element that specifies which components to document
* @param contentTree the tree to which the summaries will be added
*/
public void buildConstantSummaries(XMLNode node) {
public void buildConstantSummaries(XMLNode node, Content contentTree) {
PackageDoc[] packages = configuration.packages;
printedPackageHeaders = new HashSet<String>();
Content summariesTree = writer.getConstantSummaries();
for (int i = 0; i < packages.length; i++) {
if (hasConstantField(packages[i])) {
currentPackage = packages[i];
//Build the documentation for the current package.
buildChildren(node);
buildChildren(node, summariesTree);
}
}
contentTree.addContent(summariesTree);
}
/**
* Build the summary for the current package.
* Build the header for the given package.
*
* @param elements the list of XML elements that make up package
* documentation.
* @param node the XML element that specifies which components to document
* @param summariesTree the tree to which the package header will be added
*/
public void buildPackageConstantSummary(XMLNode node) {
buildChildren(node);
public void buildPackageHeader(XMLNode node, Content summariesTree) {
String parsedPackageName = parsePackageName(currentPackage.name());
if (! printedPackageHeaders.contains(parsedPackageName)) {
writer.addPackageName(currentPackage,
parsePackageName(currentPackage.name()), summariesTree);
printedPackageHeaders.add(parsedPackageName);
}
}
/**
* Build the summary for the current class.
*
* @param elements the list of XML elements that make up the class
* constant summary.
* @param node the XML element that specifies which components to document
* @param summariesTree the tree to which the class constant summary will be added
*/
public void buildClassConstantSummary(XMLNode node) {
public void buildClassConstantSummary(XMLNode node, Content summariesTree) {
ClassDoc[] classes = currentPackage.name().length() > 0 ?
currentPackage.allClasses() :
configuration.classDocCatalog.allClasses(
DocletConstants.DEFAULT_PACKAGE_NAME);
Arrays.sort(classes);
Content classConstantTree = writer.getClassConstantHeader();
for (int i = 0; i < classes.length; i++) {
if (! classDocsWithConstFields.contains(classes[i]) ||
! classes[i].isIncluded()) {
@ -212,42 +218,20 @@ public class ConstantsSummaryBuilder extends AbstractBuilder {
}
currentClass = classes[i];
//Build the documentation for the current class.
buildChildren(node);
buildChildren(node, classConstantTree);
}
summariesTree.addContent(classConstantTree);
}
/**
* Build the header for the given class.
* Build the summary of constant members in the class.
*
* @param node the XML element that specifies which components to document
* @param classConstantTree the tree to which the constant members table
* will be added
*/
public void buildPackageHeader(XMLNode node) {
String parsedPackageName = parsePackageName(currentPackage.name());
if (! printedPackageHeaders.contains(parsedPackageName)) {
writer.writePackageName(currentPackage,
parsePackageName(currentPackage.name()));
printedPackageHeaders.add(parsedPackageName);
}
}
/**
* Build the header for the given class.
*/
public void buildClassHeader(XMLNode node) {
writer.writeConstantMembersHeader(currentClass);
}
/**
* Print summary of constant members in the
* class.
*/
public void buildConstantMembers(XMLNode node) {
new ConstantFieldBuilder(currentClass).buildMembersSummary(node);
}
/**
* Build the footer for the given class.
*/
public void buildClassFooter(XMLNode node) {
writer.writeConstantMembersFooter(currentClass);
public void buildConstantMembers(XMLNode node, Content classConstantTree) {
new ConstantFieldBuilder(currentClass).buildMembersSummary(node, classConstantTree);
}
/**
@ -346,12 +330,16 @@ public class ConstantsSummaryBuilder extends AbstractBuilder {
/**
* Builds the table of constants for a given class.
*
* @param node the XML element that specifies which components to document
* @param classConstantTree the tree to which the class constants table
* will be added
*/
protected void buildMembersSummary(XMLNode node) {
protected void buildMembersSummary(XMLNode node, Content classConstantTree) {
List<FieldDoc> members = new ArrayList<FieldDoc>(members());
if (members.size() > 0) {
Collections.sort(members);
writer.writeConstantMembers(classdoc, members);
writer.addConstantMembers(classdoc, members, classConstantTree);
}
}

97
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/ConstructorBuilder.java
View file

@ -25,10 +25,10 @@
package com.sun.tools.doclets.internal.toolkit.builders;
import java.util.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.javadoc.*;
import java.util.*;
/**
* Builds documentation for a constructor.
@ -38,6 +38,7 @@ import java.util.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
public class ConstructorBuilder extends AbstractMemberBuilder {
@ -51,7 +52,7 @@ public class ConstructorBuilder extends AbstractMemberBuilder {
* The index of the current field that is being documented at this point
* in time.
*/
private int currentMethodIndex;
private int currentConstructorIndex;
/**
* The class whose constructors are being documented.
@ -155,83 +156,77 @@ public class ConstructorBuilder extends AbstractMemberBuilder {
/**
* Build the constructor documentation.
*
* @param elements the XML elements that specify how to construct this
* documentation.
* @param node the XML element that specifies which components to document
* @param memberDetailsTree the content tree to which the documentation will be added
*/
public void buildConstructorDoc(XMLNode node) {
public void buildConstructorDoc(XMLNode node, Content memberDetailsTree) {
if (writer == null) {
return;
}
for (currentMethodIndex = 0;
currentMethodIndex < constructors.size();
currentMethodIndex++) {
buildChildren(node);
int size = constructors.size();
if (size > 0) {
Content constructorDetailsTree = writer.getConstructorDetailsTreeHeader(
classDoc, memberDetailsTree);
for (currentConstructorIndex = 0; currentConstructorIndex < size;
currentConstructorIndex++) {
Content constructorDocTree = writer.getConstructorDocTreeHeader(
(ConstructorDoc) constructors.get(currentConstructorIndex),
constructorDetailsTree);
buildChildren(node, constructorDocTree);
constructorDetailsTree.addContent(writer.getConstructorDoc(
constructorDocTree, (currentConstructorIndex == size - 1)));
}
memberDetailsTree.addContent(
writer.getConstructorDetails(constructorDetailsTree));
}
/**
* Build the overall header.
*/
public void buildHeader(XMLNode node) {
writer.writeHeader(
classDoc,
configuration.getText("doclet.Constructor_Detail"));
}
/**
* Build the header for the individual constructor.
*/
public void buildConstructorHeader(XMLNode node) {
writer.writeConstructorHeader(
(ConstructorDoc) constructors.get(currentMethodIndex),
currentMethodIndex == 0);
}
/**
* Build the signature.
*
* @param node the XML element that specifies which components to document
* @param constructorDocTree the content tree to which the documentation will be added
*/
public void buildSignature(XMLNode node) {
writer.writeSignature(
(ConstructorDoc) constructors.get(currentMethodIndex));
public void buildSignature(XMLNode node, Content constructorDocTree) {
constructorDocTree.addContent(
writer.getSignature(
(ConstructorDoc) constructors.get(currentConstructorIndex)));
}
/**
* Build the deprecation information.
*
* @param node the XML element that specifies which components to document
* @param constructorDocTree the content tree to which the documentation will be added
*/
public void buildDeprecationInfo(XMLNode node) {
writer.writeDeprecated(
(ConstructorDoc) constructors.get(currentMethodIndex));
public void buildDeprecationInfo(XMLNode node, Content constructorDocTree) {
writer.addDeprecated(
(ConstructorDoc) constructors.get(currentConstructorIndex), constructorDocTree);
}
/**
* Build the comments for the constructor. Do nothing if
* {@link Configuration#nocomment} is set to true.
*
* @param node the XML element that specifies which components to document
* @param constructorDocTree the content tree to which the documentation will be added
*/
public void buildConstructorComments(XMLNode node) {
public void buildConstructorComments(XMLNode node, Content constructorDocTree) {
if (!configuration.nocomment) {
writer.writeComments(
(ConstructorDoc) constructors.get(currentMethodIndex));
writer.addComments(
(ConstructorDoc) constructors.get(currentConstructorIndex),
constructorDocTree);
}
}
/**
* Build the tag information.
*
* @param node the XML element that specifies which components to document
* @param constructorDocTree the content tree to which the documentation will be added
*/
public void buildTagInfo(XMLNode node) {
writer.writeTags((ConstructorDoc) constructors.get(currentMethodIndex));
}
/**
* Build the footer for the individual constructor.
*/
public void buildConstructorFooter(XMLNode node) {
writer.writeConstructorFooter();
}
/**
* Build the overall footer.
*/
public void buildFooter(XMLNode node) {
writer.writeFooter(classDoc);
public void buildTagInfo(XMLNode node, Content constructorDocTree) {
writer.addTags((ConstructorDoc) constructors.get(currentConstructorIndex),
constructorDocTree);
}
}

97
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/EnumConstantBuilder.java
View file

@ -25,10 +25,10 @@
package com.sun.tools.doclets.internal.toolkit.builders;
import java.util.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.javadoc.*;
import java.util.*;
/**
* Builds documentation for a enum constants.
@ -38,6 +38,7 @@ import java.util.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
public class EnumConstantBuilder extends AbstractMemberBuilder {
@ -145,85 +146,79 @@ public class EnumConstantBuilder extends AbstractMemberBuilder {
/**
* Build the enum constant documentation.
*
* @param elements the XML elements that specify how to construct this
* documentation.
* @param node the XML element that specifies which components to document
* @param memberDetailsTree the content tree to which the documentation will be added
*/
public void buildEnumConstant(XMLNode node) {
public void buildEnumConstant(XMLNode node, Content memberDetailsTree) {
if (writer == null) {
return;
}
for (currentEnumConstantsIndex = 0;
currentEnumConstantsIndex < enumConstants.size();
int size = enumConstants.size();
if (size > 0) {
Content enumConstantsDetailsTree = writer.getEnumConstantsDetailsTreeHeader(
classDoc, memberDetailsTree);
for (currentEnumConstantsIndex = 0; currentEnumConstantsIndex < size;
currentEnumConstantsIndex++) {
buildChildren(node);
}
}
/**
* Build the overall header.
*/
public void buildHeader(XMLNode node) {
writer.writeHeader(
classDoc,
configuration.getText("doclet.Enum_Constant_Detail"));
}
/**
* Build the header for the individual enum constants.
*/
public void buildEnumConstantHeader(XMLNode node) {
writer.writeEnumConstantHeader(
Content enumConstantsTree = writer.getEnumConstantsTreeHeader(
(FieldDoc) enumConstants.get(currentEnumConstantsIndex),
currentEnumConstantsIndex == 0);
enumConstantsDetailsTree);
buildChildren(node, enumConstantsTree);
enumConstantsDetailsTree.addContent(writer.getEnumConstants(
enumConstantsTree, (currentEnumConstantsIndex == size - 1)));
}
memberDetailsTree.addContent(
writer.getEnumConstantsDetails(enumConstantsDetailsTree));
}
}
/**
* Build the signature.
*
* @param node the XML element that specifies which components to document
* @param enumConstantsTree the content tree to which the documentation will be added
*/
public void buildSignature(XMLNode node) {
writer.writeSignature(
(FieldDoc) enumConstants.get(currentEnumConstantsIndex));
public void buildSignature(XMLNode node, Content enumConstantsTree) {
enumConstantsTree.addContent(writer.getSignature(
(FieldDoc) enumConstants.get(currentEnumConstantsIndex)));
}
/**
* Build the deprecation information.
*
* @param node the XML element that specifies which components to document
* @param enumConstantsTree the content tree to which the documentation will be added
*/
public void buildDeprecationInfo(XMLNode node) {
writer.writeDeprecated(
(FieldDoc) enumConstants.get(currentEnumConstantsIndex));
public void buildDeprecationInfo(XMLNode node, Content enumConstantsTree) {
writer.addDeprecated(
(FieldDoc) enumConstants.get(currentEnumConstantsIndex),
enumConstantsTree);
}
/**
* Build the comments for the enum constant. Do nothing if
* {@link Configuration#nocomment} is set to true.
*
* @param node the XML element that specifies which components to document
* @param enumConstantsTree the content tree to which the documentation will be added
*/
public void buildEnumConstantComments(XMLNode node) {
public void buildEnumConstantComments(XMLNode node, Content enumConstantsTree) {
if (!configuration.nocomment) {
writer.writeComments(
(FieldDoc) enumConstants.get(currentEnumConstantsIndex));
writer.addComments(
(FieldDoc) enumConstants.get(currentEnumConstantsIndex),
enumConstantsTree);
}
}
/**
* Build the tag information.
*
* @param node the XML element that specifies which components to document
* @param enumConstantsTree the content tree to which the documentation will be added
*/
public void buildTagInfo(XMLNode node) {
writer.writeTags(
(FieldDoc) enumConstants.get(currentEnumConstantsIndex));
}
/**
* Build the footer for the individual enum constants.
*/
public void buildEnumConstantFooter(XMLNode node) {
writer.writeEnumConstantFooter();
}
/**
* Build the overall footer.
*/
public void buildFooter(XMLNode node) {
writer.writeFooter(classDoc);
public void buildTagInfo(XMLNode node, Content enumConstantsTree) {
writer.addTags(
(FieldDoc) enumConstants.get(currentEnumConstantsIndex),
enumConstantsTree);
}
/**

88
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/FieldBuilder.java
View file

@ -25,10 +25,10 @@
package com.sun.tools.doclets.internal.toolkit.builders;
import java.util.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.javadoc.*;
import java.util.*;
/**
* Builds documentation for a field.
@ -38,6 +38,7 @@ import java.util.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
public class FieldBuilder extends AbstractMemberBuilder {
@ -146,81 +147,74 @@ public class FieldBuilder extends AbstractMemberBuilder {
/**
* Build the field documentation.
*
* @param elements the XML elements that specify how to construct this
* documentation.
* @param node the XML element that specifies which components to document
* @param memberDetailsTree the content tree to which the documentation will be added
*/
public void buildFieldDoc(XMLNode node) {
public void buildFieldDoc(XMLNode node, Content memberDetailsTree) {
if (writer == null) {
return;
}
for (currentFieldIndex = 0;
currentFieldIndex < fields.size();
int size = fields.size();
if (size > 0) {
Content fieldDetailsTree = writer.getFieldDetailsTreeHeader(
classDoc, memberDetailsTree);
for (currentFieldIndex = 0; currentFieldIndex < size;
currentFieldIndex++) {
buildChildren(node);
}
}
/**
* Build the overall header.
*/
public void buildHeader(XMLNode node) {
writer.writeHeader(
classDoc,
configuration.getText("doclet.Field_Detail"));
}
/**
* Build the header for the individual field.
*/
public void buildFieldHeader(XMLNode node) {
writer.writeFieldHeader(
Content fieldDocTree = writer.getFieldDocTreeHeader(
(FieldDoc) fields.get(currentFieldIndex),
currentFieldIndex == 0);
fieldDetailsTree);
buildChildren(node, fieldDocTree);
fieldDetailsTree.addContent(writer.getFieldDoc(
fieldDocTree, (currentFieldIndex == size - 1)));
}
memberDetailsTree.addContent(
writer.getFieldDetails(fieldDetailsTree));
}
}
/**
* Build the signature.
*
* @param node the XML element that specifies which components to document
* @param fieldDocTree the content tree to which the documentation will be added
*/
public void buildSignature(XMLNode node) {
writer.writeSignature((FieldDoc) fields.get(currentFieldIndex));
public void buildSignature(XMLNode node, Content fieldDocTree) {
fieldDocTree.addContent(
writer.getSignature((FieldDoc) fields.get(currentFieldIndex)));
}
/**
* Build the deprecation information.
*
* @param node the XML element that specifies which components to document
* @param fieldDocTree the content tree to which the documentation will be added
*/
public void buildDeprecationInfo(XMLNode node) {
writer.writeDeprecated((FieldDoc) fields.get(currentFieldIndex));
public void buildDeprecationInfo(XMLNode node, Content fieldDocTree) {
writer.addDeprecated(
(FieldDoc) fields.get(currentFieldIndex), fieldDocTree);
}
/**
* Build the comments for the field. Do nothing if
* {@link Configuration#nocomment} is set to true.
*
* @param node the XML element that specifies which components to document
* @param fieldDocTree the content tree to which the documentation will be added
*/
public void buildFieldComments(XMLNode node) {
public void buildFieldComments(XMLNode node, Content fieldDocTree) {
if (!configuration.nocomment) {
writer.writeComments((FieldDoc) fields.get(currentFieldIndex));
writer.addComments((FieldDoc) fields.get(currentFieldIndex), fieldDocTree);
}
}
/**
* Build the tag information.
*
* @param node the XML element that specifies which components to document
* @param fieldDocTree the content tree to which the documentation will be added
*/
public void buildTagInfo(XMLNode node) {
writer.writeTags((FieldDoc) fields.get(currentFieldIndex));
}
/**
* Build the footer for the individual field.
*/
public void buildFieldFooter(XMLNode node) {
writer.writeFieldFooter();
}
/**
* Build the overall footer.
*/
public void buildFooter(XMLNode node) {
writer.writeFooter(classDoc);
public void buildTagInfo(XMLNode node, Content fieldDocTree) {
writer.addTags((FieldDoc) fields.get(currentFieldIndex), fieldDocTree);
}
/**

2
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/LayoutParser.java
View file

@ -76,7 +76,7 @@ public class LayoutParser extends DefaultHandler {
/**
* Parse the XML specifying the layout of the documentation.
*
* @return List the list of XML elements parsed.
* @return the list of XML elements parsed.
*/
public XMLNode parseXML(String root) {
if (xmlElementsMap.containsKey(root)) {

169
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/MemberSummaryBuilder.java
View file

@ -25,10 +25,10 @@
package com.sun.tools.doclets.internal.toolkit.builders;
import java.util.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.javadoc.*;
import java.util.*;
/**
* Builds the member summary.
@ -38,6 +38,7 @@ import java.util.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
public class MemberSummaryBuilder extends AbstractMemberBuilder {
@ -193,92 +194,100 @@ public class MemberSummaryBuilder extends AbstractMemberBuilder {
/**
* Build the summary for the enum constants.
*
* @param node the XML element that specifies which components to document
* @param memberSummaryTree the content tree to which the documentation will be added
*/
public void buildEnumConstantsSummary(XMLNode node) {
buildSummary(
memberSummaryWriters[VisibleMemberMap.ENUM_CONSTANTS],
visibleMemberMaps[VisibleMemberMap.ENUM_CONSTANTS]);
public void buildEnumConstantsSummary(XMLNode node, Content memberSummaryTree) {
MemberSummaryWriter writer =
memberSummaryWriters[VisibleMemberMap.ENUM_CONSTANTS];
VisibleMemberMap visibleMemberMap =
visibleMemberMaps[VisibleMemberMap.ENUM_CONSTANTS];
addSummary(writer, visibleMemberMap, false, memberSummaryTree);
}
/**
* Build the summary for the optional members.
*
* @param node the XML element that specifies which components to document
* @param memberSummaryTree the content tree to which the documentation will be added
*/
public void buildAnnotationTypeOptionalMemberSummary(XMLNode node) {
buildSummary(
memberSummaryWriters[VisibleMemberMap.ANNOTATION_TYPE_MEMBER_OPTIONAL],
visibleMemberMaps[VisibleMemberMap.ANNOTATION_TYPE_MEMBER_OPTIONAL]);
public void buildAnnotationTypeOptionalMemberSummary(XMLNode node, Content memberSummaryTree) {
MemberSummaryWriter writer =
memberSummaryWriters[VisibleMemberMap.ANNOTATION_TYPE_MEMBER_OPTIONAL];
VisibleMemberMap visibleMemberMap =
visibleMemberMaps[VisibleMemberMap.ANNOTATION_TYPE_MEMBER_OPTIONAL];
addSummary(writer, visibleMemberMap, false, memberSummaryTree);
}
/**
* Build the summary for the optional members.
*
* @param node the XML element that specifies which components to document
* @param memberSummaryTree the content tree to which the documentation will be added
*/
public void buildAnnotationTypeRequiredMemberSummary(XMLNode node) {
buildSummary(
memberSummaryWriters[VisibleMemberMap.ANNOTATION_TYPE_MEMBER_REQUIRED],
visibleMemberMaps[VisibleMemberMap.ANNOTATION_TYPE_MEMBER_REQUIRED]);
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);
}
/**
* Build the summary for the fields.
*
* @param node the XML element that specifies which components to document
* @param memberSummaryTree the content tree to which the documentation will be added
*/
public void buildFieldsSummary(XMLNode node) {
buildSummary(
memberSummaryWriters[VisibleMemberMap.FIELDS],
visibleMemberMaps[VisibleMemberMap.FIELDS]);
}
/**
* Build the inherited summary for the fields.
*/
public void buildFieldsInheritedSummary(XMLNode node) {
buildInheritedSummary(
memberSummaryWriters[VisibleMemberMap.FIELDS],
visibleMemberMaps[VisibleMemberMap.FIELDS]);
public void buildFieldsSummary(XMLNode node, Content memberSummaryTree) {
MemberSummaryWriter writer =
memberSummaryWriters[VisibleMemberMap.FIELDS];
VisibleMemberMap visibleMemberMap =
visibleMemberMaps[VisibleMemberMap.FIELDS];
addSummary(writer, visibleMemberMap, true, memberSummaryTree);
}
/**
* Build the summary for the nested classes.
*
* @param node the XML element that specifies which components to document
* @param memberSummaryTree the content tree to which the documentation will be added
*/
public void buildNestedClassesSummary(XMLNode node) {
buildSummary(
memberSummaryWriters[VisibleMemberMap.INNERCLASSES],
visibleMemberMaps[VisibleMemberMap.INNERCLASSES]);
}
/**
* Build the inherited summary for the nested classes.
*/
public void buildNestedClassesInheritedSummary(XMLNode node) {
buildInheritedSummary(
memberSummaryWriters[VisibleMemberMap.INNERCLASSES],
visibleMemberMaps[VisibleMemberMap.INNERCLASSES]);
public void buildNestedClassesSummary(XMLNode node, Content memberSummaryTree) {
MemberSummaryWriter writer =
memberSummaryWriters[VisibleMemberMap.INNERCLASSES];
VisibleMemberMap visibleMemberMap =
visibleMemberMaps[VisibleMemberMap.INNERCLASSES];
addSummary(writer, visibleMemberMap, true, memberSummaryTree);
}
/**
* Build the method summary.
*
* @param node the XML element that specifies which components to document
* @param memberSummaryTree the content tree to which the documentation will be added
*/
public void buildMethodsSummary(XMLNode node) {
buildSummary(
memberSummaryWriters[VisibleMemberMap.METHODS],
visibleMemberMaps[VisibleMemberMap.METHODS]);
}
/**
* Build the inherited method summary.
*/
public void buildMethodsInheritedSummary(XMLNode node) {
buildInheritedSummary(
memberSummaryWriters[VisibleMemberMap.METHODS],
visibleMemberMaps[VisibleMemberMap.METHODS]);
public void buildMethodsSummary(XMLNode node, Content memberSummaryTree) {
MemberSummaryWriter writer =
memberSummaryWriters[VisibleMemberMap.METHODS];
VisibleMemberMap visibleMemberMap =
visibleMemberMaps[VisibleMemberMap.METHODS];
addSummary(writer, visibleMemberMap, true, memberSummaryTree);
}
/**
* Build the constructor summary.
*
* @param node the XML element that specifies which components to document
* @param memberSummaryTree the content tree to which the documentation will be added
*/
public void buildConstructorsSummary(XMLNode node) {
buildSummary(
memberSummaryWriters[VisibleMemberMap.CONSTRUCTORS],
visibleMemberMaps[VisibleMemberMap.CONSTRUCTORS]);
public void buildConstructorsSummary(XMLNode node, Content memberSummaryTree) {
MemberSummaryWriter writer =
memberSummaryWriters[VisibleMemberMap.CONSTRUCTORS];
VisibleMemberMap visibleMemberMap =
visibleMemberMaps[VisibleMemberMap.CONSTRUCTORS];
addSummary(writer, visibleMemberMap, false, memberSummaryTree);
}
/**
@ -286,14 +295,15 @@ public class MemberSummaryBuilder extends AbstractMemberBuilder {
*
* @param writer the summary writer to write the output.
* @param visibleMemberMap the given members to summarize.
* @param summaryTreeList list of content trees to which the documentation will be added
*/
private void buildSummary(MemberSummaryWriter writer,
VisibleMemberMap visibleMemberMap) {
VisibleMemberMap visibleMemberMap, LinkedList<Content> summaryTreeList) {
List<ProgramElementDoc> members = new ArrayList<ProgramElementDoc>(visibleMemberMap.getLeafClassMembers(
configuration));
if (members.size() > 0) {
Collections.sort(members);
writer.writeMemberSummaryHeader(classDoc);
Content tableTree = writer.getSummaryTableTree(classDoc);
for (int i = 0; i < members.size(); i++) {
ProgramElementDoc member = members.get(i);
Tag[] firstSentenceTags = member.firstSentenceTags();
@ -307,10 +317,9 @@ public class MemberSummaryBuilder extends AbstractMemberBuilder {
firstSentenceTags = inheritedDoc.holder.firstSentenceTags();
}
}
writer.writeMemberSummary(classDoc, member, firstSentenceTags,
i == 0, i == members.size() - 1);
writer.addMemberSummary(classDoc, member, firstSentenceTags, tableTree, i);
}
writer.writeMemberSummaryFooter(classDoc);
summaryTreeList.add(tableTree);
}
}
@ -319,9 +328,10 @@ public class MemberSummaryBuilder extends AbstractMemberBuilder {
*
* @param writer the writer for this member summary.
* @param visibleMemberMap the map for the members to document.
* @param summaryTreeList list of content trees to which the documentation will be added
*/
private void buildInheritedSummary(MemberSummaryWriter writer,
VisibleMemberMap visibleMemberMap) {
VisibleMemberMap visibleMemberMap, LinkedList<Content> summaryTreeList) {
for (Iterator<ClassDoc> iter = visibleMemberMap.getVisibleClassesList().iterator();
iter.hasNext();) {
ClassDoc inhclass = iter.next();
@ -335,18 +345,45 @@ public class MemberSummaryBuilder extends AbstractMemberBuilder {
List<ProgramElementDoc> inhmembers = visibleMemberMap.getMembersFor(inhclass);
if (inhmembers.size() > 0) {
Collections.sort(inhmembers);
writer.writeInheritedMemberSummaryHeader(inhclass);
Content inheritedTree = writer.getInheritedSummaryHeader(inhclass);
Content linksTree = writer.getInheritedSummaryLinksTree();
for (int j = 0; j < inhmembers.size(); ++j) {
writer.writeInheritedMemberSummary(
writer.addInheritedMemberSummary(
inhclass.isPackagePrivate() &&
! Util.isLinkable(inhclass, configuration) ?
classDoc : inhclass,
inhmembers.get(j),
j == 0,
j == inhmembers.size() - 1);
j == inhmembers.size() - 1, linksTree);
}
writer.writeInheritedMemberSummaryFooter(inhclass);
inheritedTree.addContent(linksTree);
summaryTreeList.add(writer.getMemberTree(inheritedTree));
}
}
}
/**
* Add the summary for the documentation.
*
* @param writer the writer for this member summary.
* @param visibleMemberMap the map for the members to document.
* @param showInheritedSummary true if inherited summary should be documented
* @param memberSummaryTree the content tree to which the documentation will be added
*/
private void addSummary(MemberSummaryWriter writer,
VisibleMemberMap visibleMemberMap, boolean showInheritedSummary,
Content memberSummaryTree) {
LinkedList<Content> summaryTreeList = new LinkedList<Content>();
buildSummary(writer, visibleMemberMap, summaryTreeList);
if (showInheritedSummary)
buildInheritedSummary(writer, visibleMemberMap, summaryTreeList);
if (!summaryTreeList.isEmpty()) {
Content memberTree = writer.getMemberSummaryHeader(
classDoc, memberSummaryTree);
for (int i = 0; i < summaryTreeList.size(); i++) {
memberTree.addContent(summaryTreeList.get(i));
}
memberSummaryTree.addContent(writer.getMemberTree(memberTree));
}
}
}

93
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/MethodBuilder.java
View file

@ -25,10 +25,10 @@
package com.sun.tools.doclets.internal.toolkit.builders;
import java.util.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.javadoc.*;
import java.util.*;
/**
* Builds documentation for a method.
@ -38,6 +38,7 @@ import java.util.*;
* Do not use it as an API
*
* @author Jamie Ho
* @author Bhavesh Patel (Modified)
* @since 1.5
*/
public class MethodBuilder extends AbstractMemberBuilder {
@ -141,55 +142,62 @@ public class MethodBuilder extends AbstractMemberBuilder {
/**
* Build the method documentation.
*
* @param node the XML element that specifies which components to document
* @param memberDetailsTree the content tree to which the documentation will be added
*/
public void buildMethodDoc(XMLNode node) {
public void buildMethodDoc(XMLNode node, Content memberDetailsTree) {
if (writer == null) {
return;
}
for (currentMethodIndex = 0;
currentMethodIndex < methods.size();
int size = methods.size();
if (size > 0) {
Content methodDetailsTree = writer.getMethodDetailsTreeHeader(
classDoc, memberDetailsTree);
for (currentMethodIndex = 0; currentMethodIndex < size;
currentMethodIndex++) {
buildChildren(node);
}
}
/**
* Build the overall header.
*/
public void buildHeader(XMLNode node) {
writer.writeHeader(
classDoc,
configuration.getText("doclet.Method_Detail"));
}
/**
* Build the header for the individual method.
*/
public void buildMethodHeader(XMLNode node) {
writer.writeMethodHeader(
Content methodDocTree = writer.getMethodDocTreeHeader(
(MethodDoc) methods.get(currentMethodIndex),
currentMethodIndex == 0);
methodDetailsTree);
buildChildren(node, methodDocTree);
methodDetailsTree.addContent(writer.getMethodDoc(
methodDocTree, (currentMethodIndex == size - 1)));
}
memberDetailsTree.addContent(
writer.getMethodDetails(methodDetailsTree));
}
}
/**
* Build the signature.
*
* @param node the XML element that specifies which components to document
* @param methodDocTree the content tree to which the documentation will be added
*/
public void buildSignature(XMLNode node) {
writer.writeSignature((MethodDoc) methods.get(currentMethodIndex));
public void buildSignature(XMLNode node, Content methodDocTree) {
methodDocTree.addContent(
writer.getSignature((MethodDoc) methods.get(currentMethodIndex)));
}
/**
* Build the deprecation information.
*
* @param node the XML element that specifies which components to document
* @param methodDocTree the content tree to which the documentation will be added
*/
public void buildDeprecationInfo(XMLNode node) {
writer.writeDeprecated((MethodDoc) methods.get(currentMethodIndex));
public void buildDeprecationInfo(XMLNode node, Content methodDocTree) {
writer.addDeprecated(
(MethodDoc) methods.get(currentMethodIndex), methodDocTree);
}
/**
* Build the comments for the method. Do nothing if
* {@link Configuration#nocomment} is set to true. If this method
* {@link Configuration#nocomment} is set to true.
*
* @param node the XML element that specifies which components to document
* @param methodDocTree the content tree to which the documentation will be added
*/
public void buildMethodComments(XMLNode node) {
public void buildMethodComments(XMLNode node, Content methodDocTree) {
if (!configuration.nocomment) {
MethodDoc method = (MethodDoc) methods.get(currentMethodIndex);
@ -198,36 +206,23 @@ public class MethodBuilder extends AbstractMemberBuilder {
new DocFinder.Input(method));
method = docs.inlineTags != null && docs.inlineTags.length > 0 ?
(MethodDoc) docs.holder : method;
}
//NOTE: When we fix the bug where ClassDoc.interfaceTypes() does
// not pass all implemented interfaces, holder will be the
// interface type. For now, it is really the erasure.
writer.writeComments(method.containingClass(), method);
writer.addComments(method.containingClass(), method, methodDocTree);
}
}
/**
* Build the tag information.
*
* @param node the XML element that specifies which components to document
* @param methodDocTree the content tree to which the documentation will be added
*/
public void buildTagInfo(XMLNode node) {
writer.writeTags((MethodDoc) methods.get(currentMethodIndex));
}
/**
* Build the footer of the method.
*/
public void buildMethodFooter(XMLNode node) {
writer.writeMethodFooter();
}
/**
* Build the overall footer.
*/
public void buildFooter(XMLNode node) {
writer.writeFooter(classDoc);
public void buildTagInfo(XMLNode node, Content methodDocTree) {
writer.addTags((MethodDoc) methods.get(currentMethodIndex),
methodDocTree);
}
/**

234
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/PackageSummaryBuilder.java
View file

@ -25,10 +25,10 @@
package com.sun.tools.doclets.internal.toolkit.builders;
import java.io.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.*;
import com.sun.javadoc.*;
import java.io.*;
/**
* Builds the summary for a given package.
@ -42,7 +42,6 @@ import java.io.*;
* @since 1.5
*/
public class PackageSummaryBuilder extends AbstractBuilder {
/**
* The root element of the package summary XML is {@value}.
*/
@ -58,6 +57,11 @@ public class PackageSummaryBuilder extends AbstractBuilder {
*/
private PackageSummaryWriter packageWriter;
/**
* The content that will be added to the package summary documentation tree.
*/
private Content contentTree;
private PackageSummaryBuilder(Configuration configuration) {
super(configuration);
}
@ -90,7 +94,7 @@ public class PackageSummaryBuilder extends AbstractBuilder {
//Doclet does not support this output.
return;
}
build(LayoutParser.getInstance(configuration).parseXML(ROOT));
build(LayoutParser.getInstance(configuration).parseXML(ROOT), contentTree);
}
/**
@ -102,9 +106,16 @@ public class PackageSummaryBuilder extends AbstractBuilder {
/**
* Build the package documentation.
*
* @param node the XML element that specifies which components to document
* @param contentTree the content tree to which the documentation will be added
*/
public void buildPackageDoc(XMLNode node) throws Exception {
buildChildren(node);
public void buildPackageDoc(XMLNode node, Content contentTree) throws Exception {
contentTree = packageWriter.getPackageHeader(
Util.getPackageName(packageDoc));
buildChildren(node, contentTree);
packageWriter.addPackageFooter(contentTree);
packageWriter.printDocument(contentTree);
packageWriter.close();
Util.copyDocFiles(
configuration,
@ -116,82 +127,39 @@ public class PackageSummaryBuilder extends AbstractBuilder {
}
/**
* Build the header of the summary.
* Build the content for the package doc.
*
* @param node the XML element that specifies which components to document
* @param contentTree the content tree to which the package contents
* will be added
*/
public void buildPackageHeader(XMLNode node) {
packageWriter.writePackageHeader(Util.getPackageName(packageDoc));
}
/**
* Build the description of the summary.
*/
public void buildPackageDescription(XMLNode node) {
if (configuration.nocomment) {
return;
}
packageWriter.writePackageDescription();
}
/**
* Build the tags of the summary.
*/
public void buildPackageTags(XMLNode node) {
if (configuration.nocomment) {
return;
}
packageWriter.writePackageTags();
public void buildContent(XMLNode node, Content contentTree) {
Content packageContentTree = packageWriter.getContentHeader();
buildChildren(node, packageContentTree);
contentTree.addContent(packageContentTree);
}
/**
* Build the package summary.
*
* @param node the XML element that specifies which components to document
* @param packageContentTree the package content tree to which the summaries will
* be added
*/
public void buildSummary(XMLNode node) {
buildChildren(node);
}
/**
* Build the overall header.
*/
public void buildSummaryHeader(XMLNode node) {
packageWriter.writeSummaryHeader();
}
/**
* Build the overall footer.
*/
public void buildSummaryFooter(XMLNode node) {
packageWriter.writeSummaryFooter();
}
/**
* Build the summary for the classes in this package.
*/
public void buildClassSummary(XMLNode node) {
String classTableSummary =
configuration.getText("doclet.Member_Table_Summary",
configuration.getText("doclet.Class_Summary"),
configuration.getText("doclet.classes"));
String[] classTableHeader = new String[] {
configuration.getText("doclet.Class"),
configuration.getText("doclet.Description")
};
ClassDoc[] classes =
packageDoc.isIncluded()
? packageDoc.ordinaryClasses()
: configuration.classDocCatalog.ordinaryClasses(
Util.getPackageName(packageDoc));
if (classes.length > 0) {
packageWriter.writeClassesSummary(
classes,
configuration.getText("doclet.Class_Summary"),
classTableSummary, classTableHeader);
}
public void buildSummary(XMLNode node, Content packageContentTree) {
Content summaryContentTree = packageWriter.getSummaryHeader();
buildChildren(node, summaryContentTree);
packageContentTree.addContent(summaryContentTree);
}
/**
* Build the summary for the interfaces in this package.
*
* @param node the XML element that specifies which components to document
* @param summaryContentTree the summary tree to which the interface summary
* will be added
*/
public void buildInterfaceSummary(XMLNode node) {
public void buildInterfaceSummary(XMLNode node, Content summaryContentTree) {
String interfaceTableSummary =
configuration.getText("doclet.Member_Table_Summary",
configuration.getText("doclet.Interface_Summary"),
@ -206,42 +174,50 @@ public class PackageSummaryBuilder extends AbstractBuilder {
: configuration.classDocCatalog.interfaces(
Util.getPackageName(packageDoc));
if (interfaces.length > 0) {
packageWriter.writeClassesSummary(
packageWriter.addClassesSummary(
interfaces,
configuration.getText("doclet.Interface_Summary"),
interfaceTableSummary, interfaceTableHeader);
interfaceTableSummary, interfaceTableHeader, summaryContentTree);
}
}
/**
* Build the summary for the enums in this package.
* Build the summary for the classes in this package.
*
* @param node the XML element that specifies which components to document
* @param summaryContentTree the summary tree to which the class summary will
* be added
*/
public void buildAnnotationTypeSummary(XMLNode node) {
String annotationtypeTableSummary =
public void buildClassSummary(XMLNode node, Content summaryContentTree) {
String classTableSummary =
configuration.getText("doclet.Member_Table_Summary",
configuration.getText("doclet.Annotation_Types_Summary"),
configuration.getText("doclet.annotationtypes"));
String[] annotationtypeTableHeader = new String[] {
configuration.getText("doclet.AnnotationType"),
configuration.getText("doclet.Class_Summary"),
configuration.getText("doclet.classes"));
String[] classTableHeader = new String[] {
configuration.getText("doclet.Class"),
configuration.getText("doclet.Description")
};
ClassDoc[] annotationTypes =
ClassDoc[] classes =
packageDoc.isIncluded()
? packageDoc.annotationTypes()
: configuration.classDocCatalog.annotationTypes(
? packageDoc.ordinaryClasses()
: configuration.classDocCatalog.ordinaryClasses(
Util.getPackageName(packageDoc));
if (annotationTypes.length > 0) {
packageWriter.writeClassesSummary(
annotationTypes,
configuration.getText("doclet.Annotation_Types_Summary"),
annotationtypeTableSummary, annotationtypeTableHeader);
if (classes.length > 0) {
packageWriter.addClassesSummary(
classes,
configuration.getText("doclet.Class_Summary"),
classTableSummary, classTableHeader, summaryContentTree);
}
}
/**
* Build the summary for the enums in this package.
*
* @param node the XML element that specifies which components to document
* @param summaryContentTree the summary tree to which the enum summary will
* be added
*/
public void buildEnumSummary(XMLNode node) {
public void buildEnumSummary(XMLNode node, Content summaryContentTree) {
String enumTableSummary =
configuration.getText("doclet.Member_Table_Summary",
configuration.getText("doclet.Enum_Summary"),
@ -256,17 +232,21 @@ public class PackageSummaryBuilder extends AbstractBuilder {
: configuration.classDocCatalog.enums(
Util.getPackageName(packageDoc));
if (enums.length > 0) {
packageWriter.writeClassesSummary(
packageWriter.addClassesSummary(
enums,
configuration.getText("doclet.Enum_Summary"),
enumTableSummary, enumTableHeader);
enumTableSummary, enumTableHeader, summaryContentTree);
}
}
/**
* Build the summary for the exceptions in this package.
*
* @param node the XML element that specifies which components to document
* @param summaryContentTree the summary tree to which the exception summary will
* be added
*/
public void buildExceptionSummary(XMLNode node) {
public void buildExceptionSummary(XMLNode node, Content summaryContentTree) {
String exceptionTableSummary =
configuration.getText("doclet.Member_Table_Summary",
configuration.getText("doclet.Exception_Summary"),
@ -281,17 +261,21 @@ public class PackageSummaryBuilder extends AbstractBuilder {
: configuration.classDocCatalog.exceptions(
Util.getPackageName(packageDoc));
if (exceptions.length > 0) {
packageWriter.writeClassesSummary(
packageWriter.addClassesSummary(
exceptions,
configuration.getText("doclet.Exception_Summary"),
exceptionTableSummary, exceptionTableHeader);
exceptionTableSummary, exceptionTableHeader, summaryContentTree);
}
}
/**
* Build the summary for the errors in this package.
*
* @param node the XML element that specifies which components to document
* @param summaryContentTree the summary tree to which the error summary will
* be added
*/
public void buildErrorSummary(XMLNode node) {
public void buildErrorSummary(XMLNode node, Content summaryContentTree) {
String errorTableSummary =
configuration.getText("doclet.Member_Table_Summary",
configuration.getText("doclet.Error_Summary"),
@ -306,17 +290,67 @@ public class PackageSummaryBuilder extends AbstractBuilder {
: configuration.classDocCatalog.errors(
Util.getPackageName(packageDoc));
if (errors.length > 0) {
packageWriter.writeClassesSummary(
packageWriter.addClassesSummary(
errors,
configuration.getText("doclet.Error_Summary"),
errorTableSummary, errorTableHeader);
errorTableSummary, errorTableHeader, summaryContentTree);
}
}
/**
* Build the footer of the summary.
* Build the summary for the annotation type in this package.
*
* @param node the XML element that specifies which components to document
* @param summaryContentTree the summary tree to which the annotation type
* summary will be added
*/
public void buildPackageFooter(XMLNode node) {
packageWriter.writePackageFooter();
public void buildAnnotationTypeSummary(XMLNode node, Content summaryContentTree) {
String annotationtypeTableSummary =
configuration.getText("doclet.Member_Table_Summary",
configuration.getText("doclet.Annotation_Types_Summary"),
configuration.getText("doclet.annotationtypes"));
String[] annotationtypeTableHeader = new String[] {
configuration.getText("doclet.AnnotationType"),
configuration.getText("doclet.Description")
};
ClassDoc[] annotationTypes =
packageDoc.isIncluded()
? packageDoc.annotationTypes()
: configuration.classDocCatalog.annotationTypes(
Util.getPackageName(packageDoc));
if (annotationTypes.length > 0) {
packageWriter.addClassesSummary(
annotationTypes,
configuration.getText("doclet.Annotation_Types_Summary"),
annotationtypeTableSummary, annotationtypeTableHeader,
summaryContentTree);
}
}
/**
* Build the description of the summary.
*
* @param node the XML element that specifies which components to document
* @param packageContentTree the tree to which the package description will
* be added
*/
public void buildPackageDescription(XMLNode node, Content packageContentTree) {
if (configuration.nocomment) {
return;
}
packageWriter.addPackageDescription(packageContentTree);
}
/**
* Build the tags of the summary.
*
* @param node the XML element that specifies which components to document
* @param packageContentTree the tree to which the package tags will be added
*/
public void buildPackageTags(XMLNode node, Content packageContentTree) {
if (configuration.nocomment) {
return;
}
packageWriter.addPackageTags(packageContentTree);
}
}

555
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/SerializedFormBuilder.java
View file

@ -27,7 +27,6 @@ package com.sun.tools.doclets.internal.toolkit.builders;
import java.io.*;
import java.util.*;
import com.sun.javadoc.*;
import com.sun.tools.doclets.internal.toolkit.util.*;
import com.sun.tools.doclets.internal.toolkit.*;
@ -87,6 +86,11 @@ public class SerializedFormBuilder extends AbstractBuilder {
*/
protected MemberDoc currentMember;
/**
* The content that will be added to the serialized form documentation tree.
*/
private Content contentTree;
private SerializedFormBuilder(Configuration configuration) {
super(configuration);
}
@ -117,7 +121,7 @@ public class SerializedFormBuilder extends AbstractBuilder {
} catch (Exception e) {
throw new DocletAbortException();
}
build(LayoutParser.getInstance(configuration).parseXML(NAME));
build(LayoutParser.getInstance(configuration).parseXML(NAME), contentTree);
writer.close();
}
@ -130,34 +134,44 @@ public class SerializedFormBuilder extends AbstractBuilder {
/**
* Build the serialized form.
*
* @param node the XML element that specifies which components to document
* @param serializedTree content tree to which the documentation will be added
*/
public void buildSerializedForm(XMLNode node) throws Exception {
buildChildren(node);
public void buildSerializedForm(XMLNode node, Content serializedTree) throws Exception {
serializedTree = writer.getHeader(configuration.getText(
"doclet.Serialized_Form"));
buildChildren(node, serializedTree);
writer.addFooter(serializedTree);
writer.printDocument(serializedTree);
writer.close();
}
/**
* Build the header.
* Build the serialized form summaries.
*
* @param node the XML element that specifies which components to document
* @param serializedTree content tree to which the documentation will be added
*/
public void buildHeader(XMLNode node) {
writer.writeHeader(configuration.getText("doclet.Serialized_Form"));
}
/**
* Build the contents.
*/
public void buildSerializedFormSummaries(XMLNode node) {
public void buildSerializedFormSummaries(XMLNode node, Content serializedTree) {
Content serializedSummariesTree = writer.getSerializedSummariesHeader();
PackageDoc[] packages = configuration.packages;
for (int i = 0; i < packages.length; i++) {
currentPackage = packages[i];
buildChildren(node);
buildChildren(node, serializedSummariesTree);
}
serializedTree.addContent(writer.getSerializedContent(
serializedSummariesTree));
}
/**
* Build the package serialized for for the current package being processed.
* Build the package serialized form for the current package being processed.
*
* @param node the XML element that specifies which components to document
* @param serializedSummariesTree content tree to which the documentation will be added
*/
public void buildPackageSerializedForm(XMLNode node) {
public void buildPackageSerializedForm(XMLNode node, Content serializedSummariesTree) {
Content packageSerializedTree = writer.getPackageSerializedHeader();
String foo = currentPackage.name();
ClassDoc[] classes = currentPackage.allClasses(false);
if (classes == null || classes.length == 0) {
@ -169,14 +183,29 @@ public class SerializedFormBuilder extends AbstractBuilder {
if (!serialClassFoundToDocument(classes)) {
return;
}
buildChildren(node);
buildChildren(node, packageSerializedTree);
serializedSummariesTree.addContent(packageSerializedTree);
}
public void buildPackageHeader(XMLNode node) {
writer.writePackageHeader(Util.getPackageName(currentPackage));
/**
* Build the package header.
*
* @param node the XML element that specifies which components to document
* @param packageSerializedTree content tree to which the documentation will be added
*/
public void buildPackageHeader(XMLNode node, Content packageSerializedTree) {
packageSerializedTree.addContent(writer.getPackageHeader(
Util.getPackageName(currentPackage)));
}
public void buildClassSerializedForm(XMLNode node) {
/**
* Build the class serialized form.
*
* @param node the XML element that specifies which components to document
* @param packageSerializedTree content tree to which the documentation will be added
*/
public void buildClassSerializedForm(XMLNode node, Content packageSerializedTree) {
Content classSerializedTree = writer.getClassSerializedHeader();
ClassDoc[] classes = currentPackage.allClasses(false);
Arrays.sort(classes);
for (int j = 0; j < classes.length; j++) {
@ -187,35 +216,293 @@ public class SerializedFormBuilder extends AbstractBuilder {
if(!serialClassInclude(currentClass)) {
continue;
}
buildChildren(node);
Content classTree = writer.getClassHeader(currentClass);
buildChildren(node, classTree);
classSerializedTree.addContent(classTree);
}
}
}
public void buildClassHeader(XMLNode node) {
writer.writeClassHeader(currentClass);
packageSerializedTree.addContent(classSerializedTree);
}
/**
* Build the serial UID information for the given class.
*
* @param node the XML element that specifies which components to document
* @param classTree content tree to which the serial UID information will be added
*/
public void buildSerialUIDInfo(XMLNode node) {
public void buildSerialUIDInfo(XMLNode node, Content classTree) {
Content serialUidTree = writer.getSerialUIDInfoHeader();
FieldDoc[] fields = currentClass.fields(false);
for (int i = 0; i < fields.length; i++) {
if (fields[i].name().equals("serialVersionUID") &&
fields[i].constantValueExpression() != null) {
writer.writeSerialUIDInfo(SERIAL_VERSION_UID_HEADER,
fields[i].constantValueExpression());
return;
writer.addSerialUIDInfo(SERIAL_VERSION_UID_HEADER,
fields[i].constantValueExpression(), serialUidTree);
break;
}
}
classTree.addContent(serialUidTree);
}
/**
* Build the summaries for the methods and fields.
*
* @param node the XML element that specifies which components to document
* @param classTree content tree to which the documentation will be added
*/
public void buildClassContent(XMLNode node, Content classTree) {
Content classContentTree = writer.getClassContentHeader();
buildChildren(node, classContentTree);
classTree.addContent(classContentTree);
}
/**
* Build the summaries for the methods that belong to the given
* class.
*
* @param node the XML element that specifies which components to document
* @param classContentTree content tree to which the documentation will be added
*/
public void buildSerializableMethods(XMLNode node, Content classContentTree) {
Content serializableMethodTree = methodWriter.getSerializableMethodsHeader();
MemberDoc[] members = currentClass.serializationMethods();
int membersLength = members.length;
if (membersLength > 0) {
for (int i = 0; i < membersLength; i++) {
currentMember = members[i];
Content methodsContentTree = methodWriter.getMethodsContentHeader(
(i == membersLength - 1));
buildChildren(node, methodsContentTree);
serializableMethodTree.addContent(methodsContentTree);
}
}
if (currentClass.serializationMethods().length > 0) {
classContentTree.addContent(methodWriter.getSerializableMethods(
configuration.getText("doclet.Serialized_Form_methods"),
serializableMethodTree));
if (currentClass.isSerializable() && !currentClass.isExternalizable()) {
if (currentClass.serializationMethods().length == 0) {
Content noCustomizationMsg = methodWriter.getNoCustomizationMsg(
configuration.getText(
"doclet.Serializable_no_customization"));
classContentTree.addContent(methodWriter.getSerializableMethods(
configuration.getText("doclet.Serialized_Form_methods"),
noCustomizationMsg));
}
}
}
}
/**
* Build the footer.
* Build the method sub header.
*
* @param node the XML element that specifies which components to document
* @param methodsContentTree content tree to which the documentation will be added
*/
public void buildFooter(XMLNode node) {
writer.writeFooter();
public void buildMethodSubHeader(XMLNode node, Content methodsContentTree) {
methodWriter.addMemberHeader((MethodDoc)currentMember, methodsContentTree);
}
/**
* Build the deprecated method description.
*
* @param node the XML element that specifies which components to document
* @param methodsContentTree content tree to which the documentation will be added
*/
public void buildDeprecatedMethodInfo(XMLNode node, Content methodsContentTree) {
methodWriter.addDeprecatedMemberInfo((MethodDoc) currentMember, methodsContentTree);
}
/**
* Build the information for the method.
*
* @param node the XML element that specifies which components to document
* @param methodsContentTree content tree to which the documentation will be added
*/
public void buildMethodInfo(XMLNode node, Content methodsContentTree) {
if(configuration.nocomment){
return;
}
buildChildren(node, methodsContentTree);
}
/**
* Build method description.
*
* @param node the XML element that specifies which components to document
* @param methodsContentTree content tree to which the documentation will be added
*/
public void buildMethodDescription(XMLNode node, Content methodsContentTree) {
methodWriter.addMemberDescription((MethodDoc) currentMember, methodsContentTree);
}
/**
* Build the method tags.
*
* @param node the XML element that specifies which components to document
* @param methodsContentTree content tree to which the documentation will be added
*/
public void buildMethodTags(XMLNode node, Content methodsContentTree) {
methodWriter.addMemberTags((MethodDoc) currentMember, methodsContentTree);
MethodDoc method = (MethodDoc)currentMember;
if (method.name().compareTo("writeExternal") == 0
&& method.tags("serialData").length == 0) {
if (configuration.serialwarn) {
configuration.getDocletSpecificMsg().warning(
currentMember.position(), "doclet.MissingSerialDataTag",
method.containingClass().qualifiedName(), method.name());
}
}
}
/**
* Build the field header.
*
* @param node the XML element that specifies which components to document
* @param classContentTree content tree to which the documentation will be added
*/
public void buildFieldHeader(XMLNode node, Content classContentTree) {
if (currentClass.serializableFields().length > 0) {
buildFieldSerializationOverview(currentClass, classContentTree);
}
}
/**
* Build the serialization overview for the given class.
*
* @param classDoc the class to print the overview for.
* @param classContentTree content tree to which the documentation will be added
*/
public void buildFieldSerializationOverview(ClassDoc classDoc, Content classContentTree) {
if (classDoc.definesSerializableFields()) {
FieldDoc serialPersistentField =
Util.asList(classDoc.serializableFields()).get(0);
// Check to see if there are inline comments, tags or deprecation
// information to be printed.
if (fieldWriter.shouldPrintOverview(serialPersistentField)) {
Content serializableFieldsTree = fieldWriter.getSerializableFieldsHeader();
Content fieldsOverviewContentTree = fieldWriter.getFieldsContentHeader(true);
fieldWriter.addMemberDeprecatedInfo(serialPersistentField,
fieldsOverviewContentTree);
if (!configuration.nocomment) {
fieldWriter.addMemberDescription(serialPersistentField,
fieldsOverviewContentTree);
fieldWriter.addMemberTags(serialPersistentField,
fieldsOverviewContentTree);
}
serializableFieldsTree.addContent(fieldsOverviewContentTree);
classContentTree.addContent(fieldWriter.getSerializableFields(
configuration.getText("doclet.Serialized_Form_class"),
serializableFieldsTree));
}
}
}
/**
* Build the summaries for the fields that belong to the given class.
*
* @param node the XML element that specifies which components to document
* @param classContentTree content tree to which the documentation will be added
*/
public void buildSerializableFields(XMLNode node, Content classContentTree) {
MemberDoc[] members = currentClass.serializableFields();
int membersLength = members.length;
if (membersLength > 0) {
Content serializableFieldsTree = fieldWriter.getSerializableFieldsHeader();
for (int i = 0; i < membersLength; i++) {
currentMember = members[i];
if (!currentClass.definesSerializableFields()) {
Content fieldsContentTree = fieldWriter.getFieldsContentHeader(
(i == membersLength - 1));
buildChildren(node, fieldsContentTree);
serializableFieldsTree.addContent(fieldsContentTree);
}
else {
buildSerialFieldTagsInfo(serializableFieldsTree);
}
}
classContentTree.addContent(fieldWriter.getSerializableFields(
configuration.getText("doclet.Serialized_Form_fields"),
serializableFieldsTree));
}
}
/**
* Build the field sub header.
*
* @param node the XML element that specifies which components to document
* @param fieldsContentTree content tree to which the documentation will be added
*/
public void buildFieldSubHeader(XMLNode node, Content fieldsContentTree) {
if (!currentClass.definesSerializableFields()) {
FieldDoc field = (FieldDoc) currentMember;
fieldWriter.addMemberHeader(field.type().asClassDoc(),
field.type().typeName(), field.type().dimension(), field.name(),
fieldsContentTree);
}
}
/**
* Build the field deprecation information.
*
* @param node the XML element that specifies which components to document
* @param fieldsContentTree content tree to which the documentation will be added
*/
public void buildFieldDeprecationInfo(XMLNode node, Content fieldsContentTree) {
if (!currentClass.definesSerializableFields()) {
FieldDoc field = (FieldDoc)currentMember;
fieldWriter.addMemberDeprecatedInfo(field, fieldsContentTree);
}
}
/**
* Build the serial field tags information.
*
* @param serializableFieldsTree content tree to which the documentation will be added
*/
public void buildSerialFieldTagsInfo(Content serializableFieldsTree) {
if(configuration.nocomment){
return;
}
FieldDoc field = (FieldDoc)currentMember;
// Process Serializable Fields specified as array of
// ObjectStreamFields. Print a member for each serialField tag.
// (There should be one serialField tag per ObjectStreamField
// element.)
SerialFieldTag[] tags = field.serialFieldTags();
Arrays.sort(tags);
int tagsLength = tags.length;
for (int i = 0; i < tagsLength; i++) {
Content fieldsContentTree = fieldWriter.getFieldsContentHeader(
(i == tagsLength - 1));
fieldWriter.addMemberHeader(tags[i].fieldTypeDoc(),
tags[i].fieldType(), "", tags[i].fieldName(), fieldsContentTree);
fieldWriter.addMemberDescription(tags[i], fieldsContentTree);
serializableFieldsTree.addContent(fieldsContentTree);
}
}
/**
* Build the field information.
*
* @param node the XML element that specifies which components to document
* @param fieldsContentTree content tree to which the documentation will be added
*/
public void buildFieldInfo(XMLNode node, Content fieldsContentTree) {
if(configuration.nocomment){
return;
}
FieldDoc field = (FieldDoc)currentMember;
ClassDoc cd = field.containingClass();
// Process default Serializable field.
if ((field.tags("serial").length == 0) && ! field.isSynthetic()
&& configuration.serialwarn) {
configuration.message.warning(field.position(),
"doclet.MissingSerialTag", cd.qualifiedName(),
field.name());
}
fieldWriter.addMemberDescription(field, fieldsContentTree);
fieldWriter.addMemberTags(field, fieldsContentTree);
}
/**
@ -297,208 +584,4 @@ public class SerializedFormBuilder extends AbstractBuilder {
}
return false;
}
/**
* Build the method header.
*/
public void buildMethodHeader(XMLNode node) {
if (currentClass.serializationMethods().length > 0) {
methodWriter.writeHeader(
configuration.getText("doclet.Serialized_Form_methods"));
if (currentClass.isSerializable() && !currentClass.isExternalizable()) {
if (currentClass.serializationMethods().length == 0) {
methodWriter.writeNoCustomizationMsg(
configuration.getText(
"doclet.Serializable_no_customization"));
}
}
}
}
/**
* Build the method sub header.
*/
public void buildMethodSubHeader(XMLNode node) {
methodWriter.writeMemberHeader((MethodDoc) currentMember);
}
/**
* Build the deprecated method description.
*/
public void buildDeprecatedMethodInfo(XMLNode node) {
methodWriter.writeDeprecatedMemberInfo((MethodDoc) currentMember);
}
/**
* Build method tags.
*/
public void buildMethodDescription(XMLNode node) {
methodWriter.writeMemberDescription((MethodDoc) currentMember);
}
/**
* Build the method tags.
*/
public void buildMethodTags(XMLNode node) {
methodWriter.writeMemberTags((MethodDoc) currentMember);
MethodDoc method = (MethodDoc)currentMember;
if (method.name().compareTo("writeExternal") == 0
&& method.tags("serialData").length == 0) {
if (configuration.serialwarn) {
configuration.getDocletSpecificMsg().warning(
currentMember.position(), "doclet.MissingSerialDataTag",
method.containingClass().qualifiedName(), method.name());
}
}
}
/**
* build the information for the method.
*/
public void buildMethodInfo(XMLNode node) {
if(configuration.nocomment){
return;
}
buildChildren(node);
}
/**
* Build the method footer.
*/
public void buildMethodFooter(XMLNode node) {
methodWriter.writeMemberFooter();
}
/**
* Build the field header.
*/
public void buildFieldHeader(XMLNode node) {
if (currentClass.serializableFields().length > 0) {
buildFieldSerializationOverview(currentClass);
fieldWriter.writeHeader(configuration.getText(
"doclet.Serialized_Form_fields"));
}
}
/**
* If possible, build the serialization overview for the given
* class.
*
* @param classDoc the class to print the overview for.
*/
public void buildFieldSerializationOverview(ClassDoc classDoc) {
if (classDoc.definesSerializableFields()) {
FieldDoc serialPersistentField =
Util.asList(classDoc.serializableFields()).get(0);
// Check to see if there are inline comments, tags or deprecation
// information to be printed.
if (fieldWriter.shouldPrintOverview(serialPersistentField)) {
fieldWriter.writeHeader(
configuration.getText("doclet.Serialized_Form_class"));
fieldWriter.writeMemberDeprecatedInfo(serialPersistentField);
if (!configuration.nocomment) {
fieldWriter.writeMemberDescription(serialPersistentField);
fieldWriter.writeMemberTags(serialPersistentField);
}
// Footer required to close the definition list tag
// for serialization overview.
fieldWriter.writeFooter(
configuration.getText("doclet.Serialized_Form_class"));
}
}
}
/**
* Build the field sub header.
*/
public void buildFieldSubHeader(XMLNode node) {
if (! currentClass.definesSerializableFields() ){
FieldDoc field = (FieldDoc) currentMember;
fieldWriter.writeMemberHeader(field.type().asClassDoc(),
field.type().typeName(), field.type().dimension(), field.name());
}
}
/**
* Build the field deprecation information.
*/
public void buildFieldDeprecationInfo(XMLNode node) {
if (!currentClass.definesSerializableFields()) {
FieldDoc field = (FieldDoc)currentMember;
fieldWriter.writeMemberDeprecatedInfo(field);
}
}
/**
* Build the field information.
*/
public void buildFieldInfo(XMLNode node) {
if(configuration.nocomment){
return;
}
FieldDoc field = (FieldDoc)currentMember;
ClassDoc cd = field.containingClass();
if (cd.definesSerializableFields()) {
// Process Serializable Fields specified as array of
// ObjectStreamFields. Print a member for each serialField tag.
// (There should be one serialField tag per ObjectStreamField
// element.)
SerialFieldTag[] tags = field.serialFieldTags();
Arrays.sort(tags);
for (int i = 0; i < tags.length; i++) {
fieldWriter.writeMemberHeader(tags[i].fieldTypeDoc(),
tags[i].fieldType(), "", tags[i].fieldName());
fieldWriter.writeMemberDescription(tags[i]);
}
} else {
// Process default Serializable field.
if ((field.tags("serial").length == 0) && ! field.isSynthetic()
&& configuration.serialwarn) {
configuration.message.warning(field.position(),
"doclet.MissingSerialTag", cd.qualifiedName(),
field.name());
}
fieldWriter.writeMemberDescription(field);
fieldWriter.writeMemberTags(field);
}
}
/**
* Build the field sub footer.
*/
public void buildFieldSubFooter(XMLNode node) {
if (! currentClass.definesSerializableFields()) {
fieldWriter.writeMemberFooter();
}
}
/**
* Build the summaries for the methods that belong to the given
* class.
*/
public void buildSerializableMethods(XMLNode node) {
MemberDoc[] members = currentClass.serializationMethods();
if (members.length > 0) {
for (int i = 0; i < members.length; i++) {
currentMember = members[i];
buildChildren(node);
}
}
}
/**
* Build the summaries for the fields that belong to the given
* class.
*/
public void buildSerializableFields(XMLNode node) {
MemberDoc[] members = currentClass.serializableFields();
if (members.length > 0) {
for (int i = 0; i < members.length; i++) {
currentMember = members[i];
buildChildren(node);
}
}
}
}

57
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/resources/doclet.xml
View file

@ -29,61 +29,55 @@
<Doclet>
<PackageDoc>
<PackageHeader/>
<Content>
<Summary>
<SummaryHeader/>
<InterfaceSummary/>
<ClassSummary/>
<EnumSummary/>
<ExceptionSummary/>
<ErrorSummary/>
<AnnotationTypeSummary/>
<SummaryFooter/>
</Summary>
<PackageDescription/>
<PackageTags/>
<PackageFooter/>
</Content>
</PackageDoc>
<AnnotationTypeDoc>
<AnnotationTypeHeader/>
<AnnotationTypeInfo>
<DeprecationInfo/>
<AnnotationTypeSignature/>
<AnnotationTypeDescription/>
<AnnotationTypeTagInfo/>
</AnnotationTypeInfo>
<MemberSummary>
<AnnotationTypeRequiredMemberSummary/>
<AnnotationTypeOptionalMemberSummary/>
</MemberSummary>
<AnnotationTypeMemberDetails>
<AnnotationTypeRequiredMemberDetails>
<Header/>
<AnnotationTypeRequiredMember>
<MemberHeader/>
<Signature/>
<DeprecationInfo/>
<MemberComments/>
<TagInfo/>
<MemberFooter/>
</AnnotationTypeRequiredMember>
</AnnotationTypeRequiredMemberDetails>
<AnnotationTypeOptionalMemberDetails>
<AnnotationTypeOptionalMember>
<MemberHeader/>
<Signature/>
<DeprecationInfo/>
<MemberComments/>
<TagInfo/>
<DefaultValueInfo/>
<MemberFooter/>
</AnnotationTypeOptionalMember>
<Footer/>
</AnnotationTypeOptionalMemberDetails>
<AnnotationTypeFooter/>
</AnnotationTypeMemberDetails>
</AnnotationTypeDoc>
<ClassDoc>
<ClassHeader/>
<ClassTree/>
<ClassInfo>
<TypeParamInfo/>
<SuperInterfacesInfo/>
<ImplementedInterfacesInfo/>
@ -95,92 +89,67 @@
<ClassSignature/>
<ClassDescription/>
<ClassTagInfo/>
</ClassInfo>
<MemberSummary>
<NestedClassesSummary/>
<NestedClassesInheritedSummary/>
<EnumConstantsSummary/>
<FieldsSummary/>
<FieldsInheritedSummary/>
<ConstructorsSummary/>
<MethodsSummary/>
<MethodsInheritedSummary/>
</MemberSummary>
<MemberDetails>
<EnumConstantsDetails>
<Header/>
<EnumConstant>
<EnumConstantHeader/>
<Signature/>
<DeprecationInfo/>
<EnumConstantComments/>
<TagInfo/>
<EnumConstantFooter/>
</EnumConstant>
<Footer/>
</EnumConstantsDetails>
<FieldDetails>
<Header/>
<FieldDoc>
<FieldHeader/>
<Signature/>
<DeprecationInfo/>
<FieldComments/>
<TagInfo/>
<FieldFooter/>
</FieldDoc>
<Footer/>
</FieldDetails>
<ConstructorDetails>
<Header/>
<ConstructorDoc>
<ConstructorHeader/>
<Signature/>
<DeprecationInfo/>
<ConstructorComments/>
<TagInfo/>
<ConstructorFooter/>
</ConstructorDoc>
<Footer/>
</ConstructorDetails>
<MethodDetails>
<Header/>
<MethodDoc>
<MethodHeader/>
<Signature/>
<DeprecationInfo/>
<MethodComments/>
<TagInfo/>
<MethodFooter/>
</MethodDoc>
<Footer/>
</MethodDetails>
<ClassFooter/>
</MemberDetails>
</ClassDoc>
<ConstantSummary>
<Header/>
<Contents/>
<ConstantSummaries>
<PackageConstantSummary>
<PackageHeader/>
<ClassConstantSummary>
<ClassHeader/>
<ConstantMembers/>
<ClassFooter/>
</ClassConstantSummary>
</PackageConstantSummary>
</ConstantSummaries>
<Footer/>
</ConstantSummary>
<SerializedForm>
<Header/>
<SerializedFormSummaries>
<PackageSerializedForm>
<PackageHeader/>
<ClassSerializedForm>
<ClassHeader/>
<SerialUIDInfo/>
<MethodHeader/>
<ClassContent>
<SerializableMethods>
<MethodSubHeader/>
<DeprecatedMethodInfo/>
@ -188,18 +157,16 @@
<MethodDescription/>
<MethodTags/>
</MethodInfo>
<MethodFooter/>
</SerializableMethods>
<FieldHeader/>
<SerializableFields>
<FieldSubHeader/>
<FieldDeprecationInfo/>
<FieldInfo/>
<FieldSubFooter/>
</SerializableFields>
</ClassContent>
</ClassSerializedForm>
</PackageSerializedForm>
</SerializedFormSummaries>
<Footer/>
</SerializedForm>
</Doclet>

21
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/resources/doclets.properties
View file

@ -111,12 +111,12 @@ doclet.extended_by=extended by
doclet.extends=extends
doclet.Package_private=(package private)
doclet.implements=implementsdoclet.Same_package_name_used=Package name format used twice: {0}
doclet.Nested_Classes_Interfaces_Inherited_From_Class=Nested classes/interfaces inherited from class {0}
doclet.Nested_Classes_Interface_Inherited_From_Interface=Nested classes/interfaces inherited from interface {0}
doclet.Methods_Inherited_From_Class=Methods inherited from class {0}
doclet.Methods_Inherited_From_Interface=Methods inherited from interface {0}
doclet.Fields_Inherited_From_Class=Fields inherited from class {0}
doclet.Fields_Inherited_From_Interface=Fields inherited from interface {0}
doclet.Nested_Classes_Interfaces_Inherited_From_Class=Nested classes/interfaces inherited from class
doclet.Nested_Classes_Interface_Inherited_From_Interface=Nested classes/interfaces inherited from interface
doclet.Methods_Inherited_From_Class=Methods inherited from class
doclet.Methods_Inherited_From_Interface=Methods inherited from interface
doclet.Fields_Inherited_From_Class=Fields inherited from class
doclet.Fields_Inherited_From_Interface=Fields inherited from interface
doclet.Serializable=Serializable
doclet.Externalizable=Externalizable
doclet.Annotation_Type_Member_Detail=Element Detail
@ -136,12 +136,19 @@ doclet.Use_Table_Summary=Use table, listing {0}, and an explanation
doclet.Constants_Table_Summary={0} table, listing constant fields, and values
doclet.Member_Table_Summary={0} table, listing {1}, and an explanation
doclet.fields=fields
doclet.Fields=Fields
doclet.constructors=constructors
doclet.Constructors=Constructors
doclet.methods=methods
doclet.Methods=Methods
doclet.annotation_type_optional_members=optional elements
doclet.Annotation_Type_Optional_Members=Optional Elements
doclet.annotation_type_required_members=required elements
doclet.Annotation_Type_Required_Members=Required Elements
doclet.enum_constants=enum constants
doclet.Enum_Constants=Enum Constants
doclet.nested_classes=nested classes
doclet.Nested_Classes=Nested Classes
doclet.subclasses=subclasses
doclet.subinterfaces=subinterfaces
doclet.Modifier=Modifier
@ -173,7 +180,7 @@ doclet.enum_values_doc=\n\
doclet.enum_valueof_doc=\n\
Returns the enum constant of this type with the specified name.\n\
The string must match <I>exactly</I> an identifier used to declare an\n\
The string must match <i>exactly</i> an identifier used to declare an\n\
enum constant in this type. (Extraneous whitespace characters are \n\
not permitted.)\n\
\n\

439
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/resources/stylesheet.css Normal file
View file

@ -0,0 +1,439 @@
/* Javadoc style sheet */
/*
Overall document style
*/
* {
margin:0;
padding:0;
}
body {
font-family:Helvetica, Arial, sans-serif;
color:#000000;
}
p {
margin:20px 0;
}
pre {
font-size:1.0em;
}
h1 {
font-size:1.4em;
}
h2 {
font-size:1.35em;
}
h3 {
font-size:1.3em;
}
h4 {
font-size:1.25em;
}
ul {
margin:10px 0 10px 20px;
}
li {
list-style:disc;
}
dl dt {
font-size:0.95em;
font-weight:bold;
margin:10px 0 0 0;
}
dl dd {
margin:10px 0 10px 20px;
}
dl dd ul {
margin-left:0;
}
dl dd ul li {
list-style:none;
margin:10px 0 10px 0;
}
caption {
background: #CCCCFF;
color:#000000;
text-align: left;
font-size: 150%;
font-weight: bold;
border-left: 2px ridge;
border-right: 2px ridge;
border-top: 2px ridge;
padding-left: 5px;
width:auto;
}
/*
Document title and Copyright styles
*/
.aboutLanguage {
float:right;
font-size:0.9em;
color:#000000;
}
.legalCopy {
margin:7px;
}
.bar {
font-size:1em;
margin:10px 0 0 10px;
}
.bar a {
font-weight:normal;
}
/*
Navigation bar styles
*/
.topNav {
border-top:2px solid #C0C0C0;
margin:7px;
padding:7px 0;
height:2.8em;
width:99%;
min-width:600px;
}
.bottomNav {
border-top:2px solid #C0C0C0;
margin:7px;
padding:7px 0;
height:2.8em;
width:99%;
}
.subNav {
border-bottom:2px solid #C0C0C0;
float:left;
width:99%;
margin:7px;
min-width:600px;
}
.subNav div {
clear:left;
float:left;
padding:0 0 5px 2px;
width:100%;
}
.topNav a:link,.topNav a:active, .topNav a:visited, .topNav a:hover,
.bottomNav a:link,.bottomNav a:active, .bottomNav a:visited, .bottomNav a:hover {
color:#000000;
font-weight:bold;
text-decoration:underline;
font-size:1em;
}
/* Navigation bar list styles */
.topNav ul.navList, .bottomNav ul.navList {
background-color:#EEEEFF;
padding:7px 5px;
margin:0;
float:left;
width:80%;
}
ul.navList li{
list-style:none;
float:left;
padding:3px 4px;
color:#000000;
font-size:0.98em;
}
ul.navList li.navBarCell1Rev {
background-color:#00008B;
color:#FFFFFF;
font-weight:bold;
font-size:0.97em;
}
/* Sub-navigation bar list styles */
.subNav ul.navList {
float:left;
margin:0;
font-size:0.7em;
width:350px;
}
ul.subNavList {
float:left;
margin:0;
font-size:0.7em;
width:350px;
}
ul.subNavList li{
list-style:none;
float:left;
font-size:90%;
}
/*
Page header and footer styles
*/
.header, .footer {
clear:both;
margin:0 7px;
}
.indexHeader {
font-size:0.9em;
margin:10px 0 7px 10px;
}
.header ul {
padding-left:20px;
}
/* Header and footer title styles */
.header h1.title {
font-size:1.4em;
text-align:center;
margin:0;
}
.header h2.title {
font-size:1.35em;
margin:0;
}
.subTitle {
margin:0;
padding-top:10px;
font-size:0.75em;
font-weight:bold;
}
/*
Page layout container styles
*/
.contentContainer, .sourceContainer, .classUseContainer, .serializedFormContainer,
.constantValuesContainer {
clear:both;
padding:10px 10px;
position:relative;
}
.indexContainer {
padding:0 0 10px 10px;
font-size:0.9em;
}
/*
Class inheritance information styles
*/
ul.inheritance {
margin:0;
padding:0;
}
ul.inheritance li {
display:inline;
list-style:none;
}
ul.inheritance li ul.inheritance {
margin-left:15px;
background-image:url(resources/inherit.gif);
background-repeat:no-repeat;
padding-left:15px;
padding-top:1px;
}
/*
Heading styles
*/
.indexContainer h2 {
font-weight:normal;
font-size:1.0em;
padding:10px 0 0 0;
}
.contentContainer h2 {
margin:10px 0;
}
.constantValuesContainer h2 {
background:#CCCCFF;
border:2px ridge;
padding:3px;
margin:0 0 10px 0;
}
.serializedFormContainer ul.blockList li.blockList h2 {
background:#EEEEFF;
border:2px ridge;
padding:3px;
margin:0 0 15px 0;
text-align:center;
}
.classUseContainer ul li ul li h3 {
margin-bottom:30px;
padding:3px;
}
.serializedFormContainer ul.blockList li.blockList ul.blockList li.blockList h3 {
background:#EEEEFF;
margin:0 0 15px 0;
padding:3px;
}
.serializedFormContainer ul.blockList li.blockList ul.blockList li.blockList ul.blockList li.blockList h3 {
background:#CCCCFF;
margin:0 0 15px 0;
padding:3px;
border:2px ridge;
}
ul.blockList ul.blockList li.blockList h3, ul.blockList ul.blockList li.blockList h3 {
background:#CCCCFF;
border:2px ridge;
padding-left:5px;
}
div.summary ul.blockList ul.blockList li.blockList h3 {
background:#CCCCFF;
border:0;
border:2px ridge;
padding-left:5px;
}
div.summary ul.blockList ul.blockList ul.blockList li.blockList h3 {
background:#EEEEFF;
border:0;
border-bottom:2px ridge;
}
div.details ul.blockList ul.blockList ul.blockList li.blockList h4,
div.details ul.blockList ul.blockList ul.blockListLast li.blockList h4 {
font-size:1.15em;
font-weight:bold;
padding:0 0 10px 0;
}
/*
Table styles
*/
.contentContainer table {
border-collapse: collapse ;
width:100%;
}
.contentContainer table td, .contentContainer table th {
border:2px ridge;
padding:3px;
}
/* Constant values page table styles */
.constantValuesContainer table {
border-collapse: collapse ;
margin:0 0 10px 0;
}
.constantValuesContainer table caption{
font-size:0.95em;
padding:3px;
background:#EEEEFF;
}
.constantValuesContainer table td, .constantValuesContainer table th {
border:2px ridge;
padding:3px;
}
/* Class-use/Package-use page table styles */
.classUseContainer table {
border-collapse: collapse ;
width:100%;
margin:0 0 15px 0;
}
.classUseContainer ul li ul li table {
margin-bottom:30px;
}
.classUseContainer ul li ul li table caption{
font-size:0.95em;
padding:3px;
background:#EEEEFF;
}
.classUseContainer table td, .classUseContainer table th {
border:2px ridge;
padding:3px;
}
/* Summary table styles */
ul.blockList li.blockList table.overviewSummary {
margin:0;
margin-bottom:15px;
}
ul.blockList li.blockList table caption {
padding:3px;
}
ul.blockList li.blockList table.overviewSummary td.colFirst{
text-align:right;
}
table.packageSummary td.colFirst, table.overviewSummary th.colFirst {
width:15%;
}
div.summary ul.blockList ul.blockList li.blockList caption {
display:none;
}
div.summary ul.blockList li.blockList ul.blockList li.blockList table.overviewSummary th {
border-top:0;
}
/* Table column block styles */
ul.blockList li.blockList table.overviewSummary td.colLast div.block{
padding:0;
padding-left:40px;
}
ul.blockList li.blockList table.overviewSummary td.colOne div.block{
padding:0;
padding-left:40px;
}
.contentContainer ul.blockList li.blockList table .colOne div.block{
padding-left:40px;
}
.classUseContainer ul li ul li table .colLast div.block,
.classUseContainer ul li ul li table .colOne div.block{
padding-left:40px;
}
/*
List styles
*/
ul.horizontal li {
display:inline;
font-size:0.9em;
}
/* Container specific list styles */
.indexContainer ul {
margin:0;
}
.indexContainer ul li {
list-style:none;
}
.serializedFormContainer ul.blockList li.blockList ul.blockList li.blockList ul.blockList li.blockList {
border:0;
}
.serializedFormContainer ul.blockList li.blockList ul.blockList li.blockList ul.blockList li.blockList ul.blockList li.blockList {
list-style:none;
border:0;
border-bottom:2px ridge;
}
.serializedFormContainer ul.blockList li.blockList ul.blockList li.blockList ul.blockList li.blockList ul.blockList li.blockListLast {
list-style:none;
}
/* General list styles */
ul.blockList, ul.blockListLast {
margin-left:0;
padding-left:0;
}
ul.blockList li.blockList, ul.blockListLast li.blockList {
list-style:none;
margin-bottom:25px;
}
ul.blockList ul.blockList ul.blockList li.blockList {
border:2px ridge;
}
div.details ul.blockList ul.blockList ul.blockList li.blockList {
border:0;
border-bottom:2px ridge;
}
/* Definition list styles */
ul.blockList li.blockList dl{
margin-bottom:15px;
}
ul.blockList li.blockList dl dd{
margin:0 0 0 30px;
}
ul.blockList li.blockList ul.blockList li.blockList ul.blockList li.blockList dl,
ul.blockList li.blockList ul.blockList li.blockList ul.blockListLast li.blockList dl{
padding:0 0 10px 35px;
}
dl.nameValue dt, dl.nameValue dd{
display:inline;
}
ul.blockList li.blockList pre{
margin:0 0 15px 0;
}
/* List content styles */
ul.blockList li.blockList ul.blockList li.blockList pre{
margin:10px 0 15px 0;
}
ul.blockList li.blockList ul.blockList li.blockList ul.blockList li.blockList pre,
ul.blockList li.blockList ul.blockList li.blockList ul.blockListLast li.blockList pre{
padding:0 0 10px 0;
}
ul.blockList li.blockList ul.blockList li.blockList ul.blockList li.blockList div.block,
ul.blockList li.blockList ul.blockList li.blockList ul.blockListLast li.blockList div.block{
padding:0 0 10px 35px;
}
/*
Formatting effect styles
*/
.strong {
font-weight:bold;
}
.sourceLineNo {
color:green;
padding:0 30px 0 0;
}

18
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/util/DirectoryManager.java
View file

@ -46,7 +46,7 @@ public class DirectoryManager {
/**
* The file separator string, "/", used in the formation of the URL path.
*/
public static final String URL_FILE_SEPERATOR = "/";
public static final String URL_FILE_SEPARATOR = "/";
/**
* Never instaniated.
@ -123,13 +123,13 @@ public class DirectoryManager {
for (int i = 0; i < packageName.length(); i++) {
char ch = packageName.charAt(i);
if (ch == '.') {
pathstr.append(URL_FILE_SEPERATOR);
pathstr.append(URL_FILE_SEPARATOR);
} else {
pathstr.append(ch);
}
}
if (pathstr.length() > 0 && ! pathstr.toString().endsWith(URL_FILE_SEPERATOR)) {
pathstr.append(URL_FILE_SEPERATOR);
if (pathstr.length() > 0 && ! pathstr.toString().endsWith(URL_FILE_SEPARATOR)) {
pathstr.append(URL_FILE_SEPARATOR);
}
return pathstr.toString();
}
@ -155,7 +155,7 @@ public class DirectoryManager {
for (int i = 0; i < name.length(); i++) {
char ch = name.charAt(i);
if (ch == '.') {
pathstr.append(URL_FILE_SEPERATOR);
pathstr.append(URL_FILE_SEPARATOR);
} else {
pathstr.append(ch);
}
@ -184,7 +184,7 @@ public class DirectoryManager {
StringBuffer pathstr = new StringBuffer();
pathstr.append(getRelativePath(from));
pathstr.append(getPath(to));
pathstr.append(URL_FILE_SEPERATOR);
pathstr.append(URL_FILE_SEPARATOR);
return pathstr.toString();
}
@ -226,10 +226,10 @@ public class DirectoryManager {
for (int i = 0; i < from.length(); i++) {
char ch = from.charAt(i);
if (ch == '.') {
pathstr.append(".." + URL_FILE_SEPERATOR);
pathstr.append(".." + URL_FILE_SEPARATOR);
}
}
pathstr.append(".." + URL_FILE_SEPERATOR);
pathstr.append(".." + URL_FILE_SEPARATOR);
return pathstr.toString();
}
@ -297,7 +297,7 @@ public class DirectoryManager {
String pathstr = createPathString(pd);
if (pathstr.length() > 0) {
buf.append(pathstr);
buf.append(URL_FILE_SEPERATOR);
buf.append(URL_FILE_SEPARATOR);
}
buf.append(filename);
return buf.toString();

70
langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/util/Util.java
View file

@ -50,6 +50,11 @@ public class Util {
public static final String[][] HTML_ESCAPE_CHARS =
{{"&", "&amp;"}, {"<", "&lt;"}, {">", "&gt;"}};
/**
* Name of the resource directory.
*/
public static final String RESOURCESDIR = "resources";
/**
* Return array of class members whose documentation is to be generated.
* If the member is deprecated do not include such a member in the
@ -236,8 +241,8 @@ public class Util {
String destname = configuration.docFileDestDirName;
File srcdir = new File(path + dir);
if (destname.length() > 0 && !destname.endsWith(
DirectoryManager.URL_FILE_SEPERATOR)) {
destname += DirectoryManager.URL_FILE_SEPERATOR;
DirectoryManager.URL_FILE_SEPARATOR)) {
destname += DirectoryManager.URL_FILE_SEPARATOR;
}
String dest = destname + dir;
try {
@ -263,7 +268,7 @@ public class Util {
&& ! configuration.shouldExcludeDocFileDir(
srcfile.getName())){
copyDocFiles(configuration, path, dir +
DirectoryManager.URL_FILE_SEPERATOR + srcfile.getName(),
DirectoryManager.URL_FILE_SEPARATOR + srcfile.getName(),
overwrite);
}
}
@ -322,25 +327,38 @@ public class Util {
* it already exists.
*/
public static void copyResourceFile(Configuration configuration,
String resourcefile,
boolean overwrite) {
String destdir = configuration.destDirName;
String destresourcesdir = destdir + "resources";
DirectoryManager.createDirectory(configuration, destresourcesdir);
File destfile = new File(destresourcesdir, resourcefile);
String resourcefile, boolean overwrite) {
String destresourcesdir = configuration.destDirName + RESOURCESDIR;
copyFile(configuration, resourcefile, RESOURCESDIR, destresourcesdir,
overwrite);
}
/**
* Copy a file from a source directory to a destination directory
* (if it is not there already). If <code>overwrite</code> is true and
* the destination file already exists, overwrite it.
*
* @param configuration Holds the error message
* @param file The name of the file to copy
* @param source The source directory
* @param destination The destination directory where the file needs to be copied
* @param overwrite A flag to indicate whether the file in the
* destination directory will be overwritten if
* it already exists.
*/
public static void copyFile(Configuration configuration, String file, String source,
String destination, boolean overwrite) {
DirectoryManager.createDirectory(configuration, destination);
File destfile = new File(destination, file);
if(destfile.exists() && (! overwrite)) return;
try {
InputStream in = Configuration.class.getResourceAsStream(
"resources/" + resourcefile);
source + DirectoryManager.URL_FILE_SEPARATOR + file);
if(in==null) return;
OutputStream out = new FileOutputStream(destfile);
byte[] buf = new byte[2048];
int n;
while((n = in.read(buf))>0) out.write(buf,0,n);
in.close();
out.close();
} catch(Throwable t) {}
@ -357,12 +375,12 @@ public class Util {
try{
String pkgPath = DirectoryManager.getDirectoryPath(pkgDoc);
String completePath = new SourcePath(configuration.sourcepath).
getDirectory(pkgPath) + DirectoryManager.URL_FILE_SEPERATOR;
getDirectory(pkgPath) + DirectoryManager.URL_FILE_SEPARATOR;
//Make sure that both paths are using the same seperators.
completePath = Util.replaceText(completePath, File.separator,
DirectoryManager.URL_FILE_SEPERATOR);
DirectoryManager.URL_FILE_SEPARATOR);
pkgPath = Util.replaceText(pkgPath, File.separator,
DirectoryManager.URL_FILE_SEPERATOR);
DirectoryManager.URL_FILE_SEPARATOR);
return completePath.substring(0, completePath.indexOf(pkgPath));
} catch (Exception e){
return "";
@ -571,6 +589,24 @@ public class Util {
return result;
}
/**
* Given a string, strips all html characters and
* return the result.
*
* @param rawString The string to check.
* @return the original string with all of the HTML characters
* stripped.
*
*/
public static String stripHtml(String rawString) {
// remove HTML tags
rawString = rawString.replaceAll("\\<.*?>", " ");
// consolidate multiple spaces between a word to a single space
rawString = rawString.replaceAll("\\b\\s{2,}\\b", " ");
// remove extra whitespaces
return rawString.trim();
}
/**
* Create the directory path for the file to be generated, construct
* FileOutputStream and OutputStreamWriter depending upon docencoding.

6
langtools/test/com/sun/javadoc/AccessAsciiArt/AccessAsciiArt.java
View file

@ -84,17 +84,17 @@ public class AccessAsciiArt {
// Test the top line of the class tree
{
" <IMG SRC=\"../../resources/inherit.gif\" ALT=\"extended by \"><A HREF=\"../../p1/C.html\" title=\"class in p1\">p1.C</A>",
"<li><a href=\"../../p1/C.html\" title=\"class in p1\">p1.C</a></li>",
TMPDEST_DIR1 + "p1" + FS + "subpkg" + FS + "SSC.html" },
// Test the second line of the class tree
{
" <IMG SRC=\"../../resources/inherit.gif\" ALT=\"extended by \"><A HREF=\"../../p1/SC.html\" title=\"class in p1\">p1.SC</A>",
"<li><a href=\"../../p1/SC.html\" title=\"class in p1\">p1.SC</a></li>",
TMPDEST_DIR1 + "p1" + FS + "subpkg" + FS + "SSC.html" },
// Test the third line of the class tree
{
" <IMG SRC=\"../../resources/inherit.gif\" ALT=\"extended by \"><STRONG>p1.subpkg.SSC</STRONG>",
"<li>p1.subpkg.SSC</li>",
TMPDEST_DIR1 + "p1" + FS + "subpkg" + FS +"SSC.html" },
};

15
langtools/test/com/sun/javadoc/AccessH1/AccessH1.java
View file

@ -83,17 +83,18 @@ public class AccessH1 {
* NOTE: The standard doclet uses the same separator "\n" for all OS's
*/
private static final String[][] testArray = {
// Test the style sheet
{
"h1 { font-size: 145% }",
TMPDEST_DIR1 + "stylesheet.css" },
".header h1.title {" + LS + " font-size:1.4em;" + LS +
" text-align:center;" + LS + " margin:0;" + LS +
"}",
TMPDEST_DIR1 + "stylesheet.css"
},
// Test the doc title in the overview page
{
"<H1>" + LS + "Document Title" + LS + "</H1>",
TMPDEST_DIR1 + "overview-summary.html" }
"<h1 class=\"title\">Document Title</h1>",
TMPDEST_DIR1 + "overview-summary.html"
}
};
public static void runTestsOnHTML(String[][] testArray) {

19
langtools/test/com/sun/javadoc/AccessSkipNav/AccessSkipNav.java
View file

@ -46,6 +46,7 @@ public class AccessSkipNav {
private static final String BUGNAME = "AccessSkipNav";
private static final String FS = System.getProperty("file.separator");
private static final String PS = System.getProperty("path.separator");
private static final String LS = System.getProperty("line.separator");
private static final String TMPDEST_DIR1 = "." + FS + "docs1" + FS;
private static final String TMPDEST_DIR2 = "." + FS + "docs2" + FS;
@ -84,20 +85,22 @@ public class AccessSkipNav {
// Testing only for the presence of the <a href> and <a name>
// Top navbar <A HREF>
{ "<A HREF=\"#skip-navbar_top\" title=\"Skip navigation links\"></A>",
// Top navbar <a href>
{ "<a href=\"#skip-navbar_top\" title=\"Skip navigation links\"></a>",
TMPDEST_DIR1 + "p1" + FS + "C1.html" },
// Top navbar <A NAME>
{ "<A NAME=\"skip-navbar_top\"></A>",
// Top navbar <a name>
{ "<a name=\"skip-navbar_top\">" + LS +
"<!-- -->" + LS + "</a>",
TMPDEST_DIR1 + "p1" + FS + "C1.html" },
// Bottom navbar <A HREF>
{ "<A HREF=\"#skip-navbar_bottom\" title=\"Skip navigation links\"></A>",
// Bottom navbar <a href>
{ "<a href=\"#skip-navbar_bottom\" title=\"Skip navigation links\"></a>",
TMPDEST_DIR1 + "p1" + FS + "C1.html" },
// Bottom navbar <A NAME>
{ "<A NAME=\"skip-navbar_bottom\"></A>",
// Bottom navbar <a name>
{ "<a name=\"skip-navbar_bottom\">" + LS +
"<!-- -->" + LS + "</a>",
TMPDEST_DIR1 + "p1" + FS + "C1.html" }
};

8
langtools/test/com/sun/javadoc/AccessSummary/AccessSummary.java
View file

@ -24,7 +24,7 @@
/*
* @test
* @bug 4637604 4775148
* @summary Test the tables for summary=""
* @summary Test the tables for summary attribute
* @author dkramer
* @library ../lib/
* @build JavadocTester
@ -44,15 +44,15 @@ public class AccessSummary extends JavadocTester {
// Test that the summary attribute appears
{ OUTPUT_DIR1 + "overview-summary.html",
"SUMMARY=\"\"" },
"summary=\"Packages table, listing packages, and an explanation\"" },
// Test that the summary attribute appears
{ OUTPUT_DIR1 + "p1" + FS + "C1.html",
"SUMMARY=\"\"" },
"summary=\"Constructor Summary table, listing constructors, and an explanation\"" },
// Test that the summary attribute appears
{ OUTPUT_DIR1 + "constant-values.html",
"SUMMARY=\"\"" }
"summary=\"Constant Field Values table, listing constant fields, and values\"" }
};
// First test with -header only

4
langtools/test/com/sun/javadoc/AuthorDD/AuthorDD.java
View file

@ -86,12 +86,12 @@ public class AuthorDD
// Test single @since tag:
{ "<DT><STRONG>Since:</STRONG></DT>"+NL+" <DD>JDK 1.0</DD>",
{ "<dt><span class=\"strong\">Since:</span></dt>"+NL+" <dd>JDK 1.0</dd>",
BUGID + FS + "p1" + FS + "C1.html" },
// Test multiple @author tags:
{ "<DT><STRONG>Author:</STRONG></DT>"+NL+" <DD>Doug Kramer, Jamie, Neal</DD>",
{ "<dt><span class=\"strong\">Author:</span></dt>"+NL+" <dd>Doug Kramer, Jamie, Neal</dd>",
BUGID + FS + "p1" + FS + "C1.html" },
};

32
langtools/test/com/sun/javadoc/JavascriptWinTitle/JavascriptWinTitle.java
View file

@ -90,44 +90,34 @@ public class JavascriptWinTitle {
private static final String[][] testArray = {
// Test the javascript "type" attribute is present:
{ "<SCRIPT type=\"text/javascript\">",
{ "<script type=\"text/javascript\">",
TMPDEST_DIR1 + "overview-summary.html" },
// Test onload is absent:
{ "<body>",
TMPDEST_DIR1 + "overview-summary.html" },
// Test onload is present:
{ "onload=\"windowTitle();\"",
TMPDEST_DIR1 + "overview-summary.html" },
// Test onload is present:
{ "onload=\"windowTitle();\"",
{ "<body>",
TMPDEST_DIR1 + FS + "p1" + FS + "package-summary.html" },
// Test onload is present:
{ "onload=\"windowTitle();\"",
TMPDEST_DIR1 + FS + "p1" + FS + "C.html" },
// Test that "onload" is not present in BODY tag:
{ "<BODY BGCOLOR=\"white\">",
{ "<body>",
TMPDEST_DIR1 + "overview-frame.html" },
// Test that "onload" is not present in BODY tag:
{ "<BODY BGCOLOR=\"white\">",
{ "<body>",
TMPDEST_DIR1 + "allclasses-frame.html" },
// Test that "onload" is not present in BODY tag:
{ "<BODY BGCOLOR=\"white\">",
{ "<body>",
TMPDEST_DIR1 + FS + "p1" + FS + "package-frame.html" },
// Test that win title javascript is followed by NOSCRIPT code.
{"<SCRIPT type=\"text/javascript\">" + LS +
"function windowTitle()" + LS +
"{" + LS +
{"<script type=\"text/javascript\"><!--" + LS +
" if (location.href.indexOf('is-external=true') == -1) {" + LS +
" parent.document.title=\"C (Window Title)\";" + LS +
" }" + LS +
"}" + LS +
"</SCRIPT>" + LS +
"<NOSCRIPT>" + LS +
"</NOSCRIPT>",
" }" + LS + "//-->" + LS + "</script>",
TMPDEST_DIR1 + FS + "p1" + FS + "C.html"
}

18
langtools/test/com/sun/javadoc/MetaTag/MetaTag.java
View file

@ -67,31 +67,31 @@ public class MetaTag extends JavadocTester {
private static final String[][] TEST = {
{ OUTPUT_DIR + FS + "p1" + FS + "C1.html",
"<META NAME=\"keywords\" CONTENT=\"p1.C1 class\">" },
"<meta name=\"keywords\" content=\"p1.C1 class\">" },
{ OUTPUT_DIR + FS + "p1" + FS + "C1.html",
"<META NAME=\"keywords\" CONTENT=\"field1\">" },
"<meta name=\"keywords\" content=\"field1\">" },
{ OUTPUT_DIR + FS + "p1" + FS + "C1.html",
"<META NAME=\"keywords\" CONTENT=\"field2\">" },
"<meta name=\"keywords\" content=\"field2\">" },
{ OUTPUT_DIR + FS + "p1" + FS + "C1.html",
"<META NAME=\"keywords\" CONTENT=\"method1()\">" },
"<meta name=\"keywords\" content=\"method1()\">" },
{ OUTPUT_DIR + FS + "p1" + FS + "C1.html",
"<META NAME=\"keywords\" CONTENT=\"method2()\">" },
"<meta name=\"keywords\" content=\"method2()\">" },
{ OUTPUT_DIR + FS + "p1" + FS + "package-summary.html",
"<META NAME=\"keywords\" CONTENT=\"p1 package\">" },
"<meta name=\"keywords\" content=\"p1 package\">" },
{ OUTPUT_DIR + FS + "overview-summary.html",
"<META NAME=\"keywords\" CONTENT=\"Overview, Sample Packages\">" },
"<meta name=\"keywords\" content=\"Overview, Sample Packages\">" },
//NOTE: Hopefully, this regression test is not run at midnight. If the output
//was generated yesterday and this test is run today, the test will fail.
{OUTPUT_DIR + FS + "overview-summary.html",
"<META NAME=\"date\" "
+ "CONTENT=\"" + m_dateFormat.format(new Date()) + "\">"},
"<meta name=\"date\" "
+ "content=\"" + m_dateFormat.format(new Date()) + "\">"},
};
private static final String[][] NEGATED_TEST = NO_TEST;

54
langtools/test/com/sun/javadoc/ValidHtml/ValidHtml.java
View file

@ -33,12 +33,10 @@
* @run main ValidHtml
*/
import com.sun.javadoc.*;
import java.util.*;
import java.io.*;
/**
* Runs javadoc and runs regression tests on the resulting HTML.
* It reads each file, complete with newlines, into a string to easily
@ -72,7 +70,8 @@ public class ValidHtml {
"-use",
"-overview", (srcdir + FS + "overview.html"),
"-sourcepath", srcdir,
"p1", "p2"});
"p1", "p2"
});
runTestsOnHTML(testArray);
printSummary();
@ -90,52 +89,51 @@ public class ValidHtml {
* NOTE: The standard doclet uses the same separator "\n" for all OS's
*/
private static final String[][] testArray = {
// Test the proper DOCTYPE element is present:
{
"<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Frameset//EN\" \"http://www.w3.org/TR/html4/frameset.dtd\">",
TMPDEST_DIR1 + "index.html" },
TMPDEST_DIR1 + "index.html"
},
// Test the proper DOCTYPE element is present:
{
"<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">",
TMPDEST_DIR1 + "overview-summary.html" },
TMPDEST_DIR1 + "overview-summary.html"
},
// Test the proper DOCTYPE element is present:
{
"<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">",
TMPDEST_DIR1 + "p1" + FS + "package-summary.html" },
TMPDEST_DIR1 + "p1" + FS + "package-summary.html"
},
// Test the proper DOCTYPE element is present:
{
"<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">",
TMPDEST_DIR1 + "p1" + FS + "C.html" },
TMPDEST_DIR1 + "p1" + FS + "C.html"
},
// Test the proper DOCTYPE element is present:
{
"<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">",
TMPDEST_DIR1 + "overview-frame.html" },
TMPDEST_DIR1 + "overview-frame.html"
},
// Test the proper DOCTYPE element is present:
{
"<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">",
TMPDEST_DIR1 + "allclasses-frame.html" },
TMPDEST_DIR1 + "allclasses-frame.html"
},
// Test the proper DOCTYPE element is present:
{
"<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">",
TMPDEST_DIR1 + "p1" + FS + "package-frame.html" },
TMPDEST_DIR1 + "p1" + FS + "package-frame.html"
},
// Test that <NOFRAMES> is inside <FRAMESET> element:
{
"</NOFRAMES>" + LS + "</FRAMESET>",
TMPDEST_DIR1 + "index.html" },
"</noframes>" + LS + "</frameset>",
TMPDEST_DIR1 + "index.html"
},
// Test the table elements are in the correct order:
{
"</FONT></TD>" + LS + "</TR>",
TMPDEST_DIR1 + FS + "p1" + FS + "package-use.html" }
"</td>" + LS + "</tr>",
TMPDEST_DIR1 + FS + "p1" + FS + "package-use.html"
}
};
public static void runTestsOnHTML(String[][] testArray) {
@ -152,10 +150,7 @@ public class ValidHtml {
// Find string in file's contents
if (findString(fileString, stringToFind) == -1) {
System.out.println("\nSub-test " + (subtestNum)
+ " for bug " + BUGID + " (" + BUGNAME + ") FAILED\n"
+ "when searching for:\n"
+ stringToFind);
System.out.println("\nSub-test " + (subtestNum) + " for bug " + BUGID + " (" + BUGNAME + ") FAILED\n" + "when searching for:\n" + stringToFind);
} else {
numSubtestsPassed += 1;
System.out.println("\nSub-test " + (subtestNum) + " passed:\n" + stringToFind);
@ -167,8 +162,7 @@ public class ValidHtml {
if (numSubtestsPassed == subtestNum) {
System.out.println("\nAll " + numSubtestsPassed + " subtests passed");
} else {
throw new Error("\n" + (subtestNum - numSubtestsPassed) + " of " + (subtestNum)
+ " subtests failed for bug " + BUGID + " (" + BUGNAME + ")\n");
throw new Error("\n" + (subtestNum - numSubtestsPassed) + " of " + (subtestNum) + " subtests failed for bug " + BUGID + " (" + BUGNAME + ")\n");
}
}

2
langtools/test/com/sun/javadoc/VersionNumber/VersionNumber.java
View file

@ -84,7 +84,7 @@ public class VersionNumber {
// Test the proper DOCTYPE element is present:
{
"<!-- Generated by javadoc (build",
"<!-- Generated by javadoc (version",
TMPDEST_DIR1 + "p1" + FS + "C.html" },
};

34
langtools/test/com/sun/javadoc/WindowTitles/WindowTitles.java
View file

@ -94,52 +94,52 @@ public class WindowTitles
*/
private static final String[][] testArray = {
{ "<TITLE>" + LS + "Overview" + LS + "</TITLE>",
{ "<title>Overview</title>",
TMPDIR_STRING1 + "overview-summary.html" },
{ "<TITLE>" + LS + "Class Hierarchy" + LS + "</TITLE>",
{ "<title>Class Hierarchy</title>",
TMPDIR_STRING1 + "overview-tree.html" },
{ "<TITLE>" + LS + "Overview List" + LS + "</TITLE>",
{ "<title>Overview List</title>",
TMPDIR_STRING1 + "overview-frame.html" },
{ "<TITLE>" + LS + "p1" + LS + "</TITLE>",
{ "<title>p1</title>",
TMPDIR_STRING1 + "p1" + FS + "package-summary.html" },
{ "<TITLE>" + LS + "p1" + LS + "</TITLE>",
{ "<title>p1</title>",
TMPDIR_STRING1 + "p1" + FS + "package-frame.html" },
{ "<TITLE>" + LS + "p1 Class Hierarchy" + LS + "</TITLE>",
{ "<title>p1 Class Hierarchy</title>",
TMPDIR_STRING1 + "p1" + FS + "package-tree.html" },
{ "<TITLE>" + LS + "Uses of Package p1" + LS + "</TITLE>",
{ "<title>Uses of Package p1</title>",
TMPDIR_STRING1 + "p1" + FS + "package-use.html" },
{ "<TITLE>" + LS + "C1" + LS + "</TITLE>",
{ "<title>C1</title>",
TMPDIR_STRING1 + "p1" + FS + "C1.html" },
{ "<TITLE>" + LS + "All Classes" + LS + "</TITLE>",
{ "<title>All Classes</title>",
TMPDIR_STRING1 + "allclasses-frame.html" },
{ "<TITLE>" + LS + "All Classes" + LS + "</TITLE>",
{ "<title>All Classes</title>",
TMPDIR_STRING1 + "allclasses-noframe.html" },
{ "<TITLE>" + LS + "Constant Field Values" + LS + "</TITLE>",
{ "<title>Constant Field Values</title>",
TMPDIR_STRING1 + "constant-values.html" },
{ "<TITLE>" + LS + "Deprecated List" + LS + "</TITLE>",
{ "<title>Deprecated List</title>",
TMPDIR_STRING1 + "deprecated-list.html" },
{ "<TITLE>" + LS + "Serialized Form" + LS + "</TITLE>",
{ "<title>Serialized Form</title>",
TMPDIR_STRING1 + "serialized-form.html" },
{ "<TITLE>" + LS + "API Help" + LS + "</TITLE>",
{ "<title>API Help</title>",
TMPDIR_STRING1 + "help-doc.html" },
{ "<TITLE>" + LS + "Index" + LS + "</TITLE>",
{ "<title>Index</title>",
TMPDIR_STRING1 + "index-all.html" },
{ "<TITLE>" + LS + "Uses of Class p1.C1" + LS + "</TITLE>",
{ "<title>Uses of Class p1.C1</title>",
TMPDIR_STRING1 + "p1" + FS + "class-use" + FS + "C1.html" },
};
@ -147,7 +147,7 @@ public class WindowTitles
* Assign value for [ stringToFind, filename ] for split index page
*/
private static final String[][] testSplitIndexArray = {
{ "<TITLE>" + LS + "C-Index" + LS + "</TITLE>",
{ "<title>C-Index</title>",
TMPDIR_STRING2 + "index-files" + FS + "index-1.html" },
};

2
langtools/test/com/sun/javadoc/constantValues/TestConstantValuesDriver.java
View file

@ -51,7 +51,7 @@ public class TestConstantValuesDriver extends JavadocTester {
tests[i][1] = "TEST"+(i+1)+"PASSES";
}
tests[tests.length-1][0] = BUG_ID + FS + "constant-values.html";
tests[tests.length-1][1] = "<CODE>\"&lt;Hello World&gt;\"</CODE>";
tests[tests.length-1][1] = "<code>\"&lt;Hello World&gt;\"</code>";
TestConstantValuesDriver tester = new TestConstantValuesDriver();
run(tester, ARGS, tests, NO_TEST);
tester.printSummary();

18
langtools/test/com/sun/javadoc/testClassCrossReferences/TestClassCrossReferences.java
View file

@ -37,18 +37,20 @@ public class TestClassCrossReferences extends JavadocTester {
private static final String BUG_ID = "4652655-4857717";
private static final String[][] TEST = {
{BUG_ID + FS + "C.html",
"<A HREF=\"http://java.sun.com/j2se/1.4/docs/api/java/math/package-summary.html?is-external=true\"><CODE>Link to math package</CODE></A>"},
"<a href=\"http://java.sun.com/j2se/1.4/docs/api/java/math/package-summary.html?is-external=true\"><code>Link to math package</code></a>"},
{BUG_ID + FS + "C.html",
"<A HREF=\"http://java.sun.com/j2se/1.4/docs/api/javax/swing/text/AbstractDocument.AttributeContext.html?is-external=true\" " +
"title=\"class or interface in javax.swing.text\"><CODE>Link to AttributeContext innerclass</CODE></A>"},
"<a href=\"http://java.sun.com/j2se/1.4/docs/api/javax/swing/text/AbstractDocument.AttributeContext.html?is-external=true\" " +
"title=\"class or interface in javax.swing.text\"><code>Link to AttributeContext innerclass</code></a>"},
{BUG_ID + FS + "C.html",
"<A HREF=\"http://java.sun.com/j2se/1.4/docs/api/java/math/BigDecimal.html?is-external=true\" " +
"title=\"class or interface in java.math\"><CODE>Link to external class BigDecimal</CODE></A>"},
"<a href=\"http://java.sun.com/j2se/1.4/docs/api/java/math/BigDecimal.html?is-external=true\" " +
"title=\"class or interface in java.math\"><code>Link to external class BigDecimal</code></a>"},
{BUG_ID + FS + "C.html",
"<A HREF=\"http://java.sun.com/j2se/1.4/docs/api/java/math/BigInteger.html?is-external=true#gcd(java.math.BigInteger)\" " +
"title=\"class or interface in java.math\"><CODE>Link to external member gcd</CODE></A>"},
"<a href=\"http://java.sun.com/j2se/1.4/docs/api/java/math/BigInteger.html?is-external=true#gcd(java.math.BigInteger)\" " +
"title=\"class or interface in java.math\"><code>Link to external member gcd</code></a>"},
{BUG_ID + FS + "C.html",
"<STRONG>Overrides:</STRONG></DT><DD><CODE>toString</CODE> in class <CODE>java.lang.Object</CODE>"}
"<dl>" + NL + "<dt><strong>Overrides:</strong></dt>" + NL +
"<dd><code>toString</code>&nbsp;in class&nbsp;<code>java.lang.Object</code></dd>" + NL +
"</dl>"}
};
private static final String[][] NEGATED_TEST = NO_TEST;
private static final String[] ARGS =

33
langtools/test/com/sun/javadoc/testClassTree/TestClassTree.java
View file

@ -48,32 +48,29 @@ public class TestClassTree extends JavadocTester {
//Input for string search tests.
private static final String[][] TEST = {
{BUG_ID + FS + "pkg" + FS + "package-tree.html",
"<LI TYPE=\"circle\">pkg.<A HREF=\"../pkg/ParentClass.html\" " +
"title=\"class in pkg\"><STRONG>ParentClass</STRONG></A><UL>"},
"<ul>" + NL + "<li type=\"circle\">pkg.<a href=\"../pkg/ParentClass.html\" " +
"title=\"class in pkg\"><span class=\"strong\">ParentClass</span></a>"},
{BUG_ID + FS + "pkg" + FS + "package-tree.html",
"Annotation Type Hierarchy" + NL + "</H2>" + NL + "<UL>" + NL +
"<LI TYPE=\"circle\">pkg.<A HREF=\"../pkg/AnnotationType.html\" " +
"title=\"annotation in pkg\"><STRONG>AnnotationType</STRONG></A> " +
"(implements java.lang.annotation.Annotation)" + NL + "</UL>"},
"<h2 title=\"Annotation Type Hierarchy\">Annotation Type Hierarchy</h2>" + NL +
"<ul>" + NL + "<li type=\"circle\">pkg.<a href=\"../pkg/AnnotationType.html\" " +
"title=\"annotation in pkg\"><span class=\"strong\">AnnotationType</span></a> " +
"(implements java.lang.annotation.Annotation)</li>" + NL + "</ul>"},
{BUG_ID + FS + "pkg" + FS + "package-tree.html",
"<H2>" + NL +
"Enum Hierarchy" + NL +
"</H2>" + NL +
"<UL>" + NL +
"<LI TYPE=\"circle\">java.lang.Object<UL>" + NL +
"<LI TYPE=\"circle\">java.lang.Enum&lt;E&gt; (implements java.lang.Comparable&lt;T&gt;, java.io.Serializable)" + NL +
"<UL>" + NL +
"<LI TYPE=\"circle\">pkg.<A HREF=\"../pkg/Coin.html\" title=\"enum in pkg\"><STRONG>Coin</STRONG></A></UL>" + NL +
"</UL>" + NL +
"</UL>"
"<h2 title=\"Enum Hierarchy\">Enum Hierarchy</h2>" + NL + "<ul>" + NL +
"<li type=\"circle\">java.lang.Object" + NL + "<ul>" + NL +
"<li type=\"circle\">java.lang.Enum&lt;E&gt; (implements java.lang." +
"Comparable&lt;T&gt;, java.io.Serializable)" + NL + "<ul>" + NL +
"<li type=\"circle\">pkg.<a href=\"../pkg/Coin.html\" " +
"title=\"enum in pkg\"><span class=\"strong\">Coin</span></a></li>" + NL +
"</ul>" + NL + "</li>" + NL + "</ul>" + NL + "</li>" + NL + "</ul>"
},
};
private static final String[][] NEGATED_TEST = {
{BUG_ID + FS + "pkg" + FS + "package-tree.html",
"<LI TYPE=\"circle\">class pkg.<A HREF=\"../pkg/ParentClass.html\" " +
"title=\"class in pkg\"><STRONG>ParentClass</STRONG></A><UL>"}
"<li type=\"circle\">class pkg.<a href=\"../pkg/ParentClass.html\" " +
"title=\"class in pkg\"><span class=\"strong\">ParentClass</span></a></li>"}
};
/**

8
langtools/test/com/sun/javadoc/testConstructorIndent/TestConstructorIndent.java
View file

@ -45,10 +45,10 @@ public class TestConstructorIndent extends JavadocTester {
//Input for string search tests.
private static final String[][] TEST = {
{BUG_ID + FS + "C.html", "<DL>" + NL + "<DD>This is just a simple constructor." + NL +
"<P>" + NL + "</DD>" + NL + "<DD><DL>" + NL + "<DT><STRONG>Parameters:</STRONG>" +
"</DT><DD><CODE>i</CODE> - a param.</DD></DL>" + NL +
"</DD>" + NL + "</DL>"
{BUG_ID + FS + "C.html", "<div class=\"block\">" +
"This is just a simple constructor.</div>" + NL +
"<dl><dt><span class=\"strong\">Parameters:</span></dt><dd>" +
"<code>i</code> - a param.</dd></dl>"
}
};
private static final String[][] NEGATED_TEST = NO_TEST;

Some files were not shown because too many files have changed in this diff Show more