| /* |
| * (C) Copyright IBM Corp. 1998-2007. All Rights Reserved. |
| * |
| * The program is provided "as is" without any warranty express or |
| * implied, including the warranty of non-infringement and the implied |
| * warranties of merchantibility and fitness for a particular purpose. |
| * IBM will not be liable for any damages suffered by you as a result |
| * of using the Program. In no event will IBM be liable for any |
| * special, indirect or consequential damages or lost profits even if |
| * IBM has been advised of the possibility of their occurrence. IBM |
| * will not be liable for any third party claims against you. |
| */ |
| // Requires Java2 |
| // Revision: 70 1.38 richtext/AsyncFormatter.java, richtext, richtext |
| |
| package com.ibm.richtext.textformat; |
| |
| import java.awt.Graphics; |
| import java.awt.Rectangle; |
| import java.awt.Point; |
| import java.awt.Color; |
| |
| import java.text.BreakIterator; |
| import java.text.CharacterIterator; |
| |
| import java.util.Hashtable; |
| |
| import com.ibm.richtext.textlayout.attributes.AttributeMap; |
| import com.ibm.richtext.textlayout.attributes.TextAttribute; |
| |
| import com.ibm.richtext.styledtext.MConstText; |
| |
| import com.ibm.richtext.textlayout.Graphics2DConversion; |
| |
| ///*JDK12IMPORTS |
| import java.awt.Graphics2D; |
| import java.awt.font.LineBreakMeasurer; |
| import java.awt.font.FontRenderContext; |
| //JDK12IMPORTS*/ |
| |
| /*JDK11IMPORTS |
| import com.ibm.richtext.textlayout.Graphics2D; |
| import com.ibm.richtext.textlayout.LineBreakMeasurer; |
| import com.ibm.richtext.textlayout.FontRenderContext; |
| JDK11IMPORTS*/ |
| |
| /* |
| Change history: |
| |
| 7/25/96 - |
| |
| 8/15/96 |
| Fixed bug in textOffsetToPoint (fPixHeight wasn't added to negative heights). {jbr} |
| |
| 8/19/96 |
| Removed references to JustificationStyle constants, and moved them into MFormatter {sfb} |
| |
| 8/23/96 |
| Modified findLineAt and getLineContaining - added optimization in search loop. Also, |
| they were failing when fLTPosEnd+1 == fLTNegStart. Fixed. |
| |
| 8/26/96 |
| Moved FormatDaemon stuff into this class. |
| |
| 9/11/96 |
| Shortened line returned from textOffsetToPoint by 1 pixel |
| |
| 9/23/96 |
| textOffsetToPoint line length restored (see above). drawText() now draws only lines |
| which fall in rectangle param. |
| |
| 9/26/96 |
| whitespace at end of line is used for caret positioning |
| |
| 10/4/96 |
| Added static TextBox method. |
| |
| 10/8/96 |
| Line 1300 - less than changed to less than or equal in textOffsetToPoint. Watch for |
| hangs in formatText. |
| |
| 10/9/96 |
| Changed sync. model. fFormatInBackground is used to start/stop bg formatting |
| |
| 10/17/96 |
| Added new flags: fLineInc, fFillInc for bidi support. updateFormat, pointToTextOffset, getBoundingRect, |
| and findNewInsertionOffset should now function correctly for non-Roman documents. Nothing else has been |
| modified to support intl text. |
| |
| 10/21/96 |
| Pushed paragraph formatting and caret positioning into LineLayout. In process of pushing |
| highlighting into LineLayout. |
| |
| 10/24/96 |
| Now getting paragraph styles from paragraph buffer. |
| |
| 7/7/97 |
| Up-arrow doesn't move to beginning of text if you're on the first line. |
| |
| 7/1/98 |
| No longer intersecting damaged rect with view rect in updateFormat. |
| */ |
| |
| /** |
| * This class implements MFormatter. It maintains a table of |
| * <tt>LayoutInfo</tt> instances which contain layout information |
| * for each line in the text. This class formats lines on demand, |
| * and creates a low-priority thread to format text in the background. |
| * Note that, at times, some text may not have been formatted, especially |
| * if the text is large. |
| * <p> |
| * The line table is an array of <tt>LayoutInfo</tt> objects, which expands as needed to hold |
| * all computed lines in the text. The line table consists of three |
| * regions: a "positive" region, a "gap," and a "negative" region. |
| * In the positive region, character and graphics offsets are positive |
| * integers, computed from the beginning of the text / display. In the |
| * gap, line table entries are null. New lines may be inserted into the gap. |
| * In the negative region, character and graphics offsets are negative; |
| * their absolute values indicate distances from the end of the text / display. |
| * The <tt>fLTPosEnd</tt> member gives the index in the line table of the |
| * last positive entry. The <tt>fLTNegStart</tt> gives the index of first |
| * negative entry. If there are no negative entries, <tt>fLTNegStart</tt> is |
| * equal to <tt>fLTSize</tt>, the size of the line table. |
| * <p> |
| * Changes to the line table occur only in the <tt>formatText()</tt> method. |
| * This method calls <tt>LineLayout.layout()</tt> for each line to format. |
| * |
| * @author John Raley |
| * |
| * @see MFormatter |
| * @see LineLayout |
| * @see LayoutContext |
| * @see LayoutInfo |
| */ |
| |
| final class AsyncFormatter extends MFormatter implements Runnable |
| { |
| static final String COPYRIGHT = |
| "(C) Copyright IBM Corp. 1998-1999 - All Rights Reserved"; |
| /** |
| * Text to format. |
| */ |
| private MConstText fText; |
| |
| /** |
| * Default values. |
| */ |
| private AttributeMap fDefaultValues; |
| |
| /** |
| * Font resolver. |
| */ |
| private FontResolver fFontResolver; |
| |
| /** |
| * Default character metric - used to set height of empty paragraphs |
| */ |
| private DefaultCharacterMetric fDefaultCharMetric; |
| |
| /** |
| * Length to which lines are formatted. |
| */ |
| private int fLineDim; |
| |
| /** |
| * Table of formatted lines. |
| */ |
| private LayoutInfo fLineTable[]; |
| |
| /** |
| * Size of line table. |
| */ |
| private int fLTSize = 10; // initial size must be > 0 |
| |
| /** |
| * Index of last positive entry in line table. |
| */ |
| private int fLTPosEnd; |
| |
| /** |
| * Index of first negative entry in line table. |
| */ |
| private int fLTNegStart; |
| |
| /** |
| * Length of text on which negative line offsets are based. |
| * @see #formatText |
| */ |
| private int fLTCurTextLen; |
| |
| /** |
| * Length of formatted text in fill direction, in pixels. |
| */ |
| private int fPixHeight; |
| |
| /** |
| * Length of formatted text including pseudoline. |
| */ |
| private int fFullPixHeight; |
| |
| private int fMinX; |
| private int fMaxX; |
| |
| /** |
| * <tt>true</tt> if lines should be formatted to fit line dimension. |
| */ |
| private boolean fWrap; |
| |
| /** |
| * <tt>true</tt> if characters run horizontally. |
| */ |
| private boolean fHLine = true; |
| |
| /** |
| * <tt>true</tt> if characters run from from low to high coordinates on line. |
| */ |
| private boolean fLineInc = true; |
| |
| /** |
| * <tt>true</tt> if lines run from low to high coordinates within page. |
| */ |
| private boolean fFillInc = true; |
| |
| /** |
| * Value returned from <tt>findLineAt()</tt> |
| * if pixel height precedes topmost line. |
| */ |
| private static final int kBeforeFirstLine = -2; |
| |
| /** |
| * Value returned from <tt>findLineAt()</tt> and <tt>getLineContaining()</tt> |
| * if offset / pixel height is after all existing lines. |
| */ |
| private static final int kAfterLastLine = -1; |
| |
| /** |
| * Thread which invokes formatter in the background. |
| */ |
| private Thread fDaemon; |
| |
| /** |
| * FontRenderContext to measure with. Currently not settable after |
| * construction. |
| */ |
| private FontRenderContext fFontRenderContext; |
| |
| /** |
| * Controls whether background formatting can run. |
| */ |
| private boolean fBgFormatAllowed = false; |
| |
| /** |
| * Cached line break object. |
| */ |
| private BreakIterator fLineBreak = null; |
| |
| /** |
| * Cached LineBreakMeasurer. |
| */ |
| private LineBreakMeasurer fCachedMeasurer = null; |
| private int fCachedMeasurerStart; |
| private int fCachedMeasurerLimit; |
| |
| // Some JDK's (Sun's 1.2.2) throw exceptions from |
| // LineBreakMeasurer.insertChar and deleteChar. This class |
| // detects this condition and doesn't use these two methods |
| // if they throw exceptions. |
| private static boolean fgCacheMeasurers = true; |
| |
| /** |
| * Current text time stamp. Used to maintain modification invariant. |
| */ |
| private int fCurTimeStamp; |
| |
| /** |
| * Cache of ParagraphRenderers. |
| */ |
| private Hashtable fRendererCache = new Hashtable(); |
| |
| /** |
| * Draw text inside a rectangle. Does not cache any formatting information. |
| * This is convenient for small amounts of text; comparable to TETextBox on the Mac. |
| * <p> |
| * @param text the text to draw |
| * @param g Graphics on which to draw |
| * @param drawRect rectangle in which text will be drawn |
| * @param fillInc if true, lines run from low to high coordinates in page. |
| * @param hLine if true, characters run horizontally within a line. |
| */ |
| |
| private static boolean isParagraphSeparator(char ch) { |
| |
| return ch == '\n' || ch == '\u2029'; |
| } |
| |
| /** |
| * Create an <tt>AsyncFormatter</tt>. |
| * @param text the text to format |
| * @param lineBound length to which lines are foramtted |
| * @param wrap <tt>true</tt> if text should be "line wrapped" (formatted to fit destination area) |
| */ |
| AsyncFormatter(MConstText text, |
| AttributeMap defaultValues, |
| int lineBound, |
| boolean wrap, |
| Graphics g) |
| { |
| fText = text; |
| fDefaultValues = defaultValues; |
| fFontResolver = new FontResolver(fDefaultValues); |
| |
| fLineDim = lineBound; |
| fWrap = wrap; |
| Graphics2D g2d = Graphics2DConversion.getGraphics2D(g); |
| fFontRenderContext = g2d.getFontRenderContext(); |
| |
| fDefaultCharMetric = new DefaultCharacterMetric(fFontResolver, |
| fFontRenderContext); |
| fLTCurTextLen = text.length(); |
| removeAllLines(); |
| |
| fDaemon = new Thread(this); |
| fDaemon.start(); |
| } |
| |
| public AttributeMap getDefaultValues() { |
| |
| return fDefaultValues; |
| } |
| |
| public void checkTimeStamp() { |
| String admonition = "Probably, you modified " + |
| "the text before calling stopBackgroundFormatting()."; |
| |
| if (fText.getTimeStamp() != fCurTimeStamp) { |
| throw new Error("Time stamp is out of sync. " + admonition); |
| } |
| if (fText.length() != fLTCurTextLen) { |
| throw new Error("Length changed unexpectedly. " + |
| "fText.length()="+fText.length()+"; "+ |
| "fLTCurTextLen="+fLTCurTextLen+"; "+ |
| "formatter="+this+"; "+ |
| "text="+fText); |
| } |
| } |
| |
| /** |
| * Specify whether to wrap lines using the line dimension. |
| * @param wrap if <tt>true</tt> lines will be wrapped; otherwise new lines will only be |
| * started when a newline is encountered. |
| */ |
| public synchronized void setWrap(boolean wrap) |
| { |
| if (wrap != fWrap) { |
| fWrap = wrap; |
| removeAllLines(); |
| } |
| } |
| |
| /** |
| * Return true if lines are wrapped using the line dimension. |
| * @see #setWrap |
| */ |
| public synchronized boolean wrap() |
| { |
| return fWrap; |
| } |
| |
| /** |
| * Specify the lineBound in pixels. If line wrapping is on, lines |
| * will be wrapped to this value. |
| * <p> |
| * |
| * @param lineBound the distance, in pixels, used to wrap lines. |
| */ |
| public synchronized void setLineBound(int lineBound) |
| { |
| if (fLineDim != lineBound) { |
| fLineDim = lineBound; |
| if (fWrap) { |
| removeAllLines(); |
| } |
| } |
| } |
| |
| /** |
| * Return the number of pixels along the line dimension. |
| */ |
| public synchronized int lineBound() |
| { |
| return fLineDim; |
| } |
| |
| // /** |
| // * Return <tt>true</tt> if characters run from low to high coordinates on line. |
| // */ |
| // private boolean lineInc() |
| // { |
| // return fLineInc; |
| // } |
| // |
| // /** |
| // * Return <tt>true</tt> if lines run from low to high coordinates on page. |
| // */ |
| // private boolean fillInc() |
| // { |
| // return fFillInc; |
| // } |
| |
| /** |
| * Remove all lines in the line table. Used after an operation that |
| * invalidates all existing lines, such as changing line wrapping or the |
| * line dim. |
| */ |
| private synchronized void removeAllLines() |
| { |
| fCurTimeStamp = fText.getTimeStamp(); |
| stopBackgroundFormatting(); |
| |
| fMinX = 0; |
| fMaxX = fLineDim; |
| |
| fLineTable = new LayoutInfo[fLTSize]; // fLTSize must be > 0 |
| fLTNegStart = fLTSize; |
| fLTPosEnd = 0; |
| |
| fLineTable[0] = pseudoLineInfo(null, 0); |
| |
| fPixHeight = fLineTable[0].getHeight(); // ??? or should it be zero? |
| fFullPixHeight = fPixHeight; |
| |
| // format at least one line: |
| formatToHeight(fPixHeight + 1); |
| |
| enableBGFormat(); |
| } |
| |
| /** |
| * Fill the layout info with information appropriate to the pseudoline. |
| */ |
| private synchronized LayoutInfo pseudoLineInfo(LayoutInfo info, int offset) |
| { |
| AttributeMap st = fText.paragraphStyleAt(fLTCurTextLen); // ??? if text is empty or this is the end of the text, what happens? |
| ParagraphRenderer renderer = getRendererFor(st); |
| info = renderer.layout(fText, |
| info, |
| (LineBreakMeasurer)null, |
| fFontRenderContext, |
| offset, |
| offset, |
| fLineDim, |
| fLineDim); |
| |
| return info; |
| } |
| |
| /** |
| * Return the index of the last valid line in the line table. |
| */ |
| private int lastLine() |
| { |
| return (fLTNegStart == fLTSize) ? fLTPosEnd : fLTSize - 1; |
| } |
| |
| /** |
| * Shift line table such that <tt>lastPos</tt> is the last positive |
| * entry in the table. <b>NOTE: <tt>lastPos</tt> must be a valid line!</b> |
| * <p> |
| * @param lastPos the index of the line which will become the last positive |
| * entry in the line table |
| */ |
| private void shiftTableTo(int lastPos) |
| { |
| LayoutInfo li; |
| |
| while (lastPos < fLTPosEnd) { // shift +'s to -'s |
| li = fLineTable[fLTPosEnd]; |
| fLineTable[fLTPosEnd--] = null; |
| |
| li.makeRelativeToEnd(fLTCurTextLen, fPixHeight); |
| |
| fLineTable[--fLTNegStart] = li; |
| } |
| |
| while (lastPos >= fLTNegStart) { // shift -'s to +'s |
| li = fLineTable[fLTNegStart]; |
| fLineTable[fLTNegStart++] = null; |
| |
| li.makeRelativeToBeginning(fLTCurTextLen, fPixHeight); |
| |
| fLineTable[++fLTPosEnd] = li; |
| } |
| } |
| |
| /** |
| * Increase the size of the line table. |
| */ |
| private void expandLineTable() |
| { |
| // This just doubles the size of the line table. |
| |
| LayoutInfo newLineTable[] = new LayoutInfo[fLineTable.length * 2]; |
| int newNegStart = newLineTable.length - (fLineTable.length - fLTNegStart); |
| |
| System.arraycopy(fLineTable, 0, newLineTable, 0, fLTPosEnd + 1); |
| System.arraycopy(fLineTable, fLTNegStart, newLineTable, newNegStart, fLTSize - fLTNegStart); |
| |
| fLTNegStart = newNegStart; |
| fLTSize = newLineTable.length; |
| fLineTable = newLineTable; |
| } |
| |
| /** |
| * Return the index of the line containing the pixel position <tt>fillCoord</tt>. |
| * If fillCoord exceeds the bottom of the text, return kAfterLastLine. |
| * If fillCoord is less than the top of the text, return kBeforeFirstLine. |
| * <p> |
| * @param fillCoord "height" of line to locate. |
| */ |
| private int findLineAt(int fillCoord) |
| { |
| int low, high, mid; |
| int lowStart, highStart, midStart; |
| |
| if (fillCoord >= fPixHeight) |
| return kAfterLastLine; |
| else if (fillCoord < 0) |
| return kBeforeFirstLine; |
| |
| if ((fLTNegStart < fLTSize) && (fillCoord >= fLineTable[fLTNegStart].getGraphicStart(fPixHeight))) { |
| fillCoord -= fPixHeight; |
| |
| low = fLTNegStart; |
| high = fLTSize; |
| highStart = 0; |
| } |
| else { |
| low = 0; |
| high = fLTPosEnd + 1; |
| highStart = fLineTable[fLTPosEnd].getGraphicStart(0) + fLineTable[fLTPosEnd].getHeight(); |
| } |
| lowStart = fLineTable[low].getGraphicStart(0); |
| |
| do { |
| if (lowStart == highStart) |
| return low; |
| |
| mid = low + (fillCoord - lowStart) / (highStart - lowStart) * (high - low); |
| midStart = fLineTable[mid].getGraphicStart(0); |
| |
| if (midStart > fillCoord) { |
| high = mid; |
| highStart = fLineTable[high].getGraphicStart(0); |
| } |
| else if (midStart + fLineTable[mid].getHeight() <= fillCoord) { |
| low = mid + 1; |
| lowStart = fLineTable[low].getGraphicStart(0); |
| } |
| else |
| return mid; |
| |
| } while (low < high); |
| |
| return 0; |
| } |
| |
| /** |
| * Return the index of the first character in the line. |
| * @param line the internal index of the line (direct index into linetable). |
| */ |
| private int lineCharStartInternal(int line) |
| { |
| return fLineTable[line].getCharStart(fLTCurTextLen); |
| } |
| |
| /** |
| * Return the index of the character following the last character in the line. |
| * @param line the internal index of the line (direct index into linetable). |
| */ |
| private int lineCharLimitInternal(int line) |
| { |
| return lineCharStartInternal(line) + fLineTable[line].getCharLength(); |
| } |
| |
| /** |
| * Return the graphic start of the line, unadjusted for fill direction. |
| * @param line the internal index of the line (direct index into linetable). |
| */ |
| private int lineGraphicStartInternal(int line) |
| { |
| return fLineTable[line].getGraphicStart(fPixHeight); |
| } |
| |
| /** |
| * Return the graphic limit of the line, unadjusted for fill direction. |
| * @param line the internal index of the line (direct index into linetable). |
| */ |
| private int lineGraphicLimitInternal(int line) |
| { |
| return lineGraphicStartInternal(line) + fLineTable[line].getHeight(); |
| } |
| |
| /** |
| * Return the offset of the first character which has not been formatted. |
| * If all text has been formatted, return the current text length. |
| */ |
| private int lastLineCharStop() |
| { |
| return lineCharLimitInternal(lastLine()); |
| } |
| |
| /** |
| * Return a 'valid' line containing offset. This differs from getLineContaining in |
| * this maps kAfterLastLine to lastLine(), so that the result is always a valid |
| * linetable index. |
| */ |
| private int getValidLineContaining(TextOffset offset) { |
| |
| return getValidLineContaining(offset.fOffset, offset.fPlacement); |
| } |
| |
| /** |
| * Return a 'valid' line containing offset. This differs from getLineContaining in |
| * this maps kAfterLastLine to lastLine(), so that the result is always a valid |
| * linetable index. |
| */ |
| private int getValidLineContaining(int insOffset, boolean placement) |
| { |
| int line = getLineContaining(insOffset, placement); |
| if (line == kAfterLastLine) |
| line = lastLine(); |
| else if (line == kBeforeFirstLine) |
| throw new IllegalArgumentException("Debug: getLineContaining returned kBeforeFirstLine"); |
| |
| return line; |
| } |
| |
| /** |
| * Return index of line containing <tt>offset</tt>. |
| * ??? If offset is after last formatted line, returns kAfterLastLine. Is that good? |
| * <p> |
| * @param offset the offset whose line should be located |
| * @returns line containing <tt>offset</tt> |
| */ |
| private int getLineContaining(TextOffset offset) { |
| |
| return getLineContaining(offset.fOffset, offset.fPlacement); |
| } |
| |
| private int getLineContaining(int insOffset, boolean placement) |
| { |
| int pos = insOffset; |
| if (placement == TextOffset.BEFORE_OFFSET && pos > 0) |
| --pos; |
| |
| if (pos < 0) { |
| throw new IllegalArgumentException("Debug: getLineContaining offset < 0: " + pos); |
| } |
| |
| if (pos >= lastLineCharStop()) { |
| return emptyParagraphAtEndOfText()? kAfterLastLine : lastLine(); |
| } |
| |
| int low, high, mid; |
| int lowStart, highStart, midStart; |
| |
| if ((fLTNegStart < fLTSize) && (pos >= fLineTable[fLTNegStart].getCharStart(fLTCurTextLen))) { |
| pos -= fLTCurTextLen; |
| |
| low = fLTNegStart; |
| high = fLTSize; |
| highStart = 0; |
| } |
| else { |
| low = 0; |
| high = fLTPosEnd + 1; |
| highStart = fLineTable[fLTPosEnd].getCharStart(0) + fLineTable[fLTPosEnd].getCharLength(); |
| } |
| lowStart = fLineTable[low].getCharStart(0); |
| |
| do { |
| if (highStart == lowStart) { |
| return low; |
| } |
| |
| mid = low + (pos - lowStart) / (highStart - lowStart) * (high - low); |
| midStart = fLineTable[mid].getCharStart(0); |
| |
| if (midStart > pos) { |
| high = mid; |
| highStart = fLineTable[high].getCharStart(0); |
| } |
| else if (midStart + fLineTable[mid].getCharLength() <= pos) { |
| low = mid + 1; |
| lowStart = fLineTable[low].getCharStart(0); |
| } |
| else { |
| return mid; |
| } |
| |
| } while (low < high); |
| |
| return 0; |
| } |
| |
| /** |
| * Display text in drawArea. Does not reformat text. |
| * <p> |
| * @param g the Graphics object in which to draw |
| * @param drawArea the rectangle, in g's coordinate system, in which to draw |
| * @param origin the top-left corner of the text, in g's coordinate system |
| */ |
| public synchronized void draw(Graphics g, Rectangle drawArea, Point origin) |
| { |
| draw(g, drawArea, origin, null, null, null); |
| } |
| |
| public synchronized void draw(Graphics g, Rectangle drawArea, Point origin, |
| TextOffset selStart, TextOffset selStop, Color highlight) { |
| |
| checkTimeStamp(); |
| Graphics2D g2d = Graphics2DConversion.getGraphics2D(g); |
| |
| // Get starting and ending fill 'heights.' |
| |
| int startFill; |
| int endFill; |
| |
| if (fFillInc) |
| startFill = drawArea.y - origin.y; |
| else |
| startFill = origin.y - (drawArea.y + drawArea.height); |
| |
| endFill = startFill + drawArea.height; |
| |
| // We're drawing one more line than necessary when we update because of a |
| // selection change. But we're drawing the right amount of lines when we |
| // refresh the whole display. This affects rendering speed significantly, |
| // and creating a new paragraph renderer for each line doesn't help either. |
| // For now, I'm going to subtract one from the fill height, on the theory |
| // that we're picking up the extra line because of a one-pixel slop. |
| // This seems to work, although perhaps if one pixel of a line at the |
| // bottom should draw, it won't. |
| |
| --endFill; |
| |
| // Format to ending fill height, so line table is valid for all lines we need to draw. |
| |
| formatToHeight(endFill); |
| |
| // Get starting and ending lines for fill height. If the start of the fill is after the last line, |
| // or the end of the fill is before the first line, return. |
| |
| int curLine = findLineAt(startFill); |
| if (curLine == kAfterLastLine) |
| return; |
| else if (curLine == kBeforeFirstLine) |
| curLine = 0; |
| |
| int lastLine = findLineAt(endFill); |
| if (lastLine == kBeforeFirstLine) |
| return; |
| else if (lastLine == kAfterLastLine) |
| lastLine = lastLine(); |
| |
| // Get the base coordinates (lineX, lineY) for the starting line. |
| |
| int lineX, lineY; |
| |
| int gStart = lineGraphicStartInternal(curLine); |
| |
| if (fHLine) { |
| if (fLineInc) |
| lineX = origin.x; |
| else |
| lineX = origin.x - fLineDim; |
| if (fFillInc) |
| lineY = origin.y + gStart; |
| else |
| lineY = origin.y - (gStart + fLineTable[curLine].getHeight()); |
| } |
| else { |
| if (fLineInc) |
| lineY = origin.y; |
| else |
| lineY = origin.y - fLineDim; |
| if (fFillInc) |
| lineX = origin.x + gStart; |
| else |
| lineX = origin.x - (gStart + fLineTable[curLine].getHeight()); |
| } |
| |
| // Iterate through lines, drawing each one and incrementing the base coordinate by the line height. |
| |
| |
| for (; curLine <= lastLine; curLine++) { |
| // Adjust curLine around gap in line table. |
| if ((curLine > fLTPosEnd) && (curLine < fLTNegStart)) |
| curLine = fLTNegStart; |
| |
| fLineTable[curLine].renderWithHighlight(fLTCurTextLen, g2d, fLineDim, lineX, lineY, selStart, selStop, highlight); |
| |
| // Increment line base for next iteration. |
| int lineInc = fLineTable[curLine].getHeight(); |
| if (fFillInc) { |
| if (fHLine) |
| lineY += lineInc; |
| else |
| lineX += lineInc; |
| } else { |
| if (fHLine) |
| lineY -= lineInc; |
| else |
| lineX -= lineInc; |
| } |
| } |
| } |
| |
| /** |
| * Format text to given height. |
| * @param height the height to which text will be formatted. |
| */ |
| public synchronized void formatToHeight(int reqHeight) |
| { |
| checkTimeStamp(); |
| if (reqHeight <= fPixHeight) // already formatted to this height |
| return; |
| |
| if (fText.length() == lastLineCharStop()) // already formatted all the text |
| return; |
| |
| // +++ should disable update thread here |
| |
| if (fLTNegStart < fLTSize) |
| shiftTableTo(fLTSize - 1); |
| |
| formatText(0, 0, reqHeight, false); |
| } |
| |
| /** |
| * Format text to given offset. |
| * @param offset the offset to which text will be formatted. |
| */ |
| private void formatToOffset(TextOffset offset) |
| { |
| formatToOffset(offset.fOffset, offset.fPlacement); |
| } |
| |
| private synchronized void formatToOffset(int offset, boolean placement) { |
| |
| checkTimeStamp(); |
| int llcs = lastLineCharStop(); |
| if (llcs < fLTCurTextLen) { |
| int limit = offset; |
| if (placement == TextOffset.AFTER_OFFSET) // format to past character offset is associated with |
| limit++; |
| if (limit >= llcs) { // ??? would '>' be ok instead or '>='? |
| if (limit > fLTCurTextLen) |
| limit = fLTCurTextLen; |
| |
| shiftTableTo(lastLine()); |
| formatText(llcs, limit - llcs, Integer.MAX_VALUE, true); |
| } |
| } |
| } |
| |
| /** |
| * Reformat text after a change. |
| * After the formatter's text changes, call this method to reformat. Does |
| * not redraw. |
| * @param afStart the offset into the text where modification began; ie, the |
| * first character in the text which is "different" in some way. Does not |
| * have to be nonnegative. |
| * @param afLength the number of new or changed characters in the text. Should never |
| * be less than 0. |
| * @param viewRect the Rectangle in which the text will be displayed. This is needed for |
| * returning the "damaged" area - the area of the screen in which the text must be redrawn. |
| * @param origin the top-left corner of the text, in the display's coordinate system |
| * @returns a <tt>Rectangle</tt> which specifies the area in which text must be |
| * redrawn to reflect the change to the text. |
| */ |
| public Rectangle updateFormat(final int afStart, |
| final int afLength, |
| Rectangle viewRect, |
| Point origin) |
| { |
| if (afStart < 0) { |
| throw new IllegalArgumentException("Debug: updateFormat afStart < 0: " + afStart); |
| } |
| if (fBgFormatAllowed) { |
| throw new IllegalArgumentException("Background formatting should have been disabled"); |
| } |
| fCurTimeStamp = fText.getTimeStamp(); |
| |
| int curLine = getValidLineContaining(afStart, TextOffset.AFTER_OFFSET); |
| int lineStartPos = lineCharStartInternal(curLine); |
| |
| // optimize by finding out whether change occurred |
| // after first word break on curline |
| |
| int firstPossibleBreak; |
| |
| if (lineStartPos < fText.length()) { |
| |
| if (fLineBreak == null) { |
| fLineBreak = BreakIterator.getLineInstance(); |
| } |
| CharacterIterator charIter = fText.createCharacterIterator(); |
| charIter.setIndex(lineStartPos); |
| fLineBreak.setText(charIter); |
| |
| firstPossibleBreak = fLineBreak.following(lineStartPos); |
| } |
| else |
| firstPossibleBreak = afStart; |
| |
| if ((curLine > 0) && (firstPossibleBreak == BreakIterator.DONE || afStart <= firstPossibleBreak)) { |
| curLine--; |
| if (curLine < fLTNegStart && curLine > fLTPosEnd) |
| curLine = fLTPosEnd; |
| } |
| |
| shiftTableTo(curLine); |
| |
| int pixHeight; // after the formatText call, at least pixHeight text must be formatted |
| |
| if (fHLine) { |
| if (fFillInc) |
| pixHeight = viewRect.y + viewRect.height - origin.y; |
| else |
| pixHeight = origin.y - viewRect.y; |
| } |
| else { |
| if (fFillInc) |
| pixHeight = viewRect.x + viewRect.width - origin.x; |
| else |
| pixHeight = origin.x - viewRect.x; |
| } |
| |
| Rectangle r = formatText(afStart, afLength, pixHeight, false); |
| |
| //dumpLineTable(); |
| |
| if ((fPixHeight < pixHeight) && (fLTNegStart < fLTSize) && (fLTCurTextLen > lastLineCharStop())) { |
| shiftTableTo(lastLine()); |
| Rectangle s = formatText(0, 0, pixHeight, false); |
| r = r.union(s); |
| } |
| |
| intlRect(origin, r); |
| //System.out.println("Damaged rect: "+r+"; origin: "+origin); |
| |
| // don't need to synchronized here, b/c the daemon shouldn't be running when |
| // this is executing |
| |
| if (fText.length() < lastLineCharStop()) |
| enableBGFormat(); |
| else |
| stopBackgroundFormatting(); |
| |
| //dumpLineTable(); |
| |
| return r; |
| } |
| |
| private LineBreakMeasurer makeMeasurer(int paragraphStart, int paragraphLimit) { |
| |
| MTextIterator iter = new MTextIterator(fText, |
| fFontResolver, |
| paragraphStart, |
| paragraphLimit); |
| LineBreakMeasurer measurer = new LineBreakMeasurer(iter, fFontRenderContext); |
| if (fgCacheMeasurers) { |
| fCachedMeasurerStart = paragraphStart; |
| fCachedMeasurerLimit = paragraphLimit; |
| fCachedMeasurer = measurer; |
| } |
| return measurer; |
| } |
| |
| /** |
| * Compute text format. This method calculates text format; it can be |
| * called for various purposes: to reformat text after an edit, to |
| * format text to a particular height, or to format text up to a |
| * particular offset. |
| * <p> |
| * The calling method must ensure that <tt>fLineTable</tt> has been shifted |
| * such that the last positive line is where the formatting operation will |
| * begin. |
| * <p> |
| * Called by: <tt>formatToHeight()</tt>, <tt>updateFormat()</tt>, |
| * <tt>textOffsetToPoint()</tt>, <tt>getBoundingRect()</tt> |
| * @param afStart the offset of the first character in the text which has changed |
| * @param afLength the number of new or changed characters in the text |
| * @param reqHeight the pixel height to which text must be formatted. Ignored |
| * if <tt>formatAllNewText</tt> is <tt>true</tt>, or if old lines remain in the |
| * line table after all changed text has been formatted. |
| * @param seekOffsetAtEnd if <tt>true</tt>, formatting continues until the line |
| * containing afStart+afLength has been formatted. If false, formatting may stop |
| * when reqHeight has been reached. This parameter should be <tt>true</tt> <b>only</b> |
| * if the object of the formatting operation is to extend formatting to a particular |
| * offset within the text; it should be <tt>false</tt> everywhere else. |
| * @returns a rectangle, relative to the top-left of the text, which encloses the |
| * screen area whose appearance has changed due to the reformatting. |
| */ |
| |
| private Rectangle formatText(int afStart, final int afLength, int reqHeight, boolean seekOffsetAtEnd) |
| { |
| /* assumes line table shifted such that first line to format is |
| last positive line */ |
| |
| if (afLength < 0) { |
| throw new IllegalArgumentException("afLength < 0. afLength=" + afLength); |
| } |
| |
| int newTextEnd = afStart + afLength; |
| |
| final int newCurTextLen = fText.length(); |
| |
| // variable not used int oldPixHeight = fPixHeight; |
| int oldFullPixHeight = fFullPixHeight; |
| fPixHeight -= fLineTable[fLTPosEnd].getHeight(); |
| |
| int curGraphicStart = fLineTable[fLTPosEnd].getGraphicStart(fPixHeight); |
| int curLineStart = fLineTable[fLTPosEnd].getCharStart(newCurTextLen); |
| |
| int curParagraphStart = fText.paragraphStart(curLineStart); |
| int curParagraphLimit = Integer.MIN_VALUE; // dummy value |
| |
| int damageStart = curGraphicStart; |
| |
| ParagraphRenderer renderer = null; |
| LineBreakMeasurer measurer = null; |
| |
| // try to use cached LineBreakMeasurer if possible |
| if (fCachedMeasurer != null && |
| curParagraphStart == fCachedMeasurerStart) { |
| |
| curParagraphLimit = fText.paragraphLimit(curParagraphStart); |
| |
| try { |
| if (newCurTextLen - fLTCurTextLen == 1 && afLength == 1) { |
| if (curParagraphLimit == fCachedMeasurerLimit+1) { |
| MTextIterator iter = new MTextIterator(fText, |
| fFontResolver, |
| curParagraphStart, |
| curParagraphLimit); |
| fCachedMeasurer.insertChar(iter, afStart); |
| fCachedMeasurerLimit += 1; |
| measurer = fCachedMeasurer; |
| } |
| } |
| else if (fLTCurTextLen - newCurTextLen == 1 && afLength == 0) { |
| if (fCachedMeasurerLimit > fCachedMeasurerStart + 1 && |
| curParagraphLimit == fCachedMeasurerLimit-1) { |
| MTextIterator iter = new MTextIterator(fText, |
| fFontResolver, |
| curParagraphStart, |
| curParagraphLimit); |
| fCachedMeasurer.deleteChar(iter, afStart); |
| fCachedMeasurerLimit -= 1; |
| measurer = fCachedMeasurer; |
| } |
| } |
| } |
| catch(ArrayIndexOutOfBoundsException e) { |
| fCachedMeasurer = null; |
| fgCacheMeasurers = false; |
| } |
| |
| if (measurer != null) { |
| // need to set up renderer since the paragraph update in the |
| // formatting loop will not happen |
| AttributeMap style = fText.paragraphStyleAt(curParagraphStart); |
| renderer = getRendererFor(style); |
| measurer.setPosition(curLineStart); |
| } |
| } |
| |
| if (measurer == null) { |
| // trigger paragraph update at start of formatting loop |
| curParagraphLimit = curParagraphStart; |
| curParagraphStart = 0; |
| } |
| |
| fLTCurTextLen = newCurTextLen; |
| |
| while (true) { |
| // System.out.println("line: " + fLTPosEnd + ", cls: " + curLineStart); |
| |
| |
| if (curLineStart >= curParagraphLimit) { |
| curParagraphStart = curParagraphLimit; |
| curParagraphLimit = fText.paragraphLimit(curParagraphStart); |
| |
| AttributeMap style = fText.paragraphStyleAt(curParagraphStart); |
| renderer = getRendererFor(style); |
| |
| if (curParagraphStart < curParagraphLimit) { |
| measurer = makeMeasurer(curParagraphStart, curParagraphLimit); |
| measurer.setPosition(curLineStart); |
| } |
| else { |
| measurer = null; |
| } |
| } |
| |
| { |
| boolean haveOldDirection = fLineTable[fLTPosEnd] != null; |
| boolean oldDirection = false; // dummy value for compiler |
| if (haveOldDirection) { |
| oldDirection = fLineTable[fLTPosEnd].isLeftToRight(); |
| } |
| |
| fLineTable[fLTPosEnd] = renderer.layout(fText, |
| fLineTable[fLTPosEnd], |
| measurer, |
| fFontRenderContext, |
| curParagraphStart, |
| curParagraphLimit, |
| fWrap ? fLineDim : Integer.MAX_VALUE, |
| fLineDim); |
| if (haveOldDirection) { |
| if (fLineTable[fLTPosEnd].isLeftToRight() != oldDirection) { |
| newTextEnd = Math.max(newTextEnd, curParagraphLimit); |
| } |
| } |
| } |
| |
| { |
| LayoutInfo theLine = fLineTable[fLTPosEnd]; |
| |
| theLine.setGraphicStart(curGraphicStart); |
| curGraphicStart += theLine.getHeight(); |
| |
| fPixHeight += theLine.getHeight(); |
| curLineStart += theLine.getCharLength(); |
| |
| if (!fWrap) { |
| int lineWidth = theLine.getTotalAdvance() + theLine.getLeadingMargin(); |
| if (theLine.isLeftToRight()) { |
| if (fMaxX < lineWidth) { |
| fMaxX = lineWidth; |
| } |
| } |
| else { |
| if (fLineDim-lineWidth < fMinX) { |
| fMinX = fLineDim-lineWidth; |
| } |
| } |
| } |
| } |
| /* |
| Next, discard obsolete lines. A line is obsolete if it |
| contains new text or text which has been formatted. |
| */ |
| |
| while (fLTNegStart < fLTSize) { |
| int linePos = fLineTable[fLTNegStart].getCharStart(newCurTextLen); |
| if (linePos >= curLineStart && linePos >= newTextEnd) |
| break; |
| |
| // System.out.println("delete neg line: " + fLTNegStart); |
| fPixHeight -= fLineTable[fLTNegStart].getHeight(); |
| fLineTable[fLTNegStart++] = null; |
| } |
| |
| int stopAt; |
| if (fLTNegStart < fLTSize) |
| stopAt = fLineTable[fLTNegStart].getCharStart(newCurTextLen); |
| else |
| stopAt = newCurTextLen; |
| |
| /* |
| Now, if exit conditions aren't met, create a new line. |
| */ |
| |
| if (seekOffsetAtEnd) { |
| if ((curLineStart >= newTextEnd) && (fLTNegStart == fLTSize)) { |
| // System.out.println("break 1"); |
| break; |
| } |
| } |
| else { |
| if (curLineStart >= stopAt) { |
| // System.out.println("curLineStart: " + curLineStart + " >= stopAt: " + stopAt); |
| break; |
| } |
| else if (fLTNegStart==fLTSize && fPixHeight >= reqHeight) { |
| // System.out.println("break 3"); |
| break; |
| } |
| } |
| |
| if (fLTPosEnd + 1 == fLTNegStart) |
| expandLineTable(); |
| |
| fLineTable[++fLTPosEnd] = null; // will be created by Renderer |
| } |
| //System.out.print("\n"); |
| |
| if (newCurTextLen == 0) { |
| fLineTable[0] = pseudoLineInfo(fLineTable[0], 0); |
| fPixHeight = fLineTable[0].getHeight(); |
| } |
| fFullPixHeight = fPixHeight; |
| |
| if (isParaBreakBefore(newCurTextLen)) { |
| fFullPixHeight += lastCharHeight(); |
| } |
| /* |
| System.out.println("curLineStart: " + curLineStart + |
| ", fLTPosEnd: " + fLTPosEnd + |
| ", fLTNegStart: " + fLTNegStart + |
| ", fLTSize: " + fLTSize); |
| |
| System.out.println("oldFullPixHeight: " + oldFullPixHeight + ", newFullPixHeight: " + fFullPixHeight); |
| */ |
| int damageLength; |
| if (fFullPixHeight == oldFullPixHeight) { |
| damageLength = fLineTable[fLTPosEnd].getGraphicStart(fPixHeight) |
| + fLineTable[fLTPosEnd].getHeight() - damageStart; |
| } |
| else { |
| damageLength = Math.max(fFullPixHeight, oldFullPixHeight); |
| } |
| |
| return new Rectangle(fMinX, damageStart, fMaxX-fMinX, damageLength); |
| } |
| |
| // private void dumpLineTable() |
| // { |
| // int i; |
| // |
| // System.out.println("fLTCurTextLen=" + fLTCurTextLen + " " ); |
| // for (i=0; i<= fLTPosEnd; i++) |
| // System.out.println("Line " + i + " starts at " |
| // + fLineTable[i].getCharStart(fLTCurTextLen) |
| // + " and extends " + fLineTable[i].getCharLength()); |
| // |
| // for (i=fLTNegStart; i< fLTSize; i++) |
| // System.out.println("Line " + (i-fLTNegStart+fLTPosEnd+1) + " starts at " |
| // + fLineTable[i].getCharStart(fLTCurTextLen) |
| // + " and extends " + fLineTable[i].getCharLength()); |
| // } |
| |
| public synchronized int minX() { |
| |
| return fMinX; |
| } |
| |
| /** |
| * Return the horizontal extent of the text, in pixels. |
| * <p> |
| * This returns an approximation based on the currently formatted text. |
| */ |
| public synchronized int maxX() |
| { |
| checkTimeStamp(); |
| |
| return fMaxX; |
| } |
| |
| /** |
| * Return the height of the last character in the text. |
| * |
| * This is used for the 'extra height' needed to display a caret at the end of the text when the |
| * text is empty or ends with a newline. |
| */ |
| private int lastCharHeight() |
| { |
| int charIndex = lastLineCharStop() - 1; |
| AttributeMap st = fText.characterStyleAt(charIndex); |
| DefaultCharacterMetric.Metric metric = fDefaultCharMetric.getMetricForStyle(st); |
| |
| int height = metric.getAscent(); |
| height += metric.getDescent(); |
| height += metric.getLeading(); |
| |
| return height; |
| } |
| |
| /** |
| * Return true if the character at pos is a paragraph separator. |
| */ |
| private boolean isParaBreakBefore(int pos) |
| { |
| return pos > 0 && (fText.at(pos - 1) == '\u2029' || fText.at(pos - 1) == '\n'); |
| // we really need to take look at this and determine what this function |
| // should be doing. What I've got here right now is a temporary implementation. |
| } |
| |
| public synchronized int minY() { |
| |
| return 0; |
| } |
| |
| /** |
| * Return the vertical extent of the text, in pixels. |
| * <p> |
| * This returns an approximation based on the currently formatted text. |
| */ |
| public synchronized int maxY() |
| { |
| checkTimeStamp(); |
| |
| int numChars = lastLineCharStop(); |
| |
| int pixHeight = fPixHeight; |
| if (numChars == fLTCurTextLen && isParaBreakBefore(fLTCurTextLen)) { |
| pixHeight += lastCharHeight(); |
| } |
| |
| if (numChars != 0) |
| return pixHeight * fText.length() / numChars; |
| else |
| return 0; |
| } |
| |
| /** |
| * Return the actual pixel length of the text which has been formatted. |
| */ |
| public synchronized int formattedHeight() |
| { |
| checkTimeStamp(); |
| return fPixHeight; |
| } |
| |
| /** |
| * There are two modes for dealing with carriage returns at the end of a line. In the 'infinite width' |
| * mode, the last character is considered to have infinite width. Thus if the point is past the 'real' |
| * end of the line, the offset is the position before that last character, and the offset is associated |
| * with that character (placement after). In the 'actual width' mode, the offset is positioned after |
| * that character, but still associated with it (placement before). |
| */ |
| |
| private TextOffset lineDimToOffset(TextOffset result, int line, int lineX, int lineY, TextOffset anchor, boolean infiniteMode) |
| { |
| // temporarily adjust line info to remove the negative char starts used in the line table. |
| // then call through to the paragraph renderer to get the offset. Don't put line end |
| // optimization here, let the renderer do it (perhaps it does fancy stuff with the margins). |
| |
| LayoutInfo lineInfo = fLineTable[line]; |
| |
| result = lineInfo.pixelToOffset(fLTCurTextLen, result, fLineDim, lineX, lineY); |
| |
| if (infiniteMode && |
| (result.fOffset > lineInfo.getCharStart(fLTCurTextLen)) && |
| isParaBreakBefore(result.fOffset) && |
| (anchor == null || anchor.fOffset == result.fOffset - 1)) { |
| |
| result.setOffset(result.fOffset - 1, TextOffset.AFTER_OFFSET); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Given a screen location p, return the offset of the character in the text nearest to p. |
| */ |
| public synchronized TextOffset pointToTextOffset(TextOffset result, int px, int py, Point origin, TextOffset anchor, boolean infiniteMode) |
| { |
| checkTimeStamp(); |
| if (result == null) |
| result = new TextOffset(); |
| |
| int fillD; |
| |
| if (fHLine) |
| fillD = py - origin.y; |
| else |
| fillD = px - origin.x; |
| |
| if (!fFillInc) |
| fillD = -fillD; |
| |
| if (fillD < 0) { |
| result.setOffset(0, TextOffset.AFTER_OFFSET); |
| return result; |
| } |
| |
| formatToHeight(fillD); |
| |
| if (fillD >= fPixHeight) { |
| boolean bias = fLTCurTextLen==0? TextOffset.AFTER_OFFSET : TextOffset.BEFORE_OFFSET; |
| result.setOffset(fLTCurTextLen, bias); |
| return result; |
| } |
| |
| int line = findLineAt(fillD); // always a valid line |
| int gStart = lineGraphicStartInternal(line); |
| |
| int lineX, lineY; // upper-left corner of line |
| if (fHLine) { |
| lineX = origin.x; |
| lineY = fFillInc? origin.y + gStart : origin.y - (gStart + fLineTable[line].getHeight()); |
| } |
| else { |
| lineY = origin.y; |
| lineX = fFillInc? origin.x + gStart : origin.x - (gStart + fLineTable[line].getHeight()); |
| } |
| |
| return lineDimToOffset(result, line, px - lineX, py - lineY, anchor, infiniteMode); |
| } |
| |
| private boolean emptyParagraphAtEndOfText() { |
| |
| return fLTCurTextLen > 0 && |
| isParagraphSeparator(fText.at(fLTCurTextLen-1)); |
| } |
| |
| /** |
| * Return true if the offset designates a point on the pseudoline following a paragraph |
| * separator at the end of text. This is true if the offset is the end of text |
| * and the last character in the text is a paragraph separator. |
| */ |
| private boolean afterLastParagraph(TextOffset offset) |
| { |
| return offset.fOffset == fLTCurTextLen && |
| emptyParagraphAtEndOfText(); |
| } |
| |
| /** |
| * Given an offset, return the Rectangle bounding the caret at the offset. |
| * @param offset an offset into the text |
| * @param origin the top-left corner of the text, in the display's coordinate system |
| * @return a Rectangle bounding the caret. |
| */ |
| public synchronized Rectangle getCaretRect(TextOffset offset, Point origin) { |
| |
| Rectangle r = new Rectangle(); |
| getCaretRect(r, offset, origin); |
| return r; |
| } |
| |
| private void getCaretRect(Rectangle r, TextOffset offset, Point origin) { |
| |
| checkTimeStamp(); |
| formatToOffset(offset); |
| |
| if (afterLastParagraph(offset)) { |
| int pseudoLineHeight = lastCharHeight(); |
| if (fHLine) { |
| int lineY = fFillInc ? origin.y + fPixHeight : origin.y - fPixHeight - pseudoLineHeight; |
| r.setBounds(origin.x, lineY, 0, pseudoLineHeight); |
| } |
| else { |
| int lineX = fFillInc? origin.x + fPixHeight : origin.x - fPixHeight - pseudoLineHeight; |
| r.setBounds(lineX, origin.y, pseudoLineHeight, 0); |
| } |
| return; |
| } |
| |
| int line = getValidLineContaining(offset); |
| |
| int gStart = lineGraphicStartInternal(line); |
| |
| int lineX, lineY; |
| |
| if (fHLine) { |
| lineX = origin.x; |
| if (fFillInc) |
| lineY = origin.y + gStart; |
| else |
| lineY = origin.y - (gStart + fLineTable[line].getHeight()); |
| } |
| else { |
| lineY = origin.y; |
| if (fFillInc) |
| lineX = origin.x + gStart; |
| else |
| lineX = origin.x - (gStart + fLineTable[line].getHeight()); |
| } |
| |
| Rectangle bounds = fLineTable[line].caretBounds(fText, fLTCurTextLen, fLineDim, offset.fOffset, lineX, lineY); |
| |
| r.setBounds(bounds); |
| } |
| |
| /** |
| * Draw the caret(s) associated with the given offset into the given Graphics. |
| * @param g the Graphics to draw into |
| * @param offset the offset in the text for which the caret is drawn |
| * @param origin the top-left corner of the text, in the display's coordinate system |
| * @param strongCaretColor the color of the strong caret |
| * @param weakCaretColor the color of the weak caret (if any) |
| */ |
| public synchronized void drawCaret(Graphics g, |
| TextOffset offset, |
| Point origin, |
| Color strongCaretColor, |
| Color weakCaretColor) { |
| |
| checkTimeStamp(); |
| Graphics2D g2d = Graphics2DConversion.getGraphics2D(g); |
| formatToOffset(offset); |
| |
| LayoutInfo line; |
| int gStart; |
| |
| if (afterLastParagraph(offset)) { |
| gStart = fPixHeight; |
| line = pseudoLineInfo(null, offset.fOffset); |
| } |
| else { |
| int lineIndex = getValidLineContaining(offset); |
| gStart = lineGraphicStartInternal(lineIndex); |
| line = fLineTable[lineIndex]; |
| } |
| |
| int lineX, lineY; |
| |
| if (fHLine) { |
| lineX = origin.x; |
| if (fFillInc) |
| lineY = origin.y + gStart; |
| else |
| lineY = origin.y - (gStart + line.getHeight()); |
| } |
| else { |
| lineY = origin.y; |
| if (fFillInc) |
| lineX = origin.x + gStart; |
| else |
| lineX = origin.x - (gStart + line.getHeight()); |
| } |
| |
| line.renderCaret(fText, fLTCurTextLen, g2d, fLineDim, lineX, lineY, |
| offset.fOffset, strongCaretColor, weakCaretColor); |
| } |
| |
| /** |
| * Given two offsets in the text, return a rectangle which encloses the lines containing the offsets. |
| * Offsets do not need to be ordered or nonnegative. |
| * @param offset1,offset2 offsets into the text |
| * @param origin the top-left corner of the text, in the display's coordinate system |
| * @returns a <tt>Rectangle</tt>, relative to <tt>origin</tt>, which encloses the lines containing the offsets |
| */ |
| public synchronized Rectangle getBoundingRect(TextOffset offset1, |
| TextOffset offset2, |
| Point origin, |
| boolean tight) { |
| |
| Rectangle r = new Rectangle(); |
| getBoundingRect(r, offset1, offset2, origin, tight); |
| return r; |
| } |
| |
| /* |
| Transform r from "text" coordinates to "screen" coordinates. |
| */ |
| |
| private void intlRect(Point origin, Rectangle r) { |
| |
| int lineOrig, fillOrig; |
| |
| if (fHLine) { |
| lineOrig = origin.x; |
| fillOrig = origin.y; |
| } |
| else { |
| lineOrig = origin.y; |
| fillOrig = origin.x; |
| } |
| |
| if (fLineInc) |
| r.x += lineOrig; |
| else |
| r.x = lineOrig - (r.x + r.width); |
| |
| if (fFillInc) |
| r.y += fillOrig; |
| else |
| r.y = fillOrig - (r.y + r.height); |
| |
| |
| if (!fHLine) { |
| int t = r.x; |
| r.x = r.y; |
| r.y = t; |
| t = r.width; |
| r.width = r.height; |
| r.height = t; |
| } |
| } |
| |
| |
| public synchronized void getBoundingRect(Rectangle r, |
| TextOffset offset1, |
| TextOffset offset2, |
| Point origin, |
| boolean tight) |
| { |
| checkTimeStamp(); |
| if (offset1.equals(offset2)) { |
| getCaretRect(r, offset1, origin); |
| return; |
| } |
| if (offset1.greaterThan(offset2)) { |
| TextOffset t; t = offset1; offset1 = offset2; offset2 = t; |
| } |
| |
| formatToOffset(offset2); |
| |
| int line = getValidLineContaining(offset1); |
| r.y = lineGraphicStartInternal(line); |
| |
| int gLimit; |
| boolean sameLine = false; |
| |
| if (afterLastParagraph(offset2)) |
| gLimit = fPixHeight + lastCharHeight(); |
| else { |
| int line2 = getValidLineContaining(offset2); |
| gLimit = lineGraphicLimitInternal(line2); |
| sameLine = (line == line2); |
| } |
| |
| r.height = gLimit - r.y; |
| |
| if (sameLine && tight==TIGHT) { |
| Rectangle rt = new Rectangle(); |
| getCaretRect(rt, offset1, origin); |
| r.setBounds(rt); |
| if (!offset1.equals(offset2)) { |
| getCaretRect(rt, offset2, origin); |
| r.add(rt); |
| } |
| } |
| else { |
| r.x = fMinX; |
| r.width = fMaxX - fMinX; |
| intlRect(origin, r); |
| } |
| |
| // System.out.print("gbr: " + r.x + ", " + r.y + ", " + r.width + ", " + r.height); |
| |
| // System.out.println(" --> " + r.x + ", " + r.y + ", " + r.width + ", " + r.height); |
| } |
| |
| /** |
| * Compute the offset resulting from moving from a previous offset in direction dir. |
| * For arrow keys. |
| * @param result the offset to modify and return. may be null, if so a new offset is allocated, modified, and returned. |
| * @param previousOffset the insertion offset prior to the arrow key press. |
| * @param direction the direction of the arrow key (eUp, eDown, eLeft, or eRight) |
| * @returns new offset based on direction and previous offset. |
| */ |
| public synchronized TextOffset findInsertionOffset(TextOffset result, TextOffset prevOffset, short dir) |
| { |
| return findNewInsertionOffset(result, prevOffset, prevOffset, dir); |
| } |
| |
| /** |
| * Transform key direction: after this step, "left" means previous glyph, "right" means next glyph, |
| *"up" means previous line, "down" means next line |
| */ |
| private short remapArrowKey(short dir) { |
| |
| if (!fLineInc) { |
| if (dir == eLeft) |
| dir = eRight; |
| else if (dir == eRight) |
| dir = eLeft; |
| } |
| |
| if (!fFillInc) { |
| if (dir == eUp) |
| dir = eDown; |
| else if (dir == eDown) |
| dir = eUp; |
| } |
| |
| if (!fHLine) { |
| if (dir == eLeft) |
| dir = eUp; |
| else if (dir == eRight) |
| dir = eDown; |
| else if (dir == eUp) |
| dir = eLeft; |
| else if (dir == eDown) |
| dir = eRight; |
| } |
| |
| return dir; |
| } |
| |
| /** |
| * Compute the offset resulting from moving from a previous offset, starting at an original offset, in direction dir. |
| * For arrow keys. Use this for "smart" up/down keys. |
| * @param result the offset to modify and return. May be null, if so a new offset is allocated, modified, and returned. |
| * @param origOffset the offset at which an up-down arrow key sequence began. |
| * @param prevOffset the insertion offset prior to the arrow key press |
| * @param dir the direction of the arrow key (eUp, eDown, eLeft, or eRight) |
| * @returns new offset based on direction, original offset, and previous offset. |
| */ |
| public synchronized TextOffset findNewInsertionOffset(TextOffset result, TextOffset origOffset, TextOffset prevOffset, short dir) |
| { |
| checkTimeStamp(); |
| if (result == null) |
| result = new TextOffset(); |
| |
| dir = remapArrowKey(dir); |
| |
| // assume that text at origOffset and prevOffset has already been formatted |
| |
| if (dir == eLeft || dir == eRight) { |
| formatToOffset(prevOffset); |
| int line = getValidLineContaining(prevOffset); |
| |
| result.fPlacement = TextOffset.AFTER_OFFSET; |
| result.fOffset = fLineTable[line].getNextOffset(fLTCurTextLen, prevOffset.fOffset, dir); |
| if (result.fOffset < 0) { |
| result.fOffset = 0; |
| } |
| else if (result.fOffset >= fLTCurTextLen) { |
| result.setOffset(fLTCurTextLen, TextOffset.BEFORE_OFFSET); |
| } |
| } |
| else { |
| int distOnLine; |
| |
| if (afterLastParagraph(origOffset)) |
| distOnLine = 0; |
| else { |
| int line = getValidLineContaining(origOffset); |
| |
| distOnLine = fLineTable[line].strongCaretBaselinePosition(fLTCurTextLen, fLineDim, origOffset.fOffset); |
| } |
| |
| // get prevOffset's line |
| int line; |
| if (afterLastParagraph(prevOffset)) |
| line = lastLine() + 1; |
| else { |
| line = getLineContaining(prevOffset); |
| |
| if (dir == eDown && (line == kAfterLastLine || line == lastLine()) |
| && (lastLineCharStop() < fText.length())) { |
| shiftTableTo(lastLine()); |
| formatText(lastLineCharStop(), 1, Integer.MAX_VALUE, true); |
| line = getLineContaining(prevOffset); |
| } |
| |
| if (line == kBeforeFirstLine) |
| line = 0; |
| else if (line == kAfterLastLine) |
| line = lastLine(); |
| } |
| |
| if (dir == eUp) |
| line--; |
| else if (dir == eDown) |
| line++; |
| else |
| throw new IllegalArgumentException("Debug: Illegal direction parameter in findNewInsertionOffset"); |
| |
| if (line < 0) { |
| //result.setOffset(0, TextOffset.AFTER_OFFSET); |
| result.assign(prevOffset); |
| } |
| else if (line > lastLine()) { |
| result.setOffset(fLTCurTextLen, TextOffset.BEFORE_OFFSET); |
| } |
| else { |
| if (fLineTable[line] == null) |
| line = (dir == eUp)? fLTPosEnd : fLTNegStart; |
| |
| // anchor is null since we never want a position after newline. If we used the real anchor, |
| // we might not ignore the newline even though infiniteMode is true. |
| lineDimToOffset(result, line, distOnLine, 0, null, true); |
| } |
| } |
| |
| // System.out.println("fnio prev: " + prevOffset + ", new: " + result); |
| |
| return result; |
| } |
| |
| public synchronized void stopBackgroundFormatting() |
| { |
| checkTimeStamp(); |
| fBgFormatAllowed = false; |
| } |
| |
| private synchronized void enableBGFormat() |
| { |
| try { |
| fBgFormatAllowed = true; |
| notify(); |
| } |
| catch (IllegalMonitorStateException e) { |
| } |
| } |
| |
| private int lineIndexToNumber(int lineIndex) { |
| |
| if (lineIndex <= fLTPosEnd) { |
| return lineIndex; |
| } |
| else { |
| return lineIndex - (fLTNegStart-fLTPosEnd-1); |
| } |
| } |
| |
| private int lineNumberToIndex(int lineNumber) { |
| |
| if (lineNumber <= fLTPosEnd) { |
| return lineNumber; |
| } |
| else { |
| return lineNumber + (fLTNegStart-fLTPosEnd-1); |
| } |
| } |
| |
| private void formatToLineNumber(int lineNumber) { |
| |
| while (lastLineCharStop() < fLTCurTextLen && |
| lineNumber >= lineIndexToNumber(fLTSize)) { |
| // could be smarter and choose larger amounts for |
| // larger lines, but probably not worth the effort |
| formatToHeight(fPixHeight + kPixIncrement); |
| } |
| } |
| |
| private static final boolean STRICT = true; |
| private static final boolean LENIENT = false; |
| |
| /** |
| * Insure that at least lineNumber lines exist, doing |
| * extra formatting if necessary. |
| * Throws exception if lineNumber is not valid. |
| * @param strict if STRICT, only lines [0...maxLineNumber()] |
| * are permitted. If LENIENT, maxLineNumber()+1 is |
| * the greatest valid value. |
| */ |
| private void validateLineNumber(int lineNumber, boolean strict) { |
| |
| formatToLineNumber(lineNumber); |
| |
| int maxNumber = lineIndexToNumber(fLTSize); |
| if (strict == STRICT) { |
| maxNumber -= 1; |
| } |
| |
| if (lineNumber > maxNumber+1 || |
| (lineNumber == maxNumber+1 && !emptyParagraphAtEndOfText())) { |
| throw new IllegalArgumentException("Invalid line number: " + lineNumber); |
| } |
| } |
| |
| public synchronized int getLineCount() { |
| |
| // format all text: |
| formatToHeight(Integer.MAX_VALUE); |
| |
| int lineCount = lineIndexToNumber(fLTSize); |
| |
| if (emptyParagraphAtEndOfText()) { |
| lineCount += 1; |
| } |
| |
| return lineCount; |
| } |
| |
| public synchronized int lineContaining(int charIndex) { |
| |
| formatToOffset(charIndex, TextOffset.AFTER_OFFSET); |
| |
| boolean placement = TextOffset.AFTER_OFFSET; |
| if (charIndex == fLTCurTextLen && charIndex > 0) { |
| placement = emptyParagraphAtEndOfText()? TextOffset.AFTER_OFFSET : |
| TextOffset.BEFORE_OFFSET; |
| } |
| |
| return lineContaining(charIndex, placement); |
| } |
| |
| public synchronized int lineContaining(TextOffset offset) { |
| |
| formatToOffset(offset); |
| |
| if (afterLastParagraph(offset)) { |
| return lineIndexToNumber(fLTSize); |
| } |
| |
| return lineContaining(offset.fOffset, offset.fPlacement); |
| } |
| |
| private int lineContaining(int off, boolean placement) { |
| |
| int line = off==0? 0 : getLineContaining(off, placement); |
| |
| if (line == kAfterLastLine) { |
| line = fLTSize; |
| } |
| else if (line == kBeforeFirstLine) { |
| throw new Error("lineContaining got invalid result from getLineContaining()."); |
| } |
| |
| return lineIndexToNumber(line); |
| } |
| |
| public synchronized int lineRangeLow(int lineNumber) { |
| |
| validateLineNumber(lineNumber, STRICT); |
| int index = lineNumberToIndex(lineNumber); |
| |
| if (index == fLTSize) { |
| if (emptyParagraphAtEndOfText()) { |
| return lastLineCharStop(); |
| } |
| } |
| |
| if (index >= fLTSize) { |
| throw new IllegalArgumentException("lineNumber is invalid."); |
| } |
| else { |
| return lineCharStartInternal(index); |
| } |
| } |
| |
| public synchronized int lineRangeLimit(int lineNumber) { |
| |
| validateLineNumber(lineNumber, STRICT); |
| int index = lineNumberToIndex(lineNumber); |
| |
| if (index == fLTSize) { |
| if (emptyParagraphAtEndOfText()) { |
| return lastLineCharStop(); |
| } |
| } |
| |
| if (index >= fLTSize) { |
| throw new IllegalArgumentException("lineNumber is invalid."); |
| } |
| else { |
| return lineCharLimitInternal(index); |
| } |
| } |
| |
| /** |
| * Return the number of the line at the given graphic height. |
| * If height is greater than full height, return line count. |
| */ |
| public synchronized int lineAtHeight(int height) { |
| |
| if (height >= fPixHeight) { |
| |
| int line = getLineCount(); |
| if (height < fFullPixHeight) { |
| line -= 1; |
| } |
| return line; |
| } |
| else if (height < 0) { |
| return -1; |
| } |
| else { |
| return lineIndexToNumber(findLineAt(height)); |
| } |
| } |
| |
| public synchronized int lineGraphicStart(int lineNumber) { |
| |
| checkTimeStamp(); |
| validateLineNumber(lineNumber, LENIENT); |
| |
| int index = lineNumberToIndex(lineNumber); |
| |
| if (index < fLTSize) { |
| return lineGraphicStartInternal(index); |
| } |
| else { |
| if (index == fLTSize+1) { |
| return fFullPixHeight; |
| } |
| else { |
| return fPixHeight; |
| } |
| } |
| } |
| |
| public synchronized boolean lineIsLeftToRight(int lineNumber) { |
| |
| validateLineNumber(lineNumber, STRICT); |
| |
| int index = lineNumberToIndex(lineNumber); |
| |
| if (index < fLTSize) { |
| return fLineTable[index].isLeftToRight(); |
| } |
| else { |
| AttributeMap st = fText.paragraphStyleAt(fLTCurTextLen); |
| return !TextAttribute.RUN_DIRECTION_RTL.equals(st.get(TextAttribute.RUN_DIRECTION)); |
| } |
| } |
| |
| /** |
| * Number of pixels by which to advance formatting in the background. |
| */ |
| private static final int kPixIncrement = 100; |
| |
| /** |
| * Time to sleep between background formatting operations. |
| */ |
| private static final int kInterval = 100; |
| |
| /** |
| * Perform periodic background formatting. |
| */ |
| public void run() |
| { |
| while (true) { |
| synchronized (this) { |
| while(!fBgFormatAllowed) { |
| try { |
| wait(); |
| } catch(InterruptedException e) { |
| } |
| } |
| |
| checkTimeStamp(); |
| formatToHeight(fPixHeight + kPixIncrement); |
| |
| if (lastLineCharStop() == fLTCurTextLen) { |
| stopBackgroundFormatting(); |
| } |
| } |
| |
| try { |
| Thread.sleep(kInterval); |
| } |
| catch(InterruptedException e) { |
| } |
| } |
| } |
| |
| private ParagraphRenderer getRendererFor(AttributeMap s) { |
| |
| // Note: eventually we could let clients put their own renderers |
| // on the text. |
| BidiParagraphRenderer renderer = (BidiParagraphRenderer) fRendererCache.get(s); |
| if (renderer == null) { |
| renderer = new BidiParagraphRenderer(fDefaultValues.addAttributes(s), fDefaultCharMetric); |
| fRendererCache.put(s, renderer); |
| } |
| return renderer; |
| } |
| |
| } |
