home *** CD-ROM | disk | FTP | other *** search
/ Internet News 1999 October / INEWS_10_CD.ISO / pc / jdk / jdk1.2.2 / docs / tooldocs / javadoc / source / standard / ClassUseWriter.java < prev    next >
Encoding:
Java Source  |  1999-09-19  |  10.2 KB  |  326 lines
  1. /*
  2.  * @(#)ClassUseWriter.java    1.5 98/08/05
  3.  *
  4.  * Copyright 1997, 1998 by Sun Microsystems, Inc.,
  5.  * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
  6.  * All rights reserved.
  7.  *
  8.  * This software is the confidential and proprietary information
  9.  * of Sun Microsystems, Inc. ("Confidential Information").  You
  10.  * shall not disclose such Confidential Information and shall use
  11.  * it only in accordance with the terms of the license agreement
  12.  * you entered into with Sun.
  13.  */
  14.  
  15.  
  16. package com.sun.tools.doclets.standard;
  17.  
  18. import com.sun.tools.doclets.*;
  19. import com.sun.javadoc.*;
  20. import java.io.*;
  21. import java.lang.*;
  22. import java.util.*;
  23.  
  24. /**
  25.  * Generate class usage information. 
  26.  *
  27.  * @author Robert G. Field
  28.  */
  29. public class ClassUseWriter extends SubWriterHolderWriter {
  30.  
  31.     final ClassDoc classdoc;
  32.     final Map pkgToSubclass;
  33.     final Map pkgToSubinterface;
  34.     final Map pkgToImplementingClass;
  35.     final Map pkgToField;
  36.     final Map pkgToMethodReturn;
  37.     final Map pkgToMethodArgs;
  38.     final Map pkgToMethodThrows;
  39.     final Map pkgToConstructorArgs;
  40.     final Map pkgToConstructorThrows;
  41.     final SortedSet pkgSet;
  42.     final MethodSubWriter methodSubWriter;
  43.     final ConstructorSubWriter constrSubWriter;
  44.     final FieldSubWriter fieldSubWriter;
  45.     final ClassSubWriter classSubWriter;
  46.  
  47.  
  48.     /**
  49.      * Constructor.
  50.      *
  51.      * @param filename the file to be generated. 
  52.      */
  53.     public ClassUseWriter(ClassUseMapper mapper, String path, 
  54.                           String filename, String relpath,
  55.                           ClassDoc classdoc) 
  56.                    throws IOException, DocletAbortException {
  57.         super(path, filename, relpath);
  58.         this.classdoc = classdoc;
  59.         HtmlStandardWriter.currentcd = classdoc;
  60.     this.pkgSet = new TreeSet();
  61.     this.pkgToSubclass = pkgDivide(mapper.classToSubclass);
  62.     this.pkgToSubinterface = pkgDivide(mapper.classToSubinterface);
  63.     this.pkgToImplementingClass = pkgDivide(mapper.classToImplementingClass);
  64.     this.pkgToField = pkgDivide(mapper.classToField);
  65.     this.pkgToMethodReturn = pkgDivide(mapper.classToMethodReturn);
  66.     this.pkgToMethodArgs = pkgDivide(mapper.classToMethodArgs);
  67.     this.pkgToMethodThrows = pkgDivide(mapper.classToMethodThrows);
  68.     this.pkgToConstructorArgs = pkgDivide(mapper.classToConstructorArgs);
  69.     this.pkgToConstructorThrows = pkgDivide(mapper.classToConstructorThrows);
  70.     //tmp test
  71.     if (!pkgSet.equals(mapper.classToPackage.get(classdoc))) {
  72.         System.err.println("Internal error: package sets don't match: " + pkgSet + " with: " +
  73.                    mapper.classToPackage.get(classdoc));
  74.     }
  75.         methodSubWriter = new MethodSubWriter(this);
  76.         constrSubWriter = new ConstructorSubWriter(this);
  77.         fieldSubWriter = new FieldSubWriter(this);
  78.         classSubWriter = new ClassSubWriter(this);
  79.     }
  80.  
  81.     private Map pkgDivide(Map classMap) {
  82.         Map map = new HashMap();
  83.         List list= (List)classMap.get(classdoc);
  84.         if (list != null) {
  85.             Iterator it = list.iterator();
  86.             while (it.hasNext()) {
  87.                 ProgramElementDoc doc = (ProgramElementDoc)it.next();
  88.                 PackageDoc pkg = doc.containingPackage();
  89.                 pkgSet.add(pkg);
  90.                 List inPkg = (List)map.get(pkg);
  91.                 if (inPkg == null) {
  92.                     inPkg = new ArrayList();
  93.                     map.put(pkg, inPkg);
  94.                 }
  95.                 inPkg.add(doc);
  96.             }
  97.         }
  98.         return map;
  99.     }
  100.     
  101.     /**
  102.      * Generate a class page.
  103.      *
  104.      * @param prev the previous class to generated, or null if no previous.
  105.      * @param classdoc the class to generate.
  106.      * @param next the next class to be generated, or null if no next.
  107.      */
  108.     public static void generate(ClassUseMapper mapper, 
  109.                 ClassDoc classdoc) 
  110.                          throws DocletAbortException {
  111.             ClassUseWriter clsgen;
  112.             String path = DirectoryManager.getDirectoryPath(classdoc.
  113.                                                     containingPackage());
  114.             if (path.length() > 0) {
  115.                 path += File.separator;
  116.             }
  117.             path += "class-use";
  118.             String filename = classdoc.name() + ".html";
  119.             String pkgname = classdoc.containingPackage().name();
  120.             pkgname += (pkgname.length() > 0)? ".class-use": "class-use";
  121.             String relpath = DirectoryManager.getRelativePath(pkgname); 
  122.             try {
  123.                 clsgen = new ClassUseWriter(mapper, path, filename, 
  124.                                             relpath, classdoc);
  125.                 clsgen.generateClassUseFile();
  126.                 clsgen.close();
  127.             } catch (IOException exc) {
  128.                 Standard.configuration().standardmessage.
  129.                     error("doclet.exception_encountered",
  130.                            exc.toString(), filename);
  131.                 throw new DocletAbortException();
  132.             }
  133.     }
  134.  
  135.     /** 
  136.      * Print the class use list.
  137.      */ 
  138.     protected void generateClassUseFile() throws IOException {
  139.  
  140.         printClassUseHeader();
  141.  
  142.     if (pkgSet.size() > 0) {
  143.             generateClassUse();
  144.         } else {
  145.             printText("doclet.ClassUse_No.usage.of.0", 
  146.                      classdoc.qualifiedName());
  147.             p();
  148.         }
  149.         
  150.         printClassUseFooter();
  151.     }        
  152.  
  153.     protected void generateClassUse() throws IOException {
  154.         if (Standard.configuration().packages.length > 1) {
  155.             generatePackageList();
  156.         }
  157.         generateClassList();
  158.     }
  159.  
  160.     protected void generatePackageList() throws IOException {
  161.     tableIndexSummary();
  162.     tableHeaderStart("#CCCCFF");
  163.     printText("doclet.ClassUse_Packages.that.use.0",
  164.           getClassLink(classdoc));
  165.     tableHeaderEnd();
  166.  
  167.     for (Iterator it = pkgSet.iterator(); it.hasNext();) {
  168.         PackageDoc pkg = (PackageDoc)it.next();
  169.         generatePackageUse(pkg);
  170.     }
  171.     tableEnd();
  172.     space();
  173.     p();
  174.     }
  175.         
  176.     protected void generateClassList() throws IOException {
  177.     for (Iterator it = pkgSet.iterator(); it.hasNext();) {
  178.         PackageDoc pkg = (PackageDoc)it.next();
  179.         anchor(pkg.name());
  180.         tableIndexSummary();
  181.         tableHeaderStart("#CCCCFF");
  182.         printText("doclet.ClassUse_Uses.of.0.in.1",
  183.               getClassLink(classdoc), 
  184.               getPackageLink(pkg));
  185.         tableHeaderEnd();
  186.         tableEnd();
  187.             space();
  188.             p();
  189.         generateClassUse(pkg);
  190.     }
  191.     }        
  192.  
  193.     /** 
  194.      * Print the package use list.
  195.      */ 
  196.     protected void generatePackageUse(PackageDoc pkg) throws IOException {
  197.         trBgcolorStyle("white", "TableRowColor");
  198.     summaryRow(0);
  199.     printHyperLink("", pkg.name(), pkg.name(), true);
  200.     summaryRowEnd();
  201.     summaryRow(0);
  202.     printSummaryComment(pkg);
  203.     space();
  204.     summaryRowEnd();
  205.     trEnd();
  206.     }
  207.  
  208.     /** 
  209.      * Print the class use list.
  210.      */ 
  211.     protected void generateClassUse(PackageDoc pkg) throws IOException {
  212.         String classLink = getClassLink(classdoc);
  213.     String pkgLink = getPackageLink(pkg);
  214.         classSubWriter.printUseInfo(pkgToSubclass.get(pkg),
  215.                     getText("doclet.ClassUse_Subclass",
  216.                         classLink, 
  217.                         pkgLink));
  218.         classSubWriter.printUseInfo(pkgToSubinterface.get(pkg),
  219.                     getText("doclet.ClassUse_Subinterface",
  220.                         classLink, 
  221.                         pkgLink));
  222.         classSubWriter.printUseInfo(pkgToImplementingClass.get(pkg),
  223.                     getText("doclet.ClassUse_ImplementingClass",
  224.                         classLink, 
  225.                         pkgLink));
  226.         fieldSubWriter.printUseInfo(pkgToField.get(pkg),
  227.                     getText("doclet.ClassUse_Field",
  228.                         classLink, 
  229.                         pkgLink));
  230.         methodSubWriter.printUseInfo(pkgToMethodReturn.get(pkg),
  231.                     getText("doclet.ClassUse_MethodReturn",
  232.                         classLink, 
  233.                         pkgLink));
  234.         methodSubWriter.printUseInfo(pkgToMethodArgs.get(pkg),
  235.                     getText("doclet.ClassUse_MethodArgs",
  236.                         classLink, 
  237.                         pkgLink));
  238.         methodSubWriter.printUseInfo(pkgToMethodThrows.get(pkg),
  239.                     getText("doclet.ClassUse_MethodThrows",
  240.                         classLink, 
  241.                         pkgLink));
  242.         constrSubWriter.printUseInfo(pkgToConstructorArgs.get(pkg),
  243.                     getText("doclet.ClassUse_ConstructorArgs",
  244.                         classLink, 
  245.                         pkgLink));
  246.         constrSubWriter.printUseInfo(pkgToConstructorThrows.get(pkg),
  247.                     getText("doclet.ClassUse_ConstructorThrows",
  248.                         classLink, 
  249.                         pkgLink));
  250.     }        
  251.  
  252.     /**
  253.      * Print the header for the class use Listing.
  254.      */
  255.     protected void printClassUseHeader() {
  256.         String cltype = getText(classdoc.isInterface()? 
  257.                                     "doclet.Interface": 
  258.                                     "doclet.Class");
  259.         String clname = classdoc.qualifiedName();
  260.         printHeader(getText("doclet.Window_ClassUse_Header", 
  261.                             Standard.configuration().windowtitle, 
  262.                             cltype, clname));
  263.         navLinks(true);
  264.         hr();
  265.         center();
  266.         h2();
  267.         boldText("doclet.ClassUse_Title", cltype, clname);
  268.         h2End();
  269.         centerEnd();
  270.     }
  271.  
  272.     /**
  273.      * Print the footer for the class use Listing.
  274.      */
  275.     protected void printClassUseFooter() {
  276.         hr();
  277.         navLinks(false);
  278.         printBottom();
  279.         printBodyHtmlEnd();
  280.     }
  281.  
  282.  
  283.     /**
  284.      * Print this package link
  285.      */
  286.     protected void navLinkPackage() {
  287.         navCellStart();
  288.         printHyperLink("../package-summary.html", "", 
  289.                        getText("doclet.Package"), true, "NavBarFont1");
  290.         navCellEnd();
  291.     }
  292.                                 
  293.     /**
  294.      * Print class page indicator
  295.      */
  296.     protected void navLinkClass() {
  297.         navCellStart();
  298.         printClassLink(classdoc, "", getText("doclet.Class"), true, "NavBarFont1");
  299.         navCellEnd();
  300.     }
  301.  
  302.     /**
  303.      * Print class use link
  304.      */
  305.     protected void navLinkClassUse() {
  306.         navCellRevStart();
  307.         fontStyle("NavBarFont1Rev");
  308.         boldText("doclet.navClassUse");
  309.         fontEnd();
  310.         navCellEnd();
  311.     }
  312.  
  313.     protected void navLinkTree() {
  314.         navCellStart();
  315.         if (classdoc.containingPackage().isIncluded()) {
  316.             printHyperLink("../package-tree.html", "", getText("doclet.Tree"),
  317.                            true, "NavBarFont1");
  318.         } else {
  319.             printHyperLink(relativepath + "overview-tree.html", "", 
  320.                            getText("doclet.Tree"), true, "NavBarFont1");
  321.         }
  322.         navCellEnd();
  323.     }
  324.  
  325. }
  326.