Back to index...

	/*
	* Copyright (c) 1999, 2008, 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.util.*;
	import java.awt.*;
	import java.text.AttributedCharacterIterator;
	import java.text.BreakIterator;
	import java.awt.font.*;
	import java.awt.geom.AffineTransform;
	import javax.swing.JComponent;
	import javax.swing.event.DocumentEvent;
	import sun.font.BidiUtils;

	/**
	* A flow strategy that uses java.awt.font.LineBreakMeasureer to
	* produce java.awt.font.TextLayout for i18n capable rendering.
	* If the child view being placed into the flow is of type
	* GlyphView and can be rendered by TextLayout, a GlyphPainter
	* that uses TextLayout is plugged into the GlyphView.
	*
	* @author Timothy Prinzing
	*/
	class TextLayoutStrategy extends FlowView.FlowStrategy {

	/**
	* Constructs a layout strategy for paragraphs based
	* upon java.awt.font.LineBreakMeasurer.
	*/
	public TextLayoutStrategy() {
	text = new AttributedSegment();
	}

	// --- FlowStrategy methods --------------------------------------------

	/**
	* Gives notification that something was inserted into the document
	* in a location that the given flow view is responsible for. The
	* strategy should update the appropriate changed region (which
	* depends upon the strategy used for repair).
	*
	* @param e the change information from the associated document
	* @param alloc the current allocation of the view inside of the insets.
	* This value will be null if the view has not yet been displayed.
	* @see View#insertUpdate
	*/
	public void insertUpdate(FlowView fv, DocumentEvent e, Rectangle alloc) {
	sync(fv);
	super.insertUpdate(fv, e, alloc);
	}

	/**
	* Gives notification that something was removed from the document
	* in a location that the given flow view is responsible for.
	*
	* @param e the change information from the associated document
	* @param alloc the current allocation of the view inside of the insets.
	* @see View#removeUpdate
	*/
	public void removeUpdate(FlowView fv, DocumentEvent e, Rectangle alloc) {
	sync(fv);
	super.removeUpdate(fv, e, alloc);
	}

	/**
	* Gives notification from the document that attributes were changed
	* in a location that this view is responsible for.
	*
	* @param changes the change information from the associated document
	* @param a the current allocation of the view
	* @param f the factory to use to rebuild if the view has children
	* @see View#changedUpdate
	*/
	public void changedUpdate(FlowView fv, DocumentEvent e, Rectangle alloc) {
	sync(fv);
	super.changedUpdate(fv, e, alloc);
	}

	/**
	* Does a a full layout on the given View. This causes all of
	* the rows (child views) to be rebuilt to match the given
	* constraints for each row. This is called by a FlowView.layout
	* to update the child views in the flow.
	*
	* @param fv the view to reflow
	*/
	public void layout(FlowView fv) {
	super.layout(fv);
	}

	/**
	* Creates a row of views that will fit within the
	* layout span of the row. This is implemented to execute the
	* superclass functionality (which fills the row with child
	* views or view fragments) and follow that with bidi reordering
	* of the unidirectional view fragments.
	*
	* @param row the row to fill in with views. This is assumed
	* to be empty on entry.
	* @param pos The current position in the children of
	* this views element from which to start.
	* @return the position to start the next row
	*/
	protected int layoutRow(FlowView fv, int rowIndex, int p0) {
	int p1 = super.layoutRow(fv, rowIndex, p0);
	View row = fv.getView(rowIndex);
	Document doc = fv.getDocument();
	Object i18nFlag = doc.getProperty(AbstractDocument.I18NProperty);
	if ((i18nFlag != null) && i18nFlag.equals(Boolean.TRUE)) {
	int n = row.getViewCount();
	if (n > 1) {
	AbstractDocument d = (AbstractDocument)fv.getDocument();
	Element bidiRoot = d.getBidiRootElement();
	byte[] levels = new byte[n];
	View[] reorder = new View[n];

	for( int i=0; i<n; i++ ) {
	View v = row.getView(i);
	int bidiIndex =bidiRoot.getElementIndex(v.getStartOffset());
	Element bidiElem = bidiRoot.getElement( bidiIndex );
	levels[i] = (byte)StyleConstants.getBidiLevel(bidiElem.getAttributes());
	reorder[i] = v;
	}

	BidiUtils.reorderVisually( levels, reorder );
	row.replace(0, n, reorder);
	}
	}
	return p1;
	}

	/**
	* Adjusts the given row if possible to fit within the
	* layout span. Since all adjustments were already
	* calculated by the LineBreakMeasurer, this is implemented
	* to do nothing.
	*
	* @param r the row to adjust to the current layout
	* span.
	* @param desiredSpan the current layout span >= 0
	* @param x the location r starts at.
	*/
	protected void adjustRow(FlowView fv, int rowIndex, int desiredSpan, int x) {
	}

	/**
	* Creates a unidirectional view that can be used to represent the
	* current chunk. This can be either an entire view from the
	* logical view, or a fragment of the view.
	*
	* @param fv the view holding the flow
	* @param startOffset the start location for the view being created
	* @param spanLeft the about of span left to fill in the row
	* @param rowIndex the row the view will be placed into
	*/
	protected View createView(FlowView fv, int startOffset, int spanLeft, int rowIndex) {
	// Get the child view that contains the given starting position
	View lv = getLogicalView(fv);
	View row = fv.getView(rowIndex);
	boolean requireNextWord = (viewBuffer.size() == 0) ? false : true;
	int childIndex = lv.getViewIndex(startOffset, Position.Bias.Forward);
	View v = lv.getView(childIndex);

	int endOffset = getLimitingOffset(v, startOffset, spanLeft, requireNextWord);
	if (endOffset == startOffset) {
	return null;
	}

	View frag;
	if ((startOffset==v.getStartOffset()) && (endOffset == v.getEndOffset())) {
	// return the entire view
	frag = v;
	} else {
	// return a unidirectional fragment.
	frag = v.createFragment(startOffset, endOffset);
	}

	if ((frag instanceof GlyphView) && (measurer != null)) {
	// install a TextLayout based renderer if the view is responsible
	// for glyphs. If the view represents a tab, the default
	// glyph painter is used (may want to handle tabs differently).
	boolean isTab = false;
	int p0 = frag.getStartOffset();
	int p1 = frag.getEndOffset();
	if ((p1 - p0) == 1) {
	// check for tab
	Segment s = ((GlyphView)frag).getText(p0, p1);
	char ch = s.first();
	if (ch == '\t') {
	isTab = true;
	}
	}
	TextLayout tl = (isTab) ? null :
	measurer.nextLayout(spanLeft, text.toIteratorIndex(endOffset),
	requireNextWord);
	if (tl != null) {
	((GlyphView)frag).setGlyphPainter(new GlyphPainter2(tl));
	}
	}
	return frag;
	}

	/**
	* Calculate the limiting offset for the next view fragment.
	* At most this would be the entire view (i.e. the limiting
	* offset would be the end offset in that case). If the range
	* contains a tab or a direction change, that will limit the
	* offset to something less. This value is then fed to the
	* LineBreakMeasurer as a limit to consider in addition to the
	* remaining span.
	*
	* @param v the logical view representing the starting offset.
	* @param startOffset the model location to start at.
	*/
	int getLimitingOffset(View v, int startOffset, int spanLeft, boolean requireNextWord) {
	int endOffset = v.getEndOffset();

	// check for direction change
	Document doc = v.getDocument();
	if (doc instanceof AbstractDocument) {
	AbstractDocument d = (AbstractDocument) doc;
	Element bidiRoot = d.getBidiRootElement();
	if( bidiRoot.getElementCount() > 1 ) {
	int bidiIndex = bidiRoot.getElementIndex( startOffset );
	Element bidiElem = bidiRoot.getElement( bidiIndex );
	endOffset = Math.min( bidiElem.getEndOffset(), endOffset );
	}
	}

	// check for tab
	if (v instanceof GlyphView) {
	Segment s = ((GlyphView)v).getText(startOffset, endOffset);
	char ch = s.first();
	if (ch == '\t') {
	// if the first character is a tab, create a dedicated
	// view for just the tab
	endOffset = startOffset + 1;
	} else {
	for (ch = s.next(); ch != Segment.DONE; ch = s.next()) {
	if (ch == '\t') {
	// found a tab, don't include it in the text
	endOffset = startOffset + s.getIndex() - s.getBeginIndex();
	break;
	}
	}
	}
	}

	// determine limit from LineBreakMeasurer
	int limitIndex = text.toIteratorIndex(endOffset);
	if (measurer != null) {
	int index = text.toIteratorIndex(startOffset);
	if (measurer.getPosition() != index) {
	measurer.setPosition(index);
	}
	limitIndex = measurer.nextOffset(spanLeft, limitIndex, requireNextWord);
	}
	int pos = text.toModelPosition(limitIndex);
	return pos;
	}

	/**
	* Synchronize the strategy with its FlowView. Allows the strategy
	* to update its state to account for changes in that portion of the
	* model represented by the FlowView. Also allows the strategy
	* to update the FlowView in response to these changes.
	*/
	void sync(FlowView fv) {
	View lv = getLogicalView(fv);
	text.setView(lv);

	Container container = fv.getContainer();
	FontRenderContext frc = sun.swing.SwingUtilities2.
	getFontRenderContext(container);
	BreakIterator iter;
	Container c = fv.getContainer();
	if (c != null) {
	iter = BreakIterator.getLineInstance(c.getLocale());
	} else {
	iter = BreakIterator.getLineInstance();
	}

	Object shaper = null;
	if (c instanceof JComponent) {
	shaper = ((JComponent) c).getClientProperty(
	TextAttribute.NUMERIC_SHAPING);
	}
	text.setShaper(shaper);

	measurer = new LineBreakMeasurer(text, iter, frc);

	// If the children of the FlowView's logical view are GlyphViews, they
	// need to have their painters updated.
	int n = lv.getViewCount();
	for( int i=0; i<n; i++ ) {
	View child = lv.getView(i);
	if( child instanceof GlyphView ) {
	int p0 = child.getStartOffset();
	int p1 = child.getEndOffset();
	measurer.setPosition(text.toIteratorIndex(p0));
	TextLayout layout
	= measurer.nextLayout( Float.MAX_VALUE,
	text.toIteratorIndex(p1), false );
	((GlyphView)child).setGlyphPainter(new GlyphPainter2(layout));
	}
	}

	// Reset measurer.
	measurer.setPosition(text.getBeginIndex());

	}

	// --- variables -------------------------------------------------------

	private LineBreakMeasurer measurer;
	private AttributedSegment text;

	/**
	* Implementation of AttributedCharacterIterator that supports
	* the GlyphView attributes for rendering the glyphs through a
	* TextLayout.
	*/
	static class AttributedSegment extends Segment implements AttributedCharacterIterator {

	AttributedSegment() {
	}

	View getView() {
	return v;
	}

	void setView(View v) {
	this.v = v;
	Document doc = v.getDocument();
	int p0 = v.getStartOffset();
	int p1 = v.getEndOffset();
	try {
	doc.getText(p0, p1 - p0, this);
	} catch (BadLocationException bl) {
	throw new IllegalArgumentException("Invalid view");
	}
	first();
	}

	/**
	* Get a boundary position for the font.
	* This is implemented to assume that two fonts are
	* equal if their references are equal (i.e. that the
	* font came from a cache).
	*
	* @return the location in model coordinates. This is
	* not the same as the Segment coordinates.
	*/
	int getFontBoundary(int childIndex, int dir) {
	View child = v.getView(childIndex);
	Font f = getFont(childIndex);
	for (childIndex += dir; (childIndex >= 0) && (childIndex < v.getViewCount());
	childIndex += dir) {
	Font next = getFont(childIndex);
	if (next != f) {
	// this run is different
	break;
	}
	child = v.getView(childIndex);
	}
	return (dir < 0) ? child.getStartOffset() : child.getEndOffset();
	}

	/**
	* Get the font at the given child index.
	*/
	Font getFont(int childIndex) {
	View child = v.getView(childIndex);
	if (child instanceof GlyphView) {
	return ((GlyphView)child).getFont();
	}
	return null;
	}

	int toModelPosition(int index) {
	return v.getStartOffset() + (index - getBeginIndex());
	}

	int toIteratorIndex(int pos) {
	return pos - v.getStartOffset() + getBeginIndex();
	}

	private void setShaper(Object shaper) {
	this.shaper = shaper;
	}

	// --- AttributedCharacterIterator methods -------------------------

	/**
	* Returns the index of the first character of the run
	* with respect to all attributes containing the current character.
	*/
	public int getRunStart() {
	int pos = toModelPosition(getIndex());
	int i = v.getViewIndex(pos, Position.Bias.Forward);
	View child = v.getView(i);
	return toIteratorIndex(child.getStartOffset());
	}

	/**
	* Returns the index of the first character of the run
	* with respect to the given attribute containing the current character.
	*/
	public int getRunStart(AttributedCharacterIterator.Attribute attribute) {
	if (attribute instanceof TextAttribute) {
	int pos = toModelPosition(getIndex());
	int i = v.getViewIndex(pos, Position.Bias.Forward);
	if (attribute == TextAttribute.FONT) {
	return toIteratorIndex(getFontBoundary(i, -1));
	}
	}
	return getBeginIndex();
	}

	/**
	* Returns the index of the first character of the run
	* with respect to the given attributes containing the current character.
	*/
	public int getRunStart(Set<? extends Attribute> attributes) {
	int index = getBeginIndex();
	Object[] a = attributes.toArray();
	for (int i = 0; i < a.length; i++) {
	TextAttribute attr = (TextAttribute) a[i];
	index = Math.max(getRunStart(attr), index);
	}
	return Math.min(getIndex(), index);
	}

	/**
	* Returns the index of the first character following the run
	* with respect to all attributes containing the current character.
	*/
	public int getRunLimit() {
	int pos = toModelPosition(getIndex());
	int i = v.getViewIndex(pos, Position.Bias.Forward);
	View child = v.getView(i);
	return toIteratorIndex(child.getEndOffset());
	}

	/**
	* Returns the index of the first character following the run
	* with respect to the given attribute containing the current character.
	*/
	public int getRunLimit(AttributedCharacterIterator.Attribute attribute) {
	if (attribute instanceof TextAttribute) {
	int pos = toModelPosition(getIndex());
	int i = v.getViewIndex(pos, Position.Bias.Forward);
	if (attribute == TextAttribute.FONT) {
	return toIteratorIndex(getFontBoundary(i, 1));
	}
	}
	return getEndIndex();
	}

	/**
	* Returns the index of the first character following the run
	* with respect to the given attributes containing the current character.
	*/
	public int getRunLimit(Set<? extends Attribute> attributes) {
	int index = getEndIndex();
	Object[] a = attributes.toArray();
	for (int i = 0; i < a.length; i++) {
	TextAttribute attr = (TextAttribute) a[i];
	index = Math.min(getRunLimit(attr), index);
	}
	return Math.max(getIndex(), index);
	}

	/**
	* Returns a map with the attributes defined on the current
	* character.
	*/
	public Map<Attribute, Object> getAttributes() {
	Object[] ka = keys.toArray();
	Hashtable<Attribute, Object> h = new Hashtable<Attribute, Object>();
	for (int i = 0; i < ka.length; i++) {
	TextAttribute a = (TextAttribute) ka[i];
	Object value = getAttribute(a);
	if (value != null) {
	h.put(a, value);
	}
	}
	return h;
	}

	/**
	* Returns the value of the named attribute for the current character.
	* Returns null if the attribute is not defined.
	* @param attribute the key of the attribute whose value is requested.
	*/
	public Object getAttribute(AttributedCharacterIterator.Attribute attribute) {
	int pos = toModelPosition(getIndex());
	int childIndex = v.getViewIndex(pos, Position.Bias.Forward);
	if (attribute == TextAttribute.FONT) {
	return getFont(childIndex);
	} else if( attribute == TextAttribute.RUN_DIRECTION ) {
	return
	v.getDocument().getProperty(TextAttribute.RUN_DIRECTION);
	} else if (attribute == TextAttribute.NUMERIC_SHAPING) {
	return shaper;
	}
	return null;
	}

	/**
	* Returns the keys of all attributes defined on the
	* iterator's text range. The set is empty if no
	* attributes are defined.
	*/
	public Set<Attribute> getAllAttributeKeys() {
	return keys;
	}

	View v;

	static Set<Attribute> keys;

	static {
	keys = new HashSet<Attribute>();
	keys.add(TextAttribute.FONT);
	keys.add(TextAttribute.RUN_DIRECTION);
	keys.add(TextAttribute.NUMERIC_SHAPING);
	}

	private Object shaper = null;
	}

	}

Back to index...