Android example source code file (Typeface.java)

This example Android source code file (Typeface.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Android by Example" ^TM.

Java - Android tags/keywords

android, arraylist, awt, bold, bold_italic, content, default_bold, default_family, font, fontloader, italic, monospace, normal, sans_serif, string, typeface, util

The Typeface.java Android example source code

/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.graphics;

import com.android.layoutlib.bridge.FontLoader;

import android.content.res.AssetManager;

import java.awt.Font;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * Re-implementation of Typeface over java.awt
 */
public class Typeface {
    private static final String DEFAULT_FAMILY = "sans-serif";
    private static final int[] styleBuffer = new int[1];

    /** The default NORMAL typeface object */
    public static Typeface DEFAULT;
    /**
     * The default BOLD typeface object. Note: this may be not actually be
     * bold, depending on what fonts are installed. Call getStyle() to know
     * for sure.
     */
    public static Typeface DEFAULT_BOLD;
    /** The NORMAL style of the default sans serif typeface. */
    public static Typeface SANS_SERIF;
    /** The NORMAL style of the default serif typeface. */
    public static Typeface SERIF;
    /** The NORMAL style of the default monospace typeface. */
    public static Typeface MONOSPACE;

    private static Typeface[] sDefaults;
    private static FontLoader mFontLoader;

    private final int mStyle;
    private final List<Font> mFonts;
    private final String mFamily;

    // Style
    public static final int NORMAL = _Original_Typeface.NORMAL;
    public static final int BOLD = _Original_Typeface.BOLD;
    public static final int ITALIC = _Original_Typeface.ITALIC;
    public static final int BOLD_ITALIC = _Original_Typeface.BOLD_ITALIC;

    /**
     * Returns the underlying {@link Font} objects. The first item in the list is the real
     * font. Any other items are fallback fonts for characters not found in the first one.
     */
    public List<Font> getFonts() {
        return mFonts;
    }

    /** Returns the typeface's intrinsic style attributes */
    public int getStyle() {
        return mStyle;
    }

    /** Returns true if getStyle() has the BOLD bit set. */
    public final boolean isBold() {
        return (getStyle() & BOLD) != 0;
    }

    /** Returns true if getStyle() has the ITALIC bit set. */
    public final boolean isItalic() {
        return (getStyle() & ITALIC) != 0;
    }

    /**
     * Create a typeface object given a family name, and option style information.
     * If null is passed for the name, then the "default" font will be chosen.
     * The resulting typeface object can be queried (getStyle()) to discover what
     * its "real" style characteristics are.
     *
     * @param familyName May be null. The name of the font family.
     * @param style  The style (normal, bold, italic) of the typeface.
     *               e.g. NORMAL, BOLD, ITALIC, BOLD_ITALIC
     * @return The best matching typeface.
     */
    public static Typeface create(String familyName, int style) {
        styleBuffer[0] = style;
        Font font = mFontLoader.getFont(familyName, styleBuffer);
        if (font != null) {
            ArrayList<Font> list = new ArrayList();
            list.add(font);
            list.addAll(mFontLoader.getFallBackFonts());
            return new Typeface(familyName, styleBuffer[0], list);
        }

        return null;
    }

    /**
     * Create a typeface object that best matches the specified existing
     * typeface and the specified Style. Use this call if you want to pick a new
     * style from the same family of an existing typeface object. If family is
     * null, this selects from the default font's family.
     *
     * @param family May be null. The name of the existing type face.
     * @param style  The style (normal, bold, italic) of the typeface.
     *               e.g. NORMAL, BOLD, ITALIC, BOLD_ITALIC
     * @return The best matching typeface.
     */
    public static Typeface create(Typeface family, int style) {
        styleBuffer[0] = style;
        Font font = mFontLoader.getFont(family.mFamily, styleBuffer);
        if (font != null) {
            ArrayList<Font> list = new ArrayList();
            list.add(font);
            list.addAll(mFontLoader.getFallBackFonts());
            return new Typeface(family.mFamily, styleBuffer[0], list);
        }

        return null;
    }

    /**
     * Returns one of the default typeface objects, based on the specified style
     *
     * @return the default typeface that corresponds to the style
     */
    public static Typeface defaultFromStyle(int style) {
        return sDefaults[style];
    }

    /**
     * Create a new typeface from the specified font data.
     * @param mgr The application's asset manager
     * @param path  The file name of the font data in the assets directory
     * @return The new typeface.
     */
    public static Typeface createFromAsset(AssetManager mgr, String path) {
        return null;
        //return new Typeface(nativeCreateFromAsset(mgr, path));
    }

    // don't allow clients to call this directly
    private Typeface(String family, int style, List<Font> fonts) {
        mFamily = family;
        mFonts = Collections.unmodifiableList(fonts);
        mStyle = style;
    }

    public static void init(FontLoader fontLoader) {
        mFontLoader = fontLoader;

        DEFAULT = create(DEFAULT_FAMILY, NORMAL);
        DEFAULT_BOLD = create(DEFAULT_FAMILY, BOLD);
        SANS_SERIF = create("sans-serif", NORMAL);
        SERIF = create("serif", NORMAL);
        MONOSPACE = create("monospace", NORMAL);
        sDefaults = new Typeface[] {
                DEFAULT,
                DEFAULT_BOLD,
                create(DEFAULT_FAMILY, ITALIC),
                create(DEFAULT_FAMILY, BOLD_ITALIC),
        };

        /*
        DEFAULT         = create((String)null, 0);
        DEFAULT_BOLD    = create((String)null, Typeface.BOLD);
        SANS_SERIF      = create("sans-serif", 0);
        SERIF           = create("serif", 0);
        MONOSPACE       = create("monospace", 0);

        sDefaults = new Typeface[] {
            DEFAULT,
            DEFAULT_BOLD,
            create((String)null, Typeface.ITALIC),
            create((String)null, Typeface.BOLD_ITALIC),
        };*/
    }
}