/*

 * 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.  Oracle designates this

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

 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

#include "awt.h"

#include <math.h>

#include "jlong.h"

#include "awt_Font.h"

#include "awt_Toolkit.h"

#include "java_awt_Font.h"

#include "java_awt_FontMetrics.h"

#include "java_awt_Dimension.h"

#include "sun_awt_FontDescriptor.h"

#include "sun_awt_windows_WDefaultFontCharset.h"

#include "sun_awt_windows_WFontPeer.h"

#include "awt_Component.h"

#include "Disposer.h"

/* IMPORTANT! Read the README.JNI file for notes on JNI converted AWT code.

 */

AwtFontCache fontCache;

extern jboolean IsMultiFont(JNIEnv *env, jobject obj)

{

    if (obj == NULL) {

        return JNI_FALSE;

    }

    if (env->EnsureLocalCapacity(2))

        return JNI_FALSE;

    jobject peer = env->CallObjectMethod(obj, AwtFont::peerMID);

    if (peer == NULL) {

        return JNI_FALSE;

    }

    jobject fontConfig = env->GetObjectField(peer, AwtFont::fontConfigID);

    jboolean result = fontConfig != NULL;

    env->DeleteLocalRef(peer);

    env->DeleteLocalRef(fontConfig);

    return result;

}

extern jstring GetTextComponentFontName(JNIEnv *env, jobject font)

{

    DASSERT(font != NULL);

    if (env->EnsureLocalCapacity(2)) {

        return NULL;

    }

    jobject peer = env->CallObjectMethod(font, AwtFont::peerMID);

    DASSERT(peer != NULL);

    jstring textComponentFontName =

            (jstring) env->GetObjectField(peer, AwtFont::textComponentFontNameID);

    env->DeleteLocalRef(peer);

    return textComponentFontName;

}

/************************************************************************

 * AwtFont fields

 */

/* sun.awt.windows.WFontMetrics fields */

jfieldID AwtFont::widthsID;

jfieldID AwtFont::ascentID;

jfieldID AwtFont::descentID;

jfieldID AwtFont::leadingID;

jfieldID AwtFont::heightID;

jfieldID AwtFont::maxAscentID;

jfieldID AwtFont::maxDescentID;

jfieldID AwtFont::maxHeightID;

jfieldID AwtFont::maxAdvanceID;

/* java.awt.FontDescriptor fields */

jfieldID AwtFont::nativeNameID;

jfieldID AwtFont::useUnicodeID;

/* java.awt.Font fields */

jfieldID AwtFont::pDataID;

jfieldID AwtFont::nameID;

jfieldID AwtFont::sizeID;

jfieldID AwtFont::styleID;

/* java.awt.FontMetrics fields */

jfieldID AwtFont::fontID;

/* sun.awt.PlatformFont fields */

jfieldID AwtFont::fontConfigID;

jfieldID AwtFont::componentFontsID;

/* sun.awt.windows.WFontPeer fields */

jfieldID AwtFont::textComponentFontNameID;

/* sun.awt.windows.WDefaultFontCharset fields */

jfieldID AwtFont::fontNameID;

/* java.awt.Font methods */

jmethodID AwtFont::peerMID;

/* sun.awt.PlatformFont methods */

jmethodID AwtFont::makeConvertedMultiFontStringMID;

/* sun.awt.PlatformFont methods */

jmethodID AwtFont::getFontMID;

/* java.awt.FontMetrics methods */

jmethodID AwtFont::getHeightMID;

/************************************************************************

 * AwtFont methods

 */

AwtFont::AwtFont(int num, JNIEnv *env, jobject javaFont)

{

    if (num == 0) {  // not multi-font

        num = 1;

    }

    m_hFontNum = num;

    m_hFont = new HFONT[num];

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

        m_hFont[i] = NULL;

    }

    m_textInput = -1;

    m_ascent = -1;

    m_overhang = 0;

}

AwtFont::~AwtFont()

{

}

void AwtFont::Dispose() {

    for (int i = 0; i < m_hFontNum; i++) {

        HFONT font = m_hFont[i];

        if (font != NULL && fontCache.Search(font)) {

            fontCache.Remove(font);

            /*  NOTE: delete of windows HFONT happens in FontCache::Remove

                      only when the final reference to the font is disposed */

        } else if (font != NULL) {

         // if font was not in cache, its not shared and we delete it now

           VERIFY(::DeleteObject(font));

        }

    }

    delete[] m_hFont;

    AwtObject::Dispose();

}

static void pDataDisposeMethod(JNIEnv *env, jlong pData)

{

    TRY_NO_VERIFY;

    AwtObject::_Dispose((PDATA)pData);

    CATCH_BAD_ALLOC;

}

AwtFont* AwtFont::GetFont(JNIEnv *env, jobject font,

                          jint angle, jfloat awScale)

{

    jlong pData = env->GetLongField(font, AwtFont::pDataID);

    AwtFont* awtFont = (AwtFont*)jlong_to_ptr(pData);

    if (awtFont != NULL) {

        return awtFont;

    }

    awtFont = Create(env, font, angle, awScale);

    env->SetLongField(font, AwtFont::pDataID,

        reinterpret_cast<jlong>(awtFont));

    return awtFont;

}

// Get suitable CHARSET from charset string provided by font configuration.

static int GetNativeCharset(LPCWSTR name)

{

    if (wcsstr(name, L"ANSI_CHARSET"))

        return ANSI_CHARSET;

    if (wcsstr(name, L"DEFAULT_CHARSET"))

        return DEFAULT_CHARSET;

    if (wcsstr(name, L"SYMBOL_CHARSET") || wcsstr(name, L"WingDings"))

        return SYMBOL_CHARSET;

    if (wcsstr(name, L"SHIFTJIS_CHARSET"))

        return SHIFTJIS_CHARSET;

    if (wcsstr(name, L"GB2312_CHARSET"))

        return GB2312_CHARSET;

    if (wcsstr(name, L"HANGEUL_CHARSET"))

        return HANGEUL_CHARSET;

    if (wcsstr(name, L"CHINESEBIG5_CHARSET"))

        return CHINESEBIG5_CHARSET;

    if (wcsstr(name, L"OEM_CHARSET"))

        return OEM_CHARSET;

    if (wcsstr(name, L"JOHAB_CHARSET"))

        return JOHAB_CHARSET;

    if (wcsstr(name, L"HEBREW_CHARSET"))

        return HEBREW_CHARSET;

    if (wcsstr(name, L"ARABIC_CHARSET"))

        return ARABIC_CHARSET;

    if (wcsstr(name, L"GREEK_CHARSET"))

        return GREEK_CHARSET;

    if (wcsstr(name, L"TURKISH_CHARSET"))

        return TURKISH_CHARSET;

    if (wcsstr(name, L"VIETNAMESE_CHARSET"))

        return VIETNAMESE_CHARSET;

    if (wcsstr(name, L"THAI_CHARSET"))

        return THAI_CHARSET;

    if (wcsstr(name, L"EASTEUROPE_CHARSET"))

        return EASTEUROPE_CHARSET;

    if (wcsstr(name, L"RUSSIAN_CHARSET"))

        return RUSSIAN_CHARSET;

    if (wcsstr(name, L"MAC_CHARSET"))

        return MAC_CHARSET;

    if (wcsstr(name, L"BALTIC_CHARSET"))

        return BALTIC_CHARSET;

    return ANSI_CHARSET;

}

AwtFont* AwtFont::Create(JNIEnv *env, jobject font, jint angle, jfloat awScale)

{

    int fontSize = env->GetIntField(font, AwtFont::sizeID);

    int fontStyle = env->GetIntField(font, AwtFont::styleID);

    AwtFont* awtFont = NULL;

    jobjectArray compFont = NULL;

    int cfnum;

    try {

        if (env->EnsureLocalCapacity(3) < 0)

            return 0;

        if (IsMultiFont(env, font)) {

            compFont = GetComponentFonts(env, font);

            cfnum = env->GetArrayLength(compFont);

        } else {

            compFont = NULL;

            cfnum = 0;

        }

        LPCWSTR wName;

        awtFont = new AwtFont(cfnum, env, font);

        awtFont->textAngle = angle;

        awtFont->awScale = awScale;

        if (cfnum > 0) {

            // Ask peer class for the text component font name

            jstring jTextComponentFontName = GetTextComponentFontName(env, font);

            LPCWSTR textComponentFontName = JNU_GetStringPlatformChars(env, jTextComponentFontName, NULL);

            awtFont->m_textInput = -1;

            for (int i = 0; i < cfnum; i++) {

                // nativeName is a pair of platform fontname and its charset

                // tied with a comma; "Times New Roman,ANSI_CHARSET".

                jobject fontDescriptor = env->GetObjectArrayElement(compFont,

                                                                    i);

                jstring nativeName =

                    (jstring)env->GetObjectField(fontDescriptor,

                                                 AwtFont::nativeNameID);

                wName = JNU_GetStringPlatformChars(env, nativeName, NULL);

                DASSERT(wName);

                //On NT platforms, if the font is not Symbol or Dingbats

                //use "W" version of Win32 APIs directly, info the FontDescription

                //no need to convert characters from Unicode to locale encodings.

                if (GetNativeCharset(wName) != SYMBOL_CHARSET) {

                    env->SetBooleanField(fontDescriptor, AwtFont::useUnicodeID, TRUE);

                }

                // Check to see if this font is suitable for input

                // on AWT TextComponent

                if ((awtFont->m_textInput == -1) &&

                        (textComponentFontName != NULL) &&

                        (wcscmp(wName, textComponentFontName) == 0)) {

                    awtFont->m_textInput = i;

                }

                HFONT hfonttmp = CreateHFont(const_cast<LPWSTR>(wName), fontStyle, fontSize,

                                             angle, awScale);

                awtFont->m_hFont[i] = hfonttmp;

                JNU_ReleaseStringPlatformChars(env, nativeName, wName);

                env->DeleteLocalRef(fontDescriptor);

                env->DeleteLocalRef(nativeName);

            }

            if (awtFont->m_textInput == -1) {

                // no text component font was identified, so default

                // to first component

                awtFont->m_textInput = 0;

            }

            JNU_ReleaseStringPlatformChars(env, jTextComponentFontName, textComponentFontName);

            env->DeleteLocalRef(jTextComponentFontName);

        } else {

            // Instantiation for English version.

            jstring fontName = (jstring)env->GetObjectField(font,

                                                            AwtFont::nameID);

            wName = JNU_GetStringPlatformChars(env, fontName, NULL);

            WCHAR* wEName;

            if (!wcscmp(wName, L"Helvetica") || !wcscmp(wName, L"SansSerif")) {

                wEName = L"Arial";

            } else if (!wcscmp(wName, L"TimesRoman") ||

                       !wcscmp(wName, L"Serif")) {

                wEName = L"Times New Roman";

            } else if (!wcscmp(wName, L"Courier") ||

                       !wcscmp(wName, L"Monospaced")) {

                wEName = L"Courier New";

            } else if (!wcscmp(wName, L"Dialog")) {

                wEName = L"MS Sans Serif";

            } else if (!wcscmp(wName, L"DialogInput")) {

                wEName = L"MS Sans Serif";

            } else if (!wcscmp(wName, L"ZapfDingbats")) {

                wEName = L"WingDings";

            } else

                wEName = L"Arial";

            awtFont->m_textInput = 0;

            awtFont->m_hFont[0] = CreateHFont(wEName, fontStyle, fontSize,

                                              angle, awScale);

            JNU_ReleaseStringPlatformChars(env, fontName, wName);

            env->DeleteLocalRef(fontName);

        }

        /* The several callers of this method also set the pData field.

         * That's unnecessary but harmless duplication. However we definitely

         * want only one disposer record.

         */

        env->SetLongField(font, AwtFont::pDataID,

        reinterpret_cast<jlong>(awtFont));

        Disposer_AddRecord(env, font, pDataDisposeMethod,

                       reinterpret_cast<jlong>(awtFont));

    } catch (...) {

        env->DeleteLocalRef(compFont);

        throw;

    }

    env->DeleteLocalRef(compFont);

    return awtFont;

}

int CALLBACK FindFamilyName (ENUMLOGFONTEX *lpelfe,

          NEWTEXTMETRICEX *lpntme, int FontType, LPARAM lParam)

{

    if(_tcsstr((LPTSTR)lParam, lpelfe->elfLogFont.lfFaceName)) {

        _tcscpy((LPTSTR)lParam, lpelfe->elfLogFont.lfFaceName);

        return 0;

    } else {

        return 1;

    }

}

static void strip_tail(wchar_t* text, wchar_t* tail) { // strips tail and any possible whitespace before it from the end of text

    if (wcslen(text)<=wcslen(tail)) {

        return;

    }

    wchar_t* p = text+wcslen(text)-wcslen(tail);

    if (!wcscmp(p, tail)) {

        while(p>text && iswspace(*(p-1)))

            p--;

        *p = 0;

    }

}

static HFONT CreateHFont_sub(LPCWSTR name, int style, int height,

                             int angle=0, float awScale=1.0f)

{

    LOGFONTW logFont;

    logFont.lfWidth = 0;

    logFont.lfEscapement = angle;

    logFont.lfOrientation = angle;

    logFont.lfUnderline = FALSE;

    logFont.lfStrikeOut = FALSE;

    logFont.lfCharSet = GetNativeCharset(name);

    if (angle == 0 && awScale == 1.0f) {

        logFont.lfOutPrecision = OUT_DEFAULT_PRECIS;

    } else {

        logFont.lfOutPrecision = OUT_TT_ONLY_PRECIS;

    }

    logFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;

    logFont.lfQuality = DEFAULT_QUALITY;

    logFont.lfPitchAndFamily = DEFAULT_PITCH;

    // Set style

    logFont.lfWeight = (style & java_awt_Font_BOLD) ? FW_BOLD : FW_NORMAL;

    logFont.lfItalic = (style & java_awt_Font_ITALIC) != 0;

    logFont.lfUnderline = 0;//(style & java_awt_Font_UNDERLINE) != 0;

    // Get point size

    logFont.lfHeight = -height;

    // Set font name

    WCHAR tmpname[80];

    wcscpy(tmpname, name);

    WCHAR* delimit = wcschr(tmpname, L',');

    if (delimit != NULL)

        *delimit = L'\0';  // terminate the string after the font name.

    // strip "Bold" and "Italic" from the end of the name

    strip_tail(tmpname,L""); //strip possible trailing whitespace

    strip_tail(tmpname,L"Italic");

    strip_tail(tmpname,L"Bold");

    wcscpy(&(logFont.lfFaceName[0]), tmpname);

    HFONT hFont = ::CreateFontIndirect(&logFont);

    DASSERT(hFont != NULL);

    // get a expanded or condensed version if its specified.

    if (awScale != 1.0f) {

        HDC hDC = ::GetDC(0);

        HFONT oldFont = (HFONT)::SelectObject(hDC, hFont);

        TEXTMETRIC tm;

        DWORD avgWidth;

        GetTextMetrics(hDC, &tm);

        oldFont = (HFONT)::SelectObject(hDC, oldFont);

        if (oldFont != NULL) { // should be the same as hFont

            VERIFY(::DeleteObject(oldFont));

        }

        avgWidth = tm.tmAveCharWidth;

        logFont.lfWidth = (LONG)((fabs)(avgWidth*awScale));

        hFont = ::CreateFontIndirect(&logFont);

        DASSERT(hFont != NULL);

        VERIFY(::ReleaseDC(0, hDC));

    }

    return hFont;

}

HFONT AwtFont::CreateHFont(WCHAR* name, int style, int height,

                           int angle, float awScale)

{

    WCHAR longName[80];

    // 80 > (max face name(=30) + strlen("CHINESEBIG5_CHARSET"))

    // longName doesn't have to be printable.  So, it is OK not to convert.

    wsprintf(longName, L"%ls-%d-%d", name, style, height);

    HFONT hFont = NULL;

    // only cache & share unrotated, unexpanded/uncondensed fonts

    if (angle == 0 && awScale == 1.0f) {

        hFont = fontCache.Lookup(longName);

        if (hFont != NULL) {

            fontCache.IncRefCount(hFont);

            return hFont;

        }

    }

    hFont = CreateHFont_sub(name, style, height, angle, awScale);

    if (angle == 0 && awScale == 1.0f) {

        fontCache.Add(longName, hFont);

    }

    return hFont;

}

void AwtFont::Cleanup()

{

    fontCache.Clear();

}

void AwtFont::SetupAscent(AwtFont* font)

{

    HDC hDC = ::GetDC(0);

    DASSERT(hDC != NULL);

    HGDIOBJ oldFont = ::SelectObject(hDC, font->GetHFont());

    TEXTMETRIC metrics;

    VERIFY(::GetTextMetrics(hDC, &metrics));

    font->SetAscent(metrics.tmAscent);

    ::SelectObject(hDC, oldFont);

    VERIFY(::ReleaseDC(0, hDC));

}

void AwtFont::LoadMetrics(JNIEnv *env, jobject fontMetrics)

{

    if (env->EnsureLocalCapacity(3) < 0)

        return;

    jintArray widths = env->NewIntArray(256);

    if (widths == NULL) {

        /* no local refs to delete yet. */

        return;

    }

    jobject font = env->GetObjectField(fontMetrics, AwtFont::fontID);

    AwtFont* awtFont = AwtFont::GetFont(env, font);

    HDC hDC = ::GetDC(0);

    DASSERT(hDC != NULL);

    HGDIOBJ oldFont = ::SelectObject(hDC, awtFont->GetHFont());

    TEXTMETRIC metrics;

    VERIFY(::GetTextMetrics(hDC, &metrics));

    awtFont->m_ascent = metrics.tmAscent;

    int ascent = metrics.tmAscent;

    int descent = metrics.tmDescent;

    int leading = metrics.tmExternalLeading;

    env->SetIntField(fontMetrics, AwtFont::ascentID, ascent);

    env->SetIntField(fontMetrics, AwtFont::descentID, descent);