1. /*

  2.  * @(#)GlyphPainter2.java	1.12 00/02/02

  3.  *

  4.  * Copyright 1999, 2000 Sun Microsystems, Inc. All Rights Reserved.

  5.  * 

  6.  * This software is the proprietary information of Sun Microsystems, Inc.  

  7.  * Use is subject to license terms.

  8.  * 

  9.  */

  10. package javax.swing.text;

  11. 

  12. import java.text.*;

  13. import java.awt.*;

  14. import java.awt.font.*;

  15. import java.awt.geom.Rectangle2D;

  16. 

  17. /**

  18.  * A class to perform rendering of the glyphs.

  19.  * This can be implemented to be stateless, or

  20.  * to hold some information as a cache to 

  21.  * facilitate faster rendering and model/view

  22.  * translation.  At a minimum, the GlyphPainter

  23.  * allows a View implementation to perform its

  24.  * duties independant of a particular version

  25.  * of JVM and selection of capabilities (i.e.

  26.  * shaping for i18n, etc).

  27.  * <p>

  28.  * This implementation is intended for operation

  29.  * under the Java 2 SDK.  It uses the 

  30.  * java.awt.font.TextLayout class to do i18n capable

  31.  * rendering.

  32.  *

  33.  * @author  Timothy Prinzing

  34.  * @version 1.12 02/02/00

  35.  * @see GlyphView

  36.  */

  37. class GlyphPainter2 extends GlyphView.GlyphPainter {

  38. 

  39.     public GlyphPainter2(TextLayout layout) {

  40. 	this.layout = layout;

  41.     }

  42. 

  43.     /**

  44.      * Create a painter to use for the given GlyphView.  

  45.      */

  46.     public GlyphView.GlyphPainter getPainter(GlyphView v, int p0, int p1) {

  47. 	return null;

  48.     }

  49. 

  50.     /**

  51.      * Determine the span the glyphs given a start location

  52.      * (for tab expansion).  This implementation assumes it

  53.      * has no tabs (i.e. TextLayout doesn't deal with tab

  54.      * expansion).

  55.      */

  56.     public float getSpan(GlyphView v, int p0, int p1, 

  57. 			 TabExpander e, float x) {

  58. 

  59. 	if ((p0 == v.getStartOffset()) && (p1 == v.getEndOffset())) {

  60. 	    return layout.getAdvance();

  61. 	}

  62. 	int p = v.getStartOffset();

  63. 	int index0 = p0 - p;

  64. 	int index1 = p1 - p;

  65. 

  66. 	TextHitInfo hit0 = TextHitInfo.afterOffset(index0);

  67. 	TextHitInfo hit1 = TextHitInfo.beforeOffset(index1);

  68. 	float[] locs = layout.getCaretInfo(hit0);

  69. 	float x0 = locs[0];

  70. 	locs = layout.getCaretInfo(hit1);

  71. 	float x1 = locs[0];

  72. 	return (x1 > x0) ? x1 - x0 : x0 - x1;

  73.     }

  74. 

  75.     public float getHeight(GlyphView v) {

  76. 	return layout.getAscent() + layout.getDescent() + layout.getLeading();

  77.     }

  78. 

  79.     /**

  80.      * Fetch the ascent above the baseline for the glyphs

  81.      * corresponding to the given range in the model.

  82.      */

  83.     public float getAscent(GlyphView v) {

  84. 	return layout.getAscent();

  85.     }

  86. 

  87.     /**

  88.      * Fetch the descent below the baseline for the glyphs

  89.      * corresponding to the given range in the model.

  90.      */

  91.     public float getDescent(GlyphView v) {

  92. 	return layout.getDescent();

  93.     }

  94. 

  95.     /**

  96.      * Paint the glyphs for the given view.  This is implemented

  97.      * to only render if the Graphics is of type Graphics2D which

  98.      * is required by TextLayout (and this should be the case if

  99.      * running on the Java2 SDK).

  100.      */

  101.     public void paint(GlyphView v, Graphics g, Shape a, int p0, int p1) {

  102. 	if (g instanceof Graphics2D) {

  103. 	    Rectangle2D alloc = a.getBounds2D();

  104. 	    Graphics2D g2d = (Graphics2D)g;

  105. 	    float y = (float) alloc.getY() + layout.getAscent() + layout.getLeading();

  106. 	    float x = (float) alloc.getX();

  107.             if( p0 > v.getStartOffset() || p1 < v.getEndOffset() ) {

  108.                 try {

  109.                     //TextLayout can't render only part of it's range, so if a

  110.                     //partial range is required, add a clip region.

  111.                     Shape s = v.modelToView(p0, Position.Bias.Forward,

  112.                                             p1, Position.Bias.Backward, a);

  113.                     Shape savedClip = g.getClip();

  114.                     g.setClip(s);

  115.                     layout.draw(g2d, x, y);

  116.                     g.setClip(savedClip);

  117.                 } catch (BadLocationException e) {}

  118.             } else {

  119.                 layout.draw(g2d, x, y);

  120.             }

  121. 	}

  122.     }

  123. 

  124.     public Shape modelToView(GlyphView v, int pos, Position.Bias bias,

  125. 			     Shape a) throws BadLocationException {

  126. 	int offs = pos - v.getStartOffset();

  127. 	Rectangle2D alloc = a.getBounds2D();

  128. 	TextHitInfo hit = (bias == Position.Bias.Forward) ? 

  129. 	    TextHitInfo.afterOffset(offs) : TextHitInfo.beforeOffset(offs);

  130. 	float[] locs = layout.getCaretInfo(hit);

  131. 

  132. 	// vertical at the baseline, should use slope and check if glyphs

  133. 	// are being rendered vertically.

  134. 	alloc.setRect(alloc.getX() + locs[0], alloc.getY(), 1, alloc.getHeight());

  135. 	return alloc;

  136.     }

  137. 

  138.     /**

  139.      * Provides a mapping from the view coordinate space to the logical

  140.      * coordinate space of the model.

  141.      *

  142.      * @param x the X coordinate

  143.      * @param y the Y coordinate

  144.      * @param a the allocated region to render into

  145.      * @param rightToLeft true if the text is rendered right to left

  146.      * @return the location within the model that best represents the

  147.      *  given point of view

  148.      * @see View#viewToModel

  149.      */

  150.     public int viewToModel(GlyphView v, float x, float y, Shape a, 

  151. 			   Position.Bias[] biasReturn) {

  152. 

  153. 	Rectangle2D alloc = (a instanceof Rectangle2D) ? (Rectangle2D)a : a.getBounds2D();

  154.         //Move the y co-ord of the hit onto the baseline.  This is because TextLayout supports

  155.         //italic carets and we do not.

  156. 	TextHitInfo hit = layout.hitTestChar(x - (float)alloc.getX(), 0);

  157. 	int pos = hit.getInsertionIndex();

  158. 	biasReturn[0] = hit.isLeadingEdge() ? Position.Bias.Forward : Position.Bias.Backward;

  159. 	return pos + v.getStartOffset();

  160.     }

  161. 

  162.     /**

  163.      * Determines the model location that represents the

  164.      * maximum advance that fits within the given span.

  165.      * This could be used to break the given view.  The result 

  166.      * should be a location just shy of the given advance.  This

  167.      * differs from viewToModel which returns the closest

  168.      * position which might be proud of the maximum advance.

  169.      *

  170.      * @param v the view to find the model location to break at.

  171.      * @param p0 the location in the model where the

  172.      *  fragment should start it's representation >= 0.

  173.      * @param pos the graphic location along the axis that the

  174.      *  broken view would occupy >= 0.  This may be useful for

  175.      *  things like tab calculations.

  176.      * @param len specifies the distance into the view

  177.      *  where a potential break is desired >= 0.  

  178.      * @return the maximum model location possible for a break.

  179.      * @see View#breakView

  180.      */

  181.     public int getBoundedPosition(GlyphView v, int p0, float x, float len) {

  182.         if( len < 0 )

  183.             throw new IllegalArgumentException("Length must be >= 0.");

  184. 

  185.         TextHitInfo hit = layout.hitTestChar(len, 0);

  186. 

  187.         if( (hit.getCharIndex() == -1) && !layout.isLeftToRight() ) {

  188.             return v.getEndOffset();

  189.         }

  190. 	int pos = (hit.isLeadingEdge()) ? hit.getInsertionIndex()

  191.                   : hit.getInsertionIndex() - 1;

  192. 	return pos + v.getStartOffset(); 

  193.     }

  194.     

  195.     /**

  196. 	 * Provides a way to determine the next visually represented model

  197. 	 * location that one might place a caret.  Some views may not be

  198. 	 * visible, they might not be in the same order found in the model, or

  199. 	 * they just might not allow access to some of the locations in the

  200. 	 * model.

  201. 	 *

  202. 	 * @param v the view to use

  203. 	 * @param pos the position to convert >= 0

  204. 	 * @param a the allocated region to render into

  205. 	 * @param direction the direction from the current position that can

  206. 	 *  be thought of as the arrow keys typically found on a keyboard.

  207. 	 *  This may be SwingConstants.WEST, SwingConstants.EAST, 

  208. 	 *  SwingConstants.NORTH, or SwingConstants.SOUTH.  

  209. 	 * @return the location within the model that best represents the next

  210. 	 *  location visual position.

  211. 	 * @exception BadLocationException

  212. 	 * @exception IllegalArgumentException for an invalid direction

  213. 	 */

  214.         public int getNextVisualPositionFrom(GlyphView v, int pos, 

  215.                                              Position.Bias b, Shape a, 

  216. 					     int direction,

  217. 					     Position.Bias[] biasRet) 

  218. 	    throws BadLocationException {

  219. 

  220. 	    int startOffset = v.getStartOffset();

  221. 	    int endOffset = v.getEndOffset();

  222. 	    Segment text;

  223.             AbstractDocument doc;

  224.             boolean viewIsLeftToRight;

  225.             TextHitInfo currentHit, nextHit;

  226. 	    

  227. 	    switch (direction) {

  228. 	    case View.NORTH:

  229. 		break;

  230. 	    case View.SOUTH:

  231. 		break;

  232. 	    case View.EAST:

  233.                 doc = (AbstractDocument)v.getDocument();

  234.                 viewIsLeftToRight = doc.isLeftToRight(startOffset, endOffset);

  235.                 

  236. 		if(startOffset == doc.getLength()) {

  237. 		    if(pos == -1) {

  238. 			biasRet[0] = Position.Bias.Forward;

  239. 			return startOffset;

  240. 		    }

  241. 		    // End case for bidi text where newline is at beginning

  242. 		    // of line.

  243. 		    return -1;

  244. 		}

  245. 		if(pos == -1) {

  246.                     // Entering view from the left.

  247.                     if( viewIsLeftToRight ) {

  248.                         biasRet[0] = Position.Bias.Forward;

  249.                         return startOffset;

  250.                     } else {

  251.                         text = v.getText(endOffset - 1, endOffset);

  252.                         if(text.array[text.offset] == '\n') {

  253.                             biasRet[0] = Position.Bias.Forward;

  254.                             return endOffset-1;

  255.                         }

  256.                         biasRet[0] = Position.Bias.Backward;

  257.                         return endOffset;

  258.                     }

  259. 		}

  260.                 if( b==Position.Bias.Forward )

  261.                     currentHit = TextHitInfo.afterOffset(pos-startOffset);

  262.                 else

  263.                     currentHit = TextHitInfo.beforeOffset(pos-startOffset);

  264.                 nextHit = layout.getNextRightHit(currentHit);

  265.                 if( nextHit == null ) {

  266.                     return -1;

  267.                 }

  268.                 if( viewIsLeftToRight != layout.isLeftToRight() ) {

  269.                     // If the layout's base direction is different from

  270.                     // this view's run direction, we need to use the weak

  271.                     // carrat. 

  272.                     nextHit = layout.getVisualOtherHit(nextHit);

  273.                 }

  274.                 pos = nextHit.getInsertionIndex() + startOffset;

  275.                 

  276. 		if(pos == endOffset) {

  277.                     // A move to the right from an internal position will

  278.                     // only take us to the endOffset in a left to right run.

  279. 		    text = v.getText(endOffset - 1, endOffset);

  280. 		    if(text.array[text.offset] == '\n') {

  281. 			return -1;

  282. 		    }

  283. 		    biasRet[0] = Position.Bias.Backward;

  284. 		}

  285. 		else {

  286. 		    biasRet[0] = Position.Bias.Forward;

  287. 		}

  288. 		return pos;

  289. 	    case View.WEST:

  290.                 doc = (AbstractDocument)v.getDocument();

  291.                 viewIsLeftToRight = doc.isLeftToRight(startOffset, endOffset);

  292.                 

  293. 		if(startOffset == doc.getLength()) {

  294. 		    if(pos == -1) {

  295. 			biasRet[0] = Position.Bias.Forward;

  296. 			return startOffset;

  297. 		    }

  298. 		    // End case for bidi text where newline is at beginning

  299. 		    // of line.

  300. 		    return -1;

  301. 		}

  302. 		if(pos == -1) {

  303.                     // Entering view from the right

  304.                     if( viewIsLeftToRight ) {

  305.                         text = v.getText(endOffset - 1, endOffset);

  306.                         if(text.array[text.offset] == '\n') {

  307.                             biasRet[0] = Position.Bias.Forward;

  308.                             return endOffset - 1;

  309.                         }

  310.                         biasRet[0] = Position.Bias.Backward;

  311.                         return endOffset;

  312.                     } else {

  313.                         biasRet[0] = Position.Bias.Forward;

  314.                         return startOffset;

  315.                    }

  316. 		}

  317.                 if( b==Position.Bias.Forward )

  318.                     currentHit = TextHitInfo.afterOffset(pos-startOffset);

  319.                 else

  320.                     currentHit = TextHitInfo.beforeOffset(pos-startOffset);

  321.                 nextHit = layout.getNextLeftHit(currentHit);

  322.                 if( nextHit == null ) {

  323.                     return -1;

  324.                 }

  325.                 if( viewIsLeftToRight != layout.isLeftToRight() ) {

  326.                     // If the layout's base direction is different from

  327.                     // this view's run direction, we need to use the weak

  328.                     // carrat. 

  329.                     nextHit = layout.getVisualOtherHit(nextHit);

  330.                 }

  331.                 pos = nextHit.getInsertionIndex() + startOffset;

  332. 

  333. 		if(pos == endOffset) {

  334.                     // A move to the left from an internal position will

  335.                     // only take us to the endOffset in a right to left run.

  336. 		    text = v.getText(endOffset - 1, endOffset);

  337. 		    if(text.array[text.offset] == '\n') {

  338. 			return -1;

  339. 		    }

  340. 		    biasRet[0] = Position.Bias.Backward;

  341. 		}

  342. 		else {

  343. 		    biasRet[0] = Position.Bias.Forward;

  344. 		}

  345. 		return pos;

  346. 	    default:

  347. 		throw new IllegalArgumentException("Bad direction: " + direction);

  348. 	    }

  349. 	    return pos;

  350. 

  351. 	}

  352.     // --- variables ---------------------------------------------

  353. 

  354.     TextLayout layout;

  355. 

  356. }