Java tutorial
/* * Copyright (c) 1997, 2017, 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.awt.*; import java.awt.font.FontRenderContext; import java.awt.geom.Rectangle2D; import java.security.AccessController; import java.security.PrivilegedAction; import java.util.Objects; import javax.swing.event.*; import java.lang.ref.SoftReference; import java.util.HashMap; /** * Implements View interface for a simple multi-line text view * that has text in one font and color. The view represents each * child element as a line of text. * * @author Timothy Prinzing * @see View */ public class PlainView extends View implements TabExpander { /** * Constructs a new PlainView wrapped on an element. * * @param elem the element */ public PlainView(Element elem) { super(elem); } /** * Returns the tab size set for the document, defaulting to 8. * * @return the tab size */ protected int getTabSize() { Integer i = (Integer) getDocument().getProperty(PlainDocument.tabSizeAttribute); int size = (i != null) ? i.intValue() : 8; return size; } /** * Renders a line of text, suppressing whitespace at the end * and expanding any tabs. This is implemented to make calls * to the methods <code>drawUnselectedText</code> and * <code>drawSelectedText</code> so that the way selected and * unselected text are rendered can be customized. * * @param lineIndex the line to draw >= 0 * @param g the <code>Graphics</code> context * @param x the starting X position >= 0 * @param y the starting Y position >= 0 * @see #drawUnselectedText * @see #drawSelectedText * * @deprecated replaced by * {@link #drawLine(int, Graphics2D, float, float)} */ @Deprecated(since = "9") protected void drawLine(int lineIndex, Graphics g, int x, int y) { drawLineImpl(lineIndex, g, x, y); } private void drawLineImpl(int lineIndex, Graphics g, float x, float y) { Element line = getElement().getElement(lineIndex); Element elem; try { if (line.isLeaf()) { drawElement(lineIndex, line, g, x, y); } else { // this line contains the composed text. int count = line.getElementCount(); for (int i = 0; i < count; i++) { elem = line.getElement(i); x = drawElement(lineIndex, elem, g, x, y); } } } catch (BadLocationException e) { throw new StateInvariantError("Can't render line: " + lineIndex); } } /** * Renders a line of text, suppressing whitespace at the end * and expanding any tabs. This is implemented to make calls * to the methods {@code drawUnselectedText} and * {@code drawSelectedText} so that the way selected and * unselected text are rendered can be customized. * * @param lineIndex the line to draw {@code >= 0} * @param g the {@code Graphics} context * @param x the starting X position {@code >= 0} * @param y the starting Y position {@code >= 0} * @see #drawUnselectedText * @see #drawSelectedText * * @since 9 */ protected void drawLine(int lineIndex, Graphics2D g, float x, float y) { drawLineImpl(lineIndex, g, x, y); } private float drawElement(int lineIndex, Element elem, Graphics g, float x, float y) throws BadLocationException { int p0 = elem.getStartOffset(); int p1 = elem.getEndOffset(); p1 = Math.min(getDocument().getLength(), p1); if (lineIndex == 0) { x += firstLineOffset; } AttributeSet attr = elem.getAttributes(); if (Utilities.isComposedTextAttributeDefined(attr)) { g.setColor(unselected); x = Utilities.drawComposedText(this, attr, g, x, y, p0 - elem.getStartOffset(), p1 - elem.getStartOffset()); } else { if (sel0 == sel1 || selected == unselected) { // no selection, or it is invisible x = callDrawUnselectedText(g, x, y, p0, p1); } else if ((p0 >= sel0 && p0 <= sel1) && (p1 >= sel0 && p1 <= sel1)) { x = callDrawSelectedText(g, x, y, p0, p1); } else if (sel0 >= p0 && sel0 <= p1) { if (sel1 >= p0 && sel1 <= p1) { x = callDrawUnselectedText(g, x, y, p0, sel0); x = callDrawSelectedText(g, x, y, sel0, sel1); x = callDrawUnselectedText(g, x, y, sel1, p1); } else { x = callDrawUnselectedText(g, x, y, p0, sel0); x = callDrawSelectedText(g, x, y, sel0, p1); } } else if (sel1 >= p0 && sel1 <= p1) { x = callDrawSelectedText(g, x, y, p0, sel1); x = callDrawUnselectedText(g, x, y, sel1, p1); } else { x = callDrawUnselectedText(g, x, y, p0, p1); } } return x; } /** * Renders the given range in the model as normal unselected * text. Uses the foreground or disabled color to render the text. * * @param g the graphics context * @param x the starting X coordinate >= 0 * @param y the starting Y coordinate >= 0 * @param p0 the beginning position in the model >= 0 * @param p1 the ending position in the model >= 0 * @return the X location of the end of the range >= 0 * @exception BadLocationException if the range is invalid * * @deprecated replaced by * {@link #drawUnselectedText(Graphics2D, float, float, int, int)} */ @Deprecated(since = "9") protected int drawUnselectedText(Graphics g, int x, int y, int p0, int p1) throws BadLocationException { return (int) drawUnselectedTextImpl(g, x, y, p0, p1, false); } private float callDrawUnselectedText(Graphics g, float x, float y, int p0, int p1) throws BadLocationException { return drawUnselectedTextOverridden && (g instanceof Graphics2D) ? drawUnselectedText((Graphics2D) g, x, y, p0, p1) : drawUnselectedText(g, (int) x, (int) y, p0, p1); } private float drawUnselectedTextImpl(Graphics g, float x, float y, int p0, int p1, boolean useFPAPI) throws BadLocationException { g.setColor(unselected); Document doc = getDocument(); Segment s = SegmentCache.getSharedSegment(); doc.getText(p0, p1 - p0, s); float ret = Utilities.drawTabbedText(this, s, x, y, g, this, p0, null, useFPAPI); SegmentCache.releaseSharedSegment(s); return ret; } /** * Renders the given range in the model as normal unselected * text. Uses the foreground or disabled color to render the text. * * @param g the graphics context * @param x the starting X coordinate {@code >= 0} * @param y the starting Y coordinate {@code >= 0} * @param p0 the beginning position in the model {@code >= 0} * @param p1 the ending position in the model {@code >= 0} * @return the X location of the end of the range {@code >= 0} * @exception BadLocationException if the range is invalid * * @since 9 */ protected float drawUnselectedText(Graphics2D g, float x, float y, int p0, int p1) throws BadLocationException { return drawUnselectedTextImpl(g, x, y, p0, p1, true); } /** * Renders the given range in the model as selected text. This * is implemented to render the text in the color specified in * the hosting component. It assumes the highlighter will render * the selected background. * * @param g the graphics context * @param x the starting X coordinate >= 0 * @param y the starting Y coordinate >= 0 * @param p0 the beginning position in the model >= 0 * @param p1 the ending position in the model >= 0 * @return the location of the end of the range * @exception BadLocationException if the range is invalid * * @deprecated replaced by * {@link #drawSelectedText(Graphics2D, float, float, int, int)} */ @Deprecated(since = "9") protected int drawSelectedText(Graphics g, int x, int y, int p0, int p1) throws BadLocationException { return (int) drawSelectedTextImpl(g, x, y, p0, p1, false); } float callDrawSelectedText(Graphics g, float x, float y, int p0, int p1) throws BadLocationException { return drawSelectedTextOverridden && g instanceof Graphics2D ? drawSelectedText((Graphics2D) g, x, y, p0, p1) : drawSelectedText(g, (int) x, (int) y, p0, p1); } private float drawSelectedTextImpl(Graphics g, float x, float y, int p0, int p1, boolean useFPAPI) throws BadLocationException { g.setColor(selected); Document doc = getDocument(); Segment s = SegmentCache.getSharedSegment(); doc.getText(p0, p1 - p0, s); float ret = Utilities.drawTabbedText(this, s, x, y, g, this, p0, null, useFPAPI); SegmentCache.releaseSharedSegment(s); return ret; } /** * Renders the given range in the model as selected text. This * is implemented to render the text in the color specified in * the hosting component. It assumes the highlighter will render * the selected background. * * @param g the graphics context * @param x the starting X coordinate {@code >= 0} * @param y the starting Y coordinate {@code >= 0} * @param p0 the beginning position in the model {@code >= 0} * @param p1 the ending position in the model {@code >= 0} * @return the location of the end of the range * @exception BadLocationException if the range is invalid * * @since 9 */ protected float drawSelectedText(Graphics2D g, float x, float y, int p0, int p1) throws BadLocationException { return drawSelectedTextImpl(g, x, y, p0, p1, true); } /** * Gives access to a buffer that can be used to fetch * text from the associated document. * * @return the buffer */ protected final Segment getLineBuffer() { if (lineBuffer == null) { lineBuffer = new Segment(); } return lineBuffer; } /** * Checks to see if the font metrics and longest line * are up-to-date. * * @since 1.4 */ protected void updateMetrics() { Component host = getContainer(); Font f = host.getFont(); FontMetrics fm = (font == null) ? null : host.getFontMetrics(font); if (font != f || !Objects.equals(metrics, fm)) { // The font changed, we need to recalculate the // longest line. calculateLongestLine(); if (useFloatingPointAPI) { FontRenderContext frc = metrics.getFontRenderContext(); float tabWidth = (float) font.getStringBounds("m", frc).getWidth(); tabSize = getTabSize() * tabWidth; } else { tabSize = getTabSize() * metrics.charWidth('m'); } } } // ---- View methods ---------------------------------------------------- /** * Determines the preferred span for this view along an * axis. * * @param axis may be either View.X_AXIS or View.Y_AXIS * @return the span the view would like to be rendered into >= 0. * Typically the view is told to render into the span * that is returned, although there is no guarantee. * The parent may choose to resize or break the view. * @exception IllegalArgumentException for an invalid axis */ public float getPreferredSpan(int axis) { updateMetrics(); switch (axis) { case View.X_AXIS: return getLineWidth(longLine); case View.Y_AXIS: return getElement().getElementCount() * metrics.getHeight(); default: throw new IllegalArgumentException("Invalid axis: " + axis); } } /** * Renders using the given rendering surface and area on that surface. * The view may need to do layout and create child views to enable * itself to render into the given allocation. * * @param g the rendering surface to use * @param a the allocated region to render into * * @see View#paint */ public void paint(Graphics g, Shape a) { Shape originalA = a; a = adjustPaintRegion(a); Rectangle alloc = (Rectangle) a; tabBase = alloc.x; JTextComponent host = (JTextComponent) getContainer(); Highlighter h = host.getHighlighter(); g.setFont(host.getFont()); sel0 = host.getSelectionStart(); sel1 = host.getSelectionEnd(); unselected = (host.isEnabled()) ? host.getForeground() : host.getDisabledTextColor(); Caret c = host.getCaret(); selected = c.isSelectionVisible() && h != null ? host.getSelectedTextColor() : unselected; updateMetrics(); // If the lines are clipped then we don't expend the effort to // try and paint them. Since all of the lines are the same height // with this object, determination of what lines need to be repainted // is quick. Rectangle clip = g.getClipBounds(); int fontHeight = metrics.getHeight(); int heightBelow = (alloc.y + alloc.height) - (clip.y + clip.height); int heightAbove = clip.y - alloc.y; int linesBelow, linesAbove, linesTotal; if (fontHeight > 0) { linesBelow = Math.max(0, heightBelow / fontHeight); linesAbove = Math.max(0, heightAbove / fontHeight); linesTotal = alloc.height / fontHeight; if (alloc.height % fontHeight != 0) { linesTotal++; } } else { linesBelow = linesAbove = linesTotal = 0; } // update the visible lines Rectangle lineArea = lineToRect(a, linesAbove); int y = lineArea.y + metrics.getAscent(); int x = lineArea.x; Element map = getElement(); int lineCount = map.getElementCount(); int endLine = Math.min(lineCount, linesTotal - linesBelow); lineCount--; LayeredHighlighter dh = (h instanceof LayeredHighlighter) ? (LayeredHighlighter) h : null; for (int line = linesAbove; line < endLine; line++) { if (dh != null) { Element lineElement = map.getElement(line); if (line == lineCount) { dh.paintLayeredHighlights(g, lineElement.getStartOffset(), lineElement.getEndOffset(), originalA, host, this); } else { dh.paintLayeredHighlights(g, lineElement.getStartOffset(), lineElement.getEndOffset() - 1, originalA, host, this); } } if (drawLineOverridden && (g instanceof Graphics2D)) { drawLine(line, (Graphics2D) g, (float) x, (float) y); } else { drawLine(line, g, x, y); } y += fontHeight; if (line == 0) { // This should never really happen, in so far as if // firstLineOffset is non 0, there should only be one // line of text. x -= firstLineOffset; } } } /** * Should return a shape ideal for painting based on the passed in * Shape <code>a</code>. This is useful if painting in a different * region. The default implementation returns <code>a</code>. */ Shape adjustPaintRegion(Shape a) { return a; } /** * Provides a mapping from the document model coordinate space * to the coordinate space of the view mapped to it. * * @param pos the position to convert >= 0 * @param a the allocated region to render into * @return the bounding box of the given position * @exception BadLocationException if the given position does not * represent a valid location in the associated document * @see View#modelToView */ @SuppressWarnings("deprecation") public Shape modelToView(int pos, Shape a, Position.Bias b) throws BadLocationException { // line coordinates Document doc = getDocument(); Element map = getElement(); int lineIndex = map.getElementIndex(pos); if (lineIndex < 0) { return lineToRect(a, 0); } Rectangle lineArea = lineToRect(a, lineIndex); // determine span from the start of the line tabBase = lineArea.x; Element line = map.getElement(lineIndex); int p0 = line.getStartOffset(); Segment s = SegmentCache.getSharedSegment(); doc.getText(p0, pos - p0, s); if (useFloatingPointAPI) { float xOffs = Utilities.getTabbedTextWidth(s, metrics, (float) tabBase, this, p0); SegmentCache.releaseSharedSegment(s); return new Rectangle2D.Float(lineArea.x + xOffs, lineArea.y, 1, metrics.getHeight()); } int xOffs = Utilities.getTabbedTextWidth(s, metrics, tabBase, this, p0); SegmentCache.releaseSharedSegment(s); // fill in the results and return lineArea.x += xOffs; lineArea.width = 1; lineArea.height = metrics.getHeight(); return lineArea; } /** * Provides a mapping from the view coordinate space to the logical * coordinate space of the model. * * @param x the X coordinate >= 0 * @param y the Y coordinate >= 0 * @param a the allocated region to render into * @return the location within the model that best represents the * given point in the view >= 0 * @see View#viewToModel */ public int viewToModel(float x, float y, Shape a, Position.Bias[] bias) { // PENDING(prinz) properly calculate bias bias[0] = Position.Bias.Forward; Rectangle alloc = a.getBounds(); Document doc = getDocument(); if (y < alloc.y) { // above the area covered by this icon, so the position // is assumed to be the start of the coverage for this view. return getStartOffset(); } else if (y > alloc.y + alloc.height) { // below the area covered by this icon, so the position // is assumed to be the end of the coverage for this view. return getEndOffset() - 1; } else { // positioned within the coverage of this view vertically, // so we figure out which line the point corresponds to. // if the line is greater than the number of lines contained, then // simply use the last line as it represents the last possible place // we can position to. Element map = doc.getDefaultRootElement(); int fontHeight = metrics.getHeight(); int lineIndex = (fontHeight > 0 ? (int) Math.abs((y - alloc.y) / fontHeight) : map.getElementCount() - 1); if (lineIndex >= map.getElementCount()) { return getEndOffset() - 1; } Element line = map.getElement(lineIndex); int dx = 0; if (lineIndex == 0) { alloc.x += firstLineOffset; alloc.width -= firstLineOffset; } if (x < alloc.x) { // point is to the left of the line return line.getStartOffset(); } else if (x > alloc.x + alloc.width) { // point is to the right of the line return line.getEndOffset() - 1; } else { // Determine the offset into the text try { int p0 = line.getStartOffset(); int p1 = line.getEndOffset() - 1; Segment s = SegmentCache.getSharedSegment(); doc.getText(p0, p1 - p0, s); tabBase = alloc.x; int offs = p0 + Utilities.getTabbedTextOffset(s, metrics, tabBase, x, this, p0, true); SegmentCache.releaseSharedSegment(s); return offs; } catch (BadLocationException e) { // should not happen return -1; } } } } /** * Gives notification that something was inserted into the document * 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#insertUpdate */ public void insertUpdate(DocumentEvent changes, Shape a, ViewFactory f) { updateDamage(changes, a, f); } /** * Gives notification that something was removed from the document * 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#removeUpdate */ public void removeUpdate(DocumentEvent changes, Shape a, ViewFactory f) { updateDamage(changes, a, f); } /** * 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(DocumentEvent changes, Shape a, ViewFactory f) { updateDamage(changes, a, f); } /** * Sets the size of the view. This should cause * layout of the view along the given axis, if it * has any layout duties. * * @param width the width >= 0 * @param height the height >= 0 */ public void setSize(float width, float height) { super.setSize(width, height); updateMetrics(); } // --- TabExpander methods ------------------------------------------ /** * Returns the next tab stop position after a given reference position. * This implementation does not support things like centering so it * ignores the tabOffset argument. * * @param x the current position >= 0 * @param tabOffset the position within the text stream * that the tab occurred at >= 0. * @return the tab stop, measured in points >= 0 */ public float nextTabStop(float x, int tabOffset) { if (tabSize == 0) { return x; } int ntabs = (int) ((x - tabBase) / tabSize); return tabBase + ((ntabs + 1) * tabSize); } // --- local methods ------------------------------------------------ /** * Repaint the region of change covered by the given document * event. Damages the line that begins the range to cover * the case when the insert/remove is only on one line. * If lines are added or removed, damages the whole * view. The longest line is checked to see if it has * changed. * * @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 * @since 1.4 */ protected void updateDamage(DocumentEvent changes, Shape a, ViewFactory f) { Component host = getContainer(); updateMetrics(); Element elem = getElement(); DocumentEvent.ElementChange ec = changes.getChange(elem); Element[] added = (ec != null) ? ec.getChildrenAdded() : null; Element[] removed = (ec != null) ? ec.getChildrenRemoved() : null; if (((added != null) && (added.length > 0)) || ((removed != null) && (removed.length > 0))) { // lines were added or removed... if (added != null) { int currWide = getLineWidth(longLine); for (int i = 0; i < added.length; i++) { int w = getLineWidth(added[i]); if (w > currWide) { currWide = w; longLine = added[i]; } } } if (removed != null) { for (int i = 0; i < removed.length; i++) { if (removed[i] == longLine) { calculateLongestLine(); break; } } } preferenceChanged(null, true, true); host.repaint(); } else { Element map = getElement(); int line = map.getElementIndex(changes.getOffset()); damageLineRange(line, line, a, host); if (changes.getType() == DocumentEvent.EventType.INSERT) { // check to see if the line is longer than current // longest line. int w = getLineWidth(longLine); Element e = map.getElement(line); if (e == longLine) { preferenceChanged(null, true, false); } else if (getLineWidth(e) > w) { longLine = e; preferenceChanged(null, true, false); } } else if (changes.getType() == DocumentEvent.EventType.REMOVE) { if (map.getElement(line) == longLine) { // removed from longest line... recalc calculateLongestLine(); preferenceChanged(null, true, false); } } } } /** * Repaint the given line range. * * @param host the component hosting the view (used to call repaint) * @param a the region allocated for the view to render into * @param line0 the starting line number to repaint. This must * be a valid line number in the model. * @param line1 the ending line number to repaint. This must * be a valid line number in the model. * @since 1.4 */ protected void damageLineRange(int line0, int line1, Shape a, Component host) { if (a != null) { Rectangle area0 = lineToRect(a, line0); Rectangle area1 = lineToRect(a, line1); if ((area0 != null) && (area1 != null)) { Rectangle damage = area0.union(area1); host.repaint(damage.x, damage.y, damage.width, damage.height); } else { host.repaint(); } } } /** * Determine the rectangle that represents the given line. * * @param a the region allocated for the view to render into * @param line the line number to find the region of. This must * be a valid line number in the model. * @return the rectangle that represents the given line * @since 1.4 */ protected Rectangle lineToRect(Shape a, int line) { Rectangle r = null; updateMetrics(); if (metrics != null) { Rectangle alloc = a.getBounds(); if (line == 0) { alloc.x += firstLineOffset; alloc.width -= firstLineOffset; } r = new Rectangle(alloc.x, alloc.y + (line * metrics.getHeight()), alloc.width, metrics.getHeight()); } return r; } /** * Iterate over the lines represented by the child elements * of the element this view represents, looking for the line * that is the longest. The <em>longLine</em> variable is updated to * represent the longest line contained. The <em>font</em> variable * is updated to indicate the font used to calculate the * longest line. */ private void calculateLongestLine() { Component c = getContainer(); font = c.getFont(); metrics = c.getFontMetrics(font); Document doc = getDocument(); Element lines = getElement(); int n = lines.getElementCount(); int maxWidth = -1; for (int i = 0; i < n; i++) { Element line = lines.getElement(i); int w = getLineWidth(line); if (w > maxWidth) { maxWidth = w; longLine = line; } } } /** * Calculate the width of the line represented by * the given element. It is assumed that the font * and font metrics are up-to-date. */ @SuppressWarnings("deprecation") private int getLineWidth(Element line) { if (line == null) { return 0; } int p0 = line.getStartOffset(); int p1 = line.getEndOffset(); int w; Segment s = SegmentCache.getSharedSegment(); try { line.getDocument().getText(p0, p1 - p0, s); w = Utilities.getTabbedTextWidth(s, metrics, tabBase, this, p0); } catch (BadLocationException ble) { w = 0; } SegmentCache.releaseSharedSegment(s); return w; } static boolean getFPMethodOverridden(Class<?> cls, String method, FPMethodArgs methodArgs) { HashMap<FPMethodItem, Boolean> map = null; boolean initialized = methodsOverriddenMapRef != null && (map = methodsOverriddenMapRef.get()) != null; if (!initialized) { map = new HashMap<>(); methodsOverriddenMapRef = new SoftReference<>(map); } FPMethodItem key = new FPMethodItem(cls, method); Boolean isFPMethodOverridden = map.get(key); if (isFPMethodOverridden == null) { isFPMethodOverridden = checkFPMethodOverridden(cls, method, methodArgs); map.put(key, isFPMethodOverridden); } return isFPMethodOverridden; } private static boolean checkFPMethodOverridden(final Class<?> className, final String methodName, final FPMethodArgs methodArgs) { return AccessController.doPrivileged(new PrivilegedAction<Boolean>() { @Override public Boolean run() { return isFPMethodOverridden(methodName, className, methodArgs.getMethodArguments(false), methodArgs.getMethodArguments(true)); } }); } private static boolean isFPMethodOverridden(String method, Class<?> cls, Class<?>[] intTypes, Class<?>[] fpTypes) { Module thisModule = PlainView.class.getModule(); while (!thisModule.equals(cls.getModule())) { try { cls.getDeclaredMethod(method, fpTypes); return true; } catch (Exception e1) { try { cls.getDeclaredMethod(method, intTypes); return false; } catch (Exception e2) { cls = cls.getSuperclass(); } } } return true; } enum FPMethodArgs { IGNN, IIGNN, GNNII, GNNC; public Class<?>[] getMethodArguments(boolean isFPType) { Class<?> N = (isFPType) ? Float.TYPE : Integer.TYPE; Class<?> G = (isFPType) ? Graphics2D.class : Graphics.class; switch (this) { case IGNN: return new Class<?>[] { Integer.TYPE, G, N, N }; case IIGNN: return new Class<?>[] { Integer.TYPE, Integer.TYPE, G, N, N }; case GNNII: return new Class<?>[] { G, N, N, Integer.TYPE, Integer.TYPE }; case GNNC: return new Class<?>[] { G, N, N, Character.TYPE }; default: throw new RuntimeException("Unknown method arguments!"); } } } private static class FPMethodItem { final Class<?> className; final String methodName; public FPMethodItem(Class<?> className, String methodName) { this.className = className; this.methodName = methodName; } @Override public boolean equals(Object obj) { if (obj instanceof FPMethodItem) { FPMethodItem that = (FPMethodItem) obj; return this.className.equals(that.className) && this.methodName.equals(that.methodName); } return false; } @Override public int hashCode() { return 31 * methodName.hashCode() + className.hashCode(); } } // --- member variables ----------------------------------------------- /** * Font metrics for the current font. */ protected FontMetrics metrics; /** * The current longest line. This is used to calculate * the preferred width of the view. Since the calculation * is potentially expensive we try to avoid it by stashing * which line is currently the longest. */ Element longLine; /** * Font used to calculate the longest line... if this * changes we need to recalculate the longest line */ Font font; Segment lineBuffer; float tabSize; int tabBase; int sel0; int sel1; Color unselected; Color selected; /** * Offset of where to draw the first character on the first line. * This is a hack and temporary until we can better address the problem * of text measuring. This field is actually never set directly in * PlainView, but by FieldView. */ int firstLineOffset; private static SoftReference<HashMap<FPMethodItem, Boolean>> methodsOverriddenMapRef; final boolean drawLineOverridden = getFPMethodOverridden(getClass(), "drawLine", FPMethodArgs.IGNN); final boolean drawSelectedTextOverridden = getFPMethodOverridden(getClass(), "drawSelectedText", FPMethodArgs.GNNII); final boolean drawUnselectedTextOverridden = getFPMethodOverridden(getClass(), "drawUnselectedText", FPMethodArgs.GNNII); final boolean useFloatingPointAPI = drawUnselectedTextOverridden || drawSelectedTextOverridden; }