| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| /** |
| * @author Ilya S. Okomin |
| * |
| */ |
| #include <X11/Xft/Xft.h> |
| #include <freetype/tttables.h> |
| #include <freetype/t1tables.h> |
| |
| #include <jni.h> |
| |
| #include "FontLibExports.h" |
| |
| #if (FREETYPE_MAJOR >= 2 && FREETYPE_MINOR >= 2) |
| |
| #undef HAS_FREETYPE_INTERNAL |
| #include <freetype/ftsizes.h> |
| #include <freetype/ftglyph.h> |
| #ifndef FALSE |
| #define FALSE (0) |
| #define TRUE (1) |
| #endif /* FALSE */ |
| |
| #else /* FREETYPE_MAJOR ... */ |
| |
| #define HAS_FREETYPE_INTERNAL 1 |
| #include <freetype/internal/tttypes.h> |
| |
| #endif /* FREETYPE_MAJOR ... */ |
| |
| #include <freetype/ftsnames.h> |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| |
| #include<string.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <unistd.h> |
| |
| #include <wchar.h> |
| #include <math.h> |
| |
| #include "LinuxNativeFont.h" |
| #include "exceptions.h" |
| #include "org_apache_harmony_awt_gl_font_LinuxNativeFont.h" |
| /* debug code marker - to print debug information change to DEBUG */ |
| # define NO_DEBUG |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: getFontFamiliesNames |
| * Signature: ()[Ljava/lang/String; |
| * Returns array of Strings that represents list of all font families names |
| * available on the system. |
| */ |
| JNIEXPORT jobjectArray JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_getFontFamiliesNames(JNIEnv *env, jclass jobj){ |
| |
| jobjectArray families; |
| |
| XftObjectSet *os = 0; |
| XftPattern *xftPattern; |
| XftFontSet *fs; |
| int j, i; |
| int len; |
| int numFamilies; |
| FcChar8 *family; |
| char** famList; |
| jclass strClass; |
| jstring initStr; |
| |
| |
| /* Create pattern */ |
| xftPattern = XftPatternCreate(); |
| |
| if (!XftPatternAddBool (xftPattern, XFT_OUTLINE, True)){ |
| throwNPException(env, "Outline value can't be added to XftPattern"); |
| } |
| |
| /* Just need to add which fields you want to list */ |
| os = XftObjectSetBuild (XFT_FAMILY, (char *) 0); |
| |
| fs = FcFontList (0, xftPattern, os); |
| |
| XftObjectSetDestroy (os); |
| |
| if(xftPattern){ |
| XftPatternDestroy(xftPattern); |
| } |
| |
| if (!fs){ |
| throwNPException(env, "Font list can't be created"); |
| return NULL; |
| } else { |
| numFamilies = fs->nfont; |
| famList = (char** )malloc(numFamilies * sizeof(char *)); |
| |
| for (j = 0; j < numFamilies; j++) { |
| |
| #ifdef DEBUG |
| FcChar8* font = FcNameUnparse (fs->fonts[j]); |
| printf ("%s\n", font); |
| free (font); |
| #endif /* DEBUG */ |
| |
| if (XftPatternGetString (fs->fonts[j], XFT_FAMILY, 0, &family) == XftResultMatch){ |
| |
| #ifdef DEBUG |
| printf (" %s", family); |
| #endif /* DEBUG */ |
| |
| len = (strlen((char *)family)+1); |
| famList[j] = (char*)malloc(sizeof(char) * len); |
| |
| strncpy(famList[j], (char *)family, len); |
| } else { |
| /* |
| * TODO |
| * We should add special handling for this case |
| */ |
| famList[j] = 0; |
| } |
| } |
| XftFontSetDestroy (fs); |
| } |
| |
| strClass = (*env)->FindClass(env, "java/lang/String"); |
| initStr = (*env)->NewStringUTF(env, ""); |
| |
| families = (jobjectArray)(*env)->NewObjectArray(env, |
| numFamilies, |
| strClass, |
| initStr); |
| |
| if (families == NULL){ |
| for (i = 0;i < numFamilies;i++){ |
| free(famList[i]); |
| } |
| free(famList); |
| throwNPException(env, "Not enough memory to create families list"); |
| return NULL; |
| } |
| |
| for (i = 0;i < numFamilies;i++){ |
| // number of chars == length of string -1 |
| (*env)->SetObjectArrayElement(env, families,i,(*env)->NewStringUTF(env, famList[i])); |
| free(famList[i]); |
| } |
| free(famList); |
| |
| return families; |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: embedFontNative |
| * Signature: (Ljava/lang/String;)Z |
| * |
| * Returns true if the new font was added to the system, false otherwise. |
| * Methods checks if the number of system fonts changed after font configuration |
| * was rebuilt. |
| */ |
| JNIEXPORT jstring JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_embedFontNative(JNIEnv *env, jclass obj, jstring fName){ |
| |
| int fontAdded = FALSE; |
| FcConfig *config; |
| |
| config = FcConfigGetCurrent(); |
| if (!config){ |
| return 0; |
| } |
| |
| char *path = (char *)(*env)->GetStringUTFChars(env, fName, 0); |
| fontAdded = FcConfigAppFontAddFile(config, (unsigned char*)path); |
| |
| unsigned short *familyName = 0; |
| |
| if (fontAdded) { |
| getFontFamilyName(path, &familyName); |
| } |
| |
| (*env)->ReleaseStringUTFChars(env, fName, path); |
| |
| jstring res = 0; |
| if (fontAdded && familyName) { |
| int len = 0; |
| for (; familyName[len] != 0; len++); |
| res = (*env)->NewString(env, (jchar *)familyName, len); |
| free(familyName); |
| } |
| |
| return res; |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: initializeFont |
| * Signature: (Lorg/apache/harmony/awt/gl/font/LinuxFont;Ljava/lang/String;IILjava/lang/String;)J |
| * Initiailzes native Xft font object from specified parameters and returns |
| * font handle, also sets font type to the font peer parameter. |
| * NullPointerException is thrown if there are errors in native code. |
| */ |
| JNIEXPORT jlong JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_initializeFont(JNIEnv *env, jclass jobj, jobject linuxFont, jstring jName, jint jStyle, jint size, jstring jFaceStyle){ |
| |
| jclass cls; |
| jfieldID fid; |
| jmethodID mid; |
| jboolean iscopy; |
| |
| int slant; |
| int weight; |
| const char* name; |
| |
| XftPattern *pattern; |
| XftPattern *matchPattern; |
| XftResult result; |
| Display *dpy; |
| int scr; |
| FcChar8 *faceStyle = NULL; |
| XftFont *xftFnt; |
| int font_type = FONT_TYPE_UNDEF; |
| double fSize; |
| FT_Face face; |
| |
| /* Initialize part */ |
| cls = (*env)->GetObjectClass(env, linuxFont); |
| |
| fid=(*env)->GetFieldID(env, cls, "display", "J"); |
| if (fid == 0) { |
| (*env)->ExceptionDescribe(env); |
| (*env)->ExceptionClear(env); |
| return (jlong)(IDATA)NULL; |
| } |
| dpy = (Display *)(long)(*env)->GetLongField(env, linuxFont, fid); |
| |
| if (dpy == NULL){ |
| throwNPException(env, "Cannot connect to XServer"); |
| return (jlong)(IDATA)NULL; |
| } |
| |
| if (jStyle & FONT_BOLD) { |
| // TODO: need to be defined from TextAttributes |
| weight = XFT_WEIGHT_BOLD; |
| #ifdef DEBUG |
| printf("Weight is bold"); |
| #endif // DEBUG |
| } else { |
| // TODO: need to be defined from TextAttributes |
| weight = XFT_WEIGHT_MEDIUM; |
| #ifdef DEBUG |
| printf("Weight is medium"); |
| #endif // DEBUG |
| } |
| |
| if (jStyle & FONT_ITALIC){ |
| slant = XFT_SLANT_ITALIC; |
| } else { |
| slant = XFT_SLANT_ROMAN; |
| } |
| |
| fid=(*env)->GetFieldID(env, cls, "screen", "I"); |
| if (fid == 0) { |
| (*env)->ExceptionDescribe(env); |
| (*env)->ExceptionClear(env); |
| return (jlong)(IDATA)NULL; |
| } |
| scr = (*env)->GetIntField(env, linuxFont, fid); |
| |
| name = (*env)->GetStringUTFChars(env, jName, &iscopy); |
| if (jFaceStyle){ |
| faceStyle = (FcChar8 *)(*env)->GetStringUTFChars(env, jFaceStyle, &iscopy); |
| } |
| |
| /* Xft part */ |
| /* Create pattern */ |
| pattern = XftPatternCreate(); |
| |
| if (!XftPatternAddString (pattern, XFT_FAMILY, name)){ |
| if(name){ |
| (*env)->ReleaseStringUTFChars(env, jName, name); |
| } |
| if(faceStyle){ |
| (*env)->ReleaseStringUTFChars(env, jFaceStyle, (char *)faceStyle); |
| } |
| XftPatternDestroy (pattern); |
| throwNPException(env, "Error during adding family name to XFTPattern structure"); |
| } |
| |
| /* We do not need name any more */ |
| if(name){ |
| (*env)->ReleaseStringUTFChars(env, jName, name); |
| } |
| |
| if (faceStyle && !XftPatternAddString (pattern, XFT_STYLE, faceStyle)){ |
| if(faceStyle){ |
| (*env)->ReleaseStringUTFChars(env, jFaceStyle, (char *)faceStyle); |
| } |
| XftPatternDestroy (pattern); |
| throwNPException(env, "Error during adding style name to XFTPattern structure"); |
| } |
| |
| /* We do not need faceStyle any more */ |
| if(faceStyle){ |
| XftPatternDestroy (pattern); |
| (*env)->ReleaseStringUTFChars(env, jFaceStyle, (char *)faceStyle); |
| } |
| |
| if (!XftPatternAddInteger(pattern, XFT_SLANT, slant)){ |
| XftPatternDestroy (pattern); |
| throwNPException(env, "Error during adding font slant to XFTPattern structure"); |
| } |
| |
| if (!XftPatternAddInteger(pattern, XFT_WEIGHT, weight)){ |
| XftPatternDestroy (pattern); |
| throwNPException(env, "Error during adding font weight to XFTPattern structure"); |
| } |
| |
| /* We set antialias mode for simple text rendering without antialiasing */ |
| if (!XftPatternAddBool(pattern, XFT_ANTIALIAS, False)){ |
| XftPatternDestroy (pattern); |
| throwNPException(env, "Error during adding font antialias set to false to XFTPattern structure"); |
| } |
| |
| /* |
| * |
| * To comply with Java specification and results we have to use DPI value |
| * equals to 96. Actually, it is properly to use resolution Y value instead of DPI value |
| * the correct formula resolutionY = (XDisplayHeight(dpy, scr)/(XDisplayHeightMM(dpy, scr)/25.4)); |
| * hence size = size / (double)resolutionY * 72; |
| */ |
| |
| fSize = (double)size / 96 * 72; |
| |
| if (!XftPatternAddDouble (pattern, XFT_SIZE, fSize)){ |
| XftPatternDestroy (pattern); |
| throwNPException(env, "Error during adding font size to XFTPattern structure"); |
| } |
| |
| /* if (!XftPatternAddBool (pattern, FC_HINTING, True)){ |
| XftPatternDestroy (pattern); |
| throwNPException(env, "Error during adding font hinting set to false to XFTPattern structure"); |
| } |
| */ |
| |
| if (!XftPatternAddBool (pattern, XFT_RENDER, True)){ |
| XftPatternDestroy (pattern); |
| throwNPException(env, "Error during adding font RENDER set to true to XFTPattern structure"); |
| } |
| |
| |
| if (!XftPatternAddBool (pattern, FC_AUTOHINT, True)){ |
| XftPatternDestroy (pattern); |
| throwNPException(env, "Error during adding font autohinting set to false to XFTPattern structure"); |
| } |
| |
| matchPattern = XftFontMatch (dpy, scr, pattern, &result); |
| |
| #ifdef DEBUG |
| printf ("Pattern "); |
| FcPatternPrint (pattern); |
| if (matchPattern) |
| { |
| printf ("Match "); |
| FcPatternPrint (matchPattern); |
| } |
| else { |
| printf ("No Match\n"); |
| } |
| #endif /* DEBUG */ |
| |
| XftPatternDestroy (pattern); |
| |
| if (!matchPattern){ |
| XftPatternDestroy (matchPattern); |
| return (jlong)(IDATA)NULL; |
| } |
| |
| xftFnt = XftFontOpenPattern (dpy, matchPattern); |
| |
| if (!xftFnt){ |
| XftPatternDestroy (matchPattern); |
| return (jlong)(IDATA)NULL; |
| } |
| |
| /* defining font type */ |
| face = XftLockFace(xftFnt); |
| if ((face->face_flags & FT_FACE_FLAG_SCALABLE) && |
| !(face->face_flags & FT_FACE_FLAG_FIXED_SIZES) && |
| !(face->face_flags & FT_FACE_FLAG_SFNT)) { |
| font_type = FONT_TYPE_T1; |
| } else { |
| font_type = FONT_TYPE_TT; |
| } |
| XftUnlockFace(xftFnt); |
| |
| if (font_type == FONT_TYPE_UNDEF){ |
| XftFontClose (dpy, xftFnt); |
| return (jlong)(IDATA)NULL; |
| } |
| |
| /* Set Font type in LinuxFont object (upcall) */ |
| mid=(*env)->GetMethodID(env, cls, "setFontType", "(I)V"); |
| |
| if (mid == 0) { |
| #ifdef DEBUG |
| printf("Can't find \"setFontType\" method"); |
| #endif // DEBUG |
| (*env)->ExceptionDescribe(env); |
| (*env)->ExceptionClear(env); |
| return (jlong)(IDATA)NULL; |
| } |
| |
| (*env)->CallVoidMethod(env, linuxFont, mid, font_type); |
| |
| if((*env)->ExceptionOccurred(env)) { |
| #ifdef DEBUG |
| printf("Error occured when calling \"setFontType\" method"); |
| #endif // DEBUG |
| (*env)->ExceptionDescribe(env); |
| (*env)->ExceptionClear(env); |
| return (jlong)(IDATA)NULL; |
| } |
| |
| return (jlong)(IDATA)xftFnt; |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: initializeFontFromFP |
| * Signature: (Lorg/apache/harmony/awt/gl/font/LinuxFont;Ljava/lang/String;)J |
| * Initializes native Xft font object from xlfd string and returns font handle, |
| * also sets font type to the font peer parameter. If font |
| * that is described by the given xlfd doesn't exist onto a system returned value |
| * is null. NullPointerException is thrown if there are errors in native code. |
| */ |
| JNIEXPORT jlong JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_initializeFontFromFP(JNIEnv *env, jclass jobj, jobject linuxFont, jstring jXLFD, jint size){ |
| |
| jclass cls; |
| jfieldID fid; |
| jmethodID mid; |
| jboolean iscopy; |
| |
| const char* xlfd; |
| Display *dpy; |
| int scr; |
| XftFont *xftFnt; |
| int font_type = FONT_TYPE_UNDEF; |
| FT_Face face; |
| |
| char **fn; |
| int n = 0; |
| int buf_size; |
| char *buffer; |
| |
| XftPattern *pattern; |
| XftPattern *matchPattern; |
| XftResult result; |
| |
| // Initialize part |
| cls = (*env)->GetObjectClass(env, linuxFont); |
| |
| /* get display value */ |
| fid=(*env)->GetFieldID(env, cls, "display", "J"); |
| if (fid == 0) { |
| (*env)->ExceptionDescribe(env); |
| (*env)->ExceptionClear(env); |
| return (jlong)(IDATA)NULL; |
| } |
| dpy = (Display *)(long)(*env)->GetLongField(env, linuxFont, fid); |
| |
| if (dpy == NULL){ |
| throwNPException(env, "Cannot connect to XServer"); |
| return (jlong)(IDATA)NULL; |
| } |
| |
| xlfd = (*env)->GetStringUTFChars(env, jXLFD, &iscopy); |
| buf_size = (*env)->GetStringLength(env, jXLFD) + 8; |
| buffer = (char *)malloc(buf_size); |
| |
| snprintf(buffer, buf_size, xlfd, (int)((double)(size*10) / 96 * 72)); |
| (*env)->ReleaseStringUTFChars(env, jXLFD, xlfd); |
| |
| /* get screen value */ |
| fid=(*env)->GetFieldID(env, cls, "screen", "I"); |
| if (fid == 0) { |
| (*env)->ExceptionDescribe(env); |
| (*env)->ExceptionClear(env); |
| free(buffer); |
| return (jlong)(IDATA)NULL; |
| } |
| scr = (*env)->GetIntField(env, linuxFont, fid); |
| |
| /* check if there any fonts with specified xlfd structure */ |
| fn = XListFonts( dpy, buffer, 10, &n ); |
| if (fn != NULL){ |
| XFreeFontNames(fn); |
| } |
| |
| if (n == 0){ |
| free(buffer); |
| return (jlong)(IDATA)NULL; |
| } |
| |
| /* Xft part */ |
| /* Create xlfd pattern */ |
| pattern = XftXlfdParse(buffer, False, True); |
| |
| /* We set antialias mode for simple text rendering without antialiasing */ |
| if (!XftPatternAddBool(pattern, XFT_ANTIALIAS, False)){ |
| throwNPException(env, "Error during adding font antialias set to false to XFTPattern structure"); |
| } |
| |
| if (!XftPatternAddBool (pattern, XFT_RENDER, True)){ |
| throwNPException(env, "Error during adding font RENDER set to true to XFTPattern structure"); |
| } |
| |
| |
| if (!XftPatternAddBool (pattern, FC_AUTOHINT, True)){ |
| throwNPException(env, "Error during adding font autohinting set to false to XFTPattern structure"); |
| } |
| |
| |
| matchPattern = XftFontMatch (dpy, scr, pattern, &result); |
| |
| #ifdef DEBUG |
| printf ("Pattern "); |
| FcPatternPrint (pattern); |
| if (matchPattern) |
| { |
| printf ("Match "); |
| FcPatternPrint (matchPattern); |
| } |
| else { |
| printf ("No Match\n"); |
| } |
| #endif // DEBUG |
| |
| XftPatternDestroy (pattern); |
| |
| if (!matchPattern){ |
| XftPatternDestroy (matchPattern); |
| return (long)NULL; |
| } |
| |
| xftFnt = XftFontOpenPattern (dpy, matchPattern); |
| |
| if (!xftFnt){ |
| XftPatternDestroy (matchPattern); |
| return (long)NULL; |
| } |
| |
| free(buffer); |
| |
| if (!xftFnt){ |
| return (long)NULL; |
| } |
| |
| face = XftLockFace(xftFnt); |
| |
| if ((face->face_flags & FT_FACE_FLAG_SCALABLE) && |
| !(face->face_flags & FT_FACE_FLAG_FIXED_SIZES)){ |
| if (face->face_flags & FT_FACE_FLAG_SFNT){ |
| font_type = FONT_TYPE_TT; |
| } else { |
| font_type = FONT_TYPE_T1; |
| } |
| } |
| XftUnlockFace(xftFnt); |
| |
| |
| if (font_type == FONT_TYPE_UNDEF){ |
| XftFontClose (dpy, xftFnt); |
| return (jlong)(IDATA)NULL; |
| } |
| |
| /* Set Font type in LinuxFont object (upcall) */ |
| mid=(*env)->GetMethodID(env, cls, "setFontType", "(I)V"); |
| |
| if (mid == 0) { |
| #ifdef DEBUG |
| printf("Can't find \"setFontType\" method"); |
| #endif // DEBUG |
| (*env)->ExceptionDescribe(env); |
| (*env)->ExceptionClear(env); |
| return (jlong)(IDATA)NULL; |
| } |
| |
| (*env)->CallVoidMethod(env, linuxFont, mid, font_type); |
| |
| if((*env)->ExceptionOccurred(env)) { |
| #ifdef DEBUG |
| printf("Error occured when calling \"setFontType\" method"); |
| #endif // DEBUG |
| (*env)->ExceptionDescribe(env); |
| (*env)->ExceptionClear(env); |
| return (jlong)(IDATA)NULL; |
| } |
| |
| return (long)xftFnt; |
| |
| } |
| |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: getNumGlyphsNative |
| * Signature: (J)I |
| * Returns number of glyphs in specified XftFont if success. |
| */ |
| JNIEXPORT jint JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_getNumGlyphsNative(JNIEnv *env, jclass obj, jlong fnt){ |
| |
| jint numGlyphs = 0; |
| XftFont *xftFnt = (XftFont *)(long)fnt; |
| FT_Face face; |
| |
| if(!xftFnt){ |
| return 0; |
| } |
| face = XftLockFace(xftFnt); |
| |
| if(!face) |
| return 0; |
| numGlyphs = face->num_glyphs; |
| |
| #ifdef DEBUG |
| printf("Num glyphs = %d\n", numGlyphs); |
| #endif /* DEBUG */ |
| |
| XftUnlockFace(xftFnt); |
| |
| |
| return numGlyphs; |
| |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: canDisplayCharNative |
| * Signature: (JC)Z |
| * Returns true, if XftFont object can display specified char. |
| */ |
| JNIEXPORT jboolean JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_canDisplayCharNative(JNIEnv *env, jclass obj, jlong fnt, jchar c){ |
| |
| jboolean canDisplay = 0; |
| |
| /* TODO: implement method - or we can use getGlyphCode results to find out, |
| * whether we can display char or not. |
| */ |
| |
| return canDisplay; |
| |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: getFamilyNative |
| * Signature: (J)Ljava/lang/String; |
| * Returns family name of the XftFont object. |
| */ |
| JNIEXPORT jstring JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_getFamilyNative(JNIEnv *env, jclass obj, jlong fnt){ |
| |
| XftFont *xftFnt = (XftFont *)(long)fnt; |
| |
| jstring familyName = NULL; |
| char* family; |
| |
| if (XftPatternGetString (xftFnt->pattern, XFT_FAMILY, 0, &family) != XftResultMatch){ |
| throwNPException(env, "Can not get font family value"); |
| } |
| |
| familyName = (*env)->NewStringUTF(env, family); |
| |
| return familyName; |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: getFontNameNative |
| * Signature: (J)Ljava/lang/String; |
| * Returns face name of the XftFont object. |
| */ |
| JNIEXPORT jstring JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_getFontNameNative(JNIEnv *env, jclass obj, jlong fnt){ |
| |
| // !! at the moment only EN locale font names used |
| jstring faceName = NULL; |
| XftFont *xftFnt = (XftFont *)(long)fnt; |
| FT_Face face; |
| const int BUF_SIZE = 64; |
| char name[BUF_SIZE]; |
| |
| if(!xftFnt){ |
| return 0; |
| } |
| face = XftLockFace(xftFnt); |
| |
| if(!face) |
| return 0; |
| |
| snprintf(name, BUF_SIZE, "%s %s", face->family_name, face->style_name); |
| |
| #ifdef DEBUG |
| printf("Face name = %s\n", name); |
| #endif // DEBUG |
| |
| XftUnlockFace(xftFnt); |
| |
| |
| faceName = (*env)->NewStringUTF(env, name); |
| |
| return faceName; |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: getFontPSNameNative |
| * Signature: (J)Ljava/lang/String; |
| * Returns XftFont's postscript name. |
| * Returned value is the name of the font in system default locale or |
| * for english langid if there is no results for default locale settings. |
| */ |
| JNIEXPORT jstring JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_getFontPSNameNative(JNIEnv *env, jclass obj, jlong fnt){ |
| |
| XftFont *xftFnt = (XftFont *)(long)fnt; |
| FT_Face face; |
| const char* name; |
| jstring psName; |
| |
| if(!xftFnt){ |
| return 0; |
| } |
| face = XftLockFace(xftFnt); |
| |
| if(!face) |
| return 0; |
| |
| name = FT_Get_Postscript_Name(face); |
| #ifdef DEBUG |
| printf("PostScript name = %s\n", name); |
| #endif /* DEBUG */ |
| |
| |
| psName = (*env)->NewStringUTF(env, name); |
| |
| XftUnlockFace(xftFnt); |
| |
| |
| return psName; |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: pFontFree |
| * Signature: (JJ)V |
| * Disposes XftFont object. |
| */ |
| JNIEXPORT void JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_pFontFree(JNIEnv *env, jclass obj, jlong fnt, jlong display){ |
| |
| Display *dpy = (Display *)(long)display; |
| XftFont *xftFnt = (XftFont *)(long)fnt; |
| if(xftFnt){ |
| XftFontClose (dpy, xftFnt); |
| } |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: getItalicAngleNative |
| * Signature: (JI)F |
| * Returns tangent of Italic angle of given Font. |
| * Returned value is null and NullPointerException is thrown if there is Xft error. |
| */ |
| JNIEXPORT jfloat JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_getItalicAngleNative(JNIEnv *env, jclass obj, jlong fnt, int fontType){ |
| |
| jfloat italicAngle = 0.0; |
| XftFont *xftFnt = (XftFont *)(long)fnt; |
| FT_Face face; |
| #if HAS_FREETYPE_INTERNAL |
| TT_Face tt_face; |
| #endif |
| TT_HoriHeader* hh; |
| float rise; |
| float run; |
| PS_FontInfoRec afont_info; |
| FT_Error err; |
| double pi = 3.1415926535; |
| |
| if(!xftFnt){ |
| return 0; |
| } |
| face = XftLockFace(xftFnt); |
| |
| if(!face){ |
| return 0; |
| } |
| if (fontType == FONT_TYPE_TT){ |
| #if HAS_FREETYPE_INTERNAL |
| tt_face = (TT_Face)face; |
| hh = &(tt_face->horizontal); |
| #else |
| hh = (TT_HoriHeader*)FT_Get_Sfnt_Table(face, ft_sfnt_hhea); |
| #endif |
| rise = (float)hh->caret_Slope_Rise; |
| run = (float)hh->caret_Slope_Run; |
| italicAngle = run / rise ; |
| } else { |
| err = FT_Get_PS_Font_Info( face, &afont_info); |
| if (err){ |
| XftUnlockFace(xftFnt); |
| |
| return italicAngle; |
| } |
| italicAngle = tan(((double)afont_info.italic_angle * pi) / 180); |
| } |
| |
| #ifdef DEBUG |
| printf("Italic angle value = %f\n", italicAngle); |
| #endif /* DEBUG */ |
| |
| XftUnlockFace(xftFnt); |
| |
| |
| return italicAngle; |
| |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: getFonts |
| * Signature: ()[Ljava/lang/String; |
| * Returns an array of available system fonts names. |
| * In case of errors NullPointerException is thrown. |
| */ |
| JNIEXPORT jobjectArray JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_getFonts(JNIEnv *env, jclass obj){ |
| |
| jobjectArray fonts; |
| |
| XftObjectSet *os = 0; |
| XftPattern *xftPattern; |
| int len; |
| XftFontSet *fs; |
| int j, i; |
| int numFonts; |
| const int BUF_SIZE = 128; |
| FcChar8 font[BUF_SIZE]; |
| FcChar8 *family; |
| FcChar8 *style; |
| char** fontList; |
| char* fstr="%s-%s-%d"; // "family name"-"styleName"-"style" |
| int fontStyle; |
| int weight; |
| int slant; |
| jclass strClass; |
| jstring initStr; |
| |
| /* Create pattern */ |
| xftPattern = XftPatternCreate(); |
| |
| if (!XftPatternAddBool (xftPattern, XFT_OUTLINE, True)){ |
| throwNPException(env, "Outline value can't be added to XftPattern"); |
| } |
| |
| /* Just need to add which fields you want to list */ |
| os = XftObjectSetBuild (XFT_FAMILY, XFT_STYLE, XFT_SLANT, XFT_WEIGHT, (char *) 0); |
| |
| fs = FcFontList (0, xftPattern, os); |
| |
| XftObjectSetDestroy (os); |
| |
| if(xftPattern){ |
| XftPatternDestroy(xftPattern); |
| } |
| |
| if (!fs){ |
| throwNPException(env, "Font list can't be created"); |
| return NULL; |
| } else { |
| numFonts = fs->nfont; |
| fontList = (char** )malloc(numFonts * sizeof(char *)); |
| |
| for (j = 0; j < numFonts; j++){ |
| if (XftPatternGetString (fs->fonts[j], XFT_FAMILY, 0, &family) != XftResultMatch){ |
| throwNPException(env, "Couldn't get font family name"); |
| } |
| |
| #ifdef DEBUG |
| { |
| FcChar8* font = FcNameUnparse (fs->fonts[j]); |
| printf ("%s\n", font); |
| free(font); |
| } |
| #endif /* DEBUG */ |
| |
| if (XftPatternGetString (fs->fonts[j], XFT_STYLE, 0, &style) != XftResultMatch) { |
| throwNPException(env, "Couldn't get font style name"); |
| } |
| |
| if (XftPatternGetInteger (fs->fonts[j], XFT_SLANT, 0, &slant) != XftResultMatch) { |
| throwNPException(env, "Couldn't get font slant"); |
| } |
| |
| if (XftPatternGetInteger (fs->fonts[j], XFT_WEIGHT, 0, &weight) != XftResultMatch) { |
| throwNPException(env, "Couldn't get font weight"); |
| } |
| |
| if (weight <= XFT_WEIGHT_MEDIUM) { |
| fontStyle = FONT_PLAIN; |
| } else { |
| fontStyle = FONT_BOLD; |
| } |
| |
| if (slant != XFT_SLANT_ROMAN){ |
| fontStyle |= FONT_ITALIC; |
| } |
| |
| len = snprintf((char *)font, BUF_SIZE, fstr, family, style, fontStyle); |
| |
| if (len < 0){ |
| len = BUF_SIZE; |
| } |
| |
| fontList[j] = (char*)malloc(sizeof(char) * (len+1)); |
| strncpy(fontList[j], (char *)font, len); |
| fontList[j][len] = 0; |
| } |
| XftFontSetDestroy (fs); |
| } |
| |
| |
| strClass = (*env)->FindClass(env, "java/lang/String"); |
| initStr = (*env)->NewStringUTF(env, ""); |
| |
| fonts = (jobjectArray)(*env)->NewObjectArray(env, |
| numFonts, |
| strClass, |
| initStr); |
| |
| if (fonts == NULL){ |
| for (i = 0;i < numFonts;i++){ |
| free(fontList[i]); |
| } |
| free(fontList); |
| |
| throwNPException(env, "Not enough memory to create families list"); |
| return (jobjectArray)NULL; |
| } |
| |
| for (i = 0;i < numFonts;i++){ |
| (*env)->SetObjectArrayElement(env, fonts,i,(*env)->NewStringUTF(env, fontList[i])); // number of chars == length of string -1 |
| free(fontList[i]); |
| } |
| free(fontList); |
| |
| return fonts; |
| |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: getNativeLineMetrics |
| * Signature: (JIZZI)[F |
| * Returns array of values of font metrics corresponding to the given XftFont |
| * font object. NullPointerException is thrown in case of errors. |
| */ |
| JNIEXPORT jfloatArray JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_getNativeLineMetrics(JNIEnv *env, jclass obj, jlong fnt, jint fontHeight, jboolean isAntialiased, jboolean usesFractionalMetrics, jint fontType){ |
| jfloatArray metrics; |
| jfloat values[17]; |
| |
| XftFont *xftFnt = (XftFont *)(long)fnt; |
| FT_Face face; |
| TT_OS2* os2; |
| #if HAS_FREETYPE_INTERNAL |
| TT_Face tt_face; |
| #endif |
| int units_per_EM; |
| FT_Size_Metrics size_metrics; |
| FT_Size size; |
| float mltpl; |
| |
| if (!xftFnt){ |
| return NULL; |
| } |
| #ifdef DEBUG |
| printf("XFT Ascent = %d\n", xftFnt->ascent); |
| printf("XFT Descent = %d\n", xftFnt->descent); |
| printf("XFT Height = %d\n", xftFnt->height); |
| #endif /* DEBUG */ |
| |
| face = XftLockFace(xftFnt); |
| |
| if(!face){ |
| return NULL; |
| } |
| units_per_EM = face->units_per_EM; |
| if (units_per_EM == 0){ |
| // throwNPException(env, "Units per EM value is equals to zero"); |
| XftUnlockFace(xftFnt); |
| |
| |
| return NULL; |
| } |
| values[16] = units_per_EM; |
| mltpl = (float)fontHeight / units_per_EM; |
| values[0] = (float)(face->ascender) * mltpl; // Ascent value |
| values[1] = (float)(face->descender) * mltpl; // -Descent value |
| values[2] = (float)(face->height) * mltpl - values[0] + values[1]; // External Leading value |
| values[3] = (float)(face->underline_thickness) * mltpl; // Underline size value |
| values[4] = (float)(face->underline_position) * mltpl; // Underline position value |
| |
| if (fontType == FONT_TYPE_TT){ |
| #if HAS_FREETYPE_INTERNAL |
| tt_face = (TT_Face)face; |
| os2 = &(tt_face->os2); |
| #else |
| os2 = (TT_OS2*)FT_Get_Sfnt_Table(face, ft_sfnt_os2); |
| #endif |
| values[5] = (float)(os2->yStrikeoutSize) * mltpl; // Strikeout size value |
| values[6] = (float)(os2->yStrikeoutPosition) * mltpl; // Strikeout position value |
| } else { |
| values[5] = values[3]; |
| // !!Workaround: for Type1 fonts strikethrough position = (-ascent+descent)/2 |
| values[6] = (-values[0] - values[1])/2; |
| } |
| |
| values[7] = (float)(face->bbox.xMax - face->bbox.xMin)* mltpl; // Max char width |
| |
| size = face->size; |
| size_metrics = size->metrics; |
| values[8] = (int)size_metrics.ascender >> 6; // Ascent value |
| values[9] = (int)size_metrics.descender >> 6; // Descent value |
| values[10] = (int)(size_metrics.height >> 6) - values[8] + values[9]; // External Leading value |
| values[11] = (int)values[3]; // Underline size value |
| values[12] = (int)values[4]; // Underline position value |
| |
| values[13] = (int)values[5]; // Strikeout size value |
| values[14] = (int)values[6]; // Strikeout sposition value |
| |
| values[15] = (int)values[7]; // Max char width |
| |
| #ifdef DEBUG |
| printf("Ascent = %f\n", values[0]); |
| printf("Descent = %f\n", values[1]); |
| printf("External Leading = %f\n", values[2]); |
| printf("Underline size = %f\n", values[3]); |
| printf("Underline position = %f\n", values[4]); |
| printf("Strikeout size = %f\n", values[5]); |
| printf("Strikeout position = %f\n", values[6]); |
| printf("Max char width = %f\n", values[7]); |
| |
| printf("Pixel Ascent = %f\n", values[8]); |
| printf("Pixel Descent = %f\n", values[9]); |
| printf("Pixel External Leading = %f\n", values[10]); |
| printf("Pixel Underline size = %f\n", values[11]); |
| printf("Pixel Underline position = %f\n", values[12]); |
| printf("Pixel Strikeout size = %f\n", values[13]); |
| printf("Pixel Strikeout position = %f\n", values[14]); |
| printf("Pixel Max char width = %f\n", values[15]); |
| |
| #endif /* DEBUG */ |
| |
| XftUnlockFace(xftFnt); |
| |
| |
| metrics = (*env)->NewFloatArray(env, 17); |
| (*env)->SetFloatArrayRegion(env, metrics, 0, 17, values); |
| |
| return metrics; |
| |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: getGlyphInfoNative |
| * Signature: (JCI)[F |
| * Returns array of glyph metrics values for the specified character |
| * null is returned and NullPointerException is thrown in case of FreeType |
| * errors. |
| */ |
| JNIEXPORT jfloatArray JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_getGlyphInfoNative(JNIEnv *env, jclass obj, jlong fnt, jchar chr, jint fontHeight){ |
| |
| jfloatArray results = 0; |
| jfloat values[11]; |
| |
| XftFont *font = (XftFont *)(long)fnt; |
| const float CONST_96_DIV_76 = (float)96 / 72; |
| float mltpl; |
| FT_Face face; |
| FT_GlyphSlot glyphslot; |
| FT_Glyph_Metrics metrics; |
| |
| FT_Pos width; /* glyph width */ |
| FT_Pos height; /* glyph height */ |
| |
| FT_Pos horiBearingX; /* left side bearing in horizontal layouts */ |
| FT_Pos horiBearingY; /* top side bearing in horizontal layouts */ |
| FT_Pos horiAdvance; /* advance width for horizontal layout */ |
| |
| FT_Pos vertBearingX; /* left side bearing in vertical layouts */ |
| FT_Pos vertBearingY; /* top side bearing in vertical layouts */ |
| FT_Pos vertAdvance; /* advance height for vertical layout */ |
| int units_per_EM; |
| FT_Error error; |
| |
| if (!font){ |
| return results; |
| } |
| face = XftLockFace(font); |
| |
| if(!face){ |
| return results; |
| } |
| units_per_EM = face->units_per_EM; |
| |
| error = FT_Load_Char(face, (FT_ULong)chr, FT_LOAD_RENDER | FT_LOAD_TARGET_MONO); |
| |
| if(error){ |
| // throwNPException(env, "FT_Load_char : FreeType error"); |
| XftUnlockFace(font); |
| |
| return NULL; |
| } |
| |
| glyphslot = face->glyph; |
| metrics = glyphslot->metrics; |
| |
| width = metrics.width; /* glyph width */ |
| height = metrics.height; /* glyph height */ |
| |
| horiBearingX = metrics.horiBearingX; /* left side bearing in horizontal layouts */ |
| horiBearingY = metrics.horiBearingY; /* top side bearing in horizontal layouts */ |
| horiAdvance = metrics.horiAdvance; /* advance width for horizontal layout */ |
| |
| vertBearingX = metrics.vertBearingX; /* left side bearing in vertical layouts */ |
| vertBearingY = metrics.vertBearingY; /* top side bearing in vertical layouts */ |
| vertAdvance = metrics.vertAdvance; /* advance height for vertical layout */ |
| |
| /* Multyplier to obtain proper values in pixels of the metrics */ |
| mltpl = CONST_96_DIV_76 / units_per_EM; |
| |
| #ifdef DEBUG |
| |
| printf("\n glyph metrics char = %d: : \n", chr); |
| printf("width = %d : height = %d \n", (int)width >> 6, (int)height >> 6); |
| printf("ghoriBearingX = %d : ghoriBearingY = %d \n", horiBearingX >> 6, horiBearingY>> 6); |
| printf("gvertBearingX = %d : gvertBearingY = %d \n", vertBearingX>> 6, vertBearingY>> 6); |
| printf("ghoriAdvance = %d : gvertAdvance = %d \n", horiAdvance>> 6, vertAdvance>> 6); |
| #endif /* DEBUG*/ |
| |
| XftUnlockFace(font); |
| |
| values[0] = (horiBearingX >> 6) + (horiBearingX & 0x3F)/64; // Glyph Precise Bounds : X |
| values[1] = (horiBearingY >> 6) + (horiBearingY & 0x3F)/64;// Glyph Precise Bounds : Y |
| values[2] = (horiAdvance >> 6) + (horiAdvance & 0x3F)/64; // Precise AdvanceX |
| values[3] = 0;//(vertAdvance >> 6) + (vertAdvance & 0x3F)/64; // Precise AdvanceY ?= Ascent+Descent |
| values[4] = (width >> 6) + (width & 0x3F)/64; // Glyph Precise Bounds : width |
| values[5] = (height >> 6) + (height & 0x3F)/64; // Glyph Precise Bounds : height |
| |
| results = (*env)->NewFloatArray(env, 6); |
| (*env)->SetFloatArrayRegion(env, results, 0, 6, values); |
| |
| return results; |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: getGlyphPxlInfoNative |
| * Signature: (JJC)[I |
| * Returns array of glyph metrics values in pixels for the specified character |
| * null is returned and NullPointerException is thrown in case of FreeType errors. |
| */ |
| JNIEXPORT jintArray JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_getGlyphPxlInfoNative(JNIEnv *env, jclass obj, jlong display, jlong fnt, jchar chr){ |
| |
| Display * dpy = (Display *)(long)display; |
| jintArray metricsArr = NULL; |
| jint values[6]; |
| XftFont *font = (XftFont *)(long)fnt; |
| XGlyphInfo extents; |
| FT_Face face; |
| FT_BBox acbox; |
| FT_Glyph glyph; |
| FT_Error error; |
| |
| if (!font){ |
| return metricsArr; |
| } |
| face = XftLockFace(font); |
| |
| if (!face){ |
| return metricsArr; |
| } |
| error = FT_Load_Char(face, (FT_ULong)chr, FT_LOAD_RENDER | FT_LOAD_TARGET_MONO); |
| |
| if(error){ |
| XftUnlockFace(font); |
| |
| return metricsArr; |
| } |
| |
| error = FT_Get_Glyph( face->glyph, &glyph ); |
| |
| if(error){ |
| throwNPException(env, "getGlyphPxlInfoNative 1 : FreeType error"); |
| XftUnlockFace(font); |
| |
| return metricsArr; |
| } |
| |
| FT_Glyph_Get_CBox(glyph, |
| 2, //FT_GLYPH_BBOX_PIXELS |
| &acbox); |
| FT_Done_Glyph(glyph); |
| XftUnlockFace(font); |
| |
| |
| XftTextExtents16 (dpy, |
| font, |
| &chr, |
| 1, |
| &extents); |
| #ifdef DEBUG |
| |
| printf("char = %d; y = %d; x = %d; height = %d; width = %d; advX = %d; advY = %d \n", |
| chr, extents.y, extents.x, extents.height, extents.width, extents.xOff, extents.yOff); |
| #endif // DEBUG |
| |
| values[0] = - extents.x ; // Glyph Pixels Bounds : X |
| values[1] = extents.y ; // Glyph Pixels Bounds : Y |
| values[2] = extents.xOff; // Pixels AdvanceX |
| values[3] = extents.yOff; // Pixels AdvanceY ?= Ascent+Descent |
| values[4] = acbox.xMax-acbox.xMin; // Glyph Pixels Bounds : width |
| values[5] = acbox.yMax-acbox.yMin; // Glyph Pixels Bounds : height |
| |
| metricsArr = (*env)->NewIntArray(env, 6); |
| (*env)->SetIntArrayRegion(env, metricsArr, 0, 6, values); |
| |
| return metricsArr; |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: getGlyphCodesNative |
| * Signature: (JLjava/lang/String;I)[I |
| * Returns glyphs code corresponding to the characters in String specified, null |
| * is returned if failure. NullPointerException is thrown in case of Display |
| * is null. |
| */ |
| JNIEXPORT jintArray JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_getGlyphCodesNative(JNIEnv *env, jclass obj, jlong fnt, jstring str, jint len){ |
| |
| jintArray glyphsCodes = NULL; |
| |
| // TODO: implement method |
| |
| return glyphsCodes; |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: getGlyphCodeNative |
| * Signature: (JCJ)I |
| * Returns glyph code corresponding to the specified character, null is |
| * returned if failure. NullPointerException is thrown in case of Display is null. |
| */ |
| JNIEXPORT jint JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_getGlyphCodeNative(JNIEnv *env, jclass obj, jlong fnt, jchar chr, jlong display){ |
| |
| jint code = 0xFFFF; |
| Display *dpy = (Display *)(long)display; |
| XftFont *font = (XftFont *)(long)fnt; |
| |
| if (!font){ |
| return 0xFFFF; |
| } |
| |
| code = XftCharIndex (dpy, font, chr); |
| |
| return (code == 0) ? 0xFFFF : code; |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: RemoveFontResource |
| * Signature: (Ljava/lang/String;)I |
| * Description: Re-cache ~/.fonts directory, after temporary font-file is deleted. |
| */ |
| JNIEXPORT jint JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_RemoveFontResource(JNIEnv *env, jclass obj, jstring fName){ |
| |
| FcChar8* dirName; |
| jboolean iscopy; |
| FcConfig *config; |
| FcFontSet *set; |
| FcStrSet *subdirs; |
| FcStrList *list; |
| jboolean result = TRUE; |
| |
| /* get current congif */ |
| config = FcConfigGetCurrent(); |
| |
| if (!config){ |
| return FALSE; |
| } |
| |
| dirName = (FcChar8*)((*env)->GetStringUTFChars(env, fName, &iscopy)); |
| |
| list = FcConfigGetConfigDirs (config); |
| set = FcFontSetCreate (); |
| subdirs = FcStrSetCreate (); |
| |
| /* scan dir for changes */ |
| result = result && FcDirScan (set, subdirs, 0, FcConfigGetBlanks (config), dirName, FcFalse); |
| |
| /* save changes to the config */ |
| result = result && FcDirSave (set, subdirs, dirName); |
| |
| /* rebuild fonts list */ |
| FcConfigBuildFonts(config); |
| |
| FcFontSetDestroy (set); |
| FcStrSetDestroy (subdirs); |
| FcStrListDone (list); |
| |
| (*env)->ReleaseStringUTFChars(env, fName, (char *)dirName); |
| |
| return result; |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: NativeInitGlyphBitmap |
| * Signature: (JC)J |
| * Returns pointer to FreeType FT_Bitmap that represents bitmap |
| * of the character specified or 0 if failures in native code. |
| */ |
| JNIEXPORT jlong JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_NativeInitGlyphBitmap(JNIEnv *env, jclass jobj, jlong fnt, jchar chr){ |
| |
| XftFont *font = (XftFont *)(long)fnt; |
| FT_Glyph glyph; |
| FT_BitmapGlyph glyph_bitmap; |
| int size; |
| |
| FT_Error error; |
| FT_Face face; |
| FT_Bitmap ft_bitmap; |
| |
| if (!font){ |
| return 0; |
| } |
| face = XftLockFace(font); |
| |
| if (!face){ |
| return 0; |
| } |
| |
| error = FT_Load_Char(face, (FT_ULong)chr, FT_LOAD_RENDER | FT_LOAD_TARGET_MONO); |
| |
| if(error){ |
| throwNPException(env, "NativeInitGlyphBitmap : FreeType error"); |
| |
| XftUnlockFace(font); |
| |
| return (jlong)(IDATA)NULL; |
| } |
| |
| error = FT_Get_Glyph( face->glyph, &glyph ); |
| |
| if(error){ |
| // throwNPException(env, "NativeInitGlyphBitmap 1 : FreeType error"); |
| XftUnlockFace(font); |
| |
| return (jlong)(IDATA)NULL; |
| } |
| // convert to a bitmap (default render mode + destroy old) |
| if ( glyph->format != FT_GLYPH_FORMAT_BITMAP ) { |
| error = FT_Glyph_To_Bitmap( &glyph, (FT_LOAD_RENDER | FT_LOAD_TARGET_MONO), |
| 0, 1 ); |
| if ( error ){ |
| // glyph unchanged |
| FT_Done_Glyph( glyph ); |
| XftUnlockFace(font); |
| return (jlong)(IDATA)NULL; |
| } |
| } |
| |
| glyph_bitmap = (FT_BitmapGlyph)(glyph); |
| ft_bitmap = glyph_bitmap->bitmap; |
| |
| |
| GlyphBitmap *gbmp = (GlyphBitmap *)malloc(sizeof(GlyphBitmap)); |
| gbmp->left = glyph_bitmap->left; |
| gbmp->top = glyph_bitmap->top; |
| gbmp->bitmap.rows = ft_bitmap.rows; |
| gbmp->bitmap.width = ft_bitmap.width; |
| gbmp->bitmap.pitch = ft_bitmap.pitch; |
| gbmp->bitmap.buffer = malloc(ft_bitmap.rows * ft_bitmap.pitch); |
| size= ft_bitmap.rows * ft_bitmap.pitch; |
| memcpy(gbmp->bitmap.buffer, ft_bitmap.buffer, size); |
| |
| FT_Done_Glyph(glyph); |
| XftUnlockFace(font); |
| return (long)gbmp; |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: NativeFreeGlyphBitmap |
| * Signature: (J)V |
| * Disposes GlyphBitmap memory block. |
| */ |
| JNIEXPORT void JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_NativeFreeGlyphBitmap(JNIEnv *env, jclass jobj, |
| jlong bitmap){ |
| GlyphBitmap *gbmp = (GlyphBitmap *)(long)bitmap; |
| free(gbmp->bitmap.buffer); |
| free(gbmp); |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: drawStringNative |
| * Signature: (JJJJII[CIJ)V |
| * Draws text on XftDraw with specified parameters. |
| */ |
| JNIEXPORT void |
| JNICALL Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_drawStringNative |
| (JNIEnv *env, jclass jobj, jlong xftDraw, jlong display, |
| jlong colormap, jlong font, jint x, jint y, jcharArray str, jint len, jlong color){ |
| |
| jboolean iscopy; |
| |
| XftDraw *draw = (XftDraw *)(long)xftDraw; |
| Display *dpy = (Display *)(long)display; |
| Colormap cmap = (Colormap)colormap; |
| XftFont *fnt = (XftFont *)(long)font; |
| XftColor xftColor; |
| XRenderColor renderColor; |
| XftChar16 *string; |
| XColor *xcolor = (XColor *)(long)color; |
| |
| XftDrawSetSubwindowMode(draw, IncludeInferiors/*mode*/); |
| |
| string = (XftChar16 *)(*env)->GetCharArrayElements(env, str, &iscopy); |
| |
| /* Creating XRenderColor structure */ |
| renderColor.red = xcolor->red; |
| renderColor.green = xcolor->green; |
| renderColor.blue = xcolor->blue; |
| renderColor.alpha = 0xFFFF; |
| |
| /* Creating XftColor structure */ |
| if (XAllocColor (dpy, cmap, xcolor)){ |
| xftColor.pixel = xcolor->pixel; |
| } |
| xftColor.color.red = renderColor.red; |
| xftColor.color.green = renderColor.green; |
| xftColor.color.blue = renderColor.blue; |
| xftColor.color.alpha = renderColor.alpha; |
| |
| XftDrawString16 (draw, |
| &xftColor, |
| fnt, |
| x, |
| y, |
| string, |
| len); |
| |
| (*env)->ReleaseCharArrayElements(env, str, string, iscopy); |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: createXftDrawNative |
| * Signature: (JJJ)J |
| * Returns XftDraw handle created from specified parameters. |
| */ |
| JNIEXPORT jlong JNICALL Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_createXftDrawNative |
| (JNIEnv *env, jclass jobj, jlong display, jlong drawable, jlong visual){ |
| |
| XftDraw *draw; |
| Display *dpy = (Display *)(long)display; |
| Drawable drwbl = (Drawable)drawable; |
| |
| /* Creating xftDraw structure */ |
| draw = XftDrawCreate (dpy, drwbl, (Visual *)(long)visual, 0); |
| |
| return (long)draw; |
| |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: xftDrawSetSubwindowModeNative |
| * Signature: (JI)V |
| * Set new subwindow mode to XftDraw object. |
| */ |
| JNIEXPORT void JNICALL Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_xftDrawSetSubwindowModeNative |
| (JNIEnv *env, jclass jobj, jlong xftDraw, jint mode){ |
| |
| XftDraw *draw = (XftDraw *)(long)xftDraw; |
| |
| XftDrawSetSubwindowMode(draw, mode); |
| |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: XftDrawSetClipRectangles |
| * Signature: (JIIJI)Z |
| * Sets clipping rectangles in Xft drawable to the specified clipping rectangles. |
| */ |
| JNIEXPORT jboolean JNICALL Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_XftDrawSetClipRectangles |
| (JNIEnv *env, jclass jobj, jlong xftDraw, jint xOrigin, jint yOrigin, jlong rects, jint n){ |
| |
| XftDraw *draw = (XftDraw *)(long)xftDraw; |
| XRectangle *xrects = (XRectangle *)(long)rects; |
| |
| return XftDrawSetClipRectangles (draw, xOrigin, yOrigin, xrects, n); |
| |
| } |
| |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: freeXftDrawNative |
| * Signature: (J)V |
| * Destroys XftDraw object. |
| */ |
| JNIEXPORT void JNICALL Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_freeXftDrawNative |
| (JNIEnv *env, jclass jobj, jlong xftDraw){ |
| |
| XftDraw *draw = (XftDraw *)(long)xftDraw; |
| |
| XftDrawDestroy(draw); |
| } |
| |
| /* Initializes FreeType FT_Outline structure with the source FT_Outline data. */ |
| int createOutline(FT_Outline *outline, FT_Outline *srcOutline){ |
| int size; |
| outline->flags = srcOutline->flags | FT_OUTLINE_OWNER; |
| outline->n_points = srcOutline->n_points; |
| outline->n_contours = srcOutline->n_contours; |
| |
| size = srcOutline->n_points * sizeof(FT_Vector); |
| outline->points = (FT_Vector *)malloc(size); |
| if (!outline->points){ |
| return 0; |
| } |
| memcpy(outline->points, srcOutline->points, size); |
| |
| size = srcOutline->n_points * sizeof(char); |
| outline->tags = (char *)malloc(size); |
| if (!outline->tags){ |
| free(outline->points); |
| return 0; |
| } |
| memcpy(outline->tags, srcOutline->tags, size); |
| |
| size = srcOutline->n_contours * sizeof(short); |
| outline->contours = (short *)malloc(size); |
| if (!outline->contours){ |
| free(outline->points); |
| free(outline->tags); |
| return 0; |
| } |
| memcpy(outline->contours, srcOutline->contours, size); |
| |
| return 1; |
| } |
| |
| /* Disposes FreeType FT_Outline structure. */ |
| void freeOutline(FT_Outline *outline){ |
| free(outline->points); |
| free(outline->tags); |
| free(outline->contours); |
| |
| free(outline); |
| } |
| |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: getGlyphOutline |
| * Signature: (JC)J |
| * Returns pointer to the FreeType FT_Outline structure. |
| */ |
| JNIEXPORT jlong JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_getGlyphOutline(JNIEnv *env, jclass obj, jlong fnt, jchar chr){ |
| |
| XftFont *font = (XftFont *)(long)fnt; |
| FT_Face face; |
| FT_Error error; |
| FT_Outline *outline = NULL; |
| |
| if (!font){ |
| return 0; |
| } |
| face = XftLockFace(font); |
| |
| if(!face){ |
| return 0; |
| } |
| error = FT_Load_Char(face, (FT_ULong)chr, FT_LOAD_RENDER | FT_LOAD_TARGET_MONO); |
| |
| if(error){ |
| throwNPException(env, "getGlyphOutline : FreeType error"); |
| XftUnlockFace(font); |
| |
| return (jlong)(IDATA)NULL; |
| } |
| |
| if ((face->glyph->format & ft_glyph_format_outline) != 0){ |
| outline = (FT_Outline *)malloc(sizeof(FT_Outline)); |
| if (!createOutline(outline, &face->glyph->outline)){ |
| free(outline); |
| } |
| } |
| |
| XftUnlockFace(font); |
| |
| return (long)outline; |
| } |
| |
| /* |
| * Class: org_apache_harmony_awt_gl_font_LinuxNativeFont |
| * Method: freeGlyphOutline |
| * Signature: (JC)J |
| * Disposes FT_Outline memory block. |
| */ |
| JNIEXPORT void JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_freeGlyphOutline(JNIEnv *env, jclass obj, jlong j_outline){ |
| FT_Outline *outline = (FT_Outline *)(long)j_outline; |
| |
| freeOutline(outline); |
| } |
| |
| /* |
| * Returns desierd tag index from the list. |
| */ |
| int getTagIndex(Tag* tagList, int count, Tag value){ |
| int result = -1; |
| int i; |
| |
| for (i = 0; i < count; i++){ |
| if (* (DWORD *)tagList[i] == * (DWORD *)value){ |
| return result = i; |
| } |
| } |
| return result; |
| |
| } |
| |
| /* |
| * Returns an array of pairs of coordinates [x1, y1, x2, y2...] from |
| * FreeType FT_Vector structure. |
| */ |
| JNIEXPORT jfloatArray JNICALL Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_getPointsFromFTVector |
| (JNIEnv *env, jclass obj, jlong points, jint size){ |
| |
| jfloatArray flArray; |
| float * fpPoints = (float *)malloc(sizeof(float) * size * 2); |
| int i; |
| FT_Vector *ft_points = (FT_Vector *)(long)points; |
| for(i = 0; i < size; i++){ |
| fpPoints[i*2] = (float)((int)ft_points[i].x + 32)/64; |
| fpPoints[i*2 + 1] = (float)(-(int)ft_points[i].y + 32)/64; |
| } |
| |
| flArray=(*env)->NewFloatArray(env, size*2); |
| (*env)->SetFloatArrayRegion(env, flArray, 0, size*2, fpPoints); |
| free(fpPoints); |
| return flArray; |
| } |
| |
| /* Returns an array of extrametrics of the font. */ |
| JNIEXPORT jfloatArray JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_getExtraMetricsNative(JNIEnv *env, jclass obj, jlong fnt, jint fontHeight, jint fontType) { |
| |
| jfloatArray metrics; |
| jfloat values[9]; |
| |
| XftFont *xftFnt = (XftFont *)(long)fnt; |
| FT_Face face; |
| TT_OS2* os2; |
| #if HAS_FREETYPE_INTERNAL |
| TT_Face tt_face; |
| #endif |
| int units_per_EM; |
| float mltpl; |
| |
| if (!xftFnt){ |
| return NULL; |
| } |
| |
| face = XftLockFace(xftFnt); |
| |
| if(!face){ |
| return NULL; |
| } |
| units_per_EM = face->units_per_EM; |
| if (units_per_EM == 0){ |
| // throwNPException(env, "Units per EM value is equals to zero"); |
| XftUnlockFace(xftFnt); |
| |
| return NULL; |
| } |
| mltpl = (float)fontHeight / units_per_EM; |
| |
| if (fontType == FONT_TYPE_TT){ |
| #if HAS_FREETYPE_INTERNAL |
| tt_face = (TT_Face)face; |
| os2 = &(tt_face->os2); |
| #else |
| os2 = (TT_OS2*)FT_Get_Sfnt_Table(face, ft_sfnt_os2); |
| #endif |
| |
| values[0] = (float)(os2->xAvgCharWidth) * mltpl; // the average width of characters in the font |
| values[1] = (float)(os2->ySubscriptXSize) * mltpl; // horizontal size for subscripts |
| values[2] = (float)(os2->ySubscriptYSize) * mltpl; // vertical size for subscripts |
| values[3] = (float)(os2->ySubscriptXOffset) * mltpl; // horizontal offset for subscripts |
| values[4] = (float)(os2->ySubscriptYOffset) * mltpl; // vertical offset value for subscripts |
| values[5] = (float)(os2->ySuperscriptXSize) * mltpl; // horizontal size for superscripts |
| values[6] = (float)(os2->ySuperscriptYSize) * mltpl; // vertical size for superscripts |
| values[7] = (float)(os2->ySuperscriptXOffset) * mltpl; // horizontal offset for superscripts |
| values[8] = (float)(os2->ySuperscriptYOffset) * mltpl; // vertical offset for superscripts |
| } else { |
| values[0] = 0.0f; // the average width of characters in the font |
| values[1] = 0.7f * fontHeight; // horizontal size for subscripts |
| values[2] = 0.65f * fontHeight;; // vertical size for subscripts |
| values[3] = 0.0f; // horizontal offset for subscripts |
| values[4] = 0.15f * fontHeight; // vertical offset value for subscripts |
| values[5] = 0.7f * fontHeight; // horizontal size for superscripts |
| values[6] = 0.65f * fontHeight; // vertical size for superscripts |
| values[7] = 0.0f; // horizontal offset for superscripts |
| values[8] = 0.45 * fontHeight; // vertical offset for superscripts |
| } |
| XftUnlockFace(xftFnt); |
| |
| metrics = (*env)->NewFloatArray(env, 9); |
| (*env)->SetFloatArrayRegion(env, metrics, 0, 9, values); |
| |
| return metrics; |
| |
| } |
| |
| /* |
| * Getting antialiased font from existing font |
| */ |
| JNIEXPORT jlong JNICALL |
| Java_org_apache_harmony_awt_gl_font_LinuxNativeFont_getAntialiasedFont( |
| JNIEnv *env, jclass jobj, jlong font, jlong display, jboolean isAntialiasing){ |
| |
| XftFont *fnt = (XftFont *)(long)font; |
| Display *dpy = (Display *)(long)display; |
| |
| XftResult result; |
| XftPattern *mpattern = XftFontMatch(dpy, DefaultScreen(dpy),fnt->pattern,&result); |
| |
| XftPatternDel(mpattern, XFT_ANTIALIAS); |
| if (isAntialiasing) { |
| if (!XftPatternAddBool(mpattern, XFT_ANTIALIAS, True)) { |
| throwNPException(env, |
| "Error during adding font antialias set to true to XFTPattern structure"); |
| } |
| } |
| else { |
| if (!XftPatternAddBool(mpattern, XFT_ANTIALIAS, False)) { |
| throwNPException(env, |
| "Error during adding font antialias set to false to XFTPattern structure"); |
| } |
| } |
| |
| XftFont *aaFnt = XftFontOpenPattern(dpy, mpattern); |
| return (long)aaFnt; |
| } |
