textline.java

java 作图的程序

         if(g == null) return 0;

         parseText(g);

         return leading;
      
     }
  /**
   * parse the text. When the text is parsed the width, height, leading
   * are all calculated. The text will only be truly parsed if
   * the graphics context has changed or the text has changed or
   * the font has changed. Otherwise nothing is done when this
   * method is called. 
   * @param g Graphics context.
   */

     public void parseText(Graphics g) {
         FontMetrics fm;
         TextState current = new TextState();
         char ch;
         Stack state = new Stack();
         int w = 0;

         if(lg != g) parse = true;
         lg = g;

         if(!parse) return;

         parse = false;
         width   = 0;
         leading = 0;
         ascent  = 0;
         descent = 0;
         height  = 0;
         maxAscent = 0;
         maxDescent = 0;

         if( text == null || g == null) return;

         list.removeAllElements();


         if(font == null) current.f = g.getFont();
         else             current.f = font;

         state.push(current);
         list.addElement(current);
         
         fm = g.getFontMetrics(current.f);

         for(int i=0; i<text.length(); i++) {
             ch = text.charAt(i);

             switch (ch) {

             case '$':
                      i++;
                      if(i<text.length()) current.s.append(text.charAt(i));
                      break;
/*
**                    Push the current state onto the state stack
**                    and start a new storage string
*/
	     case '{':
                      w = current.getWidth(g);
                      if(!current.isEmpty()) {
                           current = current.copyState();
                           list.addElement(current);
		      }

                      state.push(current);
                      current.x += w;
                      break;
/*
**                    Pop the state off the state stack and set the current
**                    state to the top of the state stack
*/
	     case '}':
                      w = current.x + current.getWidth(g);
                      state.pop();
                      current = ((TextState)state.peek()).copyState();
                      list.addElement(current);
                      current.x = w;
                      break;
	     case '^':
                      w = current.getWidth(g);
                      if(!current.isEmpty()) {
                           current = current.copyState();
                           list.addElement(current);
		      }
                      current.f = getScriptFont(current.f);
                      current.x += w;
                      current.y -= (int)((double)(current.getAscent(g))*sup_offset+0.5);
                      break;
 	     case '_':
                      w = current.getWidth(g);
                      if(!current.isEmpty()) {
                           current = current.copyState();
                           list.addElement(current);
		      }
                      current.f = getScriptFont(current.f);
                      current.x += w;
                      current.y += (int)((double)(current.getDescent(g))*sub_offset+0.5);
                      break;

             default: 
                      current.s.append(ch);
                      break;
	     }
	   }



         for(int i=0; i<list.size(); i++) {
            current = ((TextState)(list.elementAt(i)));

            if( !current.isEmpty() ) {
               width  += current.getWidth(g);
               ascent  = Math.max(ascent, Math.abs(current.y) + 
                                          current.getAscent(g));
               descent = Math.max(descent, Math.abs(current.y) + 
                                          current.getDescent(g));
               leading  = Math.max(leading, current.getLeading(g));

               maxDescent = Math.max(maxDescent, Math.abs(current.y) + 
                                          current.getMaxDescent(g));
               maxAscent  = Math.max(maxAscent, Math.abs(current.y) + 
                                          current.getMaxAscent(g));
	     }
         }

         height = ascent+descent+leading;

         return;

     }

  /**
   * @return true if the text has never been set or is null
   */
     public boolean isNull() {
        return (text==null);
      }
  /**
   * Parse the text then draw it.
   * @param g Graphics context
   * @param x pixel position of the text
   * @param y pixel position of the text
   * @param j justification of the text
   */
     public void draw(Graphics g, int x, int y, int j) {
         justification = j;

         if( g == null ) return;

         draw(g,x,y);
       }
  /**
   * Parse the text then draw it without any rotation.
   * @param g Graphics context
   * @param x pixel position of the text
   * @param y pixel position of the text
   */
     public void draw(Graphics g, int x, int y) {
         TextState ts;
         int xoffset = x;
         int yoffset = y;
      

         if(g == null || text == null) return;

 
         Graphics lg = g.create();

         parseText(g);


         if(justification == CENTER ) {
               xoffset = x-width/2;
         } else 
         if(justification == RIGHT ) {      
               xoffset = x-width;
	 }

         if(background != null) {
            lg.setColor(background);
            lg.fillRect(xoffset,yoffset-ascent,width,height);
            lg.setColor(g.getColor());
         }

         if(font  != null) lg.setFont(font);
         if(color != null) lg.setColor(color);

         for(int i=0; i<list.size(); i++) {
              ts = ((TextState)(list.elementAt(i)));
              if(ts.f != null) lg.setFont(ts.f);
              if(ts.s != null) 
                   lg.drawString(ts.toString(),ts.x+xoffset,ts.y+yoffset);
	 }

         lg.dispose();

         lg = null;

       }


  /**
   * @return Logical font name of the set font
   */
      public String getFontName()  { return fontname; }
  /**
   * @return Style of the set font
   */
      public int    getFontStyle() { return fontstyle; }
  /**
   * @return Size of the set font
   */
      public int    getFontSize()  { return fontsize; }
  /**
   * Set the Logical font name of the current font
   * @param s Logical font name.
   */
      public void setFontName(String s) {  fontname  = s; rebuildFont(); }
  /**
   * Set the Font style of the current font
   * @param i Font style.
   */
      public void setFontStyle(int i)   {  fontstyle = i; rebuildFont(); }
  /**
   * Set the Font size of the current font
   * @param i Font size.
   */
      public void setFontSize(int i)    {  fontsize  = i; rebuildFont(); }

  /*
  ** Rebuild the font using the current fontname, fontstyle, and fontsize.
  */
      private void rebuildFont() {
         parse = true;

         if( fontsize <= 0 || fontname == null   ) {
              font = null;
	    } else {

              font = new Font(fontname, fontstyle, fontsize);
	    }
       }

  /**
   * @param f Font
   * @return The script font version of the parsed font using the
   *        script_fraction variable.
   */
        public Font getScriptFont(Font f) {
             int size;

             if(f == null) return f;

             size = f.getSize();

             if(size <= MINIMUM_SIZE) return f;

             size = (int)((double)(f.getSize())*script_fraction + 0.5);

             if(size <= MINIMUM_SIZE) return f;

             return new Font(f.getName(), f.getStyle(), size);
	   }
  /**
   * Parse a double value. Precision is 6 figures, with 7 significant
   * figures.
   * @param d double to parse
   * return <i>true</i> if the parse was successful
   */

     public boolean parseDouble(double d) {
           return parseDouble(d, 7, 6, ALGEBRAIC);
     }

  /**
   * Parse a double value. Number of significant figures is 1 greater than
   * the precision.
   * @param d double to parse
   * @param p precision of the number
   * return <i>true</i> if the parse was successful
   */

     public boolean parseDouble(double d, int p) {
           return parseDouble(d, p+1, p, ALGEBRAIC);
     }

  /**
   * Parse a double value
   * @param d double to parse
   * @param n number of significant figures
   * @param p precision of the number
   * @param f format of the number scientific, algebraic etc.
   * return <i>true</i> if the parse was successful
   */

     public boolean parseDouble(double d, int n, int p, int f) {
         double x = d;
         int left = n - p;
         double right = 0;
         int power;
         int exponent;
         int i;
         StringBuffer s = new StringBuffer(n+4);

        
         if(left < 0 ) {
            System.out.println(
                "TextLine.parseDouble: Precision > significant figures!");
            return false;
         } 

         if(d < 0.0) {
                      x = -d;
                      s.append("-");
         } 


         //System.out.println("parseDouble: value = "+x);

         if( d == 0.0 ) exponent = 0;
         else           exponent = (int)(Math.floor(SpecialFunction.log10(x)));


         //System.out.println("parseDouble: exponent = "+exponent);

         power = exponent - (left - 1);

         //System.out.println("parseDouble: power = "+power);

         if( power < 0 ) {
             for(i=power; i<0; i++) { x *= 10.0; }
         } else {
             for(i=0; i<power; i++) { x /= 10.0; }
         }

         //System.out.println("parseDouble: adjusted value = "+x);

         left = (int)x;
         s.append(left);

         //System.out.println("parseDouble: left = "+left);

         if( p > 0 ) {
           s.append('.');
           right = x-left;
           for(i=0; i<p; i++) {
                 right *= 10;
                 if(i==p-1) right += 0.5;
                 s.append((int)(right)); 
                 right -= (int)right;
	   }
	 }
         
         //System.out.println("parseDouble: right = "+right);


         if(power != 0) {
              if(f == SCIENTIFIC) {
                              s.append('E');
                              if(power < 0) s.append('-');
                              else          s.append('+');
                              power = Math.abs(power);
                              if(power > 9) {
                                      s.append(power);
                              } else {
                                      s.append('0');
                                      s.append(power);
                              }
              } else {
                              s.append("x10{^");
                              s.append(power);
                              s.append("}");
	      }
	 }

         setText( s.toString() );

         return true;
     
     }
   }


/**
 * A structure class used exclusively with the TextLine class.
 * When the Text changes state (new font, new color, new offset)
 * then this class holds the information plus the substring
 * that the state pertains to.
 */
class TextState extends Object { 
      Font f         = null;
      StringBuffer s = null;
      int x          = 0;
      int y          = 0;

      
      public TextState() {
              s = new StringBuffer();
	    }


      public TextState copyAll() {
             TextState tmp = copyState();
             if(s.length()==0) return tmp;
             for(int i=0; i<s.length(); i++) { tmp.s.append(s.charAt(i)); }
             return tmp;
	   }


      public TextState copyState() {
             TextState tmp = new TextState();
             tmp.f = f;
             tmp.x = x;
             tmp.y = y;
             return tmp;
	   }


      public String toString() {
             return s.toString();
	   }


      public boolean isEmpty() {
           return (s.length() == 0);
	 }

      public int getWidth(Graphics g) {

           if(g == null || f == null || s.length()==0 ) return 0;

           return g.getFontMetrics(f).stringWidth(s.toString());
      }

      public int getHeight(Graphics g) {
           if(g == null || f == null ) return 0;
           
           return g.getFontMetrics(f).getHeight();
	 }
      public int getAscent(Graphics g) {
           if(g == null || f == null ) return 0;
           
           return g.getFontMetrics(f).getAscent();
	 }
      public int getDescent(Graphics g) {
           if(g == null || f == null ) return 0;
           
           return g.getFontMetrics(f).getDescent();
	 }
      public int getMaxAscent(Graphics g) {
           if(g == null || f == null ) return 0;
           
           return g.getFontMetrics(f).getMaxAscent();
	 }
      public int getMaxDescent(Graphics g) {
           if(g == null || f == null ) return 0;
           
           return g.getFontMetrics(f).getMaxDescent();
	 }
      public int getLeading(Graphics g) {
           if(g == null || f == null ) return 0;
           
           return g.getFontMetrics(f).getLeading();
	 }
}