PangoFonts.java :  » 6.0-JDK-Modules-com.sun.java » swing » com » sun » java » swing » plaf » gtk » Java Open Source

Java Open Source » 6.0 JDK Modules com.sun.java » swing 
swing » com » sun » java » swing » plaf » gtk » PangoFonts.java
/*
 * Copyright 2002-2006 Sun Microsystems, Inc.  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.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 * CA 95054 USA or visit www.sun.com if you need additional information or
 * have any questions.
 */

package com.sun.java.swing.plaf.gtk;

import java.awt.*;
import java.awt.geom.AffineTransform;
import javax.swing.plaf.FontUIResource;
import java.util.StringTokenizer;
import sun.font.FontManager;

/**
 * @author Shannon Hickey
 * @author Leif Samuelsson
 * @version 1.24 05/05/07
 */
class PangoFonts {

    public static final String CHARS_DIGITS = "0123456789";

    /**
     * Calculate a default scale factor for fonts in this L&F to match
     * the reported resolution of the screen.
     * Java 2D specified a default user-space scale of 72dpi.
     * This is unlikely to correspond to that of the real screen.
     * The Xserver reports a value which may be used to adjust for this.
     * and Java 2D exposes it via a normalizing transform.
     * However many Xservers report a hard-coded 90dpi whilst others report a
     * calculated value based on possibly incorrect data.
     * That is something that must be solved at the X11 level
     * Note that in an X11 multi-screen environment, the default screen
     * is the one used by the JRE so it is safe to use it here.
     */
    private static double fontScale;

    static {
        fontScale = 1.0d;
        GraphicsEnvironment ge =
           GraphicsEnvironment.getLocalGraphicsEnvironment();
        
        if (!ge.isHeadless()) {
            GraphicsConfiguration gc =
                ge.getDefaultScreenDevice().getDefaultConfiguration();
            AffineTransform at = gc.getNormalizingTransform();
            fontScale = at.getScaleY();
        }
    }
    

    /**
     * Parses a String containing a pango font description and returns
     * a Font object.
     *
     * @param pangoName a String describing a pango font
     *                  e.g. "Sans Italic 10"
     * @return a Font object as a FontUIResource
     *         or null if no suitable font could be created.
     */    
    static Font lookupFont(String pangoName) {
        String family = "";
        int style = Font.PLAIN;
        int size = 10;

        StringTokenizer tok = new StringTokenizer(pangoName);

        while (tok.hasMoreTokens()) {
            String word = tok.nextToken();

            if (word.equalsIgnoreCase("italic")) {
                style |= Font.ITALIC;
            } else if (word.equalsIgnoreCase("bold")) {
                style |= Font.BOLD;
            } else if (CHARS_DIGITS.indexOf(word.charAt(0)) != -1) {
                try {
                    size = Integer.parseInt(word);
                } catch (NumberFormatException ex) {
                }
            } else {
                if (family.length() > 0) {
                    family += " ";
                }
                
                family += word;
            }
        }

  /*
   * Java 2D font point sizes are in a user-space scale of 72dpi.
   * GTK allows a user to configure a "dpi" property used to scale
   * the fonts used to match a user's preference.
   * To match the font size of GTK apps we need to obtain this DPI and
   * adjust as follows:
   * Some versions of GTK use XSETTINGS if available to dynamically
   * monitor user-initiated changes in the DPI to be used by GTK
   * apps. This value is also made available as the Xft.dpi X resource.
   * This is presumably a function of the font preferences API and/or
   * the manner in which it requests the toolkit to update the default
   * for the desktop. This dual approach is probably necessary since
   * other versions of GTK - or perhaps some apps - determine the size
   * to use only at start-up from that X resource.
   * If that resource is not set then GTK scales for the DPI resolution
   * reported by the Xserver using the formula
   * DisplayHeight(dpy, screen) / DisplayHeightMM(dpy, screen) * 25.4
   * (25.4mm == 1 inch).
   * JDK tracks the Xft.dpi XSETTINGS property directly so it can
   * dynamically change font size by tracking just that value.
   * If that resource is not available use the same fall back formula
   * as GTK (see calculation for fontScale).
         * 
   * GTK's default setting for Xft.dpi is 96 dpi (and it seems -1
   * apparently also can mean that "default"). However this default
   * isn't used if there's no property set. The real default in the
   * absence of a resource is the Xserver reported dpi.
   * Finally this DPI is used to calculate the nearest Java 2D font
   * 72 dpi font size.
   * There are cases in which JDK behaviour may not exactly mimic
   * GTK native app behaviour :
   * 1) When a GTK app is not able to dynamically track the changes
   * (does not use XSETTINGS), JDK will resize but other apps will
   * not. This is OK as JDK is exhibiting preferred behaviour and
   * this is probably how all later GTK apps will behave
         * 2) When a GTK app does not use XSETTINGS and for some reason
   * the XRDB property is not present. JDK will pick up XSETTINGS
   * and the GTK app will use the Xserver default. Since its
   * impossible for JDK to know that some other GTK app is not
   * using XSETTINGS its impossible to account for this and in any
   * case for it to be a problem the values would have to be different.
   * It also seems unlikely to arise except when a user explicitly
   * deletes the X resource database entry.
         * 3) Because of rounding errors sizes may differ very slightly
   * between JDK and GTK. To fix that would at the very least require
         * Swing to specify floating pt font sizes.
   * Eg "10 pts" for GTK at 96 dpi to get the same size at Java 2D's
   * 72 dpi you'd need to specify exactly 13.33.
   * There also some other issues to be aware of for the future:
   * GTK specifies the Xft.dpi value as server-wide which when used
   * on systems with 2 distinct X screens with different physical DPI
   * the font sizes will inevitably appear different. It would have
   * been a more user-friendly design to further adjust that one
   * setting depending on the screen resolution to achieve perceived
   * equivalent sizes. If such a change were ever to be made in GTK
   * we would need to update for that.
   */
  double dsize = size;
        int dpi = 96; 
        Object value =
            Toolkit.getDefaultToolkit().getDesktopProperty("gnome.Xft/DPI");
        if (value instanceof Integer) {
            dpi = ((Integer)value).intValue() / 1024;
      if (dpi == -1) {
        dpi = 96;
      }
      if (dpi < 50) { /* 50 dpi is the minimum value gnome allows */
    dpi = 50;
      }
      /* The Java rasteriser assumes pts are in a user space of
       * 72 dpi, so we need to adjust for that.
       */
      dsize = ((double)(dpi * size)/ 72.0);
        } else {
      /* If there's no property, GTK scales for the resolution
       * reported by the Xserver using the formula listed above.
       * fontScale already accounts for the 72 dpi Java 2D space.
       */
      dsize = size * fontScale;
  }

  /* Round size to nearest integer pt size */
        size = (int)(dsize + 0.5);
  if (size < 1) {
      size = 1;
  }

        String fcFamilyLC = family.toLowerCase();
        if (FontManager.mapFcName(fcFamilyLC) != null) {
            /* family is a Fc/Pango logical font which we need to expand. */
           return FontManager.getFontConfigFUIR(fcFamilyLC, style, size);
        } else {
            /* It's a physical font which we will create with a fallback */
            Font font = new FontUIResource(family, style, size);
            return FontManager.getCompositeFontUIResource(font);
        }
    }

    /**
     * Parses a String containing a pango font description and returns
     * the (unscaled) font size as an integer.
     *
     * @param pangoName a String describing a pango font
     * @return the size of the font described by pangoName (e.g. if
     *         pangoName is "Sans Italic 10", then this method returns 10)
     */
    static int getFontSize(String pangoName) {
        int size = 10;

        StringTokenizer tok = new StringTokenizer(pangoName);
        while (tok.hasMoreTokens()) {
            String word = tok.nextToken();

            if (CHARS_DIGITS.indexOf(word.charAt(0)) != -1) {
                try {
                    size = Integer.parseInt(word);
                } catch (NumberFormatException ex) {
                }
            }
        }        

        return size;
    }
}

java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.