/*
* Copyright (c) 1999, 2006, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package javax.swing.text;
import java.text.*;
import java.awt.*;
import java.awt.font.*;
import java.awt.geom.Rectangle2D;
/**
* A class to perform rendering of the glyphs.
* This can be implemented to be stateless, or
* to hold some information as a cache to
* facilitate faster rendering and model/view
* translation. At a minimum, the GlyphPainter
* allows a View implementation to perform its
* duties independent of a particular version
* of JVM and selection of capabilities (i.e.
* shaping for i18n, etc).
* <p>
* This implementation is intended for operation
* under the JDK. It uses the
* java.awt.font.TextLayout class to do i18n capable
* rendering.
*
* @author Timothy Prinzing
* @see GlyphView
*/
class GlyphPainter2 extends GlyphView.GlyphPainter {
public GlyphPainter2(TextLayout layout) {
this.layout = layout;
}
/**
* Create a painter to use for the given GlyphView.
*/
public GlyphView.GlyphPainter getPainter(GlyphView v, int p0, int p1) {
return null;
}
/**
* Determine the span the glyphs given a start location
* (for tab expansion). This implementation assumes it
* has no tabs (i.e. TextLayout doesn't deal with tab
* expansion).
*/
public float getSpan(GlyphView v, int p0, int p1,
TabExpander e, float x) {
if ((p0 == v.getStartOffset()) && (p1 == v.getEndOffset())) {
return layout.getAdvance();
}
int p = v.getStartOffset();
int index0 = p0 - p;
int index1 = p1 - p;
TextHitInfo hit0 = TextHitInfo.afterOffset(index0);
TextHitInfo hit1 = TextHitInfo.beforeOffset(index1);
float[] locs = layout.getCaretInfo(hit0);
float x0 = locs[0];
locs = layout.getCaretInfo(hit1);
float x1 = locs[0];
return (x1 > x0) ? x1 - x0 : x0 - x1;
}
public float getHeight(GlyphView v) {
return layout.getAscent() + layout.getDescent() + layout.getLeading();
}
/**
* Fetch the ascent above the baseline for the glyphs
* corresponding to the given range in the model.
*/
public float getAscent(GlyphView v) {
return layout.getAscent();
}
/**
* Fetch the descent below the baseline for the glyphs
* corresponding to the given range in the model.
*/
public float getDescent(GlyphView v) {
return layout.getDescent();
}
/**
* Paint the glyphs for the given view. This is implemented
* to only render if the Graphics is of type Graphics2D which
* is required by TextLayout (and this should be the case if
* running on the JDK).
*/
public void paint(GlyphView v, Graphics g, Shape a, int p0, int p1) {
if (g instanceof Graphics2D) {
Rectangle2D alloc = a.getBounds2D();
Graphics2D g2d = (Graphics2D)g;
float y = (float) alloc.getY() + layout.getAscent() + layout.getLeading();
float x = (float) alloc.getX();
if( p0 > v.getStartOffset() || p1 < v.getEndOffset() ) {
try {
//TextLayout can't render only part of it's range, so if a
//partial range is required, add a clip region.
Shape s = v.modelToView(p0, Position.Bias.Forward,
p1, Position.Bias.Backward, a);
Shape savedClip = g.getClip();
g2d.clip(s);
layout.draw(g2d, x, y);
g.setClip(savedClip);
} catch (BadLocationException e) {}
} else {
layout.draw(g2d, x, y);
}
}
}
public Shape modelToView(GlyphView v, int pos, Position.Bias bias,
Shape a) throws BadLocationException {
int offs = pos - v.getStartOffset();
Rectangle2D alloc = a.getBounds2D();
TextHitInfo hit = (bias == Position.Bias.Forward) ?
TextHitInfo.afterOffset(offs) : TextHitInfo.beforeOffset(offs);
float[] locs = layout.getCaretInfo(hit);
// vertical at the baseline, should use slope and check if glyphs
// are being rendered vertically.
alloc.setRect(alloc.getX() + locs[0], alloc.getY(), 1, alloc.getHeight());
return alloc;
}
/**
* Provides a mapping from the view coordinate space to the logical
* coordinate space of the model.
*
* @param v the view containing the view coordinates
* @param x the X coordinate
* @param y the Y coordinate
* @param a the allocated region to render into
* @param biasReturn either <code>Position.Bias.Forward</code>
* or <code>Position.Bias.Backward</code> is returned as the
* zero-th element of this array
* @return the location within the model that best represents the
* given point of view
* @see View#viewToModel
*/
public int viewToModel(GlyphView v, float x, float y, Shape a,
Position.Bias[] biasReturn) {
Rectangle2D alloc = (a instanceof Rectangle2D) ? (Rectangle2D)a : a.getBounds2D();
//Move the y co-ord of the hit onto the baseline. This is because TextLayout supports
//italic carets and we do not.
TextHitInfo hit = layout.hitTestChar(x - (float)alloc.getX(), 0);
int pos = hit.getInsertionIndex();
if (pos == v.getEndOffset()) {
pos--;
}
biasReturn[0] = hit.isLeadingEdge() ? Position.Bias.Forward : Position.Bias.Backward;
return pos + v.getStartOffset();
}
/**
* Determines the model location that represents the
* maximum advance that fits within the given span.
* This could be used to break the given view. The result
* should be a location just shy of the given advance. This
* differs from viewToModel which returns the closest
* position which might be proud of the maximum advance.
*
* @param v the view to find the model location to break at.
* @param p0 the location in the model where the
* fragment should start it's representation >= 0.
* @param pos the graphic location along the axis that the
* broken view would occupy >= 0. This may be useful for
* things like tab calculations.
* @param len specifies the distance into the view
* where a potential break is desired >= 0.
* @return the maximum model location possible for a break.
* @see View#breakView
*/
public int getBoundedPosition(GlyphView v, int p0, float x, float len) {
if( len < 0 )
throw new IllegalArgumentException("Length must be >= 0.");
// note: this only works because swing uses TextLayouts that are
// only pure rtl or pure ltr
TextHitInfo hit;
if (layout.isLeftToRight()) {
hit = layout.hitTestChar(len, 0);
} else {
hit = layout.hitTestChar(layout.getAdvance() - len, 0);
}
return v.getStartOffset() + hit.getCharIndex();
}
/**
* Provides a way to determine the next visually represented model
* location that one might place a caret. Some views may not be
* visible, they might not be in the same order found in the model, or
* they just might not allow access to some of the locations in the
* model.
*
* @param v the view to use
* @param pos the position to convert >= 0
* @param a the allocated region to render into
* @param direction the direction from the current position that can
* be thought of as the arrow keys typically found on a keyboard.
* This may be SwingConstants.WEST, SwingConstants.EAST,
* SwingConstants.NORTH, or SwingConstants.SOUTH.
* @return the location within the model that best represents the next
* location visual position.
* @exception BadLocationException
* @exception IllegalArgumentException for an invalid direction
*/
public int getNextVisualPositionFrom(GlyphView v, int pos,
Position.Bias b, Shape a,
int direction,
Position.Bias[] biasRet)
throws BadLocationException {
int startOffset = v.getStartOffset();
int endOffset = v.getEndOffset();
Segment text;
AbstractDocument doc;
boolean viewIsLeftToRight;
TextHitInfo currentHit, nextHit;
switch (direction) {
case View.NORTH:
break;
case View.SOUTH:
break;
case View.EAST:
doc = (AbstractDocument)v.getDocument();
viewIsLeftToRight = doc.isLeftToRight(startOffset, endOffset);
if(startOffset == doc.getLength()) {
if(pos == -1) {
biasRet[0] = Position.Bias.Forward;
return startOffset;
}
// End case for bidi text where newline is at beginning
// of line.
return -1;
}
if(pos == -1) {
// Entering view from the left.
if( viewIsLeftToRight ) {
biasRet[0] = Position.Bias.Forward;
return startOffset;
} else {
text = v.getText(endOffset - 1, endOffset);
char c = text.array[text.offset];
SegmentCache.releaseSharedSegment(text);
if(c == '\n') {
biasRet[0] = Position.Bias.Forward;
return endOffset-1;
}
biasRet[0] = Position.Bias.Backward;
return endOffset;
}
}
if( b==Position.Bias.Forward )
currentHit = TextHitInfo.afterOffset(pos-startOffset);
else
currentHit = TextHitInfo.beforeOffset(pos-startOffset);
nextHit = layout.getNextRightHit(currentHit);
if( nextHit == null ) {
return -1;
}
if( viewIsLeftToRight != layout.isLeftToRight() ) {
// If the layout's base direction is different from
// this view's run direction, we need to use the weak
// carrat.
nextHit = layout.getVisualOtherHit(nextHit);
}
pos = nextHit.getInsertionIndex() + startOffset;
if(pos == endOffset) {
// A move to the right from an internal position will
// only take us to the endOffset in a left to right run.
text = v.getText(endOffset - 1, endOffset);
char c = text.array[text.offset];
SegmentCache.releaseSharedSegment(text);
if(c == '\n') {
return -1;
}
biasRet[0] = Position.Bias.Backward;
}
else {
biasRet[0] = Position.Bias.Forward;
}
return pos;
case View.WEST:
doc = (AbstractDocument)v.getDocument();
viewIsLeftToRight = doc.isLeftToRight(startOffset, endOffset);
if(startOffset == doc.getLength()) {
if(pos == -1) {
biasRet[0] = Position.Bias.Forward;
return startOffset;
}
// End case for bidi text where newline is at beginning
// of line.
return -1;
}
if(pos == -1) {
// Entering view from the right
if( viewIsLeftToRight ) {
text = v.getText(endOffset - 1, endOffset);
char c = text.array[text.offset];
SegmentCache.releaseSharedSegment(text);
if ((c == '\n') || Character.isSpaceChar(c)) {
biasRet[0] = Position.Bias.Forward;
return endOffset - 1;
}
biasRet[0] = Position.Bias.Backward;
return endOffset;
} else {
biasRet[0] = Position.Bias.Forward;
return startOffset;
}
}
if( b==Position.Bias.Forward )
currentHit = TextHitInfo.afterOffset(pos-startOffset);
else
currentHit = TextHitInfo.beforeOffset(pos-startOffset);
nextHit = layout.getNextLeftHit(currentHit);
if( nextHit == null ) {
return -1;
}
if( viewIsLeftToRight != layout.isLeftToRight() ) {
// If the layout's base direction is different from
// this view's run direction, we need to use the weak
// carrat.
nextHit = layout.getVisualOtherHit(nextHit);
}
pos = nextHit.getInsertionIndex() + startOffset;
if(pos == endOffset) {
// A move to the left from an internal position will
// only take us to the endOffset in a right to left run.
text = v.getText(endOffset - 1, endOffset);
char c = text.array[text.offset];
SegmentCache.releaseSharedSegment(text);
if(c == '\n') {
return -1;
}
biasRet[0] = Position.Bias.Backward;
}
else {
biasRet[0] = Position.Bias.Forward;
}
return pos;
default:
throw new IllegalArgumentException("Bad direction: " + direction);
}
return pos;
}
// --- variables ---------------------------------------------
TextLayout layout;
}