home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 May / PCW596.iso / wtest / clico / sunsoft / java / solaris.taz / solaris / hotjava / classsrc / awt / Formatter.java < prev    next >
Encoding:
Java Source  |  1995-05-15  |  11.0 KB  |  460 lines
  1. /*
  2.  * @(#)Formatter.java    1.31 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. package awt;
  20.  
  21. import java.util.*;
  22.  
  23. /**
  24.  * A class that knows how to layout a set of DisplayItems inside a
  25.  * window.
  26.  *
  27.  * @version 1.31 10 Apr 1995
  28.  * @author Jonathan Payne
  29.  */
  30. public class Formatter {
  31.     final boolean   debug = false;
  32.  
  33.     static Hashtable    colors = new Hashtable();
  34.  
  35.     /** Current formatting parameters. */
  36.     protected FormattingParameters  currentParameters;
  37.  
  38.     /** Current X coordinate, where next display item will
  39.     be added. */
  40.     protected int            x;
  41.  
  42.     /** Current X limit for the right margin.  If a display item
  43.     moves beyond xlimit, we wrap. */
  44.     protected int            xlimit;
  45.  
  46.     /** Current Y coordinate.  This is the value of Y for the top
  47.     of the current line we're building. */
  48.     protected int            y;
  49.  
  50.     /** Current lineAscent for this line. */
  51.     protected int            lineAscent;
  52.  
  53.     /** Current lineDescent for this line. */
  54.     protected int            lineDescent;
  55.  
  56.     /** Current maximum font ascent. */
  57.     protected int            fontAscent;
  58.  
  59.     /** Current font as determined by the current FormattingParameters. */
  60.     protected Font            font;
  61.  
  62.     /** Metrics of the current font. */
  63.     protected FontMetrics        fontmetrics;
  64.  
  65.     /** Current color as determined by the current FormattingParameters. */
  66.     protected Color            color;
  67.  
  68.     /** The display item index of the first item on this line.  This is
  69.     used to go back to position all the items we accumulate on the
  70.     line we're laying out right now. */
  71.     protected int            lineStartIndex;
  72.  
  73.     /** Total number of items we think we've added to the window. */
  74.     protected int            itemCount;
  75.  
  76.     /** This is the stack of formatting parameters. */
  77.     protected Stack            fpStack = new Stack();
  78.  
  79.     /** This is true when we're in a section that doesn't render. */
  80.     protected int            notRendering = 0;
  81.  
  82.     /** This is used to combine requests to break a paragraph.  This
  83.     is how much of a break we have accumulated so far since we last
  84.     wrapped.  If a request to break is greater than this number, we
  85.     bump the new Y position by that much further. */
  86.     protected int            breakSoFar;
  87.  
  88.     /** This is the window we're laying objects out in. */
  89.     public TextWindow        win;
  90.  
  91.     private int    heightChunk;
  92.  
  93.     public Formatter(TextWindow w) {
  94.     win = w;
  95.     }
  96.  
  97.     private Font newFont() {
  98.     return win.getFont(currentParameters.fontName,
  99.                currentParameters.fontAttr,
  100.                currentParameters.fontSize);
  101.     }
  102.  
  103.     private Color newColor() {
  104.     Integer colorID = new Integer((currentParameters.r << 16) +
  105.                       (currentParameters.g << 8) +
  106.                       currentParameters.b);
  107.     Color    color;
  108.  
  109.     if ((color = (Color) colors.get(colorID)) == null) {
  110.         color = new Color(win.wServer,
  111.                   currentParameters.r,
  112.                   currentParameters.g,
  113.                   currentParameters.b);
  114.         colors.put(colorID, color);
  115.     }
  116.     return color;
  117.     }
  118.  
  119.     public void setParameters(FormattingParameters fp) {
  120.     if ((currentParameters = fp) != null) {
  121.         font = newFont();
  122.         fontmetrics = win.getFontMetrics(font);
  123.         color = newColor();
  124.         if (atBeginningOfLine()) {
  125.         x = currentParameters.leftMargin;
  126.         }
  127.         xlimit = win.width - currentParameters.rightMargin;
  128.     }
  129.     }
  130.  
  131.     protected void finishCurrentLine() {
  132.     int limit = itemCount;
  133.     int offset;
  134.  
  135.     switch (currentParameters.alignment) {
  136.     case FormattingParameters.ALIGN_LEFT:
  137.     default:
  138.         offset = 0;
  139.         break;
  140.  
  141.     case FormattingParameters.ALIGN_RIGHT:
  142.         offset = xlimit - x;
  143.         break;
  144.  
  145.     case FormattingParameters.ALIGN_CENTER:
  146.         offset = (xlimit - x) / 2;
  147.         break;
  148.     }
  149.  
  150.     while (lineStartIndex < limit) {
  151.         DisplayItem    di = win.nthItem(lineStartIndex++);
  152.  
  153.         adjustItem(di, di.x + offset);
  154.     }
  155.  
  156.     int height = lineAscent + lineDescent;
  157.  
  158.     if (height > 0) {
  159.         y += height + 1;
  160.     } else if (fontmetrics != null) {
  161.         y += fontmetrics.height + 1;
  162.     }
  163.     ((TextWindow) win).startNewLine(itemCount);
  164.     win.logicalHeight = y;
  165.  
  166.     int hChunk = y >> 10;
  167.     if (hChunk > heightChunk) {
  168.         win.updateScrollbar();
  169.         heightChunk = hChunk;
  170.     }
  171.     }
  172.  
  173.     protected void adjustItem(DisplayItem di, int x) {
  174.     di.move(x, di.y);
  175.     if (di instanceof TextDisplayItem) {
  176.         ((TextDisplayItem) di).moveBaseline(y + lineAscent);
  177.     }
  178.     }
  179.  
  180.     protected abstract int getLength();
  181.     protected abstract int charAt(int i);
  182.     protected abstract TextDisplayItem makeTextItem(int pos0, int pos1);
  183.  
  184.     protected boolean outputString(int pos0, int pos1, int width) {
  185.     if (notRendering > 0) {
  186.         return true;
  187.     }
  188.  
  189.     TextDisplayItem    t = makeTextItem(pos0, pos1);
  190.     int ascent = fontmetrics.ascent;
  191.     int descent = fontmetrics.descent;
  192.  
  193.     t.setup(font, color, x, y, width, fontmetrics.height);
  194.     if (ascent > lineAscent) {
  195.         lineAscent = ascent;
  196.     }
  197.     if (ascent > fontAscent) {
  198.         fontAscent = ascent;
  199.     }
  200.     if (descent > lineDescent) {
  201.         lineDescent = descent;
  202.     }
  203.     t.valid = true;
  204.     return addDisplayItem(t, false);
  205.     }
  206.  
  207.     /* Process all the style refs at position pos, and then return
  208.        the next text position that we have to worry about style refs.
  209.        By default, assume no style refs. */
  210.  
  211.     protected int processStyleRefs(int pos) {
  212.     return getLength();
  213.     }
  214.  
  215.     protected void setBreakSoFar(int value) {
  216. //    System.out.println("breakSoFar: " + breakSoFar + " => " + value);
  217.     breakSoFar = value;
  218.     }
  219.  
  220.     protected void reset() {
  221.     fpStack.setSize(0);
  222.     heightChunk = -1;
  223.     lineStartIndex = itemCount = win.count();
  224.     y = x = 0;
  225.     lineAscent = fontAscent = lineDescent = 0;
  226.  
  227.     /* setting this high causes all leading breaks to be ignored. */
  228.     setBreakSoFar(10000);
  229.     }
  230.  
  231.     public void layout() {
  232.     reset();
  233.     win.startNewLine(0);
  234.  
  235.     pushParameters(new FormattingParameters(currentParameters));
  236.  
  237.     int    lastSpaceX;
  238.     int    lastSpace;
  239.     int    x = this.x;
  240.     int    xlimit = this.xlimit;
  241.     int    posLimit = getLength();
  242.     int    pos = 0;
  243.     int    pos0 = 0;
  244.     int    stylePos = 0;
  245.     int    wrap = 0;
  246.     int    widths[] = null;
  247.     int    lastWrapPos = -1;
  248.  
  249.     stylePos = 0;
  250.     lastSpaceX = -1;
  251.     lastSpace = -1;
  252.  
  253.     try {
  254.         while (pos < posLimit) {
  255.         if (pos >= stylePos) {
  256.             if (pos > pos0) {
  257.             outputString(pos0, pos, x - this.x);
  258.             x = this.x;
  259.             pos0 = pos;
  260.             }
  261.             this.x = x;
  262.             stylePos = processStyleRefs(pos);
  263.             x = this.x;
  264.             widths = fontmetrics.widths;
  265.             wrap = currentParameters.wrapStyle;
  266.             xlimit = this.xlimit;
  267.             lastSpace = pos;
  268.             if (win.formatter != this) {
  269.             System.out.println("Formatter aborting!");
  270.             return;
  271.             }
  272.         } else if (notRendering > 0) {
  273.             pos++;
  274.             continue;
  275.         }
  276.         int    c = charAt(pos);
  277.         int    newx;
  278.  
  279.         if (c == '\t') {
  280.             int tabWidth = widths[' '] * 8;
  281.  
  282.             if (pos > pos0) {
  283.             outputString(pos0, pos, x - this.x);
  284.             x = this.x;
  285.             }
  286.             pos0 = pos + 1;
  287.             newx = (x += tabWidth
  288.                 - ((x - currentParameters.leftMargin) % tabWidth));
  289.             this.x = newx;
  290.         } else {
  291.             if (c == ' ') {
  292.             lastSpace = pos;
  293.             lastSpaceX = x;
  294.             }
  295.             newx = x + widths[c];
  296.         } 
  297.         if ((newx >= xlimit && wrap != FormattingParameters.WRAP_NOT) 
  298.             || c == '\n') {
  299.             if (c != '\n' && wrap == FormattingParameters.WRAP_WORD
  300.             && (lastSpace > pos0
  301.                 || this.x != currentParameters.leftMargin)) {
  302.             pos = lastSpace;
  303.             x = lastSpaceX;
  304.             }
  305.             if (pos > pos0) {
  306.             if (!outputString(pos0, pos, x - this.x)) {
  307.                 System.out.println("Formatter aborting!");
  308.                 return;
  309.             }
  310.             }
  311.             if (c != '\n') {
  312.             while (pos < posLimit && (c = charAt(pos)) == ' ')
  313.                 pos += 1;
  314.             }
  315.             if (c == '\n') {
  316.             pos += 1;
  317.             }
  318.             wrapLine();
  319.             lastSpace = pos0 = pos;
  320.             x = this.x;
  321.             if (pos == lastWrapPos) {
  322.             System.out.println("Breaking: infinite loop");
  323.             break;
  324.             }
  325.             lastWrapPos = pos;
  326.             continue;
  327.         }
  328.         x = newx;
  329.         pos += 1;
  330.         }
  331.         if (pos > pos0) {
  332.         outputString(pos0, pos, x - this.x);
  333.         }
  334.         this.x = x;
  335.         stylePos = processStyleRefs(pos);
  336.         breakLine(12);    /* add a newline to the end of the document */
  337.         popParameters();
  338.     } finally {
  339.         win.logicalHeight = y;
  340.     }
  341.     }
  342.  
  343.     public void pushParameters(FormattingParameters p) {
  344.     if (p == null) {
  345.         p = new FormattingParameters(currentParameters);
  346.     }
  347.     fpStack.push(currentParameters);
  348.     setParameters(p);
  349.     }
  350.  
  351.     public void popParameters() {
  352.     FormattingParameters    fp;
  353.  
  354.     fp = (FormattingParameters) fpStack.pop();
  355.     setParameters(fp);
  356.     }
  357.  
  358.     public FormattingParameters getParameters() {
  359.     return currentParameters;
  360.     }
  361.  
  362.     public boolean addDisplayItem(DisplayItem di, boolean checkWrap) {
  363.     if (win.formatter != this) {
  364.         return false;
  365.     }
  366.     win.addItem(di);
  367.     if (checkWrap && x + di.width > xlimit) {
  368.         wrapLine();
  369.     }
  370.     /* display are aligned to the text baseline by default */
  371.     lineAscent = Math.max(lineAscent, di.height - lineDescent);
  372.     di.move(x, y);
  373.     if (debug) {
  374.         System.out.println("Adding #" + itemCount + " = " + di);
  375.     }
  376.     x += di.width;
  377.     itemCount += 1;
  378.     setBreakSoFar(-1);
  379.     return true;
  380.     }
  381.  
  382.     public void setLeftMargin(int lm) {
  383.     currentParameters.leftMargin = (short)lm;
  384.     setParameters(currentParameters);
  385.     }
  386.  
  387.     public boolean atBeginningOfLine() {
  388.     return (lineStartIndex == itemCount
  389.          || x == currentParameters.leftMargin);
  390.     }
  391.  
  392.     public int getLeftMargin() {
  393.     return currentParameters.leftMargin;
  394.     }
  395.  
  396.     public int getRightMargin() {
  397.     return win.width - currentParameters.rightMargin;
  398.     }
  399.  
  400.     public void setXCoordinate(int x) {
  401.     this.x = x;
  402.     }
  403.  
  404.     public int getXCoordinate() {
  405.     return x;
  406.     }
  407.  
  408.     public int getYCoordinate() {
  409.     return y;
  410.     }
  411.  
  412.     public void addCharacterSpacing(char c) {
  413.     int width = fontmetrics.widths[c];
  414.  
  415.     if (x + width < xlimit) {
  416.         x += width;
  417.     }
  418.     }
  419.  
  420.     public void wrapLine() {
  421.     if (debug) {
  422.         System.out.println("Wrapping");
  423.     }
  424.     setBreakSoFar(0);
  425.     finishCurrentLine();
  426.     x = currentParameters.leftMargin;
  427.     /* At some point I felt the need to change the line below
  428.        to the lines that are commented out above.  That caused
  429.        other problems which I am fixing now.  Hopefully next time
  430.        I won't have to remember why I did this! */
  431.     lineAscent = fontAscent = lineDescent = 0;
  432.     }
  433.  
  434.     public void breakLine(int extra) {
  435.     if (breakSoFar == -1) {
  436.         wrapLine();
  437.     }
  438.     if (extra > breakSoFar) {
  439.         y += (extra - breakSoFar);
  440.         setBreakSoFar(extra);
  441.     }
  442.     }
  443.  
  444.     public Font getFont() {
  445.     return font;
  446.     }
  447.  
  448.     public Color getColor() {
  449.     return color;
  450.     }
  451.  
  452.     public void stopRendering() {
  453.     notRendering += 1;
  454.     }
  455.  
  456.     public void startRendering() {
  457.     notRendering -= 1;
  458.     }
  459. }
  460.