/* * Copyright (c) 2007, 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 sun.java2d.pipe; import java.awt.AlphaComposite;import java.awt.Composite;import sun.font.GlyphList;import sun.java2d.SunGraphics2D;import sun.java2d.SurfaceData;import static sun.java2d.pipe.BufferedOpCodes.*; public abstract class BufferedTextPipe extends GlyphListPipe {     private static final int BYTES_PER_GLYPH_IMAGE = 8;    private static final int BYTES_PER_GLYPH_POSITION = 8;     /**     * The following offsets are used to pack the parameters in     * createPackedParams().  (They are also used at the native level when     * unpacking the params.)     */    private static final int OFFSET_CONTRAST  = 8;    private static final int OFFSET_RGBORDER  = 2;    private static final int OFFSET_SUBPIXPOS = 1;    private static final int OFFSET_POSITIONS = 0;     /**     * Packs the given parameters into a single int value in order to save     * space on the rendering queue.  Note that most of these parameters     * are only used for rendering LCD-optimized text, but conditionalizing     * this work wouldn't make any impact on performance, so we will pack     * those parameters even in the non-LCD case.     */    private static int createPackedParams(SunGraphics2D sg2d, GlyphList gl) {        return            (((gl.usePositions() ? 1 : 0)   << OFFSET_POSITIONS) |             ((gl.isSubPixPos()  ? 1 : 0)   << OFFSET_SUBPIXPOS) |             ((gl.isRGBOrder()   ? 1 : 0)   << OFFSET_RGBORDER ) |             ((sg2d.lcdTextContrast & 0xff) << OFFSET_CONTRAST ));    }     protected final RenderQueue rq;     protected BufferedTextPipe(RenderQueue rq) {        this.rq = rq;    }     @Override    protected void drawGlyphList(SunGraphics2D sg2d, GlyphList gl) {        /*         * The native drawGlyphList() only works with two composite types:         *    - CompositeType.SrcOver (with any extra alpha), or         *    - CompositeType.Xor         */        Composite comp = sg2d.composite;        if (comp == AlphaComposite.Src) {            /*             * In addition to the composite types listed above, the logic             * in OGL/D3DSurfaceData.validatePipe() allows for             * CompositeType.SrcNoEa, but only in the presence of an opaque             * color.  If we reach this case, we know the color is opaque,             * and therefore SrcNoEa is the same as SrcOverNoEa, so we             * override the composite here.             */            comp = AlphaComposite.SrcOver;        }         rq.lock();        try {            validateContext(sg2d, comp);            enqueueGlyphList(sg2d, gl);        } finally {            rq.unlock();        }    }     private void enqueueGlyphList(final SunGraphics2D sg2d,                                  final GlyphList gl)    {        // assert rq.lock.isHeldByCurrentThread();        RenderBuffer buf = rq.getBuffer();        final int totalGlyphs = gl.getNumGlyphs();        int glyphBytesRequired = totalGlyphs * BYTES_PER_GLYPH_IMAGE;        int posBytesRequired =            gl.usePositions() ? totalGlyphs * BYTES_PER_GLYPH_POSITION : 0;        int totalBytesRequired = 24 + glyphBytesRequired + posBytesRequired;         final long[] images = gl.getImages();        final float glyphListOrigX = gl.getX() + 0.5f;        final float glyphListOrigY = gl.getY() + 0.5f;         // make sure the RenderQueue keeps a hard reference to the FontStrike        // so that the associated glyph images are not disposed while enqueued        rq.addReference(gl.getStrike());         if (totalBytesRequired <= buf.capacity()) {            if (totalBytesRequired > buf.remaining()) {                // process the queue first and then enqueue the glyphs                rq.flushNow();            }            rq.ensureAlignment(20);            buf.putInt(DRAW_GLYPH_LIST);            // enqueue parameters            buf.putInt(totalGlyphs);            buf.putInt(createPackedParams(sg2d, gl));            buf.putFloat(glyphListOrigX);            buf.putFloat(glyphListOrigY);            // now enqueue glyph information            buf.put(images, 0, totalGlyphs);            if (gl.usePositions()) {                float[] positions = gl.getPositions();                buf.put(positions, 0, 2*totalGlyphs);            }        } else {            // queue is too small to accomodate glyphs; perform            // the operation directly on the queue flushing thread            rq.flushAndInvokeNow(new Runnable() {                public void run() {                    drawGlyphList(totalGlyphs, gl.usePositions(),                                  gl.isSubPixPos(), gl.isRGBOrder(),                                  sg2d.lcdTextContrast,                                  glyphListOrigX, glyphListOrigY,                                  images, gl.getPositions());                }            });        }    }     /**     * Called as a separate Runnable when the operation is too large to fit     * on the RenderQueue.  The OGL/D3D pipelines each have their own (small)     * native implementation of this method.     */    protected abstract void drawGlyphList(int numGlyphs, boolean usePositions,                                          boolean subPixPos, boolean rgbOrder,                                          int lcdContrast,                                          float glOrigX, float glOrigY,                                          long[] images, float[] positions);     /**     * Validates the state in the provided SunGraphics2D object.     */    protected abstract void validateContext(SunGraphics2D sg2d,                                            Composite comp);}