/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Oleg V. Khaschansky
* @version $Revision$
*
* @date: Jun 14, 2005
*/
package org.apache.harmony.awt.gl.font;
import java.awt.font.TextHitInfo;
import java.awt.font.TextLayout;
import java.awt.geom.Rectangle2D;
import java.awt.geom.GeneralPath;
import java.awt.geom.Line2D;
import java.awt.*;
import org.apache.harmony.awt.internal.nls.Messages;
/**
* This class provides functionality for creating caret and highlight shapes
* (bidirectional text is also supported, but, unfortunately, not tested yet).
*/
public class CaretManager {
private TextRunBreaker breaker;
public CaretManager(TextRunBreaker breaker) {
this.breaker = breaker;
}
/**
* Checks if TextHitInfo is not out of the text range and throws the
* IllegalArgumentException if it is.
* @param info - text hit info
*/
private void checkHit(TextHitInfo info) {
int idx = info.getInsertionIndex();
if (idx < 0 || idx > breaker.getCharCount()) {
// awt.42=TextHitInfo out of range
throw new IllegalArgumentException(Messages.getString("awt.42")); //$NON-NLS-1$
}
}
/**
* Calculates and returns visual position from the text hit info.
* @param hitInfo - text hit info
* @return visual index
*/
private int getVisualFromHitInfo(TextHitInfo hitInfo) {
final int idx = hitInfo.getCharIndex();
if (idx >= 0 && idx < breaker.getCharCount()) {
int visual = breaker.getVisualFromLogical(idx);
// We take next character for (LTR char + TRAILING info) and (RTL + LEADING)
if (hitInfo.isLeadingEdge() ^ ((breaker.getLevel(idx) & 0x1) == 0x0)) {
visual++;
}
return visual;
} else if (idx < 0) {
return breaker.isLTR() ? 0: breaker.getCharCount();
} else {
return breaker.isLTR() ? breaker.getCharCount() : 0;
}
}
/**
* Calculates text hit info from the visual position
* @param visual - visual position
* @return text hit info
*/
private TextHitInfo getHitInfoFromVisual(int visual) {
final boolean first = visual == 0;
if (!(first || visual == breaker.getCharCount())) {
int logical = breaker.getLogicalFromVisual(visual);
return (breaker.getLevel(logical) & 0x1) == 0x0 ?
TextHitInfo.leading(logical) : // LTR
TextHitInfo.trailing(logical); // RTL
} else if (first) {
return breaker.isLTR() ?
TextHitInfo.trailing(-1) :
TextHitInfo.leading(breaker.getCharCount());
} else { // Last
return breaker.isLTR() ?
TextHitInfo.leading(breaker.getCharCount()) :
TextHitInfo.trailing(-1);
}
}
/**
* Creates caret info. Required for the getCaretInfo
* methods of the TextLayout
* @param hitInfo - specifies caret position
* @return caret info, see TextLayout.getCaretInfo documentation
*/
public float[] getCaretInfo(TextHitInfo hitInfo) {
checkHit(hitInfo);
float res[] = new float[2];
int visual = getVisualFromHitInfo(hitInfo);
float advance, angle;
TextRunSegment seg;
if (visual < breaker.getCharCount()) {
int logIdx = breaker.getLogicalFromVisual(visual);
int segmentIdx = breaker.logical2segment[logIdx];
seg = breaker.runSegments.get(segmentIdx);
advance = seg.x + seg.getAdvanceDelta(seg.getStart(), logIdx);
angle = seg.metrics.italicAngle;
} else { // Last character
int logIdx = breaker.getLogicalFromVisual(visual-1);
int segmentIdx = breaker.logical2segment[logIdx];
seg = breaker.runSegments.get(segmentIdx);
advance = seg.x + seg.getAdvanceDelta(seg.getStart(), logIdx+1);
}
angle = seg.metrics.italicAngle;
res[0] = advance;
res[1] = angle;
return res;
}
/**
* Returns the next position to the right from the current caret position
* @param hitInfo - current position
* @return next position to the right
*/
public TextHitInfo getNextRightHit(TextHitInfo hitInfo) {
checkHit(hitInfo);
int visual = getVisualFromHitInfo(hitInfo);
if (visual == breaker.getCharCount()) {
return null;
}
TextHitInfo newInfo;
while(visual <= breaker.getCharCount()) {
visual++;
newInfo = getHitInfoFromVisual(visual);
if (newInfo.getCharIndex() >= breaker.logical2segment.length) {
return newInfo;
}
if (hitInfo.getCharIndex() >= 0) { // Don't check for leftmost info
if (
breaker.logical2segment[newInfo.getCharIndex()] !=
breaker.logical2segment[hitInfo.getCharIndex()]
) {
return newInfo; // We crossed segment boundary
}
}
TextRunSegment seg = breaker.runSegments.get(breaker.logical2segment[newInfo
.getCharIndex()]);
if (!seg.charHasZeroAdvance(newInfo.getCharIndex())) {
return newInfo;
}
}
return null;
}
/**
* Returns the next position to the left from the current caret position
* @param hitInfo - current position
* @return next position to the left
*/
public TextHitInfo getNextLeftHit(TextHitInfo hitInfo) {
checkHit(hitInfo);
int visual = getVisualFromHitInfo(hitInfo);
if (visual == 0) {
return null;
}
TextHitInfo newInfo;
while(visual >= 0) {
visual--;
newInfo = getHitInfoFromVisual(visual);
if (newInfo.getCharIndex() < 0) {
return newInfo;
}
// Don't check for rightmost info
if (hitInfo.getCharIndex() < breaker.logical2segment.length) {
if (
breaker.logical2segment[newInfo.getCharIndex()] !=
breaker.logical2segment[hitInfo.getCharIndex()]
) {
return newInfo; // We crossed segment boundary
}
}
TextRunSegment seg = breaker.runSegments.get(breaker.logical2segment[newInfo
.getCharIndex()]);
if (!seg.charHasZeroAdvance(newInfo.getCharIndex())) {
return newInfo;
}
}
return null;
}
/**
* For each visual caret position there are two hits. For the simple LTR text one is
* a trailing of the previous char and another is the leading of the next char. This
* method returns the opposite hit for the given hit.
* @param hitInfo - given hit
* @return opposite hit
*/
public TextHitInfo getVisualOtherHit(TextHitInfo hitInfo) {
checkHit(hitInfo);
int idx = hitInfo.getCharIndex();
int resIdx;
boolean resIsLeading;
if (idx >= 0 && idx < breaker.getCharCount()) { // Hit info in the middle
int visual = breaker.getVisualFromLogical(idx);
// Char is LTR + LEADING info
if (((breaker.getLevel(idx) & 0x1) == 0x0) ^ hitInfo.isLeadingEdge()) {
visual++;
if (visual == breaker.getCharCount()) {
if (breaker.isLTR()) {
resIdx = breaker.getCharCount();
resIsLeading = true;
} else {
resIdx = -1;
resIsLeading = false;
}
} else {
resIdx = breaker.getLogicalFromVisual(visual);
if ((breaker.getLevel(resIdx) & 0x1) == 0x0) {
resIsLeading = true;
} else {
resIsLeading = false;
}
}
} else {
visual--;
if (visual == -1) {
if (breaker.isLTR()) {
resIdx = -1;
resIsLeading = false;
} else {
resIdx = breaker.getCharCount();
resIsLeading = true;
}
} else {
resIdx = breaker.getLogicalFromVisual(visual);
if ((breaker.getLevel(resIdx) & 0x1) == 0x0) {
resIsLeading = false;
} else {
resIsLeading = true;
}
}
}
} else if (idx < 0) { // before "start"
if (breaker.isLTR()) {
resIdx = breaker.getLogicalFromVisual(0);
resIsLeading = (breaker.getLevel(resIdx) & 0x1) == 0x0; // LTR char?
} else {
resIdx = breaker.getLogicalFromVisual(breaker.getCharCount() - 1);
resIsLeading = (breaker.getLevel(resIdx) & 0x1) != 0x0; // RTL char?
}
} else { // idx == breaker.getCharCount()
if (breaker.isLTR()) {
resIdx = breaker.getLogicalFromVisual(breaker.getCharCount() - 1);
resIsLeading = (breaker.getLevel(resIdx) & 0x1) != 0x0; // LTR char?
} else {
resIdx = breaker.getLogicalFromVisual(0);
resIsLeading = (breaker.getLevel(resIdx) & 0x1) == 0x0; // RTL char?
}
}
return resIsLeading ? TextHitInfo.leading(resIdx) : TextHitInfo.trailing(resIdx);
}
public Line2D getCaretShape(TextHitInfo hitInfo, TextLayout layout) {
return getCaretShape(hitInfo, layout, true, false, null);
}
/**
* Creates a caret shape.
* @param hitInfo - hit where to place a caret
* @param layout - text layout
* @param useItalic - unused for now, was used to create
* slanted carets for italic text
* @param useBounds - true if the cared should fit into the provided bounds
* @param bounds - bounds for the caret
* @return caret shape
*/
public Line2D getCaretShape(
TextHitInfo hitInfo, TextLayout layout,
boolean useItalic, boolean useBounds, Rectangle2D bounds
) {
checkHit(hitInfo);
float x1, x2, y1, y2;
int charIdx = hitInfo.getCharIndex();
if (charIdx >= 0 && charIdx < breaker.getCharCount()) {
TextRunSegment segment = breaker.runSegments.get(breaker.logical2segment[charIdx]);
y1 = segment.metrics.descent;
y2 = - segment.metrics.ascent - segment.metrics.leading;
x1 = x2 = segment.getCharPosition(charIdx) + (hitInfo.isLeadingEdge() ?
0 : segment.getCharAdvance(charIdx));
// Decided that straight cursor looks better even for italic fonts,
// especially combined with highlighting
/*
// Not graphics, need to check italic angle and baseline
if (layout.getBaseline() >= 0) {
if (segment.metrics.italicAngle != 0 && useItalic) {
x1 -= segment.metrics.italicAngle * segment.metrics.descent;
x2 += segment.metrics.italicAngle *
(segment.metrics.ascent + segment.metrics.leading);
float baselineOffset =
layout.getBaselineOffsets()[layout.getBaseline()];
y1 += baselineOffset;
y2 += baselineOffset;
}
}
*/
} else {
y1 = layout.getDescent();
y2 = - layout.getAscent() - layout.getLeading();
x1 = x2 = ((breaker.getBaseLevel() & 0x1) == 0 ^ charIdx < 0) ?
layout.getAdvance() : 0;
}
if (useBounds) {
y1 = (float) bounds.getMaxY();
y2 = (float) bounds.getMinY();
if (x2 > bounds.getMaxX()) {
x1 = x2 = (float) bounds.getMaxX();
}
if (x1 < bounds.getMinX()) {
x1 = x2 = (float) bounds.getMinX();
}
}
return new Line2D.Float(x1, y1, x2, y2);
}
/**
* Creates caret shapes for the specified offset. On the boundaries where
* the text is changing its direction this method may return two shapes
* for the strong and the weak carets, in other cases it would return one.
* @param offset - offset in the text.
* @param bounds - bounds to fit the carets into
* @param policy - caret policy
* @param layout - text layout
* @return one or two caret shapes
*/
public Shape[] getCaretShapes(
int offset, Rectangle2D bounds,
TextLayout.CaretPolicy policy, TextLayout layout
) {
TextHitInfo hit1 = TextHitInfo.afterOffset(offset);
TextHitInfo hit2 = getVisualOtherHit(hit1);
Shape caret1 = getCaretShape(hit1, layout);
if (getVisualFromHitInfo(hit1) == getVisualFromHitInfo(hit2)) {
return new Shape[] {caret1, null};
}
Shape caret2 = getCaretShape(hit2, layout);
TextHitInfo strongHit = policy.getStrongCaret(hit1, hit2, layout);
return strongHit.equals(hit1) ?
new Shape[] {caret1, caret2} :
new Shape[] {caret2, caret1};
}
/**
* Connects two carets to produce a highlight shape.
* @param caret1 - 1st caret
* @param caret2 - 2nd caret
* @return highlight shape
*/
GeneralPath connectCarets(Line2D caret1, Line2D caret2) {
GeneralPath path = new GeneralPath(GeneralPath.WIND_NON_ZERO);
path.moveTo((float) caret1.getX1(), (float) caret1.getY1());
path.lineTo((float) caret2.getX1(), (float) caret2.getY1());
path.lineTo((float) caret2.getX2(), (float) caret2.getY2());
path.lineTo((float) caret1.getX2(), (float) caret1.getY2());
path.closePath();
return path;
}
/**
* Creates a highlight shape from given two hits. This shape
* will always be visually contiguous
* @param hit1 - 1st hit
* @param hit2 - 2nd hit
* @param bounds - bounds to fit the shape into
* @param layout - text layout
* @return highlight shape
*/
public Shape getVisualHighlightShape(
TextHitInfo hit1, TextHitInfo hit2,
Rectangle2D bounds, TextLayout layout
) {
checkHit(hit1);
checkHit(hit2);
Line2D caret1 = getCaretShape(hit1, layout, false, true, bounds);
Line2D caret2 = getCaretShape(hit2, layout, false, true, bounds);
return connectCarets(caret1, caret2);
}
/**
* Suppose that the user visually selected a block of text which has
* several different levels (mixed RTL and LTR), so, in the logical
* representation of the text this selection may be not contigous.
* This methods returns a set of logical ranges for the arbitrary
* visual selection represented by two hits.
* @param hit1 - 1st hit
* @param hit2 - 2nd hit
* @return logical ranges for the selection
*/
public int[] getLogicalRangesForVisualSelection(TextHitInfo hit1, TextHitInfo hit2) {
checkHit(hit1);
checkHit(hit2);
int visual1 = getVisualFromHitInfo(hit1);
int visual2 = getVisualFromHitInfo(hit2);
if (visual1 > visual2) {
int tmp = visual2;
visual2 = visual1;
visual1 = tmp;
}
// Max level is 255, so we don't need more than 512 entries
int results[] = new int[512];
int prevLogical, logical, runStart, numRuns = 0;
logical = runStart = prevLogical = breaker.getLogicalFromVisual(visual1);
// Get all the runs. We use the fact that direction is constant in all runs.
for (int i=visual1+1; i<=visual2; i++) {
logical = breaker.getLogicalFromVisual(i);
int diff = logical-prevLogical;
// Start of the next run encountered
if (diff > 1 || diff < -1) {
results[(numRuns)*2] = Math.min(runStart, prevLogical);
results[(numRuns)*2 + 1] = Math.max(runStart, prevLogical);
numRuns++;
runStart = logical;
}
prevLogical = logical;
}
// The last unsaved run
results[(numRuns)*2] = Math.min(runStart, logical);
results[(numRuns)*2 + 1] = Math.max(runStart, logical);
numRuns++;
int retval[] = new int[numRuns*2];
System.arraycopy(results, 0, retval, 0, numRuns*2);
return retval;
}
/**
* Creates a highlight shape from given two endpoints in the logical
* representation. This shape is not always visually contiguous
* @param firstEndpoint - 1st logical endpoint
* @param secondEndpoint - 2nd logical endpoint
* @param bounds - bounds to fit the shape into
* @param layout - text layout
* @return highlight shape
*/
public Shape getLogicalHighlightShape(
int firstEndpoint, int secondEndpoint,
Rectangle2D bounds, TextLayout layout
) {
GeneralPath res = new GeneralPath();
for (int i=firstEndpoint; i<=secondEndpoint; i++) {
int endRun = breaker.getLevelRunLimit(i, secondEndpoint);
TextHitInfo hit1 = TextHitInfo.leading(i);
TextHitInfo hit2 = TextHitInfo.trailing(endRun-1);
Line2D caret1 = getCaretShape(hit1, layout, false, true, bounds);
Line2D caret2 = getCaretShape(hit2, layout, false, true, bounds);
res.append(connectCarets(caret1, caret2), false);
i = endRun;
}
return res;
}
}
|
