1 /* 2 * Copyright (c) 1998, 2019, 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 #if defined(__linux__) 27 #include <string.h> 28 #endif /* __linux__ */ 29 #include <stdio.h> 30 #include <stdlib.h> 31 #include <strings.h> 32 #include <sys/types.h> 33 #include <sys/stat.h> 34 #include <sys/mman.h> 35 #include <fcntl.h> 36 #include <unistd.h> 37 #ifdef __solaris__ 38 #include <sys/systeminfo.h> 39 #endif 40 41 #include <jni.h> 42 #include <jni_util.h> 43 #include <jvm_md.h> 44 #include <sizecalc.h> 45 #ifndef HEADLESS 46 #include <X11/Xlib.h> 47 #include <awt.h> 48 #else 49 /* locks ought to be included from awt.h */ 50 #define AWT_LOCK() 51 #define AWT_UNLOCK() 52 #endif /* !HEADLESS */ 53 54 #if defined(__linux__) && !defined(MAP_FAILED) 55 #define MAP_FAILED ((caddr_t)-1) 56 #endif 57 58 #ifndef HEADLESS 59 extern Display *awt_display; 60 #endif /* !HEADLESS */ 61 62 #define FONTCONFIG_DLL_VERSIONED VERSIONED_JNI_LIB_NAME("fontconfig", "1") 63 #define FONTCONFIG_DLL JNI_LIB_NAME("fontconfig") 64 65 #define MAXFDIRS 512 /* Max number of directories that contain fonts */ 66 67 #if defined(__solaris__) 68 /* 69 * This can be set in the makefile to "/usr/X11" if so desired. 70 */ 71 #ifndef OPENWINHOMELIB 72 #define OPENWINHOMELIB "/usr/openwin/lib/" 73 #endif 74 75 /* This is all known Solaris X11 directories on Solaris 8, 9 and 10. 76 * It is ordered to give precedence to TrueType directories. 77 * It is needed if fontconfig is not installed or configured properly. 78 */ 79 static char *fullSolarisFontPath[] = { 80 OPENWINHOMELIB "X11/fonts/TrueType", 81 OPENWINHOMELIB "locale/euro_fonts/X11/fonts/TrueType", 82 OPENWINHOMELIB "locale/iso_8859_2/X11/fonts/TrueType", 83 OPENWINHOMELIB "locale/iso_8859_5/X11/fonts/TrueType", 84 OPENWINHOMELIB "locale/iso_8859_7/X11/fonts/TrueType", 85 OPENWINHOMELIB "locale/iso_8859_8/X11/fonts/TrueType", 86 OPENWINHOMELIB "locale/iso_8859_9/X11/fonts/TrueType", 87 OPENWINHOMELIB "locale/iso_8859_13/X11/fonts/TrueType", 88 OPENWINHOMELIB "locale/iso_8859_15/X11/fonts/TrueType", 89 OPENWINHOMELIB "locale/ar/X11/fonts/TrueType", 90 OPENWINHOMELIB "locale/hi_IN.UTF-8/X11/fonts/TrueType", 91 OPENWINHOMELIB "locale/ja/X11/fonts/TT", 92 OPENWINHOMELIB "locale/ko/X11/fonts/TrueType", 93 OPENWINHOMELIB "locale/ko.UTF-8/X11/fonts/TrueType", 94 OPENWINHOMELIB "locale/KOI8-R/X11/fonts/TrueType", 95 OPENWINHOMELIB "locale/ru.ansi-1251/X11/fonts/TrueType", 96 OPENWINHOMELIB "locale/th_TH/X11/fonts/TrueType", 97 OPENWINHOMELIB "locale/zh_TW/X11/fonts/TrueType", 98 OPENWINHOMELIB "locale/zh_TW.BIG5/X11/fonts/TT", 99 OPENWINHOMELIB "locale/zh_HK.BIG5HK/X11/fonts/TT", 100 OPENWINHOMELIB "locale/zh_CN.GB18030/X11/fonts/TrueType", 101 OPENWINHOMELIB "locale/zh/X11/fonts/TrueType", 102 OPENWINHOMELIB "locale/zh.GBK/X11/fonts/TrueType", 103 OPENWINHOMELIB "X11/fonts/Type1", 104 OPENWINHOMELIB "X11/fonts/Type1/sun", 105 OPENWINHOMELIB "X11/fonts/Type1/sun/outline", 106 OPENWINHOMELIB "locale/iso_8859_2/X11/fonts/Type1", 107 OPENWINHOMELIB "locale/iso_8859_4/X11/fonts/Type1", 108 OPENWINHOMELIB "locale/iso_8859_5/X11/fonts/Type1", 109 OPENWINHOMELIB "locale/iso_8859_7/X11/fonts/Type1", 110 OPENWINHOMELIB "locale/iso_8859_8/X11/fonts/Type1", 111 OPENWINHOMELIB "locale/iso_8859_9/X11/fonts/Type1", 112 OPENWINHOMELIB "locale/iso_8859_13/X11/fonts/Type1", 113 OPENWINHOMELIB "locale/ar/X11/fonts/Type1", 114 NULL, /* terminates the list */ 115 }; 116 117 #elif defined( __linux__) 118 /* All the known interesting locations we have discovered on 119 * various flavors of Linux 120 */ 121 static char *fullLinuxFontPath[] = { 122 "/usr/X11R6/lib/X11/fonts/TrueType", /* RH 7.1+ */ 123 "/usr/X11R6/lib/X11/fonts/truetype", /* SuSE */ 124 "/usr/X11R6/lib/X11/fonts/tt", 125 "/usr/X11R6/lib/X11/fonts/TTF", 126 "/usr/X11R6/lib/X11/fonts/OTF", /* RH 9.0 (but empty!) */ 127 "/usr/share/fonts/ja/TrueType", /* RH 7.2+ */ 128 "/usr/share/fonts/truetype", 129 "/usr/share/fonts/ko/TrueType", /* RH 9.0 */ 130 "/usr/share/fonts/zh_CN/TrueType", /* RH 9.0 */ 131 "/usr/share/fonts/zh_TW/TrueType", /* RH 9.0 */ 132 "/var/lib/defoma/x-ttcidfont-conf.d/dirs/TrueType", /* Debian */ 133 "/usr/X11R6/lib/X11/fonts/Type1", 134 "/usr/share/fonts/default/Type1", /* RH 9.0 */ 135 NULL, /* terminates the list */ 136 }; 137 #elif defined(_AIX) 138 static char *fullAixFontPath[] = { 139 "/usr/lpp/X11/lib/X11/fonts/Type1", /* from X11.fnt.iso_T1 */ 140 "/usr/lpp/X11/lib/X11/fonts/TrueType", /* from X11.fnt.ucs.ttf */ 141 NULL, /* terminates the list */ 142 }; 143 #endif 144 145 static char **getFontConfigLocations(); 146 147 typedef struct { 148 const char *name[MAXFDIRS]; 149 int num; 150 } fDirRecord, *fDirRecordPtr; 151 152 #ifndef HEADLESS 153 154 /* 155 * Returns True if display is local, False of it's remote. 156 */ 157 jboolean isDisplayLocal(JNIEnv *env) { 158 static jboolean isLocal = False; 159 static jboolean isLocalSet = False; 160 jboolean ret; 161 162 if (! isLocalSet) { 163 jclass geCls = (*env)->FindClass(env, "java/awt/GraphicsEnvironment"); 164 CHECK_NULL_RETURN(geCls, JNI_FALSE); 165 jmethodID getLocalGE = (*env)->GetStaticMethodID(env, geCls, 166 "getLocalGraphicsEnvironment", 167 "()Ljava/awt/GraphicsEnvironment;"); 168 CHECK_NULL_RETURN(getLocalGE, JNI_FALSE); 169 jobject ge = (*env)->CallStaticObjectMethod(env, geCls, getLocalGE); 170 JNU_CHECK_EXCEPTION_RETURN(env, JNI_FALSE); 171 172 jclass sgeCls = (*env)->FindClass(env, 173 "sun/java2d/SunGraphicsEnvironment"); 174 CHECK_NULL_RETURN(sgeCls, JNI_FALSE); 175 if ((*env)->IsInstanceOf(env, ge, sgeCls)) { 176 jmethodID isDisplayLocal = (*env)->GetMethodID(env, sgeCls, 177 "isDisplayLocal", 178 "()Z"); 179 JNU_CHECK_EXCEPTION_RETURN(env, JNI_FALSE); 180 isLocal = (*env)->CallBooleanMethod(env, ge, isDisplayLocal); 181 JNU_CHECK_EXCEPTION_RETURN(env, JNI_FALSE); 182 } else { 183 isLocal = True; 184 } 185 isLocalSet = True; 186 } 187 188 return isLocal; 189 } 190 191 static void AddFontsToX11FontPath ( fDirRecord *fDirP ) 192 { 193 char *onePath; 194 int index, nPaths; 195 int origNumPaths, length; 196 int origIndex; 197 int totalDirCount; 198 char **origFontPath; 199 char **tempFontPath; 200 int doNotAppend; 201 int *appendDirList; 202 char **newFontPath; 203 int err, compareLength; 204 char fontDirPath[512]; 205 int dirFile; 206 207 doNotAppend = 0; 208 209 if ( fDirP->num == 0 ) return; 210 211 appendDirList = SAFE_SIZE_ARRAY_ALLOC(malloc, fDirP->num, sizeof ( int )); 212 if ( appendDirList == NULL ) { 213 return; /* if it fails we cannot do much */ 214 } 215 216 origFontPath = XGetFontPath ( awt_display, &nPaths ); 217 218 totalDirCount = nPaths; 219 origNumPaths = nPaths; 220 tempFontPath = origFontPath; 221 222 223 for (index = 0; index < fDirP->num; index++ ) { 224 225 doNotAppend = 0; 226 227 tempFontPath = origFontPath; 228 for ( origIndex = 0; origIndex < nPaths; origIndex++ ) { 229 230 onePath = *tempFontPath; 231 232 compareLength = strlen ( onePath ); 233 if ( onePath[compareLength -1] == '/' ) 234 compareLength--; 235 236 /* there is a slash at the end of every solaris X11 font path name */ 237 if ( strncmp ( onePath, fDirP->name[index], compareLength ) == 0 ) { 238 doNotAppend = 1; 239 break; 240 } 241 tempFontPath++; 242 } 243 244 appendDirList[index] = 0; 245 if ( doNotAppend == 0 ) { 246 snprintf(fontDirPath, sizeof(fontDirPath), "%s/fonts.dir", fDirP->name[index]); 247 fontDirPath[sizeof(fontDirPath) - 1] = '\0'; 248 dirFile = open ( fontDirPath, O_RDONLY, 0 ); 249 if ( dirFile == -1 ) { 250 doNotAppend = 1; 251 } else { 252 close ( dirFile ); 253 totalDirCount++; 254 appendDirList[index] = 1; 255 } 256 } 257 258 } 259 260 /* if no changes are required do not bother to do a setfontpath */ 261 if ( totalDirCount == nPaths ) { 262 free ( ( void *) appendDirList ); 263 XFreeFontPath ( origFontPath ); 264 return; 265 } 266 267 268 newFontPath = SAFE_SIZE_ARRAY_ALLOC(malloc, totalDirCount, sizeof(char *)); 269 /* if it fails free things and get out */ 270 if ( newFontPath == NULL ) { 271 free ( ( void *) appendDirList ); 272 XFreeFontPath ( origFontPath ); 273 return; 274 } 275 276 for ( origIndex = 0; origIndex < nPaths; origIndex++ ) { 277 onePath = origFontPath[origIndex]; 278 newFontPath[origIndex] = onePath; 279 } 280 281 /* now add the other font paths */ 282 283 for (index = 0; index < fDirP->num; index++ ) { 284 285 if ( appendDirList[index] == 1 ) { 286 287 /* printf ( "Appending %s\n", fDirP->name[index] ); */ 288 289 onePath = SAFE_SIZE_ARRAY_ALLOC(malloc, strlen (fDirP->name[index]) + 2, sizeof( char ) ); 290 if (onePath == NULL) { 291 free ( ( void *) appendDirList ); 292 293 for ( index = origIndex; index < nPaths; index++ ) { 294 free( newFontPath[index] ); 295 } 296 297 free( ( void *) newFontPath); 298 XFreeFontPath ( origFontPath ); 299 return; 300 } 301 strcpy ( onePath, fDirP->name[index] ); 302 strcat ( onePath, "/" ); 303 newFontPath[nPaths++] = onePath; 304 /* printf ( "The path to be appended is %s\n", onePath ); */ 305 } 306 } 307 308 /* printf ( "The dir count = %d\n", totalDirCount ); */ 309 free ( ( void *) appendDirList ); 310 311 XSetFontPath ( awt_display, newFontPath, totalDirCount ); 312 313 for ( index = origNumPaths; index < totalDirCount; index++ ) { 314 free( newFontPath[index] ); 315 } 316 317 free ( (void *) newFontPath ); 318 XFreeFontPath ( origFontPath ); 319 return; 320 } 321 #endif /* !HEADLESS */ 322 323 324 #ifndef HEADLESS 325 static char **getX11FontPath () 326 { 327 char **x11Path, **fontdirs; 328 int i, pos, slen, nPaths, numDirs; 329 330 x11Path = XGetFontPath (awt_display, &nPaths); 331 332 /* This isn't ever going to be perfect: the font path may contain 333 * much we aren't interested in, but the cost should be moderate 334 * Exclude all directories that contain the strings "Speedo","/F3/", 335 * "75dpi", "100dpi", "misc" or "bitmap", or don't begin with a "/", 336 * the last of which should exclude font servers. 337 * Also exclude the user specific ".gnome*" directories which 338 * aren't going to contain the system fonts we need. 339 * Hopefully we are left only with Type1 and TrueType directories. 340 * It doesn't matter much if there are extraneous directories, it'll just 341 * cost us a little wasted effort upstream. 342 */ 343 fontdirs = (char**)calloc(nPaths+1, sizeof(char*)); 344 if (fontdirs == NULL) { 345 return NULL; 346 } 347 pos = 0; 348 for (i=0; i < nPaths; i++) { 349 if (x11Path[i][0] != '/') { 350 continue; 351 } 352 if (strstr(x11Path[i], "/75dpi") != NULL) { 353 continue; 354 } 355 if (strstr(x11Path[i], "/100dpi") != NULL) { 356 continue; 357 } 358 if (strstr(x11Path[i], "/misc") != NULL) { 359 continue; 360 } 361 if (strstr(x11Path[i], "/Speedo") != NULL) { 362 continue; 363 } 364 if (strstr(x11Path[i], ".gnome") != NULL) { 365 continue; 366 } 367 #ifdef __solaris__ 368 if (strstr(x11Path[i], "/F3/") != NULL) { 369 continue; 370 } 371 if (strstr(x11Path[i], "bitmap") != NULL) { 372 continue; 373 } 374 #endif 375 fontdirs[pos] = strdup(x11Path[i]); 376 slen = strlen(fontdirs[pos]); 377 if (slen > 0 && fontdirs[pos][slen-1] == '/') { 378 fontdirs[pos][slen-1] = '\0'; /* null out trailing "/" */ 379 } 380 pos++; 381 } 382 383 XFreeFontPath(x11Path); 384 if (pos == 0) { 385 free(fontdirs); 386 fontdirs = NULL; 387 } 388 return fontdirs; 389 } 390 391 392 #endif /* !HEADLESS */ 393 394 #if defined(__linux__) 395 /* from awt_LoadLibrary.c */ 396 JNIEXPORT jboolean JNICALL AWTIsHeadless(); 397 #endif 398 399 /* This eliminates duplicates, at a non-linear but acceptable cost 400 * since the lists are expected to be reasonably short, and then 401 * deletes references to non-existent directories, and returns 402 * a single path consisting of unique font directories. 403 */ 404 static char* mergePaths(char **p1, char **p2, char **p3, jboolean noType1) { 405 406 int len1=0, len2=0, len3=0, totalLen=0, numDirs=0, 407 currLen, i, j, found, pathLen=0; 408 char **ptr, **fontdirs; 409 char *fontPath = NULL; 410 411 if (p1 != NULL) { 412 ptr = p1; 413 while (*ptr++ != NULL) len1++; 414 } 415 if (p2 != NULL) { 416 ptr = p2; 417 418 while (*ptr++ != NULL) len2++; 419 } 420 if (p3 != NULL) { 421 ptr = p3; 422 while (*ptr++ != NULL) len3++; 423 } 424 totalLen = len1+len2+len3; 425 fontdirs = (char**)calloc(totalLen, sizeof(char*)); 426 if (fontdirs == NULL) { 427 return NULL; 428 } 429 430 for (i=0; i < len1; i++) { 431 if (noType1 && strstr(p1[i], "Type1") != NULL) { 432 continue; 433 } 434 fontdirs[numDirs++] = p1[i]; 435 } 436 437 currLen = numDirs; /* only compare against previous path dirs */ 438 for (i=0; i < len2; i++) { 439 if (noType1 && strstr(p2[i], "Type1") != NULL) { 440 continue; 441 } 442 found = 0; 443 for (j=0; j < currLen; j++) { 444 if (strcmp(fontdirs[j], p2[i]) == 0) { 445 found = 1; 446 break; 447 } 448 } 449 if (!found) { 450 fontdirs[numDirs++] = p2[i]; 451 } 452 } 453 454 currLen = numDirs; /* only compare against previous path dirs */ 455 for (i=0; i < len3; i++) { 456 if (noType1 && strstr(p3[i], "Type1") != NULL) { 457 continue; 458 } 459 found = 0; 460 for (j=0; j < currLen; j++) { 461 if (strcmp(fontdirs[j], p3[i]) == 0) { 462 found = 1; 463 break; 464 } 465 } 466 if (!found) { 467 fontdirs[numDirs++] = p3[i]; 468 } 469 } 470 471 /* Now fontdirs contains unique dirs and numDirs records how many. 472 * What we don't know is if they all exist. On reflection I think 473 * this isn't an issue, so for now I will return all these locations, 474 * converted to one string */ 475 for (i=0; i<numDirs; i++) { 476 pathLen += (strlen(fontdirs[i]) + 1); 477 } 478 if (pathLen > 0 && (fontPath = malloc(pathLen))) { 479 *fontPath = '\0'; 480 for (i = 0; i<numDirs; i++) { 481 if (i != 0) { 482 strcat(fontPath, ":"); 483 } 484 strcat(fontPath, fontdirs[i]); 485 } 486 } 487 free (fontdirs); 488 489 return fontPath; 490 } 491 492 /* 493 * The goal of this function is to find all "system" fonts which 494 * are needed by the JRE to display text in supported locales etc, and 495 * to support APIs which allow users to enumerate all system fonts and use 496 * them from their Java applications. 497 * The preferred mechanism is now using the new "fontconfig" library 498 * This exists on newer versions of Linux and Solaris (S10 and above) 499 * The library is dynamically located. The results are merged with 500 * a set of "known" locations and with the X11 font path, if running in 501 * a local X11 environment. 502 * The hardwired paths are built into the JDK binary so as new font locations 503 * are created on a host plaform for them to be located by the JRE they will 504 * need to be added ito the host's font configuration database, typically 505 * /etc/fonts/local.conf, and to ensure that directory contains a fonts.dir 506 * NB: Fontconfig also depends heavily for performance on the host O/S 507 * maintaining up to date caches. 508 * This is consistent with the requirements of the desktop environments 509 * on these OSes. 510 * This also frees us from X11 APIs as JRE is required to function in 511 * a "headless" mode where there is no Xserver. 512 */ 513 static char *getPlatformFontPathChars(JNIEnv *env, jboolean noType1, jboolean isX11) { 514 515 char **fcdirs = NULL, **x11dirs = NULL, **knowndirs = NULL, *path = NULL; 516 517 /* As of 1.5 we try to use fontconfig on both Solaris and Linux. 518 * If its not available NULL is returned. 519 */ 520 fcdirs = getFontConfigLocations(); 521 522 #if defined(__linux__) 523 knowndirs = fullLinuxFontPath; 524 #elif defined(__solaris__) 525 knowndirs = fullSolarisFontPath; 526 #elif defined(_AIX) 527 knowndirs = fullAixFontPath; 528 #endif 529 /* REMIND: this code requires to be executed when the GraphicsEnvironment 530 * is already initialised. That is always true, but if it were not so, 531 * this code could throw an exception and the fontpath would fail to 532 * be initialised. 533 */ 534 #ifndef HEADLESS 535 if (isX11) { // The following only works in an x11 environment. 536 #if defined(__linux__) 537 /* There's no headless build on linux ... */ 538 if (!AWTIsHeadless()) { /* .. so need to call a function to check */ 539 #endif 540 /* Using the X11 font path to locate font files is now a fallback 541 * useful only if fontconfig failed, or is incomplete. So we could 542 * remove this code completely and the consequences should be rare 543 * and non-fatal. If this happens, then the calling Java code can 544 * be modified to no longer require that the AWT lock (the X11GE) 545 * be initialised prior to calling this code. 546 */ 547 AWT_LOCK(); 548 if (isDisplayLocal(env)) { 549 x11dirs = getX11FontPath(); 550 } 551 AWT_UNLOCK(); 552 #if defined(__linux__) 553 } 554 #endif 555 } 556 #endif /* !HEADLESS */ 557 path = mergePaths(fcdirs, x11dirs, knowndirs, noType1); 558 if (fcdirs != NULL) { 559 char **p = fcdirs; 560 while (*p != NULL) free(*p++); 561 free(fcdirs); 562 } 563 564 if (x11dirs != NULL) { 565 char **p = x11dirs; 566 while (*p != NULL) free(*p++); 567 free(x11dirs); 568 } 569 570 return path; 571 } 572 573 JNIEXPORT jstring JNICALL Java_sun_awt_FcFontManager_getFontPathNative 574 (JNIEnv *env, jobject thiz, jboolean noType1, jboolean isX11) { 575 jstring ret; 576 static char *ptr = NULL; /* retain result across calls */ 577 578 if (ptr == NULL) { 579 ptr = getPlatformFontPathChars(env, noType1, isX11); 580 } 581 ret = (*env)->NewStringUTF(env, ptr); 582 return ret; 583 } 584 585 #include <dlfcn.h> 586 587 #include <fontconfig/fontconfig.h> 588 589 590 static void* openFontConfig() { 591 592 char *homeEnv; 593 static char *homeEnvStr = "HOME="; /* must be static */ 594 void* libfontconfig = NULL; 595 #ifdef __solaris__ 596 #define SYSINFOBUFSZ 8 597 char sysinfobuf[SYSINFOBUFSZ]; 598 #endif 599 600 /* Private workaround to not use fontconfig library. 601 * May be useful during testing/debugging 602 */ 603 char *useFC = getenv("USE_J2D_FONTCONFIG"); 604 if (useFC != NULL && !strcmp(useFC, "no")) { 605 return NULL; 606 } 607 608 #ifdef __solaris__ 609 /* fontconfig is likely not properly configured on S8/S9 - skip it, 610 * although allow user to override this behaviour with an env. variable 611 * ie if USE_J2D_FONTCONFIG=yes then we skip this test. 612 * NB "4" is the length of a string which matches our patterns. 613 */ 614 if (useFC == NULL || strcmp(useFC, "yes")) { 615 if (sysinfo(SI_RELEASE, sysinfobuf, SYSINFOBUFSZ) == 4) { 616 if ((!strcmp(sysinfobuf, "5.8") || !strcmp(sysinfobuf, "5.9"))) { 617 return NULL; 618 } 619 } 620 } 621 #endif 622 623 #if defined(_AIX) 624 /* On AIX, fontconfig is not a standard package supported by IBM. 625 * instead it has to be installed from the "AIX Toolbox for Linux Applications" 626 * site http://www-03.ibm.com/systems/power/software/aix/linux/toolbox/alpha.html 627 * and will be installed under /opt/freeware/lib/libfontconfig.a. 628 * Notice that the archive contains the real 32- and 64-bit shared libraries. 629 * We first try to load 'libfontconfig.so' from the default library path in the 630 * case the user has installed a private version of the library and if that 631 * doesn't succeed, we try the version from /opt/freeware/lib/libfontconfig.a 632 */ 633 libfontconfig = dlopen("libfontconfig.so", RTLD_LOCAL|RTLD_LAZY); 634 if (libfontconfig == NULL) { 635 libfontconfig = dlopen("/opt/freeware/lib/libfontconfig.a(libfontconfig.so.1)", RTLD_MEMBER|RTLD_LOCAL|RTLD_LAZY); 636 if (libfontconfig == NULL) { 637 return NULL; 638 } 639 } 640 #else 641 /* 64 bit sparc should pick up the right version from the lib path. 642 * New features may be added to libfontconfig, this is expected to 643 * be compatible with old features, but we may need to start 644 * distinguishing the library version, to know whether to expect 645 * certain symbols - and functionality - to be available. 646 * Also add explicit search for .so.1 in case .so symlink doesn't exist. 647 */ 648 libfontconfig = dlopen(FONTCONFIG_DLL_VERSIONED, RTLD_LOCAL|RTLD_LAZY); 649 if (libfontconfig == NULL) { 650 libfontconfig = dlopen(FONTCONFIG_DLL, RTLD_LOCAL|RTLD_LAZY); 651 if (libfontconfig == NULL) { 652 return NULL; 653 } 654 } 655 #endif 656 657 /* Version 1.0 of libfontconfig crashes if HOME isn't defined in 658 * the environment. This should generally never happen, but we can't 659 * control it, and can't control the version of fontconfig, so iff 660 * its not defined we set it to an empty value which is sufficient 661 * to prevent a crash. I considered unsetting it before exit, but 662 * it doesn't appear to work on Solaris, so I will leave it set. 663 */ 664 homeEnv = getenv("HOME"); 665 if (homeEnv == NULL) { 666 putenv(homeEnvStr); 667 } 668 669 return libfontconfig; 670 } 671 672 typedef void* (FcFiniFuncType)(); 673 674 static void closeFontConfig(void* libfontconfig, jboolean fcFini) { 675 676 /* NB FcFini is not in (eg) the Solaris 10 version of fontconfig. Its not 677 * clear if this means we are really leaking resources in those cases 678 * but it seems we should call this function when its available. 679 * But since the Swing GTK code may be still accessing the lib, its probably 680 * safest for now to just let this "leak" rather than potentially 681 * concurrently free global data still in use by other code. 682 */ 683 #if 0 684 if (fcFini) { /* release resources */ 685 FcFiniFuncType FcFini = (FcFiniFuncType)dlsym(libfontconfig, "FcFini"); 686 687 if (FcFini != NULL) { 688 (*FcFini)(); 689 } 690 } 691 #endif 692 dlclose(libfontconfig); 693 } 694 695 typedef FcConfig* (*FcInitLoadConfigFuncType)(); 696 typedef FcPattern* (*FcPatternBuildFuncType)(FcPattern *orig, ...); 697 typedef FcObjectSet* (*FcObjectSetFuncType)(const char *first, ...); 698 typedef FcFontSet* (*FcFontListFuncType)(FcConfig *config, 699 FcPattern *p, 700 FcObjectSet *os); 701 typedef FcResult (*FcPatternGetBoolFuncType)(const FcPattern *p, 702 const char *object, 703 int n, 704 FcBool *b); 705 typedef FcResult (*FcPatternGetIntegerFuncType)(const FcPattern *p, 706 const char *object, 707 int n, 708 int *i); 709 typedef FcResult (*FcPatternGetStringFuncType)(const FcPattern *p, 710 const char *object, 711 int n, 712 FcChar8 ** s); 713 typedef FcChar8* (*FcStrDirnameFuncType)(const FcChar8 *file); 714 typedef void (*FcPatternDestroyFuncType)(FcPattern *p); 715 typedef void (*FcFontSetDestroyFuncType)(FcFontSet *s); 716 typedef FcPattern* (*FcNameParseFuncType)(const FcChar8 *name); 717 typedef FcBool (*FcPatternAddStringFuncType)(FcPattern *p, 718 const char *object, 719 const FcChar8 *s); 720 typedef void (*FcDefaultSubstituteFuncType)(FcPattern *p); 721 typedef FcBool (*FcConfigSubstituteFuncType)(FcConfig *config, 722 FcPattern *p, 723 FcMatchKind kind); 724 typedef FcPattern* (*FcFontMatchFuncType)(FcConfig *config, 725 FcPattern *p, 726 FcResult *result); 727 typedef FcFontSet* (*FcFontSetCreateFuncType)(); 728 typedef FcBool (*FcFontSetAddFuncType)(FcFontSet *s, FcPattern *font); 729 730 typedef FcResult (*FcPatternGetCharSetFuncType)(FcPattern *p, 731 const char *object, 732 int n, 733 FcCharSet **c); 734 typedef FcFontSet* (*FcFontSortFuncType)(FcConfig *config, 735 FcPattern *p, 736 FcBool trim, 737 FcCharSet **csp, 738 FcResult *result); 739 typedef FcCharSet* (*FcCharSetUnionFuncType)(const FcCharSet *a, 740 const FcCharSet *b); 741 typedef FcChar32 (*FcCharSetSubtractCountFuncType)(const FcCharSet *a, 742 const FcCharSet *b); 743 744 typedef int (*FcGetVersionFuncType)(); 745 746 typedef FcStrList* (*FcConfigGetCacheDirsFuncType)(FcConfig *config); 747 typedef FcChar8* (*FcStrListNextFuncType)(FcStrList *list); 748 typedef FcChar8* (*FcStrListDoneFuncType)(FcStrList *list); 749 750 static char **getFontConfigLocations() { 751 752 char **fontdirs; 753 int numdirs = 0; 754 FcInitLoadConfigFuncType FcInitLoadConfig; 755 FcPatternBuildFuncType FcPatternBuild; 756 FcObjectSetFuncType FcObjectSetBuild; 757 FcFontListFuncType FcFontList; 758 FcPatternGetStringFuncType FcPatternGetString; 759 FcStrDirnameFuncType FcStrDirname; 760 FcPatternDestroyFuncType FcPatternDestroy; 761 FcFontSetDestroyFuncType FcFontSetDestroy; 762 763 FcConfig *fontconfig; 764 FcPattern *pattern; 765 FcObjectSet *objset; 766 FcFontSet *fontSet; 767 FcStrList *strList; 768 FcChar8 *str; 769 int i, f, found, len=0; 770 char **fontPath; 771 772 void* libfontconfig = openFontConfig(); 773 774 if (libfontconfig == NULL) { 775 return NULL; 776 } 777 778 FcPatternBuild = 779 (FcPatternBuildFuncType)dlsym(libfontconfig, "FcPatternBuild"); 780 FcObjectSetBuild = 781 (FcObjectSetFuncType)dlsym(libfontconfig, "FcObjectSetBuild"); 782 FcFontList = 783 (FcFontListFuncType)dlsym(libfontconfig, "FcFontList"); 784 FcPatternGetString = 785 (FcPatternGetStringFuncType)dlsym(libfontconfig, "FcPatternGetString"); 786 FcStrDirname = 787 (FcStrDirnameFuncType)dlsym(libfontconfig, "FcStrDirname"); 788 FcPatternDestroy = 789 (FcPatternDestroyFuncType)dlsym(libfontconfig, "FcPatternDestroy"); 790 FcFontSetDestroy = 791 (FcFontSetDestroyFuncType)dlsym(libfontconfig, "FcFontSetDestroy"); 792 793 if (FcPatternBuild == NULL || 794 FcObjectSetBuild == NULL || 795 FcPatternGetString == NULL || 796 FcFontList == NULL || 797 FcStrDirname == NULL || 798 FcPatternDestroy == NULL || 799 FcFontSetDestroy == NULL) { /* problem with the library: return. */ 800 closeFontConfig(libfontconfig, JNI_FALSE); 801 return NULL; 802 } 803 804 /* Make calls into the fontconfig library to build a search for 805 * outline fonts, and to get the set of full file paths from the matches. 806 * This set is returned from the call to FcFontList(..) 807 * We allocate an array of char* pointers sufficient to hold all 808 * the matches + 1 extra which ensures there will be a NULL after all 809 * valid entries. 810 * We call FcStrDirname strip the file name from the path, and 811 * check if we have yet seen this directory. If not we add a pointer to 812 * it into our array of char*. Note that FcStrDirname returns newly 813 * allocated storage so we can use this in the return char** value. 814 * Finally we clean up, freeing allocated resources, and return the 815 * array of unique directories. 816 */ 817 pattern = (*FcPatternBuild)(NULL, FC_OUTLINE, FcTypeBool, FcTrue, NULL); 818 objset = (*FcObjectSetBuild)(FC_FILE, NULL); 819 fontSet = (*FcFontList)(NULL, pattern, objset); 820 if (fontSet == NULL) { 821 /* FcFontList() may return NULL if fonts are not installed. */ 822 fontdirs = NULL; 823 } else { 824 fontdirs = (char**)calloc(fontSet->nfont+1, sizeof(char*)); 825 if (fontdirs == NULL) { 826 (*FcFontSetDestroy)(fontSet); 827 goto cleanup; 828 } 829 for (f=0; f < fontSet->nfont; f++) { 830 FcChar8 *file; 831 FcChar8 *dir; 832 if ((*FcPatternGetString)(fontSet->fonts[f], FC_FILE, 0, &file) == 833 FcResultMatch) { 834 dir = (*FcStrDirname)(file); 835 found = 0; 836 for (i=0;i<numdirs; i++) { 837 if (strcmp(fontdirs[i], (char*)dir) == 0) { 838 found = 1; 839 break; 840 } 841 } 842 if (!found) { 843 fontdirs[numdirs++] = (char*)dir; 844 } else { 845 free((char*)dir); 846 } 847 } 848 } 849 /* Free fontset if one was returned */ 850 (*FcFontSetDestroy)(fontSet); 851 } 852 853 cleanup: 854 /* Free memory and close the ".so" */ 855 (*FcPatternDestroy)(pattern); 856 closeFontConfig(libfontconfig, JNI_TRUE); 857 return fontdirs; 858 } 859 860 /* These are copied from sun.awt.SunHints. 861 * Consider initialising them as ints using JNI for more robustness. 862 */ 863 #define TEXT_AA_OFF 1 864 #define TEXT_AA_ON 2 865 #define TEXT_AA_LCD_HRGB 4 866 #define TEXT_AA_LCD_HBGR 5 867 #define TEXT_AA_LCD_VRGB 6 868 #define TEXT_AA_LCD_VBGR 7 869 870 JNIEXPORT jint JNICALL 871 Java_sun_font_FontConfigManager_getFontConfigAASettings 872 (JNIEnv *env, jclass obj, jstring localeStr, jstring fcNameStr) { 873 874 FcNameParseFuncType FcNameParse; 875 FcPatternAddStringFuncType FcPatternAddString; 876 FcConfigSubstituteFuncType FcConfigSubstitute; 877 FcDefaultSubstituteFuncType FcDefaultSubstitute; 878 FcFontMatchFuncType FcFontMatch; 879 FcPatternGetBoolFuncType FcPatternGetBool; 880 FcPatternGetIntegerFuncType FcPatternGetInteger; 881 FcPatternDestroyFuncType FcPatternDestroy; 882 883 FcPattern *pattern, *matchPattern; 884 FcResult result; 885 FcBool antialias = FcFalse; 886 int rgba = 0; 887 const char *locale=NULL, *fcName=NULL; 888 void* libfontconfig; 889 890 if (fcNameStr == NULL || localeStr == NULL) { 891 return -1; 892 } 893 894 fcName = (*env)->GetStringUTFChars(env, fcNameStr, 0); 895 if (fcName == NULL) { 896 return -1; 897 } 898 locale = (*env)->GetStringUTFChars(env, localeStr, 0); 899 900 if ((libfontconfig = openFontConfig()) == NULL) { 901 (*env)->ReleaseStringUTFChars(env, fcNameStr, (const char*)fcName); 902 if (locale) { 903 (*env)->ReleaseStringUTFChars(env, localeStr,(const char*)locale); 904 } 905 return -1; 906 } 907 908 FcNameParse = (FcNameParseFuncType)dlsym(libfontconfig, "FcNameParse"); 909 FcPatternAddString = 910 (FcPatternAddStringFuncType)dlsym(libfontconfig, "FcPatternAddString"); 911 FcConfigSubstitute = 912 (FcConfigSubstituteFuncType)dlsym(libfontconfig, "FcConfigSubstitute"); 913 FcDefaultSubstitute = (FcDefaultSubstituteFuncType) 914 dlsym(libfontconfig, "FcDefaultSubstitute"); 915 FcFontMatch = (FcFontMatchFuncType)dlsym(libfontconfig, "FcFontMatch"); 916 FcPatternGetBool = (FcPatternGetBoolFuncType) 917 dlsym(libfontconfig, "FcPatternGetBool"); 918 FcPatternGetInteger = (FcPatternGetIntegerFuncType) 919 dlsym(libfontconfig, "FcPatternGetInteger"); 920 FcPatternDestroy = 921 (FcPatternDestroyFuncType)dlsym(libfontconfig, "FcPatternDestroy"); 922 923 if (FcNameParse == NULL || 924 FcPatternAddString == NULL || 925 FcConfigSubstitute == NULL || 926 FcDefaultSubstitute == NULL || 927 FcFontMatch == NULL || 928 FcPatternGetBool == NULL || 929 FcPatternGetInteger == NULL || 930 FcPatternDestroy == NULL) { /* problem with the library: return. */ 931 932 (*env)->ReleaseStringUTFChars(env, fcNameStr, (const char*)fcName); 933 if (locale) { 934 (*env)->ReleaseStringUTFChars(env, localeStr,(const char*)locale); 935 } 936 closeFontConfig(libfontconfig, JNI_FALSE); 937 return -1; 938 } 939 940 941 pattern = (*FcNameParse)((FcChar8 *)fcName); 942 if (locale != NULL) { 943 (*FcPatternAddString)(pattern, FC_LANG, (unsigned char*)locale); 944 } 945 (*FcConfigSubstitute)(NULL, pattern, FcMatchPattern); 946 (*FcDefaultSubstitute)(pattern); 947 matchPattern = (*FcFontMatch)(NULL, pattern, &result); 948 /* Perhaps should call FcFontRenderPrepare() here as some pattern 949 * elements might change as a result of that call, but I'm not seeing 950 * any difference in testing. 951 */ 952 if (matchPattern) { 953 (*FcPatternGetBool)(matchPattern, FC_ANTIALIAS, 0, &antialias); 954 (*FcPatternGetInteger)(matchPattern, FC_RGBA, 0, &rgba); 955 (*FcPatternDestroy)(matchPattern); 956 } 957 (*FcPatternDestroy)(pattern); 958 959 (*env)->ReleaseStringUTFChars(env, fcNameStr, (const char*)fcName); 960 if (locale) { 961 (*env)->ReleaseStringUTFChars(env, localeStr, (const char*)locale); 962 } 963 closeFontConfig(libfontconfig, JNI_TRUE); 964 965 if (antialias == FcFalse) { 966 return TEXT_AA_OFF; 967 } else if (rgba <= FC_RGBA_UNKNOWN || rgba >= FC_RGBA_NONE) { 968 return TEXT_AA_ON; 969 } else { 970 switch (rgba) { 971 case FC_RGBA_RGB : return TEXT_AA_LCD_HRGB; 972 case FC_RGBA_BGR : return TEXT_AA_LCD_HBGR; 973 case FC_RGBA_VRGB : return TEXT_AA_LCD_VRGB; 974 case FC_RGBA_VBGR : return TEXT_AA_LCD_VBGR; 975 default : return TEXT_AA_LCD_HRGB; // should not get here. 976 } 977 } 978 } 979 980 JNIEXPORT jint JNICALL 981 Java_sun_font_FontConfigManager_getFontConfigVersion 982 (JNIEnv *env, jclass obj) { 983 984 void* libfontconfig; 985 FcGetVersionFuncType FcGetVersion; 986 int version = 0; 987 988 if ((libfontconfig = openFontConfig()) == NULL) { 989 return 0; 990 } 991 992 FcGetVersion = (FcGetVersionFuncType)dlsym(libfontconfig, "FcGetVersion"); 993 994 if (FcGetVersion == NULL) { 995 closeFontConfig(libfontconfig, JNI_FALSE); 996 return 0; 997 } 998 version = (*FcGetVersion)(); 999 closeFontConfig(libfontconfig, JNI_FALSE); 1000 1001 return version; 1002 } 1003 1004 1005 JNIEXPORT void JNICALL 1006 Java_sun_font_FontConfigManager_getFontConfig 1007 (JNIEnv *env, jclass obj, jstring localeStr, jobject fcInfoObj, 1008 jobjectArray fcCompFontArray, jboolean includeFallbacks) { 1009 1010 FcNameParseFuncType FcNameParse; 1011 FcPatternAddStringFuncType FcPatternAddString; 1012 FcConfigSubstituteFuncType FcConfigSubstitute; 1013 FcDefaultSubstituteFuncType FcDefaultSubstitute; 1014 FcFontMatchFuncType FcFontMatch; 1015 FcPatternGetStringFuncType FcPatternGetString; 1016 FcPatternDestroyFuncType FcPatternDestroy; 1017 FcPatternGetCharSetFuncType FcPatternGetCharSet; 1018 FcFontSortFuncType FcFontSort; 1019 FcFontSetDestroyFuncType FcFontSetDestroy; 1020 FcCharSetUnionFuncType FcCharSetUnion; 1021 FcCharSetSubtractCountFuncType FcCharSetSubtractCount; 1022 FcGetVersionFuncType FcGetVersion; 1023 FcConfigGetCacheDirsFuncType FcConfigGetCacheDirs; 1024 FcStrListNextFuncType FcStrListNext; 1025 FcStrListDoneFuncType FcStrListDone; 1026 1027 int i, arrlen; 1028 jobject fcCompFontObj; 1029 jstring fcNameStr, jstr; 1030 const char *locale, *fcName; 1031 FcPattern *pattern; 1032 FcResult result; 1033 void* libfontconfig; 1034 jfieldID fcNameID, fcFirstFontID, fcAllFontsID, fcVersionID, fcCacheDirsID; 1035 jfieldID familyNameID, styleNameID, fullNameID, fontFileID; 1036 jmethodID fcFontCons; 1037 char* debugMinGlyphsStr = getenv("J2D_DEBUG_MIN_GLYPHS"); 1038 jclass fcInfoClass; 1039 jclass fcCompFontClass; 1040 jclass fcFontClass; 1041 1042 CHECK_NULL(fcInfoObj); 1043 CHECK_NULL(fcCompFontArray); 1044 1045 fcInfoClass = 1046 (*env)->FindClass(env, "sun/font/FontConfigManager$FontConfigInfo"); 1047 CHECK_NULL(fcInfoClass); 1048 fcCompFontClass = 1049 (*env)->FindClass(env, "sun/font/FontConfigManager$FcCompFont"); 1050 CHECK_NULL(fcCompFontClass); 1051 fcFontClass = 1052 (*env)->FindClass(env, "sun/font/FontConfigManager$FontConfigFont"); 1053 CHECK_NULL(fcFontClass); 1054 1055 1056 CHECK_NULL(fcVersionID = (*env)->GetFieldID(env, fcInfoClass, "fcVersion", "I")); 1057 CHECK_NULL(fcCacheDirsID = (*env)->GetFieldID(env, fcInfoClass, "cacheDirs", 1058 "[Ljava/lang/String;")); 1059 CHECK_NULL(fcNameID = (*env)->GetFieldID(env, fcCompFontClass, 1060 "fcName", "Ljava/lang/String;")); 1061 CHECK_NULL(fcFirstFontID = (*env)->GetFieldID(env, fcCompFontClass, "firstFont", 1062 "Lsun/font/FontConfigManager$FontConfigFont;")); 1063 CHECK_NULL(fcAllFontsID = (*env)->GetFieldID(env, fcCompFontClass, "allFonts", 1064 "[Lsun/font/FontConfigManager$FontConfigFont;")); 1065 CHECK_NULL(fcFontCons = (*env)->GetMethodID(env, fcFontClass, "<init>", "()V")); 1066 CHECK_NULL(familyNameID = (*env)->GetFieldID(env, fcFontClass, 1067 "familyName", "Ljava/lang/String;")); 1068 CHECK_NULL(styleNameID = (*env)->GetFieldID(env, fcFontClass, 1069 "styleStr", "Ljava/lang/String;")); 1070 CHECK_NULL(fullNameID = (*env)->GetFieldID(env, fcFontClass, 1071 "fullName", "Ljava/lang/String;")); 1072 CHECK_NULL(fontFileID = (*env)->GetFieldID(env, fcFontClass, 1073 "fontFile", "Ljava/lang/String;")); 1074 1075 if ((libfontconfig = openFontConfig()) == NULL) { 1076 return; 1077 } 1078 1079 FcNameParse = (FcNameParseFuncType)dlsym(libfontconfig, "FcNameParse"); 1080 FcPatternAddString = 1081 (FcPatternAddStringFuncType)dlsym(libfontconfig, "FcPatternAddString"); 1082 FcConfigSubstitute = 1083 (FcConfigSubstituteFuncType)dlsym(libfontconfig, "FcConfigSubstitute"); 1084 FcDefaultSubstitute = (FcDefaultSubstituteFuncType) 1085 dlsym(libfontconfig, "FcDefaultSubstitute"); 1086 FcFontMatch = (FcFontMatchFuncType)dlsym(libfontconfig, "FcFontMatch"); 1087 FcPatternGetString = 1088 (FcPatternGetStringFuncType)dlsym(libfontconfig, "FcPatternGetString"); 1089 FcPatternDestroy = 1090 (FcPatternDestroyFuncType)dlsym(libfontconfig, "FcPatternDestroy"); 1091 FcPatternGetCharSet = 1092 (FcPatternGetCharSetFuncType)dlsym(libfontconfig, 1093 "FcPatternGetCharSet"); 1094 FcFontSort = 1095 (FcFontSortFuncType)dlsym(libfontconfig, "FcFontSort"); 1096 FcFontSetDestroy = 1097 (FcFontSetDestroyFuncType)dlsym(libfontconfig, "FcFontSetDestroy"); 1098 FcCharSetUnion = 1099 (FcCharSetUnionFuncType)dlsym(libfontconfig, "FcCharSetUnion"); 1100 FcCharSetSubtractCount = 1101 (FcCharSetSubtractCountFuncType)dlsym(libfontconfig, 1102 "FcCharSetSubtractCount"); 1103 FcGetVersion = (FcGetVersionFuncType)dlsym(libfontconfig, "FcGetVersion"); 1104 1105 if (FcNameParse == NULL || 1106 FcPatternAddString == NULL || 1107 FcConfigSubstitute == NULL || 1108 FcDefaultSubstitute == NULL || 1109 FcFontMatch == NULL || 1110 FcPatternGetString == NULL || 1111 FcPatternDestroy == NULL || 1112 FcPatternGetCharSet == NULL || 1113 FcFontSetDestroy == NULL || 1114 FcCharSetUnion == NULL || 1115 FcGetVersion == NULL || 1116 FcCharSetSubtractCount == NULL) {/* problem with the library: return.*/ 1117 closeFontConfig(libfontconfig, JNI_FALSE); 1118 return; 1119 } 1120 1121 (*env)->SetIntField(env, fcInfoObj, fcVersionID, (*FcGetVersion)()); 1122 1123 /* Optionally get the cache dir locations. This isn't 1124 * available until v 2.4.x, but this is OK since on those later versions 1125 * we can check the time stamps on the cache dirs to see if we 1126 * are out of date. There are a couple of assumptions here. First 1127 * that the time stamp on the directory changes when the contents are 1128 * updated. Secondly that the locations don't change. The latter is 1129 * most likely if a new version of fontconfig is installed, but we also 1130 * invalidate the cache if we detect that. Arguably even that is "rare", 1131 * and most likely is tied to an OS upgrade which gets a new file anyway. 1132 */ 1133 FcConfigGetCacheDirs = 1134 (FcConfigGetCacheDirsFuncType)dlsym(libfontconfig, 1135 "FcConfigGetCacheDirs"); 1136 FcStrListNext = 1137 (FcStrListNextFuncType)dlsym(libfontconfig, "FcStrListNext"); 1138 FcStrListDone = 1139 (FcStrListDoneFuncType)dlsym(libfontconfig, "FcStrListDone"); 1140 if (FcStrListNext != NULL && FcStrListDone != NULL && 1141 FcConfigGetCacheDirs != NULL) { 1142 1143 FcStrList* cacheDirs; 1144 FcChar8* cacheDir; 1145 int cnt = 0; 1146 jobject cacheDirArray = 1147 (*env)->GetObjectField(env, fcInfoObj, fcCacheDirsID); 1148 int max = (*env)->GetArrayLength(env, cacheDirArray); 1149 1150 cacheDirs = (*FcConfigGetCacheDirs)(NULL); 1151 if (cacheDirs != NULL) { 1152 while ((cnt < max) && (cacheDir = (*FcStrListNext)(cacheDirs))) { 1153 jstr = (*env)->NewStringUTF(env, (const char*)cacheDir); 1154 JNU_CHECK_EXCEPTION(env); 1155 1156 (*env)->SetObjectArrayElement(env, cacheDirArray, cnt++, jstr); 1157 (*env)->DeleteLocalRef(env, jstr); 1158 } 1159 (*FcStrListDone)(cacheDirs); 1160 } 1161 } 1162 1163 locale = (*env)->GetStringUTFChars(env, localeStr, 0); 1164 if (locale == NULL) { 1165 (*env)->ExceptionClear(env); 1166 JNU_ThrowOutOfMemoryError(env, "Could not create locale"); 1167 return; 1168 } 1169 1170 arrlen = (*env)->GetArrayLength(env, fcCompFontArray); 1171 for (i=0; i<arrlen; i++) { 1172 FcFontSet* fontset; 1173 int fn, j, fontCount, nfonts; 1174 unsigned int minGlyphs; 1175 FcChar8 **family, **styleStr, **fullname, **file; 1176 jarray fcFontArr = NULL; 1177 FcCharSet *unionCharset = NULL; 1178 1179 fcCompFontObj = (*env)->GetObjectArrayElement(env, fcCompFontArray, i); 1180 fcNameStr = 1181 (jstring)((*env)->GetObjectField(env, fcCompFontObj, fcNameID)); 1182 fcName = (*env)->GetStringUTFChars(env, fcNameStr, 0); 1183 if (fcName == NULL) { 1184 (*env)->DeleteLocalRef(env, fcCompFontObj); 1185 (*env)->DeleteLocalRef(env, fcNameStr); 1186 continue; 1187 } 1188 pattern = (*FcNameParse)((FcChar8 *)fcName); 1189 (*env)->ReleaseStringUTFChars(env, fcNameStr, (const char*)fcName); 1190 (*env)->DeleteLocalRef(env, fcNameStr); 1191 if (pattern == NULL) { 1192 closeFontConfig(libfontconfig, JNI_FALSE); 1193 if (locale) { 1194 (*env)->ReleaseStringUTFChars(env, localeStr, (const char*)locale); 1195 } 1196 return; 1197 } 1198 1199 /* locale may not usually be necessary as fontconfig appears to apply 1200 * this anyway based on the user's environment. However we want 1201 * to use the value of the JDK startup locale so this should take 1202 * care of it. 1203 */ 1204 if (locale != NULL) { 1205 (*FcPatternAddString)(pattern, FC_LANG, (unsigned char*)locale); 1206 } 1207 (*FcConfigSubstitute)(NULL, pattern, FcMatchPattern); 1208 (*FcDefaultSubstitute)(pattern); 1209 fontset = (*FcFontSort)(NULL, pattern, FcTrue, NULL, &result); 1210 if (fontset == NULL) { 1211 (*FcPatternDestroy)(pattern); 1212 closeFontConfig(libfontconfig, JNI_FALSE); 1213 if (locale) { 1214 (*env)->ReleaseStringUTFChars(env, localeStr, (const char*)locale); 1215 } 1216 return; 1217 } 1218 1219 /* fontconfig returned us "nfonts". If we are just getting the 1220 * first font, we set nfont to zero. Otherwise we use "nfonts". 1221 * Next create separate C arrrays of length nfonts for family file etc. 1222 * Inspect the returned fonts and the ones we like (adds enough glyphs) 1223 * are added to the arrays and we increment 'fontCount'. 1224 */ 1225 nfonts = fontset->nfont; 1226 family = (FcChar8**)calloc(nfonts, sizeof(FcChar8*)); 1227 styleStr = (FcChar8**)calloc(nfonts, sizeof(FcChar8*)); 1228 fullname = (FcChar8**)calloc(nfonts, sizeof(FcChar8*)); 1229 file = (FcChar8**)calloc(nfonts, sizeof(FcChar8*)); 1230 if (family == NULL || styleStr == NULL || 1231 fullname == NULL || file == NULL) { 1232 if (family != NULL) { 1233 free(family); 1234 } 1235 if (styleStr != NULL) { 1236 free(styleStr); 1237 } 1238 if (fullname != NULL) { 1239 free(fullname); 1240 } 1241 if (file != NULL) { 1242 free(file); 1243 } 1244 (*FcPatternDestroy)(pattern); 1245 (*FcFontSetDestroy)(fontset); 1246 closeFontConfig(libfontconfig, JNI_FALSE); 1247 if (locale) { 1248 (*env)->ReleaseStringUTFChars(env, localeStr, (const char*)locale); 1249 } 1250 return; 1251 } 1252 fontCount = 0; 1253 minGlyphs = 20; 1254 if (debugMinGlyphsStr != NULL) { 1255 int val = minGlyphs; 1256 sscanf(debugMinGlyphsStr, "%5d", &val); 1257 if (val >= 0 && val <= 65536) { 1258 minGlyphs = val; 1259 } 1260 } 1261 1262 for (j=0; j<nfonts; j++) { 1263 FcPattern *fontPattern = fontset->fonts[j]; 1264 FcChar8 *fontformat; 1265 FcCharSet *charset = NULL; 1266 1267 fontformat = NULL; 1268 (*FcPatternGetString)(fontPattern, FC_FONTFORMAT, 0, &fontformat); 1269 /* We only want TrueType fonts but some Linuxes still depend 1270 * on Type 1 fonts for some Locale support, so we'll allow 1271 * them there. 1272 */ 1273 if (fontformat != NULL 1274 && (strcmp((char*)fontformat, "TrueType") != 0) 1275 #if defined(__linux__) || defined(_AIX) 1276 && (strcmp((char*)fontformat, "Type 1") != 0) 1277 && (strcmp((char*)fontformat, "CFF") != 0) 1278 #endif 1279 ) { 1280 continue; 1281 } 1282 result = (*FcPatternGetCharSet)(fontPattern, 1283 FC_CHARSET, 0, &charset); 1284 if (result != FcResultMatch) { 1285 free(family); 1286 free(fullname); 1287 free(styleStr); 1288 free(file); 1289 (*FcPatternDestroy)(pattern); 1290 (*FcFontSetDestroy)(fontset); 1291 closeFontConfig(libfontconfig, JNI_FALSE); 1292 if (locale) { 1293 (*env)->ReleaseStringUTFChars(env, localeStr, (const char*)locale); 1294 } 1295 return; 1296 } 1297 1298 /* We don't want 20 or 30 fonts, so once we hit 10 fonts, 1299 * then require that they really be adding value. Too many 1300 * adversely affects load time for minimal value-add. 1301 * This is still likely far more than we've had in the past. 1302 */ 1303 if (j==10) { 1304 minGlyphs = 50; 1305 } 1306 if (unionCharset == NULL) { 1307 unionCharset = charset; 1308 } else { 1309 if ((*FcCharSetSubtractCount)(charset, unionCharset) 1310 > minGlyphs) { 1311 unionCharset = (* FcCharSetUnion)(unionCharset, charset); 1312 } else { 1313 continue; 1314 } 1315 } 1316 1317 fontCount++; // found a font we will use. 1318 (*FcPatternGetString)(fontPattern, FC_FILE, 0, &file[j]); 1319 (*FcPatternGetString)(fontPattern, FC_FAMILY, 0, &family[j]); 1320 (*FcPatternGetString)(fontPattern, FC_STYLE, 0, &styleStr[j]); 1321 (*FcPatternGetString)(fontPattern, FC_FULLNAME, 0, &fullname[j]); 1322 if (!includeFallbacks) { 1323 break; 1324 } 1325 if (fontCount == 254) { 1326 break; // CompositeFont will only use up to 254 slots from here. 1327 } 1328 } 1329 1330 /* Once we get here 'fontCount' is the number of returned fonts 1331 * we actually want to use, so we create 'fcFontArr' of that length. 1332 * The non-null entries of "family[]" etc are those fonts. 1333 * Then loop again over all nfonts adding just those non-null ones 1334 * to 'fcFontArr'. If its null (we didn't want the font) 1335 * then we don't enter the main body. 1336 * So we should never get more than 'fontCount' entries. 1337 */ 1338 if (includeFallbacks) { 1339 fcFontArr = 1340 (*env)->NewObjectArray(env, fontCount, fcFontClass, NULL); 1341 if (IS_NULL(fcFontArr)) { 1342 free(family); 1343 free(fullname); 1344 free(styleStr); 1345 free(file); 1346 (*FcPatternDestroy)(pattern); 1347 (*FcFontSetDestroy)(fontset); 1348 closeFontConfig(libfontconfig, JNI_FALSE); 1349 if (locale) { 1350 (*env)->ReleaseStringUTFChars(env, localeStr, (const char*)locale); 1351 } 1352 return; 1353 } 1354 (*env)->SetObjectField(env,fcCompFontObj, fcAllFontsID, fcFontArr); 1355 } 1356 fn=0; 1357 1358 for (j=0;j<nfonts;j++) { 1359 if (family[j] != NULL) { 1360 jobject fcFont = 1361 (*env)->NewObject(env, fcFontClass, fcFontCons); 1362 if (IS_NULL(fcFont)) break; 1363 jstr = (*env)->NewStringUTF(env, (const char*)family[j]); 1364 if (IS_NULL(jstr)) break; 1365 (*env)->SetObjectField(env, fcFont, familyNameID, jstr); 1366 (*env)->DeleteLocalRef(env, jstr); 1367 if (file[j] != NULL) { 1368 jstr = (*env)->NewStringUTF(env, (const char*)file[j]); 1369 if (IS_NULL(jstr)) break; 1370 (*env)->SetObjectField(env, fcFont, fontFileID, jstr); 1371 (*env)->DeleteLocalRef(env, jstr); 1372 } 1373 if (styleStr[j] != NULL) { 1374 jstr = (*env)->NewStringUTF(env, (const char*)styleStr[j]); 1375 if (IS_NULL(jstr)) break; 1376 (*env)->SetObjectField(env, fcFont, styleNameID, jstr); 1377 (*env)->DeleteLocalRef(env, jstr); 1378 } 1379 if (fullname[j] != NULL) { 1380 jstr = (*env)->NewStringUTF(env, (const char*)fullname[j]); 1381 if (IS_NULL(jstr)) break; 1382 (*env)->SetObjectField(env, fcFont, fullNameID, jstr); 1383 (*env)->DeleteLocalRef(env, jstr); 1384 } 1385 if (fn==0) { 1386 (*env)->SetObjectField(env, fcCompFontObj, 1387 fcFirstFontID, fcFont); 1388 } 1389 if (includeFallbacks) { 1390 (*env)->SetObjectArrayElement(env, fcFontArr, fn++,fcFont); 1391 } else { 1392 (*env)->DeleteLocalRef(env, fcFont); 1393 break; 1394 } 1395 (*env)->DeleteLocalRef(env, fcFont); 1396 } 1397 } 1398 if (includeFallbacks) { 1399 (*env)->DeleteLocalRef(env, fcFontArr); 1400 } 1401 (*env)->DeleteLocalRef(env, fcCompFontObj); 1402 (*FcFontSetDestroy)(fontset); 1403 (*FcPatternDestroy)(pattern); 1404 free(family); 1405 free(styleStr); 1406 free(fullname); 1407 free(file); 1408 } 1409 1410 /* release resources and close the ".so" */ 1411 1412 if (locale) { 1413 (*env)->ReleaseStringUTFChars(env, localeStr, (const char*)locale); 1414 } 1415 closeFontConfig(libfontconfig, JNI_TRUE); 1416 }