jdk/src/java.desktop/share/classes/sun/font/PhysicalStrike.java

/*
 * Copyright (c) 2003, 2008, 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.font;

import java.awt.Font;
import java.awt.geom.AffineTransform;
import java.awt.geom.GeneralPath;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.util.concurrent.ConcurrentHashMap;


public abstract class PhysicalStrike extends FontStrike {

    static final long INTMASK = 0xffffffffL;
    static boolean longAddresses;
    static {
        switch (StrikeCache.nativeAddressSize) {
        case 8: longAddresses = true; break;
        case 4: longAddresses = false; break;
        default: throw new RuntimeException("Unexpected address size");
        }
    }

    private PhysicalFont physicalFont;
    protected CharToGlyphMapper mapper;
    /* the ScalerContext is a native structure pre-filled with the
     * info needed to setup the scaler for this strike. Its immutable
     * so we set it up when the strike is created and free it when the
     * strike is disposed. There's then no need to pass the info down
     * separately to native on every call to the scaler.
     */
    protected long pScalerContext;

    /* Only one of these two arrays is non-null.
     * use the one that matches size of an address (32 or 64 bits)
     */
    protected long[] longGlyphImages;
    protected int[] intGlyphImages;

    /* Used by the TrueTypeFont subclass, which is the only client
     * of getGlyphPoint(). The field and method are here because
     * there is no TrueTypeFontStrike subclass.
     * This map is a cache of the positions of points on the outline
     * of a TrueType glyph. It is used by the OpenType layout engine
     * to perform mark positioning. Without this cache every position
     * request involves scaling and hinting the glyph outline potentially
     * over and over again.
     */
    ConcurrentHashMap<Integer, Point2D.Float> glyphPointMapCache;

    protected boolean getImageWithAdvance;
    protected static final int complexTX =
        AffineTransform.TYPE_FLIP |
        AffineTransform.TYPE_GENERAL_SCALE |
        AffineTransform.TYPE_GENERAL_ROTATION |
        AffineTransform.TYPE_GENERAL_TRANSFORM |
        AffineTransform.TYPE_QUADRANT_ROTATION;

    PhysicalStrike(PhysicalFont physicalFont, FontStrikeDesc desc) {
        this.physicalFont = physicalFont;
        this.desc = desc;
    }

    protected PhysicalStrike() {
    }
    /* A number of methods are delegated by the strike to the scaler
     * context which is a shared resource on a physical font.
     */

    public int getNumGlyphs() {
        return physicalFont.getNumGlyphs();
    }

    /* These 3 metrics methods below should be implemented to return
     * values in user space.
     */
    StrikeMetrics getFontMetrics() {
        if (strikeMetrics == null) {
            strikeMetrics =
                physicalFont.getFontMetrics(pScalerContext);
        }
        return strikeMetrics;
    }

    float getCodePointAdvance(int cp) {
        return getGlyphAdvance(physicalFont.getMapper().charToGlyph(cp));
    }

   Point2D.Float getCharMetrics(char ch) {
        return getGlyphMetrics(physicalFont.getMapper().charToGlyph(ch));
    }

    int getSlot0GlyphImagePtrs(int[] glyphCodes, long[] images, int  len) {
        return 0;
    }

    /* Used by the OpenType engine for mark positioning.
     */
    Point2D.Float getGlyphPoint(int glyphCode, int ptNumber) {
        Point2D.Float gp = null;
        Integer ptKey = Integer.valueOf(glyphCode<<16|ptNumber);
        if (glyphPointMapCache == null) {
            synchronized (this) {
                if (glyphPointMapCache == null) {
                    glyphPointMapCache =
                        new ConcurrentHashMap<Integer, Point2D.Float>();
                }
            }
        } else {
            gp = glyphPointMapCache.get(ptKey);
        }

        if (gp == null) {
            gp = (physicalFont.getGlyphPoint(pScalerContext, glyphCode, ptNumber));
            adjustPoint(gp);
            glyphPointMapCache.put(ptKey, gp);
        }
        return gp;
    }

    protected void adjustPoint(Point2D.Float pt) {
    }
}