Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
mlflink.cpp
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 106k
Category:

Windows Kernel

Development Platform:

Visual C++

mlflink.cpp：Code Content
  1. // MLFLink.cpp : Implementation of CMLFLink
  2. #include "private.h"
  3. #include "mlmain.h"
  4. #include "codepage.h"
  6. #ifdef UNIX
  7. inline WORD READWINTELWORD(WORD w)
  8. {
  9.   return ( w << 8 | w >> 8 );
  10. }
  12. inline DWORD READWINTELDWORD(DWORD dw)
  13. {
  14.   return READWINTELWORD( (WORD)(dw >> 16 )) | ((DWORD)READWINTELWORD( dw & 0xffff)) << 16;
  15. }
  16. #else
  17. #define READWINTELWORD
  18. #define READWINTELDWORD
  19. #endif
  21. IMLangFontLink *g_pMLFLink = NULL;
  23. CMLFLink::CCodePagesCache* CMLFLink::m_pCodePagesCache = NULL;
  24. CMLFLink::CFontMappingCache* CMLFLink::m_pFontMappingCache = NULL;
  25. CMLFLink2::CFontMappingCache2* CMLFLink2::m_pFontMappingCache2 = NULL;
  27. // Strings to identify regular font
  28. const char szRegular[]    = "Regular";
  29. const char szNormal[]     = "Normal";
  31. // font table
  32. FONTINFO *g_pfont_table = NULL;
  34. // Unicode range table for non Windows code page code points
  35. // Data is provided by NT international group.
  36. URANGEFONT g_urange_table[] = {
  37. {0x0108, 0x010B, 0},
  38. {0x0114, 0x0115, 0},
  39. {0x011C, 0x011D, 0},
  40. {0x0120, 0x0121, 0},
  41. {0x0124, 0x0125, 0},
  42. {0x0128, 0x0129, 0},
  43. {0x012C, 0x012D, 0},
  44. {0x0134, 0x0135, 0},
  45. {0x014E, 0x014F, 0},
  46. {0x015C, 0x015D, 0},
  47. {0x0168, 0x0169, 0},
  48. {0x016C, 0x016D, 0},
  49. {0x0174, 0x0177, 0},
  50. {0x017F, 0x0191, 0},
  51. {0x0193, 0x019F, 0},
  52. {0x01A2, 0x01AE, 0},
  53. {0x01B1, 0x01CD, 0},
  54. {0x01CF, 0x01CF, 0},
  55. {0x01D1, 0x01D1, 0},
  56. {0x01D3, 0x01D3, 0},
  57. {0x01D5, 0x01D5, 0},
  58. {0x01D7, 0x01D7, 0},
  59. {0x01D9, 0x01D9, 0},
  60. {0x01DB, 0x01DB, 0},
  61. {0x01DD, 0x01F5, 0},
  62. {0x01FA, 0x0217, 0},
  63. {0x0250, 0x0250, 0},
  64. {0x0252, 0x0260, 0},
  65. {0x0262, 0x02A8, 0},
  66. {0x02B0, 0x02C5, 0},
  67. {0x02C8, 0x02C8, 0},
  68. {0x02CC, 0x02CC, 0},
  69. {0x02CE, 0x02CF, 0},
  70. {0x02D1, 0x02D7, 0},
  71. {0x02DE, 0x02DE, 0},
  72. {0x02E0, 0x02E9, 0},
  73. {0x0302, 0x0302, 0},
  74. {0x0304, 0x0308, 0},
  75. {0x030A, 0x0322, 0},
  76. {0x0324, 0x0345, 0},
  77. {0x0360, 0x0361, 0},
  78. {0x0374, 0x0375, 0},
  79. {0x037A, 0x037A, 0},
  80. {0x037E, 0x037E, 0},
  81. {0x0387, 0x0387, 0},
  82. {0x03D0, 0x03D6, 0},
  83. {0x03DA, 0x03DA, 0},
  84. {0x03DC, 0x03DC, 0},
  85. {0x03DE, 0x03DE, 0},
  86. {0x03E0, 0x03E0, 0},
  87. {0x03E2, 0x03F3, 0},
  88. {0x0460, 0x0486, 0},
  89. {0x0492, 0x04C4, 0},
  90. {0x04C7, 0x04C8, 0},
  91. {0x04CB, 0x04CC, 0},
  92. {0x04D0, 0x04EB, 0},
  93. {0x04EE, 0x04F5, 0},
  94. {0x04F8, 0x04F9, 0},
  95. {0x0531, 0x0556, 0},
  96. {0x0559, 0x055F, 0},
  97. {0x0561, 0x0587, 0},
  98. {0x0589, 0x0589, 0},
  99. {0x0591, 0x05A1, 0},
  100. {0x05A3, 0x05AF, 0},
  101. {0x05C4, 0x05C4, 0},
  102. {0x0660, 0x066D, 0},
  103. {0x0670, 0x067D, 0},
  104. {0x067F, 0x0685, 0},
  105. {0x0687, 0x0697, 0},
  106. {0x0699, 0x06AE, 0},
  107. {0x06B0, 0x06B7, 0},
  108. {0x06BA, 0x06BE, 0},
  109. {0x06C0, 0x06CE, 0},
  110. {0x06D0, 0x06ED, 0},
  111. {0x06F0, 0x06F9, 0},
  112. {0x0901, 0x0903, 0},
  113. {0x0905, 0x0939, 0},
  114. {0x093C, 0x094D, 0},
  115. {0x0950, 0x0954, 0},
  116. {0x0958, 0x0970, 0},
  117. {0x0981, 0x0983, 0},
  118. {0x0985, 0x098C, 0},
  119. {0x098F, 0x0990, 0},
  120. {0x0993, 0x09A8, 0},
  121. {0x09AA, 0x09B0, 0},
  122. {0x09B2, 0x09B2, 0},
  123. {0x09B6, 0x09B9, 0},
  124. {0x09BC, 0x09BC, 0},
  125. {0x09BE, 0x09C4, 0},
  126. {0x09C7, 0x09C8, 0},
  127. {0x09CB, 0x09CD, 0},
  128. {0x09D7, 0x09D7, 0},
  129. {0x09DC, 0x09DD, 0},
  130. {0x09DF, 0x09E3, 0},
  131. {0x09E6, 0x09FA, 0},
  132. {0x0A02, 0x0A02, 0},
  133. {0x0A05, 0x0A0A, 0},
  134. {0x0A0F, 0x0A10, 0},
  135. {0x0A13, 0x0A28, 0},
  136. {0x0A2A, 0x0A30, 0},
  137. {0x0A32, 0x0A33, 0},
  138. {0x0A35, 0x0A36, 0},
  139. {0x0A38, 0x0A39, 0},
  140. {0x0A3C, 0x0A3C, 0},
  141. {0x0A3E, 0x0A42, 0},
  142. {0x0A47, 0x0A48, 0},
  143. {0x0A4B, 0x0A4D, 0},
  144. {0x0A59, 0x0A5C, 0},
  145. {0x0A5E, 0x0A5E, 0},
  146. {0x0A66, 0x0A74, 0},
  147. {0x0A81, 0x0A83, 0},
  148. {0x0A85, 0x0A8B, 0},
  149. {0x0A8D, 0x0A8D, 0},
  150. {0x0A8F, 0x0A91, 0},
  151. {0x0A93, 0x0AA8, 0},
  152. {0x0AAA, 0x0AB0, 0},
  153. {0x0AB2, 0x0AB3, 0},
  154. {0x0AB5, 0x0AB9, 0},
  155. {0x0ABC, 0x0AC5, 0},
  156. {0x0AC7, 0x0AC9, 0},
  157. {0x0ACB, 0x0ACD, 0},
  158. {0x0AD0, 0x0AD0, 0},
  159. {0x0AE0, 0x0AE0, 0},
  160. {0x0AE6, 0x0AEF, 0},
  161. {0x0B01, 0x0B03, 0},
  162. {0x0B05, 0x0B0C, 0},
  163. {0x0B0F, 0x0B10, 0},
  164. {0x0B13, 0x0B28, 0},
  165. {0x0B2A, 0x0B30, 0},
  166. {0x0B32, 0x0B33, 0},
  167. {0x0B36, 0x0B39, 0},
  168. {0x0B3C, 0x0B43, 0},
  169. {0x0B47, 0x0B48, 0},
  170. {0x0B4B, 0x0B4D, 0},
  171. {0x0B56, 0x0B57, 0},
  172. {0x0B5C, 0x0B5D, 0},
  173. {0x0B5F, 0x0B61, 0},
  174. {0x0B66, 0x0B70, 0},
  175. {0x0B82, 0x0B83, 0},
  176. {0x0B85, 0x0B8A, 0},
  177. {0x0B8E, 0x0B90, 0},
  178. {0x0B92, 0x0B95, 0},
  179. {0x0B99, 0x0B9A, 0},
  180. {0x0B9C, 0x0B9C, 0},
  181. {0x0B9E, 0x0B9F, 0},
  182. {0x0BA3, 0x0BA4, 0},
  183. {0x0BA8, 0x0BAA, 0},
  184. {0x0BAE, 0x0BB5, 0},
  185. {0x0BB7, 0x0BB9, 0},
  186. {0x0BBE, 0x0BC2, 0},
  187. {0x0BC6, 0x0BC8, 0},
  188. {0x0BCA, 0x0BCD, 0},
  189. {0x0BD7, 0x0BD7, 0},
  190. {0x0BE7, 0x0BF2, 0},
  191. {0x0C01, 0x0C03, 0},
  192. {0x0C05, 0x0C0C, 0},
  193. {0x0C0E, 0x0C10, 0},
  194. {0x0C12, 0x0C28, 0},
  195. {0x0C2A, 0x0C33, 0},
  196. {0x0C35, 0x0C39, 0},
  197. {0x0C3E, 0x0C44, 0},
  198. {0x0C46, 0x0C48, 0},
  199. {0x0C4A, 0x0C4D, 0},
  200. {0x0C55, 0x0C56, 0},
  201. {0x0C60, 0x0C61, 0},
  202. {0x0C66, 0x0C6F, 0},
  203. {0x0C82, 0x0C83, 0},
  204. {0x0C85, 0x0C8C, 0},
  205. {0x0C8E, 0x0C90, 0},
  206. {0x0C92, 0x0CA8, 0},
  207. {0x0CAA, 0x0CB3, 0},
  208. {0x0CB5, 0x0CB9, 0},
  209. {0x0CBE, 0x0CC4, 0},
  210. {0x0CC6, 0x0CC8, 0},
  211. {0x0CCA, 0x0CCD, 0},
  212. {0x0CD5, 0x0CD6, 0},
  213. {0x0CDE, 0x0CDE, 0},
  214. {0x0CE0, 0x0CE1, 0},
  215. {0x0CE6, 0x0CEF, 0},
  216. {0x0D02, 0x0D03, 0},
  217. {0x0D05, 0x0D0C, 0},
  218. {0x0D0E, 0x0D10, 0},
  219. {0x0D12, 0x0D28, 0},
  220. {0x0D2A, 0x0D39, 0},
  221. {0x0D3E, 0x0D43, 0},
  222. {0x0D46, 0x0D48, 0},
  223. {0x0D4A, 0x0D4D, 0},
  224. {0x0D57, 0x0D57, 0},
  225. {0x0D60, 0x0D61, 0},
  226. {0x0D66, 0x0D6F, 0},
  227. {0x0E81, 0x0E82, 0},
  228. {0x0E84, 0x0E84, 0},
  229. {0x0E87, 0x0E88, 0},
  230. {0x0E8A, 0x0E8A, 0},
  231. {0x0E8D, 0x0E8D, 0},
  232. {0x0E94, 0x0E97, 0},
  233. {0x0E99, 0x0E9F, 0},
  234. {0x0EA1, 0x0EA3, 0},
  235. {0x0EA5, 0x0EA5, 0},
  236. {0x0EA7, 0x0EA7, 0},
  237. {0x0EAA, 0x0EAB, 0},
  238. {0x0EAD, 0x0EB9, 0},
  239. {0x0EBB, 0x0EBD, 0},
  240. {0x0EC0, 0x0EC4, 0},
  241. {0x0EC6, 0x0EC6, 0},
  242. {0x0EC8, 0x0ECD, 0},
  243. {0x0ED0, 0x0ED9, 0},
  244. {0x0EDC, 0x0EDD, 0},
  245. {0x0F00, 0x0F47, 0},
  246. {0x0F49, 0x0F69, 0},
  247. {0x0F71, 0x0F8B, 0},
  248. {0x0F90, 0x0F95, 0},
  249. {0x0F97, 0x0F97, 0},
  250. {0x0F99, 0x0FAD, 0},
  251. {0x0FB1, 0x0FB7, 0},
  252. {0x0FB9, 0x0FB9, 0},
  253. {0x10A0, 0x10C5, 0},
  254. {0x10D0, 0x10F6, 0},
  255. {0x10FB, 0x10FB, 0},
  256. {0x1100, 0x1159, 0},
  257. {0x115F, 0x11A2, 0},
  258. {0x11A8, 0x11F9, 0},
  259. {0x1E00, 0x1E9B, 0},
  260. {0x1EA0, 0x1EF9, 0},
  261. {0x1F00, 0x1F15, 0},
  262. {0x1F18, 0x1F1D, 0},
  263. {0x1F20, 0x1F45, 0},
  264. {0x1F48, 0x1F4D, 0},
  265. {0x1F50, 0x1F57, 0},
  266. {0x1F59, 0x1F59, 0},
  267. {0x1F5B, 0x1F5B, 0},
  268. {0x1F5D, 0x1F5D, 0},
  269. {0x1F5F, 0x1F7D, 0},
  270. {0x1F80, 0x1FB4, 0},
  271. {0x1FB6, 0x1FC4, 0},
  272. {0x1FC6, 0x1FD3, 0},
  273. {0x1FD6, 0x1FDB, 0},
  274. {0x1FDD, 0x1FEF, 0},
  275. {0x1FF2, 0x1FF4, 0},
  276. {0x1FF6, 0x1FFE, 0},
  277. {0x2000, 0x200B, 0},
  278. {0x2011, 0x2012, 0},
  279. {0x2017, 0x2017, 0},
  280. {0x201B, 0x201B, 0},
  281. {0x201F, 0x201F, 0},
  282. {0x2023, 0x2024, 0},
  283. {0x2028, 0x202E, 0},
  284. {0x2031, 0x2031, 0},
  285. {0x2034, 0x2034, 0},
  286. {0x2036, 0x2038, 0},
  287. {0x203C, 0x2046, 0},
  288. {0x206A, 0x2070, 0},
  289. {0x2075, 0x207E, 0},
  290. {0x2080, 0x2080, 0},
  291. {0x2085, 0x208E, 0},
  292. {0x20A0, 0x20A9, 0},
  293. {0x20D0, 0x20E1, 0},
  294. {0x2100, 0x2102, 0},
  295. {0x2104, 0x2104, 0},
  296. {0x2106, 0x2108, 0},
  297. {0x210A, 0x2112, 0},
  298. {0x2114, 0x2115, 0},
  299. {0x2117, 0x2120, 0},
  300. {0x2123, 0x2125, 0},
  301. {0x2127, 0x212A, 0},
  302. {0x212C, 0x2138, 0},
  303. {0x2155, 0x215A, 0},
  304. {0x215F, 0x215F, 0},
  305. {0x216C, 0x216F, 0},
  306. {0x217A, 0x2182, 0},
  307. {0x219A, 0x21D1, 0},
  308. {0x21D3, 0x21D3, 0},
  309. {0x21D5, 0x21EA, 0},
  310. {0x2201, 0x2201, 0},
  311. {0x2204, 0x2206, 0},
  312. {0x2209, 0x220A, 0},
  313. {0x220C, 0x220E, 0},
  314. {0x2210, 0x2210, 0},
  315. {0x2212, 0x2214, 0},
  316. {0x2216, 0x2219, 0},
  317. {0x221B, 0x221C, 0},
  318. {0x2221, 0x2222, 0},
  319. {0x2224, 0x2224, 0},
  320. {0x2226, 0x2226, 0},
  321. {0x222D, 0x222D, 0},
  322. {0x222F, 0x2233, 0},
  323. {0x2238, 0x223B, 0},
  324. {0x223E, 0x2247, 0},
  325. {0x2249, 0x224B, 0},
  326. {0x224D, 0x2251, 0},
  327. {0x2253, 0x225F, 0},
  328. {0x2262, 0x2263, 0},
  329. {0x2268, 0x2269, 0},
  330. {0x226C, 0x226D, 0},
  331. {0x2270, 0x2281, 0},
  332. {0x2284, 0x2285, 0},
  333. {0x2288, 0x2294, 0},
  334. {0x2296, 0x2298, 0},
  335. {0x229A, 0x22A4, 0},
  336. {0x22A6, 0x22BE, 0},
  337. {0x22C0, 0x22F1, 0},
  338. {0x2300, 0x2300, 0},
  339. {0x2302, 0x2311, 0},
  340. {0x2313, 0x237A, 0},
  341. {0x2400, 0x2424, 0},
  342. {0x2440, 0x244A, 0},
  343. {0x24B6, 0x24CF, 0},
  344. {0x24EA, 0x24EA, 0},
  345. {0x254C, 0x254F, 0},
  346. {0x2575, 0x2580, 0},
  347. {0x2590, 0x2591, 0},
  348. {0x25A2, 0x25A2, 0},
  349. {0x25AA, 0x25B1, 0},
  350. {0x25B4, 0x25B5, 0},
  351. {0x25B8, 0x25BB, 0},
  352. {0x25BE, 0x25BF, 0},
  353. {0x25C2, 0x25C5, 0},
  354. {0x25C9, 0x25CA, 0},
  355. {0x25CC, 0x25CD, 0},
  356. {0x25D2, 0x25E1, 0},
  357. {0x25E6, 0x25EE, 0},
  358. {0x2600, 0x2604, 0},
  359. {0x2607, 0x2608, 0},
  360. {0x260A, 0x260D, 0},
  361. {0x2610, 0x2613, 0},
  362. {0x261A, 0x261B, 0},
  363. {0x261D, 0x261D, 0},
  364. {0x261F, 0x263F, 0},
  365. {0x2641, 0x2641, 0},
  366. {0x2643, 0x265F, 0},
  367. {0x2662, 0x2662, 0},
  368. {0x2666, 0x2666, 0},
  369. {0x266B, 0x266B, 0},
  370. {0x266E, 0x266E, 0},
  371. {0x2701, 0x2704, 0},
  372. {0x2706, 0x2709, 0},
  373. {0x270C, 0x2727, 0},
  374. {0x2729, 0x274B, 0},
  375. {0x274D, 0x274D, 0},
  376. {0x274F, 0x2752, 0},
  377. {0x2756, 0x2756, 0},
  378. {0x2758, 0x275E, 0},
  379. {0x2761, 0x2767, 0},
  380. {0x2776, 0x2794, 0},
  381. {0x2798, 0x27AF, 0},
  382. {0x27B1, 0x27BE, 0},
  383. {0x3004, 0x3004, 0},
  384. {0x3018, 0x301C, 0},
  385. {0x3020, 0x3020, 0},
  386. {0x302A, 0x3037, 0},
  387. {0x303F, 0x303F, 0},
  388. {0x3094, 0x3094, 0},
  389. {0x3099, 0x309A, 0},
  390. {0x30F7, 0x30FA, 0},
  391. {0x312A, 0x312C, 0},
  392. {0x3190, 0x319F, 0},
  393. {0x322A, 0x3230, 0},
  394. {0x3233, 0x3238, 0},
  395. {0x323A, 0x3243, 0},
  396. {0x3280, 0x32A2, 0},
  397. {0x32A9, 0x32B0, 0},
  398. {0x32C0, 0x32CB, 0},
  399. {0x32D0, 0x32FE, 0},
  400. {0x3300, 0x3302, 0},
  401. {0x3304, 0x330C, 0},
  402. {0x330E, 0x3313, 0},
  403. {0x3315, 0x3317, 0},
  404. {0x3319, 0x3321, 0},
  405. {0x3324, 0x3325, 0},
  406. {0x3328, 0x332A, 0},
  407. {0x332C, 0x3335, 0},
  408. {0x3337, 0x333A, 0},
  409. {0x333C, 0x3348, 0},
  410. {0x334B, 0x334C, 0},
  411. {0x334E, 0x3350, 0},
  412. {0x3352, 0x3356, 0},
  413. {0x3358, 0x3376, 0},
  414. {0x337F, 0x337F, 0},
  415. {0x3385, 0x3387, 0},
  416. {0x33CB, 0x33CC, 0},
  417. {0x33D4, 0x33D4, 0},
  418. {0x33D7, 0x33D7, 0},
  419. {0x33D9, 0x33DA, 0},
  420. {0x33E0, 0x33FE, 0},
  421. {0xFB00, 0xFB06, 0},
  422. {0xFB13, 0xFB17, 0},
  423. {0xFB1E, 0xFB36, 0},
  424. {0xFB38, 0xFB3C, 0},
  425. {0xFB3E, 0xFB3E, 0},
  426. {0xFB40, 0xFB41, 0},
  427. {0xFB43, 0xFB44, 0},
  428. {0xFB46, 0xFBB1, 0},
  429. {0xFBD3, 0xFD3F, 0},
  430. {0xFD50, 0xFD8F, 0},
  431. {0xFD92, 0xFDC7, 0},
  432. {0xFDF0, 0xFDFB, 0},
  433. {0xFE20, 0xFE23, 0},
  434. {0xFE32, 0xFE32, 0},
  435. {0xFE58, 0xFE58, 0},
  436. {0xFE70, 0xFE72, 0},
  437. {0xFE74, 0xFE74, 0},
  438. {0xFE76, 0xFEFC, 0},
  439. {0xFEFF, 0xFEFF, 0},
  440. {0xFFA0, 0xFFBE, 0},
  441. {0xFFC2, 0xFFC7, 0},
  442. {0xFFCA, 0xFFCF, 0},
  443. {0xFFD2, 0xFFD7, 0},
  444. {0xFFDA, 0xFFDC, 0},
  445. {0xFFE8, 0xFFEE, 0},
  446. {0xFFFD, 0xFFFD, 0}
  447. };
  449. const struct {
  450.     int         nCharSet;
  451.     UINT        uCodePage;
  452.     DWORD       dwCodePages;
  453.     SCRIPT_ID   sid[3];
  454. } g_CharSetTransTable[] = 
  455. {
  456.     ANSI_CHARSET,        1252, FS_LATIN1,   sidAsciiLatin,  sidLatin,   sidDefault,  
  457.     EASTEUROPE_CHARSET,  1250, FS_LATIN2,   sidAsciiLatin,  sidLatin,   sidDefault,  
  458.     RUSSIAN_CHARSET,     1251, FS_CYRILLIC, sidCyrillic,    sidDefault, sidDefault,
  459.     GREEK_CHARSET,       1253, FS_GREEK,    sidGreek,       sidDefault, sidDefault,
  460.     TURKISH_CHARSET,     1254, FS_TURKISH,  sidAsciiLatin,  sidLatin,   sidDefault,
  461.     HEBREW_CHARSET,      1255, FS_HEBREW,   sidHebrew,      sidDefault, sidDefault,
  462.     ARABIC_CHARSET,      1256, FS_ARABIC,   sidArabic,      sidDefault, sidDefault,
  463.     BALTIC_CHARSET,      1257, FS_BALTIC,   sidAsciiLatin,  sidLatin,   sidDefault,
  464.     VIETNAMESE_CHARSET,  1258, FS_VIETNAMESE, sidAsciiLatin,  sidLatin, sidDefault,
  465.     THAI_CHARSET,         874, FS_THAI ,    sidThai,        sidDefault, sidDefault,
  466.     SHIFTJIS_CHARSET,     932, FS_JISJAPAN, sidKana,        sidDefault, sidDefault, //sidKana,        sidHan,     sidDefault,
  467.     GB2312_CHARSET,       936, FS_CHINESESIMP,sidHan,       sidDefault, sidDefault, //sidKana,     sidHan,     sidBopomofo,
  468.     HANGEUL_CHARSET,      949, FS_WANSUNG,  sidHangul,      sidDefault, sidDefault, //sidHangul,   sidKana,    sidHan,
  469.     CHINESEBIG5_CHARSET,  950, FS_CHINESETRAD, sidBopomofo, sidDefault, sidDefault, //sidKana,     sidHan,     sidBopomofo,     
  470.     JOHAB_CHARSET,       1361, FS_JOHAB,    sidDefault,     sidDefault, sidDefault,
  471.     DEFAULT_CHARSET,        0, 0,           sidDefault,     sidDefault, sidDefault,
  472. };
  474. // Primary chars for scripts
  475. // Pre-sorted by Unicode characters to speed up CMAP search.
  476. const struct {
  477.     WCHAR       wch;    //Can be extended to a character list
  478.     SCRIPT_ID   sid;
  479. } g_wCharToScript[] =
  480. {
  481.         0x0531, sidArmenian,
  482.         0x0710, sidSyriac,
  483.         0x0780, sidThaana,
  484.         0x0905, sidDevanagari,
  485.         0x0985, sidBengali,
  486.         0x0a05, sidGurmukhi,
  487.         0x0a85, sidGujarati,
  488.         0x0b05, sidOriya,
  489.         0x0b85, sidTamil,
  490.         0x0c05, sidTelugu,
  491.         0x0c85, sidKannada,
  492.         0x0d05, sidMalayalam,
  493.         0x0d85, sidSinhala,
  494.         0x0e81, sidLao,
  495.         0x0f40, sidTibetan,
  496.         0x10a0, sidGeorgian,
  497.         0x1300, sidEthiopic,
  498.         0x1401, sidCanSyllabic,
  499.         0x13a0, sidCherokee,
  500.         0xa000, sidYi,
  501.         0x1680, sidOgham,
  502.         0x16a0, sidRunic,
  503.         0x1700, sidBurmese,
  504.         0x1780, sidKhmer,
  505.         0x2800, sidBraille,
  506. //      0x0020, sidUserDefined
  507.     };
  509. // Script tables ported from Trident
  510. static SCRIPT_ID s_asidUnicodeSubRangeScriptMapping[] =
  511. {
  512.     sidAsciiLatin, sidLatin,      sidLatin,      sidLatin,        // 128-131
  513.     sidLatin,      sidLatin,      0,             sidGreek,        // 132-135
  514.     sidGreek,      sidCyrillic,   sidArmenian,   sidHebrew,       // 136-139
  515.     sidHebrew,     sidArabic,     sidArabic,     sidDevanagari,   // 140-143
  516.     sidBengali,    sidGurmukhi,   sidGujarati,   sidOriya,        // 144-147
  517.     sidTamil,      sidTelugu,     sidKannada,    sidMalayalam,    // 148-151
  518.     sidThai,       sidLao,        sidGeorgian,   sidGeorgian,     // 152-155
  519.     sidHangul,     sidLatin,      sidGreek,      0,               // 156-159
  520.     0,             0,             0,             0,               // 160-163
  521.     0,             0,             0,             0,               // 164-167
  522.     0,             0,             0,             0,               // 168-171
  523.     0,             0,             0,             0,               // 172-175
  524.     sidHan,        sidKana,       sidKana,       sidBopomofo,     // 176-179
  525.     sidHangul,     0,             0,             0,               // 180-183
  526.     sidHangul,     sidHangul,     sidHangul,     sidHan,          // 184-187
  527.     0,             sidHan,        0,             0,               // 188-191
  528.     0,             0,             0,             0,               // 192-195
  529.     0,             0,             sidHangul,     0,               // 196-199
  530. };
  533. // Script table (raw data from MichelSu)
  534. // Rendered by script ID
  535. const SCRIPT ScriptTable[] = 
  536. {
  538.     {sidDefault,    IDS_SIDDEFAULT,     0,  0,  0,  0, SCRIPTCONTF_SCRIPT_SYSTEM},      // 0
  539.     {sidMerge,      IDS_SIDMERGE,       0,  0,  0,  0, SCRIPTCONTF_SCRIPT_SYSTEM},      // 1
  540.     {sidAsciiSym,   IDS_SIDASCIISYM,    0,  0,  0,  0, SCRIPTCONTF_SCRIPT_SYSTEM},      // 2
  541.     {sidAsciiLatin, IDS_SIDASCIILATIN,  1252, 0,      IDS_FONT_WESTERN_FIXED, IDS_FONT_WESTERN_PROP2, SCRIPTCONTF_SCRIPT_USER},  // 3
  542.     {sidLatin,      IDS_SIDLATIN,       1252, 0,      IDS_FONT_WESTERN_FIXED, IDS_FONT_WESTERN_PROP2, SCRIPTCONTF_SCRIPT_HIDE},  // 4
  543.     {sidGreek,      IDS_SIDGREEK,       1253, 0x03AC, IDS_FONT_WESTERN_FIXED, IDS_FONT_WESTERN_PROP2, SCRIPTCONTF_SCRIPT_USER},  // 5
  544.     {sidCyrillic,   IDS_SIDCYRILLIC,    1251, 0x0401, IDS_FONT_WESTERN_FIXED, IDS_FONT_WESTERN_PROP2, SCRIPTCONTF_SCRIPT_USER},  // 6
  545.     {sidArmenian,   IDS_SIDARMENIAN,    0,    0x0531, 0, 0, SCRIPTCONTF_SCRIPT_USER},                                            // 7
  546. /**/{sidHebrew,     IDS_SIDHEBREW,      1255, 0x05D4, IDS_FONT_HEBREW_FIXED,  IDS_FONT_HEBREW_PROP, SCRIPTCONTF_SCRIPT_USER},    // 8
  547.     {sidArabic,     IDS_SIDARABIC,      1256, 0x0627, IDS_FONT_ARABIC_FIXED,  IDS_FONT_ARABIC_PROP, SCRIPTCONTF_SCRIPT_USER},    // 9
  548.     {sidDevanagari, IDS_SIDDEVANAGARI,  0,    0x0905, IDS_FONT_DEVANAGARI_FIXED,IDS_FONT_DEVANAGARI_PROP, SCRIPTCONTF_SCRIPT_USER}, // 10
  549.     {sidBengali,    IDS_SIDBENGALI,     0,    0x0985, 0, 0, SCRIPTCONTF_SCRIPT_USER},                                            // 11
  550.     {sidGurmukhi,   IDS_SIDGURMUKHI,    0,    0x0A05, 0, 0, SCRIPTCONTF_SCRIPT_USER},                                            // 12
  551.     {sidGujarati,   IDS_SIDGUJARATI,    0,    0x0A85, 0, 0, SCRIPTCONTF_SCRIPT_USER},                                            // 13
  552.     {sidOriya,      IDS_SIDORIYA,       0,    0x0B05, 0, 0, SCRIPTCONTF_SCRIPT_USER},                                            // 14
  553.     {sidTamil,      IDS_SIDTAMIL,       0,    0x0B85, IDS_FONT_TAMIL_FIXED, IDS_FONT_TAMIL_PROP, SCRIPTCONTF_SCRIPT_USER},       // 15
  554.     {sidTelugu,     IDS_SIDTELUGU,      0,    0x0C05, 0, 0, SCRIPTCONTF_SCRIPT_USER},                                            // 16
  555.     {sidKannada,    IDS_SIDKANNADA,     0,    0x0C85, 0, 0, SCRIPTCONTF_SCRIPT_USER},                                            // 17
  556.     {sidMalayalam,  IDS_SIDMALAYALAM,   0,    0x0D05, 0, 0, SCRIPTCONTF_SCRIPT_USER},                                            // 18
  557.     {sidThai,       IDS_SIDTHAI,        874,  0x0E01, IDS_FONT_THAI_FIXED, IDS_FONT_THAI_PROP, SCRIPTCONTF_SCRIPT_USER},         // 19
  558.     {sidLao,        IDS_SIDLAO,         0,    0x0E81, 0, 0, SCRIPTCONTF_SCRIPT_USER},                                            // 20
  559.     {sidTibetan,    IDS_SIDTIBETAN,     0,    0x0F40, 0, 0, SCRIPTCONTF_SCRIPT_USER},                                            // 21
  560.     {sidGeorgian,   IDS_SIDGEORGIAN,    0,    0x10A0, 0, 0, SCRIPTCONTF_SCRIPT_USER},                                            // 22
  561.     {sidHangul,     IDS_SIDHANGUL,      949,  0,      IDS_FONT_KOREAN_FIXED,   IDS_FONT_KOREAN_PROP, SCRIPTCONTF_SCRIPT_USER},   // 23
  562.     {sidKana,       IDS_SIDKANA,        932,  0,      IDS_FONT_JAPANESE_FIXED, IDS_FONT_JAPANESE_PROP, SCRIPTCONTF_SCRIPT_USER}, // 24
  563.     {sidBopomofo,   IDS_SIDBOPOMOFO,    950,  0,      IDS_FONT_TAIWAN_FIXED,   IDS_FONT_TAIWAN_PROP, SCRIPTCONTF_SCRIPT_USER},   // 25
  564.     {sidHan,        IDS_SIDHAN,         936,  0,      IDS_FONT_CHINESE_FIXED,  IDS_FONT_CHINESE_PROP, SCRIPTCONTF_SCRIPT_USER},  // 26
  565.     {sidEthiopic,   IDS_SIDETHIOPIC,    0,    0x1300, 0, 0, SCRIPTCONTF_SCRIPT_USER},      // 27
  566.     {sidCanSyllabic,IDS_SIDCANSYLLABIC, 0,    0x1401, 0, 0, SCRIPTCONTF_SCRIPT_USER},      // 28
  567.     {sidCherokee,   IDS_SIDCHEROKEE,    0,    0x13A0, 0, 0, SCRIPTCONTF_SCRIPT_USER},      // 29
  568.     {sidYi,         IDS_SIDYI,          0,    0xA000, 0, 0, SCRIPTCONTF_SCRIPT_USER},      // 30
  569.     {sidBraille,    IDS_SIDBRAILLE,     0,    0x2800, 0, 0, SCRIPTCONTF_SCRIPT_USER},      // 31
  570.     {sidRunic,      IDS_SIDRUNIC,       0,    0x16A0, 0, 0, SCRIPTCONTF_SCRIPT_USER},      // 32
  571.     {sidOgham,      IDS_SIDOGHAM,       0,    0x1680, 0, 0, SCRIPTCONTF_SCRIPT_USER},      // 33
  572.     {sidSinhala,    IDS_SIDSINHALA,     0,    0x0D85, 0, 0, SCRIPTCONTF_SCRIPT_USER},      // 34
  573.     {sidSyriac,     IDS_SIDSYRIAC,      0,    0x0710, 0, 0, SCRIPTCONTF_SCRIPT_USER},      // 35
  574.     {sidBurmese,    IDS_SIDBURMESE,     0,    0x1700, 0, 0, SCRIPTCONTF_SCRIPT_USER},      // 36
  575.     {sidKhmer,      IDS_SIDKHMER,       0,    0x1780, 0, 0, SCRIPTCONTF_SCRIPT_USER},      // 37
  576.     {sidThaana,     IDS_SIDTHAANA,      0,    0x0780, 0, 0, SCRIPTCONTF_SCRIPT_USER},      // 38
  577.     {sidMongolian,  IDS_SIDMONGOLIAN,   0,    0,      0, 0, SCRIPTCONTF_SCRIPT_USER},      // 39
  578.     {sidUserDefined,IDS_SIDUSERDEFINED, 0,    0x0020, 0, 0, SCRIPTCONTF_SCRIPT_USER},      // 40
  579. };
  583. UINT g_cScript = ARRAYSIZE(ScriptTable);
  585. /////////////////////////////////////////////////////////////////////////////
  586. // CMLFLink Free Global Objects
  588. void CMLangFontLink_FreeGlobalObjects()
  589. {
  590.     if (g_pMLFLink)
  591.         g_pMLFLink->Release();
  592.     if (CMLFLink::m_pCodePagesCache)
  593.         delete CMLFLink::m_pCodePagesCache;
  594.     if (CMLFLink::m_pFontMappingCache)
  595.         delete CMLFLink::m_pFontMappingCache;
  596.     if (CMLFLink2::m_pFontMappingCache2)
  597.         delete CMLFLink2::m_pFontMappingCache2;
  598. }
  600. /////////////////////////////////////////////////////////////////////////////
  601. // CMLFLink
  603. CMLFLink::CMLFLink()
  604. {
  605.     EnterCriticalSection(&g_cs);
  606.     if (!m_pCodePagesCache)
  607.         m_pCodePagesCache = new CCodePagesCache;
  608.     if (!m_pFontMappingCache)
  609.         m_pFontMappingCache = new CFontMappingCache;
  610.     LeaveCriticalSection(&g_cs);
  611.     m_pFlinkTable = NULL;
  612. }
  615. /////////////////////////////////////////////////////////////////////////////
  616. // CMLFLink : IMLangCodePages
  618. STDMETHODIMP CMLFLink::GetCharCodePages(WCHAR chSrc, DWORD* pdwCodePages)
  619. {
  620.     ASSERT_THIS;
  621.     ASSERT_WRITE_PTR_OR_NULL(pdwCodePages);
  623.     HRESULT hr = S_OK;
  624.     int nLen;
  625.     int iCmd = 0;
  626.     int nPickOffset;
  627.     int nBitOffset = 0;
  628.     int nBitCount = 32;
  629.     DWORD dwDiff = 0xffffffff;
  630.     DWORD dwOr = 0;
  631.     DWORD dwCodePages;
  632.     DWORD adwBitsMap[32];
  633.     const CCodePagesHeader* pHeader;
  634.     const WORD* pwTable;
  635.     int nBlock;
  636.     int nEndLen;
  637.     const BYTE* pbBlock;
  639.     if (m_pCodePagesCache)
  640.         hr = m_pCodePagesCache->Load();
  641.     else
  642.         hr = E_FAIL;
  644.     if (SUCCEEDED(hr))
  645.     {
  646.         pHeader = (CCodePagesHeader*)(BYTE*)*m_pCodePagesCache;
  647.         pwTable = (WORD*)(*m_pCodePagesCache + READWINTELDWORD(pHeader->m_dwTableOffset));
  648.         nBlock = chSrc / READWINTELDWORD(pHeader->m_dwBlockSize);
  649.         nEndLen = chSrc % READWINTELDWORD(pHeader->m_dwBlockSize);
  650.         pbBlock = *m_pCodePagesCache + READWINTELWORD(pwTable[nBlock]);
  651.     }
  653.     for (int nDoneLen = 0; SUCCEEDED(hr) && nDoneLen < (int)READWINTELDWORD(pHeader->m_dwBlockSize); nDoneLen += nLen)
  654.     {
  655.         BYTE bCmd = pbBlock[--iCmd];
  656.         if (bCmd < pHeader->m_abCmdCode[1])
  657.         {
  658.             // Flat
  659.             nLen = bCmd + 1;
  660.             nPickOffset = nBitOffset + nBitCount * (nEndLen - nDoneLen);
  661.             nBitOffset += nBitCount * nLen;
  662.         }
  663.         else if (bCmd < pHeader->m_abCmdCode[2])
  664.         {
  665.             // Pack
  666.             nLen = bCmd - pHeader->m_abCmdCode[1] + 2;
  667.             nPickOffset = nBitOffset;
  668.             nBitOffset += nBitCount;
  669.         }
  670.         else if (bCmd < pHeader->m_abCmdCode[4])
  671.         {
  672.             // Diff & Or
  673.             nLen = 0;
  675.             DWORD dw = pbBlock[--iCmd];
  676.             dw <<= 8;
  677.             dw |= pbBlock[--iCmd];
  678.             dw <<= 8;
  679.             dw |= pbBlock[--iCmd];
  680.             dw <<= 8;
  681.             dw |= pbBlock[--iCmd];
  683.             if (bCmd < pHeader->m_abCmdCode[3])
  684.             {
  685.                 // Diff
  686.                 dwDiff = dw;
  687.                 DWORD dwShift = 1;
  688.                 nBitCount = 0;
  689.                 for (int nBit = 0; nBit < 32; nBit++)
  690.                 {
  691.                     if (dwDiff & (1 << nBit))
  692.                     {
  693.                         adwBitsMap[nBit] = dwShift;
  694.                         dwShift <<= 1;
  695.                         nBitCount++;
  696.                     }
  697.                     else
  698.                     {
  699.                         adwBitsMap[nBit] = 0;
  700.                     }
  701.                 }
  702.             }
  703.             else
  704.             {
  705.                 // Or
  706.                 dwOr = dw;
  707.             }
  708.         }
  709.         else
  710.         {
  711.             // Big Pack
  712.             nLen = (bCmd - pHeader->m_abCmdCode[4]) * 0x100 + pbBlock[--iCmd] + pHeader->m_abCmdCode[2] - pHeader->m_abCmdCode[1] + 1 + 1;
  713.             nPickOffset = nBitOffset;
  714.             nBitOffset += nBitCount;
  715.         }
  717.         if (nEndLen < nDoneLen + nLen)
  718.             break;
  719.     }
  721.     if (SUCCEEDED(hr) &&
  722.         nDoneLen < (int)READWINTELDWORD(pHeader->m_dwBlockSize))
  723.     {
  724.         const BYTE* const pbBuf = &pbBlock[nPickOffset / 8];
  725.         DWORD dwCompBits = pbBuf[0] | (DWORD(pbBuf[1]) << 8) | (DWORD(pbBuf[2]) << 16) | (DWORD(pbBuf[3]) << 24);
  726.         dwCompBits >>= nPickOffset % 8;
  727.         if (nBitOffset % 8)
  728.             dwCompBits |= pbBuf[4] << (32 - nBitOffset % 8);
  730.         if (nBitCount < 32)
  731.         {
  732.             dwCompBits &= (1 << nBitCount) - 1;
  734.             dwCodePages = 0;
  735.             for (int nBit = 0; nBit < 32; nBit++)
  736.             {
  737.                 if (dwCompBits & adwBitsMap[nBit])
  738.                     dwCodePages |= (1 << nBit);
  739.             }
  740.         }
  741.         else
  742.         {
  743.             dwCodePages = dwCompBits;
  744.         }
  746.         dwCodePages |= dwOr;
  747.     }
  748.     else
  749.     {
  750.         hr = E_FAIL; // Probably Code Pages data is broken.
  751.     }
  753.     if (pdwCodePages)
  754.     {
  755.         if (SUCCEEDED(hr))
  756.         {
  757.             // We invent this new internal charset bit, FS_MLANG_K1HANJA, to support Korean K1 Hanja
  758.             // K1 Hanja is defined in KSC 5657-1991, it contains non-cp949 DBCS characters
  759.             // Currenly, Korean fonts shipped with NT5 and Win98 support K1 Hanja glyphs 
  760.             // and we don't want to switch font to other DBCS fonts in this case.
  761.             if (dwCodePages & FS_MLANG_K1HANJA)
  762.             {
  763.                 // Assume Korean font supports K1_HANJA on Win98 and NT5 
  764.                 if (g_bIsNT5 || (g_bIsWin98 && CP_KOR_5601 == GetACP()))
  765.                     dwCodePages |= FS_WANSUNG;
  766.                 dwCodePages &= ~FS_MLANG_K1HANJA;
  767.             }            
  768.             *pdwCodePages = dwCodePages;
  769.         }
  770.         else
  771.             *pdwCodePages = 0;
  772.     }
  774.     return hr;
  775. }   
  779. STDMETHODIMP CMLFLink::GetStrCodePages(const WCHAR* pszSrc, long cchSrc, DWORD dwPriorityCodePages, DWORD* pdwCodePages, long* pcchCodePages)
  780. {
  781.     ASSERT_THIS;
  782.     ASSERT_READ_BLOCK(pszSrc, cchSrc);
  783.     ASSERT_WRITE_PTR_OR_NULL(pdwCodePages);
  784.     ASSERT_WRITE_PTR_OR_NULL(pcchCodePages);
  786.     HRESULT hr = S_OK;
  787.     long cchCodePages = 0;
  788.     DWORD dwStrCodePages = (DWORD)~0;
  789.     BOOL fInit = FALSE;
  790.     BOOL fNoPri = FALSE;
  792.     if (!pszSrc || cchSrc <= 0) // We can't make dwStrCodePages when cchSrc is zero
  793.         hr = E_INVALIDARG;
  795.     while (SUCCEEDED(hr) && cchSrc > 0)
  796.     {
  797.         DWORD dwCharCodePages;
  799.         if (SUCCEEDED(hr = GetCharCodePages(*pszSrc, &dwCharCodePages)))
  800.         {
  801.             if (!fInit)
  802.             {
  803.                 fInit = TRUE;
  804.                 fNoPri = !(dwPriorityCodePages & dwCharCodePages);
  805.             }
  806.             else if (fNoPri != !(dwPriorityCodePages & dwCharCodePages))
  807.             {
  808.                 break;
  809.             }
  810.             if (!fNoPri)
  811.                 dwPriorityCodePages &= dwCharCodePages;
  813.             if (dwCharCodePages && (dwCharCodePages & dwStrCodePages))
  814.                 dwStrCodePages &= dwCharCodePages;
  815.             else if (dwCharCodePages) // Don't break if dwCharCodePages is zero
  816.                      break;
  818.             pszSrc++;
  819.             cchSrc--;
  820.             cchCodePages++;
  821.         }
  822.     }
  824.     if (SUCCEEDED(hr))
  825.     {
  826.         if (pcchCodePages)
  827.             *pcchCodePages = cchCodePages;
  828.         if (pdwCodePages)
  829.             *pdwCodePages = dwStrCodePages;
  830.     }
  831.     else
  832.     {
  833.         if (pcchCodePages)
  834.             *pcchCodePages = 0;
  835.         if (pdwCodePages)
  836.             *pdwCodePages = 0;
  837.     }
  839.     return hr;
  840. }
  842. STDMETHODIMP CMLFLink::CodePageToCodePages(UINT uCodePage, DWORD* pdwCodePages)
  843. {
  844.     ASSERT_THIS;
  845.     ASSERT_WRITE_PTR_OR_NULL(pdwCodePages);
  847.     for (int iCharSet = 0; g_CharSetTransTable[iCharSet].uCodePage; iCharSet++)
  848.     {
  849.         if (uCodePage == g_CharSetTransTable[iCharSet].uCodePage)
  850.         {
  851.             if (pdwCodePages)
  852.                 *pdwCodePages = g_CharSetTransTable[iCharSet].dwCodePages;
  853.             return S_OK;
  854.         }
  855.     }
  857.     if (pdwCodePages)
  858.         *pdwCodePages = 0;
  860.     return E_FAIL; // Unknown code page
  861. }
  863. STDMETHODIMP CMLFLink::CodePagesToCodePage(DWORD dwCodePages, UINT uDefaultCodePage, UINT* puCodePage)
  864. {
  865.     ASSERT_THIS;
  866.     ASSERT_WRITE_PTR_OR_NULL(puCodePage);
  868.     HRESULT hr = E_FAIL; // Unknown code pages
  869.     DWORD dwDefaultCodePages;
  871.     if (uDefaultCodePage &&
  872.         SUCCEEDED(hr = CodePageToCodePages(uDefaultCodePage, &dwDefaultCodePages)) &&
  873.         (dwDefaultCodePages & dwCodePages))
  874.     {
  875.         hr = S_OK;
  876.     }
  877.     else
  878.     {
  879.         for (int iCharSet = 0; g_CharSetTransTable[iCharSet].dwCodePages; iCharSet++)
  880.         {
  881.             if (dwCodePages & g_CharSetTransTable[iCharSet].dwCodePages)
  882.             {
  883.                 uDefaultCodePage = g_CharSetTransTable[iCharSet].uCodePage;
  884.                 hr = S_OK;
  885.                 break;
  886.             }
  887.         }
  888.     }
  890.     if (puCodePage)
  891.     {
  892.         if (SUCCEEDED(hr))
  893.             *puCodePage = uDefaultCodePage;
  894.         else
  895.             *puCodePage = 0;
  896.     }
  898.     return hr;
  899. }
  902. #define REGSTR_PATH_FONTLINK TSZMICROSOFTPATH TEXT("\Windows NT\CurrentVersion\FontLink\SystemLink")
  904. void CMLFLink::FreeFlinkTable(void)
  905. {
  906.     if (m_pFlinkTable)
  907.     {
  908.         for (UINT i=0; i<m_uiFLinkFontNum; i++)
  909.             if (m_pFlinkTable[i].pmszFaceName)
  910.                 LocalFree(m_pFlinkTable[i].pmszFaceName);
  911.         LocalFree(m_pFlinkTable);
  912.         m_pFlinkTable = NULL;
  913.         m_uiFLinkFontNum = 0;
  914.     }
  915. }
  917. #define MAX_FONTLINK_BUFFER_SIZE    1024
  919. HRESULT CMLFLink::CreateNT5FontLinkTable(void)
  920. {
  921.     HKEY    hKey = NULL;
  922.     HKEY    hKeyFont = NULL;
  923.     ULONG   ulFonts = 0;
  924.     ULONG   ulFLinkFonts = 0;
  925.     DWORD   dwIndex = 0;
  926.     WCHAR   szFaceName[MAX_PATH];
  927.     LPWSTR  pNewFaceName = NULL;
  928.     DWORD   dwOffset = 0;
  929.     DWORD   dwOffset2 = 0;
  930.     DWORD   dwValue;
  931.     DWORD   dwData;
  932.     WCHAR   szFontFile[LF_FACESIZE];
  933.     DWORD   dwType;
  934.     WCHAR   szFlinkFont[MAX_FONTLINK_BUFFER_SIZE];
  935.     
  937.     // Internal temperate data
  938.     struct tagFontTable
  939.     {
  940.         WCHAR szFontFile[LF_FACESIZE];
  941.         WCHAR szFaceName[LF_FACESIZE];
  942.     }* tmpFontTable = NULL;
  944.     HRESULT hr;
  946.     // Open system font and fontlink key
  947.     if ((ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGSTR_PATH_FONTLINK, 0, KEY_READ, &hKey)) ||
  948.         (ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGFONTKEYNT, 0, KEY_READ, &hKeyFont)))
  949.     {
  950.         hr = E_FAIL;
  951.         goto TABLE_DONE;
  952.     }
  955.     // Get number of items
  956.     if ((ERROR_SUCCESS != RegQueryInfoKey(hKey, NULL, NULL, 0, NULL, 
  957.          NULL, NULL, &ulFLinkFonts, NULL, NULL, NULL, NULL) || 0 == ulFLinkFonts) ||            
  958.         (ERROR_SUCCESS != RegQueryInfoKey(hKeyFont, NULL, NULL, 0, NULL, 
  959.             NULL, NULL, &ulFonts, NULL, NULL, NULL, NULL) || 0 == ulFonts))
  960.     {
  961.         hr = E_FAIL;
  962.         goto TABLE_DONE;
  963.     }
  965.     tmpFontTable = (struct tagFontTable *)LocalAlloc(LPTR, sizeof(struct tagFontTable)*ulFonts);
  967.     if (NULL == tmpFontTable)
  968.     {
  969.         hr = E_OUTOFMEMORY;
  970.         goto TABLE_DONE;
  971.     }
  973.     dwValue = dwData = LF_FACESIZE;
  974.     dwType = REG_SZ;
  975.     dwIndex = 0;
  976.     ulFonts = 0;    
  978.     while (ERROR_NO_MORE_ITEMS != RegEnumValueW(
  979.                       hKeyFont,
  980.                       dwIndex++,
  981.                       szFaceName,
  982.                       &dwValue,
  983.                       NULL,
  984.                       &dwType,
  985.                       (LPBYTE)szFontFile,
  986.                       &dwData ))
  987.     {
  988.         //  TTF fonts only, TTC fonts already have face name under fontlink
  989.         if (pNewFaceName = wcsstr(szFaceName, L" & "))
  990.             break;
  991.         pNewFaceName = wcsstr(szFaceName, L" (TrueType)");
  992.         if(pNewFaceName)
  993.         {
  994.            *pNewFaceName = 0;
  995.            MLStrCpyNW(tmpFontTable[ulFonts].szFaceName, szFaceName, LF_FACESIZE);
  996.            MLStrCpyNW(tmpFontTable[ulFonts++].szFontFile, szFontFile, LF_FACESIZE);
  997.         }
  999.         dwValue = dwData = LF_FACESIZE;
  1000.         dwType = REG_SZ;
  1001.     }
  1003.     
  1004.     m_pFlinkTable = (PFLINKFONT) LocalAlloc(LPTR, sizeof(FLINKFONT)*ulFLinkFonts);
  1005.     if (NULL == m_pFlinkTable)
  1006.     {
  1007.         hr = E_OUTOFMEMORY;
  1008.         goto TABLE_DONE;
  1009.     }
  1011.     dwValue = LF_FACESIZE;
  1012.     dwData = MAX_FONTLINK_BUFFER_SIZE;
  1013.     dwType = REG_MULTI_SZ;
  1015.     dwIndex = 0;
  1017.     while (ERROR_NO_MORE_ITEMS != RegEnumValueW(
  1018.                       hKey,
  1019.                       dwIndex,
  1020.                       m_pFlinkTable[dwIndex].szFaceName,
  1021.                       &dwValue,
  1022.                       NULL,
  1023.                       &dwType,
  1024.                       (LPBYTE)szFlinkFont,
  1025.                       &dwData ))
  1026.     {
  1027.         m_pFlinkTable[dwIndex].pmszFaceName = (LPWSTR) LocalAlloc(LPTR, MAX_FONTLINK_BUFFER_SIZE); 
  1028.         if (!m_pFlinkTable[dwIndex].pmszFaceName)
  1029.         {
  1030.             hr = E_OUTOFMEMORY;
  1031.             goto TABLE_DONE;
  1032.         }
  1033.         while (TRUE)
  1034.         {
  1035.             pNewFaceName = wcsstr(&szFlinkFont[dwOffset], L",");
  1036.             
  1037.             if (pNewFaceName)   // TTC font, get face name from registry
  1038.             {
  1039.                 MLStrCpyNW(&(m_pFlinkTable[dwIndex].pmszFaceName[dwOffset2]), ++pNewFaceName, LF_FACESIZE);
  1040.                 dwOffset2 += lstrlenW(pNewFaceName)+1;
  1041.             }
  1042.             else                // TTF font, search font table for face name            
  1043.             {
  1044.                 if (szFlinkFont[dwOffset])
  1045.                     for (UINT i=0; i<ulFonts; i++)
  1046.                     {
  1047.                         if (!MLStrCmpNIW(&szFlinkFont[dwOffset], tmpFontTable[i].szFontFile, LF_FACESIZE))
  1048.                         {
  1049.                             MLStrCpyNW(&(m_pFlinkTable[dwIndex].pmszFaceName[dwOffset2]), tmpFontTable[i].szFaceName, LF_FACESIZE);
  1050.                             dwOffset2 += lstrlenW(tmpFontTable[i].szFaceName)+1;
  1051.                             break;
  1052.                         }
  1053.                     }
  1054.                 else            // End of multiple string, break out                    
  1055.                     break;
  1056.             }
  1058.             dwOffset += lstrlenW(&szFlinkFont[dwOffset])+1;
  1060.             // Prevent infinitive loop, shouldn't happen
  1061.             if (dwOffset >= MAX_FONTLINK_BUFFER_SIZE) 
  1062.             {
  1063.                 break;
  1064.             }
  1065.         }
  1067.         dwValue = LF_FACESIZE;
  1068.         dwData = MAX_FONTLINK_BUFFER_SIZE;
  1069.         dwType = REG_MULTI_SZ;
  1070.         dwOffset = dwOffset2 = 0;
  1071.         dwIndex++;
  1072.     }
  1074.     m_uiFLinkFontNum = ulFLinkFonts;
  1076.     hr = S_OK;
  1078. TABLE_DONE:
  1079.     if (hKey)
  1080.         RegCloseKey(hKey);
  1081.     if (hKeyFont)
  1082.         RegCloseKey(hKeyFont);
  1083.     if (tmpFontTable)
  1084.         LocalFree(tmpFontTable);
  1085.     if ((hr != S_OK) && m_pFlinkTable)
  1086.         FreeFlinkTable();
  1088.     return hr;
  1089. }
  1092. HRESULT CMLFLink::GetNT5FLinkFontCodePages(HDC hDC, LOGFONTW* plfEnum, DWORD * lpdwCodePages)
  1093. {
  1094.     HRESULT hr = S_OK;
  1095.     UINT    i;
  1097.     if (!EnumFontFamiliesExW(hDC, plfEnum, GetFontCodePagesEnumFontProcW, (LPARAM)lpdwCodePages, 0))
  1098.         return E_FAIL;
  1100.     if (NULL == m_pFlinkTable)
  1101.         CreateNT5FontLinkTable();
  1103.     if (m_pFlinkTable)
  1104.     {
  1105.         for (i=0; i<m_uiFLinkFontNum;i++)
  1106.         {
  1107.             if (!MLStrCmpNIW(plfEnum->lfFaceName, m_pFlinkTable[i].szFaceName, LF_FACESIZE))
  1108.             {
  1109.                 DWORD dwOffset=0;
  1110.                 // Internal buffer, we're sure it'll end
  1111.                 while(TRUE)
  1112.                 {
  1113.                     MLStrCpyNW(plfEnum->lfFaceName, &m_pFlinkTable[i].pmszFaceName[dwOffset], LF_FACESIZE);
  1114.                     EnumFontFamiliesExW(hDC, plfEnum, GetFontCodePagesEnumFontProcW, (LPARAM)lpdwCodePages, 0);
  1115.                     dwOffset += lstrlenW(&m_pFlinkTable[i].pmszFaceName[dwOffset])+1;
  1116.                     // End of multiple string ?
  1117.                     if (m_pFlinkTable[i].pmszFaceName[dwOffset] == 0)
  1118.                         break;                        
  1119.                 }
  1120.                 break;
  1121.             }
  1122.         }
  1123.     }
  1125.     return hr;
  1126. }
  1129. /////////////////////////////////////////////////////////////////////////////
  1130. // CMLFLink : IMLangFontLink
  1131. // 1/29/99 - Change HR return
  1132. //        Now, we always return S_OK unless system error, caller will
  1133. //        check code pages bits in dwCodePages for font code page coverage
  1134. STDMETHODIMP CMLFLink::GetFontCodePages(HDC hDC, HFONT hFont, DWORD* pdwCodePages)
  1135. {
  1136.     ASSERT_THIS;
  1137.     ASSERT_WRITE_PTR_OR_NULL(pdwCodePages);
  1139.     HRESULT hr = S_OK;
  1140.     LOGFONT lfFont;
  1141.     DWORD dwCodePages = 0;
  1144.     if (!::GetObject(hFont, sizeof(lfFont), &lfFont))
  1145.         hr = E_FAIL; // Invalid hFont
  1147.     if (SUCCEEDED(hr))
  1148.     {
  1149.         LOGFONT lfEnum;
  1151.         // Enumerates all character sets of given font's facename
  1152.         // Then, combines them in dwCodePages
  1154.         ::memset(&lfEnum, 0, sizeof(lfEnum));
  1155.         lfEnum.lfCharSet = DEFAULT_CHARSET;
  1156.         _tcsncpy(lfEnum.lfFaceName, lfFont.lfFaceName, ARRAYSIZE(lfEnum.lfFaceName));
  1159.         if (g_bIsNT5)
  1160.         {
  1161.             LOGFONTW lfEnumW = {0};
  1162.             lfEnumW.lfCharSet = DEFAULT_CHARSET;
  1164.             if (MultiByteToWideChar(GetACP(), 0, lfFont.lfFaceName, LF_FACESIZE, lfEnumW.lfFaceName, LF_FACESIZE))
  1165.                 hr = GetNT5FLinkFontCodePages(hDC, &lfEnumW, &dwCodePages);
  1166.             else
  1167.                 if (!::EnumFontFamiliesEx(hDC, &lfEnum, GetFontCodePagesEnumFontProc, (LPARAM)&dwCodePages, 0))
  1168.                     hr = E_FAIL; // Invalid hDC
  1170.         }
  1171.         else
  1172.         {
  1173.             if (!::EnumFontFamiliesEx(hDC, &lfEnum, GetFontCodePagesEnumFontProc, (LPARAM)&dwCodePages, 0))
  1174.                 hr = E_FAIL; // Invalid hDC
  1175.         }
  1177.     }
  1179. //############################
  1180. //######  MingLiU HACK  ######
  1181. //## Fix the bogus font !!! ##
  1182. //############################
  1183.     if (SUCCEEDED(hr) && ::CompareString(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, lfFont.lfFaceName, -1, _T("MingLiU"), -1) == 2)
  1184.     {
  1185.         dwCodePages &= ~FS_LATIN1; // Actually it doesn't have the characters of ANSI_CHARSET.
  1186.     }
  1187. //############################
  1188. #ifdef UNICODE
  1189. #define PRC_DEFAULT_GUI_FONT L"x5b8bx4f53"
  1190. #else
  1191. #define PRC_DEFAULT_GUI_FONT "xcbxcexccxe5"
  1192. #endif
  1194.     // PRC Win95 DEFAULT_GUI_FONT HACK !!!
  1195.     if (SUCCEEDED(hr) && lfFont.lfCharSet == ANSI_CHARSET && ::CompareString(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, lfFont.lfFaceName, -1, PRC_DEFAULT_GUI_FONT, -1) == 2)
  1196.     {
  1197.         dwCodePages &= ~FS_CHINESESIMP; // Actually it doesn't have the characters of GB2321_CHARSET.
  1198.     }
  1200.     if (pdwCodePages)
  1201.     {
  1202.         if (SUCCEEDED(hr))
  1203.             *pdwCodePages = dwCodePages;
  1204.         else
  1205.             *pdwCodePages = 0;
  1206.     }
  1208.     return hr;
  1209. }
  1211. int CALLBACK CMLFLink::GetFontCodePagesEnumFontProc(const LOGFONT* plf, const TEXTMETRIC*, DWORD FontType, LPARAM lParam)
  1212. {
  1213.     for (int iCharSet = 0; g_CharSetTransTable[iCharSet].nCharSet != DEFAULT_CHARSET; iCharSet++)
  1214.     {
  1215.         if (plf->lfCharSet == g_CharSetTransTable[iCharSet].nCharSet)
  1216.         {
  1217.             if ((FontType == TRUETYPE_FONTTYPE) || 
  1218.                 (g_CharSetTransTable[iCharSet].uCodePage == GetACP()))
  1219.             {
  1220.                 *((DWORD*)lParam) |= g_CharSetTransTable[iCharSet].dwCodePages;
  1221.                 break;
  1222.             }
  1223.         }
  1224.     }
  1226.     return TRUE;
  1227. }
  1229. int CALLBACK CMLFLink::GetFontCodePagesEnumFontProcW(const LOGFONTW* plf, const TEXTMETRICW*, DWORD FontType, LPARAM lParam)
  1230. {
  1231.     for (int iCharSet = 0; g_CharSetTransTable[iCharSet].nCharSet != DEFAULT_CHARSET; iCharSet++)
  1232.     {
  1233.         if (plf->lfCharSet == g_CharSetTransTable[iCharSet].nCharSet)
  1234.         {
  1235.             if ((FontType == TRUETYPE_FONTTYPE) || 
  1236.                 (g_CharSetTransTable[iCharSet].uCodePage == GetACP()))
  1237.             {
  1238.                 *((DWORD*)lParam) |= g_CharSetTransTable[iCharSet].dwCodePages;
  1239.                 break;
  1240.             }
  1241.         }
  1242.     }
  1244.     return TRUE;
  1245. }
  1248. STDMETHODIMP CMLFLink::MapFont(HDC hDC, DWORD dwCodePages, HFONT hSrcFont, HFONT* phDestFont)
  1249. {
  1250.     ASSERT_THIS;
  1251.     ASSERT_WRITE_PTR_OR_NULL(phDestFont);
  1253.     HRESULT hr = S_OK;
  1254.     CFontMappingInfo fm; // To accelerate internal subroutine calls
  1256.     fm.hDC = hDC;
  1258.     // Font mapping cache works only for Display
  1259.     BOOL fDisplay = (::GetDeviceCaps(hDC, TECHNOLOGY) == DT_RASDISPLAY);
  1261.     dwCodePages &= ~FS_SYMBOL; // We don't map symbol font.
  1263.     if (!::GetObject(hSrcFont, sizeof(fm.lfSrcFont), &fm.lfSrcFont))
  1264.         hr = E_FAIL; // Invalid hSrcFont
  1266.     if (fDisplay)
  1267.         EnumFontFamiliesEx(hDC, &fm.lfSrcFont, (FONTENUMPROC)VerifyFontSizeEnumFontProc, (LPARAM)&fm.lfSrcFont, 0);
  1269.     // Do two things at same time
  1270.     // (1) Find given font in the font mapping cache
  1271.     // (2) Build m_auCodePage[] and m_adwCodePages[]
  1272.     if (SUCCEEDED(hr))
  1273.     {
  1274.         hr = S_FALSE; // hr == S_FALSE means that we didn't find the font in the cache
  1275.         for (int n = 0; n < 32 && dwCodePages; n++)
  1276.         {
  1277.             hr = CodePagesToCodePage(dwCodePages, 0, &fm.auCodePage[n]); // Pick one of CodePages
  1279.             if (SUCCEEDED(hr))
  1280.                 hr = CodePageToCodePages(fm.auCodePage[n], &fm.adwCodePages[n]);
  1282.             if (SUCCEEDED(hr))
  1283.             {
  1284.                 if (fDisplay && m_pFontMappingCache)
  1285.                     hr = m_pFontMappingCache->FindEntry(fm.auCodePage[n], fm.lfSrcFont, &fm.hDestFont);
  1286.                 else
  1287.                     hr = S_FALSE;
  1288.             }
  1290.             if (hr != S_FALSE)
  1291.                 break;
  1293.             dwCodePages &= ~fm.adwCodePages[n];
  1294.         }
  1295.         fm.auCodePage[n] = NULL; // End mark
  1296.         fm.adwCodePages[n] = 0;
  1297.     }
  1299.     if (hr == S_FALSE) // Not exist in cache
  1300.     {
  1302.         hr = MapFontCodePages(fm, GetFaceNameRegistry);
  1304.         if (hr == MLSTR_E_FACEMAPPINGFAILURE)
  1305.             hr = MapFontCodePages(fm, GetFaceNameGDI);
  1307.         // Handle font link failure case for NT5
  1308.         if (hr == MLSTR_E_FACEMAPPINGFAILURE && g_bIsNT5)
  1309.             hr = MapFontCodePages(fm, GetFaceNameMIME);
  1311.         if (SUCCEEDED(hr) && fDisplay && m_pFontMappingCache)
  1312.             hr = m_pFontMappingCache->AddEntry(fm.auCodePage[fm.iCP], fm.lfSrcFont, fm.hDestFont);
  1313.     }
  1315.     if (phDestFont)
  1316.     {
  1317.         if (SUCCEEDED(hr))
  1318.         {            
  1319.             *phDestFont = fm.hDestFont;
  1320.             fm.hDestFont = NULL; // Avoid being deleted it in destructor
  1321.         }
  1322.         else
  1323.         {
  1324.             *phDestFont = NULL;
  1325.         }
  1326.     }
  1328.     return hr;
  1329. }
  1331. STDMETHODIMP CMLFLink::ReleaseFont(HFONT hFont)
  1332. {
  1333.     ASSERT_THIS;
  1335.     HRESULT hr = S_OK;
  1337.     if (!m_pFontMappingCache || FAILED(hr = m_pFontMappingCache->UnlockEntry(hFont)))
  1338.     {
  1339.         // For non display DC
  1340.         if (::DeleteObject(hFont))
  1341.             hr = S_OK;
  1342.         else
  1343.             hr = E_FAIL; // Invalid hFont
  1344.     }
  1345.     return hr;
  1346. }
  1348. STDMETHODIMP CMLFLink::ResetFontMapping(void)
  1349. {
  1350.     ASSERT_THIS;
  1351.     HRESULT hr = S_OK;
  1353.     if (m_pFontMappingCache)
  1354.         hr =  m_pFontMappingCache->FlushEntries();
  1356.     return hr;
  1357. }
  1359. STDMETHODIMP CMLFLink2::ResetFontMapping(void)
  1360. {
  1361.     ASSERT_THIS;
  1362.     HRESULT hr = S_OK;
  1364.     if (m_pIMLFLnk)
  1365.         hr =  m_pIMLFLnk->ResetFontMapping();
  1367.     if (m_pFontMappingCache2)
  1368.         hr = (S_OK == m_pFontMappingCache2->EnsureFontTable(FALSE)? hr : E_FAIL);
  1370.     return hr;
  1371. }
  1373. HRESULT CMLFLink::MapFontCodePages(CFontMappingInfo& fm, PFNGETFACENAME pfnGetFaceName)
  1374. {
  1375.     HRESULT hr = MLSTR_E_FACEMAPPINGFAILURE;    
  1377.     for (fm.iCP = 0; fm.auCodePage[fm.iCP]; fm.iCP++)
  1378.     {
  1379.         fm.lfDestFont.lfCharSet = DEFAULT_CHARSET;
  1381.         hr = (this->*pfnGetFaceName)(fm);
  1383.         if (SUCCEEDED(hr))
  1384.         {
  1385.             LOGFONT lf = {0};
  1387.             // If face name is from registry or MIMEDB, we set charset to codepage charset.
  1388.             if (fm.lfDestFont.lfCharSet == DEFAULT_CHARSET)
  1389.             {
  1390.                 for (int iCharSet = 0; g_CharSetTransTable[iCharSet].uCodePage; iCharSet++)
  1391.                 {
  1392.                     if (fm.auCodePage[fm.iCP] == g_CharSetTransTable[iCharSet].uCodePage)
  1393.                     {
  1394.                         fm.lfDestFont.lfCharSet = (BYTE)g_CharSetTransTable[iCharSet].nCharSet;
  1395.                         break;
  1396.                     }
  1397.                 }
  1398.             }
  1400.             lf.lfCharSet = DEFAULT_CHARSET;
  1401.             MLStrCpyN(lf.lfFaceName, fm.szFaceName, LF_FACESIZE);
  1403.             // Retrieve LOGFONT from gotten facename
  1404.             fm.lfDestFont.lfFaceName[0] = _T('');
  1406.             if (!::EnumFontFamiliesEx(fm.hDC, &lf, MapFontEnumFontProc, (LPARAM)&fm.lfDestFont, 0))
  1407.                 hr = E_FAIL; // Invalid hDC
  1408.             else if (fm.lfDestFont.lfFaceName[0] == _T(''))
  1409.                 hr = MLSTR_E_FACEMAPPINGFAILURE;
  1410.         }
  1412.         if (SUCCEEDED(hr))
  1413.         {
  1414.             fm.lfDestFont.lfHeight      = fm.lfSrcFont.lfHeight;
  1415.             fm.lfDestFont.lfWidth       = fm.lfSrcFont.lfWidth;
  1416.             fm.lfDestFont.lfEscapement  = fm.lfSrcFont.lfEscapement;
  1417.             fm.lfDestFont.lfOrientation = fm.lfSrcFont.lfOrientation;
  1418.             fm.lfDestFont.lfWeight      = fm.lfSrcFont.lfWeight;
  1419.             fm.lfDestFont.lfItalic      = fm.lfSrcFont.lfItalic;
  1420.             fm.lfDestFont.lfUnderline   = fm.lfSrcFont.lfUnderline;
  1421.             fm.lfDestFont.lfStrikeOut   = fm.lfSrcFont.lfStrikeOut;
  1424.             HRESULT hrTemp = VerifyFaceMap(fm);
  1425.             if (hrTemp == MLSTR_E_FACEMAPPINGFAILURE && fm.lfDestFont.lfWidth)
  1426.             {
  1427.                 fm.lfDestFont.lfWidth = 0; // To recover non-scalable font
  1428.                 hr = VerifyFaceMap(fm);
  1429.             }
  1430.             else
  1431.             {
  1432.                 hr = hrTemp;
  1433.             }
  1434.         }
  1436.         if (hr != MLSTR_E_FACEMAPPINGFAILURE)
  1437.             break;
  1438.     }
  1440.     return hr;
  1441. }
  1442.     
  1443. int CALLBACK CMLFLink::MapFontEnumFontProc(const LOGFONT* plfFont, const TEXTMETRIC*, DWORD, LPARAM lParam)
  1444. {
  1445.     LOGFONT* plfDestFont = (LOGFONT*)lParam;
  1446.     
  1447.     if (!plfDestFont->lfFaceName[0] )
  1448.     {
  1449.         if (plfDestFont->lfCharSet != DEFAULT_CHARSET)
  1450.         {
  1451.             if (plfDestFont->lfCharSet == plfFont->lfCharSet)
  1452.                 *plfDestFont = *plfFont;
  1453.         }
  1454.         else
  1455.               *plfDestFont = *plfFont;
  1456.     }
  1458.     return TRUE;
  1459. }
  1461. HRESULT CMLFLink::GetFaceNameRegistry(CFontMappingInfo& fm)
  1462. {
  1463.     static const TCHAR szRootKey[]       = _T("Software\Microsoft\Internet Explorer");
  1464.     static const TCHAR szIntlKey[]       = _T("International\%d");
  1465.     static const TCHAR szPropFontName[]  = _T("IEPropFontName");
  1466.     static const TCHAR szFixedFontName[] = _T("IEFixedFontName");
  1468.     HRESULT hr = S_OK;
  1469.     HKEY hKeyRoot;
  1471.     if (::RegOpenKeyEx(HKEY_CURRENT_USER, szRootKey, 0, KEY_READ, &hKeyRoot) == ERROR_SUCCESS)
  1472.     {
  1473.         TCHAR szCodePageKey[ARRAYSIZE(szIntlKey) + 10];
  1474.         HKEY hKeySub;
  1476.         ::wsprintf(szCodePageKey, szIntlKey, fm.auCodePage[fm.iCP]);
  1477.         if (::RegOpenKeyEx(hKeyRoot, szCodePageKey, 0, KEY_READ, &hKeySub) == ERROR_SUCCESS)
  1478.         {
  1479.             const TCHAR* pszFontNameValue;
  1480.             DWORD dwType;
  1481.             DWORD dwSize = sizeof(fm.szFaceName);
  1483.             if ((fm.lfSrcFont.lfPitchAndFamily & 0x03) == FIXED_PITCH)
  1484.                 pszFontNameValue = szFixedFontName;
  1485.             else
  1486.                 pszFontNameValue = szPropFontName;
  1488.             if (::RegQueryValueEx(hKeySub, pszFontNameValue, 0, &dwType, (LPBYTE)fm.szFaceName, &dwSize) != ERROR_SUCCESS)
  1489.                 hr = MLSTR_E_FACEMAPPINGFAILURE;
  1491.             if (::RegCloseKey(hKeySub) != ERROR_SUCCESS && SUCCEEDED(hr))
  1492.                 hr = MLSTR_E_FACEMAPPINGFAILURE;
  1493.         }
  1494.         else
  1495.         {
  1496.             hr = MLSTR_E_FACEMAPPINGFAILURE;
  1497.         }
  1499.         if (::RegCloseKey(hKeyRoot) != ERROR_SUCCESS && SUCCEEDED(hr))
  1500.             hr = MLSTR_E_FACEMAPPINGFAILURE;
  1501.     }
  1502.     else
  1503.     {
  1504.         hr = MLSTR_E_FACEMAPPINGFAILURE;
  1505.     }
  1506.     return hr;
  1507. }
  1509. HRESULT CMLFLink::GetFaceNameGDI(CFontMappingInfo& fm)
  1510. {
  1511.     HRESULT hr = S_OK;
  1513.     for (int iCharSet = 0; g_CharSetTransTable[iCharSet].uCodePage; iCharSet++)
  1514.     {
  1515.         if (fm.auCodePage[fm.iCP] == g_CharSetTransTable[iCharSet].uCodePage)
  1516.             break;
  1517.     }
  1519.     if (g_CharSetTransTable[iCharSet].uCodePage)
  1520.     {
  1521.         ::memset(&fm.lfDestFont, 0, sizeof(fm.lfDestFont));
  1523.         // Specify font weight as NORMAL to avoid NT GDI font mapping bugs
  1524.         fm.lfDestFont.lfWeight = FW_NORMAL;
  1525.         fm.lfDestFont.lfCharSet = (BYTE)g_CharSetTransTable[iCharSet].nCharSet;
  1526.         hr = GetFaceNameRealizeFont(fm);
  1527.     }
  1528.     else
  1529.     {
  1530.         hr = E_FAIL; // Unknown code page
  1531.     }
  1533.     if (SUCCEEDED(hr))
  1534.     {
  1535.         // Height, CharSet, Pitch and Family
  1536.         fm.lfDestFont.lfHeight = fm.lfSrcFont.lfHeight;
  1537.         fm.lfDestFont.lfPitchAndFamily = fm.lfSrcFont.lfPitchAndFamily;
  1538.         hr = GetFaceNameRealizeFont(fm);
  1540.         if (FAILED(hr))
  1541.         {
  1542.             // CharSet, Pitch and Family
  1543.             fm.lfDestFont.lfHeight = 0;
  1544.             hr = GetFaceNameRealizeFont(fm);
  1545.         }
  1547.         if (FAILED(hr))
  1548.         {
  1549.             // CharSet and Pitch
  1550.             fm.lfDestFont.lfPitchAndFamily &= 0x03; // Pitch Mask
  1551.             hr = GetFaceNameRealizeFont(fm);
  1552.         }
  1554.         if (FAILED(hr))
  1555.         {
  1556.             // CharSet only
  1557.             fm.lfDestFont.lfPitchAndFamily = 0;
  1558.             hr = GetFaceNameRealizeFont(fm);
  1559.         }
  1560.     }
  1562.     return hr;
  1563. }
  1565. extern void BuildGlobalObjects(void);
  1567. HRESULT CMLFLink::GetFaceNameMIME(CFontMappingInfo& fm)
  1568. {
  1569.     HRESULT hr = E_FAIL;
  1570.     MIMECPINFO cpInfo;    
  1572.     if (fm.auCodePage[fm.iCP] == 936)
  1573.     {
  1574.         MLStrCpyN(fm.szFaceName, TEXT("SimSun"), LF_FACESIZE);
  1575.         return S_OK;
  1576.     }
  1578.     if (!g_pMimeDatabase)
  1579.         BuildGlobalObjects();
  1582.     if (NULL != g_pMimeDatabase)
  1583.     {
  1584.         if (SUCCEEDED(g_pMimeDatabase->GetCodePageInfo(fm.auCodePage[fm.iCP], 0x409, &cpInfo)))
  1585.         {
  1586.             TCHAR szFontFaceName[LF_FACESIZE];
  1587.             szFontFaceName[0] = 0;
  1589.             if ((fm.lfSrcFont.lfPitchAndFamily & 0x03) == FIXED_PITCH && cpInfo.wszFixedWidthFont[0])
  1590.             {
  1591. #ifdef UNICODE
  1592.                 MLStrCpyNW(szFontFaceName, cpInfo.wszFixedWidthFont, LF_FACESIZE);
  1593. #else
  1594.                 WideCharToMultiByte(CP_ACP, 0, cpInfo.wszFixedWidthFont, -1, szFontFaceName, LF_FACESIZE, NULL, NULL);
  1595. #endif
  1596.             }
  1597.             else
  1598.                 if (cpInfo.wszProportionalFont[0])
  1599.                 {
  1600. #ifdef UNICODE
  1601.                     MLStrCpyNW(szFontFaceName, cpInfo.wszProportionalFont, LF_FACESIZE);
  1602. #else
  1603.                     WideCharToMultiByte(CP_ACP, 0, cpInfo.wszProportionalFont, -1, szFontFaceName, LF_FACESIZE, NULL, NULL);
  1604. #endif
  1605.                 }
  1607.             if (szFontFaceName[0])
  1608.             {
  1609.                 MLStrCpyN(fm.szFaceName, szFontFaceName, LF_FACESIZE);
  1610.                 hr = S_OK;
  1611.             }
  1612.         }
  1613.         else
  1614.             hr = MLSTR_E_FACEMAPPINGFAILURE;
  1615.     }
  1617.     return hr;
  1618. }
  1620. HRESULT CMLFLink::GetFaceNameRealizeFont(CFontMappingInfo& fm)
  1621. {
  1622.     HRESULT hr = S_OK;
  1623.     HFONT hFont = NULL;
  1624.     HFONT hOldFont;
  1625.     DWORD dwFontCodePages;
  1627.     // First let's get a facename based on the given lfDestFont
  1628.     // Then verify if the font of the found facename has the code pages we want.
  1630.     hFont = ::CreateFontIndirect(&fm.lfDestFont);
  1631.     if (!hFont)
  1632.         hr = E_FAIL; // Out of memory or GDI resource
  1634.     if (SUCCEEDED(hr))
  1635.     {
  1636.         hOldFont = (HFONT)::SelectObject(fm.hDC, hFont);
  1637.         if (!hOldFont)
  1638.             hr = E_FAIL; // Out of memory or GDI resource
  1639.     }
  1641.     if (SUCCEEDED(hr))
  1642.     {
  1643.         if (!::GetTextFace(fm.hDC, ARRAYSIZE(fm.szFaceName), fm.szFaceName))
  1644.             hr = E_FAIL; // Out of memory or GDI resource
  1646.         if (!::SelectObject(fm.hDC, hOldFont) && SUCCEEDED(hr))
  1647.             hr = E_FAIL; // Out of memory or GDI resource
  1648.     }
  1650.     if (hFont)
  1651.         ::DeleteObject(hFont);
  1653.     if (SUCCEEDED(hr))
  1654.     {
  1655.         LOGFONT lfTemp;
  1657.         lfTemp = fm.lfDestFont;
  1658.         _tcsncpy(lfTemp.lfFaceName, fm.szFaceName, ARRAYSIZE(lfTemp.lfFaceName));
  1660.         hFont = ::CreateFontIndirect(&lfTemp);
  1661.         if (!hFont)
  1662.             hr = E_FAIL; // Out of memory or GDI resource
  1664.         if (SUCCEEDED(hr = GetFontCodePages(fm.hDC, hFont, &dwFontCodePages)) && !(dwFontCodePages & fm.adwCodePages[fm.iCP]))
  1665.                 hr = MLSTR_E_FACEMAPPINGFAILURE;
  1667.         if (hFont)
  1668.             ::DeleteObject(hFont);
  1669.     }
  1671.     return hr;
  1672. }
  1674. HRESULT CMLFLink::VerifyFaceMap(CFontMappingInfo& fm)
  1675. {
  1676.     HRESULT hr = S_OK;
  1677.     HFONT hOldFont;
  1679.     if (fm.hDestFont)
  1680.         ::DeleteObject(fm.hDestFont);
  1682.     fm.hDestFont = ::CreateFontIndirect(&fm.lfDestFont);
  1683.     if (!fm.hDestFont)
  1684.         hr = E_FAIL; // Out of memory or GDI resource
  1686.     if (SUCCEEDED(hr))
  1687.     {
  1688.         hOldFont = (HFONT)::SelectObject(fm.hDC, fm.hDestFont);
  1689.         if (!hOldFont)
  1690.             hr = E_FAIL; // Out of memory or GDI resource
  1691.     }
  1693.     if (SUCCEEDED(hr))
  1694.     {
  1695.         TCHAR szFaceName[LF_FACESIZE];
  1697.         if (!::GetTextFace(fm.hDC, ARRAYSIZE(szFaceName), szFaceName))
  1698.             hr = E_FAIL; // Out of memory or GDI resource
  1700.         if (SUCCEEDED(hr))
  1701.         {
  1702.             int nRet = ::CompareString(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, fm.lfDestFont.lfFaceName, -1, szFaceName, -1);
  1703.             if (!nRet)
  1704.                 hr = E_FAIL; // Unexpected error
  1705.             else if (nRet != 2) // Not Equal
  1706.                 hr = MLSTR_E_FACEMAPPINGFAILURE;
  1707.         }
  1709.         if (!::SelectObject(fm.hDC, hOldFont) && SUCCEEDED(hr))
  1710.             hr = E_FAIL; // Out of memory or GDI resource
  1711.     }
  1713.     return hr;
  1714. }
  1716. /////////////////////////////////////////////////////////////////////////////
  1717. // CMLFLink::CFontMappingCache
  1719. CMLFLink::CFontMappingCache::CFontMappingCache(void) :
  1720.     m_pEntries(NULL),
  1721.     m_pFree(NULL),
  1722.     m_cEntries(0)
  1723. {
  1724.     ::InitializeCriticalSection(&m_cs);
  1725. }
  1727. CMLFLink::CFontMappingCache::~CFontMappingCache(void)
  1728. {
  1729.     FlushEntries();
  1730.     DeleteCriticalSection(&m_cs);
  1731. }
  1733. HRESULT CMLFLink::CFontMappingCache::FindEntry(UINT uCodePage, const LOGFONT& lfSrcFont, HFONT* phDestFont)
  1734. {
  1735.     HRESULT hr = S_FALSE;
  1737.     ::EnterCriticalSection(&m_cs);
  1739.     if (m_pEntries)
  1740.     {
  1741.         CFontMappingCacheEntry* pEntry = m_pEntries;
  1743.         while ((pEntry = pEntry->m_pPrev) != m_pEntries)
  1744.         {
  1745.             if (uCodePage == pEntry->m_uSrcCodePage &&
  1746.                 lfSrcFont.lfPitchAndFamily == pEntry->m_bSrcPitchAndFamily &&
  1747.                 lfSrcFont.lfHeight == pEntry->m_lSrcHeight &&
  1748.                 lfSrcFont.lfWidth == pEntry->m_lSrcWidth &&
  1749.                 lfSrcFont.lfEscapement == pEntry->m_lSrcEscapement &&
  1750.                 lfSrcFont.lfOrientation == pEntry->m_lSrcOrientation &&
  1751.                 lfSrcFont.lfWeight == pEntry->m_lSrcWeight &&
  1752.                 lfSrcFont.lfItalic == pEntry->m_bSrcItalic &&
  1753.                 lfSrcFont.lfUnderline == pEntry->m_bSrcUnderline &&
  1754.                 lfSrcFont.lfStrikeOut == pEntry->m_bSrcStrikeOut)
  1755.             {
  1756.                 int nRet = ::CompareString(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, lfSrcFont.lfFaceName, -1, pEntry->m_szSrcFaceName, -1);
  1757.                 if (!nRet)
  1758.                 {
  1759.                     hr = E_FAIL; // Unexpected error
  1760.                     break;
  1761.                 }
  1762.                 else if (nRet == 2) // Equal
  1763.                 {
  1764.                     if (phDestFont)
  1765.                         *phDestFont = pEntry->m_hDestFont;
  1766.                     pEntry->m_nLockCount++;
  1767.                     hr = S_OK;
  1768.                     break;
  1769.                 }
  1770.             }
  1771.         }
  1772.     }
  1774.     ::LeaveCriticalSection(&m_cs);
  1776.     if (phDestFont && hr != S_OK)
  1777.         *phDestFont = NULL;
  1779.     return hr;
  1780. }
  1782. HRESULT CMLFLink::CFontMappingCache::UnlockEntry(HFONT hDestFont)
  1783. {
  1784.     HRESULT hr = E_FAIL; // hDestFont is not found in the cache
  1786.     ::EnterCriticalSection(&m_cs);
  1788.     if (m_pEntries)
  1789.     {
  1790.         CFontMappingCacheEntry* pEntry = m_pEntries;
  1792.         while ((pEntry = pEntry->m_pPrev) != m_pEntries)
  1793.         {
  1794.             if (hDestFont == pEntry->m_hDestFont)
  1795.             {
  1796.                 if (pEntry->m_nLockCount - 1 >= 0)
  1797.                 {
  1798.                     pEntry->m_nLockCount--;
  1799.                     hr = S_OK;
  1800.                 }
  1801.                 break;
  1802.             }
  1803.         }
  1804.     }
  1806.     ::LeaveCriticalSection(&m_cs);
  1808.     return hr;
  1809. }
  1811. HRESULT CMLFLink::CFontMappingCache::AddEntry(UINT uCodePage, const LOGFONT& lfSrcFont, HFONT hDestFont)
  1812. {
  1813.     HRESULT hr = S_OK;
  1815.     ::EnterCriticalSection(&m_cs);
  1817.     if (!m_pEntries) // Need to allocate all the entries
  1818.     {
  1819.         CFontMappingCacheEntry* pEntries;
  1821.         pEntries = new CFontMappingCacheEntry[NUMFONTMAPENTRIES + 1]; // +1 for sentinel
  1823.         if (pEntries)
  1824.         {
  1825.             // Init sentinel
  1826.             pEntries[0].m_pPrev = &pEntries[0];
  1827.             pEntries[0].m_pNext = &pEntries[0];
  1829.             // Init free entries
  1830.             for (int n = 0; n < NUMFONTMAPENTRIES; n++)
  1831.             {
  1832.                 const nEnt = n + 1; // + 1 for sentinel
  1834.                 if (n < NUMFONTMAPENTRIES - 1)
  1835.                     pEntries[nEnt].m_pNext = &pEntries[nEnt + 1];
  1836.                 else
  1837.                     pEntries[nEnt].m_pNext = NULL;
  1838.             }
  1840.             m_pEntries = &pEntries[0];
  1841.             m_pFree = &pEntries[1];
  1842.         }
  1843.         else
  1844.         {
  1845.             hr = E_OUTOFMEMORY;
  1846.         }
  1847.     }
  1849.     if (SUCCEEDED(hr) && !m_pFree) // Need to delete oldest entry
  1850.     {
  1851.         CFontMappingCacheEntry* pOldestEntry = m_pEntries->m_pPrev;
  1853.         while (pOldestEntry->m_nLockCount > 0 && pOldestEntry != m_pEntries) // Entry is locked
  1854.             pOldestEntry = pOldestEntry->m_pPrev;
  1856.         if (pOldestEntry != m_pEntries)
  1857.         {
  1858.             if (pOldestEntry->m_hDestFont)
  1859.                 ::DeleteObject(pOldestEntry->m_hDestFont);
  1861.             // Delete it from m_pEntries list
  1862.             pOldestEntry->m_pPrev->m_pNext = pOldestEntry->m_pNext;
  1863.             pOldestEntry->m_pNext->m_pPrev = pOldestEntry->m_pPrev;
  1865.             // Insert it into m_pFree list
  1866.             pOldestEntry->m_pNext = m_pFree;
  1867.             m_pFree = pOldestEntry;
  1868.         }
  1869.         else // No entry available
  1870.         {
  1871.             hr = E_FAIL; // Out of cache entries
  1872.         }
  1873.     }
  1875.     if (SUCCEEDED(hr)) // Create new entry and fill it
  1876.     {
  1877.         CFontMappingCacheEntry* pNewEntry;
  1879.         // Delete it from m_pFree list
  1880.         pNewEntry = m_pFree; // shouldn't be NULL
  1881.         m_pFree = pNewEntry->m_pNext;
  1883.         // Insert it into m_pEntries list
  1884.         pNewEntry->m_pNext = m_pEntries->m_pNext;
  1885.         pNewEntry->m_pPrev = m_pEntries;
  1886.         m_pEntries->m_pNext->m_pPrev = pNewEntry;
  1887.         m_pEntries->m_pNext = pNewEntry;
  1889.         // Fill it
  1890.         pNewEntry->m_nLockCount = 1;
  1891.         pNewEntry->m_uSrcCodePage = uCodePage;
  1892.         pNewEntry->m_lSrcHeight = lfSrcFont.lfHeight;
  1893.         pNewEntry->m_lSrcWidth = lfSrcFont.lfWidth;
  1894.         pNewEntry->m_lSrcEscapement = lfSrcFont.lfEscapement;
  1895.         pNewEntry->m_lSrcOrientation = lfSrcFont.lfOrientation;
  1896.         pNewEntry->m_lSrcWeight = lfSrcFont.lfWeight;
  1897.         pNewEntry->m_bSrcItalic = lfSrcFont.lfItalic;
  1898.         pNewEntry->m_bSrcUnderline = lfSrcFont.lfUnderline;
  1899.         pNewEntry->m_bSrcStrikeOut = lfSrcFont.lfStrikeOut;
  1900.         pNewEntry->m_bSrcPitchAndFamily = lfSrcFont.lfPitchAndFamily;
  1901.         _tcsncpy(pNewEntry->m_szSrcFaceName, lfSrcFont.lfFaceName, ARRAYSIZE(pNewEntry->m_szSrcFaceName));
  1902.         pNewEntry->m_hDestFont = hDestFont;
  1903.     }
  1905.     ::LeaveCriticalSection(&m_cs);
  1907.     return hr;
  1908. }
  1910. HRESULT CMLFLink::CFontMappingCache::FlushEntries(void)
  1911. {
  1912.     ::EnterCriticalSection(&m_cs);
  1914.     if (m_pEntries)
  1915.     {
  1916.         CFontMappingCacheEntry* pEntry = m_pEntries;
  1918.         while ((pEntry = pEntry->m_pPrev) != m_pEntries)
  1919.         {
  1920.             if (pEntry->m_hDestFont)
  1921.                 ::DeleteObject(pEntry->m_hDestFont);
  1922.         }
  1924.         delete[] m_pEntries;
  1926.         m_pEntries = NULL;
  1927.         m_cEntries = 0;
  1928.     }
  1930.     ::LeaveCriticalSection(&m_cs);
  1932.     return S_OK;
  1933. }
  1935. /////////////////////////////////////////////////////////////////////////////
  1936. // CMLFLink::CCodePagesCache
  1938. CMLFLink::CCodePagesCache::CCodePagesCache(void) :
  1939.     m_pbBuf(NULL)
  1940. {
  1941.     ::InitializeCriticalSection(&m_cs);
  1942. }
  1944. CMLFLink::CCodePagesCache::~CCodePagesCache(void)
  1945. {
  1946.     DeleteCriticalSection(&m_cs);
  1947. }
  1949. HRESULT CMLFLink::CCodePagesCache::RealLoad(void)
  1950. {
  1951.     HRESULT hr = S_OK;
  1953.     ::EnterCriticalSection(&m_cs);
  1955.     if (!m_pbBuf)
  1956.     {
  1957.         HRSRC hrCodePages;
  1958.         HGLOBAL hgCodePages;
  1960.         if (SUCCEEDED(hr))
  1961.         {
  1962.             hrCodePages = ::FindResource(g_hInst, MAKEINTRESOURCE(IDR_CODEPAGES), _T("CODEPAGES"));
  1963.             if (!hrCodePages)
  1964.                 hr = E_FAIL; // Build error?
  1965.         }
  1966.         if (SUCCEEDED(hr))
  1967.         {
  1968.             hgCodePages = ::LoadResource(g_hInst, hrCodePages);
  1969.             if (!hgCodePages)
  1970.                 hr = E_FAIL; // Unexpected error
  1971.         }
  1972.         if (SUCCEEDED(hr))
  1973.         {
  1974.             m_pbBuf = (BYTE*)::LockResource(hgCodePages);
  1975.             if (!m_pbBuf)
  1976.                 hr = E_FAIL; // Unexpected error
  1977.         }
  1978.     }
  1980.     ::LeaveCriticalSection(&m_cs);
  1982.     return hr;
  1983. }
  1985. extern "C" HRESULT GetGlobalFontLinkObject(IMLangFontLink **ppMLFontLink)
  1986. {
  1987.     HRESULT hr = E_INVALIDARG;
  1989.     if (NULL != ppMLFontLink)
  1990.     {
  1991.         if (NULL == g_pMLFLink)
  1992.         {
  1993.             EnterCriticalSection(&g_cs);
  1994.             if (NULL == g_pMLFLink)
  1995.                 CComCreator< CComPolyObject< CMLFLink > >::CreateInstance(NULL, IID_IMLangFontLink, (void **)&g_pMLFLink);
  1996.             LeaveCriticalSection(&g_cs);
  1997.         }
  1998.         *ppMLFontLink = g_pMLFLink;
  1999.         if (g_pMLFLink)
  2000.         {
  2001.             g_pMLFLink->AddRef();
  2002.             hr = S_OK;
  2003.         }
  2004.         else
  2005.             hr = E_FAIL;
  2006.     }
  2007.     return hr;
  2008. }
  2010. HRESULT CMLFLink2::CFontMappingCache2::MapFontFromCMAP(HDC hDC, WCHAR wchar, HFONT hSrcFont, HFONT *phDestFont)
  2011. {
  2012.     BOOL    bFont = FALSE;
  2013.     HRESULT hr = E_FAIL;
  2014.     int     i,j,k;
  2015.     LOGFONT LogFont;
  2017.     if (!phDestFont)
  2018.         return E_INVALIDARG;
  2020.     if (!GetObject(hSrcFont, sizeof(LOGFONT), &LogFont))
  2021.         return hr;
  2023.     if (!g_pfont_table || !g_pfont_table[0].szFaceName[0])
  2024.     {        
  2025.         if (FAILED(LoadFontDataFile()))
  2026.         {
  2027.             return hr;
  2028.         }
  2029.     }
  2031.     i=0;
  2032.     j=ARRAYSIZE(g_urange_table);
  2033.     k = j/2;
  2035.     while (i<=j)
  2036.     {
  2038.         if (wchar >= g_urange_table[k].wcFrom && wchar <= g_urange_table[k].wcTo)
  2039.            break;
  2040.         else
  2041.            if (wchar < g_urange_table[k].wcFrom)
  2042.            {
  2043.                j = k -1;
  2044.            }
  2045.            else
  2046.            {
  2047.                i = k + 1;
  2048.            }
  2049.            k = (i+j)/2;
  2050.     }
  2052.     if (i<=j && g_urange_table[k].nFonts)
  2053.     {
  2054.         TCHAR szFaceName[LF_FACESIZE];
  2055.         GetTextFace(hDC, LF_FACESIZE, szFaceName);
  2057.         // Check if it supports the character
  2058.         for (i=0; i<g_urange_table[k].nFonts; i++)
  2059.         {
  2060.             if (!MLStrCmpI(szFaceName,g_pfont_table[*(g_urange_table[k].pFontIndex+i)].lf.lfFaceName))
  2061.                 break;
  2062.         }
  2064.         // Current font doesn't support this character
  2065.         if (i == g_urange_table[k].nFonts)
  2066.         {
  2067.             for (i=0; i<g_urange_table[k].nFonts; i++)
  2068.             {
  2069.                 if (LogFont.lfCharSet == g_pfont_table[*(g_urange_table[k].pFontIndex+i)].lf.lfCharSet)
  2070.                     break;
  2071.             }
  2073.             // No font available for current CharSet, then return the first one in the list            
  2074.             if (i >= g_urange_table[k].nFonts)
  2075.             {
  2076.                 i = fetchCharSet((BYTE *) &(LogFont.lfCharSet), k);
  2077.             }
  2079.             MLStrCpyN(LogFont.lfFaceName, g_pfont_table[*(g_urange_table[k].pFontIndex+i)].lf.lfFaceName, LF_FACESIZE);
  2080.         }
  2082.         if (i < g_urange_table[k].nFonts)
  2083.         {
  2084.             MLStrCpyN(LogFont.lfFaceName, g_pfont_table[*(g_urange_table[k].pFontIndex+i)].lf.lfFaceName, LF_FACESIZE);
  2085.         }
  2086.         
  2087.         bFont = TRUE;
  2088.     } 
  2090.     if (bFont && (*phDestFont = CreateFontIndirect(&LogFont)))
  2091.     {
  2092.         hr = S_OK;       
  2093.     }
  2094.     else
  2095.     {
  2096.         *phDestFont = NULL;
  2097.     }
  2100.     return hr;
  2101. }
  2105. HRESULT CMLFLink2::CFontMappingCache2::UnicodeRanges(
  2106.     LPTSTR  szFont,
  2107.     UINT    *puiRanges, 
  2108.     UNICODERANGE* pURanges
  2109.     )
  2111. {
  2112.     HRESULT hr = E_FAIL;
  2113.     UINT    nURange = 0;
  2114.     DWORD   cmap    = 0;
  2115.     DWORD   name    = 0;
  2116.     HANDLE  hTTF;    
  2117.     TCHAR   szFontPath[MAX_PATH];
  2118.     static TCHAR s_szFontDir[MAX_PATH] = {0};
  2121.     HANDLE  hTTFMap;
  2122.     DWORD   dwFileSize;
  2123.     LPVOID  lpvFile;
  2124.     LPBYTE  lp, lp1, lp2;
  2125.     DWORD   Num;
  2126.     WORD    i, j, Len;
  2128.     if (!s_szFontDir[0])
  2129.     {
  2130.         MLGetWindowsDirectory(s_szFontDir, MAX_PATH);
  2131.         MLPathCombine(s_szFontDir, s_szFontDir, FONT_FOLDER);
  2132.     }
  2133.     MLPathCombine(szFontPath, s_szFontDir, szFont);
  2135.     hTTF = CreateFile(  szFontPath,             // pointer to name of the file
  2136.                         GENERIC_READ,           // access (read-write) mode
  2137.                         FILE_SHARE_READ,        // share mode
  2138.                         NULL,                   // pointer to security attributes
  2139.                         OPEN_EXISTING,          // how to create
  2140.                         FILE_ATTRIBUTE_NORMAL,  // file attributes
  2141.                         NULL);                  // handle to file with attributes to copy;
  2143.     if (INVALID_HANDLE_VALUE == hTTF)
  2144.         return hr;
  2146.     dwFileSize = GetFileSize(hTTF, NULL);
  2148.     hTTFMap = CreateFileMapping(
  2149.                   hTTF,
  2150.                   NULL,
  2151.                   PAGE_READONLY,
  2152.                   0,
  2153.                   dwFileSize,
  2154.                   NULL
  2155.               );
  2157.     if(hTTFMap == NULL)
  2158.     {
  2159.         goto CloseHandle0;
  2160.     }
  2162.     lpvFile = MapViewOfFile(
  2163.                   hTTFMap,
  2164.                   FILE_MAP_READ,
  2165.                   0,
  2166.                   0,
  2167.                   0
  2168.               );
  2170.     if(lpvFile == NULL)
  2171.     {
  2172.         goto CloseHandle;
  2173.     }
  2175.     lp = (LPBYTE)lpvFile;
  2177.     // Font table name uses ASCII
  2178.     if(strncmp(((TTC_HEAD*)lp)->TTCTag, "ttcf", 4) == 0)   // TTC format
  2179.     {
  2180.         lp += FOUR_BYTE_NUM(((TTC_HEAD*)lp)->OffsetTTF1);  // points to first TTF
  2181.     }
  2183.     Num = TWO_BYTE_NUM(((TTF_HEAD*)lp)->NumTables);        // Number of Tables
  2184.     lp += sizeof(TTF_HEAD);
  2186.     for(i = 0; i < Num; i++)   // go thru all tables to find cmap and name
  2187.     {
  2188.         if(strncmp( ((TABLE_DIR*)lp)->Tag, "cmap", 4) == 0)
  2189.         {
  2190.             cmap = FOUR_BYTE_NUM(((TABLE_DIR*)lp)->Offset);
  2191.             if (name) break;
  2192.         }
  2193.         else if(strncmp( ((TABLE_DIR*)lp)->Tag, "name", 4) == 0)
  2194.         {
  2195.             name = FOUR_BYTE_NUM(((TABLE_DIR*)lp)->Offset);
  2196.             if (cmap) break;
  2197.         }
  2198.         lp += sizeof(TABLE_DIR);
  2199.      }
  2201.     if((!cmap) || (!name))    // Can't find cmap or name
  2202.     {
  2203.         goto CloseHandle;
  2204.     }
  2206.     // Read thru all name records
  2207.     // to see if font subfamily name is "Regular"
  2209.     lp  = (LPBYTE)lpvFile + name;                   // point to name table
  2210.     Num = TWO_BYTE_NUM(((NAME_TABLE*)lp)->NumRec);  // # of name record
  2211.     lp1 = lp  + sizeof(NAME_TABLE);                 // point to name record
  2213.     for(i = 0; i < Num; i++)
  2214.     {
  2215.         if(FONT_SUBFAMILY_NAME == TWO_BYTE_NUM(((NAME_RECORD*)lp1)->NameID))
  2216.         {
  2217.             lp2 = lp +                              // point to string store
  2218.                   TWO_BYTE_NUM(((NAME_TABLE* )lp )->Offset) +
  2219.                   TWO_BYTE_NUM(((NAME_RECORD*)lp1)->Offset);
  2221.             Len = TWO_BYTE_NUM(((NAME_RECORD*)lp1)->Length);
  2223.             if(((MICROSOFT_PLATFORM == TWO_BYTE_NUM(((NAME_RECORD*)lp1)->Platform)) && 
  2224.                 (UNICODE_INDEXING == TWO_BYTE_NUM(((NAME_RECORD*)lp1)->Encoding)))  ||
  2225.                ((APPLE_UNICODE_PLATFORM == TWO_BYTE_NUM(((NAME_RECORD*)lp1)->Platform)) && 
  2226.                 (APPLE_UNICODE_INDEXING == TWO_BYTE_NUM(((NAME_RECORD*)lp1)->Encoding))))  
  2227.             {
  2228.                 Len >>= 1;
  2229.                 const char *pStr = szRegular;
  2231.                 if (Len == sizeof(szNormal) -1)
  2232.                     pStr = szNormal;
  2233.                 else 
  2234.                     if (Len != sizeof(szRegular)-1)
  2235.                     {
  2236.                         lp1 += sizeof(NAME_RECORD);
  2237.                         continue;
  2238.                     }
  2240.                 while(--Len > 0)
  2241.                 {
  2242.                     if(*(lp2+(Len<<1)+1) != pStr[Len])
  2243.                     break;
  2244.                 }
  2246.                 if (!Len)
  2247.                     break;
  2248.                 else
  2249.                 {
  2250.                     lp1 += sizeof(NAME_RECORD);
  2251.                     continue;
  2252.                 }
  2253.             }
  2254.             else
  2255.             {
  2256.                 if(strncmp((char*)lp2, szRegular, sizeof(szRegular)-1) != 0 && 
  2257.                    strncmp((char*)lp2, szNormal, sizeof(szNormal)-1) != 0)
  2258.                 {
  2259.                     lp1 += sizeof(NAME_RECORD);
  2260.                     continue;
  2261.                 }
  2262.                 else
  2263.                     break;
  2264.             }
  2265.         }
  2266.         lp1 += sizeof(NAME_RECORD);
  2267.     }
  2269.     // If no regular font, exit
  2270.     if (i == Num)
  2271.         goto CloseHandle;
  2273.     // all non-regular fonts have already been eliminated
  2274.     lp1  = (LPBYTE)lpvFile + cmap;                     // point to cmap table
  2275.     Num  = TWO_BYTE_NUM(((CMAP_HEAD*)lp1)->NumTables);
  2276.     lp1 += sizeof(CMAP_HEAD);
  2278.     while(Num >0)
  2279.     {
  2281.         if(TWO_BYTE_NUM(((CMAP_TABLE*)lp1)->Platform) == MICROSOFT_PLATFORM && 
  2282.            (TWO_BYTE_NUM(((CMAP_TABLE*)lp1)->Encoding) == UNICODE_INDEXING ||
  2283.            TWO_BYTE_NUM(((CMAP_TABLE*)lp1)->Encoding) == UNICODE_SYMBOL_INDEXING))
  2284.         {
  2285.             lp = (LPBYTE)lpvFile
  2286.                  + cmap
  2287.                  + FOUR_BYTE_NUM(((CMAP_TABLE*)lp1)->Offset);
  2289.             if(TWO_BYTE_NUM(((CMAP_FORMAT*)lp)->Format) == CMAP_FORMAT_FOUR)
  2290.             {
  2291.                 break;
  2292.             }
  2293.         }
  2294.         Num--;
  2295.         lp1 += sizeof(CMAP_TABLE);
  2296.     }
  2298.     if(Num == 0)                            // can't find Platform:3/Encoding:1 (Unicode)
  2299.         goto CloseHandle;
  2301.     Num  = TWO_BYTE_NUM(((CMAP_FORMAT*)lp)->SegCountX2);
  2302.     lp2  = lp  + sizeof(CMAP_FORMAT);       // lp2 -> first WCHAR of wcTo
  2303.     lp1  = lp2 + Num + 2;                   // lp1 -> first WCHAR of wcFrom
  2305.     Num /= 2;
  2307.     if (pURanges == NULL)
  2308.     {
  2309.         *puiRanges = Num;
  2310.     }
  2311.     else
  2312.     {
  2313.         if (Num > *puiRanges)
  2314.             Num = *puiRanges;
  2315.         else
  2316.             *puiRanges = Num;
  2318.         for(i=0, j=0; i < Num; i++, j++, j++)
  2319.         {
  2320.             pURanges[i].wcFrom = TWO_BYTE_NUM((lp1+j));
  2321.             pURanges[i].wcTo   = TWO_BYTE_NUM((lp2+j));
  2322.         }
  2323.     }
  2325.     hr = S_OK;
  2327. CloseHandle:
  2328.     UnmapViewOfFile(lpvFile);
  2329. CloseHandle0:
  2330.     CloseHandle(hTTFMap);
  2331.     CloseHandle(hTTF);
  2333.     return hr;
  2334. }
  2336. int CMLFLink2::CFontMappingCache2::fetchCharSet(BYTE *pCharset, int iURange)
  2337. {
  2338.     int i,j;
  2340.     //Check if current charset valid for the font
  2341.     for (i=0; i<g_urange_table[iURange].nFonts; i++)
  2342.     {
  2343.         for (j=0;(j<32) && g_CharSetTransTable[j].uCodePage;j++)
  2344.         {
  2345.             if (g_pfont_table[*(g_urange_table[iURange].pFontIndex+i)].dwCodePages[0] & g_CharSetTransTable[j].dwCodePages)
  2346.                 if (*pCharset == g_CharSetTransTable[j].nCharSet)
  2347.                     return i;
  2348.         }
  2349.     }
  2351.     //If invalid, fetch first valid one.
  2352.     for (i=0;(i<32) && g_CharSetTransTable[i].uCodePage;i++)
  2353.     {
  2354.         if (g_pfont_table[*(g_urange_table[iURange].pFontIndex)].dwCodePages[0] & g_CharSetTransTable[i].dwCodePages)
  2355.         {
  2356.            *pCharset = (BYTE)g_CharSetTransTable[i].nCharSet;
  2357.            break;
  2358.         }
  2359.     }
  2361.     return 0;
  2362. }
  2365. BOOL CMLFLink2::CFontMappingCache2::GetNonCpFontUnicodeRanges(TCHAR *szFontName, int iFontIndex)
  2366. {
  2367.     LONG    nURange = 0;
  2368.     DWORD   cmap    = 0;
  2369.     DWORD   name    = 0;
  2370.     DWORD   os2     = 0;
  2372.     HANDLE  hTTFMap;
  2373.     DWORD   dwFileSize;
  2374.     LPVOID  lpvFile;
  2375.     LPBYTE  lp, lp1, lp2;
  2376.     DWORD   Num;
  2377.     int     i, j, k, m;
  2378.     WORD    Len;
  2379.     HANDLE  hTTF;
  2380.     BOOL    bRet = FALSE;
  2383.     hTTF = CreateFile(  szFontName,             // pointer to name of the file
  2384.                         GENERIC_READ,           // access (read-write) mode
  2385.                         FILE_SHARE_READ,        // share mode
  2386.                         NULL,                   // pointer to security attributes
  2387.                         OPEN_EXISTING,          // how to create
  2388.                         FILE_ATTRIBUTE_NORMAL,  // file attributes
  2389.                         NULL);                  // handle to file with attributes to copy;
  2391.     if (hTTF == INVALID_HANDLE_VALUE)
  2392.         return FALSE;
  2394.     dwFileSize = GetFileSize(hTTF, NULL);
  2396.     hTTFMap = CreateFileMapping(
  2397.                   hTTF,
  2398.                   NULL,
  2399.                   PAGE_READONLY,
  2400.                   0,
  2401.                   dwFileSize,
  2402.                   NULL
  2403.               );
  2405.     if(hTTFMap == NULL)
  2406.     {
  2407.         goto CloseHandle01;
  2408.     }
  2410.     lpvFile = MapViewOfFile(
  2411.                   hTTFMap,
  2412.                   FILE_MAP_READ,
  2413.                   0,
  2414.                   0,
  2415.                   0
  2416.               );
  2418.     if(lpvFile == NULL)
  2419.     {
  2420.         goto CloseHandle00;
  2421.     }
  2423.     lp = (LPBYTE)lpvFile;
  2425.     if(strncmp(((TTC_HEAD*)lp)->TTCTag, "ttcf", 4) == 0)   // TTC format
  2426.     {
  2427.         lp += FOUR_BYTE_NUM(((TTC_HEAD*)lp)->OffsetTTF1);  // points to first TTF
  2428.     }
  2430.     Num = TWO_BYTE_NUM(((TTF_HEAD*)lp)->NumTables);        // Number of Tables
  2431.     {
  2432.       // if SearchRange != (Maximum power of 2 <= Num)*16,
  2433.       // then this is not a TTF file
  2434.       DWORD  wTmp = 1;
  2436.       while(wTmp <= Num)
  2437.       {
  2438.         wTmp <<= 1;
  2439.       }
  2440.       wTmp <<= 3;          // (wTmp/2)*16
  2442.       if(wTmp != (DWORD)TWO_BYTE_NUM(((TTF_HEAD*)lp)->SearchRange))
  2443.       {
  2444.         goto CloseHandle00;
  2445.       }
  2447.       // if RangeShift != (Num*16) - SearchRange,
  2448.       // then this is not a TTF file
  2449.       wTmp = (Num<<4) - wTmp;
  2450.       if(wTmp != (DWORD)TWO_BYTE_NUM(((TTF_HEAD*)lp)->RangeShift))
  2451.       {
  2452.         goto CloseHandle00;
  2453.       }
  2454.     }
  2456.     lp += sizeof(TTF_HEAD);
  2458.     for(i = 0; i < (int)Num; i++)   // go thru all tables to find cmap and name
  2459.     {
  2460.         if(strncmp( ((TABLE_DIR*)lp)->Tag, "cmap", 4) == 0)
  2461.         {
  2462.             cmap = FOUR_BYTE_NUM(((TABLE_DIR*)lp)->Offset);
  2463.             if (name && os2) break;
  2464.         }
  2465.         else if(strncmp( ((TABLE_DIR*)lp)->Tag, "name", 4) == 0)
  2466.         {
  2467.             name = FOUR_BYTE_NUM(((TABLE_DIR*)lp)->Offset);
  2468.             if (cmap && os2) break;
  2469.         }
  2470.         else if(strncmp( ((TABLE_DIR*)lp)->Tag, "OS/2", 4) == 0)
  2471.         {
  2472.             os2 = FOUR_BYTE_NUM(((TABLE_DIR*)lp)->Offset);
  2473.             if (cmap && name) break;
  2474.         }
  2476.         lp += sizeof(TABLE_DIR);
  2477.      }
  2479.     if((!cmap) || (!name) || (!os2))    // Can't find cmap or name
  2480.     {
  2481.         goto CloseHandle00;
  2482.     }
  2484.     // Read thru all name records
  2485.     // to see if font subfamily name is "Regular"
  2487.     lp  = (LPBYTE)lpvFile + name;                   // point to name table
  2488.     Num = TWO_BYTE_NUM(((NAME_TABLE*)lp)->NumRec);  // # of name record
  2489.     lp1 = lp  + sizeof(NAME_TABLE);                 // point to name record
  2491.     for(i = 0; i < (int)Num; i++)
  2492.     {
  2493.         if(FONT_SUBFAMILY_NAME == TWO_BYTE_NUM(((NAME_RECORD*)lp1)->NameID))
  2494.         {
  2495.             lp2 = lp +                              // point to string store
  2496.                   TWO_BYTE_NUM(((NAME_TABLE* )lp )->Offset) +
  2497.                   TWO_BYTE_NUM(((NAME_RECORD*)lp1)->Offset);
  2499.             Len = TWO_BYTE_NUM(((NAME_RECORD*)lp1)->Length);
  2501.             if(UNICODE_INDEXING == TWO_BYTE_NUM(((NAME_RECORD*)lp1)->Encoding))
  2502.             {
  2503.                 Len >>= 1;
  2504.                 while(--Len > 0)
  2505.                 {
  2506.                     if(*(lp2+(Len<<1)+1) != szRegular[Len])
  2507.                     goto CloseHandle00;
  2508.                 }
  2509.                 break;
  2510.             }
  2511.             else
  2512.             {
  2513.                 if(strncmp((char*)lp2, szRegular, Len) != 0)
  2514.                     goto CloseHandle00;
  2515.                 else
  2516.                     break;
  2517.             }
  2518.         } 
  2520.         lp1 += sizeof(NAME_RECORD);
  2521.     }
  2523.     // all non-regular fonts have already been eliminated
  2525.     lp1  = (LPBYTE)lpvFile + cmap;                     // point to cmap table
  2526.     Num  = TWO_BYTE_NUM(((CMAP_HEAD*)lp)->NumTables);
  2527.     lp1 += sizeof(CMAP_HEAD);
  2529.     while(Num >0)
  2530.     {
  2531.         if(TWO_BYTE_NUM(((CMAP_TABLE*)lp1)->Platform) == MICROSOFT_PLATFORM && 
  2532.            TWO_BYTE_NUM(((CMAP_TABLE*)lp1)->Encoding) == UNICODE_INDEXING)
  2533.         {
  2534.             lp = (LPBYTE)lpvFile
  2535.                  + cmap
  2536.                  + FOUR_BYTE_NUM(((CMAP_TABLE*)lp1)->Offset);
  2538.             if(TWO_BYTE_NUM(((CMAP_FORMAT*)lp)->Format) == CMAP_FORMAT_FOUR)
  2539.             {
  2540.                 break;
  2541.             }
  2542.         }
  2543.         Num--;
  2544.         lp1 += sizeof(CMAP_TABLE);
  2545.     }
  2547.     if(Num == 0)                   // can't find Platform:3/Encoding:1 (Unicode)
  2548.         goto CloseHandle00;
  2551.     Num  = TWO_BYTE_NUM(((CMAP_FORMAT*)lp)->SegCountX2) ;
  2553.     m = ARRAYSIZE(g_urange_table);
  2555.     lp2  = lp  + sizeof(CMAP_FORMAT);     // lp2 -> first WCHAR of wcTo
  2556.     lp1  = lp2 + Num + 2;                 // lp1 -> first WCHAR of wcFrom
  2559.     // Fast parse !!!
  2560.     while (--m)
  2561.     {
  2562.         // URANGE binary search
  2563.         i=0;
  2564.         j= (int) Num - 2;
  2565.         k=j/2;
  2566.         while (i<=j)
  2567.         {
  2568.             if (k % 2) 
  2569.                 k++;
  2571.             if (g_urange_table[m].wcFrom >= TWO_BYTE_NUM((lp1+k)) && g_urange_table[m].wcTo <= TWO_BYTE_NUM((lp2+k)))
  2572.             {
  2573.                 EnterCriticalSection(&g_cs);
  2574.                 if (!g_urange_table[m].pFontIndex)
  2575.                     g_urange_table[m].pFontIndex = (int *)LocalAlloc(LPTR, sizeof(int)* MAX_FONT_INDEX);
  2576.                 if (!g_urange_table[m].pFontIndex)
  2577.                 {
  2578.                     goto CloseHandle00;
  2579.                 }
  2581.                 if (g_urange_table[m].nFonts >= MAX_FONT_INDEX)
  2582.                 {
  2583.                     break;
  2584.                 }
  2586.                 g_urange_table[m].pFontIndex[g_urange_table[m].nFonts] = iFontIndex;
  2587.                 g_urange_table[m].nFonts++;
  2589.                 // Fill in font code page signature
  2590.                 g_pfont_table[iFontIndex].dwCodePages[0] = FOUR_BYTE_NUM(((BYTE *)lpvFile+os2+OFFSET_OS2CPRANGE));
  2591.                 g_pfont_table[iFontIndex].dwCodePages[1] = FOUR_BYTE_NUM(((BYTE *)lpvFile+os2+OFFSET_OS2CPRANGE+1));                
  2592.                 LeaveCriticalSection(&g_cs);
  2593.                 break;
  2594.             }
  2595.             else
  2596.             {
  2597.                 if (g_urange_table[m].wcFrom < TWO_BYTE_NUM((lp1+k)))
  2598.                 {
  2599.                     j = k-2;
  2600.                 }
  2601.                 else
  2602.                 {
  2603.                     i = k+2;
  2604.                 }
  2605.                 k = (i+j)/2;
  2606.             }
  2607.         }
  2608.     }
  2609.     
  2610.     bRet = TRUE;
  2612. CloseHandle00:
  2613.     UnmapViewOfFile(lpvFile);
  2614. CloseHandle01:
  2615.     CloseHandle(hTTF);
  2616.     CloseHandle(hTTFMap);
  2618.     return bRet;
  2619. }
  2621. HRESULT GetRegFontKey(HKEY *phKey, DWORD *pdwValues)
  2622. {
  2623.     HRESULT hr = E_FAIL;
  2625.     if (ERROR_SUCCESS == (g_bIsNT? 
  2626.         RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGFONTKEYNT, 0, KEY_READ, phKey):
  2627.         RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGFONTKEY95, 0, KEY_READ, phKey)))
  2628.     {
  2629.         if (ERROR_SUCCESS == RegQueryInfoKey(*phKey, NULL, NULL, 0, NULL, 
  2630.             NULL, NULL, pdwValues, NULL, NULL, NULL, NULL))
  2631.         {
  2632.             hr = S_OK;
  2633.         }        
  2634.     }
  2636.     return hr;
  2637. }
  2639. BOOL CMLFLink2::CFontMappingCache2::GetFontURangeBits(TCHAR *szFontFile, DWORD * pdwURange)
  2640. {
  2641.     // We can make use of font Unicode range signature if needed.
  2642.     return TRUE;    
  2643. }
  2645. BOOL CMLFLink2::CFontMappingCache2::SetFontScripts(void)
  2646. {
  2648.     LOGFONT lf;
  2649.     int     i,j;
  2650.     HWND    hWnd = GetTopWindow(GetDesktopWindow());
  2651.     HDC     hDC = GetDC(hWnd);
  2653.     if (!g_pfont_table)
  2654.         return FALSE;
  2656.     // Process code page based scripts (g_CharSetTransTable.sid)
  2657.     for (i = 0; g_CharSetTransTable[i].nCharSet != DEFAULT_CHARSET; i++)
  2658.     {
  2659.         j = 0;
  2660.         ZeroMemory(&lf, sizeof(lf));
  2661.         lf.lfCharSet = (BYTE)g_CharSetTransTable[i].nCharSet;
  2663.         while (g_CharSetTransTable[i].sid[j] != sidDefault)
  2664.         {
  2665.             EnumFontFamiliesEx(hDC, &lf, (FONTENUMPROC)SetFontScriptsEnumFontProc, (LPARAM)g_CharSetTransTable[i].sid[j], 0);
  2666.             j++;
  2667.         }
  2668.     }
  2670.     if (hDC)
  2671.         ReleaseDC(hWnd, hDC);
  2673.     // Process Unicode subrange based scripts (not implemented)
  2674.     // Skip this part since we need to access font CMAP anyway
  2676.     // Process char based scripts (g_wCharToScript)
  2678.     for (i=1; i<= (int)g_pfont_table[0].dwCodePages[0]; i++)
  2679.     {
  2680.         UINT uiRanges = 0;
  2681.         UNICODERANGE* pURanges = NULL;
  2682.         SCRIPT_IDS  scripts;
  2684.         if (SUCCEEDED(m_pFontMappingCache2->UnicodeRanges(g_pfont_table[i].szFileName, &uiRanges, pURanges)))
  2685.         {
  2686.             if (uiRanges)
  2687.             {
  2688.                 int         l, m, n;                
  2690.                 pURanges = (UNICODERANGE *)LocalAlloc(LPTR, sizeof(UNICODERANGE) * uiRanges);
  2692.                 if (!pURanges)
  2693.                     return E_OUTOFMEMORY;
  2695.                 m_pFontMappingCache2->UnicodeRanges(g_pfont_table[i].szFileName, &uiRanges, pURanges);
  2696.                 for (j=0; j< ARRAYSIZE(g_wCharToScript); j++)
  2697.                 {
  2699.                     l = 0;
  2700.                     m = uiRanges;
  2701.                     n = m/2;
  2702.                     while (l <= m)
  2703.                     {
  2704.                         if ((g_wCharToScript[j].wch >= pURanges[n].wcFrom) && (g_wCharToScript[j].wch <= pURanges[n].wcTo))
  2705.                         {
  2706.                             scripts = 1;
  2707.                             scripts <<= g_wCharToScript[j].sid;
  2708.                             g_pfont_table[i].scripts |= scripts;
  2709.                             break;
  2710.                         }
  2711.                         else
  2712.                         {
  2713.                             if (g_wCharToScript[j].wch < pURanges[n].wcFrom)
  2714.                                 m = n-1;
  2715.                             else
  2716.                                 l = n+1;
  2717.                             n = (m+l)/2;
  2718.                         }
  2719.                     }
  2720.                 }
  2722.                 LocalFree(pURanges);
  2723.                 pURanges = NULL;
  2724.             }
  2725.         }
  2727.         // sidUserDefined should contain all valid regular TrueType fonts
  2728.         if (!MLStrStr(g_pfont_table[i].szFaceName, TEXT("Bold")) && !MLStrStr(g_pfont_table[i].szFaceName, TEXT("Italic")))
  2729.         {
  2730.             scripts = 1;
  2731.             scripts <<= sidUserDefined;
  2732.             g_pfont_table[i].scripts |= scripts;
  2733.         }
  2734.     }
  2736.     //GetFontScriptFromCMAP(szFont, &(g_pfont_table[i].scripts));
  2738.     return TRUE;
  2739. }
  2741. BOOL CMLFLink2::CFontMappingCache2::IsFontUpdated(void)
  2742. {
  2743.     HKEY    hkey;
  2744.     DWORD   dwFonts = 0;
  2745.     BOOL    bRet = FALSE;
  2748.     if (g_pfont_table)
  2749.     {
  2750.         if (S_OK == GetRegFontKey(&hkey, &dwFonts))
  2751.         {
  2752.             if (g_pfont_table[0].dwCodePages[1] != dwFonts)
  2753.                 bRet = TRUE;
  2754.             RegCloseKey(hkey);
  2755.         }
  2756.     }
  2757.     else
  2758.     {
  2759.         // font table not created yet, need to update
  2760.         bRet = TRUE;
  2761.     }
  2763.     return bRet;
  2764. }
  2765.     
  2766. // Make sure we have font data table available and it is updated
  2767. HRESULT CMLFLink2::CFontMappingCache2::EnsureFontTable(BOOL bUpdateURangeTable)    
  2768. {
  2769.     if (IsFontUpdated())
  2770.     {
  2771.         if (g_pfont_table)
  2772.         {
  2773.             if (g_pfont_table[0].szFaceName[0])
  2774.             {
  2775.                 bUpdateURangeTable = TRUE;
  2776.             }
  2777.             LocalFree(g_pfont_table);
  2778.             g_pfont_table = NULL;
  2779.         }
  2781.         if (!SetFontTable())
  2782.             return E_OUTOFMEMORY;
  2784.         if (bUpdateURangeTable)
  2785.         {
  2786.             for (int i = 0; i < ARRAYSIZE(g_urange_table); i++)
  2787.             {
  2788.                 if (g_urange_table[i].nFonts)
  2789.                 {
  2790.                     LocalFree(g_urange_table[i].pFontIndex);
  2791.                     g_urange_table[i].pFontIndex = NULL;
  2792.                     g_urange_table[i].nFonts = 0;
  2793.                 }            
  2794.             }
  2796.             if (S_OK != SetFontUnicodeRanges())
  2797.                 return E_OUTOFMEMORY;
  2799.             SaveFontDataFile();
  2800.         }
  2801.     }
  2803.     // All tables created successfully
  2804.     return S_OK;
  2805. }
  2808. #ifdef UNIX
  2809. typedef struct tagTable_info{
  2810.     int count;
  2811.     int table_size;
  2812.     } Table_info;
  2814. int UnixGetAllFontsProc(ENUMLOGFONTEX* plfFont, NEWTEXTMETRICEX* lpntm, int iFontType, LPARAM lParam)
  2815. {
  2816.     LOGFONT *lplf;
  2817.     int *pcount = &((Table_info*)lParam)->count;
  2818.     int *ptable_size = &((Table_info*)lParam)->table_size;
  2820.     lplf = &(plfFont->elfLogFont);
  2821.     // We don't use non TrueType fonts
  2822.     if (iFontType == DEVICE_FONTTYPE || iFontType == RASTER_FONTTYPE)
  2823.         return 1;   // keep going but don't use this font
  2825.     // We don't use the SYMBOL, Mac Charset fonts
  2826.     if(lplf->lfCharSet == SYMBOL_CHARSET || lplf->lfCharSet == MAC_CHARSET)
  2827.         return 1;
  2829.     // We don't handle vertical fonts
  2830.     if (TEXT('@') == lplf->lfFaceName[0])
  2831.         return 1;
  2833.     // Now update the font-table
  2834.     // Does UNIX use TTF? // if (FontType == TRUETYPE_FONTTYPE)
  2835.     {
  2836.         CopyMemory(&g_pfont_table[*pcount].lf, lplf, sizeof(LOGFONT));
  2837.         MLStrCpyN(g_pfont_table[*pcount].szFaceName, lplf->lfFaceName, LF_FACESIZE);
  2838.         (*pcount)++;
  2839.     }
  2841.     if (*pcount >= *ptable_size)
  2842.     {
  2843.         FONTINFO * pfont_table = NULL;
  2845.         *ptable_size += FONT_TABLE_INIT_SIZE;
  2846.         pfont_table = (FONTINFO *) LocalReAlloc(g_pfont_table, 
  2847.                                         sizeof(FONTINFO) * *ptable_size,
  2848.                                         LMEM_MOVEABLE | LMEM_ZEROINIT);
  2849.         if (NULL == pfont_table)
  2850.         {
  2851.             return 0; // Stop enum. 
  2852.         }
  2853.         else
  2854.         {
  2855.             g_pfont_table = pfont_table;
  2856.         }
  2857.     }
  2858.  
  2859.     return 1;       // Keep enum. 
  2860. }
  2861. #endif
  2863. BOOL CMLFLink2::CFontMappingCache2::SetFontTable(void)
  2864. {
  2865.     BOOL    bRet = TRUE;
  2866.     TCHAR   szFaceName[MAX_PATH];
  2868.     DWORD   dwValue;
  2869.     TCHAR   szFontFile[MAX_FONT_FILE_NAME];
  2870.     DWORD   dwData;
  2871.     DWORD   dwType = REG_SZ;
  2872.     DWORD   dwFonts;
  2873.     int     i, table_size = FONT_TABLE_INIT_SIZE;
  2874.     LPTSTR  pNewFaceName = NULL;
  2875.     HKEY    hkey = NULL;
  2876.     static int count;
  2878.     HDC     hDC = NULL;
  2879.     HWND    hWnd = NULL;
  2880.     
  2881.     if (!g_pfont_table)
  2882.     {
  2883.         EnterCriticalSection(&g_cs);
  2884.         g_pfont_table = (FONTINFO *)LocalAlloc(LPTR, sizeof(FONTINFO) * FONT_TABLE_INIT_SIZE);
  2885.         LeaveCriticalSection(&g_cs);
  2886.         if (!g_pfont_table)
  2887.         {
  2888.             bRet = FALSE;
  2889.             goto SETFONT_DONE;
  2890.         }        
  2891.     }
  2892.     else
  2893.     {
  2894.         return TRUE;
  2895.     }
  2896.     
  2897. #ifndef UNIX
  2898.     if (S_OK != GetRegFontKey(&hkey, &dwFonts))
  2899.     {
  2900.         return FALSE;
  2901.     }    
  2903.     count = 1;
  2904.     hWnd = GetTopWindow(GetDesktopWindow());
  2905.     hDC = GetDC(hWnd);
  2907.     for (i=0; ;i++)
  2908.     {
  2909.         dwValue = sizeof(szFaceName);
  2910.         dwData  = sizeof(szFontFile);
  2912.         if (ERROR_NO_MORE_ITEMS == RegEnumValue(
  2913.                       hkey,
  2914.                       i,
  2915.                       szFaceName,
  2916.                       &dwValue,
  2917.                       NULL,
  2918.                       &dwType,
  2919.                       (LPBYTE)szFontFile,
  2920.                       &dwData ))
  2921.         {
  2922.             break;
  2923.         }
  2924.         DWORD dwOffset = 0;
  2925. FIND_NEXT_FACENAME:
  2926.         
  2927.         pNewFaceName = MLStrStr(&szFaceName[dwOffset], TEXT(" & "));
  2928.         if (pNewFaceName)
  2929.         {
  2930.            *pNewFaceName = 0;
  2931.            // Skip " & ", look for next font face name
  2932.            pNewFaceName+=3;
  2933.         }
  2934.         else
  2935.         {
  2936.             pNewFaceName = MLStrStr(&szFaceName[dwOffset], TEXT("(TrueType)"));
  2937.             if(pNewFaceName)
  2938.             {
  2939.                 // Ignor the space between face name and "(TrueTye)" signature
  2940.                 if ((pNewFaceName > szFaceName) && (*(pNewFaceName-1) == 0x20))
  2941.                     pNewFaceName--;
  2942.                 *pNewFaceName = 0;
  2943.             }
  2944.         }
  2947.         EnterCriticalSection(&g_cs);
  2948.         if (pNewFaceName && !EnumFontFamilies(hDC, &szFaceName[dwOffset], MapFontExEnumFontProc, (LPARAM)&count))   //TrueType font
  2949.         {
  2950.             if (count >= table_size)
  2951.             {
  2952.                 FONTINFO * _pfont_table = NULL;
  2954.                 table_size += FONT_TABLE_INIT_SIZE;
  2955.                 _pfont_table = (FONTINFO *) LocalReAlloc(g_pfont_table, sizeof(FONTINFO) * table_size,
  2956.                                     LMEM_MOVEABLE | LMEM_ZEROINIT);
  2957.                 if (NULL == _pfont_table)
  2958.                 {
  2959.                     bRet = FALSE;
  2960.                     goto SETFONT_DONE;
  2961.                 }
  2962.                 else
  2963.                 {
  2964.                     g_pfont_table = _pfont_table;
  2965.                 }
  2966.             }
  2968.             GetFontURangeBits(szFontFile, &(g_pfont_table[count-1].dwUniSubRanges[0]));
  2969.             MLStrCpyN(g_pfont_table[count-1].szFaceName, &szFaceName[dwOffset], LF_FACESIZE);
  2970.             MLStrCpyN(g_pfont_table[count-1].szFileName, szFontFile, LF_FACESIZE);
  2972.         }
  2973.         LeaveCriticalSection(&g_cs);
  2974.         if (pNewFaceName && (*pNewFaceName))
  2975.         {
  2976.             dwOffset = (DWORD)(pNewFaceName - &szFaceName[0]);
  2977.             goto FIND_NEXT_FACENAME;
  2978.         }
  2979.     }
  2980. #else
  2981.     // For UNIX, we don't have registry font information,
  2982.     // Let's create font table through EnumFontFamiliesEx.
  2983.     Table_info table_info;
  2984.     table_info.count = 1;
  2985.     table_info.table_size = table_size;
  2987.     int iRet;
  2988.     LOGFONT lf;
  2989.     lf.lfCharSet = DEFAULT_CHARSET; // give me all fonts
  2990.     lf.lfFaceName[0] = _T('');
  2991.     lf.lfPitchAndFamily = 0;
  2992.         
  2993.     hWnd = GetTopWindow(GetDesktopWindow());
  2994.     hDC = GetDC(hWnd);
  2996.     EnterCriticalSection(&g_cs);
  2997.     iRet = EnumFontFamiliesEx(hDC, // Enum all fonts
  2998.                      &lf,
  2999.                      (FONTENUMPROC)UnixGetAllFontsProc,
  3000.                      (LPARAM)&table_info,
  3001.                      0);
  3002.     LeaveCriticalSection(&g_cs);
  3003.     count = table_info.count;
  3004.     if (iRet == 0) // abort
  3005.     {
  3006.         bRet = FALSE;
  3007.         goto SETFONT_DONE;    
  3008.     }
  3009. #endif // UNIX
  3011.     // Release un-used memory
  3012.     g_pfont_table = (FONTINFO *)LocalReAlloc(g_pfont_table, (count)*sizeof(FONTINFO), LMEM_MOVEABLE);
  3014.     // Save TrueType font number
  3015.     g_pfont_table[0].dwCodePages[0] = count-1;
  3017. #ifndef UNIX
  3018.     // Unix doesn't have this number.
  3019.     // Save total font number for font change verification 
  3020.     g_pfont_table[0].dwCodePages[1] = dwFonts;
  3022.     RegCloseKey(hkey);
  3023. #endif
  3025.     if (count > 1)
  3026.         SetFontScripts();
  3028. SETFONT_DONE:    
  3030.     if (hDC)
  3031.         ReleaseDC(hWnd, hDC);
  3033.     if (count <= 1)
  3034.     {
  3035.         if (g_pfont_table)
  3036.             LocalFree(g_pfont_table);
  3037.         bRet = FALSE;
  3038.     }
  3040.     return bRet;
  3042. }
  3045. HRESULT CMLFLink2::CFontMappingCache2::SaveFontDataFile(void)
  3046. {
  3047.     FONTDATAHEADER fileHeader;
  3048.     HRESULT hr = E_FAIL;
  3049.     int     *pTmpBuf = NULL;
  3050.     HANDLE  hFile = NULL;
  3051.     int     i, j, Count = 0;
  3052.     DWORD   dwSize;
  3053.     FONTDATATABLE fontInfoTable, fontIndexTable;
  3056.     hFile = CreateFile( szFontDataFilePath,         
  3057.                         GENERIC_WRITE,          
  3058.                         0,                      
  3059.                         NULL,                   
  3060.                         CREATE_ALWAYS,          
  3061.                         FILE_ATTRIBUTE_HIDDEN,
  3062.                         NULL);                 
  3064.     if (hFile == INVALID_HANDLE_VALUE)
  3065.     {
  3066.         goto SAVE_FONT_DATA_DONE;
  3067.     }
  3070.     for (i = 0; i < ARRAYSIZE(g_urange_table); i++)
  3071.     {
  3072.         Count += (g_urange_table[i].nFonts+1);
  3073.     }
  3076.     // Create file header
  3077.     lstrcpyA(fileHeader.FileSig, FONT_DATA_SIGNATURE);
  3078.     fileHeader.dwVersion = 0x00010000;
  3080.     // Use file size as CheckSum
  3081.     fileHeader.dwCheckSum = sizeof(FONTINFO)*(g_pfont_table[0].dwCodePages[0]+1)+Count*sizeof(int)+
  3082.          + sizeof(FONTDATAHEADER) + sizeof(FONTDATATABLE)*FONTDATATABLENUM;
  3083.     fileHeader.nTable = FONTDATATABLENUM;
  3086.     pTmpBuf = (int *)LocalAlloc(LPTR, Count*sizeof(int));
  3088.     // Get font index data
  3089.     for (i = 0; i < ARRAYSIZE(g_urange_table); i++)
  3090.     {
  3091.         *pTmpBuf++ = g_urange_table[i].nFonts;
  3093.         if (g_urange_table[i].nFonts)
  3094.         {
  3095.             for (j = 0; j< g_urange_table[i].nFonts; j++)
  3096.             {
  3097.                 *pTmpBuf++ = *(g_urange_table[i].pFontIndex+j);
  3098.             }
  3099.         }
  3100.     }
  3102.     pTmpBuf -= Count;
  3104.     // Create Dir tables
  3105.     lstrcpyA(fontInfoTable.szName, "fnt");
  3106.     fontInfoTable.dwOffset = sizeof(FONTDATAHEADER) + sizeof(FONTDATATABLE)*FONTDATATABLENUM;
  3107.     fontInfoTable.dwSize = sizeof(FONTINFO)*(g_pfont_table[0].dwCodePages[0]+1);
  3109.     lstrcpyA(fontIndexTable.szName, "idx");
  3110.     fontIndexTable.dwOffset = fontInfoTable.dwSize+fontInfoTable.dwOffset;
  3111.     fontIndexTable.dwSize = Count*sizeof(int);
  3113.     if (WriteFile(hFile, &fileHeader, sizeof(FONTDATAHEADER), &dwSize, NULL) &&
  3114.         WriteFile(hFile, &fontInfoTable, sizeof(FONTDATATABLE), &dwSize, NULL) &&
  3115.         WriteFile(hFile, &fontIndexTable, sizeof(FONTDATATABLE), &dwSize, NULL) &&
  3116.         WriteFile(hFile, g_pfont_table, fontInfoTable.dwSize, &dwSize, NULL) &&
  3117.         WriteFile(hFile, pTmpBuf, fontIndexTable.dwSize, &dwSize, NULL))
  3118.     {
  3119.         hr = S_OK;
  3120.     }
  3122. SAVE_FONT_DATA_DONE:
  3123.     if (hFile)
  3124.         CloseHandle(hFile);
  3125.     if (pTmpBuf)
  3126.         LocalFree(pTmpBuf);
  3128.     return hr;
  3129. }
  3131. HRESULT CMLFLink2::CFontMappingCache2::LoadFontDataFile(void)
  3132. {
  3133.     HANDLE  hFontData = NULL;
  3134.     HANDLE  hFileMap = NULL;
  3135.     LPVOID  lpvFile;
  3136.     int *   lp;
  3137.     HRESULT hr = E_FAIL;
  3138.     DWORD   dwFileSize;
  3140.     int     i, j;
  3141.     HKEY    hKey = NULL;
  3142.     DWORD   nFonts;
  3143.     FONTDATAHEADER *pHeader;
  3144.     FONTDATATABLE *pfTable;
  3147.     hFontData = CreateFile(szFontDataFilePath,  
  3148.                         GENERIC_READ,           
  3149.                         FILE_SHARE_READ,        
  3150.                         NULL,                   
  3151.                         OPEN_EXISTING,          
  3152.                         FILE_ATTRIBUTE_NORMAL,  
  3153.                         NULL);                  
  3155.     if (hFontData == INVALID_HANDLE_VALUE)
  3156.         return EnsureFontTable(TRUE);
  3158.     dwFileSize = GetFileSize(hFontData, NULL);
  3160.     hFileMap = CreateFileMapping(
  3161.                   hFontData,
  3162.                   NULL,
  3163.                   PAGE_READONLY,
  3164.                   0,
  3165.                   dwFileSize,
  3166.                   NULL
  3167.               );
  3169.     if(hFileMap == NULL)
  3170.     {
  3171.         goto Load_File_Done;
  3172.     }
  3174.     lpvFile = MapViewOfFile(
  3175.                   hFileMap,
  3176.                   FILE_MAP_READ,
  3177.                   0,
  3178.                   0,
  3179.                   0
  3180.               );
  3182.     if (lpvFile == NULL)
  3183.     {        
  3184.         goto Load_File_Done;
  3185.     }
  3187.     pHeader = (FONTDATAHEADER *)lpvFile;
  3189.     // Check mlang font cache file by signature and checksum
  3190.     if (lstrcmpA(pHeader->FileSig, FONT_DATA_SIGNATURE) || pHeader->dwCheckSum != dwFileSize)
  3191.     {
  3192.         goto Load_File_Done;
  3193.     }
  3196.     if (S_OK != GetRegFontKey(&hKey, &nFonts))
  3197.     {
  3198.         goto Load_File_Done;
  3199.     }
  3201.     pfTable = (FONTDATATABLE *) ((LPBYTE)lpvFile + sizeof(FONTDATAHEADER));
  3203.     //!BUGBUG, Check if there is any font change (no guarantee, but works in most cases)
  3204.     if (nFonts != ((FONTINFO*)((LPBYTE)lpvFile + pfTable[0].dwOffset))->dwCodePages[1])
  3205.     {
  3206.         // If there is a change in system font number, we reload everything
  3207.         UnmapViewOfFile(lpvFile);
  3208.         CloseHandle(hFileMap);
  3209.         CloseHandle(hFontData);
  3210.         RegCloseKey(hKey);
  3211.         return EnsureFontTable(TRUE);
  3212.     }
  3214.     EnterCriticalSection(&g_cs);
  3215.     // Reset cache information
  3216.     if (g_pfont_table)
  3217.     {
  3218.         
  3219.         LocalFree(g_pfont_table);
  3220.         g_pfont_table = NULL;
  3221.         for (i = 0; i < ARRAYSIZE(g_urange_table); i++)
  3222.         {
  3223.             if (g_urange_table[i].nFonts)
  3224.             {
  3225.                 LocalFree(g_urange_table[i].pFontIndex);
  3226.                 g_urange_table[i].pFontIndex = NULL;
  3227.                 g_urange_table[i].nFonts = 0;
  3228.             }
  3229.         }        
  3230.     }
  3233.     if(!(g_pfont_table = (FONTINFO *) (LocalAlloc(LPTR, pfTable[0].dwSize))))
  3234.     {
  3235.         hr = E_OUTOFMEMORY;
  3236.         goto Load_File_Done;
  3237.     }
  3239.     CopyMemory(g_pfont_table, (LPBYTE)lpvFile + pfTable[0].dwOffset, pfTable[0].dwSize);
  3241.     lp = (int *)((LPBYTE)lpvFile + pfTable[1].dwOffset);
  3243.     for (i = 0; i < ARRAYSIZE(g_urange_table); i++)
  3244.     {
  3245.         if (g_urange_table[i].nFonts = *lp++)
  3246.         {
  3247.             //g_urange_table[i].nFonts = *lp++;
  3248.             g_urange_table[i].pFontIndex = (int *)LocalAlloc(LPTR, sizeof(int)*g_urange_table[i].nFonts);
  3249.             for (j = 0; j<  g_urange_table[i].nFonts; j++)
  3250.             {
  3251.                 g_urange_table[i].pFontIndex[j] = *lp++;
  3252.             }
  3253.         }
  3254.     }
  3256.     LeaveCriticalSection(&g_cs);
  3258.     hr = S_OK;
  3260. Load_File_Done:
  3261.     if (lpvFile)
  3262.         UnmapViewOfFile(lpvFile);
  3263.     if (hFileMap)
  3264.         CloseHandle(hFileMap);
  3265.     if (hFontData)
  3266.         CloseHandle(hFontData);
  3267.     if (hKey)
  3268.         RegCloseKey(hKey);
  3270.     return hr;
  3272. }
  3275. HRESULT CMLFLink2::CFontMappingCache2::SetFontUnicodeRanges(void)
  3276. {
  3277.     TCHAR   szFontPath[MAX_PATH];
  3278.     TCHAR   szFont[MAX_PATH];
  3279.     HRESULT hr = S_OK;
  3280.     int     i;
  3281.     
  3283.     EnterCriticalSection(&g_cs);
  3284.     g_pfont_table[0].szFaceName[0] = 1;
  3285.     LeaveCriticalSection(&g_cs);
  3286.     
  3287.     MLGetWindowsDirectory(szFontPath, MAX_PATH);
  3288.     MLPathCombine(szFontPath, szFontPath, FONT_FOLDER);
  3290.     for (i=1; i<= (int)g_pfont_table[0].dwCodePages[0]; i++)
  3291.     {
  3292.         MLPathCombine(szFont, szFontPath, g_pfont_table[i].szFileName);
  3293.         GetNonCpFontUnicodeRanges(szFont, i);
  3294.     }
  3296.     // Release un-used memory
  3297.     for (i=0; i< ARRAYSIZE(g_urange_table); i++)
  3298.     {
  3299.         if (g_urange_table[i].nFonts)
  3300.             g_urange_table[i].pFontIndex = (int *)LocalReAlloc(g_urange_table[i].pFontIndex, g_urange_table[i].nFonts*sizeof(int), LMEM_MOVEABLE);
  3301.     }
  3303.     return hr;
  3304. }
  3306. STDMETHODIMP CMLFLink2::GetStrCodePages(const WCHAR* pszSrc, long cchSrc, DWORD dwPriorityCodePages, DWORD* pdwCodePages, long* pcchCodePages)
  3307. {
  3308.     ASSERT_THIS;
  3309.     ASSERT_READ_BLOCK(pszSrc, cchSrc);
  3310.     ASSERT_WRITE_PTR_OR_NULL(pdwCodePages);
  3311.     ASSERT_WRITE_PTR_OR_NULL(pcchCodePages);
  3313.     HRESULT hr = S_OK;
  3314.     long cchCodePages = 0;
  3315.     DWORD dwStrCodePages = (DWORD)~0;
  3316.     BOOL fInit = FALSE;
  3317.     BOOL fNoPri = FALSE;
  3319.     if (!pszSrc || cchSrc <= 0) // We can't make dwStrCodePages when cchSrc is zero
  3320.         hr = E_INVALIDARG;
  3322.     if (!m_pIMLFLnk)
  3323.         return E_OUTOFMEMORY;
  3325.     while (SUCCEEDED(hr) && cchSrc > 0)
  3326.     {
  3327.         DWORD dwCharCodePages;
  3329.         if (SUCCEEDED(hr = m_pIMLFLnk->GetCharCodePages(*pszSrc, &dwCharCodePages)))
  3330.         {
  3331.             if (!fInit)
  3332.             {
  3333.                 fInit = TRUE;
  3334.                 fNoPri = !(dwPriorityCodePages & dwCharCodePages);
  3335.             }
  3336.             else if (fNoPri != !(dwPriorityCodePages & dwCharCodePages))
  3337.             {
  3338.                 break;
  3339.             }
  3340.             if (!fNoPri)
  3341.                 dwPriorityCodePages &= dwCharCodePages;
  3343.             if (dwCharCodePages && (dwCharCodePages & dwStrCodePages))
  3344.                 dwStrCodePages &= dwCharCodePages;
  3345.             else
  3346.                 break;
  3348.             pszSrc++;
  3349.             cchSrc--;
  3350.             cchCodePages++;
  3351.         }
  3352.     }
  3354.     if (SUCCEEDED(hr))
  3355.     {
  3356.         if (!cchCodePages)
  3357.         {
  3358.             dwStrCodePages = 0;
  3359.             cchCodePages++;
  3360.         }
  3361.         if (pcchCodePages)
  3362.             *pcchCodePages = cchCodePages;
  3363.         if (pdwCodePages)
  3364.             *pdwCodePages = dwStrCodePages;
  3365.     }
  3366.     else
  3367.     {
  3368.         if (pcchCodePages)
  3369.             *pcchCodePages = 0;
  3370.         if (pdwCodePages)
  3371.             *pdwCodePages = 0;
  3372.     }
  3374.     return hr;
  3375. }
  3377. STDMETHODIMP CMLFLink2::MapFont(HDC hDC, DWORD dwCodePages, WCHAR wchar, HFONT* phDestFont)
  3378. {
  3379.     HFONT hSrcFont = NULL;
  3381.     if (NULL == (hSrcFont = (HFONT) GetCurrentObject(hDC, OBJ_FONT)))
  3382.         return E_FAIL;
  3384.     if (dwCodePages)
  3385.     {
  3386.         if (m_pIMLFLnk)
  3387.             return m_pIMLFLnk->MapFont(hDC, dwCodePages, hSrcFont, phDestFont);
  3388.         return E_OUTOFMEMORY;
  3389.     }
  3390.     else
  3391.     {
  3392.         if (!m_pFontMappingCache2)
  3393.             m_pFontMappingCache2 = new CFontMappingCache2;
  3394.         if (m_pFontMappingCache2)
  3395.             return m_pFontMappingCache2->MapFontFromCMAP(hDC, wchar, hSrcFont, phDestFont);
  3396.         else
  3397.             return E_OUTOFMEMORY;
  3398.     }
  3399. }
  3401. STDMETHODIMP CMLFLink2::GetFontUnicodeRanges(HDC hDC, UINT *puiRanges, UNICODERANGE* pURanges)
  3402. {
  3403.     int     i;
  3404.     LOGFONT lf;
  3405.     HRESULT hr = E_FAIL;
  3406.     HFONT   hFont = NULL;
  3408.     if (!puiRanges)
  3409.         return E_INVALIDARG;
  3411.     if (!m_pFontMappingCache2)
  3412.         m_pFontMappingCache2 = new CFontMappingCache2;
  3413.     if (!m_pFontMappingCache2)
  3414.         return E_OUTOFMEMORY;
  3416.     if (!(hFont = (HFONT)GetCurrentObject(hDC, OBJ_FONT)))
  3417.         return hr;
  3419.     if (FAILED(m_pFontMappingCache2->EnsureFontTable(FALSE)))
  3420.         return hr;
  3422.     if (!GetObject(hFont, sizeof(LOGFONT), &lf))
  3423.         return hr;
  3425.     for (i=1; i<= (int) g_pfont_table[0].dwCodePages[0]; i++)
  3426.     {
  3427.         if (!lstrcmp(lf.lfFaceName, g_pfont_table[i].szFaceName))
  3428.             break;
  3429.     }
  3431.     if (i > (int) g_pfont_table[0].dwCodePages[0])
  3432.         return hr;
  3434.     return m_pFontMappingCache2->UnicodeRanges(g_pfont_table[i].szFileName, puiRanges, pURanges);
  3436. }
  3438. STDMETHODIMP CMLFLink2::GetScriptFontInfo(SCRIPT_ID sid, DWORD dwFlags, UINT *puiFonts, SCRIPTFONTINFO* pScriptFont)
  3439. {
  3440.     HRESULT hr = E_FAIL;
  3441.     UINT    uiNum;
  3442.     BYTE    bPitch = dwFlags & SCRIPTCONTF_FIXED_FONT? FIXED_PITCH:VARIABLE_PITCH;
  3444.     if (!m_pFontMappingCache2)
  3445.         m_pFontMappingCache2 = new CFontMappingCache2;
  3447.     if (m_pFontMappingCache2)
  3448.         m_pFontMappingCache2->EnsureFontTable(FALSE);
  3450.     if (!g_pfont_table)
  3451.         return hr;
  3454.     if (!pScriptFont)
  3455.     {
  3456.         uiNum = g_pfont_table[0].dwCodePages[0];
  3457.     }
  3458.     else
  3459.     {
  3460.         uiNum = *puiFonts;    
  3461.     }
  3463.     *puiFonts = 0;
  3465.     // Binary search font table to match script id.
  3466.     for (UINT i=1; i<= g_pfont_table[0].dwCodePages[0]; i++)
  3467.     {
  3468.         // Check font pitch
  3469.         if (!(g_pfont_table[i].lf.lfPitchAndFamily & bPitch))
  3470.             continue;
  3472.         // Get sid bit mask
  3473.         SCRIPT_IDS sids = 1;
  3474.         sids <<= sid;
  3476.         if (sids & g_pfont_table[i].scripts)
  3477.         {
  3478.             // Bail out is required number reached
  3479.             if (*puiFonts >= uiNum)
  3480.             {
  3481.                 break;
  3482.             }
  3483.             if (pScriptFont)
  3484.             {
  3485.                 MultiByteToWideChar(CP_ACP, 0, g_pfont_table[i].szFaceName, -1, (pScriptFont + *puiFonts)->wszFont, MAX_MIMEFACE_NAME);
  3486.                 (pScriptFont + *puiFonts)->scripts = g_pfont_table[i].scripts;
  3487.             }
  3488.             (*puiFonts)++;
  3489.         }
  3490.     }
  3492.     return S_OK;
  3494. }
  3496. // Map Windows code page to script id 
  3497. // if multiple script id exist, we'll return the default one
  3498. STDMETHODIMP CMLFLink2::CodePageToScriptID(UINT uiCodePage, SCRIPT_ID *pSid)
  3499. {
  3500.     MIMECPINFO  cpInfo;
  3501.     HRESULT     hr = E_FAIL;
  3503.     if (!pSid)
  3504.         return E_INVALIDARG;
  3506.     if (NULL != g_pMimeDatabase)
  3507.     {
  3508.         if (SUCCEEDED(g_pMimeDatabase->GetCodePageInfo(uiCodePage, 0x409, &cpInfo)))
  3509.         {
  3510.             if (cpInfo.uiFamilyCodePage == CP_USER_DEFINED)
  3511.             {
  3512.                 *pSid = sidUserDefined;
  3513.                 hr = S_OK; 
  3514.             }
  3515.             else
  3516.                 for (int i = 0; g_CharSetTransTable[i].uCodePage; i++)
  3517.                 {
  3518.                     if (cpInfo.uiFamilyCodePage == g_CharSetTransTable[i].uCodePage)
  3519.                     {
  3520.                         *pSid = g_CharSetTransTable[i].sid[0];
  3521.                         hr = S_OK;
  3522.                         break;
  3523.                     }
  3524.                 }            
  3525.         }
  3526.     }
  3528.     return hr;
  3529. }
  3530.         
  3531. CMLFLink2::CFontMappingCache2::CFontMappingCache2(void)
  3532. {
  3533.     GetSystemDirectory(szFontDataFilePath, MAX_PATH);
  3534.     MLPathCombine(szFontDataFilePath, szFontDataFilePath, FONT_DATA_FILE_NAME);
  3535. }
  3537. CMLFLink2::CFontMappingCache2::~CFontMappingCache2(void)
  3538. {
  3539.     if (g_pfont_table) 
  3540.     {
  3541.         LocalFree(g_pfont_table); 
  3542.         g_pfont_table = NULL;
  3543.     }
  3545.     if (g_urange_table)
  3546.     {
  3547.         for (int i=0; i< ARRAYSIZE(g_urange_table); i++)
  3548.         if (g_urange_table[i].nFonts)
  3549.         {
  3550.             LocalFree(g_urange_table[i].pFontIndex);
  3551.         }
  3552.     }
  3553. }
  3555. int CALLBACK CMLFLink2::CFontMappingCache2::MapFontExEnumFontProc(const LOGFONT* plfFont, const TEXTMETRIC*, DWORD FontType, LPARAM lParam)
  3556. {  
  3557.     if (FontType == TRUETYPE_FONTTYPE && plfFont->lfFaceName[0] != TEXT('@') )
  3558.     {
  3559.         CopyMemory(&g_pfont_table[*(int *)lParam].lf, plfFont, sizeof(LOGFONT));
  3560.         (*(int *)lParam)++;
  3561.         return 0;
  3562.     }
  3563.     return 1;
  3564. }
  3566. int CALLBACK CMLFLink2::CFontMappingCache2::SetFontScriptsEnumFontProc(const LOGFONT* plfFont, const TEXTMETRIC*, DWORD FontType, LPARAM lParam)
  3567. {      
  3568.     if (FontType == TRUETYPE_FONTTYPE)
  3569.     {
  3570.         if (g_pfont_table)
  3571.         {
  3572.             for (int i=1; i<= (int)g_pfont_table[0].dwCodePages[0]; i++)
  3573.                 if (!MLStrCmpNI(plfFont->lfFaceName, g_pfont_table[i].szFaceName, LF_FACESIZE))
  3574.                 {
  3575.                     SCRIPT_IDS scripts = 1;
  3576.                     scripts <<= lParam;
  3577.                     g_pfont_table[i].scripts |= scripts;
  3578.                     break;
  3579.                 }
  3581.             if (i > (int)g_pfont_table[0].dwCodePages[0] && plfFont->lfFaceName[0] != TEXT('@'))        // GDI font not in current font table?
  3582.             {
  3583.                 FONTINFO * pfont_table = NULL;
  3585.                 pfont_table = (FONTINFO *) LocalReAlloc(g_pfont_table, 
  3586.                                         sizeof(FONTINFO) * (g_pfont_table[0].dwCodePages[0]+2),
  3587.                                         LMEM_MOVEABLE | LMEM_ZEROINIT);
  3588.                 if (NULL != pfont_table)
  3589.                 {
  3590.                     g_pfont_table = pfont_table;
  3591.                     g_pfont_table[0].dwCodePages[0]++;
  3592.                     MLStrCpyN(g_pfont_table[i].szFaceName, (char *)plfFont->lfFaceName, LF_FACESIZE);
  3593.                     CopyMemory(&g_pfont_table[i].lf, plfFont, sizeof(LOGFONT));
  3595.                     SCRIPT_IDS scripts = 1;
  3596.                     scripts <<= lParam;
  3597.                     g_pfont_table[i].scripts |= scripts;                    
  3598.                 }
  3599.             }
  3600.         }
  3601.     }
  3602.     return 1;
  3603. }
  3605. int CALLBACK CMLFLink::VerifyFontSizeEnumFontProc(const LOGFONT* plfFont, const TEXTMETRIC* ptm, DWORD FontType, LPARAM lParam)
  3606. {
  3607.     LOGFONT* plfSrcFont = (LOGFONT*)lParam;
  3609.     if (FontType != TRUETYPE_FONTTYPE)
  3610.     {
  3611.         LONG lHeight = ptm->tmInternalLeading - ptm->tmHeight;
  3612.         // Match source font's lfHeight to physical bitmap font's lfHeight
  3613.         if (lHeight < 0 && plfSrcFont->lfHeight < 0 && lHeight < plfSrcFont->lfHeight)
  3614.         {
  3615.             plfSrcFont->lfHeight = lHeight ;
  3616.         }
  3617.     }
  3619.     return 0;
  3620. }
  3621.