1 /*
2 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package sun.java2d;
27
28 import java.awt.AWTError;
29 import java.awt.Color;
30 import java.awt.Font;
31 import java.awt.Graphics2D;
32 import java.awt.GraphicsConfiguration;
33 import java.awt.GraphicsDevice;
34 import java.awt.GraphicsEnvironment;
35 import java.awt.Insets;
36 import java.awt.Rectangle;
37 import java.awt.Toolkit;
38 import java.awt.font.TextAttribute;
39 import java.awt.image.BufferedImage;
40 import java.awt.peer.ComponentPeer;
41 import java.io.BufferedReader;
42 import java.io.File;
43 import java.io.FileInputStream;
44 import java.io.FilenameFilter;
45 import java.io.InputStreamReader;
46 import java.io.IOException;
47 import java.text.AttributedCharacterIterator;
48 import java.util.ArrayList;
49 import java.util.HashSet;
50 import java.util.Iterator;
51 import java.util.Locale;
52 import java.util.Map;
53 import java.util.NoSuchElementException;
54 import java.util.Set;
55 import java.util.StringTokenizer;
56 import java.util.TreeMap;
57 import java.util.Vector;
58 import java.util.concurrent.ConcurrentHashMap;
59 import sun.awt.AppContext;
60 import sun.awt.DisplayChangedListener;
61 import sun.awt.FontConfiguration;
62 import sun.awt.SunDisplayChanger;
63 import sun.font.CompositeFontDescriptor;
64 import sun.font.Font2D;
65 import sun.font.FontManager;
66 import sun.font.FontManagerFactory;
67 import sun.font.FontManagerForSGE;
68 import sun.font.NativeFont;
69
70 /**
71 * This is an implementation of a GraphicsEnvironment object for the
72 * default local GraphicsEnvironment.
73 *
74 * @see GraphicsDevice
75 * @see GraphicsConfiguration
76 */
77 public abstract class SunGraphicsEnvironment extends GraphicsEnvironment
78 implements DisplayChangedListener {
79
80 public static boolean isOpenSolaris;
81 private static Font defaultFont;
82
83 public SunGraphicsEnvironment() {
84 java.security.AccessController.doPrivileged(
85 new java.security.PrivilegedAction<Object>() {
86 public Object run() {
87 String osName = System.getProperty("os.name");
88 if ("SunOS".equals(osName)) {
89 String version = System.getProperty("os.version", "0.0");
90 try {
91 float ver = Float.parseFloat(version);
92 if (ver > 5.10f) {
93 File f = new File("/etc/release");
94 FileInputStream fis = new FileInputStream(f);
95 InputStreamReader isr
96 = new InputStreamReader(fis, "ISO-8859-1");
97 BufferedReader br = new BufferedReader(isr);
98 String line = br.readLine();
99 if (line.indexOf("OpenSolaris") >= 0) {
100 isOpenSolaris = true;
101 } else {
102 /* We are using isOpenSolaris as meaning
103 * we know the Solaris commercial fonts aren't
104 * present. "Solaris Next" (03/10) did not
105 * include these even though its was not
106 * OpenSolaris. Need to revisit how this is
107 * handled but for now as in 6ux, we'll use
108 * the test for a standard font resource as
109 * being an indicator as to whether we need
110 * to treat this as OpenSolaris from a font
111 * config perspective.
112 */
113 String courierNew =
114 "/usr/openwin/lib/X11/fonts/TrueType/CourierNew.ttf";
115 File courierFile = new File(courierNew);
116 isOpenSolaris = !courierFile.exists();
117 }
118 fis.close();
119 }
120 } catch (Exception e) {
121 }
122 }
123 /* Establish the default font to be used by SG2D etc */
124 defaultFont = new Font(Font.DIALOG, Font.PLAIN, 12);
125
126 return null;
127 }
128 });
129 }
130
131 protected GraphicsDevice[] screens;
132
133 /**
134 * Returns an array of all of the screen devices.
135 */
136 public synchronized GraphicsDevice[] getScreenDevices() {
137 GraphicsDevice[] ret = screens;
138 if (ret == null) {
139 int num = getNumScreens();
140 ret = new GraphicsDevice[num];
141 for (int i = 0; i < num; i++) {
142 ret[i] = makeScreenDevice(i);
143 }
144 screens = ret;
145 }
146 return ret;
147 }
148
149 /**
150 * Returns the number of screen devices of this graphics environment.
151 *
152 * @return the number of screen devices of this graphics environment
153 */
154 protected abstract int getNumScreens();
155
156 /**
157 * Create and return the screen device with the specified number. The
158 * device with number <code>0</code> will be the default device (returned
159 * by {@link #getDefaultScreenDevice()}.
160 *
161 * @param screennum the number of the screen to create
162 *
163 * @return the created screen device
164 */
165 protected abstract GraphicsDevice makeScreenDevice(int screennum);
166
167 /**
168 * Returns the default screen graphics device.
169 */
170 public GraphicsDevice getDefaultScreenDevice() {
171 GraphicsDevice[] screens = getScreenDevices();
172 if (screens.length == 0) {
173 throw new AWTError("no screen devices");
174 }
175 return screens[0];
176 }
177
178 /**
179 * Returns a Graphics2D object for rendering into the
180 * given BufferedImage.
181 * @throws NullPointerException if BufferedImage argument is null
182 */
183 public Graphics2D createGraphics(BufferedImage img) {
184 if (img == null) {
185 throw new NullPointerException("BufferedImage cannot be null");
186 }
187 SurfaceData sd = SurfaceData.getPrimarySurfaceData(img);
188 return new SunGraphics2D(sd, Color.white, Color.black, defaultFont);
189 }
190
191 public static FontManagerForSGE getFontManagerForSGE() {
192 FontManager fm = FontManagerFactory.getInstance();
193 return (FontManagerForSGE) fm;
194 }
195
196 /* Modifies the behaviour of a subsequent call to preferLocaleFonts()
197 * to use Mincho instead of Gothic for dialoginput in JA locales
198 * on windows. Not needed on other platforms.
199 *
200 * DO NOT MOVE OR RENAME OR OTHERWISE ALTER THIS METHOD.
201 * ITS USED BY SOME NON-JRE INTERNAL CODE.
202 */
203 public static void useAlternateFontforJALocales() {
204 getFontManagerForSGE().useAlternateFontforJALocales();
205 }
206
207 /**
208 * Returns all fonts available in this environment.
209 */
210 public Font[] getAllFonts() {
211 FontManagerForSGE fm = getFontManagerForSGE();
212 Font[] installedFonts = fm.getAllInstalledFonts();
213 Font[] created = fm.getCreatedFonts();
214 if (created == null || created.length == 0) {
215 return installedFonts;
216 } else {
217 int newlen = installedFonts.length + created.length;
218 Font [] fonts = java.util.Arrays.copyOf(installedFonts, newlen);
219 System.arraycopy(created, 0, fonts,
220 installedFonts.length, created.length);
221 return fonts;
222 }
223 }
224
225 public String[] getAvailableFontFamilyNames(Locale requestedLocale) {
226 FontManagerForSGE fm = getFontManagerForSGE();
227 String[] installed = fm.getInstalledFontFamilyNames(requestedLocale);
228 /* Use a new TreeMap as used in getInstalledFontFamilyNames
229 * and insert all the keys in lower case, so that the sort order
230 * is the same as the installed families. This preserves historical
231 * behaviour and inserts new families in the right place.
232 * It would have been marginally more efficient to directly obtain
233 * the tree map and just insert new entries, but not so much as
234 * to justify the extra internal interface.
235 */
236 TreeMap<String, String> map = fm.getCreatedFontFamilyNames();
237 if (map == null || map.size() == 0) {
238 return installed;
239 } else {
240 for (int i=0; i<installed.length; i++) {
241 map.put(installed[i].toLowerCase(requestedLocale),
242 installed[i]);
243 }
244 String[] retval = new String[map.size()];
245 Object [] keyNames = map.keySet().toArray();
246 for (int i=0; i < keyNames.length; i++) {
247 retval[i] = map.get(keyNames[i]);
248 }
249 return retval;
250 }
251 }
252
253 public String[] getAvailableFontFamilyNames() {
254 return getAvailableFontFamilyNames(Locale.getDefault());
255 }
256
257 /**
258 * Return the bounds of a GraphicsDevice, less its screen insets.
259 * See also java.awt.GraphicsEnvironment.getUsableBounds();
260 */
261 public static Rectangle getUsableBounds(GraphicsDevice gd) {
262 GraphicsConfiguration gc = gd.getDefaultConfiguration();
263 Insets insets = Toolkit.getDefaultToolkit().getScreenInsets(gc);
264 Rectangle usableBounds = gc.getBounds();
265
266 usableBounds.x += insets.left;
267 usableBounds.y += insets.top;
268 usableBounds.width -= (insets.left + insets.right);
269 usableBounds.height -= (insets.top + insets.bottom);
270
271 return usableBounds;
272 }
273
274 /**
275 * From the DisplayChangedListener interface; called
276 * when the display mode has been changed.
277 */
278 public void displayChanged() {
279 // notify screens in device array to do display update stuff
280 for (GraphicsDevice gd : getScreenDevices()) {
281 if (gd instanceof DisplayChangedListener) {
282 ((DisplayChangedListener) gd).displayChanged();
283 }
284 }
285
286 // notify SunDisplayChanger list (e.g. VolatileSurfaceManagers and
287 // SurfaceDataProxies) about the display change event
288 displayChanger.notifyListeners();
289 }
290
291 /**
292 * Part of the DisplayChangedListener interface:
293 * propagate this event to listeners
294 */
295 public void paletteChanged() {
296 displayChanger.notifyPaletteChanged();
297 }
298
299 /**
300 * Returns true when the display is local, false for remote displays.
301 *
302 * @return true when the display is local, false for remote displays
303 */
304 public abstract boolean isDisplayLocal();
305
306 /*
307 * ----DISPLAY CHANGE SUPPORT----
308 */
309
310 protected SunDisplayChanger displayChanger = new SunDisplayChanger();
311
312 /**
313 * Add a DisplayChangeListener to be notified when the display settings
314 * are changed.
315 */
316 public void addDisplayChangedListener(DisplayChangedListener client) {
317 displayChanger.add(client);
318 }
319
320 /**
321 * Remove a DisplayChangeListener from Win32GraphicsEnvironment
322 */
323 public void removeDisplayChangedListener(DisplayChangedListener client) {
324 displayChanger.remove(client);
325 }
326
327 /*
328 * ----END DISPLAY CHANGE SUPPORT----
329 */
330
331 /**
332 * Returns true if FlipBufferStrategy with COPIED buffer contents
333 * is preferred for this peer's GraphicsConfiguration over
334 * BlitBufferStrategy, false otherwise.
335 *
336 * The reason FlipBS could be preferred is that in some configurations
337 * an accelerated copy to the screen is supported (like Direct3D 9)
338 *
339 * @return true if flip strategy should be used, false otherwise
340 */
341 public boolean isFlipStrategyPreferred(ComponentPeer peer) {
342 return false;
343 }
344 }