archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 827363a95b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '827363a95b'
${ noResults }
windows-server-2003/shell/ext/mlang/mlflink.cpp

3924 lines
116 KiB
Raw Blame History

// MLFLink.cpp : Implementation of CMLFLink
#include "private.h"
#include "mlmain.h"
#include "codepage.h"
#ifdef UNIX
inline WORD READWINTELWORD(WORD w)
{
return ( w << 8 | w >> 8 );
}
inline DWORD READWINTELDWORD(DWORD dw)
{
return READWINTELWORD( (WORD)(dw >> 16 )) | ((DWORD)READWINTELWORD( dw & 0xffff)) << 16;
}
#else
#define READWINTELWORD
#define READWINTELDWORD
#endif
IMLangFontLink *g_pMLFLink = NULL;
CMLFLink::CCodePagesCache* CMLFLink::m_pCodePagesCache = NULL;
CMLFLink::CFontMappingCache* CMLFLink::m_pFontMappingCache = NULL;
CMLFLink2::CFontMappingCache2* CMLFLink2::m_pFontMappingCache2 = NULL;
// Strings to identify regular font
const char szRegular[] = "Regular";
const char szNormal[] = "Normal";
// font table
FONTINFO *g_pfont_table = NULL;
// Unicode range table for non Windows code page code points
// Data is provided by NT international group.
URANGEFONT g_urange_table[] = {
{0x0108, 0x010B, 0},
{0x0114, 0x0115, 0},
{0x011C, 0x011D, 0},
{0x0120, 0x0121, 0},
{0x0124, 0x0125, 0},
{0x0128, 0x0129, 0},
{0x012C, 0x012D, 0},
{0x0134, 0x0135, 0},
{0x014E, 0x014F, 0},
{0x015C, 0x015D, 0},
{0x0168, 0x0169, 0},
{0x016C, 0x016D, 0},
{0x0174, 0x0177, 0},
{0x017F, 0x0191, 0},
{0x0193, 0x019F, 0},
{0x01A2, 0x01AE, 0},
{0x01B1, 0x01CD, 0},
{0x01CF, 0x01CF, 0},
{0x01D1, 0x01D1, 0},
{0x01D3, 0x01D3, 0},
{0x01D5, 0x01D5, 0},
{0x01D7, 0x01D7, 0},
{0x01D9, 0x01D9, 0},
{0x01DB, 0x01DB, 0},
{0x01DD, 0x01F5, 0},
{0x01FA, 0x0217, 0},
{0x0250, 0x0250, 0},
{0x0252, 0x0260, 0},
{0x0262, 0x02A8, 0},
{0x02B0, 0x02C5, 0},
{0x02C8, 0x02C8, 0},
{0x02CC, 0x02CC, 0},
{0x02CE, 0x02CF, 0},
{0x02D1, 0x02D7, 0},
{0x02DE, 0x02DE, 0},
{0x02E0, 0x02E9, 0},
{0x0302, 0x0302, 0},
{0x0304, 0x0308, 0},
{0x030A, 0x0322, 0},
{0x0324, 0x0345, 0},
{0x0360, 0x0361, 0},
{0x0374, 0x0375, 0},
{0x037A, 0x037A, 0},
{0x037E, 0x037E, 0},
{0x0387, 0x0387, 0},
{0x03D0, 0x03D6, 0},
{0x03DA, 0x03DA, 0},
{0x03DC, 0x03DC, 0},
{0x03DE, 0x03DE, 0},
{0x03E0, 0x03E0, 0},
{0x03E2, 0x03F3, 0},
{0x0460, 0x0486, 0},
{0x0492, 0x04C4, 0},
{0x04C7, 0x04C8, 0},
{0x04CB, 0x04CC, 0},
{0x04D0, 0x04EB, 0},
{0x04EE, 0x04F5, 0},
{0x04F8, 0x04F9, 0},
{0x0531, 0x0556, 0},
{0x0559, 0x055F, 0},
{0x0561, 0x0587, 0},
{0x0589, 0x0589, 0},
{0x0591, 0x05A1, 0},
{0x05A3, 0x05AF, 0},
{0x05C4, 0x05C4, 0},
{0x0660, 0x066D, 0},
{0x0670, 0x067D, 0},
{0x067F, 0x0685, 0},
{0x0687, 0x0697, 0},
{0x0699, 0x06AE, 0},
{0x06B0, 0x06B7, 0},
{0x06BA, 0x06BE, 0},
{0x06C0, 0x06CE, 0},
{0x06D0, 0x06ED, 0},
{0x06F0, 0x06F9, 0},
{0x0901, 0x0903, 0},
{0x0905, 0x0939, 0},
{0x093C, 0x094D, 0},
{0x0950, 0x0954, 0},
{0x0958, 0x0970, 0},
{0x0981, 0x0983, 0},
{0x0985, 0x098C, 0},
{0x098F, 0x0990, 0},
{0x0993, 0x09A8, 0},
{0x09AA, 0x09B0, 0},
{0x09B2, 0x09B2, 0},
{0x09B6, 0x09B9, 0},
{0x09BC, 0x09BC, 0},
{0x09BE, 0x09C4, 0},
{0x09C7, 0x09C8, 0},
{0x09CB, 0x09CD, 0},
{0x09D7, 0x09D7, 0},
{0x09DC, 0x09DD, 0},
{0x09DF, 0x09E3, 0},
{0x09E6, 0x09FA, 0},
{0x0A02, 0x0A02, 0},
{0x0A05, 0x0A0A, 0},
{0x0A0F, 0x0A10, 0},
{0x0A13, 0x0A28, 0},
{0x0A2A, 0x0A30, 0},
{0x0A32, 0x0A33, 0},
{0x0A35, 0x0A36, 0},
{0x0A38, 0x0A39, 0},
{0x0A3C, 0x0A3C, 0},
{0x0A3E, 0x0A42, 0},
{0x0A47, 0x0A48, 0},
{0x0A4B, 0x0A4D, 0},
{0x0A59, 0x0A5C, 0},
{0x0A5E, 0x0A5E, 0},
{0x0A66, 0x0A74, 0},
{0x0A81, 0x0A83, 0},
{0x0A85, 0x0A8B, 0},
{0x0A8D, 0x0A8D, 0},
{0x0A8F, 0x0A91, 0},
{0x0A93, 0x0AA8, 0},
{0x0AAA, 0x0AB0, 0},
{0x0AB2, 0x0AB3, 0},
{0x0AB5, 0x0AB9, 0},
{0x0ABC, 0x0AC5, 0},
{0x0AC7, 0x0AC9, 0},
{0x0ACB, 0x0ACD, 0},
{0x0AD0, 0x0AD0, 0},
{0x0AE0, 0x0AE0, 0},
{0x0AE6, 0x0AEF, 0},
{0x0B01, 0x0B03, 0},
{0x0B05, 0x0B0C, 0},
{0x0B0F, 0x0B10, 0},
{0x0B13, 0x0B28, 0},
{0x0B2A, 0x0B30, 0},
{0x0B32, 0x0B33, 0},
{0x0B36, 0x0B39, 0},
{0x0B3C, 0x0B43, 0},
{0x0B47, 0x0B48, 0},
{0x0B4B, 0x0B4D, 0},
{0x0B56, 0x0B57, 0},
{0x0B5C, 0x0B5D, 0},
{0x0B5F, 0x0B61, 0},
{0x0B66, 0x0B70, 0},
{0x0B82, 0x0B83, 0},
{0x0B85, 0x0B8A, 0},
{0x0B8E, 0x0B90, 0},
{0x0B92, 0x0B95, 0},
{0x0B99, 0x0B9A, 0},
{0x0B9C, 0x0B9C, 0},
{0x0B9E, 0x0B9F, 0},
{0x0BA3, 0x0BA4, 0},
{0x0BA8, 0x0BAA, 0},
{0x0BAE, 0x0BB5, 0},
{0x0BB7, 0x0BB9, 0},
{0x0BBE, 0x0BC2, 0},
{0x0BC6, 0x0BC8, 0},
{0x0BCA, 0x0BCD, 0},
{0x0BD7, 0x0BD7, 0},
{0x0BE7, 0x0BF2, 0},
{0x0C01, 0x0C03, 0},
{0x0C05, 0x0C0C, 0},
{0x0C0E, 0x0C10, 0},
{0x0C12, 0x0C28, 0},
{0x0C2A, 0x0C33, 0},
{0x0C35, 0x0C39, 0},
{0x0C3E, 0x0C44, 0},
{0x0C46, 0x0C48, 0},
{0x0C4A, 0x0C4D, 0},
{0x0C55, 0x0C56, 0},
{0x0C60, 0x0C61, 0},
{0x0C66, 0x0C6F, 0},
{0x0C82, 0x0C83, 0},
{0x0C85, 0x0C8C, 0},
{0x0C8E, 0x0C90, 0},
{0x0C92, 0x0CA8, 0},
{0x0CAA, 0x0CB3, 0},
{0x0CB5, 0x0CB9, 0},
{0x0CBE, 0x0CC4, 0},
{0x0CC6, 0x0CC8, 0},
{0x0CCA, 0x0CCD, 0},
{0x0CD5, 0x0CD6, 0},
{0x0CDE, 0x0CDE, 0},
{0x0CE0, 0x0CE1, 0},
{0x0CE6, 0x0CEF, 0},
{0x0D02, 0x0D03, 0},
{0x0D05, 0x0D0C, 0},
{0x0D0E, 0x0D10, 0},
{0x0D12, 0x0D28, 0},
{0x0D2A, 0x0D39, 0},
{0x0D3E, 0x0D43, 0},
{0x0D46, 0x0D48, 0},
{0x0D4A, 0x0D4D, 0},
{0x0D57, 0x0D57, 0},
{0x0D60, 0x0D61, 0},
{0x0D66, 0x0D6F, 0},
{0x0E81, 0x0E82, 0},
{0x0E84, 0x0E84, 0},
{0x0E87, 0x0E88, 0},
{0x0E8A, 0x0E8A, 0},
{0x0E8D, 0x0E8D, 0},
{0x0E94, 0x0E97, 0},
{0x0E99, 0x0E9F, 0},
{0x0EA1, 0x0EA3, 0},
{0x0EA5, 0x0EA5, 0},
{0x0EA7, 0x0EA7, 0},
{0x0EAA, 0x0EAB, 0},
{0x0EAD, 0x0EB9, 0},
{0x0EBB, 0x0EBD, 0},
{0x0EC0, 0x0EC4, 0},
{0x0EC6, 0x0EC6, 0},
{0x0EC8, 0x0ECD, 0},
{0x0ED0, 0x0ED9, 0},
{0x0EDC, 0x0EDD, 0},
{0x0F00, 0x0F47, 0},
{0x0F49, 0x0F69, 0},
{0x0F71, 0x0F8B, 0},
{0x0F90, 0x0F95, 0},
{0x0F97, 0x0F97, 0},
{0x0F99, 0x0FAD, 0},
{0x0FB1, 0x0FB7, 0},
{0x0FB9, 0x0FB9, 0},
{0x10A0, 0x10C5, 0},
{0x10D0, 0x10F6, 0},
{0x10FB, 0x10FB, 0},
{0x1100, 0x1159, 0},
{0x115F, 0x11A2, 0},
{0x11A8, 0x11F9, 0},
{0x1E00, 0x1E9B, 0},
{0x1EA0, 0x1EF9, 0},
{0x1F00, 0x1F15, 0},
{0x1F18, 0x1F1D, 0},
{0x1F20, 0x1F45, 0},
{0x1F48, 0x1F4D, 0},
{0x1F50, 0x1F57, 0},
{0x1F59, 0x1F59, 0},
{0x1F5B, 0x1F5B, 0},
{0x1F5D, 0x1F5D, 0},
{0x1F5F, 0x1F7D, 0},
{0x1F80, 0x1FB4, 0},
{0x1FB6, 0x1FC4, 0},
{0x1FC6, 0x1FD3, 0},
{0x1FD6, 0x1FDB, 0},
{0x1FDD, 0x1FEF, 0},
{0x1FF2, 0x1FF4, 0},
{0x1FF6, 0x1FFE, 0},
{0x2000, 0x200B, 0},
{0x2011, 0x2012, 0},
{0x2017, 0x2017, 0},
{0x201B, 0x201B, 0},
{0x201F, 0x201F, 0},
{0x2023, 0x2024, 0},
{0x2028, 0x202E, 0},
{0x2031, 0x2031, 0},
{0x2034, 0x2034, 0},
{0x2036, 0x2038, 0},
{0x203C, 0x2046, 0},
{0x206A, 0x2070, 0},
{0x2075, 0x207E, 0},
{0x2080, 0x2080, 0},
{0x2085, 0x208E, 0},
{0x20A0, 0x20A9, 0},
{0x20D0, 0x20E1, 0},
{0x2100, 0x2102, 0},
{0x2104, 0x2104, 0},
{0x2106, 0x2108, 0},
{0x210A, 0x2112, 0},
{0x2114, 0x2115, 0},
{0x2117, 0x2120, 0},
{0x2123, 0x2125, 0},
{0x2127, 0x212A, 0},
{0x212C, 0x2138, 0},
{0x2155, 0x215A, 0},
{0x215F, 0x215F, 0},
{0x216C, 0x216F, 0},
{0x217A, 0x2182, 0},
{0x219A, 0x21D1, 0},
{0x21D3, 0x21D3, 0},
{0x21D5, 0x21EA, 0},
{0x2201, 0x2201, 0},
{0x2204, 0x2206, 0},
{0x2209, 0x220A, 0},
{0x220C, 0x220E, 0},
{0x2210, 0x2210, 0},
{0x2212, 0x2214, 0},
{0x2216, 0x2219, 0},
{0x221B, 0x221C, 0},
{0x2221, 0x2222, 0},
{0x2224, 0x2224, 0},
{0x2226, 0x2226, 0},
{0x222D, 0x222D, 0},
{0x222F, 0x2233, 0},
{0x2238, 0x223B, 0},
{0x223E, 0x2247, 0},
{0x2249, 0x224B, 0},
{0x224D, 0x2251, 0},
{0x2253, 0x225F, 0},
{0x2262, 0x2263, 0},
{0x2268, 0x2269, 0},
{0x226C, 0x226D, 0},
{0x2270, 0x2281, 0},
{0x2284, 0x2285, 0},
{0x2288, 0x2294, 0},
{0x2296, 0x2298, 0},
{0x229A, 0x22A4, 0},
{0x22A6, 0x22BE, 0},
{0x22C0, 0x22F1, 0},
{0x2300, 0x2300, 0},
{0x2302, 0x2311, 0},
{0x2313, 0x237A, 0},
{0x2400, 0x2424, 0},
{0x2440, 0x244A, 0},
{0x24B6, 0x24CF, 0},
{0x24EA, 0x24EA, 0},
{0x254C, 0x254F, 0},
{0x2575, 0x2580, 0},
{0x2590, 0x2591, 0},
{0x25A2, 0x25A2, 0},
{0x25AA, 0x25B1, 0},
{0x25B4, 0x25B5, 0},
{0x25B8, 0x25BB, 0},
{0x25BE, 0x25BF, 0},
{0x25C2, 0x25C5, 0},
{0x25C9, 0x25CA, 0},
{0x25CC, 0x25CD, 0},
{0x25D2, 0x25E1, 0},
{0x25E6, 0x25EE, 0},
{0x2600, 0x2604, 0},
{0x2607, 0x2608, 0},
{0x260A, 0x260D, 0},
{0x2610, 0x2613, 0},
{0x261A, 0x261B, 0},
{0x261D, 0x261D, 0},
{0x261F, 0x263F, 0},
{0x2641, 0x2641, 0},
{0x2643, 0x265F, 0},
{0x2662, 0x2662, 0},
{0x2666, 0x2666, 0},
{0x266B, 0x266B, 0},
{0x266E, 0x266E, 0},
{0x2701, 0x2704, 0},
{0x2706, 0x2709, 0},
{0x270C, 0x2727, 0},
{0x2729, 0x274B, 0},
{0x274D, 0x274D, 0},
{0x274F, 0x2752, 0},
{0x2756, 0x2756, 0},
{0x2758, 0x275E, 0},
{0x2761, 0x2767, 0},
{0x2776, 0x2794, 0},
{0x2798, 0x27AF, 0},
{0x27B1, 0x27BE, 0},
{0x3004, 0x3004, 0},
{0x3018, 0x301C, 0},
{0x3020, 0x3020, 0},
{0x302A, 0x3037, 0},
{0x303F, 0x303F, 0},
{0x3094, 0x3094, 0},
{0x3099, 0x309A, 0},
{0x30F7, 0x30FA, 0},
{0x312A, 0x312C, 0},
{0x3190, 0x319F, 0},
{0x322A, 0x3230, 0},
{0x3233, 0x3238, 0},
{0x323A, 0x3243, 0},
{0x3280, 0x32A2, 0},
{0x32A9, 0x32B0, 0},
{0x32C0, 0x32CB, 0},
{0x32D0, 0x32FE, 0},
{0x3300, 0x3302, 0},
{0x3304, 0x330C, 0},
{0x330E, 0x3313, 0},
{0x3315, 0x3317, 0},
{0x3319, 0x3321, 0},
{0x3324, 0x3325, 0},
{0x3328, 0x332A, 0},
{0x332C, 0x3335, 0},
{0x3337, 0x333A, 0},
{0x333C, 0x3348, 0},
{0x334B, 0x334C, 0},
{0x334E, 0x3350, 0},
{0x3352, 0x3356, 0},
{0x3358, 0x3376, 0},
{0x337F, 0x337F, 0},
{0x3385, 0x3387, 0},
{0x33CB, 0x33CC, 0},
{0x33D4, 0x33D4, 0},
{0x33D7, 0x33D7, 0},
{0x33D9, 0x33DA, 0},
{0x33E0, 0x33FE, 0},
{0xFB00, 0xFB06, 0},
{0xFB13, 0xFB17, 0},
{0xFB1E, 0xFB36, 0},
{0xFB38, 0xFB3C, 0},
{0xFB3E, 0xFB3E, 0},
{0xFB40, 0xFB41, 0},
{0xFB43, 0xFB44, 0},
{0xFB46, 0xFBB1, 0},
{0xFBD3, 0xFD3F, 0},
{0xFD50, 0xFD8F, 0},
{0xFD92, 0xFDC7, 0},
{0xFDF0, 0xFDFB, 0},
{0xFE20, 0xFE23, 0},
{0xFE32, 0xFE32, 0},
{0xFE58, 0xFE58, 0},
{0xFE70, 0xFE72, 0},
{0xFE74, 0xFE74, 0},
{0xFE76, 0xFEFC, 0},
{0xFEFF, 0xFEFF, 0},
{0xFFA0, 0xFFBE, 0},
{0xFFC2, 0xFFC7, 0},
{0xFFCA, 0xFFCF, 0},
{0xFFD2, 0xFFD7, 0},
{0xFFDA, 0xFFDC, 0},
{0xFFE8, 0xFFEE, 0},
{0xFFFD, 0xFFFD, 0}
};
const struct {
int nCharSet;
UINT uCodePage;
DWORD dwCodePages;
SCRIPT_ID sid[3];
} g_CharSetTransTable[] =
{
ANSI_CHARSET, 1252, FS_LATIN1, sidAsciiLatin, sidLatin, sidDefault,
EASTEUROPE_CHARSET, 1250, FS_LATIN2, sidAsciiLatin, sidLatin, sidDefault,
RUSSIAN_CHARSET, 1251, FS_CYRILLIC, sidCyrillic, sidDefault, sidDefault,
GREEK_CHARSET, 1253, FS_GREEK, sidGreek, sidDefault, sidDefault,
TURKISH_CHARSET, 1254, FS_TURKISH, sidAsciiLatin, sidLatin, sidDefault,
HEBREW_CHARSET, 1255, FS_HEBREW, sidHebrew, sidDefault, sidDefault,
ARABIC_CHARSET, 1256, FS_ARABIC, sidArabic, sidDefault, sidDefault,
BALTIC_CHARSET, 1257, FS_BALTIC, sidAsciiLatin, sidLatin, sidDefault,
VIETNAMESE_CHARSET, 1258, FS_VIETNAMESE, sidAsciiLatin, sidLatin, sidDefault,
THAI_CHARSET, 874, FS_THAI , sidThai, sidDefault, sidDefault,
SHIFTJIS_CHARSET, 932, FS_JISJAPAN, sidKana, sidDefault, sidDefault, //sidKana, sidHan, sidDefault,
GB2312_CHARSET, 936, FS_CHINESESIMP,sidHan, sidDefault, sidDefault, //sidKana, sidHan, sidBopomofo,
HANGEUL_CHARSET, 949, FS_WANSUNG, sidHangul, sidDefault, sidDefault, //sidHangul, sidKana, sidHan,
CHINESEBIG5_CHARSET, 950, FS_CHINESETRAD, sidBopomofo, sidDefault, sidDefault, //sidKana, sidHan, sidBopomofo,
JOHAB_CHARSET, 1361, FS_JOHAB, sidHangul, sidDefault, sidDefault,
DEFAULT_CHARSET, 0, 0, sidDefault, sidDefault, sidDefault,
};
//
// Extended code page table
//
const struct {
int nCharSet;
UINT uCodePage;
DWORD dwCodePages;
} g_CharSetTransTableExt[] =
{
ANSI_CHARSET, 28591, FS_MLANG_28591,
EASTEUROPE_CHARSET, 28592, FS_MLANG_28592,
RUSSIAN_CHARSET, 28595, FS_MLANG_28595,
GREEK_CHARSET, 28597, FS_MLANG_28597,
TURKISH_CHARSET, 28593, FS_MLANG_28593,
HEBREW_CHARSET, 28598, FS_MLANG_28598,
HEBREW_CHARSET, 38598, FS_MLANG_38598,
ARABIC_CHARSET, 28596, FS_MLANG_28596,
BALTIC_CHARSET, 28594, FS_MLANG_28594,
VIETNAMESE_CHARSET, 28599, FS_MLANG_28599,
THAI_CHARSET, 28605, FS_MLANG_28605,
ANSI_CHARSET, 20127, FS_MLANG_20127,
ANSI_CHARSET, 50220, FS_MLANG_50220,
ANSI_CHARSET, 51932, FS_MLANG_51932,
ANSI_CHARSET, 51949, FS_MLANG_51949,
ANSI_CHARSET, 50225, FS_MLANG_50225,
ANSI_CHARSET, 52936, FS_MLANG_52936,
ANSI_CHARSET, 65000, FS_MLANG_65000,
ANSI_CHARSET, 65001, FS_MLANG_65001,
ANSI_CHARSET, 1200, FS_MLANG_1200,
ANSI_CHARSET, 20866, FS_MLANG_20866,
ANSI_CHARSET, 21866, FS_MLANG_21866,
ANSI_CHARSET, 50221, FS_MLANG_50221,
ANSI_CHARSET, 50222, FS_MLANG_50222,
DEFAULT_CHARSET, 0, 0,
};
// Primary chars for scripts
// Pre-sorted by Unicode characters to speed up CMAP search.
const struct {
WCHAR wch; //Can be extended to a character list
SCRIPT_ID sid;
} g_wCharToScript[] =
{
0x0531, sidArmenian,
0x0710, sidSyriac,
0x0780, sidThaana,
0x0905, sidDevanagari,
0x0985, sidBengali,
0x0a05, sidGurmukhi,
0x0a85, sidGujarati,
0x0b05, sidOriya,
0x0b85, sidTamil,
0x0c05, sidTelugu,
0x0c85, sidKannada,
0x0d05, sidMalayalam,
0x0d85, sidSinhala,
0x0e81, sidLao,
0x0f40, sidTibetan,
0x10a0, sidGeorgian,
0x10d0, sidGeorgian,
0x1300, sidEthiopic,
0x1401, sidCanSyllabic,
0x13a0, sidCherokee,
0xa000, sidYi,
0x1680, sidOgham,
0x16a0, sidRunic,
0x1700, sidBurmese,
0x1780, sidKhmer,
0x2800, sidBraille,
// 0x0020, sidUserDefined
};
// Script tables ported from Trident
static SCRIPT_ID s_asidUnicodeSubRangeScriptMapping[] =
{
sidAsciiLatin, sidLatin, sidLatin, sidLatin, // 128-131
sidLatin, sidLatin, 0, sidGreek, // 132-135
sidGreek, sidCyrillic, sidArmenian, sidHebrew, // 136-139
sidHebrew, sidArabic, sidArabic, sidDevanagari, // 140-143
sidBengali, sidGurmukhi, sidGujarati, sidOriya, // 144-147
sidTamil, sidTelugu, sidKannada, sidMalayalam, // 148-151
sidThai, sidLao, sidGeorgian, sidGeorgian, // 152-155
sidHangul, sidLatin, sidGreek, 0, // 156-159
0, 0, 0, 0, // 160-163
0, 0, 0, 0, // 164-167
0, 0, 0, 0, // 168-171
0, 0, 0, 0, // 172-175
sidHan, sidKana, sidKana, sidBopomofo, // 176-179
sidHangul, 0, 0, 0, // 180-183
sidHangul, sidHangul, sidHangul, sidHan, // 184-187
0, sidHan, 0, 0, // 188-191
0, 0, 0, 0, // 192-195
0, 0, sidHangul, 0, // 196-199
};
// Script table (raw data from MichelSu)
// Rendered by script ID
const SCRIPT ScriptTable[] =
{
{sidDefault, IDS_SIDDEFAULT, 0, 0, 0, 0, SCRIPTCONTF_SCRIPT_SYSTEM}, // 0
{sidMerge, IDS_SIDMERGE, 0, 0, 0, 0, SCRIPTCONTF_SCRIPT_SYSTEM}, // 1
{sidAsciiSym, IDS_SIDASCIISYM, 0, 0, 0, 0, SCRIPTCONTF_SCRIPT_SYSTEM}, // 2
{sidAsciiLatin, IDS_SIDASCIILATIN, 1252, 0, IDS_FONT_WESTERN_FIXED, IDS_FONT_WESTERN_PROP2, SCRIPTCONTF_SCRIPT_USER}, // 3
{sidLatin, IDS_SIDLATIN, 1252, 0, IDS_FONT_WESTERN_FIXED, IDS_FONT_WESTERN_PROP2, SCRIPTCONTF_SCRIPT_HIDE}, // 4
{sidGreek, IDS_SIDGREEK, 1253, 0x03AC, IDS_FONT_WESTERN_FIXED, IDS_FONT_WESTERN_PROP2, SCRIPTCONTF_SCRIPT_USER}, // 5
{sidCyrillic, IDS_SIDCYRILLIC, 1251, 0x0401, IDS_FONT_WESTERN_FIXED, IDS_FONT_WESTERN_PROP2, SCRIPTCONTF_SCRIPT_USER}, // 6
{sidArmenian, IDS_SIDARMENIAN, 0, 0x0531, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 7
/**/{sidHebrew, IDS_SIDHEBREW, 1255, 0x05D4, IDS_FONT_HEBREW_FIXED, IDS_FONT_HEBREW_PROP, SCRIPTCONTF_SCRIPT_USER}, // 8
{sidArabic, IDS_SIDARABIC, 1256, 0x0627, IDS_FONT_ARABIC_FIXED, IDS_FONT_ARABIC_PROP, SCRIPTCONTF_SCRIPT_USER}, // 9
{sidDevanagari, IDS_SIDDEVANAGARI, 0, 0x0905, IDS_FONT_DEVANAGARI_FIXED,IDS_FONT_DEVANAGARI_PROP, SCRIPTCONTF_SCRIPT_USER}, // 10
{sidBengali, IDS_SIDBENGALI, 0, 0x0985, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 11
{sidGurmukhi, IDS_SIDGURMUKHI, 0, 0x0A05, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 12
{sidGujarati, IDS_SIDGUJARATI, 0, 0x0A85, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 13
{sidOriya, IDS_SIDORIYA, 0, 0x0B05, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 14
{sidTamil, IDS_SIDTAMIL, 0, 0x0B85, IDS_FONT_TAMIL_FIXED, IDS_FONT_TAMIL_PROP, SCRIPTCONTF_SCRIPT_USER}, // 15
{sidTelugu, IDS_SIDTELUGU, 0, 0x0C05, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 16
{sidKannada, IDS_SIDKANNADA, 0, 0x0C85, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 17
{sidMalayalam, IDS_SIDMALAYALAM, 0, 0x0D05, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 18
{sidThai, IDS_SIDTHAI, 874, 0x0E01, IDS_FONT_THAI_FIXED2, IDS_FONT_THAI_PROP2, SCRIPTCONTF_SCRIPT_USER}, // 19
{sidLao, IDS_SIDLAO, 0, 0x0E81, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 20
{sidTibetan, IDS_SIDTIBETAN, 0, 0x0F40, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 21
{sidGeorgian, IDS_SIDGEORGIAN, 0, 0x10D0, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 22
{sidHangul, IDS_SIDHANGUL, 949, 0, IDS_FONT_KOREAN_FIXED, IDS_FONT_KOREAN_PROP, SCRIPTCONTF_SCRIPT_USER}, // 23
{sidKana, IDS_SIDKANA, 932, 0, IDS_FONT_JAPANESE_FIXED, IDS_FONT_JAPANESE_PROP, SCRIPTCONTF_SCRIPT_USER}, // 24
{sidBopomofo, IDS_SIDBOPOMOFO, 950, 0, IDS_FONT_TAIWAN_FIXED, IDS_FONT_TAIWAN_PROP, SCRIPTCONTF_SCRIPT_USER}, // 25
{sidHan, IDS_SIDHAN, 936, 0, IDS_FONT_CHINESE_FIXED, IDS_FONT_CHINESE_PROP, SCRIPTCONTF_SCRIPT_USER}, // 26
{sidEthiopic, IDS_SIDETHIOPIC, 0, 0x1300, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 27
{sidCanSyllabic,IDS_SIDCANSYLLABIC, 0, 0x1401, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 28
{sidCherokee, IDS_SIDCHEROKEE, 0, 0x13A0, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 29
{sidYi, IDS_SIDYI, 0, 0xA000, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 30
{sidBraille, IDS_SIDBRAILLE, 0, 0x2800, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 31
{sidRunic, IDS_SIDRUNIC, 0, 0x16A0, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 32
{sidOgham, IDS_SIDOGHAM, 0, 0x1680, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 33
{sidSinhala, IDS_SIDSINHALA, 0, 0x0D85, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 34
{sidSyriac, IDS_SIDSYRIAC, 0, 0x0710, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 35
{sidBurmese, IDS_SIDBURMESE, 0, 0x1700, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 36
{sidKhmer, IDS_SIDKHMER, 0, 0x1780, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 37
{sidThaana, IDS_SIDTHAANA, 0, 0x0780, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 38
{sidMongolian, IDS_SIDMONGOLIAN, 0, 0, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 39
{sidUserDefined,IDS_SIDUSERDEFINED, 0, 0x0020, 0, 0, SCRIPTCONTF_SCRIPT_USER}, // 40
};
UINT g_cScript = ARRAYSIZE(ScriptTable);
/////////////////////////////////////////////////////////////////////////////
// CMLFLink Free Global Objects
void CMLangFontLink_FreeGlobalObjects()
{
if (g_pMLFLink)
g_pMLFLink->Release();
if (CMLFLink::m_pCodePagesCache)
delete CMLFLink::m_pCodePagesCache;
if (CMLFLink::m_pFontMappingCache)
delete CMLFLink::m_pFontMappingCache;
if (CMLFLink2::m_pFontMappingCache2)
delete CMLFLink2::m_pFontMappingCache2;
}
/////////////////////////////////////////////////////////////////////////////
// CMLFLink
CMLFLink::CMLFLink()
{
DllAddRef();
EnterCriticalSection(&g_cs);
if (!m_pCodePagesCache)
m_pCodePagesCache = new CCodePagesCache;
if (!m_pFontMappingCache)
m_pFontMappingCache = new CFontMappingCache;
LeaveCriticalSection(&g_cs);
m_pFlinkTable = NULL;
}
STDMETHODIMP CMLFLink::GetCharCodePages(WCHAR chSrc, DWORD* pdwCodePages)
{
return ::GetCharCodePagesEx(chSrc, pdwCodePages, CPBITS_WINDOWS);
}
/////////////////////////////////////////////////////////////////////////////
// CMLFLink : IMLangCodePages
HRESULT GetCharCodePagesEx(WCHAR chSrc, DWORD* pdwCodePages, DWORD dwFlags)
{
ASSERT_WRITE_PTR_OR_NULL(pdwCodePages);
HRESULT hr = S_OK;
int nLen;
int iCmd = 0;
int nPickOffset;
int nBitOffset = 0;
int nBitCount = 32;
DWORD dwDiff = 0xffffffff;
DWORD dwOr = 0;
DWORD dwCodePages;
DWORD adwBitsMap[32];
const CCodePagesHeader* pHeader;
const WORD* pwTable;
int nBlock;
int nEndLen;
const BYTE* pbBlock;
BYTE *pBuffer = NULL;
if (!CMLFLink::m_pCodePagesCache)
CMLFLink::m_pCodePagesCache = new CMLFLink::CCodePagesCache;
if (CMLFLink::m_pCodePagesCache)
hr = CMLFLink::m_pCodePagesCache->Load();
else
{
hr = E_FAIL;
}
if (SUCCEEDED(hr))
{
pBuffer = CMLFLink::m_pCodePagesCache->GetCodePageBits(dwFlags & CPBITS_WINDOWS? FALSE:TRUE);
pHeader = (CCodePagesHeader*) pBuffer;
pwTable = (WORD*)(pBuffer + READWINTELDWORD(pHeader->m_dwTableOffset));
nBlock = chSrc / READWINTELDWORD(pHeader->m_dwBlockSize);
nEndLen = chSrc % READWINTELDWORD(pHeader->m_dwBlockSize);
pbBlock = pBuffer + READWINTELWORD(pwTable[nBlock]);
}
for (int nDoneLen = 0; SUCCEEDED(hr) && nDoneLen < (int)READWINTELDWORD(pHeader->m_dwBlockSize); nDoneLen += nLen)
{
BYTE bCmd = pbBlock[--iCmd];
if (bCmd < pHeader->m_abCmdCode[1])
{
// Flat
nLen = bCmd + 1;
nPickOffset = nBitOffset + nBitCount * (nEndLen - nDoneLen);
nBitOffset += nBitCount * nLen;
}
else if (bCmd < pHeader->m_abCmdCode[2])
{
// Pack
nLen = bCmd - pHeader->m_abCmdCode[1] + 2;
nPickOffset = nBitOffset;
nBitOffset += nBitCount;
}
else if (bCmd < pHeader->m_abCmdCode[4])
{
// Diff & Or
nLen = 0;
DWORD dw = pbBlock[--iCmd];
dw <<= 8;
dw |= pbBlock[--iCmd];
dw <<= 8;
dw |= pbBlock[--iCmd];
dw <<= 8;
dw |= pbBlock[--iCmd];
if (bCmd < pHeader->m_abCmdCode[3])
{
// Diff
dwDiff = dw;
DWORD dwShift = 1;
nBitCount = 0;
for (int nBit = 0; nBit < 32; nBit++)
{
if (dwDiff & (1 << nBit))
{
adwBitsMap[nBit] = dwShift;
dwShift <<= 1;
nBitCount++;
}
else
{
adwBitsMap[nBit] = 0;
}
}
}
else
{
// Or
dwOr = dw;
}
}
else
{
// Big Pack
nLen = (bCmd - pHeader->m_abCmdCode[4]) * 0x100 + pbBlock[--iCmd] + pHeader->m_abCmdCode[2] - pHeader->m_abCmdCode[1] + 1 + 1;
nPickOffset = nBitOffset;
nBitOffset += nBitCount;
}
if (nEndLen < nDoneLen + nLen)
break;
}
if (SUCCEEDED(hr) &&
nDoneLen < (int)READWINTELDWORD(pHeader->m_dwBlockSize))
{
const BYTE* const pbBuf = &pbBlock[nPickOffset / 8];
DWORD dwCompBits = pbBuf[0] | (DWORD(pbBuf[1]) << 8) | (DWORD(pbBuf[2]) << 16) | (DWORD(pbBuf[3]) << 24);
dwCompBits >>= nPickOffset % 8;
if (nBitOffset % 8)
dwCompBits |= pbBuf[4] << (32 - nBitOffset % 8);
if (nBitCount < 32)
{
dwCompBits &= (1 << nBitCount) - 1;
dwCodePages = 0;
for (int nBit = 0; nBit < 32; nBit++)
{
if (dwCompBits & adwBitsMap[nBit])
dwCodePages |= (1 << nBit);
}
}
else
{
dwCodePages = dwCompBits;
}
dwCodePages |= dwOr;
}
else
{
hr = E_FAIL; // Probably Code Pages data is broken.
}
if (pdwCodePages)
{
if (SUCCEEDED(hr))
{
if (dwFlags & CPBITS_WINDOWS)
{
// 04/07/00 WEIWU
// Need to match latest NLS file (Currently W2K RTM) if we're in strict mode for outbound encoding detection
// For backward compatibilities reasons, we don't want to change our raw Windows CP data.
// We patch up major differences between Win95/NT4 NLS files and current NLS files here
// For non-Windows CP data, we'll modify them directly since it doesn't affect text rendering
if (dwFlags & CPBITS_STRICT)
{
// Add Euro support for 936,950, 949 if we're in strict mode
if (chSrc == 0x20AC)
{
dwCodePages |= FS_WANSUNG|FS_CHINESESIMP|FS_CHINESETRAD;
}
else if (chSrc == 0x00AE)
{
dwCodePages |= FS_WANSUNG;
}
// Clear K1_HANJA bits if we're in strict mode
dwCodePages &= ~FS_MLANG_K1HANJA;
}
else
{
// We introduce this new internal charset bit, FS_MLANG_K1HANJA, to support Korean K1 Hanja
// K1 Hanja is defined in KSC 5657-1991, it contains non-cp949 DBCS characters
// Currenly, Korean fonts shipped with NT5 and Win98 support K1 Hanja glyphs
// and we don't want to switch font to other DBCS fonts in this case.
if (dwCodePages & FS_MLANG_K1HANJA)
{
// Assume Korean font supports K1_HANJA on Win98 and NT5
if (g_bIsNT5 || (g_bIsWin98 && CP_KOR_5601 == g_uACP))
dwCodePages |= FS_WANSUNG;
dwCodePages &= ~FS_MLANG_K1HANJA;
}
}
}
*pdwCodePages = dwCodePages;
}
else
{
*pdwCodePages = 0;
}
}
return hr;
}
HRESULT GetStrCodePagesEx(const WCHAR* pszSrc, long cchSrc, DWORD dwPriorityCodePages, DWORD* pdwCodePages, long* pcchCodePages, DWORD dwFlags)
{
ASSERT_READ_BLOCK(pszSrc, cchSrc);
ASSERT_WRITE_PTR_OR_NULL(pdwCodePages);
ASSERT_WRITE_PTR_OR_NULL(pcchCodePages);
HRESULT hr = S_OK;
long cchCodePages = 0;
DWORD dwStrCodePages = (DWORD)~0;
BOOL fInit = FALSE;
BOOL fNoPri = FALSE;
if (!pszSrc || cchSrc <= 0) // We can't make dwStrCodePages when cchSrc is zero
hr = E_INVALIDARG;
while (SUCCEEDED(hr) && cchSrc > 0)
{
DWORD dwCharCodePages;
if (SUCCEEDED(hr = GetCharCodePagesEx(*pszSrc, &dwCharCodePages, dwFlags)))
{
if (!fInit)
{
fInit = TRUE;
fNoPri = !(dwPriorityCodePages & dwCharCodePages);
}
else if (fNoPri != !(dwPriorityCodePages & dwCharCodePages))
{
break;
}
if (!fNoPri)
dwPriorityCodePages &= dwCharCodePages;
if (dwCharCodePages & dwStrCodePages)
dwStrCodePages &= dwCharCodePages;
// Don't break if dwCharCodePages is zero and we're not in strict mode
else if (dwCharCodePages || dwFlags & CPBITS_STRICT)
break;
pszSrc++;
cchSrc--;
cchCodePages++;
}
}
// Codepage bits defines don't take full 32 bits.
// If no bits are flipped, we don't have any candidate code pages, we should clear the bits
if (dwStrCodePages == (DWORD)~0)
dwStrCodePages = 0;
if (SUCCEEDED(hr))
{
if (pcchCodePages)
*pcchCodePages = cchCodePages;
if (pdwCodePages)
*pdwCodePages = dwStrCodePages;
}
else
{
if (pcchCodePages)
*pcchCodePages = 0;
if (pdwCodePages)
*pdwCodePages = 0;
}
return hr;
}
STDMETHODIMP CMLFLink::GetStrCodePages(const WCHAR* pszSrc, long cchSrc, DWORD dwPriorityCodePages, DWORD* pdwCodePages, long* pcchCodePages)
{
return ::GetStrCodePagesEx(pszSrc, cchSrc, dwPriorityCodePages, pdwCodePages, pcchCodePages, CPBITS_WINDOWS);
}
HRESULT CodePageToCodePagesEx(UINT uCodePage, DWORD* pdwCodePages, DWORD* pdwCodePagesExt)
{
ASSERT_WRITE_PTR_OR_NULL(pdwCodePages);
int iCharSet;
if (pdwCodePages)
*pdwCodePages = 0;
if (pdwCodePagesExt)
*pdwCodePagesExt = 0;
for (iCharSet = 0; g_CharSetTransTable[iCharSet].uCodePage; iCharSet++)
{
if (uCodePage == g_CharSetTransTable[iCharSet].uCodePage)
{
if (pdwCodePages)
*pdwCodePages = g_CharSetTransTable[iCharSet].dwCodePages;
return S_OK;
}
}
for (iCharSet = 0; g_CharSetTransTableExt[iCharSet].uCodePage; iCharSet++)
{
if (uCodePage == g_CharSetTransTableExt[iCharSet].uCodePage)
{
if (pdwCodePages)
*pdwCodePagesExt = g_CharSetTransTableExt[iCharSet].dwCodePages;
return S_OK;
}
}
return E_FAIL; // Unknown code page
}
STDMETHODIMP CMLFLink::CodePageToCodePages(UINT uCodePage, DWORD* pdwCodePages)
{
ASSERT_THIS;
ASSERT_WRITE_PTR_OR_NULL(pdwCodePages);
for (int iCharSet = 0; g_CharSetTransTable[iCharSet].uCodePage; iCharSet++)
{
if (uCodePage == g_CharSetTransTable[iCharSet].uCodePage)
{
if (pdwCodePages)
*pdwCodePages = g_CharSetTransTable[iCharSet].dwCodePages;
return S_OK;
}
}
if (pdwCodePages)
*pdwCodePages = 0;
return E_FAIL; // Unknown code page
}
STDMETHODIMP CMLFLink::CodePagesToCodePage(DWORD dwCodePages, UINT uDefaultCodePage, UINT* puCodePage)
{
return ::CodePagesToCodePageEx(dwCodePages, uDefaultCodePage, puCodePage, 0);
}
HRESULT CodePagesToCodePageEx(DWORD dwCodePages, UINT uDefaultCodePage, UINT* puCodePage, BOOL bCodePagesExt)
{
ASSERT_WRITE_PTR_OR_NULL(puCodePage);
HRESULT hr = E_FAIL; // Unknown code pages
DWORD dwDefaultCodePages;
if (uDefaultCodePage &&
SUCCEEDED(hr = CodePageToCodePagesEx(uDefaultCodePage, &dwDefaultCodePages, NULL)) &&
(dwDefaultCodePages & dwCodePages))
{
hr = S_OK;
}
else
{
if (bCodePagesExt)
{
for (int iCharSet = 0; g_CharSetTransTableExt[iCharSet].dwCodePages; iCharSet++)
{
if (dwCodePages & g_CharSetTransTableExt[iCharSet].dwCodePages)
{
uDefaultCodePage = g_CharSetTransTableExt[iCharSet].uCodePage;
hr = S_OK;
break;
}
}
}
else
{
for (int iCharSet = 0; g_CharSetTransTable[iCharSet].dwCodePages; iCharSet++)
{
if (dwCodePages & g_CharSetTransTable[iCharSet].dwCodePages)
{
uDefaultCodePage = g_CharSetTransTable[iCharSet].uCodePage;
hr = S_OK;
break;
}
}
}
}
if (puCodePage)
{
if (SUCCEEDED(hr))
*puCodePage = uDefaultCodePage;
else
*puCodePage = 0;
}
return hr;
}
#define REGSTR_PATH_FONTLINK TSZMICROSOFTPATH TEXT("\\Windows NT\\CurrentVersion\\FontLink\\SystemLink")
void CMLFLink::FreeFlinkTable(void)
{
if (m_pFlinkTable)
{
for (UINT i=0; i<m_uiFLinkFontNum; i++)
if (m_pFlinkTable[i].pmszFaceName)
LocalFree(m_pFlinkTable[i].pmszFaceName);
LocalFree(m_pFlinkTable);
m_pFlinkTable = NULL;
m_uiFLinkFontNum = 0;
}
}
#define MAX_FONTLINK_BUFFER_SIZE 1024
HRESULT CMLFLink::CreateNT5FontLinkTable(void)
{
HKEY hKey = NULL;
HKEY hKeyFont = NULL;
ULONG ulFonts = 0;
ULONG ulFLinkFonts = 0;
DWORD dwIndex = 0;
WCHAR szFaceName[LF_FACESIZE];
LPWSTR pNewFaceName = NULL;
DWORD dwOffset = 0;
DWORD dwOffset2 = 0;
DWORD dwValue;
DWORD dwData;
WCHAR szFontFile[LF_FACESIZE];
DWORD dwType;
WCHAR szFlinkFont[MAX_FONTLINK_BUFFER_SIZE];
// Internal temperate data
struct tagFontTable
{
WCHAR szFontFile[LF_FACESIZE];
WCHAR szFaceName[LF_FACESIZE];
}* tmpFontTable = NULL;
HRESULT hr;
// Open system font and fontlink key
if ((ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGSTR_PATH_FONTLINK, 0, KEY_READ, &hKey)) ||
(ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGFONTKEYNT, 0, KEY_READ, &hKeyFont)))
{
hr = E_FAIL;
goto TABLE_DONE;
}
// Get number of items
if ((ERROR_SUCCESS != RegQueryInfoKey(hKey, NULL, NULL, 0, NULL,
NULL, NULL, &ulFLinkFonts, NULL, NULL, NULL, NULL) || 0 == ulFLinkFonts) ||
(ERROR_SUCCESS != RegQueryInfoKey(hKeyFont, NULL, NULL, 0, NULL,
NULL, NULL, &ulFonts, NULL, NULL, NULL, NULL) || 0 == ulFonts))
{
hr = E_FAIL;
goto TABLE_DONE;
}
tmpFontTable = (struct tagFontTable *)LocalAlloc(LPTR, sizeof(struct tagFontTable)*ulFonts);
if (NULL == tmpFontTable)
{
hr = E_OUTOFMEMORY;
goto TABLE_DONE;
}
dwValue = dwData = LF_FACESIZE;
dwType = REG_SZ;
dwIndex = 0;
ulFonts = 0;
while (ERROR_NO_MORE_ITEMS != RegEnumValueW(
hKeyFont,
dwIndex++,
szFaceName,
&dwValue,
NULL,
&dwType,
(LPBYTE)szFontFile,
&dwData ))
{
// TTF fonts only, TTC fonts already have face name under fontlink
if (pNewFaceName = wcsstr(szFaceName, L" & "))
break;
pNewFaceName = wcsstr(szFaceName, L" (TrueType)");
if(pNewFaceName)
{
*pNewFaceName = 0;
MLStrCpyNW(tmpFontTable[ulFonts].szFaceName, szFaceName, ARRAYSIZE(tmpFontTable[ulFonts].szFaceName));
MLStrCpyNW(tmpFontTable[ulFonts].szFontFile, szFontFile, ARRAYSIZE(tmpFontTable[ulFonts].szFontFile));
ulFonts++;
}
dwValue = dwData = LF_FACESIZE;
dwType = REG_SZ;
}
m_pFlinkTable = (PFLINKFONT) LocalAlloc(LPTR, sizeof(FLINKFONT)*ulFLinkFonts);
if (NULL == m_pFlinkTable)
{
hr = E_OUTOFMEMORY;
goto TABLE_DONE;
}
dwValue = LF_FACESIZE;
dwData = MAX_FONTLINK_BUFFER_SIZE;
dwType = REG_MULTI_SZ;
dwIndex = 0;
while (ERROR_NO_MORE_ITEMS != RegEnumValueW(
hKey,
dwIndex,
m_pFlinkTable[dwIndex].szFaceName,
&dwValue,
NULL,
&dwType,
(LPBYTE)szFlinkFont,
&dwData ))
{
m_pFlinkTable[dwIndex].pmszFaceName = (LPWSTR) LocalAlloc(LPTR, MAX_FONTLINK_BUFFER_SIZE);
if (!m_pFlinkTable[dwIndex].pmszFaceName)
{
hr = E_OUTOFMEMORY;
goto TABLE_DONE;
}
while (TRUE)
{
pNewFaceName = wcsstr(&szFlinkFont[dwOffset], L",");
if (pNewFaceName) // TTC font, get face name from registry
{
MLStrCpyNW(&(m_pFlinkTable[dwIndex].pmszFaceName[dwOffset2]), ++pNewFaceName, LF_FACESIZE);
dwOffset2 += lstrlenW(pNewFaceName)+1;
}
else // TTF font, search font table for face name
{
if (szFlinkFont[dwOffset])
for (UINT i=0; i<ulFonts; i++)
{
if (!MLStrCmpNIW(&szFlinkFont[dwOffset], tmpFontTable[i].szFontFile, LF_FACESIZE))
{
MLStrCpyNW(&(m_pFlinkTable[dwIndex].pmszFaceName[dwOffset2]), tmpFontTable[i].szFaceName, LF_FACESIZE);
dwOffset2 += lstrlenW(tmpFontTable[i].szFaceName)+1;
break;
}
}
else // End of multiple string, break out
break;
}
dwOffset += lstrlenW(&szFlinkFont[dwOffset])+1;
// Prevent infinitive loop, shouldn't happen
if (dwOffset >= MAX_FONTLINK_BUFFER_SIZE)
{
break;
}
}
dwValue = LF_FACESIZE;
dwData = MAX_FONTLINK_BUFFER_SIZE;
dwType = REG_MULTI_SZ;
dwOffset = dwOffset2 = 0;
dwIndex++;
}
m_uiFLinkFontNum = ulFLinkFonts;
hr = S_OK;
TABLE_DONE:
if (hKey)
RegCloseKey(hKey);
if (hKeyFont)
RegCloseKey(hKeyFont);
if (tmpFontTable)
LocalFree(tmpFontTable);
if ((hr != S_OK) && m_pFlinkTable)
FreeFlinkTable();
return hr;
}
HRESULT CMLFLink::GetNT5FLinkFontCodePages(HDC hDC, LOGFONTW* plfEnum, DWORD * lpdwCodePages)
{
HRESULT hr = S_OK;
UINT i;
if (!EnumFontFamiliesExW(hDC, plfEnum, GetFontCodePagesEnumFontProcW, (LPARAM)lpdwCodePages, 0))
return E_FAIL;
if (NULL == m_pFlinkTable)
CreateNT5FontLinkTable();
if (m_pFlinkTable)
{
for (i=0; i<m_uiFLinkFontNum;i++)
{
if (!MLStrCmpNIW(plfEnum->lfFaceName, m_pFlinkTable[i].szFaceName, LF_FACESIZE))
{
DWORD dwOffset=0;
// Internal buffer, we're sure it'll end
while(TRUE)
{
MLStrCpyNW(plfEnum->lfFaceName, &m_pFlinkTable[i].pmszFaceName[dwOffset], LF_FACESIZE);
EnumFontFamiliesExW(hDC, plfEnum, GetFontCodePagesEnumFontProcW, (LPARAM)lpdwCodePages, 0);
dwOffset += lstrlenW(&m_pFlinkTable[i].pmszFaceName[dwOffset])+1;
// End of multiple string ?
if (m_pFlinkTable[i].pmszFaceName[dwOffset] == 0)
break;
}
break;
}
}
}
return hr;
}
/////////////////////////////////////////////////////////////////////////////
// CMLFLink : IMLangFontLink
// 1/29/99 - Change HR return
// Now, we always return S_OK unless system error, caller will
// check code pages bits in dwCodePages for font code page coverage
STDMETHODIMP CMLFLink::GetFontCodePages(HDC hDC, HFONT hFont, DWORD* pdwCodePages)
{
ASSERT_THIS;
ASSERT_WRITE_PTR_OR_NULL(pdwCodePages);
HRESULT hr = S_OK;
LOGFONT lfFont;
DWORD dwCodePages = 0;
if (!::GetObject(hFont, sizeof(lfFont), &lfFont))
hr = E_FAIL; // Invalid hFont
if (SUCCEEDED(hr))
{
LOGFONT lfEnum;
// Enumerates all character sets of given font's facename
// Then, combines them in dwCodePages
::memset(&lfEnum, 0, sizeof(lfEnum));
lfEnum.lfCharSet = DEFAULT_CHARSET;
//
//Security, strsafe
//
_tcsncpy(lfEnum.lfFaceName, lfFont.lfFaceName, ARRAYSIZE(lfEnum.lfFaceName));
if (g_bIsNT5)
{
LOGFONTW lfEnumW = {0};
lfEnumW.lfCharSet = DEFAULT_CHARSET;
if (MultiByteToWideChar(g_uACP, 0, lfFont.lfFaceName, LF_FACESIZE, lfEnumW.lfFaceName, LF_FACESIZE))
hr = GetNT5FLinkFontCodePages(hDC, &lfEnumW, &dwCodePages);
else
if (!::EnumFontFamiliesEx(hDC, &lfEnum, GetFontCodePagesEnumFontProc, (LPARAM)&dwCodePages, 0))
hr = E_FAIL; // Invalid hDC
}
else
{
if (!::EnumFontFamiliesEx(hDC, &lfEnum, GetFontCodePagesEnumFontProc, (LPARAM)&dwCodePages, 0))
hr = E_FAIL; // Invalid hDC
}
}
//############################
//###### MingLiU HACK ######
//## Fix the bogus font !!! ##
//############################
if (SUCCEEDED(hr) && ::CompareString(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, lfFont.lfFaceName, -1, _T("MingLiU"), -1) == 2)
{
dwCodePages &= ~FS_LATIN1; // Actually it doesn't have the characters of ANSI_CHARSET.
}
//############################
// We should use following logic to replace above hack code
// But, there is another DBCS<->Western font size mapping issue, we should disable this code until that issue is resolved,
#if 0
// If font claims FE and 1252 and 1250, believe it can do 1252.
// If font claims FE and 1252 and not 1250, don't believe it can do 1252.
// This lets full Unicode fonts pass but blocks bad FE fonts.
if (SUCCEEDED(hr) && (dwCodePages & (FS_JISJAPAN|FS_CHINESESIMP|FS_WANSUNG|FS_CHINESETRAD)) && (dwCodePages & FS_LATIN1) && !(dwCodePages & FS_LATIN2))
{
dwCodePages &= ~FS_LATIN1;
}
#endif
#ifdef UNICODE
#define PRC_DEFAULT_GUI_FONT L"\x5b8b\x4f53"
#else
#define PRC_DEFAULT_GUI_FONT "\xcb\xce\xcc\xe5"
#endif
// PRC Win95 DEFAULT_GUI_FONT HACK !!!
if (SUCCEEDED(hr) && lfFont.lfCharSet == ANSI_CHARSET && ::CompareString(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, lfFont.lfFaceName, -1, PRC_DEFAULT_GUI_FONT, -1) == 2)
{
dwCodePages &= ~FS_CHINESESIMP; // Actually it doesn't have the characters of GB2321_CHARSET.
}
if (pdwCodePages)
{
if (SUCCEEDED(hr))
*pdwCodePages = dwCodePages;
else
*pdwCodePages = 0;
}
return hr;
}
int CALLBACK CMLFLink::GetFontCodePagesEnumFontProc(const LOGFONT* plf, const TEXTMETRIC*, DWORD FontType, LPARAM lParam)
{
for (int iCharSet = 0; g_CharSetTransTable[iCharSet].nCharSet != DEFAULT_CHARSET; iCharSet++)
{
if (plf->lfCharSet == g_CharSetTransTable[iCharSet].nCharSet)
{
if ((FontType == TRUETYPE_FONTTYPE) ||
(g_CharSetTransTable[iCharSet].uCodePage == g_uACP))
{
*((DWORD*)lParam) |= g_CharSetTransTable[iCharSet].dwCodePages;
break;
}
}
}
return TRUE;
}
int CALLBACK CMLFLink::GetFontCodePagesEnumFontProcW(const LOGFONTW* plf, const TEXTMETRICW*, DWORD FontType, LPARAM lParam)
{
for (int iCharSet = 0; g_CharSetTransTable[iCharSet].nCharSet != DEFAULT_CHARSET; iCharSet++)
{
if (plf->lfCharSet == g_CharSetTransTable[iCharSet].nCharSet)
{
if ((FontType == TRUETYPE_FONTTYPE) ||
(g_CharSetTransTable[iCharSet].uCodePage == g_uACP))
{
*((DWORD*)lParam) |= g_CharSetTransTable[iCharSet].dwCodePages;
break;
}
}
}
return TRUE;
}
STDMETHODIMP CMLFLink::MapFont(HDC hDC, DWORD dwCodePages, HFONT hSrcFont, HFONT* phDestFont)
{
ASSERT_THIS;
ASSERT_WRITE_PTR_OR_NULL(phDestFont);
HRESULT hr = S_OK;
CFontMappingInfo fm; // To accelerate internal subroutine calls
fm.hDC = hDC;
// Font mapping cache works only for Display
BOOL fDisplay = (::GetDeviceCaps(hDC, TECHNOLOGY) == DT_RASDISPLAY);
dwCodePages &= ~FS_SYMBOL; // We don't map symbol font.
if (!::GetObject(hSrcFont, sizeof(fm.lfSrcFont), &fm.lfSrcFont))
hr = E_FAIL; // Invalid hSrcFont
// Do two things at same time
// (1) Find given font in the font mapping cache
// (2) Build m_auCodePage[] and m_adwCodePages[]
if (SUCCEEDED(hr))
{
if (fDisplay)
{
BYTE nCharSet = fm.lfSrcFont.lfCharSet;
fm.lfSrcFont.lfCharSet = DEFAULT_CHARSET;
EnumFontFamiliesEx(hDC, &fm.lfSrcFont, (FONTENUMPROC)VerifyFontSizeEnumFontProc, (LPARAM)&fm.lfSrcFont, 0);
fm.lfSrcFont.lfCharSet = nCharSet;
}
hr = S_FALSE; // hr == S_FALSE means that we didn't find the font in the cache
for (int n = 0; n < 32 && dwCodePages; n++)
{
hr = CodePagesToCodePage(dwCodePages, 0, &fm.auCodePage[n]); // Pick one of CodePages
if (SUCCEEDED(hr))
hr = CodePageToCodePages(fm.auCodePage[n], &fm.adwCodePages[n]);
if (SUCCEEDED(hr))
{
if (fDisplay && m_pFontMappingCache)
hr = m_pFontMappingCache->FindEntry(fm.auCodePage[n], fm.lfSrcFont, &fm.hDestFont);
else
hr = S_FALSE;
}
if (hr != S_FALSE)
break;
dwCodePages &= ~fm.adwCodePages[n];
}
fm.auCodePage[n] = NULL; // End mark
fm.adwCodePages[n] = 0;
}
if (hr == S_FALSE) // Not exist in cache
{
hr = MapFontCodePages(fm, GetFaceNameRegistry);
if (hr == MLSTR_E_FACEMAPPINGFAILURE)
hr = MapFontCodePages(fm, GetFaceNameGDI);
// Handle font link failure case for NT5
if (hr == MLSTR_E_FACEMAPPINGFAILURE && g_bIsNT5)
hr = MapFontCodePages(fm, GetFaceNameMIME);
if (SUCCEEDED(hr) && fDisplay && m_pFontMappingCache)
hr = m_pFontMappingCache->AddEntry(fm.auCodePage[fm.iCP], fm.lfSrcFont, fm.hDestFont);
}
if (phDestFont)
{
if (SUCCEEDED(hr))
{
*phDestFont = fm.hDestFont;
fm.hDestFont = NULL; // Avoid being deleted it in destructor
}
else
{
*phDestFont = NULL;
}
}
return hr;
}
STDMETHODIMP CMLFLink::ReleaseFont(HFONT hFont)
{
ASSERT_THIS;
HRESULT hr = S_OK;
if (!m_pFontMappingCache || FAILED(hr = m_pFontMappingCache->UnlockEntry(hFont)))
{
// For non display DC
if (::DeleteObject(hFont))
hr = S_OK;
else
hr = E_FAIL; // Invalid hFont
}
return hr;
}
STDMETHODIMP CMLFLink::ResetFontMapping(void)
{
ASSERT_THIS;
HRESULT hr = S_OK;
if (m_pFontMappingCache)
hr = m_pFontMappingCache->FlushEntries();
return hr;
}
STDMETHODIMP CMLFLink2::ResetFontMapping(void)
{
ASSERT_THIS;
HRESULT hr = S_OK;
if (m_pIMLFLnk)
hr = m_pIMLFLnk->ResetFontMapping();
if (m_pFontMappingCache2)
hr = (S_OK == m_pFontMappingCache2->EnsureFontTable(FALSE)? hr : E_FAIL);
return hr;
}
HRESULT CMLFLink::MapFontCodePages(CFontMappingInfo& fm, PFNGETFACENAME pfnGetFaceName)
{
HRESULT hr = MLSTR_E_FACEMAPPINGFAILURE;
for (fm.iCP = 0; fm.auCodePage[fm.iCP]; fm.iCP++)
{
fm.lfDestFont.lfCharSet = DEFAULT_CHARSET;
hr = (this->*pfnGetFaceName)(fm);
if (SUCCEEDED(hr))
{
LOGFONT lf = {0};
// If face name is from registry or MIMEDB, we set charset to codepage charset.
if (fm.lfDestFont.lfCharSet == DEFAULT_CHARSET)
{
for (int iCharSet = 0; g_CharSetTransTable[iCharSet].uCodePage; iCharSet++)
{
if (fm.auCodePage[fm.iCP] == g_CharSetTransTable[iCharSet].uCodePage)
{
fm.lfDestFont.lfCharSet = (BYTE)g_CharSetTransTable[iCharSet].nCharSet;
break;
}
}
}
lf.lfCharSet = DEFAULT_CHARSET;
MLStrCpyN(lf.lfFaceName, fm.szFaceName, LF_FACESIZE);
// Retrieve LOGFONT from gotten facename
fm.lfDestFont.lfFaceName[0] = _T('\0');
if (!::EnumFontFamiliesEx(fm.hDC, &lf, MapFontEnumFontProc, (LPARAM)&fm.lfDestFont, 0))
hr = E_FAIL; // Invalid hDC
else if (fm.lfDestFont.lfFaceName[0] == _T('\0'))
hr = MLSTR_E_FACEMAPPINGFAILURE;
}
if (SUCCEEDED(hr))
{
fm.lfDestFont.lfHeight = fm.lfSrcFont.lfHeight;
fm.lfDestFont.lfWidth = fm.lfSrcFont.lfWidth;
fm.lfDestFont.lfEscapement = fm.lfSrcFont.lfEscapement;
fm.lfDestFont.lfOrientation = fm.lfSrcFont.lfOrientation;
fm.lfDestFont.lfWeight = fm.lfSrcFont.lfWeight;
fm.lfDestFont.lfItalic = fm.lfSrcFont.lfItalic;
fm.lfDestFont.lfUnderline = fm.lfSrcFont.lfUnderline;
fm.lfDestFont.lfStrikeOut = fm.lfSrcFont.lfStrikeOut;
HRESULT hrTemp = VerifyFaceMap(fm);
if (hrTemp == MLSTR_E_FACEMAPPINGFAILURE && fm.lfDestFont.lfWidth)
{
fm.lfDestFont.lfWidth = 0; // To recover non-scalable font
hr = VerifyFaceMap(fm);
}
else
{
hr = hrTemp;
}
}
if (hr != MLSTR_E_FACEMAPPINGFAILURE)
break;
}
return hr;
}
int CALLBACK CMLFLink::MapFontEnumFontProc(const LOGFONT* plfFont, const TEXTMETRIC*, DWORD, LPARAM lParam)
{
LOGFONT* plfDestFont = (LOGFONT*)lParam;
if (!plfDestFont->lfFaceName[0] )
{
if (plfDestFont->lfCharSet != DEFAULT_CHARSET)
{
if (plfDestFont->lfCharSet == plfFont->lfCharSet)
*plfDestFont = *plfFont;
}
else
*plfDestFont = *plfFont;
}
return TRUE;
}
HRESULT CMLFLink::GetFaceNameRegistry(CFontMappingInfo& fm)
{
static const TCHAR szRootKey[] = _T("Software\\Microsoft\\Internet Explorer");
static const TCHAR szIntlKey[] = _T("International\\%d");
static const TCHAR szPropFontName[] = _T("IEPropFontName");
static const TCHAR szFixedFontName[] = _T("IEFixedFontName");
HRESULT hr = S_OK;
HKEY hKeyRoot;
if (::RegOpenKeyEx(HKEY_CURRENT_USER, szRootKey, 0, KEY_READ, &hKeyRoot) == ERROR_SUCCESS)
{
TCHAR szCodePageKey[ARRAYSIZE(szIntlKey) + 10];
HKEY hKeySub;
::wsprintf(szCodePageKey, szIntlKey, fm.auCodePage[fm.iCP]);
if (::RegOpenKeyEx(hKeyRoot, szCodePageKey, 0, KEY_READ, &hKeySub) == ERROR_SUCCESS)
{
const TCHAR* pszFontNameValue;
DWORD dwType;
DWORD dwSize = sizeof(fm.szFaceName);
if ((fm.lfSrcFont.lfPitchAndFamily & 0x03) == FIXED_PITCH)
pszFontNameValue = szFixedFontName;
else
pszFontNameValue = szPropFontName;
if (::RegQueryValueEx(hKeySub, pszFontNameValue, 0, &dwType, (LPBYTE)fm.szFaceName, &dwSize) != ERROR_SUCCESS)
hr = MLSTR_E_FACEMAPPINGFAILURE;
if (::RegCloseKey(hKeySub) != ERROR_SUCCESS && SUCCEEDED(hr))
hr = MLSTR_E_FACEMAPPINGFAILURE;
}
else
{
hr = MLSTR_E_FACEMAPPINGFAILURE;
}
if (::RegCloseKey(hKeyRoot) != ERROR_SUCCESS && SUCCEEDED(hr))
hr = MLSTR_E_FACEMAPPINGFAILURE;
}
else
{
hr = MLSTR_E_FACEMAPPINGFAILURE;
}
return hr;
}
HRESULT CMLFLink::GetFaceNameGDI(CFontMappingInfo& fm)
{
HRESULT hr = S_OK;
for (int iCharSet = 0; g_CharSetTransTable[iCharSet].uCodePage; iCharSet++)
{
if (fm.auCodePage[fm.iCP] == g_CharSetTransTable[iCharSet].uCodePage)
break;
}
if (g_CharSetTransTable[iCharSet].uCodePage)
{
::memset(&fm.lfDestFont, 0, sizeof(fm.lfDestFont));
// Specify font weight as NORMAL to avoid NT GDI font mapping bugs
fm.lfDestFont.lfWeight = FW_NORMAL;
fm.lfDestFont.lfCharSet = (BYTE)g_CharSetTransTable[iCharSet].nCharSet;
hr = GetFaceNameRealizeFont(fm);
}
else
{
hr = E_FAIL; // Unknown code page
}
if (SUCCEEDED(hr))
{
// Height, CharSet, Pitch and Family
fm.lfDestFont.lfHeight = fm.lfSrcFont.lfHeight;
fm.lfDestFont.lfPitchAndFamily = fm.lfSrcFont.lfPitchAndFamily;
hr = GetFaceNameRealizeFont(fm);
if (FAILED(hr))
{
// CharSet, Pitch and Family
fm.lfDestFont.lfHeight = 0;
hr = GetFaceNameRealizeFont(fm);
}
if (FAILED(hr))
{
// CharSet and Pitch
fm.lfDestFont.lfPitchAndFamily &= 0x03; // Pitch Mask
hr = GetFaceNameRealizeFont(fm);
}
if (FAILED(hr))
{
// CharSet only
fm.lfDestFont.lfPitchAndFamily = 0;
hr = GetFaceNameRealizeFont(fm);
}
}
return hr;
}
HRESULT CMLFLink::GetFaceNameMIME(CFontMappingInfo& fm)
{
HRESULT hr = E_FAIL;
MIMECPINFO cpInfo;
if (fm.auCodePage[fm.iCP] == 936)
{
MLStrCpyN(fm.szFaceName, TEXT("SimSun"), LF_FACESIZE);
return S_OK;
}
if (!g_pMimeDatabase)
BuildGlobalObjects();
if (NULL != g_pMimeDatabase)
{
if (SUCCEEDED(g_pMimeDatabase->GetCodePageInfo(fm.auCodePage[fm.iCP], 0x409, &cpInfo)))
{
TCHAR szFontFaceName[LF_FACESIZE];
szFontFaceName[0] = 0;
if ((fm.lfSrcFont.lfPitchAndFamily & 0x03) == FIXED_PITCH && cpInfo.wszFixedWidthFont[0])
{
#ifdef UNICODE
MLStrCpyNW(szFontFaceName, cpInfo.wszFixedWidthFont, LF_FACESIZE);
#else
WideCharToMultiByte(CP_ACP, 0, cpInfo.wszFixedWidthFont, -1, szFontFaceName, LF_FACESIZE, NULL, NULL);
#endif
}
else
if (cpInfo.wszProportionalFont[0])
{
#ifdef UNICODE
MLStrCpyNW(szFontFaceName, cpInfo.wszProportionalFont, LF_FACESIZE);
#else
WideCharToMultiByte(CP_ACP, 0, cpInfo.wszProportionalFont, -1, szFontFaceName, LF_FACESIZE, NULL, NULL);
#endif
}
if (szFontFaceName[0])
{
MLStrCpyN(fm.szFaceName, szFontFaceName, LF_FACESIZE);
hr = S_OK;
}
}
else
hr = MLSTR_E_FACEMAPPINGFAILURE;
}
return hr;
}
HRESULT CMLFLink::GetFaceNameRealizeFont(CFontMappingInfo& fm)
{
HRESULT hr = S_OK;
HFONT hFont = NULL;
HFONT hOldFont;
DWORD dwFontCodePages;
// First let's get a facename based on the given lfDestFont
// Then verify if the font of the found facename has the code pages we want.
hFont = ::CreateFontIndirect(&fm.lfDestFont);
if (!hFont)
hr = E_FAIL; // Out of memory or GDI resource
if (SUCCEEDED(hr))
{
hOldFont = (HFONT)::SelectObject(fm.hDC, hFont);
if (!hOldFont)
hr = E_FAIL; // Out of memory or GDI resource
}
if (SUCCEEDED(hr))
{
if (!::GetTextFace(fm.hDC, ARRAYSIZE(fm.szFaceName), fm.szFaceName))
hr = E_FAIL; // Out of memory or GDI resource
if (!::SelectObject(fm.hDC, hOldFont) && SUCCEEDED(hr))
hr = E_FAIL; // Out of memory or GDI resource
}
if (hFont)
::DeleteObject(hFont);
if (SUCCEEDED(hr))
{
LOGFONT lfTemp;
lfTemp = fm.lfDestFont;
//
// Security
//
_tcsncpy(lfTemp.lfFaceName, fm.szFaceName, ARRAYSIZE(lfTemp.lfFaceName));
hFont = ::CreateFontIndirect(&lfTemp);
if (!hFont)
hr = E_FAIL; // Out of memory or GDI resource
if (SUCCEEDED(hr = GetFontCodePages(fm.hDC, hFont, &dwFontCodePages)) && !(dwFontCodePages & fm.adwCodePages[fm.iCP]))
hr = MLSTR_E_FACEMAPPINGFAILURE;
if (hFont)
::DeleteObject(hFont);
}
return hr;
}
HRESULT CMLFLink::VerifyFaceMap(CFontMappingInfo& fm)
{
HRESULT hr = S_OK;
HFONT hOldFont;
if (fm.hDestFont)
::DeleteObject(fm.hDestFont);
fm.hDestFont = ::CreateFontIndirect(&fm.lfDestFont);
if (!fm.hDestFont)
hr = E_FAIL; // Out of memory or GDI resource
if (SUCCEEDED(hr))
{
hOldFont = (HFONT)::SelectObject(fm.hDC, fm.hDestFont);
if (!hOldFont)
hr = E_FAIL; // Out of memory or GDI resource
}
if (SUCCEEDED(hr))
{
TCHAR szFaceName[LF_FACESIZE];
if (!::GetTextFace(fm.hDC, ARRAYSIZE(szFaceName), szFaceName))
hr = E_FAIL; // Out of memory or GDI resource
if (SUCCEEDED(hr))
{
int nRet = ::CompareString(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, fm.lfDestFont.lfFaceName, -1, szFaceName, -1);
if (!nRet)
hr = E_FAIL; // Unexpected error
else if (nRet != 2) // Not Equal
hr = MLSTR_E_FACEMAPPINGFAILURE;
}
if (!::SelectObject(fm.hDC, hOldFont) && SUCCEEDED(hr))
hr = E_FAIL; // Out of memory or GDI resource
}
return hr;
}
/////////////////////////////////////////////////////////////////////////////
// CMLFLink::CFontMappingCache
CMLFLink::CFontMappingCache::CFontMappingCache(void) :
m_pEntries(NULL),
m_pFree(NULL),
m_cEntries(0)
{
::InitializeCriticalSection(&m_cs);
}
CMLFLink::CFontMappingCache::~CFontMappingCache(void)
{
FlushEntries();
DeleteCriticalSection(&m_cs);
}
HRESULT CMLFLink::CFontMappingCache::FindEntry(UINT uCodePage, const LOGFONT& lfSrcFont, HFONT* phDestFont)
{
HRESULT hr = S_FALSE;
::EnterCriticalSection(&m_cs);
if (m_pEntries)
{
CFontMappingCacheEntry* pEntry = m_pEntries;
while ((pEntry = pEntry->m_pPrev) != m_pEntries)
{
if (uCodePage == pEntry->m_uSrcCodePage &&
lfSrcFont.lfPitchAndFamily == pEntry->m_bSrcPitchAndFamily &&
lfSrcFont.lfHeight == pEntry->m_lSrcHeight &&
lfSrcFont.lfWidth == pEntry->m_lSrcWidth &&
lfSrcFont.lfEscapement == pEntry->m_lSrcEscapement &&
lfSrcFont.lfOrientation == pEntry->m_lSrcOrientation &&
lfSrcFont.lfWeight == pEntry->m_lSrcWeight &&
lfSrcFont.lfItalic == pEntry->m_bSrcItalic &&
lfSrcFont.lfUnderline == pEntry->m_bSrcUnderline &&
lfSrcFont.lfStrikeOut == pEntry->m_bSrcStrikeOut)
{
int nRet = ::CompareString(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, lfSrcFont.lfFaceName, -1, pEntry->m_szSrcFaceName, -1);
if (!nRet)
{
hr = E_FAIL; // Unexpected error
break;
}
else if (nRet == 2) // Equal
{
if (phDestFont)
*phDestFont = pEntry->m_hDestFont;
pEntry->m_nLockCount++;
hr = S_OK;
break;
}
}
}
}
::LeaveCriticalSection(&m_cs);
if (phDestFont && hr != S_OK)
*phDestFont = NULL;
return hr;
}
HRESULT CMLFLink::CFontMappingCache::UnlockEntry(HFONT hDestFont)
{
HRESULT hr = E_FAIL; // hDestFont is not found in the cache
::EnterCriticalSection(&m_cs);
if (m_pEntries)
{
CFontMappingCacheEntry* pEntry = m_pEntries;
while ((pEntry = pEntry->m_pPrev) != m_pEntries)
{
if (hDestFont == pEntry->m_hDestFont)
{
if (pEntry->m_nLockCount - 1 >= 0)
{
pEntry->m_nLockCount--;
hr = S_OK;
}
break;
}
}
}
::LeaveCriticalSection(&m_cs);
return hr;
}
HRESULT CMLFLink::CFontMappingCache::AddEntry(UINT uCodePage, const LOGFONT& lfSrcFont, HFONT hDestFont)
{
HRESULT hr = S_OK;
::EnterCriticalSection(&m_cs);
if (!m_pEntries) // Need to allocate all the entries
{
CFontMappingCacheEntry* pEntries;
pEntries = new CFontMappingCacheEntry[NUMFONTMAPENTRIES + 1]; // +1 for sentinel
if (pEntries)
{
// Init sentinel
pEntries[0].m_pPrev = &pEntries[0];
pEntries[0].m_pNext = &pEntries[0];
// Init free entries
for (int n = 0; n < NUMFONTMAPENTRIES; n++)
{
const nEnt = n + 1; // + 1 for sentinel
if (n < NUMFONTMAPENTRIES - 1)
pEntries[nEnt].m_pNext = &pEntries[nEnt + 1];
else
pEntries[nEnt].m_pNext = NULL;
}
m_pEntries = &pEntries[0];
m_pFree = &pEntries[1];
}
else
{
hr = E_OUTOFMEMORY;
}
}
if (SUCCEEDED(hr) && !m_pFree) // Need to delete oldest entry
{
CFontMappingCacheEntry* pOldestEntry = m_pEntries->m_pPrev;
while (pOldestEntry->m_nLockCount > 0 && pOldestEntry != m_pEntries) // Entry is locked
pOldestEntry = pOldestEntry->m_pPrev;
if (pOldestEntry != m_pEntries)
{
if (pOldestEntry->m_hDestFont)
::DeleteObject(pOldestEntry->m_hDestFont);
// Delete it from m_pEntries list
pOldestEntry->m_pPrev->m_pNext = pOldestEntry->m_pNext;
pOldestEntry->m_pNext->m_pPrev = pOldestEntry->m_pPrev;
// Insert it into m_pFree list
pOldestEntry->m_pNext = m_pFree;
m_pFree = pOldestEntry;
}
else // No entry available
{
hr = E_FAIL; // Out of cache entries
}
}
if (SUCCEEDED(hr)) // Create new entry and fill it
{
CFontMappingCacheEntry* pNewEntry;
// Delete it from m_pFree list
pNewEntry = m_pFree; // shouldn't be NULL
m_pFree = pNewEntry->m_pNext;
// Insert it into m_pEntries list
pNewEntry->m_pNext = m_pEntries->m_pNext;
pNewEntry->m_pPrev = m_pEntries;
m_pEntries->m_pNext->m_pPrev = pNewEntry;
m_pEntries->m_pNext = pNewEntry;
// Fill it
pNewEntry->m_nLockCount = 1;
pNewEntry->m_uSrcCodePage = uCodePage;
pNewEntry->m_lSrcHeight = lfSrcFont.lfHeight;
pNewEntry->m_lSrcWidth = lfSrcFont.lfWidth;
pNewEntry->m_lSrcEscapement = lfSrcFont.lfEscapement;
pNewEntry->m_lSrcOrientation = lfSrcFont.lfOrientation;
pNewEntry->m_lSrcWeight = lfSrcFont.lfWeight;
pNewEntry->m_bSrcItalic = lfSrcFont.lfItalic;
pNewEntry->m_bSrcUnderline = lfSrcFont.lfUnderline;
pNewEntry->m_bSrcStrikeOut = lfSrcFont.lfStrikeOut;
pNewEntry->m_bSrcPitchAndFamily = lfSrcFont.lfPitchAndFamily;
//security
_tcsncpy(pNewEntry->m_szSrcFaceName, lfSrcFont.lfFaceName, ARRAYSIZE(pNewEntry->m_szSrcFaceName));
pNewEntry->m_hDestFont = hDestFont;
}
::LeaveCriticalSection(&m_cs);
return hr;
}
HRESULT CMLFLink::CFontMappingCache::FlushEntries(void)
{
::EnterCriticalSection(&m_cs);
if (m_pEntries)
{
CFontMappingCacheEntry* pEntry = m_pEntries;
while ((pEntry = pEntry->m_pPrev) != m_pEntries)
{
if (pEntry->m_hDestFont)
::DeleteObject(pEntry->m_hDestFont);
}
delete[] m_pEntries;
m_pEntries = NULL;
m_cEntries = 0;
}
::LeaveCriticalSection(&m_cs);
return S_OK;
}
/////////////////////////////////////////////////////////////////////////////
// CMLFLink::CCodePagesCache
CMLFLink::CCodePagesCache::CCodePagesCache(void) :
m_pbBuf(NULL),m_pbBufExt(NULL)
{
::InitializeCriticalSection(&m_cs);
}
CMLFLink::CCodePagesCache::~CCodePagesCache(void)
{
DeleteCriticalSection(&m_cs);
}
HRESULT CMLFLink::CCodePagesCache::RealLoad(void)
{
HRESULT hr = S_OK;
::EnterCriticalSection(&m_cs);
if (!m_pbBuf && !m_pbBufExt)
{
HRSRC hrCodePages;
HGLOBAL hgCodePages;
HRSRC hrCodePagesExt;
HGLOBAL hgCodePagesExt;
if (SUCCEEDED(hr))
{
hrCodePages = ::FindResource(g_hInst, MAKEINTRESOURCE(IDR_CODEPAGES), _T("CODEPAGES"));
hrCodePagesExt = ::FindResource(g_hInst, MAKEINTRESOURCE(IDR_CODEPAGESEXT), _T("CODEPAGESEXT"));
if (!hrCodePages || !hrCodePagesExt)
hr = E_FAIL; // Build error?
}
if (SUCCEEDED(hr))
{
hgCodePages = ::LoadResource(g_hInst, hrCodePages);
hgCodePagesExt = ::LoadResource(g_hInst, hrCodePagesExt);
if (!hgCodePages && !hgCodePagesExt)
hr = E_FAIL; // Unexpected error
}
if (SUCCEEDED(hr))
{
m_pbBuf = (BYTE*)::LockResource(hgCodePages);
m_pbBufExt = (BYTE*)::LockResource(hgCodePagesExt);
if (!m_pbBuf || !m_pbBufExt)
hr = E_FAIL; // Unexpected error
}
}
::LeaveCriticalSection(&m_cs);
return hr;
}
extern "C" HRESULT GetGlobalFontLinkObject(IMLangFontLink **ppMLFontLink)
{
HRESULT hr = E_INVALIDARG;
if (NULL != ppMLFontLink)
{
if (NULL == g_pMLFLink)
{
EnterCriticalSection(&g_cs);
if (NULL == g_pMLFLink)
CComCreator< CComPolyObject< CMLFLink > >::CreateInstance(NULL, IID_IMLangFontLink, (void **)&g_pMLFLink);
LeaveCriticalSection(&g_cs);
}
*ppMLFontLink = g_pMLFLink;
if (g_pMLFLink)
{
g_pMLFLink->AddRef();
hr = S_OK;
}
else
hr = E_FAIL;
}
return hr;
}
HRESULT CMLFLink2::CFontMappingCache2::MapFontFromCMAP(HDC hDC, WCHAR wchar, HFONT hSrcFont, HFONT *phDestFont)
{
BOOL bFont = FALSE;
HRESULT hr = E_FAIL;
int i,j,k;
LOGFONT LogFont;
if (!phDestFont)
return E_INVALIDARG;
if (!GetObject(hSrcFont, sizeof(LOGFONT), &LogFont))
return hr;
if (!g_pfont_table || !g_pfont_table[0].szFaceName[0])
{
if (FAILED(LoadFontDataFile()))
{
return hr;
}
}
i=0;
j=ARRAYSIZE(g_urange_table);
k = j/2;
while (i<=j)
{
if (wchar >= g_urange_table[k].wcFrom && wchar <= g_urange_table[k].wcTo)
break;
else
if (wchar < g_urange_table[k].wcFrom)
{
j = k -1;
}
else
{
i = k + 1;
}
k = (i+j)/2;
}
if (i<=j && g_urange_table[k].nFonts)
{
TCHAR szFaceName[LF_FACESIZE];
GetTextFace(hDC, LF_FACESIZE, szFaceName);
// Check if it supports the character
for (i=0; i<g_urange_table[k].nFonts; i++)
{
if (!MLStrCmpI(szFaceName,g_pfont_table[*(g_urange_table[k].pFontIndex+i)].lf.lfFaceName))
break;
}
// Current font doesn't support this character
if (i == g_urange_table[k].nFonts)
{
for (i=0; i<g_urange_table[k].nFonts; i++)
{
if (LogFont.lfCharSet == g_pfont_table[*(g_urange_table[k].pFontIndex+i)].lf.lfCharSet)
break;
}
// No font available for current CharSet, then return the first one in the list
if (i >= g_urange_table[k].nFonts)
{
i = fetchCharSet((BYTE *) &(LogFont.lfCharSet), k);
}
MLStrCpyN(LogFont.lfFaceName, g_pfont_table[*(g_urange_table[k].pFontIndex+i)].lf.lfFaceName, LF_FACESIZE);
}
if (i < g_urange_table[k].nFonts)
{
MLStrCpyN(LogFont.lfFaceName, g_pfont_table[*(g_urange_table[k].pFontIndex+i)].lf.lfFaceName, LF_FACESIZE);
}
bFont = TRUE;
}
if (bFont && (*phDestFont = CreateFontIndirect(&LogFont)))
{
hr = S_OK;
}
else
{
*phDestFont = NULL;
}
return hr;
}
HRESULT CMLFLink2::CFontMappingCache2::UnicodeRanges(
LPTSTR szFont,
UINT *puiRanges,
UNICODERANGE* pURanges
)
{
HRESULT hr = E_FAIL;
UINT nURange = 0;
DWORD cmap = 0;
DWORD name = 0;
HANDLE hTTF;
TCHAR szFontPath[MAX_PATH];
static TCHAR s_szFontDir[MAX_PATH] = {0};
HANDLE hTTFMap;
DWORD dwFileSize;
LPVOID lpvFile = NULL;
LPBYTE lp, lp1, lp2, lpMax = NULL;
DWORD Num;
WORD i, j, Len;
if (!szFont[0])
return hr;
if (!s_szFontDir[0])
{
MLGetWindowsDirectory(s_szFontDir, MAX_PATH);
MLPathCombine(s_szFontDir, ARRAYSIZE(s_szFontDir), s_szFontDir, FONT_FOLDER);
}
MLPathCombine(szFontPath, ARRAYSIZE(szFontPath), s_szFontDir, szFont);
hTTF = CreateFile( szFontPath, // pointer to name of the file
GENERIC_READ, // access (read-write) mode
FILE_SHARE_READ, // share mode
NULL, // pointer to security attributes
OPEN_EXISTING, // how to create
FILE_ATTRIBUTE_NORMAL, // file attributes
NULL); // handle to file with attributes to copy;
if (INVALID_HANDLE_VALUE == hTTF)
return hr;
dwFileSize = GetFileSize(hTTF, NULL);
hTTFMap = CreateFileMapping(
hTTF,
NULL,
PAGE_READONLY,
0,
dwFileSize,
NULL
);
if(hTTFMap == NULL)
{
goto CloseHandle;
}
lpvFile = MapViewOfFile(
hTTFMap,
FILE_MAP_READ,
0,
0,
0
);
if(lpvFile == NULL)
{
goto CloseHandle;
}
lp = (LPBYTE)lpvFile;
// The maximum boundary we can go
lpMax = (LPBYTE)lpvFile + dwFileSize;
// Font table name uses ASCII
if(strncmp(((TTC_HEAD*)lp)->TTCTag, "ttcf", 4) == 0) // TTC format
{
lp += FOUR_BYTE_NUM(((TTC_HEAD*)lp)->OffsetTTF1); // points to first TTF
}
Num = TWO_BYTE_NUM(((TTF_HEAD*)lp)->NumTables); // Number of Tables
lp += sizeof(TTF_HEAD);
if (lp+Num*sizeof(TABLE_DIR) >= lpMax) // Not a valid TrueType file if table size >= TTF file size
goto CloseHandle;
for(i = 0; i < Num ; i++) // go thru all tables to find cmap and name
{
if(strncmp( ((TABLE_DIR*)lp)->Tag, "cmap", 4) == 0)
{
cmap = FOUR_BYTE_NUM(((TABLE_DIR*)lp)->Offset);
if (name) break;
}
else if(strncmp( ((TABLE_DIR*)lp)->Tag, "name", 4) == 0)
{
name = FOUR_BYTE_NUM(((TABLE_DIR*)lp)->Offset);
if (cmap) break;
}
lp += sizeof(TABLE_DIR);
}
if((!cmap) || (!name)) // Can't find cmap or name
{
goto CloseHandle;
}
// Read thru all name records
// to see if font subfamily name is "Regular"
lp = (LPBYTE)lpvFile + name; // point to name table
Num = TWO_BYTE_NUM(((NAME_TABLE*)lp)->NumRec); // # of name record
if (lp + sizeof(NAME_TABLE)*Num >= lpMax)
goto CloseHandle;
lp1 = lp + sizeof(NAME_TABLE); // point to name record
for(i = 0; i < Num; i++)
{
if(FONT_SUBFAMILY_NAME == TWO_BYTE_NUM(((NAME_RECORD*)lp1)->NameID))
{
lp2 = lp + // point to string store
TWO_BYTE_NUM(((NAME_TABLE* )lp )->Offset) +
TWO_BYTE_NUM(((NAME_RECORD*)lp1)->Offset);
// Invalid TTF file
if (lp2 >= lpMax)
break;
Len = TWO_BYTE_NUM(((NAME_RECORD*)lp1)->Length);
if(((MICROSOFT_PLATFORM == TWO_BYTE_NUM(((NAME_RECORD*)lp1)->Platform)) &&
(UNICODE_INDEXING == TWO_BYTE_NUM(((NAME_RECORD*)lp1)->Encoding))) ||
((APPLE_UNICODE_PLATFORM == TWO_BYTE_NUM(((NAME_RECORD*)lp1)->Platform)) &&
(APPLE_UNICODE_INDEXING == TWO_BYTE_NUM(((NAME_RECORD*)lp1)->Encoding))))
{
Len >>= 1;
const char *pStr = szRegular;
if (Len == sizeof(szNormal) -1)
pStr = szNormal;
else
if (Len != sizeof(szRegular)-1)
{
lp1 += sizeof(NAME_RECORD);
continue;
}
while(--Len > 0)
{
if(*(lp2+(Len<<1)+1) != pStr[Len])
break;
}
if (!Len)
break;
else
{
lp1 += sizeof(NAME_RECORD);
continue;
}
}
else
{
if(strncmp((char*)lp2, szRegular, sizeof(szRegular)-1) != 0 &&
strncmp((char*)lp2, szNormal, sizeof(szNormal)-1) != 0)
{
lp1 += sizeof(NAME_RECORD);
continue;
}
else
break;
}
}
lp1 += sizeof(NAME_RECORD);
}
// If no regular font, exit
if (i == Num)
goto CloseHandle;
// all non-regular fonts have already been eliminated
lp1 = (LPBYTE)lpvFile + cmap; // point to cmap table
if (lp1 + sizeof(CMAP_TABLE)*Num >= lpMax)
goto CloseHandle;
Num = TWO_BYTE_NUM(((CMAP_HEAD*)lp1)->NumTables);
lp1 += sizeof(CMAP_HEAD);
while(Num >0)
{
if(TWO_BYTE_NUM(((CMAP_TABLE*)lp1)->Platform) == MICROSOFT_PLATFORM &&
(TWO_BYTE_NUM(((CMAP_TABLE*)lp1)->Encoding) == UNICODE_INDEXING ||
TWO_BYTE_NUM(((CMAP_TABLE*)lp1)->Encoding) == UNICODE_SYMBOL_INDEXING))
{
lp = (LPBYTE)lpvFile
+ cmap
+ FOUR_BYTE_NUM(((CMAP_TABLE*)lp1)->Offset);
if(TWO_BYTE_NUM(((CMAP_FORMAT*)lp)->Format) == CMAP_FORMAT_FOUR)
{
break;
}
}
Num--;
lp1 += sizeof(CMAP_TABLE);
}
if(Num == 0) // can't find Platform:3/Encoding:1 (Unicode)
goto CloseHandle;
Num = TWO_BYTE_NUM(((CMAP_FORMAT*)lp)->SegCountX2);
lp2 = lp + sizeof(CMAP_FORMAT); // lp2 -> first WCHAR of wcTo
lp1 = lp2 + Num + 2; // lp1 -> first WCHAR of wcFrom
if (lp1 + Num >= lpMax)
goto CloseHandle;
Num /= 2;
if (pURanges == NULL)
{
*puiRanges = Num;
}
else
{
if (Num > *puiRanges)
Num = *puiRanges;
else
*puiRanges = Num;
for(i=0, j=0; i < Num; i++, j++, j++)
{
pURanges[i].wcFrom = TWO_BYTE_NUM((lp1+j));
pURanges[i].wcTo = TWO_BYTE_NUM((lp2+j));
}
}
hr = S_OK;
CloseHandle:
if (lpvFile)
{
UnmapViewOfFile(lpvFile);
}
if (hTTFMap)
{
CloseHandle(hTTFMap);
}
// Handle is checked after creation.
CloseHandle(hTTF);
return hr;
}
int CMLFLink2::CFontMappingCache2::fetchCharSet(BYTE *pCharset, int iURange)
{
int i,j;
//Check if current charset valid for the font
for (i=0; i<g_urange_table[iURange].nFonts; i++)
{
for (j=0;(j<32) && g_CharSetTransTable[j].uCodePage;j++)
{
if (g_pfont_table[*(g_urange_table[iURange].pFontIndex+i)].dwCodePages[0] & g_CharSetTransTable[j].dwCodePages)
if (*pCharset == g_CharSetTransTable[j].nCharSet)
return i;
}
}
//If invalid, fetch first valid one.
for (i=0;(i<32) && g_CharSetTransTable[i].uCodePage;i++)
{
if (g_pfont_table[*(g_urange_table[iURange].pFontIndex)].dwCodePages[0] & g_CharSetTransTable[i].dwCodePages)
{
*pCharset = (BYTE)g_CharSetTransTable[i].nCharSet;
break;
}
}
return 0;
}
BOOL CMLFLink2::CFontMappingCache2::GetNonCpFontUnicodeRanges(TCHAR *szFontName, int iFontIndex)
{
LONG nURange = 0;
DWORD cmap = 0;
DWORD name = 0;
DWORD os2 = 0;
HANDLE hTTFMap;
DWORD dwFileSize;
LPVOID lpvFile = NULL;
LPBYTE lp, lp1, lp2;
DWORD Num;
int i, j, k, m;
WORD Len;
HANDLE hTTF;
BOOL bRet = FALSE;
hTTF = CreateFile( szFontName, // pointer to name of the file
GENERIC_READ, // access (read-write) mode
FILE_SHARE_READ, // share mode
NULL, // pointer to security attributes
OPEN_EXISTING, // how to create
FILE_ATTRIBUTE_NORMAL, // file attributes
NULL); // handle to file with attributes to copy;
if (hTTF == INVALID_HANDLE_VALUE)
return FALSE;
dwFileSize = GetFileSize(hTTF, NULL);
hTTFMap = CreateFileMapping(
hTTF,
NULL,
PAGE_READONLY,
0,
dwFileSize,
NULL
);
if(hTTFMap == NULL)
{
goto GET_NCP_EXIT;
}
lpvFile = MapViewOfFile(
hTTFMap,
FILE_MAP_READ,
0,
0,
0
);
if(lpvFile == NULL)
{
goto GET_NCP_EXIT;
}
lp = (LPBYTE)lpvFile;
if(strncmp(((TTC_HEAD*)lp)->TTCTag, "ttcf", 4) == 0) // TTC format
{
lp += FOUR_BYTE_NUM(((TTC_HEAD*)lp)->OffsetTTF1); // points to first TTF
}
Num = TWO_BYTE_NUM(((TTF_HEAD*)lp)->NumTables); // Number of Tables
{
// if SearchRange != (Maximum power of 2 <= Num)*16,
// then this is not a TTF file
DWORD wTmp = 1;
while(wTmp <= Num)
{
wTmp <<= 1;
}
wTmp <<= 3; // (wTmp/2)*16
if(wTmp != (DWORD)TWO_BYTE_NUM(((TTF_HEAD*)lp)->SearchRange))
{
goto GET_NCP_EXIT;
}
// if RangeShift != (Num*16) - SearchRange,
// then this is not a TTF file
wTmp = (Num<<4) - wTmp;
if(wTmp != (DWORD)TWO_BYTE_NUM(((TTF_HEAD*)lp)->RangeShift))
{
goto GET_NCP_EXIT;
}
}
lp += sizeof(TTF_HEAD);
for(i = 0; i < (int)Num; i++) // go thru all tables to find cmap and name
{
if(strncmp( ((TABLE_DIR*)lp)->Tag, "cmap", 4) == 0)
{
cmap = FOUR_BYTE_NUM(((TABLE_DIR*)lp)->Offset);
if (name && os2) break;
}
else if(strncmp( ((TABLE_DIR*)lp)->Tag, "name", 4) == 0)
{
name = FOUR_BYTE_NUM(((TABLE_DIR*)lp)->Offset);
if (cmap && os2) break;
}
else if(strncmp( ((TABLE_DIR*)lp)->Tag, "OS/2", 4) == 0)
{
os2 = FOUR_BYTE_NUM(((TABLE_DIR*)lp)->Offset);
if (cmap && name) break;
}
lp += sizeof(TABLE_DIR);
}
if((!cmap) || (!name) || (!os2)) // Can't find cmap or name
{
goto GET_NCP_EXIT;
}
// Read thru all name records
// to see if font subfamily name is "Regular"
lp = (LPBYTE)lpvFile + name; // point to name table
Num = TWO_BYTE_NUM(((NAME_TABLE*)lp)->NumRec); // # of name record
lp1 = lp + sizeof(NAME_TABLE); // point to name record
for(i = 0; i < (int)Num; i++)
{
if(FONT_SUBFAMILY_NAME == TWO_BYTE_NUM(((NAME_RECORD*)lp1)->NameID))
{
lp2 = lp + // point to string store
TWO_BYTE_NUM(((NAME_TABLE* )lp )->Offset) +
TWO_BYTE_NUM(((NAME_RECORD*)lp1)->Offset);
Len = TWO_BYTE_NUM(((NAME_RECORD*)lp1)->Length);
if(UNICODE_INDEXING == TWO_BYTE_NUM(((NAME_RECORD*)lp1)->Encoding))
{
Len >>= 1;
while(--Len > 0)
{
if(*(lp2+(Len<<1)+1) != szRegular[Len])
goto GET_NCP_EXIT;
}
break;
}
else
{
if(strncmp((char*)lp2, szRegular, Len) != 0)
goto GET_NCP_EXIT;
else
break;
}
}
lp1 += sizeof(NAME_RECORD);
}
// all non-regular fonts have already been eliminated
lp1 = (LPBYTE)lpvFile + cmap; // point to cmap table
Num = TWO_BYTE_NUM(((CMAP_HEAD*)lp)->NumTables);
lp1 += sizeof(CMAP_HEAD);
while(Num >0)
{
if(TWO_BYTE_NUM(((CMAP_TABLE*)lp1)->Platform) == MICROSOFT_PLATFORM &&
TWO_BYTE_NUM(((CMAP_TABLE*)lp1)->Encoding) == UNICODE_INDEXING)
{
lp = (LPBYTE)lpvFile
+ cmap
+ FOUR_BYTE_NUM(((CMAP_TABLE*)lp1)->Offset);
if(TWO_BYTE_NUM(((CMAP_FORMAT*)lp)->Format) == CMAP_FORMAT_FOUR)
{
break;
}
}
Num--;
lp1 += sizeof(CMAP_TABLE);
}
if(Num == 0) // can't find Platform:3/Encoding:1 (Unicode)
goto GET_NCP_EXIT;
Num = TWO_BYTE_NUM(((CMAP_FORMAT*)lp)->SegCountX2) ;
m = ARRAYSIZE(g_urange_table);
lp2 = lp + sizeof(CMAP_FORMAT); // lp2 -> first WCHAR of wcTo
lp1 = lp2 + Num + 2; // lp1 -> first WCHAR of wcFrom
// Fast parse !!!
while (--m)
{
// URANGE binary search
i=0;
j= (int) Num - 2;
k=j/2;
while (i<=j)
{
if (k % 2)
k++;
if (g_urange_table[m].wcFrom >= TWO_BYTE_NUM((lp1+k)) && g_urange_table[m].wcTo <= TWO_BYTE_NUM((lp2+k)))
{
EnterCriticalSection(&g_cs);
if (!g_urange_table[m].pFontIndex)
g_urange_table[m].pFontIndex = (int *)LocalAlloc(LPTR, sizeof(int)* MAX_FONT_INDEX);
if (!g_urange_table[m].pFontIndex)
{
LeaveCriticalSection(&g_cs);
goto GET_NCP_EXIT;
}
if (g_urange_table[m].nFonts >= MAX_FONT_INDEX)
{
LeaveCriticalSection(&g_cs);
break;
}
g_urange_table[m].pFontIndex[g_urange_table[m].nFonts] = iFontIndex;
g_urange_table[m].nFonts++;
// Fill in font code page signature
g_pfont_table[iFontIndex].dwCodePages[0] = FOUR_BYTE_NUM(((BYTE *)lpvFile+os2+OFFSET_OS2CPRANGE));
g_pfont_table[iFontIndex].dwCodePages[1] = FOUR_BYTE_NUM(((BYTE *)lpvFile+os2+OFFSET_OS2CPRANGE+1));
LeaveCriticalSection(&g_cs);
break;
}
else
{
if (g_urange_table[m].wcFrom < TWO_BYTE_NUM((lp1+k)))
{
j = k-2;
}
else
{
i = k+2;
}
k = (i+j)/2;
}
}
}
bRet = TRUE;
GET_NCP_EXIT:
if (lpvFile)
{
UnmapViewOfFile(lpvFile);
}
if (hTTFMap)
{
CloseHandle(hTTFMap);
}
CloseHandle(hTTF);
return bRet;
}
HRESULT GetRegFontKey(HKEY *phKey, DWORD *pdwValues)
{
HRESULT hr = E_FAIL;
if (ERROR_SUCCESS == (g_bIsNT?
RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGFONTKEYNT, 0, KEY_READ, phKey):
RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGFONTKEY95, 0, KEY_READ, phKey)))
{
if (ERROR_SUCCESS == RegQueryInfoKey(*phKey, NULL, NULL, 0, NULL,
NULL, NULL, pdwValues, NULL, NULL, NULL, NULL))
{
hr = S_OK;
}
else
{
RegCloseKey(*phKey);
}
}
return hr;
}
BOOL CMLFLink2::CFontMappingCache2::GetFontURangeBits(TCHAR *szFontFile, DWORD * pdwURange)
{
// We can make use of font Unicode range signature if needed.
return TRUE;
}
BOOL CMLFLink2::CFontMappingCache2::SetFontScripts(void)
{
LOGFONT lf;
int i,j;
HWND hWnd = GetTopWindow(GetDesktopWindow());
HDC hDC = GetDC(hWnd);
if (!g_pfont_table)
return FALSE;
// Process code page based scripts (g_CharSetTransTable.sid)
for (i = 0; g_CharSetTransTable[i].nCharSet != DEFAULT_CHARSET; i++)
{
j = 0;
ZeroMemory(&lf, sizeof(lf));
lf.lfCharSet = (BYTE)g_CharSetTransTable[i].nCharSet;
while (g_CharSetTransTable[i].sid[j] != sidDefault)
{
EnumFontFamiliesEx(hDC, &lf, (FONTENUMPROC)SetFontScriptsEnumFontProc, (LPARAM)g_CharSetTransTable[i].sid[j], 0);
j++;
}
}
if (hDC)
ReleaseDC(hWnd, hDC);
// Process Unicode subrange based scripts (not implemented)
// Skip this part since we need to access font CMAP anyway
// Process char based scripts (g_wCharToScript)
for (i=1; i<= (int)g_pfont_table[0].dwCodePages[0]; i++)
{
UINT uiRanges = 0;
UNICODERANGE* pURanges = NULL;
SCRIPT_IDS scripts;
if (SUCCEEDED(m_pFontMappingCache2->UnicodeRanges(g_pfont_table[i].szFileName, &uiRanges, pURanges)))
{
if (uiRanges)
{
int l, m, n;
pURanges = (UNICODERANGE *)LocalAlloc(LPTR, sizeof(UNICODERANGE) * uiRanges);
if (!pURanges)
return FALSE;
m_pFontMappingCache2->UnicodeRanges(g_pfont_table[i].szFileName, &uiRanges, pURanges);
for (j=0; j< ARRAYSIZE(g_wCharToScript); j++)
{
l = 0;
m = uiRanges;
n = m/2;
while (l <= m)
{
if ((g_wCharToScript[j].wch >= pURanges[n].wcFrom) && (g_wCharToScript[j].wch <= pURanges[n].wcTo))
{
scripts = 1;
scripts <<= g_wCharToScript[j].sid;
g_pfont_table[i].scripts |= scripts;
break;
}
else
{
if (g_wCharToScript[j].wch < pURanges[n].wcFrom)
m = n-1;
else
l = n+1;
n = (m+l)/2;
}
}
}
LocalFree(pURanges);
pURanges = NULL;
}
}
// sidUserDefined should contain all valid regular TrueType fonts
if (!MLStrStr(g_pfont_table[i].szFaceName, TEXT("Bold")) && !MLStrStr(g_pfont_table[i].szFaceName, TEXT("Italic")))
{
scripts = 1;
scripts <<= sidUserDefined;
g_pfont_table[i].scripts |= scripts;
}
}
//GetFontScriptFromCMAP(szFont, &(g_pfont_table[i].scripts));
return TRUE;
}
BOOL CMLFLink2::CFontMappingCache2::IsFontUpdated(void)
{
HKEY hkey;
DWORD dwFonts = 0;
BOOL bRet = FALSE;
if (g_pfont_table)
{
if (S_OK == GetRegFontKey(&hkey, &dwFonts))
{
if (g_pfont_table[0].dwCodePages[1] != dwFonts)
bRet = TRUE;
RegCloseKey(hkey);
}
}
else
{
// font table not created yet, need to update
bRet = TRUE;
}
return bRet;
}
// Make sure we have font data table available and it is updated
HRESULT CMLFLink2::CFontMappingCache2::EnsureFontTable(BOOL bUpdateURangeTable)
{
BOOL bRet;
if (IsFontUpdated())
{
// Need to guard the whole font creation procedure by critical sections
EnterCriticalSection(&g_cs);
if (IsFontUpdated())
{
if (g_pfont_table)
{
if (g_pfont_table[0].szFaceName[0])
{
bUpdateURangeTable = TRUE;
}
LocalFree(g_pfont_table);
g_pfont_table = NULL;
}
bRet = SetFontTable();
if (!bRet)
{
LeaveCriticalSection(&g_cs);
return E_OUTOFMEMORY;
}
}
LeaveCriticalSection(&g_cs);
}
if (bUpdateURangeTable)
{
EnterCriticalSection(&g_cs);
for (int i = 0; i < ARRAYSIZE(g_urange_table); i++)
{
if (g_urange_table[i].nFonts)
{
LocalFree(g_urange_table[i].pFontIndex);
g_urange_table[i].pFontIndex = NULL;
g_urange_table[i].nFonts = 0;
}
}
LeaveCriticalSection(&g_cs);
if (S_OK != SetFontUnicodeRanges())
return E_OUTOFMEMORY;
SaveFontDataFile();
}
// All tables created successfully
return S_OK;
}
#ifdef UNIX
typedef struct tagTable_info{
int count;
int table_size;
} Table_info;
int UnixGetAllFontsProc(ENUMLOGFONTEX* plfFont, NEWTEXTMETRICEX* lpntm, int iFontType, LPARAM lParam)
{
LOGFONT *lplf;
int *pcount = &((Table_info*)lParam)->count;
int *ptable_size = &((Table_info*)lParam)->table_size;
lplf = &(plfFont->elfLogFont);
// We don't use non TrueType fonts
if (iFontType == DEVICE_FONTTYPE || iFontType == RASTER_FONTTYPE)
return 1; // keep going but don't use this font
// We don't use the SYMBOL, Mac Charset fonts
if(lplf->lfCharSet == SYMBOL_CHARSET || lplf->lfCharSet == MAC_CHARSET)
return 1;
// We don't handle vertical fonts
if (TEXT('@') == lplf->lfFaceName[0])
return 1;
// Now update the font-table
// Does UNIX use TTF? // if (FontType == TRUETYPE_FONTTYPE)
{
CopyMemory(&g_pfont_table[*pcount].lf, lplf, sizeof(LOGFONT));
MLStrCpyN(g_pfont_table[*pcount].szFaceName, lplf->lfFaceName, LF_FACESIZE);
(*pcount)++;
}
if (*pcount >= *ptable_size)
{
FONTINFO * pfont_table = NULL;
*ptable_size += FONT_TABLE_INIT_SIZE;
pfont_table = (FONTINFO *) LocalReAlloc(g_pfont_table,
sizeof(FONTINFO) * *ptable_size,
LMEM_MOVEABLE | LMEM_ZEROINIT);
if (NULL == pfont_table)
{
return 0; // Stop enum.
}
else
{
g_pfont_table = pfont_table;
}
}
return 1; // Keep enum.
}
#endif
BOOL CMLFLink2::CFontMappingCache2::SetFontTable(void)
{
BOOL bRet = TRUE;
TCHAR szFaceName[MAX_PATH];
DWORD dwValue;
TCHAR szFontFile[MAX_FONT_FILE_NAME];
DWORD dwData;
DWORD dwType = REG_SZ;
DWORD dwFonts;
int i, table_size = FONT_TABLE_INIT_SIZE;
LPTSTR pNewFaceName = NULL;
HKEY hkey = NULL;
static int count;
HDC hDC = NULL;
HWND hWnd = NULL;
FONTINFO * pFontTable;
count = 1;
if (!g_pfont_table)
{
g_pfont_table = (FONTINFO *)LocalAlloc(LPTR, sizeof(FONTINFO) * FONT_TABLE_INIT_SIZE);
if (!g_pfont_table)
{
bRet = FALSE;
goto SETFONT_DONE;
}
}
else
{
// weiwu: Need to clean up this code
goto SETFONT_DONE;
}
#ifndef UNIX
if (S_OK != GetRegFontKey(&hkey, &dwFonts))
{
bRet = FALSE;
goto SETFONT_DONE;
}
hWnd = GetTopWindow(GetDesktopWindow());
hDC = GetDC(hWnd);
for (i=0; ;i++)
{
dwValue = sizeof(szFaceName);
dwData = sizeof(szFontFile);
if (ERROR_NO_MORE_ITEMS == RegEnumValue(
hkey,
i,
szFaceName,
&dwValue,
NULL,
&dwType,
(LPBYTE)szFontFile,
&dwData ))
{
break;
}
DWORD dwOffset = 0;
FIND_NEXT_FACENAME:
pNewFaceName = MLStrStr(&szFaceName[dwOffset], TEXT(" & "));
if (pNewFaceName)
{
*pNewFaceName = 0;
// Skip " & ", look for next font face name
pNewFaceName+=3;
}
else
{
pNewFaceName = MLStrStr(&szFaceName[dwOffset], TEXT("(TrueType)"));
if(pNewFaceName)
{
// Ignor the space between face name and "(TrueTye)" signature
if ((pNewFaceName > szFaceName) && (*(pNewFaceName-1) == 0x20))
pNewFaceName--;
*pNewFaceName = 0;
}
}
if (pNewFaceName && !EnumFontFamilies(hDC, &szFaceName[dwOffset], MapFontExEnumFontProc, (LPARAM)&count)) //TrueType font
{
int nSize;
LPTSTR pFontFile;
if (count >= table_size)
{
FONTINFO * _pfont_table = NULL;
table_size += FONT_TABLE_INIT_SIZE;
_pfont_table = (FONTINFO *) LocalReAlloc(g_pfont_table, sizeof(FONTINFO) * table_size,
LMEM_MOVEABLE | LMEM_ZEROINIT);
if (NULL == _pfont_table)
{
bRet = FALSE;
RegCloseKey(hkey);
goto SETFONT_DONE;
}
else
{
g_pfont_table = _pfont_table;
}
}
nSize = lstrlen(szFontFile);
if (!MLStrCmpNI(&szFontFile[nSize-3], "fot", 3))
_tcsncpy(&szFontFile[nSize-3], "ttf", 3);
//
// Trim off path
//
// #335900, some third party apps write font file names to registry directly
// and the names they used could have redundant font path
//
pFontFile = szFontFile;
while (nSize)
{
// Font file name contains only ASCII characters,
// So, we can safely trim the path by backward searching '\'
if (szFontFile[nSize] == TEXT('\\'))
{
pFontFile = &szFontFile[nSize];
pFontFile++;
break;
}
nSize--;
}
GetFontURangeBits(szFontFile, &(g_pfont_table[count-1].dwUniSubRanges[0]));
MLStrCpyN(g_pfont_table[count-1].szFaceName, &szFaceName[dwOffset], LF_FACESIZE);
MLStrCpyN(g_pfont_table[count-1].szFileName, pFontFile, LF_FACESIZE);
}
if (pNewFaceName && (*pNewFaceName))
{
dwOffset = (DWORD)(pNewFaceName - &szFaceName[0]);
goto FIND_NEXT_FACENAME;
}
}
#else
// For UNIX, we don't have registry font information,
// Let's create font table through EnumFontFamiliesEx.
Table_info table_info;
table_info.count = 1;
table_info.table_size = table_size;
int iRet;
LOGFONT lf;
lf.lfCharSet = DEFAULT_CHARSET; // give me all fonts
lf.lfFaceName[0] = _T('\0');
lf.lfPitchAndFamily = 0;
hWnd = GetTopWindow(GetDesktopWindow());
hDC = GetDC(hWnd);
iRet = EnumFontFamiliesEx(hDC, // Enum all fonts
&lf,
(FONTENUMPROC)UnixGetAllFontsProc,
(LPARAM)&table_info,
0);
count = table_info.count;
if (iRet == 0) // abort
{
bRet = FALSE;
goto SETFONT_DONE;
}
#endif // UNIX
// Release un-used memory
pFontTable = (FONTINFO *)LocalReAlloc(g_pfont_table, (count)*sizeof(FONTINFO), LMEM_MOVEABLE);
if (pFontTable)
{
g_pfont_table = pFontTable;
}
// Save TrueType font number
g_pfont_table[0].dwCodePages[0] = count-1;
#ifndef UNIX
// Unix doesn't have this number.
// Save total font number for font change verification
g_pfont_table[0].dwCodePages[1] = dwFonts;
RegCloseKey(hkey);
#endif
if (count > 1)
SetFontScripts();
SETFONT_DONE:
if (hDC)
ReleaseDC(hWnd, hDC);
if (count <= 1)
{
if (g_pfont_table)
{
LocalFree(g_pfont_table);
g_pfont_table = NULL;
}
bRet = FALSE;
}
return bRet;
}
HRESULT CMLFLink2::CFontMappingCache2::SaveFontDataFile(void)
{
FONTDATAHEADER fileHeader;
HRESULT hr = E_FAIL;
int *pTmpBuf = NULL;
HANDLE hFile = NULL;
int i, j, Count = 0;
DWORD dwSize;
FONTDATATABLE fontInfoTable, fontIndexTable;
hFile = CreateFile( szFontDataFilePath,
GENERIC_WRITE,
0,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_HIDDEN,
NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
goto SAVE_FONT_DATA_DONE;
}
for (i = 0; i < ARRAYSIZE(g_urange_table); i++)
{
Count += (g_urange_table[i].nFonts+1);
}
// Create file header
lstrcpynA(fileHeader.FileSig, FONT_DATA_SIGNATURE, sizeof(fileHeader.FileSig));
fileHeader.dwVersion = 0x00010000;
// Use file size as CheckSum
fileHeader.dwCheckSum = sizeof(FONTINFO)*(g_pfont_table[0].dwCodePages[0]+1)+Count*sizeof(int)+
+ sizeof(FONTDATAHEADER) + sizeof(FONTDATATABLE)*FONTDATATABLENUM;
fileHeader.nTable = FONTDATATABLENUM;
pTmpBuf = (int *)LocalAlloc(LPTR, Count*sizeof(int));
if (!pTmpBuf)
goto SAVE_FONT_DATA_DONE;
// Get font index data
for (i = 0; i < ARRAYSIZE(g_urange_table); i++)
{
*pTmpBuf++ = g_urange_table[i].nFonts;
if (g_urange_table[i].nFonts)
{
for (j = 0; j< g_urange_table[i].nFonts; j++)
{
*pTmpBuf++ = *(g_urange_table[i].pFontIndex+j);
}
}
}
pTmpBuf -= Count;
// Create Dir tables
lstrcpynA(fontInfoTable.szName, "fnt", sizeof(fontInfoTable.szName));
fontInfoTable.dwOffset = sizeof(FONTDATAHEADER) + sizeof(FONTDATATABLE)*FONTDATATABLENUM;
fontInfoTable.dwSize = sizeof(FONTINFO)*(g_pfont_table[0].dwCodePages[0]+1);
lstrcpynA(fontIndexTable.szName, "idx", sizeof(fontIndexTable.szName));
fontIndexTable.dwOffset = fontInfoTable.dwSize+fontInfoTable.dwOffset;
fontIndexTable.dwSize = Count*sizeof(int);
if (WriteFile(hFile, &fileHeader, sizeof(FONTDATAHEADER), &dwSize, NULL) &&
WriteFile(hFile, &fontInfoTable, sizeof(FONTDATATABLE), &dwSize, NULL) &&
WriteFile(hFile, &fontIndexTable, sizeof(FONTDATATABLE), &dwSize, NULL) &&
WriteFile(hFile, g_pfont_table, fontInfoTable.dwSize, &dwSize, NULL) &&
WriteFile(hFile, pTmpBuf, fontIndexTable.dwSize, &dwSize, NULL))
{
hr = S_OK;
}
SAVE_FONT_DATA_DONE:
if (hFile)
CloseHandle(hFile);
if (pTmpBuf)
LocalFree(pTmpBuf);
return hr;
}
HRESULT CMLFLink2::CFontMappingCache2::LoadFontDataFile(void)
{
HANDLE hFontData = NULL;
HANDLE hFileMap = NULL;
LPVOID lpvFile = NULL;
int * lp;
HRESULT hr = E_FAIL;
DWORD dwFileSize;
int i, j;
HKEY hKey = NULL;
DWORD nFonts;
FONTDATAHEADER *pHeader;
FONTDATATABLE *pfTable;
hFontData = CreateFile(szFontDataFilePath,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hFontData == INVALID_HANDLE_VALUE)
return EnsureFontTable(TRUE);
dwFileSize = GetFileSize(hFontData, NULL);
hFileMap = CreateFileMapping(
hFontData,
NULL,
PAGE_READONLY,
0,
dwFileSize,
NULL
);
if(hFileMap == NULL)
{
goto Load_File_Done;
}
lpvFile = MapViewOfFile(
hFileMap,
FILE_MAP_READ,
0,
0,
0
);
if (lpvFile == NULL)
{
goto Load_File_Done;
}
pHeader = (FONTDATAHEADER *)lpvFile;
// Check mlang font cache file by signature and checksum
if (lstrcmpA(pHeader->FileSig, FONT_DATA_SIGNATURE) || pHeader->dwCheckSum != dwFileSize)
{
goto Load_File_Done;
}
if (S_OK != GetRegFontKey(&hKey, &nFonts))
{
goto Load_File_Done;
}
pfTable = (FONTDATATABLE *) ((LPBYTE)lpvFile + sizeof(FONTDATAHEADER));
// Check if there is any font change (no guarantee, but works in most cases)
if (nFonts != ((FONTINFO*)((LPBYTE)lpvFile + pfTable[0].dwOffset))->dwCodePages[1])
{
// If there is a change in system font number, we reload everything
UnmapViewOfFile(lpvFile);
CloseHandle(hFileMap);
CloseHandle(hFontData);
RegCloseKey(hKey);
return EnsureFontTable(TRUE);
}
EnterCriticalSection(&g_cs);
// Reset cache information
if (g_pfont_table)
{
LocalFree(g_pfont_table);
g_pfont_table = NULL;
for (i = 0; i < ARRAYSIZE(g_urange_table); i++)
{
if (g_urange_table[i].nFonts)
{
LocalFree(g_urange_table[i].pFontIndex);
g_urange_table[i].pFontIndex = NULL;
g_urange_table[i].nFonts = 0;
}
}
}
if(!(g_pfont_table = (FONTINFO *) (LocalAlloc(LPTR, pfTable[0].dwSize))))
{
LeaveCriticalSection(&g_cs);
hr = E_OUTOFMEMORY;
goto Load_File_Done;
}
CopyMemory(g_pfont_table, (LPBYTE)lpvFile + pfTable[0].dwOffset, pfTable[0].dwSize);
lp = (int *)((LPBYTE)lpvFile + pfTable[1].dwOffset);
for (i = 0; i < ARRAYSIZE(g_urange_table); i++)
{
if (g_urange_table[i].nFonts = *lp++)
{
//g_urange_table[i].nFonts = *lp++;
g_urange_table[i].pFontIndex = (int *)LocalAlloc(LPTR, sizeof(int)*g_urange_table[i].nFonts);
for (j = 0; j< g_urange_table[i].nFonts; j++)
{
g_urange_table[i].pFontIndex[j] = *lp++;
}
}
}
LeaveCriticalSection(&g_cs);
hr = S_OK;
Load_File_Done:
if (lpvFile)
UnmapViewOfFile(lpvFile);
if (hFileMap)
CloseHandle(hFileMap);
if (hFontData)
CloseHandle(hFontData);
if (hKey)
RegCloseKey(hKey);
return hr;
}
HRESULT CMLFLink2::CFontMappingCache2::SetFontUnicodeRanges(void)
{
TCHAR szFontPath[MAX_PATH];
TCHAR szFont[MAX_PATH];
HRESULT hr = S_OK;
int i;
int *pInt;
EnterCriticalSection(&g_cs);
g_pfont_table[0].szFaceName[0] = 1;
LeaveCriticalSection(&g_cs);
MLGetWindowsDirectory(szFontPath, MAX_PATH);
MLPathCombine(szFontPath, ARRAYSIZE(szFontPath), szFontPath, FONT_FOLDER);
for (i=1; i<= (int)g_pfont_table[0].dwCodePages[0]; i++)
{
MLPathCombine(szFont, ARRAYSIZE(szFont), szFontPath, g_pfont_table[i].szFileName);
GetNonCpFontUnicodeRanges(szFont, i);
}
// Release un-used memory
for (i=0; i< ARRAYSIZE(g_urange_table); i++)
{
if (g_urange_table[i].nFonts)
{
pInt = (int *)LocalReAlloc(g_urange_table[i].pFontIndex, g_urange_table[i].nFonts*sizeof(int), LMEM_MOVEABLE);
if (pInt)
{
g_urange_table[i].pFontIndex = pInt;
}
}
}
return hr;
}
STDMETHODIMP CMLFLink2::GetStrCodePages(const WCHAR* pszSrc, long cchSrc, DWORD dwPriorityCodePages, DWORD* pdwCodePages, long* pcchCodePages)
{
ASSERT_THIS;
ASSERT_READ_BLOCK(pszSrc, cchSrc);
ASSERT_WRITE_PTR_OR_NULL(pdwCodePages);
ASSERT_WRITE_PTR_OR_NULL(pcchCodePages);
HRESULT hr = S_OK;
long cchCodePages = 0;
DWORD dwStrCodePages = (DWORD)~0;
BOOL fInit = FALSE;
BOOL fNoPri = FALSE;
if (!pszSrc || cchSrc <= 0) // We can't make dwStrCodePages when cchSrc is zero
hr = E_INVALIDARG;
if (!m_pIMLFLnk)
return E_OUTOFMEMORY;
while (SUCCEEDED(hr) && cchSrc > 0)
{
DWORD dwCharCodePages;
if (SUCCEEDED(hr = m_pIMLFLnk->GetCharCodePages(*pszSrc, &dwCharCodePages)))
{
if (!fInit)
{
fInit = TRUE;
fNoPri = !(dwPriorityCodePages & dwCharCodePages);
}
else if (fNoPri != !(dwPriorityCodePages & dwCharCodePages))
{
break;
}
if (!fNoPri)
dwPriorityCodePages &= dwCharCodePages;
if (dwCharCodePages && (dwCharCodePages & dwStrCodePages))
dwStrCodePages &= dwCharCodePages;
else
break;
pszSrc++;
cchSrc--;
cchCodePages++;
}
}
if (SUCCEEDED(hr))
{
if (!cchCodePages)
{
dwStrCodePages = 0;
cchCodePages++;
}
if (pcchCodePages)
*pcchCodePages = cchCodePages;
if (pdwCodePages)
*pdwCodePages = dwStrCodePages;
}
else
{
if (pcchCodePages)
*pcchCodePages = 0;
if (pdwCodePages)
*pdwCodePages = 0;
}
return hr;
}
STDMETHODIMP CMLFLink2::MapFont(HDC hDC, DWORD dwCodePages, WCHAR wchar, HFONT* phDestFont)
{
HFONT hSrcFont = NULL;
if (NULL == (hSrcFont = (HFONT) GetCurrentObject(hDC, OBJ_FONT)))
return E_FAIL;
if (dwCodePages)
{
if (m_pIMLFLnk)
return m_pIMLFLnk->MapFont(hDC, dwCodePages, hSrcFont, phDestFont);
return E_OUTOFMEMORY;
}
else
{
if (!m_pFontMappingCache2)
m_pFontMappingCache2 = new CFontMappingCache2;
if (m_pFontMappingCache2)
return m_pFontMappingCache2->MapFontFromCMAP(hDC, wchar, hSrcFont, phDestFont);
else
return E_OUTOFMEMORY;
}
}
STDMETHODIMP CMLFLink2::GetFontUnicodeRanges(HDC hDC, UINT *puiRanges, UNICODERANGE* pURanges)
{
int i;
LOGFONT lf;
HRESULT hr = E_FAIL;
HFONT hFont = NULL;
if (!puiRanges)
return E_INVALIDARG;
if (!m_pFontMappingCache2)
m_pFontMappingCache2 = new CFontMappingCache2;
if (!m_pFontMappingCache2)
return E_OUTOFMEMORY;
if (!(hFont = (HFONT)GetCurrentObject(hDC, OBJ_FONT)))
return hr;
if (FAILED(m_pFontMappingCache2->EnsureFontTable(FALSE)))
return hr;
if (!GetObject(hFont, sizeof(LOGFONT), &lf))
return hr;
for (i=1; i<= (int) g_pfont_table[0].dwCodePages[0]; i++)
{
if (!lstrcmp(lf.lfFaceName, g_pfont_table[i].szFaceName))
break;
}
if (i > (int) g_pfont_table[0].dwCodePages[0])
return hr;
return m_pFontMappingCache2->UnicodeRanges(g_pfont_table[i].szFileName, puiRanges, pURanges);
}
STDMETHODIMP CMLFLink2::GetScriptFontInfo(SCRIPT_ID sid, DWORD dwFlags, UINT *puiFonts, SCRIPTFONTINFO* pScriptFont)
{
HRESULT hr = E_FAIL;
UINT uiNum;
BYTE bPitch = dwFlags & SCRIPTCONTF_FIXED_FONT? FIXED_PITCH:VARIABLE_PITCH;
if (!m_pFontMappingCache2)
m_pFontMappingCache2 = new CFontMappingCache2;
if (m_pFontMappingCache2)
m_pFontMappingCache2->EnsureFontTable(FALSE);
if (!g_pfont_table)
return hr;
if (!pScriptFont)
{
uiNum = g_pfont_table[0].dwCodePages[0];
}
else
{
uiNum = *puiFonts;
}
*puiFonts = 0;
// Binary search font table to match script id.
for (UINT i=1; i<= g_pfont_table[0].dwCodePages[0]; i++)
{
// Check font pitch
if (!(g_pfont_table[i].lf.lfPitchAndFamily & bPitch))
continue;
// Get sid bit mask
SCRIPT_IDS sids = 1;
sids <<= sid;
if (sids & g_pfont_table[i].scripts)
{
// Bail out is required number reached
if (*puiFonts >= uiNum)
{
break;
}
if (pScriptFont)
{
MultiByteToWideChar(CP_ACP, 0, g_pfont_table[i].szFaceName, -1, (pScriptFont + *puiFonts)->wszFont, MAX_MIMEFACE_NAME);
(pScriptFont + *puiFonts)->scripts = g_pfont_table[i].scripts;
}
(*puiFonts)++;
}
}
return S_OK;
}
// Map Windows code page to script id
// if multiple script id exist, we'll return the default one
STDMETHODIMP CMLFLink2::CodePageToScriptID(UINT uiCodePage, SCRIPT_ID *pSid)
{
MIMECPINFO cpInfo;
HRESULT hr = E_FAIL;
if (!pSid)
return E_INVALIDARG;
if (NULL != g_pMimeDatabase)
{
if (SUCCEEDED(g_pMimeDatabase->GetCodePageInfo(uiCodePage, 0x409, &cpInfo)))
{
if (cpInfo.uiFamilyCodePage == CP_USER_DEFINED)
{
*pSid = sidUserDefined;
hr = S_OK;
}
else
for (int i = 0; g_CharSetTransTable[i].uCodePage; i++)
{
if (cpInfo.uiFamilyCodePage == g_CharSetTransTable[i].uCodePage)
{
*pSid = g_CharSetTransTable[i].sid[0];
hr = S_OK;
break;
}
}
}
}
return hr;
}
CMLFLink2::CFontMappingCache2::CFontMappingCache2(void)
{
if (GetSystemDirectory(szFontDataFilePath, MAX_PATH))
{
MLPathCombine(szFontDataFilePath, ARRAYSIZE(szFontDataFilePath), szFontDataFilePath, FONT_DATA_FILE_NAME);
}
}
CMLFLink2::CFontMappingCache2::~CFontMappingCache2(void)
{
EnterCriticalSection(&g_cs);
if (g_pfont_table)
{
LocalFree(g_pfont_table);
g_pfont_table = NULL;
}
for (int i=0; i< ARRAYSIZE(g_urange_table); i++)
{
if (g_urange_table[i].nFonts)
{
LocalFree(g_urange_table[i].pFontIndex);
g_urange_table[i].nFonts = 0;
}
}
LeaveCriticalSection(&g_cs);
}
int CALLBACK CMLFLink2::CFontMappingCache2::MapFontExEnumFontProc(const LOGFONT* plfFont, const TEXTMETRIC*, DWORD FontType, LPARAM lParam)
{
if (FontType == TRUETYPE_FONTTYPE && plfFont->lfFaceName[0] != TEXT('@') )
{
CopyMemory(&g_pfont_table[*(int *)lParam].lf, plfFont, sizeof(LOGFONT));
(*(int *)lParam)++;
return 0;
}
return 1;
}
int CALLBACK CMLFLink2::CFontMappingCache2::SetFontScriptsEnumFontProc(const LOGFONT* plfFont, const TEXTMETRIC*, DWORD FontType, LPARAM lParam)
{
if (FontType == TRUETYPE_FONTTYPE)
{
if (g_pfont_table)
{
for (int i=1; i<= (int)g_pfont_table[0].dwCodePages[0]; i++)
if (!MLStrCmpNI(plfFont->lfFaceName, g_pfont_table[i].szFaceName, LF_FACESIZE))
{
SCRIPT_IDS scripts = 1;
scripts <<= lParam;
g_pfont_table[i].scripts |= scripts;
break;
}
if (i > (int)g_pfont_table[0].dwCodePages[0] && plfFont->lfFaceName[0] != TEXT('@')) // GDI font not in current font table?
{
FONTINFO * pfont_table = NULL;
pfont_table = (FONTINFO *) LocalReAlloc(g_pfont_table,
sizeof(FONTINFO) * (g_pfont_table[0].dwCodePages[0]+2),
LMEM_MOVEABLE | LMEM_ZEROINIT);
if (NULL != pfont_table)
{
g_pfont_table = pfont_table;
g_pfont_table[0].dwCodePages[0]++;
MLStrCpyN(g_pfont_table[i].szFaceName, (char *)plfFont->lfFaceName, ARRAYSIZE(g_pfont_table[i].szFaceName));
CopyMemory(&g_pfont_table[i].lf, plfFont, sizeof(LOGFONT));
SCRIPT_IDS scripts = 1;
scripts <<= lParam;
g_pfont_table[i].scripts |= scripts;
}
}
}
}
return 1;
}
int CALLBACK CMLFLink::VerifyFontSizeEnumFontProc(const LOGFONT* plfFont, const TEXTMETRIC* ptm, DWORD FontType, LPARAM lParam)
{
LOGFONT* plfSrcFont = (LOGFONT*)lParam;
if (FontType != TRUETYPE_FONTTYPE)
{
LONG lHeight = ptm->tmInternalLeading - ptm->tmHeight;
// Match source font's lfHeight to physical bitmap font's lfHeight
if (lHeight < 0 && plfSrcFont->lfHeight < 0 && lHeight < plfSrcFont->lfHeight)
{
plfSrcFont->lfHeight = lHeight ;
}
}
return 0;
}