home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1995 November / PCWK1195.iso / inne / win95 / sieciowe / hotja32.lzh / hotjava / classsrc / browser / basicstyle.java < prev    next >
Text File  |  1995-08-11  |  10KB  |  350 lines
  1. /*
  2.  * @(#)BasicStyle.java    1.12 95/04/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 browser;
  21.  
  22. import java.util.*;
  23. import net.www.html.*;
  24. import awt.*;
  25.  
  26. /**
  27.  * The BasicStyle class is used to specify most of the style changes
  28.  * that occur as a result of html tag refs.  Zero or more of the
  29.  * parameters may be specified for change.  BasicStyle operates on
  30.  * instances of FormattingParameters, generating new instances of
  31.  * FormattingParameters by modifying old ones.
  32.  * @see awt.FormattingParameters
  33.  * @version 1.12, 10 Apr 1995
  34.  * @author Jonathan Payne
  35.  */
  36.  
  37. public class BasicStyle extends Style {
  38.     /** The left margin. */
  39.     int        leftMargin;
  40.  
  41.     /** The right margin. */
  42.     int        rightMargin;
  43.  
  44.     /** Character attribute to add, e.g., BOLD, ITALIC. */
  45.     int        fontAttrAdd;
  46.  
  47.     /** Character attributes to clear, e.g., BOLD, ITALIC. */
  48.     int        fontAttrClr;
  49.  
  50.     /** Size of the font to use. */
  51.     int        fontSize;
  52.  
  53.     /** Family name for the font, e.g., Times. */
  54.     String  fontName;
  55.  
  56.     /**
  57.      * The red, green and blue components of the foreground color to
  58.      * use.
  59.      */
  60.     short   r, g, b;
  61.  
  62.     /** Paragraph alignment: left, right, center, etc. */    
  63.     byte    align;
  64.  
  65.     /** Wrapping mode: not, word, character. */
  66.     byte    wrap;
  67.  
  68.     /**
  69.      * Whether or not the left margin setting is to be added to the
  70.      * current one, or whether it is to be used as the new left
  71.      * margin.
  72.      */
  73.     boolean lmarginIncrement;
  74.  
  75.     /**
  76.      * Whether or not the right margin setting is to be added to the
  77.      * current one, or whether it is to be used as the new right
  78.      * margin.
  79.      */
  80.     boolean rmarginIncrement;
  81.  
  82.     final int    A_LMARGIN = 1;
  83.     final int    A_ATTR_ADD = 2;
  84.     final int    A_ATTR_CLR = 4;
  85.     final int    A_FONT_SIZE = 8;
  86.     final int    A_FONT_NAME = 16;
  87.     final int    A_COLOR = 32;
  88.     final int    A_WRAP = 64;
  89.     final int    A_ALIGN = 128;
  90.     final int    A_RMARGIN = 256;
  91.  
  92.     int        which = 0;
  93.  
  94.     /**
  95.      * Constructs a new instance of BasicStyle.  Initializes itself
  96.      * based on the attribute=value pairs in the specified
  97.      * specification.  Possible attributes and their values are:
  98.      * <dl compact><dt>size<dd>integer size of font <dt>color<dd>
  99.      * integer:integer:integer red, green and blue components of
  100.      * color<dt>style<dd><dl compact><dt>i<dd>turn on italics
  101.      * mode<dt>b<dd>turn on bold mode<dt>u<dd> turn on underline
  102.      * mode<dt>p<dd>go to plain text (no italics or
  103.      * bold)<dt>f<dd>select fixed width
  104.      * font</dl><dt>[+-]leftMargin<dd> integer new value of left
  105.      * margin - if + or - is specified, the new value is relative to
  106.      * the current value<dt>[+-]rightMargin<dd>integer new value of
  107.      * right margin - if + or - is specified, the new value is
  108.      * relative to the current value<dt>wrap<dd><dl compact><dt>not<dd>wrap
  109.      * only at newlines in the document<dt>word<dd>wrap at word
  110.      * bounderies<dt>char<dd>wrap as soon as a character doesn't fit
  111.      * on the line</dl></dl>.
  112.      */
  113.  
  114.     public BasicStyle(String spec) {
  115.     super(spec);
  116.     }
  117.  
  118.     /** Handles the initialization string described in the constructor. */
  119.     protected void handleStyleSpec(String spec) {
  120.     String    attr = specAttribute(spec);
  121.     String    value = specValue(spec);
  122.  
  123.     if (attr.equals("size")) {
  124.         setFontSize(Integer.parseInt(value));
  125.     } else if (attr.equals("color")) {
  126.         StringTokenizer t = new StringTokenizer(value, ":");
  127.         int    r, g, b;
  128.  
  129.         r = Integer.parseInt(t.nextToken());
  130.         g = Integer.parseInt(t.nextToken());
  131.         b = Integer.parseInt(t.nextToken());
  132.         setColor(r, g, b);
  133.     } else if (attr.equals("style")) {
  134.         int    i = 0;
  135.         int cnt = value.length();
  136.         int    c;
  137.  
  138.         while (--cnt >= 0) {
  139.         switch ((c = value.charAt(i++))) {
  140.         case 'i':
  141.             addFontAttribute(FormattingParameters.ITALIC);
  142.             break;
  143.  
  144.         case 'b':
  145.             addFontAttribute(FormattingParameters.BOLD);
  146.             break;
  147.  
  148.         case 'u':
  149.             addFontAttribute(FormattingParameters.UNDERLINE);
  150.             break;
  151.  
  152.         case 'p':
  153.             clearFontAttribute(FormattingParameters.ITALIC | FormattingParameters.BOLD);
  154.             break;
  155.  
  156.         case 'f':
  157.             setFontName("Courier");
  158.             break;
  159.  
  160.         default:
  161.             throw new Exception("Unknown font modifier: " + new Character((char)c));
  162.         }
  163.         }
  164.     } else if (attr.equals("leftMargin")) {
  165.         if (value.charAt(0) == '+' || value.charAt(0) == '-') {
  166.         lmarginIncrement = true;
  167.         if (value.charAt(0) == '+') {
  168.             value = value.substring(1);
  169.         }
  170.         }        
  171.         setLeftMargin(Integer.parseInt(value));
  172.     } else if (attr.equals("rightMargin")) {
  173.         if (value.charAt(0) == '+' || value.charAt(0) == '-') {
  174.         rmarginIncrement = true;
  175.         if (value.charAt(0) == '+') {
  176.             value = value.substring(1);
  177.         }
  178.         }        
  179.         setRightMargin(Integer.parseInt(value));
  180.     } else if (attr.equals("align")) {
  181.         switch (value.charAt(0)) {
  182.         case 'l':
  183.         setAlignment(FormattingParameters.ALIGN_LEFT);
  184.         break;
  185.  
  186.         case 'r':
  187.         setAlignment(FormattingParameters.ALIGN_RIGHT);
  188.         break;
  189.  
  190.         case 'c':
  191.         setAlignment(FormattingParameters.ALIGN_CENTER);
  192.         break;
  193.         }
  194.     } else if (attr.equals("wrap")) {
  195.         if (value.equals("not")) {
  196.         setWrap(FormattingParameters.WRAP_NOT);
  197.         } else if (value.equals("word")) {
  198.         setWrap(FormattingParameters.WRAP_WORD);
  199.         } else if (value.equals("char")) {
  200.         setWrap(FormattingParameters.WRAP_CHAR);
  201.         }
  202.     } else {
  203.         super.handleStyleSpec(spec);
  204.     }
  205.     }
  206.  
  207.     /**
  208.      * Processes this style in the context provided by a Formatter
  209.      * and a TagRef.  If the specified TagRef has a matching closing
  210.      * tag, then this pushes new parameters onto the formatter's
  211.      * parameter stack.  Otherwise it just applies the style changes
  212.      * implied by this BasicStyle object.
  213.      * @param f    the WRFormatter that's formatting the document
  214.      * that contained this style
  215.      * @param ref the html TagRef that refered to this style
  216.      * @see awt.Formatter
  217.      * @see WRFormatter
  218.      */
  219.  
  220.     public void start(WRFormatter f, TagRef ref) {
  221.     FormattingParameters    fp;
  222.  
  223.     super.start(f, ref);
  224.     if (ref.tag.hasEndTag) {
  225.         fp = new FormattingParameters(f.getParameters());
  226.     } else {
  227.         fp = f.getParameters();
  228.     }
  229.  
  230.     if (shouldApply(A_LMARGIN)) {
  231.         if (lmarginIncrement) {
  232.         fp.leftMargin += (short)leftMargin;
  233.         } else {
  234.         fp.leftMargin = (short)leftMargin;
  235.         }
  236.     }
  237.     if (shouldApply(A_RMARGIN)) {
  238.         if (rmarginIncrement) {
  239.         fp.rightMargin += (short)rightMargin;
  240.         } else {
  241.         fp.rightMargin = (short)rightMargin;
  242.         }
  243.     }
  244.     if (shouldApply(A_ATTR_ADD))
  245.         fp.fontAttr |= fontAttrAdd;
  246.     if (shouldApply(A_ATTR_CLR))
  247.         fp.fontAttr &= ~fontAttrClr;
  248.     if (shouldApply(A_FONT_SIZE))
  249.         fp.fontSize = (byte)fontSize;
  250.     if (shouldApply(A_FONT_NAME))
  251.         fp.fontName = fontName;
  252.     if (shouldApply(A_COLOR)) {
  253.         fp.r = r;
  254.         fp.g = g;
  255.         fp.b = b;
  256.     }
  257.     if (shouldApply(A_WRAP)) {
  258.         fp.wrapStyle = wrap;
  259.     }
  260.     if (shouldApply(A_ALIGN)) {
  261.         fp.alignment = align;
  262.     }
  263.     if (ref.tag.hasEndTag) {
  264. //        System.out.println("Pushing for: " + ref);
  265.         f.pushParameters(fp);
  266.     } else {
  267.         f.setParameters(fp);
  268.     }
  269.     }
  270.  
  271.     /**
  272.      * Processes this style in the context provided by a Formatter
  273.      * and a TagRef.  If the specified TagRef is a closing tag, then
  274.      * pop the formatter's parameter stack.
  275.      * @param f    the WRFormatter that's formatting the document
  276.      * that contained this style
  277.      * @param ref the html TagRef that refered to this style
  278.      * @see awt.Formatter
  279.      * @see WRFormatter
  280.      */
  281.     public void finish(WRFormatter f, TagRef ref) {
  282.     super.finish(f, ref);
  283.     if (ref.tag.hasEndTag) {
  284. //        System.out.println("Popping for: " + ref);
  285.         f.popParameters();
  286.     }
  287.     }
  288.  
  289.     public boolean shouldApply(int bit) {
  290.     return ((which & bit) != 0);
  291.     }
  292.  
  293.     public BasicStyle setWrap(byte wrap) {
  294.     this.wrap = wrap;
  295.     which |= A_WRAP;
  296.     return this;
  297.     }
  298.  
  299.     public BasicStyle setAlignment(byte align) {
  300.     this.align = align;
  301.     which |= A_ALIGN;
  302.     return this;
  303.     }    
  304.  
  305.     public BasicStyle setLeftMargin(int lm) {
  306.     leftMargin = lm;
  307.     which |= A_LMARGIN;
  308.     return this;
  309.     }
  310.  
  311.     public BasicStyle setRightMargin(int rm) {
  312.     rightMargin = rm;
  313.     which |= A_RMARGIN;
  314.     return this;
  315.     }
  316.  
  317.     public BasicStyle addFontAttribute(int attr) {
  318.     fontAttrAdd = attr;
  319.     which |= A_ATTR_ADD;
  320.     return this;
  321.     }
  322.  
  323.     public BasicStyle clearFontAttribute(int attr) {
  324.     fontAttrClr = attr;
  325.     which |= A_ATTR_CLR;
  326.     return this;
  327.     }
  328.  
  329.     public BasicStyle setFontSize(int size) {
  330.     fontSize = size;
  331.     which |= A_FONT_SIZE;
  332.     return this;
  333.     }
  334.  
  335.     public BasicStyle setFontName(String name) {
  336.     fontName = name;
  337.     which |= A_FONT_NAME;
  338.     return this;
  339.     }
  340.  
  341.     public BasicStyle setColor(int r, int g, int b) {
  342.     this.r = (short)r;
  343.     this.g = (short)g;
  344.     this.b = (short)b;
  345.     which |= A_COLOR;
  346.     return this;
  347.     }
  348. }
  349.  
  350.