home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1995 November / PCWK1195.iso / inne / win95 / sieciowe / hotja32.lzh / hotjava / classsrc / net / www / html / document.java < prev    next >
Text File  |  1995-08-11  |  5KB  |  184 lines
  1. /*
  2.  * @(#)Document.java    1.15 95/05/10 Jonathan Payne
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19.  
  20. package net.www.html;
  21.  
  22. import java.util.*;
  23. import java.io.*;
  24. import awt.DisplayItem;
  25.  
  26. /** net.ww.html.Document is a class which holds an html document.
  27.     An html document is parsed text, a vector of tags, and
  28.     optional html source text.  Document is used by html.Parser to
  29.     store parsed documents, but it is also used to help
  30.     programatically generate html documents.  E.g., the ftp
  31.     protocol handler might generate an html document out of a
  32.     directory listing. */
  33.  
  34. public class Document {
  35.     /** The head tag, so we can tell when we've finished parsing
  36.     the head of a document.  The reason we care is that all the
  37.     elements inside a head should really not be rendered.  This
  38.     is where we'll stick the <title> and perhaps other
  39.     extensions such as a digital signature.  The problem is,
  40.     mosaic and other viewers out there don't mind if there is
  41.     a <head> without the corresponding </head>.  So millions
  42.     of people all over the world write completely incorrect
  43.     html documents AND NEVER EVEN KNOW IT! */
  44.     static Tag    HEADtag = Tag.lookup("head");
  45.  
  46.     /** If this is non-null, it contains the htmlSource that this
  47.     document was built from. */
  48.     protected String    htmlSource;
  49.  
  50.     /** This is the text of the html document, with the tags and
  51.     extra white space removed.  */
  52.     protected byte    text[];
  53.  
  54.     /** This is an array of tag references into the text string. */
  55.     protected Vector    tags;
  56.  
  57.     /** Title of this html document, or null if not known yet. */
  58.     protected String    title;
  59.  
  60.     /** This is whether or not we're in a <pre> section.  <pre>
  61.     sections cannot be nested, and we enforce that here, so we
  62.     don't need to keep a count. */
  63.     protected boolean    inPREelement = false;
  64.  
  65.     public Document() {
  66.     reset();
  67.     }
  68.  
  69.     public final void setSource(String source) {
  70.     htmlSource = source;
  71.     }
  72.  
  73.     public void reset() {
  74.     text = null;
  75.     title = null;
  76.     if (tags == null) {
  77.         tags = new Vector();
  78.     } else {
  79.         tags.setSize(0);
  80.     }
  81.     }
  82.  
  83.     /** This adds a pre-made TagRef to the document, and sets
  84.     its position to the current position. */
  85.     protected final TagRef addTagRef(TagRef ref, int offset) {
  86.     if (ref != null) {
  87.         Tag    theTag = ref.tag;
  88.         int    tagID = theTag.id;
  89.  
  90.         if (inPREelement) {
  91.         if (tagID == Tag.PRE && ref.isEnd) {
  92.             inPREelement = false;
  93.         } else {
  94.             if (theTag.breaks && tagID != Tag.BR && tagID != Tag.HR) {
  95.             System.out.println("Warning: Ignoring: " + theTag + " inside <pre> section");
  96.             return null;
  97.             }
  98.         }
  99.         } else if (tagID == Tag.PRE) {
  100.         inPREelement = true;
  101.         }
  102.  
  103.         ref.pos = offset;
  104.         tags.addElement(ref);
  105.     }
  106.  
  107.     return ref;
  108.     }
  109.  
  110.     /** Create a new start tag ref at the current position.  This
  111.     creates a generic TagRef object, but can be subclassed to
  112.     create specific TagRef subclasses. */
  113.     public TagRef startTag(Tag t, int offset) {
  114.     //System.out.println("Add <" + t.name + "> at " + offset);
  115.     return addTagRef(new TagRef(t, offset, false), offset);
  116.     }
  117.  
  118.     /** Create a new end tag ref at the current position.  This
  119.     creates a generic TagRef object, but can be subclassed to
  120.     create specific TagRef subclasses. */
  121.     public TagRef endTag(Tag t, int offset) {
  122.     //System.out.println("Add </" + t.name + "> at " + offset);
  123.     return addTagRef(new TagRef(t, offset, true), offset);
  124.     }
  125.  
  126.     /** Return the vector of tag refs. */
  127.     public Vector getTags() {
  128.     return tags;
  129.     }
  130.  
  131.     /** Return the text array. */
  132.     public byte getText()[] {
  133.     return text;
  134.     }
  135.  
  136.     /** Set the text array. It is not copied. */
  137.     public void setText(byte text[]) {
  138.     this.text = text;
  139.     }
  140.  
  141.     /** Set the text. */
  142.     public void setText(String str) {
  143.     text = new byte[str.length()];
  144.     for (int i = 0 ; i < text.length ; i++) {
  145.         text[i] = (byte)str.charAt(i);
  146.     }
  147.     }
  148.  
  149.     /** This returns the title for this document, as defined by
  150.     the <title> </title> tag pairs.  If no title is found,
  151.     "" is returned. */
  152.     public String getTitle() {
  153.     if (title != null) {
  154.         return title;
  155.     }
  156.     if (tags == null) {
  157.         return "";
  158.     }
  159.     Tag titleTag = Tag.lookup("title");
  160.     int cnt = tags.size();
  161.     int i = 0;
  162.     int pos0 = -1;
  163.  
  164.     title = "";
  165.     while (--cnt >= 0) {
  166.         TagRef  ref = (TagRef) tags.elementAt(i++);
  167.  
  168.         if (ref.tag == titleTag) {
  169.         if (ref.isEnd) {
  170.             /* check to make sure we found the <title> begin
  171.                tag!  If not, we return no title. */
  172.             if (pos0 == -1) {
  173.             break;
  174.             }
  175.             title = new String(text, 0, pos0, ref.pos - pos0);
  176.             break;
  177.         }
  178.         pos0 = ref.pos;
  179.         }
  180.     }
  181.     return title;
  182.     }
  183. }
  184.