Back to index...

	/*
	* Copyright (c) 1997, 2013, 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;

	import java.awt.AWTError;
	import java.awt.Color;
	import java.awt.Font;
	import java.awt.Graphics2D;
	import java.awt.GraphicsConfiguration;
	import java.awt.GraphicsDevice;
	import java.awt.GraphicsEnvironment;
	import java.awt.Insets;
	import java.awt.Rectangle;
	import java.awt.Toolkit;
	import java.awt.font.TextAttribute;
	import java.awt.image.BufferedImage;
	import java.awt.peer.ComponentPeer;
	import java.io.BufferedReader;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FilenameFilter;
	import java.io.InputStreamReader;
	import java.io.IOException;
	import java.text.AttributedCharacterIterator;
	import java.util.ArrayList;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.Locale;
	import java.util.Map;
	import java.util.NoSuchElementException;
	import java.util.Set;
	import java.util.StringTokenizer;
	import java.util.TreeMap;
	import java.util.Vector;
	import java.util.concurrent.ConcurrentHashMap;
	import sun.awt.AppContext;
	import sun.awt.DisplayChangedListener;
	import sun.awt.FontConfiguration;
	import sun.awt.SunDisplayChanger;
	import sun.font.CompositeFontDescriptor;
	import sun.font.Font2D;
	import sun.font.FontManager;
	import sun.font.FontManagerFactory;
	import sun.font.FontManagerForSGE;
	import sun.font.NativeFont;

	/**
	* This is an implementation of a GraphicsEnvironment object for the
	* default local GraphicsEnvironment.
	*
	* @see GraphicsDevice
	* @see GraphicsConfiguration
	*/
	public abstract class SunGraphicsEnvironment extends GraphicsEnvironment
	implements DisplayChangedListener {

	public static boolean isOpenSolaris;
	private static Font defaultFont;

	public SunGraphicsEnvironment() {
	java.security.AccessController.doPrivileged(
	new java.security.PrivilegedAction() {
	public Object run() {
	String version = System.getProperty("os.version", "0.0");
	try {
	float ver = Float.parseFloat(version);
	if (ver > 5.10f) {
	File f = new File("/etc/release");
	FileInputStream fis = new FileInputStream(f);
	InputStreamReader isr
	= new InputStreamReader(fis, "ISO-8859-1");
	BufferedReader br = new BufferedReader(isr);
	String line = br.readLine();
	if (line.indexOf("OpenSolaris") >= 0) {
	isOpenSolaris = true;
	} else {
	/* We are using isOpenSolaris as meaning
	* we know the Solaris commercial fonts aren't
	* present. "Solaris Next" (03/10) did not
	* include these even though its was not
	* OpenSolaris. Need to revisit how this is
	* handled but for now as in 6ux, we'll use
	* the test for a standard font resource as
	* being an indicator as to whether we need
	* to treat this as OpenSolaris from a font
	* config perspective.
	*/
	String courierNew =
	"/usr/openwin/lib/X11/fonts/TrueType/CourierNew.ttf";
	File courierFile = new File(courierNew);
	isOpenSolaris = !courierFile.exists();
	}
	fis.close();
	}
	} catch (Exception e) {
	}

	/* Establish the default font to be used by SG2D etc */
	defaultFont = new Font(Font.DIALOG, Font.PLAIN, 12);

	return null;
	}
	});
	}

	protected GraphicsDevice[] screens;

	/**
	* Returns an array of all of the screen devices.
	*/
	public synchronized GraphicsDevice[] getScreenDevices() {
	GraphicsDevice[] ret = screens;
	if (ret == null) {
	int num = getNumScreens();
	ret = new GraphicsDevice[num];
	for (int i = 0; i < num; i++) {
	ret[i] = makeScreenDevice(i);
	}
	screens = ret;
	}
	return ret;
	}

	/**
	* Returns the number of screen devices of this graphics environment.
	*
	* @return the number of screen devices of this graphics environment
	*/
	protected abstract int getNumScreens();

	/**
	* Create and return the screen device with the specified number. The
	* device with number <code>0</code> will be the default device (returned
	* by {@link #getDefaultScreenDevice()}.
	*
	* @param screennum the number of the screen to create
	*
	* @return the created screen device
	*/
	protected abstract GraphicsDevice makeScreenDevice(int screennum);

	/**
	* Returns the default screen graphics device.
	*/
	public GraphicsDevice getDefaultScreenDevice() {
	GraphicsDevice[] screens = getScreenDevices();
	if (screens.length == 0) {
	throw new AWTError("no screen devices");
	}
	return screens[0];
	}

	/**
	* Returns a Graphics2D object for rendering into the
	* given BufferedImage.
	* @throws NullPointerException if BufferedImage argument is null
	*/
	public Graphics2D createGraphics(BufferedImage img) {
	if (img == null) {
	throw new NullPointerException("BufferedImage cannot be null");
	}
	SurfaceData sd = SurfaceData.getPrimarySurfaceData(img);
	return new SunGraphics2D(sd, Color.white, Color.black, defaultFont);
	}

	public static FontManagerForSGE getFontManagerForSGE() {
	FontManager fm = FontManagerFactory.getInstance();
	return (FontManagerForSGE) fm;
	}

	/* Modifies the behaviour of a subsequent call to preferLocaleFonts()
	* to use Mincho instead of Gothic for dialoginput in JA locales
	* on windows. Not needed on other platforms.
	*
	* DO NOT MOVE OR RENAME OR OTHERWISE ALTER THIS METHOD.
	* ITS USED BY SOME NON-JRE INTERNAL CODE.
	*/
	public static void useAlternateFontforJALocales() {
	getFontManagerForSGE().useAlternateFontforJALocales();
	}

	/**
	* Returns all fonts available in this environment.
	*/
	public Font[] getAllFonts() {
	FontManagerForSGE fm = getFontManagerForSGE();
	Font[] installedFonts = fm.getAllInstalledFonts();
	Font[] created = fm.getCreatedFonts();
	if (created == null \|\| created.length == 0) {
	return installedFonts;
	} else {
	int newlen = installedFonts.length + created.length;
	Font [] fonts = java.util.Arrays.copyOf(installedFonts, newlen);
	System.arraycopy(created, 0, fonts,
	installedFonts.length, created.length);
	return fonts;
	}
	}

	public String[] getAvailableFontFamilyNames(Locale requestedLocale) {
	FontManagerForSGE fm = getFontManagerForSGE();
	String[] installed = fm.getInstalledFontFamilyNames(requestedLocale);
	/* Use a new TreeMap as used in getInstalledFontFamilyNames
	* and insert all the keys in lower case, so that the sort order
	* is the same as the installed families. This preserves historical
	* behaviour and inserts new families in the right place.
	* It would have been marginally more efficient to directly obtain
	* the tree map and just insert new entries, but not so much as
	* to justify the extra internal interface.
	*/
	TreeMap<String, String> map = fm.getCreatedFontFamilyNames();
	if (map == null \|\| map.size() == 0) {
	return installed;
	} else {
	for (int i=0; i<installed.length; i++) {
	map.put(installed[i].toLowerCase(requestedLocale),
	installed[i]);
	}
	String[] retval = new String[map.size()];
	Object [] keyNames = map.keySet().toArray();
	for (int i=0; i < keyNames.length; i++) {
	retval[i] = (String)map.get(keyNames[i]);
	}
	return retval;
	}
	}

	public String[] getAvailableFontFamilyNames() {
	return getAvailableFontFamilyNames(Locale.getDefault());
	}

	/**
	* Return the bounds of a GraphicsDevice, less its screen insets.
	* See also java.awt.GraphicsEnvironment.getUsableBounds();
	*/
	public static Rectangle getUsableBounds(GraphicsDevice gd) {
	GraphicsConfiguration gc = gd.getDefaultConfiguration();
	Insets insets = Toolkit.getDefaultToolkit().getScreenInsets(gc);
	Rectangle usableBounds = gc.getBounds();

	usableBounds.x += insets.left;
	usableBounds.y += insets.top;
	usableBounds.width -= (insets.left + insets.right);
	usableBounds.height -= (insets.top + insets.bottom);

	return usableBounds;
	}

	/**
	* From the DisplayChangedListener interface; called
	* when the display mode has been changed.
	*/
	public void displayChanged() {
	// notify screens in device array to do display update stuff
	for (GraphicsDevice gd : getScreenDevices()) {
	if (gd instanceof DisplayChangedListener) {
	((DisplayChangedListener) gd).displayChanged();
	}
	}

	// notify SunDisplayChanger list (e.g. VolatileSurfaceManagers and
	// SurfaceDataProxies) about the display change event
	displayChanger.notifyListeners();
	}

	/**
	* Part of the DisplayChangedListener interface:
	* propagate this event to listeners
	*/
	public void paletteChanged() {
	displayChanger.notifyPaletteChanged();
	}

	/**
	* Returns true when the display is local, false for remote displays.
	*
	* @return true when the display is local, false for remote displays
	*/
	public abstract boolean isDisplayLocal();

	/*
	* ----DISPLAY CHANGE SUPPORT----
	*/

	protected SunDisplayChanger displayChanger = new SunDisplayChanger();

	/**
	* Add a DisplayChangeListener to be notified when the display settings
	* are changed.
	*/
	public void addDisplayChangedListener(DisplayChangedListener client) {
	displayChanger.add(client);
	}

	/**
	* Remove a DisplayChangeListener from Win32GraphicsEnvironment
	*/
	public void removeDisplayChangedListener(DisplayChangedListener client) {
	displayChanger.remove(client);
	}

	/*
	* ----END DISPLAY CHANGE SUPPORT----
	*/

	/**
	* Returns true if FlipBufferStrategy with COPIED buffer contents
	* is preferred for this peer's GraphicsConfiguration over
	* BlitBufferStrategy, false otherwise.
	*
	* The reason FlipBS could be preferred is that in some configurations
	* an accelerated copy to the screen is supported (like Direct3D 9)
	*
	* @return true if flip strategy should be used, false otherwise
	*/
	public boolean isFlipStrategyPreferred(ComponentPeer peer) {
	return false;
	}
	}

Back to index...