feat(jdk8): move files to new folder to avoid resources compiled.

jdkSrc/jdk8/javax/swing/text/GlyphPainter1.java

@@ -0,0 +1,250 @@
+/*
+ * Copyright (c) 1999, 2006, 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.*;
+
+/**
+ * A class to perform rendering of the glyphs.
+ * This can be implemented to be stateless, or
+ * to hold some information as a cache to
+ * facilitate faster rendering and model/view
+ * translation.  At a minimum, the GlyphPainter
+ * allows a View implementation to perform its
+ * duties independent of a particular version
+ * of JVM and selection of capabilities (i.e.
+ * shaping for i18n, etc).
+ * <p>
+ * This implementation is intended for operation
+ * under the JDK1.1 API of the Java Platform.
+ * Since the JDK is backward compatible with
+ * JDK1.1 API, this class will also function on
+ * Java 2.  The JDK introduces improved
+ * API for rendering text however, so the GlyphPainter2
+ * is recommended for the DK.
+ *
+ * @author  Timothy Prinzing
+ * @see GlyphView
+ */
+class GlyphPainter1 extends GlyphView.GlyphPainter {
+
+    /**
+     * Determine the span the glyphs given a start location
+     * (for tab expansion).
+     */
+    public float getSpan(GlyphView v, int p0, int p1,
+                         TabExpander e, float x) {
+        sync(v);
+        Segment text = v.getText(p0, p1);
+        int[] justificationData = getJustificationData(v);
+        int width = Utilities.getTabbedTextWidth(v, text, metrics, (int) x, e, p0,
+                                                 justificationData);
+        SegmentCache.releaseSharedSegment(text);
+        return width;
+    }
+
+    public float getHeight(GlyphView v) {
+        sync(v);
+        return metrics.getHeight();
+    }
+
+    /**
+     * Fetches the ascent above the baseline for the glyphs
+     * corresponding to the given range in the model.
+     */
+    public float getAscent(GlyphView v) {
+        sync(v);
+        return metrics.getAscent();
+    }
+
+    /**
+     * Fetches the descent below the baseline for the glyphs
+     * corresponding to the given range in the model.
+     */
+    public float getDescent(GlyphView v) {
+        sync(v);
+        return metrics.getDescent();
+    }
+
+    /**
+     * Paints the glyphs representing the given range.
+     */
+    public void paint(GlyphView v, Graphics g, Shape a, int p0, int p1) {
+        sync(v);
+        Segment text;
+        TabExpander expander = v.getTabExpander();
+        Rectangle alloc = (a instanceof Rectangle) ? (Rectangle)a : a.getBounds();
+
+        // determine the x coordinate to render the glyphs
+        int x = alloc.x;
+        int p = v.getStartOffset();
+        int[] justificationData = getJustificationData(v);
+        if (p != p0) {
+            text = v.getText(p, p0);
+            int width = Utilities.getTabbedTextWidth(v, text, metrics, x, expander, p,
+                                                     justificationData);
+            x += width;
+            SegmentCache.releaseSharedSegment(text);
+        }
+
+        // determine the y coordinate to render the glyphs
+        int y = alloc.y + metrics.getHeight() - metrics.getDescent();
+
+        // render the glyphs
+        text = v.getText(p0, p1);
+        g.setFont(metrics.getFont());
+
+        Utilities.drawTabbedText(v, text, x, y, g, expander,p0,
+                                 justificationData);
+        SegmentCache.releaseSharedSegment(text);
+    }
+
+    public Shape modelToView(GlyphView v, int pos, Position.Bias bias,
+                             Shape a) throws BadLocationException {
+
+        sync(v);
+        Rectangle alloc = (a instanceof Rectangle) ? (Rectangle)a : a.getBounds();
+        int p0 = v.getStartOffset();
+        int p1 = v.getEndOffset();
+        TabExpander expander = v.getTabExpander();
+        Segment text;
+
+        if(pos == p1) {
+            // The caller of this is left to right and borders a right to
+            // left view, return our end location.
+            return new Rectangle(alloc.x + alloc.width, alloc.y, 0,
+                                 metrics.getHeight());
+        }
+        if ((pos >= p0) && (pos <= p1)) {
+            // determine range to the left of the position
+            text = v.getText(p0, pos);
+            int[] justificationData = getJustificationData(v);
+            int width = Utilities.getTabbedTextWidth(v, text, metrics, alloc.x, expander, p0,
+                                                     justificationData);
+            SegmentCache.releaseSharedSegment(text);
+            return new Rectangle(alloc.x + width, alloc.y, 0, metrics.getHeight());
+        }
+        throw new BadLocationException("modelToView - can't convert", p1);
+    }
+
+    /**
+     * Provides a mapping from the view coordinate space to the logical
+     * coordinate space of the model.
+     *
+     * @param v the view containing the view coordinates
+     * @param x the X coordinate
+     * @param y the Y coordinate
+     * @param a the allocated region to render into
+     * @param biasReturn always returns <code>Position.Bias.Forward</code>
+     *   as the zero-th element of this array
+     * @return the location within the model that best represents the
+     *  given point in the view
+     * @see View#viewToModel
+     */
+    public int viewToModel(GlyphView v, float x, float y, Shape a,
+                           Position.Bias[] biasReturn) {
+
+        sync(v);
+        Rectangle alloc = (a instanceof Rectangle) ? (Rectangle)a : a.getBounds();
+        int p0 = v.getStartOffset();
+        int p1 = v.getEndOffset();
+        TabExpander expander = v.getTabExpander();
+        Segment text = v.getText(p0, p1);
+        int[] justificationData = getJustificationData(v);
+        int offs = Utilities.getTabbedTextOffset(v, text, metrics,
+                                                 alloc.x, (int) x, expander, p0,
+                                                 justificationData);
+        SegmentCache.releaseSharedSegment(text);
+        int retValue = p0 + offs;
+        if(retValue == p1) {
+            // No need to return backward bias as GlyphPainter1 is used for
+            // ltr text only.
+            retValue--;
+        }
+        biasReturn[0] = Position.Bias.Forward;
+        return retValue;
+    }
+
+    /**
+     * Determines the best location (in the model) to break
+     * the given view.
+     * This method attempts to break on a whitespace
+     * location.  If a whitespace location can't be found, the
+     * nearest character location is returned.
+     *
+     * @param v the view
+     * @param p0 the location in the model where the
+     *  fragment should start its representation >= 0
+     * @param pos the graphic location along the axis that the
+     *  broken view would occupy >= 0; this may be useful for
+     *  things like tab calculations
+     * @param len specifies the distance into the view
+     *  where a potential break is desired >= 0
+     * @return the model location desired for a break
+     * @see View#breakView
+     */
+    public int getBoundedPosition(GlyphView v, int p0, float x, float len) {
+        sync(v);
+        TabExpander expander = v.getTabExpander();
+        Segment s = v.getText(p0, v.getEndOffset());
+        int[] justificationData = getJustificationData(v);
+        int index = Utilities.getTabbedTextOffset(v, s, metrics, (int)x, (int)(x+len),
+                                                  expander, p0, false,
+                                                  justificationData);
+        SegmentCache.releaseSharedSegment(s);
+        int p1 = p0 + index;
+        return p1;
+    }
+
+    void sync(GlyphView v) {
+        Font f = v.getFont();
+        if ((metrics == null) || (! f.equals(metrics.getFont()))) {
+            // fetch a new FontMetrics
+            Container c = v.getContainer();
+            metrics = (c != null) ? c.getFontMetrics(f) :
+                Toolkit.getDefaultToolkit().getFontMetrics(f);
+        }
+    }
+
+
+
+    /**
+     * @return justificationData from the ParagraphRow this GlyphView
+     * is in or {@code null} if no justification is needed
+     */
+    private int[] getJustificationData(GlyphView v) {
+        View parent = v.getParent();
+        int [] ret = null;
+        if (parent instanceof ParagraphView.Row) {
+            ParagraphView.Row row = ((ParagraphView.Row) parent);
+            ret = row.justificationData;
+        }
+        return ret;
+    }
+
+    // --- variables ---------------------------------------------
+
+    FontMetrics metrics;
+}