1 /*
2 * Copyright (c) 2003, 2006, 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.font;
27
28 import java.io.File;
29 import java.awt.Font;
30 import java.util.Collection;
31 import java.util.HashMap;
32 import java.util.concurrent.ConcurrentHashMap;
33 import java.util.Locale;
34
35 public class FontFamily {
36
37 private static ConcurrentHashMap<String, FontFamily>
38 familyNameMap = new ConcurrentHashMap<String, FontFamily>();
39 private static HashMap<String, FontFamily> allLocaleNames;
40
41 protected String familyName;
42 protected Font2D plain;
43 protected Font2D bold;
44 protected Font2D italic;
45 protected Font2D bolditalic;
46 protected boolean logicalFont = false;
47 protected int familyRank;
48
49 public static FontFamily getFamily(String name) {
50 return familyNameMap.get(name.toLowerCase(Locale.ENGLISH));
51 }
52
53 public static String[] getAllFamilyNames() {
54 return null;
55 }
56
57 /* Only for use by FontManager.deRegisterBadFont(..).
58 * If this was the only font in the family, the family is removed
59 * from the map
60 */
61 static void remove(Font2D font2D) {
62
63 String name = font2D.getFamilyName(Locale.ENGLISH);
64 FontFamily family = getFamily(name);
65 if (family == null) {
66 return;
67 }
68 if (family.plain == font2D) {
69 family.plain = null;
70 }
71 if (family.bold == font2D) {
72 family.bold = null;
73 }
74 if (family.italic == font2D) {
75 family.italic = null;
76 }
77 if (family.bolditalic == font2D) {
78 family.bolditalic = null;
79 }
80 if (family.plain == null && family.bold == null &&
81 family.plain == null && family.bold == null) {
82 familyNameMap.remove(name);
83 }
84 }
85
86 public FontFamily(String name, boolean isLogFont, int rank) {
87 logicalFont = isLogFont;
88 familyName = name;
89 familyRank = rank;
90 familyNameMap.put(name.toLowerCase(Locale.ENGLISH), this);
91 }
92
93 /* Create a family for created fonts which aren't listed in the
94 * main map.
95 */
96 FontFamily(String name) {
97 logicalFont = false;
98 familyName = name;
99 familyRank = Font2D.DEFAULT_RANK;
100 }
101
102 public String getFamilyName() {
103 return familyName;
104 }
105
106 public int getRank() {
107 return familyRank;
108 }
109
110 private boolean isFromSameSource(Font2D font) {
111 if (!(font instanceof FileFont)) {
112 return false;
113 }
114
115 FileFont existingFont = null;
116 if (plain instanceof FileFont) {
117 existingFont = (FileFont)plain;
118 } else if (bold instanceof FileFont) {
119 existingFont = (FileFont)bold;
120 } else if (italic instanceof FileFont) {
121 existingFont = (FileFont)italic;
122 } else if (bolditalic instanceof FileFont) {
123 existingFont = (FileFont)bolditalic;
124 }
125 // A family isn't created until there's a font.
126 // So if we didn't find a file font it means this
127 // isn't a file-based family.
128 if (existingFont == null) {
129 return false;
130 }
131 File existDir = (new File(existingFont.platName)).getParentFile();
132
133 FileFont newFont = (FileFont)font;
134 File newDir = (new File(newFont.platName)).getParentFile();
135 return java.util.Objects.equals(newDir, existDir);
136 }
137
138 /*
139 * We want a family to be of the same width and prefer medium/normal width.
140 * Once we find a particular width we accept more of the same width
141 * until we find one closer to normal when we 'evict' all existing fonts.
142 * So once we see a 'normal' width font we evict all members that are not
143 * normal width and then accept only new ones that are normal width.
144 *
145 * Once a font passes the width test we subject it to the weight test.
146 * For Plain we target the weight the closest that is <= NORMAL (400)
147 * For Bold we target the weight that is closest to BOLD (700).
148 *
149 * In the future, rather than discarding these fonts, we should
150 * extend the family to include these so lookups on these properties
151 * can locate them, as presently they will only be located by full name
152 * based lookup.
153 */
154
155 private int familyWidth = 0;
156 private boolean preferredWidth(Font2D font) {
157
158 int newWidth = font.getWidth();
159
160 if (familyWidth == 0) {
161 familyWidth = newWidth;
162 return true;
163 }
164
165 if (newWidth == familyWidth) {
166 return true;
167 }
168
169 if (Math.abs(Font2D.FWIDTH_NORMAL - newWidth) <
170 Math.abs(Font2D.FWIDTH_NORMAL - familyWidth))
171 {
172 if (FontUtilities.debugFonts()) {
173 FontUtilities.getLogger().info(
174 "Found more preferred width. New width = " + newWidth +
175 " Old width = " + familyWidth + " in font " + font +
176 " nulling out fonts plain: " + plain + " bold: " + bold +
177 " italic: " + italic + " bolditalic: " + bolditalic);
178 }
179 familyWidth = newWidth;
180 plain = bold = italic = bolditalic = null;
181 return true;
182 } else if (FontUtilities.debugFonts()) {
183 FontUtilities.getLogger().info(
184 "Family rejecting font " + font +
185 " of less preferred width " + newWidth);
186 }
187 return false;
188 }
189
190 private boolean closerWeight(Font2D currFont, Font2D font, int style) {
191 if (familyWidth != font.getWidth()) {
192 return false;
193 }
194
195 if (currFont == null) {
196 return true;
197 }
198
199 if (FontUtilities.debugFonts()) {
200 FontUtilities.getLogger().info(
201 "New weight for style " + style + ". Curr.font=" + currFont +
202 " New font="+font+" Curr.weight="+ + currFont.getWeight()+
203 " New weight="+font.getWeight());
204 }
205
206 int newWeight = font.getWeight();
207 switch (style) {
208 case Font.PLAIN:
209 case Font.ITALIC:
210 return (newWeight <= Font2D.FWEIGHT_NORMAL &&
211 newWeight > currFont.getWeight());
212
213 case Font.BOLD:
214 case Font.BOLD|Font.ITALIC:
215 return (Math.abs(newWeight - Font2D.FWEIGHT_BOLD) <
216 Math.abs(currFont.getWeight() - Font2D.FWEIGHT_BOLD));
217
218 default:
219 return false;
220 }
221 }
222
223 public void setFont(Font2D font, int style) {
224
225 if (FontUtilities.isLogging()) {
226 FontUtilities.getLogger().info(
227 "Request to add " + font + " with style " + style +
228 " to family " + this);
229 }
230 /* Allow a lower-rank font only if its a file font
231 * from the exact same source as any previous font.
232 */
233 if ((font.getRank() > familyRank) && !isFromSameSource(font)) {
234 if (FontUtilities.isLogging()) {
235 FontUtilities.getLogger()
236 .warning("Rejecting adding " + font +
237 " of lower rank " + font.getRank() +
238 " to family " + this +
239 " of rank " + familyRank);
240 }
241 return;
242 }
243
244 switch (style) {
245
246 case Font.PLAIN:
247 if (preferredWidth(font) && closerWeight(plain, font, style)) {
248 plain = font;
249 }
250 break;
251
252 case Font.BOLD:
253 if (preferredWidth(font) && closerWeight(bold, font, style)) {
254 bold = font;
255 }
256 break;
257
258 case Font.ITALIC:
259 if (preferredWidth(font) && closerWeight(italic, font, style)) {
260 italic = font;
261 }
262 break;
263
264 case Font.BOLD|Font.ITALIC:
265 if (preferredWidth(font) && closerWeight(bolditalic, font, style)) {
266 bolditalic = font;
267 }
268 break;
269
270 default:
271 break;
272 }
273 }
274
275 public Font2D getFontWithExactStyleMatch(int style) {
276
277 switch (style) {
278
279 case Font.PLAIN:
280 return plain;
281
282 case Font.BOLD:
283 return bold;
284
285 case Font.ITALIC:
286 return italic;
287
288 case Font.BOLD|Font.ITALIC:
289 return bolditalic;
290
291 default:
292 return null;
293 }
294 }
295
296 /* REMIND: if the callers of this method are operating in an
297 * environment in which not all fonts are registered, the returned
298 * font may be a algorithmically styled one, where in fact if loadfonts
299 * were executed, a styled font may be located. Our present "solution"
300 * to this is to register all fonts in a directory and assume that this
301 * registered all the styles of a font, since they would all be in the
302 * same location.
303 */
304 public Font2D getFont(int style) {
305
306 switch (style) {
307
308 case Font.PLAIN:
309 return plain;
310
311 case Font.BOLD:
312 if (bold != null) {
313 return bold;
314 } else if (plain != null && plain.canDoStyle(style)) {
315 return plain;
316 } else {
317 return null;
318 }
319
320 case Font.ITALIC:
321 if (italic != null) {
322 return italic;
323 } else if (plain != null && plain.canDoStyle(style)) {
324 return plain;
325 } else {
326 return null;
327 }
328
329 case Font.BOLD|Font.ITALIC:
330 if (bolditalic != null) {
331 return bolditalic;
332 } else if (italic != null && italic.canDoStyle(style)) {
333 return italic;
334 } else if (bold != null && bold.canDoStyle(style)) {
335 return italic;
336 } else if (plain != null && plain.canDoStyle(style)) {
337 return plain;
338 } else {
339 return null;
340 }
341 default:
342 return null;
343 }
344 }
345
346 /* Only to be called if getFont(style) returns null
347 * This method will only return null if the family is completely empty!
348 * Note that it assumes the font of the style you need isn't in the
349 * family. The logic here is that if we must substitute something
350 * it might as well be from the same family.
351 */
352 Font2D getClosestStyle(int style) {
353
354 switch (style) {
355 /* if you ask for a plain font try to return a non-italic one,
356 * then a italic one, finally a bold italic one */
357 case Font.PLAIN:
358 if (bold != null) {
359 return bold;
360 } else if (italic != null) {
361 return italic;
362 } else {
363 return bolditalic;
364 }
365
366 /* if you ask for a bold font try to return a non-italic one,
367 * then a bold italic one, finally an italic one */
368 case Font.BOLD:
369 if (plain != null) {
370 return plain;
371 } else if (bolditalic != null) {
372 return bolditalic;
373 } else {
374 return italic;
375 }
376
377 /* if you ask for a italic font try to return a bold italic one,
378 * then a plain one, finally an bold one */
379 case Font.ITALIC:
380 if (bolditalic != null) {
381 return bolditalic;
382 } else if (plain != null) {
383 return plain;
384 } else {
385 return bold;
386 }
387
388 case Font.BOLD|Font.ITALIC:
389 if (italic != null) {
390 return italic;
391 } else if (bold != null) {
392 return bold;
393 } else {
394 return plain;
395 }
396 }
397 return null;
398 }
399
400 /* Font may have localized names. Store these in a separate map, so
401 * that only clients who use these names need be affected.
402 */
403 static synchronized void addLocaleNames(FontFamily family, String[] names){
404 if (allLocaleNames == null) {
405 allLocaleNames = new HashMap<String, FontFamily>();
406 }
407 for (int i=0; i<names.length; i++) {
408 allLocaleNames.put(names[i].toLowerCase(), family);
409 }
410 }
411
412 public static synchronized FontFamily getLocaleFamily(String name) {
413 if (allLocaleNames == null) {
414 return null;
415 }
416 return allLocaleNames.get(name.toLowerCase());
417 }
418
419 public static FontFamily[] getAllFontFamilies() {
420 Collection<FontFamily> families = familyNameMap.values();
421 return families.toArray(new FontFamily[0]);
422 }
423
424 public String toString() {
425 return
426 "Font family: " + familyName +
427 " plain="+plain+
428 " bold=" + bold +
429 " italic=" + italic +
430 " bolditalic=" + bolditalic;
431
432 }
433
434 }