93 |
*/ |
*/ |
94 |
private Map packageNameToDocSet = new HashMap(); |
private Map packageNameToDocSet = new HashMap(); |
95 |
|
|
96 |
|
/** |
97 |
|
* Cache for version string from resource /version.properties |
98 |
|
*/ |
99 |
|
private String docletVersion; |
100 |
|
|
101 |
|
/** |
102 |
|
* For now, do not output a help page. |
103 |
|
*/ |
104 |
|
private static final boolean outputHelpPage = false; |
105 |
|
|
106 |
private void printNavBar(HtmlPage output, String currentPage, ClassDoc currentClass) |
private void printNavBar(HtmlPage output, String currentPage, ClassDoc currentClass) |
107 |
{ |
{ |
108 |
output.beginDiv(CssClass.NAVBAR_TOP); |
output.beginDiv(CssClass.NAVBAR_TOP); |
132 |
output.print(" "); |
output.print(" "); |
133 |
} |
} |
134 |
|
|
135 |
if (!overviewLevel) { |
if (!overviewLevel || isSinglePackage()) { |
136 |
if ("package".equals(currentPage)) { |
if ("package".equals(currentPage)) { |
137 |
output.beginSpan(CssClass.NAVBAR_ITEM_ACTIVE); |
output.beginSpan(CssClass.NAVBAR_ITEM_ACTIVE); |
138 |
output.print("Package"); |
output.print("Package"); |
140 |
} |
} |
141 |
else { |
else { |
142 |
output.beginSpan(CssClass.NAVBAR_ITEM_ENABLED); |
output.beginSpan(CssClass.NAVBAR_ITEM_ENABLED); |
143 |
output.beginAnchor("package-summary" + filenameExtension); |
String packageHref; |
144 |
|
if (isSinglePackage()) { |
145 |
|
packageHref = output.getPathToRoot() + "/" + getPackageURL(getSinglePackage()) + "/package-summary" + filenameExtension; |
146 |
|
} |
147 |
|
else { |
148 |
|
packageHref = "package-summary" + filenameExtension; |
149 |
|
} |
150 |
|
output.beginAnchor(packageHref); |
151 |
output.print("Package"); |
output.print("Package"); |
152 |
output.endAnchor(); |
output.endAnchor(); |
153 |
output.endSpan(CssClass.NAVBAR_ITEM_ENABLED); |
output.endSpan(CssClass.NAVBAR_ITEM_ENABLED); |
228 |
output.print(" "); |
output.print(" "); |
229 |
|
|
230 |
if ("full-tree".equals(currentPage) |
if ("full-tree".equals(currentPage) |
231 |
|| "package-tree".equals(currentPage) |
|| "package-tree".equals(currentPage)) { |
|
|| (isSinglePackage() && overviewLevel)) { |
|
232 |
output.beginSpan(CssClass.NAVBAR_ITEM_ACTIVE); |
output.beginSpan(CssClass.NAVBAR_ITEM_ACTIVE); |
233 |
output.print("Tree"); |
output.print("Tree"); |
234 |
output.endSpan(CssClass.NAVBAR_ITEM_ACTIVE); |
output.endSpan(CssClass.NAVBAR_ITEM_ACTIVE); |
235 |
} |
} |
236 |
else { |
else { |
237 |
output.beginSpan(CssClass.NAVBAR_ITEM_ENABLED); |
output.beginSpan(CssClass.NAVBAR_ITEM_ENABLED); |
238 |
output.beginAnchor("tree" + filenameExtension); |
String treeHref; |
239 |
|
if (isSinglePackage() && overviewLevel) { |
240 |
|
treeHref = getPackageURL(getSinglePackage()) + "/tree" + filenameExtension; |
241 |
|
} |
242 |
|
else { |
243 |
|
treeHref = "tree" + filenameExtension; |
244 |
|
} |
245 |
|
|
246 |
|
output.beginAnchor(treeHref); |
247 |
output.print("Tree"); |
output.print("Tree"); |
248 |
output.endAnchor(); |
output.endAnchor(); |
249 |
output.endSpan(CssClass.NAVBAR_ITEM_ENABLED); |
output.endSpan(CssClass.NAVBAR_ITEM_ENABLED); |
290 |
} |
} |
291 |
} |
} |
292 |
|
|
293 |
if (!optionNoHelp.getValue()) { |
if (outputHelpPage) { |
294 |
output.print(" "); |
if (!optionNoHelp.getValue()) { |
295 |
|
output.print(" "); |
296 |
if ("help".equals(currentPage)) { |
|
297 |
output.beginSpan(CssClass.NAVBAR_ITEM_ACTIVE); |
if ("help".equals(currentPage)) { |
298 |
output.print("Help"); |
output.beginSpan(CssClass.NAVBAR_ITEM_ACTIVE); |
299 |
output.endSpan(CssClass.NAVBAR_ITEM_ACTIVE); |
output.print("Help"); |
300 |
} |
output.endSpan(CssClass.NAVBAR_ITEM_ACTIVE); |
301 |
else { |
} |
302 |
output.beginSpan(CssClass.NAVBAR_ITEM_ENABLED); |
else { |
303 |
output.beginAnchor(output.getPathToRoot() + "/help" + filenameExtension); |
output.beginSpan(CssClass.NAVBAR_ITEM_ENABLED); |
304 |
output.print("Help"); |
output.beginAnchor(output.getPathToRoot() + "/help" + filenameExtension); |
305 |
output.endAnchor(); |
output.print("Help"); |
306 |
output.endSpan(CssClass.NAVBAR_ITEM_ENABLED); |
output.endAnchor(); |
307 |
|
output.endSpan(CssClass.NAVBAR_ITEM_ENABLED); |
308 |
|
} |
309 |
} |
} |
310 |
} |
} |
311 |
|
|
327 |
output.endDiv(CssClass.NAVBAR_TOP); |
output.endDiv(CssClass.NAVBAR_TOP); |
328 |
} |
} |
329 |
|
|
330 |
|
private void printNavBarTopRow(HtmlPage output, String currentPage, ClassDoc currentClass) |
331 |
|
{ |
332 |
|
output.beginRow(); |
333 |
|
output.beginCell(CssClass.NAVBAR_TOP); |
334 |
|
printNavBar(output, currentPage, currentClass); |
335 |
|
output.endCell(); |
336 |
|
if (null != optionHeader.getValue()) { |
337 |
|
output.beginCell(); |
338 |
|
output.print(replaceDocRoot(output, optionHeader.getValue())); |
339 |
|
output.endCell(); |
340 |
|
} |
341 |
|
output.endRow(); |
342 |
|
} |
343 |
|
|
344 |
|
private void printNavBarTopNaviCell(HtmlPage output) |
345 |
|
{ |
346 |
|
output.beginCell(CssClass.NAVBAR_TOP_NAVI); |
347 |
|
output.beginAnchor(output.getPathToRoot() + "/index" + filenameExtension, "Show this documentation set in a frameset", "_top"); |
348 |
|
output.print("Frames"); |
349 |
|
output.endAnchor(); |
350 |
|
output.print(" | "); |
351 |
|
String noFramesHref; |
352 |
|
if (isSinglePackage()) { |
353 |
|
noFramesHref = output.getPathToRoot() |
354 |
|
+ "/" + getPackageURL(getSinglePackage()) |
355 |
|
+ "/package-summary" + filenameExtension; |
356 |
|
} |
357 |
|
else { |
358 |
|
noFramesHref = output.getPathToRoot() |
359 |
|
+ "/index-noframes" + filenameExtension; |
360 |
|
} |
361 |
|
|
362 |
|
output.beginAnchor(noFramesHref, "Show the overview page without frames", "_top"); |
363 |
|
output.print("No Frames"); |
364 |
|
output.endAnchor(); |
365 |
|
output.print(" "); |
366 |
|
|
367 |
|
output.endCell(); |
368 |
|
} |
369 |
|
|
370 |
private void printNavBarTop(HtmlPage output, String currentPage) |
private void printNavBarTop(HtmlPage output, String currentPage) |
371 |
{ |
{ |
372 |
printNavBarTop(output, currentPage, null); |
printNavBarTop(output, currentPage, null, null, null); |
373 |
} |
} |
374 |
|
|
375 |
private void printNavBarTop(HtmlPage output, String currentPage, ClassDoc currentClass) |
private void printNavBarTop(HtmlPage output, String currentPage, |
376 |
|
ClassDoc currentClass, ClassDoc prevClass, ClassDoc nextClass) |
377 |
{ |
{ |
378 |
if (!optionNoNavBar.getValue()) { |
if (!optionNoNavBar.getValue()) { |
379 |
output.beginTable(CssClass.NAVBAR_TOP); |
output.beginTable(CssClass.NAVBAR_TOP); |
380 |
|
printNavBarTopRow(output, currentPage, currentClass); |
381 |
output.beginRow(); |
output.beginRow(); |
382 |
output.beginCell(CssClass.NAVBAR_TOP); |
if ("class".equals(currentPage)) { |
383 |
printNavBar(output, currentPage, currentClass); |
output.beginCell(CssClass.NAVBAR_TOP_NAVI); |
384 |
output.endCell(); |
if (null != prevClass) { |
385 |
if (null != optionHeader.getValue()) { |
output.anchor(getClassDocURL(output, prevClass), "Prev Class"); |
386 |
output.beginCell(); |
} |
387 |
output.print(replaceDocRoot(output, optionHeader.getValue())); |
else { |
388 |
|
output.print("Prev Class"); |
389 |
|
} |
390 |
|
output.print(" | "); |
391 |
|
if (null != nextClass) { |
392 |
|
output.anchor(getClassDocURL(output, nextClass), "Next Class"); |
393 |
|
} |
394 |
|
else { |
395 |
|
output.print("Next Class"); |
396 |
|
} |
397 |
|
output.endCell(); |
398 |
|
} |
399 |
|
else { |
400 |
|
output.beginCell(CssClass.NAVBAR_TOP_NAVI); |
401 |
|
output.endCell(); |
402 |
|
} |
403 |
|
|
404 |
|
printNavBarTopNaviCell(output); |
405 |
|
output.endRow(); |
406 |
|
|
407 |
|
if ("class".equals(currentPage)) { |
408 |
|
output.beginRow(); |
409 |
|
|
410 |
|
output.beginCell(CssClass.NAVBAR_TOP_NAVI); |
411 |
|
output.print("Summary: "); |
412 |
|
|
413 |
|
if (currentClass.innerClasses().length > 0) { |
414 |
|
output.anchor("#summary-inner", "Nested"); |
415 |
|
} |
416 |
|
else { |
417 |
|
output.print("Nested"); |
418 |
|
} |
419 |
|
|
420 |
|
output.print(" | "); |
421 |
|
|
422 |
|
if (currentClass.fields().length > 0) { |
423 |
|
output.anchor("#summary-fields", "Field"); |
424 |
|
} |
425 |
|
else { |
426 |
|
output.print("Field"); |
427 |
|
} |
428 |
|
|
429 |
|
output.print(" | "); |
430 |
|
|
431 |
|
if (currentClass.methods().length > 0) { |
432 |
|
output.anchor("#summary-methods", "Method"); |
433 |
|
} |
434 |
|
else { |
435 |
|
output.print("Methods"); |
436 |
|
} |
437 |
|
|
438 |
|
output.print(" | "); |
439 |
|
|
440 |
|
if (currentClass.constructors().length > 0) { |
441 |
|
output.anchor("#summary-constructors", "Constr"); |
442 |
|
} |
443 |
|
else { |
444 |
|
output.print("Constr"); |
445 |
|
} |
446 |
|
|
447 |
|
output.endCell(); |
448 |
|
|
449 |
|
output.beginCell(CssClass.NAVBAR_TOP_NAVI); |
450 |
|
output.print("Detail: "); |
451 |
|
|
452 |
|
if (currentClass.innerClasses().length > 0) { |
453 |
|
output.anchor("#detail-inner", "Nested"); |
454 |
|
} |
455 |
|
else { |
456 |
|
output.print("Nested"); |
457 |
|
} |
458 |
|
|
459 |
|
output.print(" | "); |
460 |
|
|
461 |
|
if (currentClass.fields().length > 0) { |
462 |
|
output.anchor("#detail-fields", "Field"); |
463 |
|
} |
464 |
|
else { |
465 |
|
output.print("Field"); |
466 |
|
} |
467 |
|
|
468 |
|
output.print(" | "); |
469 |
|
|
470 |
|
if (currentClass.methods().length > 0) { |
471 |
|
output.anchor("#detail-methods", "Method"); |
472 |
|
} |
473 |
|
else { |
474 |
|
output.print("Methods"); |
475 |
|
} |
476 |
|
|
477 |
|
output.print(" | "); |
478 |
|
|
479 |
|
if (currentClass.constructors().length > 0) { |
480 |
|
output.anchor("#detail-constructors", "Constr"); |
481 |
|
} |
482 |
|
else { |
483 |
|
output.print("Constr"); |
484 |
|
} |
485 |
|
|
486 |
output.endCell(); |
output.endCell(); |
487 |
|
output.endRow(); |
488 |
} |
} |
489 |
|
output.endTable(); |
490 |
|
} |
491 |
|
} |
492 |
|
|
493 |
|
private void printNavBarTopPackage(HtmlPage output, String currentPage, |
494 |
|
PackageDoc prevPackage, PackageDoc nextPackage) |
495 |
|
{ |
496 |
|
if (!optionNoNavBar.getValue()) { |
497 |
|
output.beginTable(CssClass.NAVBAR_TOP); |
498 |
|
printNavBarTopRow(output, currentPage, null); |
499 |
|
|
500 |
|
output.beginRow(); |
501 |
|
output.beginCell(CssClass.NAVBAR_TOP_NAVI); |
502 |
|
if (null != prevPackage) { |
503 |
|
output.anchor(output.getPathToRoot() + "/" + getPackageURL(prevPackage) + "/package-summary" + filenameExtension, "Prev Package"); |
504 |
|
} |
505 |
|
else { |
506 |
|
output.print("Prev Package"); |
507 |
|
} |
508 |
|
output.print(" | "); |
509 |
|
if (null != nextPackage) { |
510 |
|
output.anchor(output.getPathToRoot() + "/" + getPackageURL(nextPackage) + "/package-summary" + filenameExtension, "Next Package"); |
511 |
|
} |
512 |
|
else { |
513 |
|
output.print("Next Package"); |
514 |
|
} |
515 |
|
output.endCell(); |
516 |
|
|
517 |
|
printNavBarTopNaviCell(output); |
518 |
output.endRow(); |
output.endRow(); |
519 |
|
|
520 |
output.endTable(); |
output.endTable(); |
521 |
} |
} |
522 |
} |
} |
614 |
out.close(); |
out.close(); |
615 |
} |
} |
616 |
|
|
617 |
private void printPackagePage(File packageDir, String pathToRoot, PackageDoc packageDoc) |
private void printPackagePage(File packageDir, String pathToRoot, |
618 |
|
PackageDoc packageDoc, |
619 |
|
PackageDoc prevPackageDoc, |
620 |
|
PackageDoc nextPackageDoc) |
621 |
throws IOException |
throws IOException |
622 |
{ |
{ |
623 |
HtmlPage output = new HtmlPage(new File(packageDir, |
HtmlPage output = new HtmlPage(new File(packageDir, |
624 |
"package-summary" + filenameExtension), |
"package-summary" + filenameExtension), |
625 |
pathToRoot, |
pathToRoot, |
626 |
getOutputDocEncoding()); |
getOutputDocEncoding()); |
627 |
output.beginPage(getPageTitle(packageDoc.name()), getOutputCharset()); |
|
628 |
|
Set keywords = new LinkedHashSet(); |
629 |
|
keywords.add(packageDoc.name() + " packages"); |
630 |
|
|
631 |
|
output.beginPage(getPageTitle(packageDoc.name()), getOutputCharset(), |
632 |
|
keywords); |
633 |
output.beginBody(CssClass.BODY_CONTENT_PACKAGE); |
output.beginBody(CssClass.BODY_CONTENT_PACKAGE); |
634 |
printNavBarTop(output, "package"); |
printNavBarTopPackage(output, "package", prevPackageDoc, nextPackageDoc); |
635 |
|
|
636 |
output.beginDiv(CssClass.PACKAGE_TITLE); |
output.beginDiv(CssClass.PACKAGE_TITLE); |
637 |
output.print("Package "); |
output.print("Package "); |
1383 |
printMemberDetails(output, |
printMemberDetails(output, |
1384 |
classDoc.serializationMethods(), |
classDoc.serializationMethods(), |
1385 |
"Serialization Methods", |
"Serialization Methods", |
1386 |
true); |
true, null); |
1387 |
printMemberDetails(output, |
printMemberDetails(output, |
1388 |
classDoc.serializableFields(), |
classDoc.serializableFields(), |
1389 |
"Serialized Fields", |
"Serialized Fields", |
1390 |
true); |
true, null); |
1391 |
} |
} |
1392 |
} |
} |
1393 |
} |
} |
1464 |
} |
} |
1465 |
} |
} |
1466 |
|
|
1467 |
output.beginDiv(CssClass.DEPRECATION_TOC); |
if (!deprecatedInterfaces.isEmpty() |
1468 |
output.div(CssClass.DEPRECATION_TOC_HEADER, "Contents"); |
|| !deprecatedClasses.isEmpty() |
1469 |
output.beginDiv(CssClass.DEPRECATION_TOC_LIST); |
|| !deprecatedExceptions.isEmpty() |
1470 |
if (!deprecatedInterfaces.isEmpty()) { |
|| !deprecatedErrors.isEmpty() |
1471 |
output.beginDiv(CssClass.DEPRECATION_TOC_ENTRY); |
|| !deprecatedFields.isEmpty() |
1472 |
output.anchor("#interfaces", "Deprecated Interfaces"); |
|| !deprecatedMethods.isEmpty() |
1473 |
output.endDiv(CssClass.DEPRECATION_TOC_ENTRY); |
|| !deprecatedConstructors.isEmpty()) { |
1474 |
} |
|
1475 |
if (!deprecatedClasses.isEmpty()) { |
output.beginDiv(CssClass.DEPRECATION_TOC); |
1476 |
output.beginDiv(CssClass.DEPRECATION_TOC_ENTRY); |
output.div(CssClass.DEPRECATION_TOC_HEADER, "Contents"); |
1477 |
output.anchor("#classes", "Deprecated Classes"); |
output.beginDiv(CssClass.DEPRECATION_TOC_LIST); |
1478 |
output.endDiv(CssClass.DEPRECATION_TOC_ENTRY); |
if (!deprecatedInterfaces.isEmpty()) { |
1479 |
} |
output.beginDiv(CssClass.DEPRECATION_TOC_ENTRY); |
1480 |
if (!deprecatedExceptions.isEmpty()) { |
output.anchor("#interfaces", "Deprecated Interfaces"); |
1481 |
output.beginDiv(CssClass.DEPRECATION_TOC_ENTRY); |
output.endDiv(CssClass.DEPRECATION_TOC_ENTRY); |
1482 |
output.anchor("#exceptions", "Deprecated Exceptions"); |
} |
1483 |
output.endDiv(CssClass.DEPRECATION_TOC_ENTRY); |
if (!deprecatedClasses.isEmpty()) { |
1484 |
} |
output.beginDiv(CssClass.DEPRECATION_TOC_ENTRY); |
1485 |
if (!deprecatedErrors.isEmpty()) { |
output.anchor("#classes", "Deprecated Classes"); |
1486 |
output.beginDiv(CssClass.DEPRECATION_TOC_ENTRY); |
output.endDiv(CssClass.DEPRECATION_TOC_ENTRY); |
1487 |
output.anchor("#errors", "Deprecated Errors"); |
} |
1488 |
output.endDiv(CssClass.DEPRECATION_TOC_ENTRY); |
if (!deprecatedExceptions.isEmpty()) { |
1489 |
} |
output.beginDiv(CssClass.DEPRECATION_TOC_ENTRY); |
1490 |
if (!deprecatedFields.isEmpty()) { |
output.anchor("#exceptions", "Deprecated Exceptions"); |
1491 |
output.beginDiv(CssClass.DEPRECATION_TOC_ENTRY); |
output.endDiv(CssClass.DEPRECATION_TOC_ENTRY); |
1492 |
output.anchor("#fields", "Deprecated Fields"); |
} |
1493 |
output.endDiv(CssClass.DEPRECATION_TOC_ENTRY); |
if (!deprecatedErrors.isEmpty()) { |
1494 |
} |
output.beginDiv(CssClass.DEPRECATION_TOC_ENTRY); |
1495 |
if (!deprecatedFields.isEmpty()) { |
output.anchor("#errors", "Deprecated Errors"); |
1496 |
output.beginDiv(CssClass.DEPRECATION_TOC_ENTRY); |
output.endDiv(CssClass.DEPRECATION_TOC_ENTRY); |
1497 |
output.anchor("#methods", "Deprecated Methods"); |
} |
1498 |
output.endDiv(CssClass.DEPRECATION_TOC_ENTRY); |
if (!deprecatedFields.isEmpty()) { |
1499 |
} |
output.beginDiv(CssClass.DEPRECATION_TOC_ENTRY); |
1500 |
if (!deprecatedFields.isEmpty()) { |
output.anchor("#fields", "Deprecated Fields"); |
1501 |
output.beginDiv(CssClass.DEPRECATION_TOC_ENTRY); |
output.endDiv(CssClass.DEPRECATION_TOC_ENTRY); |
1502 |
output.anchor("#constructors", "Deprecated Constructors"); |
} |
1503 |
output.endDiv(CssClass.DEPRECATION_TOC_ENTRY); |
if (!deprecatedMethods.isEmpty()) { |
1504 |
} |
output.beginDiv(CssClass.DEPRECATION_TOC_ENTRY); |
1505 |
output.endDiv(CssClass.DEPRECATION_TOC_LIST); |
output.anchor("#methods", "Deprecated Methods"); |
1506 |
output.endDiv(CssClass.DEPRECATION_TOC); |
output.endDiv(CssClass.DEPRECATION_TOC_ENTRY); |
1507 |
|
} |
1508 |
output.anchorName("interfaces"); |
if (!deprecatedConstructors.isEmpty()) { |
1509 |
printDeprecationSummary(output, deprecatedInterfaces, "Deprecated Interfaces"); |
output.beginDiv(CssClass.DEPRECATION_TOC_ENTRY); |
1510 |
|
output.anchor("#constructors", "Deprecated Constructors"); |
1511 |
output.anchorName("classes"); |
output.endDiv(CssClass.DEPRECATION_TOC_ENTRY); |
1512 |
printDeprecationSummary(output, deprecatedClasses, "Deprecated Classes"); |
} |
1513 |
|
output.endDiv(CssClass.DEPRECATION_TOC_LIST); |
1514 |
output.anchorName("exceptions"); |
output.endDiv(CssClass.DEPRECATION_TOC); |
1515 |
printDeprecationSummary(output, deprecatedExceptions, "Deprecated Exceptions"); |
|
1516 |
|
output.anchorName("interfaces"); |
1517 |
output.anchorName("errors"); |
printDeprecationSummary(output, deprecatedInterfaces, "Deprecated Interfaces"); |
1518 |
printDeprecationSummary(output, deprecatedErrors, "Deprecated Errors"); |
|
1519 |
|
output.anchorName("classes"); |
1520 |
output.anchorName("fields"); |
printDeprecationSummary(output, deprecatedClasses, "Deprecated Classes"); |
1521 |
printDeprecationSummary(output, deprecatedFields, "Deprecated Fields"); |
|
1522 |
|
output.anchorName("exceptions"); |
1523 |
output.anchorName("methods"); |
printDeprecationSummary(output, deprecatedExceptions, "Deprecated Exceptions"); |
1524 |
printDeprecationSummary(output, deprecatedMethods, "Deprecated Methods"); |
|
1525 |
|
output.anchorName("errors"); |
1526 |
output.anchorName("constructors"); |
printDeprecationSummary(output, deprecatedErrors, "Deprecated Errors"); |
1527 |
printDeprecationSummary(output, deprecatedConstructors, "Deprecated Constructors"); |
|
1528 |
|
output.anchorName("fields"); |
1529 |
|
printDeprecationSummary(output, deprecatedFields, "Deprecated Fields"); |
1530 |
|
|
1531 |
|
output.anchorName("methods"); |
1532 |
|
printDeprecationSummary(output, deprecatedMethods, "Deprecated Methods"); |
1533 |
|
|
1534 |
|
output.anchorName("constructors"); |
1535 |
|
printDeprecationSummary(output, deprecatedConstructors, "Deprecated Constructors"); |
1536 |
|
} |
1537 |
|
else { |
1538 |
|
output.beginDiv(CssClass.DEPRECATION_EMPTY); |
1539 |
|
output.print("No deprecated classes or class members in this API."); |
1540 |
|
output.endDiv(CssClass.DEPRECATION_EMPTY); |
1541 |
|
|
1542 |
|
} |
1543 |
|
|
1544 |
printNavBarBottom(output, "deprecated"); |
printNavBarBottom(output, "deprecated"); |
1545 |
output.endBody(); |
output.endBody(); |
1564 |
output.print("GNU Gjdoc"); |
output.print("GNU Gjdoc"); |
1565 |
output.print(" Standard Doclet "); |
output.print(" Standard Doclet "); |
1566 |
output.print(getDocletVersion()); |
output.print(getDocletVersion()); |
1567 |
|
output.print(", part of "); |
1568 |
|
output.anchor("http://www.gnu.org/software/classpath/cp-tools/", "GNU Classpath Tools"); |
1569 |
output.endDiv(CssClass.ABOUT_GENERATOR); |
output.endDiv(CssClass.ABOUT_GENERATOR); |
1570 |
|
|
1571 |
printNavBarBottom(output, "about"); |
printNavBarBottom(output, "about"); |
1712 |
getOutputDocEncoding()); |
getOutputDocEncoding()); |
1713 |
output.beginPage(getPageTitle(classDoc.name()), getOutputCharset()); |
output.beginPage(getPageTitle(classDoc.name()), getOutputCharset()); |
1714 |
output.beginBody(CssClass.BODY_CONTENT_USES); |
output.beginBody(CssClass.BODY_CONTENT_USES); |
1715 |
printNavBarTop(output, "uses", classDoc); |
printNavBarTop(output, "uses", classDoc, null, null); |
1716 |
|
|
1717 |
output.div(CssClass.USAGE_TITLE, "Uses of class " + classDoc.qualifiedName()); |
output.div(CssClass.USAGE_TITLE, "Uses of class " + classDoc.qualifiedName()); |
1718 |
|
|
1863 |
} |
} |
1864 |
} |
} |
1865 |
|
|
1866 |
private void printClassPage(File packageDir, String pathToRoot, ClassDoc classDoc) |
private void printClassPage(File packageDir, String pathToRoot, |
1867 |
|
ClassDoc classDoc, ClassDoc prevClassDoc, ClassDoc nextClassDoc) |
1868 |
throws IOException |
throws IOException |
1869 |
{ |
{ |
1870 |
HtmlPage output = new HtmlPage(new File(packageDir, |
HtmlPage output = new HtmlPage(new File(packageDir, |
1871 |
classDoc.name() + filenameExtension), |
classDoc.name() + filenameExtension), |
1872 |
pathToRoot, |
pathToRoot, |
1873 |
getOutputDocEncoding()); |
getOutputDocEncoding()); |
1874 |
output.beginPage(getPageTitle(classDoc.name()), getOutputCharset()); |
Set keywords = new LinkedHashSet(); |
1875 |
|
{ |
1876 |
|
keywords.add(classDoc.qualifiedName() + " class"); |
1877 |
|
FieldDoc[] fieldDocs = classDoc.fields(); |
1878 |
|
for (int i=0; i<fieldDocs.length; ++i) { |
1879 |
|
FieldDoc fieldDoc = fieldDocs[i]; |
1880 |
|
keywords.add(fieldDoc.name()); |
1881 |
|
} |
1882 |
|
|
1883 |
|
MethodDoc[] methodDocs = classDoc.methods(); |
1884 |
|
for (int i=0; i<methodDocs.length; ++i) { |
1885 |
|
MethodDoc methodDoc = methodDocs[i]; |
1886 |
|
keywords.add(methodDoc.name() + "()"); |
1887 |
|
} |
1888 |
|
} |
1889 |
|
|
1890 |
|
output.beginPage(getPageTitle(classDoc.name()), getOutputCharset(), |
1891 |
|
keywords); |
1892 |
output.beginBody(CssClass.BODY_CONTENT_CLASS); |
output.beginBody(CssClass.BODY_CONTENT_CLASS); |
1893 |
printNavBarTop(output, "class", classDoc); |
printNavBarTop(output, "class", classDoc, prevClassDoc, nextClassDoc); |
1894 |
|
|
1895 |
output.beginDiv(CssClass.CLASS_TITLE); |
output.beginDiv(CssClass.CLASS_TITLE); |
1896 |
output.div(CssClass.CLASS_TITLE_PACKAGE, |
output.div(CssClass.CLASS_TITLE_PACKAGE, |
2058 |
} |
} |
2059 |
|
|
2060 |
printProgramElementDocs(output, getSortedInnerClasses(classDoc), |
printProgramElementDocs(output, getSortedInnerClasses(classDoc), |
2061 |
"Nested Class Summary", haveInheritedClasses); |
"Nested Class Summary", haveInheritedClasses, |
2062 |
|
"summary-inner"); |
2063 |
|
|
2064 |
{ |
{ |
2065 |
ClassDoc superClassDoc = classDoc.superclass(); |
ClassDoc superClassDoc = classDoc.superclass(); |
2072 |
} |
} |
2073 |
|
|
2074 |
printProgramElementDocs(output, getSortedFields(classDoc), |
printProgramElementDocs(output, getSortedFields(classDoc), |
2075 |
"Field Summary", haveInheritedFields); |
"Field Summary", haveInheritedFields, |
2076 |
|
"summary-fields"); |
2077 |
|
|
2078 |
{ |
{ |
2079 |
ClassDoc superClassDoc = classDoc.superclass(); |
ClassDoc superClassDoc = classDoc.superclass(); |
2100 |
} |
} |
2101 |
|
|
2102 |
printProgramElementDocs(output, getSortedConstructors(classDoc), |
printProgramElementDocs(output, getSortedConstructors(classDoc), |
2103 |
"Constructor Summary", false); |
"Constructor Summary", false, |
2104 |
|
"summary-constructors"); |
2105 |
printProgramElementDocs(output, getSortedMethods(classDoc), |
printProgramElementDocs(output, getSortedMethods(classDoc), |
2106 |
"Method Summary", haveInheritedMethods); |
"Method Summary", haveInheritedMethods, |
2107 |
|
"summary-methods"); |
2108 |
|
|
2109 |
if (classDoc.isInterface()) { |
if (classDoc.isInterface()) { |
2110 |
InterfaceRelation relation |
InterfaceRelation relation |
2128 |
} |
} |
2129 |
|
|
2130 |
printMemberDetails(output, getSortedFields(classDoc), |
printMemberDetails(output, getSortedFields(classDoc), |
2131 |
"Field Details", false); |
"Field Details", false, "detail-fields"); |
2132 |
printMemberDetails(output, getSortedConstructors(classDoc), |
printMemberDetails(output, getSortedConstructors(classDoc), |
2133 |
"Constructor Details", false); |
"Constructor Details", false, "detail-constructors"); |
2134 |
printMemberDetails(output, getSortedMethods(classDoc), |
printMemberDetails(output, getSortedMethods(classDoc), |
2135 |
"Method Details", false); |
"Method Details", false, "detail-methods"); |
2136 |
|
|
2137 |
printNavBarBottom(output, "class", classDoc); |
printNavBarBottom(output, "class", classDoc); |
2138 |
|
|
2215 |
|
|
2216 |
private void printMemberDetails(HtmlPage output, |
private void printMemberDetails(HtmlPage output, |
2217 |
ProgramElementDoc[] memberDocs, String header, |
ProgramElementDoc[] memberDocs, String header, |
2218 |
boolean isOnSerializedPage) |
boolean isOnSerializedPage, |
2219 |
|
String anchor) |
2220 |
{ |
{ |
2221 |
if (memberDocs.length > 0) { |
if (memberDocs.length > 0) { |
2222 |
|
|
2223 |
|
if (null != anchor) { |
2224 |
|
output.anchorName(anchor); |
2225 |
|
} |
2226 |
|
|
2227 |
CssClass sectionClass; |
CssClass sectionClass; |
2228 |
if (isOnSerializedPage) { |
if (isOnSerializedPage) { |
2229 |
sectionClass = CssClass.SERIALIZED_SECTION_HEADER; |
sectionClass = CssClass.SERIALIZED_SECTION_HEADER; |
2245 |
output.beginDiv(CssClass.MEMBER_DETAIL); |
output.beginDiv(CssClass.MEMBER_DETAIL); |
2246 |
output.div(CssClass.MEMBER_DETAIL_NAME, memberDoc.name()); |
output.div(CssClass.MEMBER_DETAIL_NAME, memberDoc.name()); |
2247 |
|
|
2248 |
output.beginDiv(CssClass.MEMBER_DETAIL_SYNOPSIS); |
StringBuffer synopsis = new StringBuffer(); |
2249 |
|
int synopsisLength = 0; |
2250 |
|
|
2251 |
if (!isOnSerializedPage || !memberDoc.isField()) { |
if (!isOnSerializedPage || !memberDoc.isField()) { |
2252 |
output.print(getFullModifiers(memberDoc)); |
String fullModifiers = getFullModifiers(memberDoc); |
2253 |
} |
synopsis.append(fullModifiers); |
2254 |
if (memberDoc.isMethod()) { |
synopsisLength += fullModifiers.length(); |
2255 |
output.print(" "); |
|
|
printType(output, ((MethodDoc)memberDoc).returnType()); |
|
2256 |
} |
} |
2257 |
else if (memberDoc.isField()) { |
if (memberDoc.isMethod() || memberDoc.isField()) { |
2258 |
output.print(" "); |
Type type; |
2259 |
printType(output, ((FieldDoc)memberDoc).type()); |
if (memberDoc.isMethod()) { |
2260 |
|
type = ((MethodDoc)memberDoc).returnType(); |
2261 |
|
} |
2262 |
|
else { |
2263 |
|
type = ((FieldDoc)memberDoc).type(); |
2264 |
|
} |
2265 |
|
|
2266 |
|
synopsis.append(" "); |
2267 |
|
synopsisLength ++; |
2268 |
|
synopsis.append(createTypeHref(output, type, false)); |
2269 |
|
if (null != type.asClassDoc() && type.asClassDoc().isIncluded()) { |
2270 |
|
synopsisLength += type.asClassDoc().name().length(); |
2271 |
|
} |
2272 |
|
else { |
2273 |
|
synopsisLength += type.qualifiedTypeName().length(); |
2274 |
|
} |
2275 |
|
synopsisLength += type.dimension().length(); |
2276 |
} |
} |
2277 |
output.print(" "); |
|
2278 |
|
synopsis.append(" "); |
2279 |
|
synopsisLength ++; |
2280 |
|
|
2281 |
if (optionLinkSource.getValue() && null != memberDoc.position()) { |
if (optionLinkSource.getValue() && null != memberDoc.position()) { |
2282 |
ClassDoc containingClass = memberDoc.containingClass(); |
ClassDoc containingClass = memberDoc.containingClass(); |
2284 |
containingClass = containingClass.containingClass(); |
containingClass = containingClass.containingClass(); |
2285 |
} |
} |
2286 |
String href = containingClass.name() + "-source" + filenameExtension + "#line." + memberDoc.position().line(); |
String href = containingClass.name() + "-source" + filenameExtension + "#line." + memberDoc.position().line(); |
2287 |
output.beginAnchor(href); |
synopsis.append(output.createHrefString(href, memberDoc.name())); |
|
output.print(memberDoc.name()); |
|
|
output.endAnchor(); |
|
2288 |
} |
} |
2289 |
else { |
else { |
2290 |
output.print(memberDoc.name()); |
synopsis.append(memberDoc.name()); |
2291 |
} |
} |
2292 |
|
synopsisLength += memberDoc.name().length(); |
2293 |
|
|
2294 |
if (memberDoc.isConstructor() || memberDoc.isMethod()) { |
if (memberDoc.isConstructor() || memberDoc.isMethod()) { |
2295 |
printParameters(output, (ExecutableMemberDoc)memberDoc); |
//printParameters(output, (ExecutableMemberDoc)memberDoc); |
2296 |
|
synopsis.append("("); |
2297 |
|
++ synopsisLength; |
2298 |
|
StringBuffer paddingLeft = new StringBuffer(); |
2299 |
|
for (int j=0; j<synopsisLength; ++j) { |
2300 |
|
paddingLeft.append(' '); |
2301 |
|
} |
2302 |
|
Parameter[] parameters = ((ExecutableMemberDoc)memberDoc).parameters(); |
2303 |
|
for (int j=0; j<parameters.length; ++j) { |
2304 |
|
Parameter parameter = parameters[j]; |
2305 |
|
synopsis.append(createTypeHref(output, parameter.type(), false)); |
2306 |
|
synopsis.append(" "); |
2307 |
|
synopsis.append(parameter.name()); |
2308 |
|
if (j < parameters.length - 1) { |
2309 |
|
synopsis.append(",\n"); |
2310 |
|
synopsis.append(paddingLeft); |
2311 |
|
} |
2312 |
|
} |
2313 |
|
synopsis.append(")"); |
2314 |
|
ClassDoc[] exceptions = ((ExecutableMemberDoc)memberDoc).thrownExceptions(); |
2315 |
|
if (exceptions.length > 0) { |
2316 |
|
synopsis.append("\n throws "); |
2317 |
|
for (int j=0; j<exceptions.length; ++j) { |
2318 |
|
ClassDoc exception = exceptions[j]; |
2319 |
|
synopsis.append(createTypeHref(output, exception, false)); |
2320 |
|
if (j < exceptions.length - 1) { |
2321 |
|
synopsis.append(",\n "); |
2322 |
|
} |
2323 |
|
} |
2324 |
|
} |
2325 |
} |
} |
2326 |
|
|
2327 |
|
output.beginDiv(CssClass.MEMBER_DETAIL_SYNOPSIS); |
2328 |
|
output.print(synopsis.toString()); |
2329 |
output.endDiv(CssClass.MEMBER_DETAIL_SYNOPSIS); |
output.endDiv(CssClass.MEMBER_DETAIL_SYNOPSIS); |
2330 |
|
|
2331 |
output.beginDiv(CssClass.MEMBER_DETAIL_BODY); |
output.beginDiv(CssClass.MEMBER_DETAIL_BODY); |
2546 |
output.print(", "); |
output.print(", "); |
2547 |
} |
} |
2548 |
printType(output, parameters[j].type()); |
printType(output, parameters[j].type()); |
2549 |
output.print(" "); |
output.print(" "); |
2550 |
output.print(parameters[j].name()); |
output.print(parameters[j].name()); |
2551 |
} |
} |
2552 |
output.print(")"); |
output.print(")"); |
2555 |
private void printProgramElementDocs(HtmlPage output, |
private void printProgramElementDocs(HtmlPage output, |
2556 |
ProgramElementDoc[] memberDocs, |
ProgramElementDoc[] memberDocs, |
2557 |
String header, |
String header, |
2558 |
boolean forceOutputHeader) |
boolean forceOutputHeader, |
2559 |
|
String anchor) |
2560 |
{ |
{ |
2561 |
if (memberDocs.length > 0 || forceOutputHeader) { |
if (memberDocs.length > 0 || forceOutputHeader) { |
2562 |
|
output.anchorName(anchor); |
2563 |
output.beginDiv(CssClass.TABLE_CONTAINER); |
output.beginDiv(CssClass.TABLE_CONTAINER); |
2564 |
output.beginTable(CssClass.CLASS_SUMMARY, new String[] { "border", "width" }, new String[] { "1", "100%" }); |
output.beginTable(CssClass.CLASS_SUMMARY, new String[] { "border", "width" }, new String[] { "1", "100%" }); |
2565 |
output.rowDiv(CssClass.TABLE_HEADER, header); |
output.rowDiv(CssClass.TABLE_HEADER, header); |
2832 |
printSplitIndex(); |
printSplitIndex(); |
2833 |
} |
} |
2834 |
} |
} |
2835 |
if (!optionNoHelp.getValue()) { |
if (outputHelpPage && !optionNoHelp.getValue()) { |
2836 |
printHelpPage(); |
printHelpPage(); |
2837 |
} |
} |
2838 |
|
|
2889 |
|
|
2890 |
printSerializationPage(); |
printSerializationPage(); |
2891 |
|
|
2892 |
Collection packageDocs = getAllPackages(); |
Collection packageDocsCollection = getAllPackages(); |
2893 |
Iterator it = packageDocs.iterator(); |
PackageDoc[] packageDocs |
2894 |
while (it.hasNext()) { |
= (PackageDoc[])packageDocsCollection.toArray(new PackageDoc[0]); |
2895 |
PackageDoc packageDoc = (PackageDoc)it.next(); |
|
2896 |
|
for (int i=0; i<packageDocs.length; ++i) { |
2897 |
|
PackageDoc packageDoc = packageDocs[i]; |
2898 |
File packageDir = new File(getTargetDirectory(), |
File packageDir = new File(getTargetDirectory(), |
2899 |
packageDoc.name().replace('.', File.separatorChar)); |
packageDoc.name().replace('.', File.separatorChar)); |
2900 |
if (!packageDir.exists() && !packageDir.mkdirs()) { |
if (!packageDir.exists() && !packageDir.mkdirs()) { |
2916 |
packageName = "<unnamed>"; |
packageName = "<unnamed>"; |
2917 |
} |
} |
2918 |
printNotice("Writing HTML files for package " + packageName); |
printNotice("Writing HTML files for package " + packageName); |
2919 |
printPackagePage(packageDir, pathToRoot, packageDoc); |
printPackagePage(packageDir, pathToRoot, packageDoc, |
2920 |
|
(i > 0) ? packageDocs[i - 1] : null, |
2921 |
|
(i < packageDocs.length - 1) ? packageDocs[i + 1] : null); |
2922 |
if (!optionNoTree.getValue()) { |
if (!optionNoTree.getValue()) { |
2923 |
printPackageTreePage(packageDir, pathToRoot, packageDoc); |
printPackageTreePage(packageDir, pathToRoot, packageDoc); |
2924 |
} |
} |
2927 |
for (int j=0; j<classDocs.length; ++j) { |
for (int j=0; j<classDocs.length; ++j) { |
2928 |
ClassDoc classDoc = classDocs[j]; |
ClassDoc classDoc = classDocs[j]; |
2929 |
if (classDoc.isIncluded()) { |
if (classDoc.isIncluded()) { |
2930 |
printClassPage(packageDir, pathToRoot, classDocs[j]); |
printClassPage(packageDir, pathToRoot, |
2931 |
|
classDocs[j], |
2932 |
|
(j > 0) ? classDocs[j - 1] : null, |
2933 |
|
(j < classDocs.length - 1) ? classDocs[j + 1] : null |
2934 |
|
); |
2935 |
if (optionUse.getValue()) { |
if (optionUse.getValue()) { |
2936 |
printClassUsagePage(packageDir, pathToRoot, classDocs[j]); |
printClassUsagePage(packageDir, pathToRoot, classDocs[j]); |
2937 |
} |
} |
3414 |
return title + " (" + optionWindowTitle.getValue() + ")"; |
return title + " (" + optionWindowTitle.getValue() + ")"; |
3415 |
} |
} |
3416 |
} |
} |
3417 |
|
|
3418 |
|
protected String getDocletVersion() |
3419 |
|
{ |
3420 |
|
if (null == docletVersion) { |
3421 |
|
try { |
3422 |
|
Properties versionProperties = new Properties(); |
3423 |
|
versionProperties.load(getClass().getResourceAsStream("/version.properties")); |
3424 |
|
docletVersion = versionProperties.getProperty("gjdoc.version"); |
3425 |
|
} |
3426 |
|
catch (IOException ignore) { |
3427 |
|
} |
3428 |
|
if (null == docletVersion) { |
3429 |
|
docletVersion = "unknown"; |
3430 |
|
} |
3431 |
|
} |
3432 |
|
return docletVersion; |
3433 |
|
} |
3434 |
} |
} |