/*

 * Copyright 1996-2005 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

/*

 * These routines are used for display string with multi font.

 */

#ifdef HEADLESS

    #error This file should not be included in headless library

#endif

#include <stdlib.h>

#include <string.h>

#include <math.h>

#include <ctype.h>

#include <jni.h>

#include <jni_util.h>

#include <jvm.h>

#ifndef XAWT

#include <Xm/Display.h>

#endif

#include "awt_Font.h"

#ifndef XAWT

#include "awt_Component.h"

#endif

#include "awt_MenuItem.h"

#include "awt_p.h"

#include "multi_font.h"

extern XFontStruct *loadFont(Display *, char *, int32_t);

extern struct FontIDs fontIDs;

extern struct PlatformFontIDs platformFontIDs;

extern struct MFontPeerIDs mFontPeerIDs;

/*

 * make string with str + string representation of num

 * This string is used as tag string of Motif Compound String and FontList.

 */

static void

makeTag(char *str, int32_t num, char *buf)

{

    int32_t len = strlen(str);

    strcpy(buf, str);

    buf[len] = '0' + num % 100;

    buf[len + 1] = '\0';

}

#ifndef XAWT

jobject

awtJNI_CreateAndSetGlobalRef(JNIEnv * env, jobject this)

{

    jobject gRef;

    gRef = (*env)->NewGlobalRef(env, this);

    JNU_SetLongFieldFromPtr(env, this, mComponentPeerIDs.jniGlobalRef, gRef);

    return gRef;

}

struct gRefStruct

{

    jobject gRef;

    struct gRefStruct *next;

};

static struct gRefStruct *gRefHead = NULL;

static struct gRefStruct *gRefTail = NULL;

/*

 * This function is called by components that

 * are being disposed. It used to invalidate

 * the global ref immediately, but the awt is

 * rather full of thread race conditions involving

 * component disposal and outstanding events.

 * Now we queue up 'to be deleted' global refs

 * as they come in, and don't invalidate them

 * until the X event queue is empty. Callers of

 * either of these functions _must_ have AWT_LOCK'd

 * before using them!

 */

void

awtJNI_DeleteGlobalRef(JNIEnv * env, jobject this)

{

    jobject gRef;

    struct gRefStruct *newGRef;

    struct gRefStruct *temp;

    gRef = (jobject)

        JNU_GetLongFieldAsPtr(env, this, mComponentPeerIDs.jniGlobalRef);

    JNU_SetLongFieldFromPtr(env, this, mComponentPeerIDs.jniGlobalRef, NULL);

    /*

     * Verra handy for tracking down race conditions. If you

     * have a peer getting called after its been disposed...

     */

    /* jio_fprintf(stderr,"%p\n",(void *)gRef); */

    newGRef = (struct gRefStruct *)malloc((size_t)sizeof(struct gRefStruct));

    if(newGRef == NULL)

        (*env)->DeleteGlobalRef(env, gRef);

    else

    {

        newGRef->gRef = gRef;

        newGRef->next = NULL;

        if(gRefHead == NULL)

        {

            gRefTail = newGRef;

            gRefHead = newGRef;

        }

        else

        {

            gRefTail->next = newGRef;

            gRefTail = newGRef;

        }

    }

}

void

awtJNI_DeleteGlobalMenuRef(JNIEnv * env, jobject this)

{

    jobject gRef;

    struct gRefStruct *newGRef;

    struct gRefStruct *temp;

    gRef = (jobject)

    /*

     * Verra handy for tracking down race conditions. If you

     * have a peer getting called after its been disposed...

     */

    /* jio_fprintf(stderr,"%p\n",(void *)gRef); */

    newGRef = (struct gRefStruct *)malloc((size_t)sizeof(struct gRefStruct));

    if(newGRef == NULL)

        (*env)->DeleteGlobalRef(env, gRef);

    else

    {

        newGRef->gRef = gRef;

        newGRef->next = NULL;

        if(gRefHead == NULL)

        {

            gRefTail = newGRef;

            gRefHead = newGRef;

        }

        else

        {

            gRefTail->next = newGRef;

            gRefTail = newGRef;

        }

    }

}

void awtJNI_CleanupGlobalRefs()

{

    struct gRefStruct *working,*next;

    JNIEnv *env;

    int32_t count = 0;

    if(gRefHead == NULL) {

        return;

    }

    env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);

    working = gRefHead;

    gRefHead = gRefTail = NULL;

    while(working != NULL)

    {

        count++;

        next = working->next;

        (*env)->DeleteGlobalRef(env, working->gRef);

        free((void *)working);

        working = next;

    }

}

#endif

static int32_t

awtJNI_GetFontDescriptorNumber(JNIEnv * env

                               ,jobject font

                               ,jobject fd)

{

    int32_t i = 0, num;

    /* initialize to NULL so that DeleteLocalRef will work. */

    jobjectArray componentFonts = NULL;

    jobject peer = NULL;

    jobject temp = NULL;

    jboolean validRet = JNI_FALSE;

    if ((*env)->EnsureLocalCapacity(env, 2) < 0)

        goto done;

    peer = (*env)->CallObjectMethod(env,font,fontIDs.getPeer);

    if (peer == NULL)

        goto done;

    componentFonts = (jobjectArray)

        (*env)->GetObjectField(env,peer,platformFontIDs.componentFonts);

    if (componentFonts == NULL)

        goto done;

    num = (*env)->GetArrayLength(env, componentFonts);

    for (i = 0; i < num; i++) {

        temp = (*env)->GetObjectArrayElement(env, componentFonts, i);

        if ((*env)->IsSameObject(env, fd, temp)) {

            validRet = JNI_TRUE;

            break;

        }

        (*env)->DeleteLocalRef(env, temp);

    }

 done:

    (*env)->DeleteLocalRef(env, peer);

    (*env)->DeleteLocalRef(env, componentFonts);

    if (validRet)

        return i;

    return 0;

}

#ifndef XAWT

jobject

awtJNI_GetFont(JNIEnv * env, jobject this)

{

    jobject target = NULL;

    jobject font = NULL;

    target = (*env)->GetObjectField(env, this, mComponentPeerIDs.target);

    // SECURITY: Must call _NoClientCode() methods to ensure that we

    //           are not invoking client code on the privileged thread

    font = JNU_CallMethodByName(env,

                                NULL,

                                target,

                                "getFont_NoClientCode",

                                "()Ljava/awt/Font;").l;

    (*env)->DeleteLocalRef(env, target);

    return font;

}

#endif

jobject

awtJNI_GetFMFont(JNIEnv * env, jobject this)

{

    return JNU_CallMethodByName(env, NULL, this, "getFont_NoClientCode",

                                "()Ljava/awt/Font;").l;

}

jboolean

awtJNI_IsMultiFont(JNIEnv * env, jobject this)

{

    jobject peer = NULL;

    jobject fontConfig = NULL;

    if (this == NULL) {

        return JNI_FALSE;

    }

    if ((*env)->EnsureLocalCapacity(env, 2) < 0) {

        return JNI_FALSE;

    }

    peer = (*env)->CallObjectMethod(env,this,fontIDs.getPeer);

    if (peer == NULL) {

        return JNI_FALSE;

    }

    fontConfig = (*env)->GetObjectField(env,peer,platformFontIDs.fontConfig);

    (*env)->DeleteLocalRef(env, peer);

    if (fontConfig == NULL) {

        return JNI_FALSE;

    }

    (*env)->DeleteLocalRef(env, fontConfig);

    return JNI_TRUE;

}

jboolean

awtJNI_IsMultiFontMetrics(JNIEnv * env, jobject this)

{

    jobject peer = NULL;

    jobject fontConfig = NULL;

    jobject font = NULL;

    if (JNU_IsNull(env, this)) {

        return JNI_FALSE;

    }

    if ((*env)->EnsureLocalCapacity(env, 3) < 0) {

        return JNI_FALSE;

    }

    font = JNU_CallMethodByName(env, NULL, this, "getFont_NoClientCode",

                                "()Ljava/awt/Font;").l;

    if (JNU_IsNull(env, font)) {

        return JNI_FALSE;

    }

    peer = (*env)->CallObjectMethod(env,font,fontIDs.getPeer);

    (*env)->DeleteLocalRef(env, font);

    if (peer == NULL) {

        return JNI_FALSE;

    }

    fontConfig = (*env)->GetObjectField(env,peer,platformFontIDs.fontConfig);

    (*env)->DeleteLocalRef(env, peer);

    if (fontConfig == NULL) {

        return JNI_FALSE;

    }

    (*env)->DeleteLocalRef(env, fontConfig);

    return JNI_TRUE;

}

#ifndef XAWT

#ifdef __linux__

XmString

unicodeXmStringCreate(char* text, char* tag, int len) {

    XmString ret_val;

    XtProcessLock();

    ret_val = _XmStringNCreate (text, tag, len);

    XtProcessUnlock();

    return ret_val;

}

#endif

/*

 * Unicode to Motif Multi Font Compound String converter

 *

 * ASSUMES: We are not running on a privileged thread

 */

XmString

awtJNI_MakeMultiFontString(JNIEnv * env, jstring s, jobject font)

{

    XmString xmstr = NULL, xmtmp1, xmtmp2;

    jobjectArray dataArray = NULL;

    char *err = NULL;

    int32_t stringCount,i;

    int32_t fdnumber;

    struct FontData *fdata = awtJNI_GetFontData(env, font, &err);

    jobject fontDescriptor = NULL;

    jbyteArray data = NULL;

    char *stringData = NULL;

    char tag[BUFSIZ];

    if ((*env)->PushLocalFrame(env, 16) < 0)

        return NULL;

    if (!JNU_IsNull(env, s) && !JNU_IsNull(env, font)) {

        jobject peer;

        peer = (*env)->CallObjectMethod(env,font,fontIDs.getPeer);

        DASSERT(!awt_currentThreadIsPrivileged(env));

        dataArray =

            (*env)->CallObjectMethod(

                             env,

                             peer,

                             platformFontIDs.makeConvertedMultiFontString,

                             s);

        if ((*env)->ExceptionOccurred(env)) {

            (*env)->ExceptionDescribe(env);

            (*env)->ExceptionClear(env);

            (*env)->PopLocalFrame(env, NULL);

            return (XmString) NULL;

        }

        if(dataArray == NULL) {

            (*env)->PopLocalFrame(env, NULL);

            return (XmString) NULL;

        }

    } else {

        (*env)->PopLocalFrame(env, NULL);

        return (XmString) NULL;

    }

    stringCount = (*env)->GetArrayLength(env, dataArray);

    for (i = 0; i < stringCount; i+=2) {

        fontDescriptor = (*env)->GetObjectArrayElement(env, dataArray, i);

        data = (*env)->GetObjectArrayElement(env, dataArray, i + 1);

        /* Bail if we've finished */

        if(fontDescriptor == NULL || data == NULL)

            break;

        fdnumber = awtJNI_GetFontDescriptorNumber(env, font, fontDescriptor);

        fdata = awtJNI_GetFontData(env, font, &err);

        makeTag(fdata->flist[fdnumber].charset_name, fdnumber, tag);

        stringData = (char *)(*env)->GetPrimitiveArrayCritical(env, data, NULL);

        if(stringData != NULL) {

            unsigned char* buf = stringData;

            int len;

            char *offsetStringData;

            offsetStringData = stringData + (4 * sizeof(char));

#ifdef __linux__

            len = buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3];

            /* Motif XmStringCreate() API requests "text must be a NULL-terminated

               string" and its implementation uses "strlen()" to calculate the length

               of the text string. Unfortunately when we deal with iso10646 font

               on linux, the "text" is requested to be encoded in UTF16, which has the

               posibility of including code points like "0xYY00" ("0xYY" + "0x00") that

               causes problem when XmStringCreate() calls _XmStringNCreate() without

               specifying a specific text lenth (see Motif XmString.c). The workaround is

               to call _XmStringNCreate() directly with specific text length at this

               cirsumstance.

            */

            if (strstr(fdata->flist[fdnumber].charset_name, "UnicodeBigUnmarked"))

                xmtmp1 = unicodeXmStringCreate(offsetStringData, tag, len);

            else

                xmtmp1 = XmStringCreate(offsetStringData, tag);

            if (xmstr == NULL)

                xmstr = xmtmp1;

            else {

                xmtmp2 = XmStringConcat(xmstr, xmtmp1);

                XmStringFree(xmtmp1);

                XmStringFree(xmstr);

                xmstr = xmtmp2;

            }

#else

            if(xmstr == NULL) {

                xmstr = XmStringCreate(offsetStringData, tag);

            }

            else {

                xmtmp1 = XmStringCreate(offsetStringData, tag);

                xmtmp2 = XmStringConcat(xmstr, xmtmp1);

                XmStringFree(xmtmp1);

                XmStringFree(xmstr);

                xmstr = xmtmp2;

            }

#endif

        }

        (*env)->ReleasePrimitiveArrayCritical(env, data, stringData, JNI_ABORT);

        (*env)->DeleteLocalRef(env, fontDescriptor);

        (*env)->DeleteLocalRef(env, data);

    }

    (*env)->PopLocalFrame(env, NULL);

    return xmstr;

}

/*

 * Find the character encoding for a given font and register that encoding

 * with the given tag.  The encoding is the last two fields of the XLFD of

 * the font (converted to uppercase).

 */

static void registerEncoding(char *xlfd, char *tag)

{

    char *e = xlfd + strlen(xlfd);

    char *ret = NULL;

    do { --e; } while (e != xlfd && *e != '-');

    do { --e; } while (e != xlfd && *e != '-');

    if (e != xlfd) {

        char *encoding = strdup(++e);

        char *u = NULL;

        for (u = encoding; *u != '\0'; ++u) {

            if (islower(*u)) {

                *u = toupper(*u);

            }

        }

        /*

         * Motif will core dump on or otherwise mishandle unknown (or

         * non-standard) character encodings (in conversion to compound

         * text, bug 4122785).  Register Sun private encodings for

         * Symbol or dingbat fonts as ISO8859-1, which is a lie,

         * but produces predictable results.

         */

        if (strncmp(encoding, "SUN-", 4) == 0) {

                free(encoding);

                encoding = strdup("ISO8859-1");

        }

        ret = XmRegisterSegmentEncoding(tag, encoding);

        if (ret != NULL)

                XtFree(ret);

        free(encoding);

    }

}

XmFontList

awtJNI_GetFontList(JNIEnv * env, jobject font)

{

    int32_t i;

    XmFontListEntry fle;

    XmFontList fontlist;