JDK8/Java8源码在线阅读
/*
* 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);
/**代码未完, 请加载全部代码(NowJava.com).**/
关注时代Java
关注时代Java