Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-07 20:17:37 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
5d5d533e2c
gecko-dev/cmd/winfe/intlwin.cpp
spider 5d5d533e2c Normandy Merge ....
1998-06-22 21:19:46 +00:00

1400 lines
40 KiB
C++
Executable File
Raw Blame History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Netscape Public License
* Version 1.0 (the "NPL"); you may not use this file except in
* compliance with the NPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of this code under the NPL is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
* Reserved.
*/
#include "stdafx.h"
#include "mainfrm.h"
#include "libi18n.h"
#include "xplocale.h"
#include "cxprint.h"
#include "cxsave.h"
#include "np.h"
#include "prlog.h"
#include "prlink.h"
#include "xpstrsw.h"
#if defined(OJI)
#include "jvmmgr.h"
#elif defined(JAVA)
#include "java.h"
#endif
#include "cuvfs.h"
#include "intl_csi.h"
#include "edt.h"
#include "prefapi.h"
#include "edt.h"
#ifdef XP_WIN32
static BOOL intlUnicodeFlag(int16 wincsid);
#define INIT_FLAG_FOR_CSID(c) { CIntlWin::flagTable[(c) & MASK_FLAG_TABLE] = intlUnicodeFlag(c);}
BOOL CIntlWin::flagTable[MAX_FLAG_TABLE_NUM];
#endif // XP_WIN32
extern int INTL_DocCharSetID(MWContext *context);
enum { // just to ignore unnecessary strcomp
javaFontHelvetica = 0,
javaFontTimesRoman,
javaFontCourier,
javaFontDialog,
javaFontDialogInput,
javaFontZapfDingbats
};
extern "C" {
const char* IntlGetJavaFaceName(int csid, int javaFontID);
BYTE IntlGetJavaCharset(int csid, int javaFontID);
jref *intl_makeJavaString(int16 encoding, char *str, int len);
};
extern "C" {
PR_PUBLIC_API(BOOL ) CINTLWIN_TEXTOUT_E(int16 wincsid, HDC hdc, int nXStart, int nYStart, LPCSTR lpString,int iLength);
PR_PUBLIC_API(BOOL ) CINTLWIN_GETTEXTEXTENTPOINT_E(int wincsid, HDC hDC, LPCSTR lpString, int cbString, LPSIZE lpSize);
PR_PUBLIC_API(const char*) INTLGETJAVAFACENAME_E(int csid, int javaFontID);
PR_PUBLIC_API(BYTE ) INTLGETJAVACHARSET_E(int csid, int javaFontID);
#ifdef JAVA
PR_PUBLIC_API(jref* ) INTL_MAKEJAVASTRING_E(int16 encoding, char *str, int len);
#endif // JAVA
PR_PUBLIC_API(int16* ) INTL_GETUNICODECSIDLIST_E(int16 * outnum);
PR_PUBLIC_API(int32 ) INTL_UNICODELEN_E(uint16* ustr);
PR_PUBLIC_API(INTL_CompoundStr* ) INTL_COMPOUNDSTRFROMUNICODE_E(uint16* inunicode, uint32 inlen);
PR_PUBLIC_API(void ) INTL_COMPOUNDSTRDESTROY_E(INTL_CompoundStr* This);
PR_PUBLIC_API(INTL_CompoundStrIterator ) INTL_COMPOUNDSTRFIRSTSTR_E(INTL_CompoundStr* This, INTL_Encoding_ID *outencoding, unsigned char** outtext);
PR_PUBLIC_API(INTL_CompoundStrIterator ) INTL_COMPOUNDSTRNEXTSTR_E(INTL_CompoundStrIterator iterator, INTL_Encoding_ID *outencoding, unsigned char** outtext);
PR_PUBLIC_API(INTL_CompoundStr* ) INTL_COMPOUNDSTRCLONE_E(INTL_CompoundStr* s1);
PR_PUBLIC_API(int16 ) INTL_DEFAULTWINCHARSETID_E(MWContext *context);
PR_PUBLIC_API(int32 ) INTL_TEXTBYTECOUNTTOCHARLEN_E(int16 csid, unsigned char* text, uint32 byteCount);
PR_PUBLIC_API(int32 ) INTL_TEXTCHARLENTOBYTECOUNT_E(int16 csid, unsigned char* text, uint32 charLen);
PR_PUBLIC_API(uint32 ) INTL_UNICODETOSTRLEN_E(INTL_Encoding_ID encoding,INTL_Unicode* ustr, uint32 ustrlen);
PR_PUBLIC_API(void ) INTL_UNICODETOSTR_E(INTL_Encoding_ID encoding,INTL_Unicode* ustr,uint32 ustrlen,unsigned char* dest, uint32 destbuflen);
};
//
// Data type use for Unicode table loader
//
#define MAXUTABLENAME 16
typedef struct tblrsrcinfo {
char name[MAXUTABLENAME];
uint16 refcount;
HGLOBAL hTbl;
} tblrsrcinfo;
typedef struct utablename {
uint16 csid;
tblrsrcinfo frominfo;
tblrsrcinfo toinfo;
} utablename;
//
// The following are private
//
static void intl_WriteUnicodeConvList(int num_of_csid, int16* csidlist);
static void intl_ReadUnicodeConvList();
static void intl_UnloadUCS2Table(uint16 csid, void *utblPtr, int from);
static tblrsrcinfo* intl_FindUTableName(uint16 csid, int from);
static void *intl_LoadUCS2Table(uint16 csid, int from);
static void intl_UnloadUCS2Table(uint16 csid, void *utblPtr, int from);
// This structure is used for following table for default font value,
// It'll be removed after default value goes to resource file.
struct FontCharTable
{
int16 csid;
char szPropFont[LF_FACESIZE] ;
int iPropSize ;
char szFixFont[LF_FACESIZE] ;
int iFixSize ;
int iPropCharset;
int iFixCharset;
};
// Note: always add new comer to last line.
struct FontCharTable fontchar_tbl[] =
{
CS_LATIN1, DEF_PROPORTIONAL_FONT, 12, DEF_FIXED_FONT, 10, ANSI_CHARSET, ANSI_CHARSET,
CS_SJIS, "<EFBFBD>l<EFBFBD>r <20><><EFBFBD><EFBFBD>", 10, "<EFBFBD>l<EFBFBD>r <20><><EFBFBD><EFBFBD>", 10, SHIFTJIS_CHARSET, SHIFTJIS_CHARSET,
CS_BIG5, "Times New Roman", 12, "Courier New", 10, CHINESEBIG5_CHARSET, CHINESEBIG5_CHARSET,
CS_KSC_8BIT,"Times New Roman", 12, "Courier New", 10, HANGEUL_CHARSET, HANGEUL_CHARSET,
CS_GB_8BIT, "Times New Roman", 12, "Courier New", 10, 134, 134,
CS_CP_1250, "Times New Roman", 12, "Courier New", 10, 238,238,
CS_CP_1251, "Times New Roman", 12, "Courier New", 10, 204,204,
CS_ARMSCII8, "ArmNet Helvetica", 12, "ArmNet Courier", 10, 160, 160,
CS_CP_1253, "Times New Roman", 12, "Courier New", 10, 161,161,
CS_8859_9, "Times New Roman", 12, "Courier New", 10, 162,162,
CS_UTF8, DEF_PROPORTIONAL_FONT, 12, DEF_FIXED_FONT, 10, DEFAULT_CHARSET, DEFAULT_CHARSET,
CS_USER_DEFINED_ENCODING, DEF_PROPORTIONAL_FONT, 12, DEF_FIXED_FONT, 10, ANSI_CHARSET, ANSI_CHARSET,
0, "", 0, "", 0, 0, 0
} ;
// This table defined how many encoding we supports in our Navigator and
// what kind of conversion we support for each encoding.
// Note: always add new comer to last line.
// Encoding, Encoding used for Display, supported CSID list, 0
unsigned int lang_table[] =
{
IDS_LANGUAGE_LATIN1, CS_LATIN1, CS_LATIN1, 0,
IDS_LANGUAGE_LATIN2, CS_CP_1250, CS_CP_1250, CS_LATIN2, 0,
IDS_LANGUAGE_JAPANESE, CS_SJIS, CS_AUTO | CS_SJIS, CS_SJIS, CS_JIS, CS_EUCJP, 0,
IDS_LANGUAGE_TAIWANESE, CS_BIG5, CS_BIG5, CS_CNS_8BIT,
CS_X_BIG5, CS_CNS11643_1110, CS_CNS11643_1, CS_CNS11643_2, 0,
IDS_LANGUAGE_CHINESE, CS_GB_8BIT, CS_GB_8BIT,
CS_GB2312, CS_GB2312_11, 0,
IDS_LANGUAGE_KOREAN, CS_KSC_8BIT, CS_KSC_8BIT | CS_AUTO, CS_KSC_8BIT, CS_2022_KR,
CS_KSC5601, CS_KSC5601_11, 0,
IDS_LANGUAGE_WIN1251, CS_CP_1251, CS_CP_1251, CS_8859_5, CS_KOI8_R, 0,
IDS_LANGUAGE_ARMENIAN, CS_ARMSCII8, CS_ARMSCII8, 0,
IDS_LANGUAGE_GREEK, CS_CP_1253, CS_CP_1253, CS_8859_7, 0,
IDS_LANGUAGE_TURKISH, CS_8859_9, CS_8859_9, 0,
IDS_LANGUAGE_UTF8, CS_UTF8, CS_UTF8, CS_UTF7, CS_UCS2, CS_UCS2_SWAP, 0,
IDS_LANGUAGE_USERDEFINED, CS_USER_DEFINED_ENCODING, CS_USER_DEFINED_ENCODING, 0,
UINT_MAX
};
CIntlFont::CIntlFont()
{
CString fontList;
LPSTR lpszPropName = NULL;
LPSTR lpszFixName = NULL;
int32 iPropSize, iFixSize ;
int iPropCharset, iFixCharset;
BOOL ret = FALSE;
int i ;
int nLang ;
EncodingInfo *pEncoding;
iPropCharset = iFixCharset = 0;
#ifdef XP_WIN32
for(int j = 0; j < MAX_FLAG_TABLE_NUM; j++)
INIT_FLAG_FOR_CSID(j);
#endif
pEncodingInfoTbl = (struct EncodingInfo *) malloc( (MAXLANGNUM + 1) * sizeof (struct EncodingInfo) ) ;
if (pEncodingInfoTbl == NULL)
{
TRACE("No memory for MultiLingual support.\n");
return ;
}
memset(pEncodingInfoTbl, 0, (MAXLANGNUM + 1) * sizeof(struct EncodingInfo));
nLang = 0;
pEncoding = pEncodingInfoTbl;
for (i = 0; (lang_table[i] != UINT_MAX) && (nLang < MAXLANGNUM); i++)
{
pEncoding->iLangResId = lang_table[i++];
pEncoding->iCSID = lang_table[i++];
// Setup default font information.
for (int j = 0; j < MAXLANGNUM; j++)
{
if (fontchar_tbl[j].csid == pEncoding->iCSID)
{
// First, lets try to copy from the hard coded table
strcpy(pEncoding->szPropName, fontchar_tbl[j].szPropFont);
pEncoding->iPropSize = fontchar_tbl[j].iPropSize;
strcpy(pEncoding->szFixName, fontchar_tbl[j].szFixFont);
pEncoding->iFixSize = fontchar_tbl[j].iFixSize;
pEncoding->iPropCharset = fontchar_tbl[j].iPropCharset;
pEncoding->iFixCharset = fontchar_tbl[j].iFixCharset;
}
}
char key[80];
// Now, let's try to get it from the PREF
sprintf(key, "intl.font%d.win.prop_font", pEncoding->iCSID);
lpszPropName = NULL;
if( PREF_NOERROR == PREF_CopyCharPref(key, &lpszPropName))
{
strcpy(pEncoding->szPropName, lpszPropName);
XP_FREE(lpszPropName);
}
sprintf(key, "intl.font%d.win.fixed_font", pEncoding->iCSID);
lpszFixName = NULL;
if( PREF_NOERROR == PREF_CopyCharPref(key, &lpszFixName))
{
strcpy(pEncoding->szFixName, lpszFixName);
XP_FREE(lpszFixName);
}
sprintf(key, "intl.font%d.win.prop_size", pEncoding->iCSID);
if( PREF_NOERROR == PREF_GetIntPref(key, &iPropSize))
pEncoding->iPropSize = (int)iPropSize;
sprintf(key, "intl.font%d.win.fixed_size", pEncoding->iCSID);
if( PREF_NOERROR == PREF_GetIntPref(key, &iFixSize))
pEncoding->iFixSize = (int)iFixSize;
// Setup supported CSID list
for (j =0; lang_table[i]; j++)
{
pEncoding->csid[j] = lang_table[i++] ;
#ifdef XP_WIN32
INIT_FLAG_FOR_CSID(pEncoding->csid[j]);
#endif
}
pEncoding->nCodeset = j;
nLang ++ ;
pEncoding ++ ;
}
nEncoding = MAXLANGNUM;
intl_ReadUnicodeConvList();
}
EncodingInfo * CIntlFont::GetEncodingInfo(int id)
{
if (id < nEncoding)
return &pEncodingInfoTbl[id];
else
return NULL;
}
EncodingInfo * CIntlFont::GetEncodingInfo(MWContext *pContext)
{
int doc_csid, id;
doc_csid = INTL_DocCharSetID(pContext) & ~CS_AUTO ;
id = DocCSIDtoID(doc_csid);
return GetEncodingInfo(id);
}
int16 IntlCharsetToCsid(BYTE charset)
{
int i;
for (i = 0; i < MAXLANGNUM; i++)
{
EncodingInfo *pEncoding = theApp.m_pIntlFont->GetEncodingInfo(i);
if (charset == pEncoding->iPropCharset)
return (pEncoding->iCSID & ~CS_AUTO);
}
return CS_LATIN1;
}
int CIntlFont::DocCSIDtoID(int doc_csid)
{
int i, j;
EncodingInfo *pEncoding ;
pEncoding = &pEncodingInfoTbl[0];
for (i = 0; i < nEncoding; i++)
{
for (j = 0; j < pEncoding->nCodeset; j++)
{
if (doc_csid == pEncoding->csid[j])
{
return i ;
}
}
pEncoding ++ ;
}
// Note!!!: return 0 here is not good idea, but it can avoid crash.
// need to revisit this code later.
return 0;
}
char * CIntlFont::GetEncodingName(int id)
{
if (id < nEncoding)
return szLoadString(pEncodingInfoTbl[id].iLangResId);
else // Never should come here
return "Unknown";
}
void CIntlFont::WriteToIniFile()
{
EncodingInfo *pEncoding;
pEncoding = &pEncodingInfoTbl[0];
for (int i = 0; i < MAXLANGNUM; i++)
{
char key[80];
sprintf(key, "intl.font%d.win.prop_font", pEncoding->iCSID);
PREF_SetCharPref(key, pEncoding->szPropName);
sprintf(key, "intl.font%d.win.fixed_font", pEncoding->iCSID);
PREF_SetCharPref(key, pEncoding->szFixName);
sprintf(key, "intl.font%d.win.prop_size", pEncoding->iCSID);
PREF_SetIntPref(key, (int32)pEncoding->iPropSize);
sprintf(key, "intl.font%d.win.fixed_size", pEncoding->iCSID);
PREF_SetIntPref(key, (int32)pEncoding->iFixSize);
pEncoding ++ ;
}
}
BYTE IntlGetLfCharset(int csid)
{
int id;
if (csid == 0)
csid = INTL_DefaultWinCharSetID(0);
csid = csid & ~CS_AUTO; // mask off AUTO bit
if (csid == 0 || csid == CS_LATIN1 || csid == CS_UNKNOWN)
return ANSI_CHARSET;
id = theApp.m_pIntlFont->DocCSIDtoID(csid);
EncodingInfo *pEncoding = theApp.m_pIntlFont->GetEncodingInfo(id);
return pEncoding->iPropCharset;
}
const char *IntlGetUIFixFaceName(int csid)
{
int id ;
if (csid == 0)
csid = INTL_DefaultWinCharSetID(0);
csid = csid & ~CS_AUTO; // mask off AUTO bit
id = theApp.m_pIntlFont->DocCSIDtoID(csid);
EncodingInfo *pEncoding = theApp.m_pIntlFont->GetEncodingInfo(id);
return pEncoding->szFixName;
}
const char *IntlGetUIPropFaceName(int csid)
{
int id ;
if (csid == 0)
csid = INTL_DefaultWinCharSetID(0);
csid = csid & ~CS_AUTO; // mask off AUTO bit
id = theApp.m_pIntlFont->DocCSIDtoID(csid);
EncodingInfo *pEncoding = theApp.m_pIntlFont->GetEncodingInfo(id);
return pEncoding->szPropName;
}
//------------------------------------------------------------
// Function called from cross-platform code
//------------------------------------------------------------
extern "C" int FE_StrColl(const char* s1, const char* s2)
{
return lstrcmp(s1, s2);
}
extern "C" size_t FE_StrfTime(MWContext *context, char *result, size_t maxsize, int format,
const struct tm *timeptr)
{
#ifdef XP_WIN16
switch(format)
{
case XP_TIME_FORMAT:
return strftime (result, maxsize, "%H:%M", timeptr);
case XP_WEEKDAY_TIME_FORMAT:
return strftime (result, maxsize, "%a %H:%M", timeptr);
case XP_DATE_TIME_FORMAT:
return strftime (result, maxsize, "%x %H:%M", timeptr);
case XP_LONG_DATE_TIME_FORMAT:
return strftime (result, maxsize, "%c", timeptr);
default:
result[0] = '\0';
return 0;
}
#else
int wincsid = INTL_DefaultWinCharSetID(context);
LANGID langid;
langid = GetSystemDefaultLangID();
if ((wincsid & MULTIBYTE) &&
sysInfo.m_bDBCS &&
!((GetSystemDefaultLangID() == 0x0411 && wincsid == CS_SJIS) ||
(GetSystemDefaultLangID() == 0x0412 && wincsid == CS_KSC_8BIT) ||
(GetSystemDefaultLangID() == 0x0812 && wincsid == CS_KSC_8BIT) ||
(GetSystemDefaultLangID() == 0x0804 && wincsid == CS_GB_8BIT) ||
(GetSystemDefaultLangID() == 0x1004 && wincsid == CS_GB_8BIT) ||
(GetSystemDefaultLangID() == 0x0C04 && wincsid == CS_BIG5) ||
(GetSystemDefaultLangID() == 0x0404 && wincsid == CS_BIG5)))
{ // In multibyte, if system doesn't match with current win_csid
switch(format)
{
case XP_TIME_FORMAT:
return strftime (result, maxsize, "%H:%M", timeptr);
case XP_WEEKDAY_TIME_FORMAT:
return strftime (result, maxsize, "%a %H:%M", timeptr);
case XP_DATE_TIME_FORMAT:
return strftime (result, maxsize, "%x %H:%M", timeptr);
case XP_LONG_DATE_TIME_FORMAT:
return strftime (result, maxsize, "%c", timeptr);
default:
result[0] = '\0';
return 0;
}
}
else
{
SYSTEMTIME daytime;
int n, m;
daytime.wYear = 1900 + timeptr->tm_year;
daytime.wMonth = timeptr->tm_mon + 1;
daytime.wDayOfWeek = timeptr->tm_wday;
daytime.wDay = timeptr->tm_mday;
daytime.wHour = timeptr->tm_hour;
daytime.wMinute = timeptr->tm_min;
daytime.wSecond = timeptr->tm_sec;
daytime.wMilliseconds = 0;
*result = '\0';
switch(format)
{
case XP_TIME_FORMAT:
// return strftime (result, maxsize, "%X", timeptr);
if (n = GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &daytime, NULL, result, maxsize))
return n;
else
return strftime (result, maxsize, "%H:%M", timeptr);
case XP_WEEKDAY_TIME_FORMAT:
// return strftime (result, maxsize, "%a %X", timeptr);
if (GetDateFormat(LOCALE_USER_DEFAULT,0,&daytime,"ddd ", result, maxsize))
{
n = strlen(result);
if (m = GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &daytime, NULL, result+n, maxsize-n))
return n + m;
else
return strftime (result, maxsize, "%a %H:%M", timeptr);
}
else
return strftime (result, maxsize, "%a %H:%M", timeptr);
case XP_DATE_TIME_FORMAT:
// return strftime (result, maxsize, "%x %X", timeptr);
if (GetDateFormat(LOCALE_USER_DEFAULT,DATE_SHORTDATE, &daytime,NULL, result, maxsize))
{
n = strlen(result);
result[n++] = ' ';
if (m = GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &daytime, NULL, result+n, maxsize-n))
return m + n;
else
return strftime (result, maxsize, "%x %H:%M", timeptr);
}
else
return strftime (result, maxsize, "%x %H:%M", timeptr);
case XP_LONG_DATE_TIME_FORMAT:
// return strftime (result, maxsize, "%x %X", timeptr);
if (GetDateFormat(LOCALE_USER_DEFAULT,DATE_LONGDATE, &daytime,NULL, result, maxsize))
{
n = strlen(result);
result[n++] = ' ';
if (m = GetTimeFormat(LOCALE_USER_DEFAULT, 0, &daytime, NULL, result+n, maxsize-n))
return m + n;
else
return strftime (result, maxsize, "%x %H:%M", timeptr);
}
else
return strftime (result, maxsize, "%x %H:%M", timeptr);
default:
result[0] = '\0';
return 0;
}
}
#endif
}
CXPResSwitcher g_xpResSwitcher;
/* XP_GetString
*
* This one takes XP string ID (which is used mainly by libnet, libsec)
* and loads String from resource file (netscape.rc3).
*/
extern "C" char *XP_GetString(int id)
{
int16 resid;
resid = id + 7000;
char *buf = szLoadString(resid, &g_xpResSwitcher);
return buf;
}
/*
INTL_DocCharSetID and INTL_DefaultDocCharSetID getting closer and closer
For 2.1, we need to remove one of them.
*/
int INTL_DocCharSetID(MWContext *context)
{
int doccsid;
if (context == NULL)
return theApp.m_iCSID;
else if (doccsid = INTL_GetCSIDocCSID(LO_GetDocumentCharacterSetInfo(context)))
return doccsid;
#ifndef MOZ_NGLAYOUT
else if (context->type == MWContextPrint && ((CPrintCX *)((context)->fe.cx))->m_iCSID)
return ((CPrintCX *)((context)->fe.cx))->m_iCSID;
#endif
else if (GetFrame(context) && GetFrame(context)->m_iCSID)
return GetFrame(context)->m_iCSID;
else
return theApp.m_iCSID;
}
/*
This routine will retrieve default URL charset Id
from conversion engine.
*/
extern int16 INTL_DefaultDocCharSetID(MWContext * context)
{
int doccsid;
if (context == NULL)
return theApp.m_iCSID;
else if (doccsid = INTL_GetCSIDocCSID(LO_GetDocumentCharacterSetInfo(context)))
return doccsid;
#ifndef MOZ_NGLAYOUT
else if (context->type == MWContextPrint && ((CPrintCX *)((context)->fe.cx))->m_iCSID)
return ((CPrintCX *)((context)->fe.cx))->m_iCSID;
#endif
else if (context->type == MWContextSaveToDisk && ((CSaveCX*)((context)->fe.cx))->m_iCSID)
return ((CSaveCX *)((context)->fe.cx))->m_iCSID;
else if (GetFrame(context) && ((CMainFrame *)GetFrame(context))->m_iCSID)
return ((CMainFrame *)GetFrame(context))->m_iCSID;
else
return theApp.m_iCSID;
}
extern "C" uint16 FE_DefaultDocCharSetID(MWContext * context)
{
if (context == NULL)
return theApp.m_iCSID;
#ifndef MOZ_NGLAYOUT
else if (context->type == MWContextPrint && ((CPrintCX *)((context)->fe.cx))->m_iCSID)
return ((CPrintCX *)((context)->fe.cx))->m_iCSID;
#endif
else if (context->type == MWContextSaveToDisk && ((CSaveCX*)((context)->fe.cx))->m_iCSID)
return ((CSaveCX *)((context)->fe.cx))->m_iCSID;
else if (GetFrame(context) && ((CMainFrame *)GetFrame(context))->m_iCSID)
return ((CMainFrame *)GetFrame(context))->m_iCSID;
else
return theApp.m_iCSID;
}
/*
This routine will relayout current document.
It's called from xp rountine to do CharSet conversion
based on new doc_csid found from <Meta ...>
*/
extern void INTL_Relayout(MWContext * pContext)
{
if(pContext == NULL || ABSTRACTCX(pContext) == NULL || ABSTRACTCX(pContext)->IsDestroyed()) {
// Don't allow this to happen if the context has been destroyed...
return;
}
// Let the page load, so that it is in the cache (bug fix 51701)
// or will get a page that is partially "transfer interrupted"
// if just doing a Reload() as that part of the page is
// possibly already cached before the entire page is downloaded
// leading to lossy display.
// Another way to do this is to ignore the cache altogether for a
// more immediate effect: Reload(NET_SUPER_RELOAD)
// but that is not nice to the cache, or the user if working
// offline, etc.
#ifdef EDITOR
if(EDT_IS_EDITOR(pContext)){
EDT_RefreshLayout(pContext);
} else
#endif
ABSTRACTCX(pContext)->NiceReload();
}
/*
See information in
Unicode Functions Supported by Windows 95
PSS ID Number: Q125671
*/
int CIntlWin::m_iConvBufSize = 0;
#ifdef XP_WIN32
LPWSTR CIntlWin::m_wConvBuf = NULL;
#endif
BOOL CIntlWin::FontSelectIgnorePitch(int16 wincsid)
{
return ( (wincsid & MULTIBYTE)
);
}
BOOL CIntlWin::FontSelectIgnoreCharset(int16 wincsid)
{
return ( UseUnicodeFontAPI(wincsid) ||
( CS_USER_DEFINED_ENCODING == wincsid)
);
}
BOOL CIntlWin::AllocConvBuffer(int iLength)
{
#ifdef WIN32
if (m_iConvBufSize == 0)
{
if (iLength < 1024)
iLength = 1024;
m_wConvBuf = (WCHAR *)malloc(iLength);
m_iConvBufSize = iLength;
}
else
{
m_wConvBuf = (WCHAR *) realloc(m_wConvBuf, iLength);
m_iConvBufSize = iLength;
}
#endif
return TRUE;
}
int16 CIntlWin::m_system_locale_csid = 0;
int16 CIntlWin::GetSystemLocaleCsid()
{
if( 0 == m_system_locale_csid )
{
#ifdef XP_WIN32
m_system_locale_csid = CodePageToCsid(GetACP());
#else
m_system_locale_csid = CodePageToCsid(GetKBCodePage()); // In Win3.1 We cannot call GetACP(), we can just call GetKBCodePage()
#endif
}
if( 0 == m_system_locale_csid ) // if still cannot find the csid, Fall back to Latin 1
{
m_system_locale_csid = CS_LATIN1;
}
return m_system_locale_csid;
}
int16 CIntlWin::CodePageToCsid(UINT cp)
{
switch(cp)
{
case 1250:
case 852: // MS-DOS Slavic OEM in the case of Win16 GetKBCodePage
return CS_CP_1250;
case 1251:
case 855: // IBM Cyrillic OEM in the case of Win16 GetKBCodePage
case 866: // MS-DOS Russian OEM in the case of Win16 GetKBCodePage
return CS_CP_1251;
case 1252:
case 437: // US OEM in the case of Win16 GetKBCodePage
case 850: // MS-DOS Multilingual OEM in the case of Win16 GetKBCodePage
case 860: // MS-DOS Portutuese OEM in the case of Win16 GetKBCodePage
case 861: // MS-DOS Icelandic OEM in the case of Win16 GetKBCodePage
case 863: // MS-DOS Canadian-French OEM in the case of Win16 GetKBCodePage
case 865: // MS-DOS Nordic OEM in the case of Win16 GetKBCodePage
return CS_LATIN1;
case 1253:
case 737: // Greek OEM in the case of Win16 GetKBCodePage
case 869: // IBM Modern Greek OEM in the case of Win16 GetKBCodePage
return CS_CP_1253;
case 1254:
case 857: // IBM Turkish OEM in the case of Win16 GetKBCodePage
return CS_CP_1254; // CS_CP_1254;
case 1255:
return CS_UNKNOWN; // CS_CP_1255;
case 1256:
return CS_UNKNOWN; // CS_CP_1256;
case 775: // Baltic OEM in the case of Win16 GetKBCodePage
case 1257:
return CS_UNKNOWN; // CS_CP_1257;
case 932:
return CS_SJIS;
case 936:
return CS_GB_8BIT;
case 949:
case 1361: // Korean (Johab) OEM in the case of Win16 GetKBCodePage
return CS_KSC_8BIT;
case 950:
return CS_BIG5;
default:
return CS_UNKNOWN;
}
}
int CIntlWin::MultiByteToWideChar(int16 wincsid, LPCSTR lpMultiByte, int iLength)
{
if((lpMultiByte == NULL) || (lpMultiByte[0] == '\0') || (iLength == 0))
return 0;
#ifdef WIN32
if (iLength == -1)
iLength = strlen(lpMultiByte);
if (((iLength+1) * 2) > m_iConvBufSize)
AllocConvBuffer((iLength+1) * 2);
iLength = INTL_TextToUnicode(wincsid, (unsigned char*)lpMultiByte, iLength, m_wConvBuf, m_iConvBufSize) ;
#endif
return iLength;
}
//
// UseUnicodeFontAPI return
//
// csid Latin1/Symbol/ UTF8 MultiByte Other Single Byte
// UserDefined/Digbats J/K/SC/TC CE/Greek/Cyr/Turk
// Platform
// Win 95 NonDB FALSE TRUE TRUE FALSE (Need test)
// Win NT NonDB FALSE TRUE TRUE TRUE (Need test)
// Win 95 DB FALSE TRUE (1) FALSE
// Win NT DB FALSE TRUE (1) TRUE(2)
//
// (1) FALSE if it is equal to the system locale's csid.
// (2) Could be true or false. But need more work for Edit control if use TRUE
//
#ifdef XP_WIN32
static BOOL intlUnicodeFlag(int16 wincsid)
{
if(! theApp.m_bUseUnicodeFont)
return FALSE;
if(0 == wincsid) // Unknown csid
return FALSE;
if(CS_UTF8 == wincsid)
return TRUE;
if( (CS_LATIN1 == wincsid) || (CS_SYMBOL == wincsid) ||
(CS_DINGBATS == wincsid) || (CS_USER_DEFINED_ENCODING == wincsid))
{
return FALSE;
}
if( wincsid & MULTIBYTE)
{
if(CIntlWin::GetSystemLocaleCsid() == wincsid)
return FALSE;
else
return TRUE;
}
else // Other SingleByte csid
{
if(sysInfo.m_bWinNT)
return TRUE;
else
return FALSE;
}
}
#endif
BOOL CIntlWin::UseVirtualFont()
{
return theApp.m_bUseVirtualFont;
}
BOOL CIntlWin::GetTextExtentPoint(int wincsid, HDC hDC, LPCSTR pString, int iLength, LPSIZE lpSize)
{
#ifdef MOZ_NGLAYOUT
XP_ASSERT(0);
return FALSE;
#else
if(0 == iLength)
{
lpSize->cx = 0;
lpSize->cy = 0;
return TRUE;
}
wincsid = INTL_DocToWinCharSetID(wincsid) & ~ CS_AUTO;
#ifdef XP_WIN32
int wlen;
if ( CIntlWin::UseUnicodeFontAPI(wincsid))
{
// Handle UTF8 by using multifont
if((wincsid == CS_UTF8) && CIntlWin::UseVirtualFont())
{
return CIntlUnicodeVirtualFontStrategy::GetTextExtentPoint(hDC, pString, iLength, lpSize );
}
if(wlen = MultiByteToWideChar(wincsid, pString, iLength))
{
return ::GetTextExtentPoint32W(hDC, m_wConvBuf, wlen, lpSize);
}
}
#endif // XP_WIN32
if(wincsid == CS_UTF8)
{
return CIntlUnicodeVirtualFontStrategy::GetTextExtentPoint(hDC, pString, iLength, lpSize );
}
#ifdef XP_WIN32 // The final fallback
return::GetTextExtentPoint32(hDC, pString, iLength, lpSize);
#else
return::GetTextExtentPoint(hDC, pString, iLength, lpSize);
#endif
#endif /* MOZ_NGLAYOUT */
}
BOOL CIntlWin::GetTextExtentPointWithCyaFont(CyaFont *theNSFont,int wincsid, HDC hDC, LPCSTR pString, int iLength, LPSIZE lpSize)
{
#ifdef MOZ_NGLAYOUT
XP_ASSERT(0);
return FALSE;
#else
if(0 == iLength)
{
lpSize->cx = 0;
lpSize->cy = 0;
return TRUE;
}
// wincsid = INTL_DocToWinCharSetID(wincsid) & ~ CS_AUTO;
XP_ASSERT(((wincsid & CS_AUTO) == 0) && (wincsid != CS_JIS) && (wincsid!=CS_EUCJP));
#ifdef XP_WIN32
int wlen;
if ( CIntlWin::UseUnicodeFontAPI(wincsid))
{
// Handle UTF8 by using multifont
if((wincsid == CS_UTF8) && CIntlWin::UseVirtualFont())
{
return CIntlUnicodeVirtualFontStrategy::GetTextExtentPointWithCyaFont(theNSFont,hDC, pString, iLength, lpSize );
}
if(wlen = MultiByteToWideChar(wincsid, pString, iLength))
{
return theNSFont->MeasureTextSize(hDC, (char *)m_wConvBuf, wlen*sizeof(*m_wConvBuf), NULL, 0, lpSize);
}
}
#endif // XP_WIN32
if(wincsid == CS_UTF8)
{
return CIntlUnicodeVirtualFontStrategy::GetTextExtentPointWithCyaFont(theNSFont,hDC, pString, iLength, lpSize );
}
return( theNSFont->MeasureTextSize( hDC, (char *)pString, iLength, NULL, 0, lpSize) );
// #ifdef XP_WIN32 // The final fallback
// return::GetTextExtentPoint32(hDC, pString, iLength, lpSize);
// #else
// return::GetTextExtentPoint(hDC, pString, iLength, lpSize);
// #endif
#endif /* MOZ_NGLAYOUT */
}
CSize CIntlWin::GetTextExtent(int16 wincsid, HDC pDC, LPCTSTR pString, int iLength)
{
CSize csSize;
BOOL bRetval;
bRetval = CIntlWin::GetTextExtentPoint(wincsid, pDC, pString, iLength, &csSize);
return(csSize);
}
BOOL CIntlWin::TextOut(int16 wincsid, HDC hDC, int nXStart, int nYStart, LPCSTR lpString,int iLength)
{
#ifdef MOZ_NGLAYOUT
XP_ASSERT(0);
return FALSE;
#else
if(0 == iLength)
return TRUE;
wincsid = INTL_DocToWinCharSetID(wincsid) & ~ CS_AUTO;
#ifdef XP_WIN32
int wlen;
if ( CIntlWin::UseUnicodeFontAPI(wincsid))
{
// Handle UTF8 by using multifont
if((wincsid == CS_UTF8) && CIntlWin::UseVirtualFont())
{
return CIntlUnicodeVirtualFontStrategy::TextOut(
hDC, nXStart, nYStart, lpString, iLength);
}
if(wlen = MultiByteToWideChar(wincsid, lpString, iLength))
{
return ::TextOutW(hDC, nXStart, nYStart, m_wConvBuf, wlen);
}
}
#endif // XP_WIN32
if(wincsid == CS_UTF8)
{
return CIntlUnicodeVirtualFontStrategy::TextOut(hDC, nXStart, nYStart, lpString, iLength);
}
return ::TextOut(hDC, nXStart, nYStart, lpString, iLength); // The final fallback
#endif /* MOZ_NGLAYOUT */
}
//based on BOOL CIntlWin::TextOut(int16 wincsid, HDC hDC, int nXStart, int nYStart, LPCSTR lpString,int iLength)
BOOL CIntlWin::TextOutWithCyaFont(CyaFont *theNSFont, int16 wincsid, HDC hDC,
int nXStart, int nYStart, LPCSTR lpString,int iLength)
{
#ifdef MOZ_NGLAYOUT
XP_ASSERT(0);
return FALSE;
#else
if(0 == iLength)
return TRUE;
#ifdef XP_WIN32
int wlen;
if ( CIntlWin::UseUnicodeFontAPI(wincsid))
{
// Handle UTF8 by using multifont
if((wincsid == CS_UTF8) && CIntlWin::UseVirtualFont())
{
return( CIntlUnicodeVirtualFontStrategy::TextOutWithCyaFont(theNSFont, hDC, nXStart, nYStart, lpString, iLength) );
}
if(wlen = MultiByteToWideChar(wincsid, lpString, iLength))
{
// the encording flag in theNSFont makes it call ::TextOutW()
if( theNSFont->drawText(hDC, nXStart, nYStart, (char *)m_wConvBuf, wlen * 2) == FONTERR_OK)
return(TRUE);
else
return(FALSE);
// return ::TextOutW(hDC, nXStart, nYStart, m_wConvBuf, wlen);
}
}
#endif // XP_WIN32
if(wincsid == CS_UTF8)
{
// todo
return CIntlUnicodeVirtualFontStrategy::TextOut(hDC, nXStart, nYStart, lpString, iLength);
}
//return ::TextOut(hDC, nXStart, nYStart, lpString, iLength); // The final fallback
if( theNSFont->drawText(hDC, nXStart, nYStart, (char *)lpString, iLength) == FONTERR_OK )
return(TRUE);
else
return(FALSE);
#endif /* MOZ_NGLAYOUT */
}
// *** Fix Me: Need to change to support UTF8
BOOL CIntlWin::ExtTextOut(int16 wincsid, HDC pDC, int x, int y, UINT nOptions, LPCRECT lpRect, LPCSTR lpszString, UINT nCount, LPINT lpDxWidths)
{
#ifdef MOZ_NGLAYOUT
XP_ASSERT(0);
return FALSE;
#else
if(0 == nCount)
return TRUE;
wincsid = INTL_DocToWinCharSetID(wincsid) & ~ CS_AUTO;
#ifdef XP_WIN32
int wlen;
if ( CIntlWin::UseUnicodeFontAPI(wincsid))
{
// Handle UTF8 by using multifont
if((wincsid == CS_UTF8) && CIntlWin::UseVirtualFont())
{
// Fix Me: For now, igore the option and rect. Just use TextOut
// Need to implement the CIntlUnicodeVirtualFontStrategy::ExTextOut() later
return CIntlUnicodeVirtualFontStrategy::TextOut(
pDC, x, y, lpszString, nCount);
}
if(wlen = MultiByteToWideChar(wincsid, lpszString, nCount))
{
return ::ExtTextOutW(pDC, x, y, nOptions, lpRect, m_wConvBuf, wlen, lpDxWidths);
}
}
#endif
if(wincsid == CS_UTF8)
{
// Fix Me: For now, igore the option and rect. Just use TextOut
// Need to implement the CIntlUnicodeVirtualFontStrategy::ExTextOut() later
return CIntlUnicodeVirtualFontStrategy::TextOut(
pDC, x, y, lpszString, nCount);
}
return ::ExtTextOut(pDC, x, y, nOptions, lpRect, lpszString, nCount, lpDxWidths);
#endif /* MOZ_NGLAYOUT */
}
#ifdef XP_WIN32
int CIntlWin::DrawTextEx(int16 wincsid, HDC hdc, LPSTR lpchText, int cchText,LPRECT lprc,UINT dwDTFormat,LPDRAWTEXTPARAMS lpDTParams)
{
#ifdef MOZ_NGLAYOUT
XP_ASSERT(0);
return 0;
#else
wincsid = INTL_DocToWinCharSetID(wincsid) & ~ CS_AUTO;
int iRetval;
int wlen;
if (cchText == -1)
cchText = strlen(lpchText);
if ( CIntlWin::UseUnicodeFontAPI(wincsid))
{
// DrawTextExW and DrawTextW is not working on Win95 right now. See Note above
if( (!((wincsid == CS_UTF8) && CIntlWin::UseVirtualFont()))
&& (sysInfo.m_bWinNT)
&& (wlen = MultiByteToWideChar(wincsid, lpchText, cchText))
)
{
return ::DrawTextW(hdc, m_wConvBuf, wlen, lprc, dwDTFormat);
}
int x, y;
SIZE sz;
CIntlWin::GetTextExtentPoint(wincsid, hdc, lpchText, cchText, &sz);
// Caculate X
x = lprc->left;
if(dwDTFormat & DT_CENTER)
x = (lprc->right + lprc->right - sz.cx) / 2;
else if(dwDTFormat & DT_RIGHT)
x = lprc->right - sz.cx;
// Caculate Y
y = lprc->top ;
if(dwDTFormat & DT_VCENTER)
y = ( lprc->top + lprc->bottom - sz.cy ) / 2;
else if(dwDTFormat & DT_BOTTOM)
y = lprc->bottom - sz.cy;
if(dwDTFormat & DT_CALCRECT)
{
lprc->right = x + sz.cx;
return sz.cy;
}
return CIntlWin::TextOut(wincsid, hdc, x, y, lpchText, cchText);
}
else
{
if (sysInfo.m_bWinNT)
iRetval = ::DrawText(hdc, lpchText, cchText, lprc, dwDTFormat);
else
iRetval = ::DrawTextEx(hdc, lpchText, cchText, lprc, dwDTFormat, lpDTParams);
}
return iRetval;
#endif /* MOZ_NGLAYOUT */
}
#endif
int CIntlWin::DrawText(int16 wincsid, HDC hdc, LPSTR lpchText, int cchText,LPRECT lprc,UINT dwDTFormat)
{
#ifdef MOZ_NGLAYOUT
XP_ASSERT(0);
return 0;
#else
#ifdef _WIN32
return CIntlWin::DrawTextEx( wincsid, hdc, lpchText, cchText, lprc, dwDTFormat, NULL);
#else
wincsid = INTL_DocToWinCharSetID(wincsid) & ~ CS_AUTO;
if (cchText == -1)
cchText = strlen(lpchText);
if(wincsid == CS_UTF8)
{
int x, y;
SIZE sz;
CIntlUnicodeVirtualFontStrategy::GetTextExtentPoint(hdc, lpchText, cchText, &sz);
// Caculate X
x = lprc->left;
if(dwDTFormat & DT_CENTER)
x = (lprc->right + lprc->right - sz.cx) / 2;
else if(dwDTFormat & DT_RIGHT)
x = lprc->right - sz.cx;
// Caculate Y
y = lprc->top;
if(dwDTFormat & DT_VCENTER)
y = ( lprc->top + lprc->bottom - sz.cy ) / 2;
else if(dwDTFormat & DT_BOTTOM)
y = lprc->bottom - sz.cy;
if(dwDTFormat & DT_CALCRECT)
{
lprc->right = x + sz.cx;
return sz.cy;
}
return CIntlUnicodeVirtualFontStrategy::TextOut(hdc, x, y, lpchText, cchText);
}
return ::DrawText(hdc, lpchText, cchText, lprc, dwDTFormat );
#endif
#endif /* MOZ_NGLAYOUT */
}
extern "C" void *FE_GetSingleByteTable(int16 from_csid, int16 to_csid, int resourceid)
{
HRSRC hrsrc;
HGLOBAL hRes;
char szName[256];
strcpy(szName, (const char *)INTL_CsidToCharsetNamePt(from_csid));
strcpy(szName + strlen(szName), "_TO_");
strcpy(szName + strlen(szName), (const char *)INTL_CsidToCharsetNamePt(to_csid));
for (char *p = szName; *p; p++)
{
if (*p == '-') *p = '_';
}
hrsrc = ::FindResource(AfxGetResourceHandle(), szName, RT_RCDATA);
XP_ASSERT(hrsrc);
if (!hrsrc) {
TRACE1("FE_GetSingleByteTable cannot find resource: %s\n", szName);
return NULL;
}
hRes = ::LoadResource(AfxGetResourceHandle(), hrsrc);
XP_ASSERT(hRes);
if (!hRes) {
TRACE1("FE_GetSingleByteTable cannot load resource: %s\n", szName);
return NULL;
}
return (void *) hRes;
}
extern "C" char *FE_LockTable(void **hres)
{
return (LPSTR)::LockResource((HGLOBAL) hres);
}
extern "C" void FE_FreeSingleByteTable(void **hres)
{
#ifndef XP_WIN32
::UnlockResource((HGLOBAL) hres);
#endif
::FreeResource((HGLOBAL) hres);
}
/*--------------------------------------------------------------------------*/
#define MAXNUMOFCSIDLIST 64
#define UNICODECONVERSIONCHARTLIST "UnicodeConversionCharsetList"
#ifdef XP_WIN32
#define UNICODEDLL "UNI3200.DLL"
#define LIBRARYLOADOK(l) (l != NULL)
#define UNICODE_VERIFYCSIDLIST_SYM "UNICODE_VERIFYCSIDLIST"
#else
#define UNICODEDLL "UNI1600.DLL"
#define LIBRARYLOADOK(l) (l > HINSTANCE_ERROR)
#define UNICODE_VERIFYCSIDLIST_SYM "_UNICODE_VERIFYCSIDLIST"
#endif
static int intl_VerifyCsidList(int inNumOfItem, int16 *csidlist)
{
int iRetval = 0;
HINSTANCE hUniLib = LoadLibrary(UNICODEDLL);
if(LIBRARYLOADOK(hUniLib)) {
typedef int (*func)(int, int16 *);
func VerifyProc = (func)GetProcAddress(hUniLib, UNICODE_VERIFYCSIDLIST_SYM);
ASSERT(VerifyProc);
if(VerifyProc) {
iRetval = VerifyProc(inNumOfItem, csidlist);
VerifyProc = NULL;
}
FreeLibrary(hUniLib);
hUniLib = NULL;
}
return(iRetval);
}
//
// Read and Write charset List for Unicode conversion
//
static void intl_ReadUnicodeConvList()
{
CString charsetlist;
int16 csidlist[MAXNUMOFCSIDLIST];
int num_of_csid;
// Find the charsetlist from preference
charsetlist = theApp.GetProfileString("INTL", UNICODECONVERSIONCHARTLIST, "");
// If we cannot find it from preference , find it from resource
if(strlen((const char*)charsetlist) == 0)
charsetlist = szLoadString(IDS_CHARSET_LIST_FOR_UNICODE);
// Otherwise, it is very wrong, however, we still give it
// CS_LATIN1 , CS_SYMBOL, and CS_DINGBATS
if(strlen((const char*)charsetlist) == 0)
charsetlist =
"iso-8859-1,x-cp1250,x-cp1251,x-cp1253,iso-8859-9,Shift_JIS,euc-kr,gb2312,big5,adobe-symbol-encoding,x-dingbats";
for(num_of_csid=0; num_of_csid < MAXNUMOFCSIDLIST; )
{
int duplicate;
int csid;
int i;
int lastone = 0;
int len = charsetlist.GetLength();
int thislen = charsetlist.Find(',');
if(thislen == -1)
{
lastone = 1;
thislen = len;
}
csid=INTL_CharSetNameToID((char *)(const char *)charsetlist.Left(thislen));
// Check to see is that duplicate ?
for(i=0, duplicate=0;i < num_of_csid; i ++)
{
if(csid == csidlist[i])
duplicate = 1;
}
// If not duplicate, add it to the list
if(duplicate == 0 )
csidlist[num_of_csid++] = csid;
if(lastone == 0 )
charsetlist = charsetlist.Right(len - thislen - 1);
else
break;
}
// Write it to the Prefs
intl_WriteUnicodeConvList(num_of_csid, csidlist);
// Filter through our csid checking code - intl_VerifyCsidList()
num_of_csid = intl_VerifyCsidList(num_of_csid, csidlist);
// OK, now we have the list. Call the xp function to initialize
// Unicode Converter
INTL_SetUnicodeCSIDList(num_of_csid, csidlist);
}
static void intl_WriteUnicodeConvList(int num_of_csid, int16* csidlist)
{
char str[512];
int first, i;
char * cur;
// Now, convert those csid to string
for(first=1,i=0,cur=str;i < num_of_csid;i++)
{
if(first)
first = 0;
else
*cur++ = ',';
INTL_CharSetIDToName(csidlist[i], cur);
cur += strlen(cur);
}
// And write to the Profile
theApp.WriteProfileString("INTL", UNICODECONVERSIONCHARTLIST, str);
}
extern "C" {
BYTE IntlGetJavaCharset(int csid, int javaFontID)
{
// currently, we ignore javaFontID. We may need to use it later
switch(csid)
{
case CS_DINGBATS:
case CS_SYMBOL:
return SYMBOL_CHARSET;
default:
return IntlGetLfCharset(csid);
}
}
const char* IntlGetJavaFaceName(int csid, int javaFontID)
{
switch(csid)
{
case CS_DINGBATS:
return "Wingdings";
case CS_SYMBOL:
return "Symbol";
default:
switch(javaFontID)
{
case javaFontTimesRoman:
case javaFontDialog:
case javaFontHelvetica:
return IntlGetUIPropFaceName(csid);
case javaFontDialogInput:
case javaFontCourier:
return IntlGetUIFixFaceName(csid);
default:
return IntlGetUIPropFaceName(csid);
}
}
}
};
extern "C" {
PR_PUBLIC_API(const char* )
INTLGETJAVAFACENAME_E(int csid, int javaFontID)
{ return IntlGetJavaFaceName(csid, javaFontID); }
PR_PUBLIC_API(BYTE )
INTLGETJAVACHARSET_E(int csid, int javaFontID)
{ return IntlGetJavaCharset(csid, javaFontID); }
PR_PUBLIC_API(int16* )
INTL_GETUNICODECSIDLIST_E(int16 * outnum)
{ return INTL_GetUnicodeCSIDList(outnum); }
PR_PUBLIC_API(int32 )
INTL_UNICODELEN_E(uint16* ustr)
{ return INTL_UnicodeLen(ustr); }
PR_PUBLIC_API(INTL_CompoundStr* )
INTL_COMPOUNDSTRFROMUNICODE_E(uint16* inunicode, uint32 inlen)
{ return INTL_CompoundStrFromUnicode(inunicode, inlen); }
PR_PUBLIC_API(void )
INTL_COMPOUNDSTRDESTROY_E(INTL_CompoundStr* This)
{ INTL_CompoundStrDestroy(This); }
PR_PUBLIC_API(INTL_CompoundStrIterator )
INTL_COMPOUNDSTRFIRSTSTR_E(INTL_CompoundStr* This, INTL_Encoding_ID *outencoding, unsigned char** outtext)
{ return INTL_CompoundStrFirstStr(This, outencoding,outtext); }
PR_PUBLIC_API(INTL_CompoundStrIterator )
INTL_COMPOUNDSTRNEXTSTR_E(INTL_CompoundStrIterator iterator, INTL_Encoding_ID *outencoding, unsigned char** outtext)
{ return INTL_CompoundStrNextStr(iterator, outencoding, outtext); }
PR_PUBLIC_API(INTL_CompoundStr* )
INTL_COMPOUNDSTRCLONE_E(INTL_CompoundStr* s1)
{ return INTL_CompoundStrClone(s1); }
PR_PUBLIC_API(int16 )
INTL_DEFAULTWINCHARSETID_E(MWContext *context)
{ return INTL_DefaultWinCharSetID(context); }
PR_PUBLIC_API(int32 )
INTL_TEXTBYTECOUNTTOCHARLEN_E(int16 csid, unsigned char* text, uint32 byteCount)
{ return INTL_TextByteCountToCharLen(csid, text, byteCount); }
PR_PUBLIC_API(int32 )
INTL_TEXTCHARLENTOBYTECOUNT_E(int16 csid, unsigned char* text, uint32 charLen)
{ return INTL_TextCharLenToByteCount(csid, text, charLen); }
PR_PUBLIC_API(uint32 )
INTL_UNICODETOSTRLEN_E(INTL_Encoding_ID encoding,INTL_Unicode* ustr, uint32 ustrlen)
{ return INTL_UnicodeToStrLen(encoding,ustr,ustrlen); }
PR_PUBLIC_API(void )
INTL_UNICODETOSTR_E(INTL_Encoding_ID encoding,INTL_Unicode* ustr,uint32 ustrlen,unsigned char* dest, uint32 destbuflen)
{ INTL_UnicodeToStr(encoding,ustr,ustrlen,dest,destbuflen); }
#ifdef JAVA
PR_PUBLIC_API(jref * )
INTL_MAKEJAVASTRING_E(int16 encoding, char *str, int len)
{ return intl_makeJavaString(encoding, str, len); }
#endif // JAVA
PR_PUBLIC_API(BOOL )
CINTLWIN_TEXTOUT_E(int16 wincsid, HDC hdc, int nXStart, int nYStart, LPCSTR lpString,int iLength)
{ return CIntlWin::TextOut( wincsid, hdc, nXStart, nYStart, lpString, iLength); }
PR_PUBLIC_API(BOOL )
CINTLWIN_GETTEXTEXTENTPOINT_E(int wincsid, HDC hDC, LPCSTR lpString, int cbString, LPSIZE lpSize)
{ return CIntlWin::GetTextExtentPoint( wincsid, hDC, lpString, cbString, lpSize); }
}; // extern "C"
Reference in New Issue View Git Blame Copy Permalink