textrenderercache.java

world wind java sdk 源码

/*
Copyright (C) 2001, 2006 United States Government
as represented by the Administrator of the
National Aeronautics and Space Administration.
All Rights Reserved.
*/
package gov.nasa.worldwind.render;

import com.sun.opengl.util.j2d.TextRenderer;
import gov.nasa.worldwind.Disposable;
import gov.nasa.worldwind.util.Logging;

/**
 * http://java.sun.com/products/java-media/2D/reference/faqs/index.html#Q_What_are_fractional_metrics_Wh
 *
 * @author tag
 * @version $Id: TextRendererCache.java 10925 2009-05-06 22:22:50Z dcollins $
 */
public class TextRendererCache implements Disposable
{
    protected boolean defaultAntialias;
    protected boolean defaultUseFractionalMetrics;
    protected boolean defaultUseMipmaps;
    protected boolean defaultUseSmoothing;
    protected boolean defaultUseVertexArrays;
    protected java.util.concurrent.ConcurrentHashMap<Object, TextRenderer> textRendererMap;

    public TextRendererCache()
    {
        this.textRendererMap = new java.util.concurrent.ConcurrentHashMap<Object, TextRenderer>();

        // By default enable antialiasing, mipmapping, and smoothing, but disable fractional metrics and vertex arrays.
        // * For the common case where text is rendered without scaling at integral screen coordinates, smoothing and
        //   mipmapping have no effect on the rendering of text. However smoothing and mipmapping will will blur text
        //   if it's drawn scaled or if the text is drawn at a non-integral screen point, but that's better than the
        //   ugly aliased appearance without smoothing or mipmapping.
        // * Fractional metrics are deigned for high resolution output devices (i.e. printers), enabling this feature
        //   on a standard screen will result in blurred text. See the following link for a description of why:
        //   http://java.sun.com/products/java-media/2D/reference/faqs/index.html#Q_What_are_fractional_metrics_Wh
        // * Vertex arrays are problematic on some graphics cards. Disable this feature by default to maximize
        //   compatibility.

        this.defaultAntialias = true;
        this.defaultUseFractionalMetrics = false;
        this.defaultUseMipmaps = true;
        this.defaultUseSmoothing = true;
        this.defaultUseVertexArrays = false;
    }

    public boolean isDefaultAntialias()
    {
        return this.defaultAntialias;
    }

    public void setDefaultAntialias(boolean antialias)
    {
        this.defaultAntialias = antialias;
    }

    public boolean isDefaultUseFractionalMetrics()
    {
        return this.defaultUseFractionalMetrics;
    }

    public void setDefaultUseFractionalMetrics(boolean useFractionalMetrics)
    {
        this.defaultUseFractionalMetrics = useFractionalMetrics;
    }

    public boolean isDefaultUseMipmaps()
    {
        return this.defaultUseMipmaps;
    }

    public void setDefaultUseMipmaps(boolean useMipmaps)
    {
        this.defaultUseMipmaps = useMipmaps;
    }

    public boolean isDefaultUseSmoothing()
    {
        return this.defaultUseSmoothing;
    }

    public void setDefaultUseSmoothing(boolean useSmoothing)
    {
        this.defaultUseSmoothing = useSmoothing;
    }

    public boolean isDefaultUseVertexArrays()
    {
        return this.defaultUseVertexArrays;
    }

    public void setDefaultUseVertexArrays(boolean useVertexArrays)
    {
        this.defaultUseVertexArrays = useVertexArrays;
    }

    public void dispose()
    {
        this.disposeAll();
        this.textRendererMap.clear();
    }

    public int getNumObjects()
    {
        return this.textRendererMap.size();
    }

    public TextRenderer get(Object key)
    {
        if (key == null)
        {
            String message = Logging.getMessage("nullValue.KeyIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        return this.textRendererMap.get(key);
    }

    public void put(Object key, TextRenderer textRenderer)
    {
        if (key == null)
        {
            String message = Logging.getMessage("nullValue.KeyIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        TextRenderer oldTextRenderer = this.textRendererMap.put(key, textRenderer);

        if (oldTextRenderer != null)
        {
            this.dispose(oldTextRenderer);
        }
    }

    public void remove(Object key)
    {
        if (key == null)
        {
            String message = Logging.getMessage("nullValue.KeyIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        TextRenderer textRenderer = this.textRendererMap.remove(key);

        if (textRenderer != null)
        {
            this.dispose(textRenderer);
        }
    }

    public boolean contains(Object key)
    {
        if (key == null)
        {
            String message = Logging.getMessage("nullValue.KeyIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        return this.textRendererMap.containsKey(key);
    }

    public void clear()
    {
        this.disposeAll();
        this.textRendererMap.clear();
    }

    //**************************************************************//
    //********************  Common Utilities  **********************//
    //**************************************************************//

    public TextRenderer getOrCreate(java.awt.Font font, boolean antialiased, boolean useFractionalMetrics,
        boolean useMipmaps)
    {
        if (font == null)
        {
            String message = Logging.getMessage("nullValue.FontIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        CacheKey key = new CacheKey(font, antialiased, useFractionalMetrics, useMipmaps);

        TextRenderer value = this.get(key);
        if (value == null)
        {
            value = this.createTextRenderer(font, antialiased, useFractionalMetrics, useMipmaps);
            this.put(key, value);
        }

        return value;
    }

    public TextRenderer getOrCreate(java.awt.Font font)
    {
        if (font == null)
        {
            String message = Logging.getMessage("nullValue.FontIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        return this.getOrCreate(font, this.isDefaultAntialias(), this.isDefaultUseFractionalMetrics(),
            this.isDefaultUseMipmaps());
    }

    public TextRenderer createTextRenderer(java.awt.Font font, boolean antialiased, boolean useFractionalMetrics,
        boolean mipmap)
    {
        if (font == null)
        {
            String message = Logging.getMessage("nullValue.FontIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        TextRenderer textRenderer = new TextRenderer(font, antialiased, useFractionalMetrics, null, mipmap);
        this.setupDefaultAttributes(textRenderer);

        return textRenderer;
    }

    public TextRenderer setupDefaultAttributes(TextRenderer textRenderer)
    {
        if (textRenderer == null)
            return null;

        textRenderer.setSmoothing(this.isDefaultUseSmoothing());
        textRenderer.setUseVertexArrays(this.isDefaultUseVertexArrays());

        return textRenderer;
    }

    //**************************************************************//
    //********************  Cache Key  *****************************//
    //**************************************************************//

    public static class CacheKey
    {
        private final java.awt.Font font;
        private final boolean antialiased;
        private final boolean useFractionalMetrics;
        private final boolean useMipmaps;

        public CacheKey(java.awt.Font font, boolean antialiased, boolean useFractionalMetrics, boolean useMipmaps)
        {
            if (font == null)
            {
                String message = Logging.getMessage("nullValue.FontIsNull");
                Logging.logger().severe(message);
                throw new IllegalArgumentException(message);
            }

            this.font = font;
            this.antialiased = antialiased;
            this.useFractionalMetrics = useFractionalMetrics;
            this.useMipmaps = useMipmaps;
        }

        public final java.awt.Font getFont()
        {
            return this.font;
        }

        public final boolean isAntialiased()
        {
            return this.antialiased;
        }

        public final boolean isUseFractionalMetrics()
        {
            return this.useFractionalMetrics;
        }

        public final boolean isUseMipmaps()
        {
            return this.useMipmaps;
        }

        public boolean equals(Object o)
        {
            if (this == o)
                return true;
            if (o == null || this.getClass() != o.getClass())
                return false;

            CacheKey that = (CacheKey) o;

            return (this.antialiased == that.antialiased)
                && (this.useFractionalMetrics == that.useFractionalMetrics)
                && (this.useMipmaps == that.useMipmaps)
                && (this.font.equals(that.font));
        }

        public int hashCode()
        {
            int result = this.font.hashCode();
            result = 31 * result + (this.antialiased ? 1 : 0);
            result = 31 * result + (this.useFractionalMetrics ? 1 : 0);
            result = 31 * result + (this.useMipmaps ? 1 : 0);
            return result;
        }
    }

    //**************************************************************//
    //********************  Protected Methods  *********************//
    //**************************************************************//

    protected void dispose(TextRenderer textRenderer)
    {
        if (textRenderer != null)
        {
            textRenderer.dispose();
        }
    }

    protected void disposeAll()
    {
        for (java.util.Map.Entry<Object, TextRenderer> e : this.textRendererMap.entrySet())
        {
            if (e.getValue() != null)
            {
                this.dispose(e.getValue());
            }
        }
    }
}