font.c 7.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385
  1. /* -*- mode: c; tab-width: 4; c-basic-offset: 4; c-file-style: "linux" -*- */
  2. //
  3. // Copyright (c) 2009-2011, Wei Mingzhi <whistler_wmz@users.sf.net>.
  4. // Copyright (c) 2011-2017, SDLPAL development team.
  5. // All rights reserved.
  6. //
  7. // This file is part of SDLPAL.
  8. //
  9. // SDLPAL is free software: you can redistribute it and/or modify
  10. // it under the terms of the GNU General Public License as published by
  11. // the Free Software Foundation, either version 3 of the License, or
  12. // (at your option) any later version.
  13. //
  14. // This program is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17. // GNU General Public License for more details.
  18. //
  19. // You should have received a copy of the GNU General Public License
  20. // along with this program. If not, see <http://www.gnu.org/licenses/>.
  21. //
  22. #include "font.h"
  23. #include "util.h"
  24. #include "text.h"
  25. #define _FONT_C
  26. #include "fontglyph.h"
  27. #include "ascii.h"
  28. static int _font_height = 16;
  29. static uint8_t reverseBits(uint8_t x) {
  30. uint8_t y = 0;
  31. for(int i = 0 ; i < 8; i++){
  32. y <<= 1;
  33. y |= (x & 1);
  34. x >>= 1;
  35. }
  36. return y;
  37. }
  38. static void PAL_LoadEmbeddedFont(void)
  39. {
  40. FILE *fp;
  41. char *char_buf;
  42. wchar_t *wchar_buf;
  43. size_t nBytes;
  44. int nChars, i;
  45. //
  46. // Load the wor16.asc file.
  47. //
  48. if (NULL == (fp = UTIL_OpenFile("wor16.asc")))
  49. {
  50. return;
  51. }
  52. //
  53. // Get the size of wor16.asc file.
  54. //
  55. fseek(fp, 0, SEEK_END);
  56. nBytes = ftell(fp);
  57. //
  58. // Allocate buffer & read all the character codes.
  59. //
  60. if (NULL == (char_buf = (char *)malloc(nBytes)))
  61. {
  62. fclose(fp);
  63. return;
  64. }
  65. fseek(fp, 0, SEEK_SET);
  66. if (fread(char_buf, 1, nBytes, fp) < nBytes)
  67. {
  68. fclose(fp);
  69. return;
  70. }
  71. //
  72. // Close wor16.asc file.
  73. //
  74. fclose(fp);
  75. //
  76. // Detect the codepage of 'wor16.asc' and exit if not BIG5 or probability < 99
  77. // Note: 100% probability is impossible as the function does not recognize some special
  78. // characters such as bopomofo that may be used by 'wor16.asc'.
  79. //
  80. if (PAL_DetectCodePageForString(char_buf, nBytes, CP_BIG5, &i) != CP_BIG5 || i < 99)
  81. {
  82. free(char_buf);
  83. return;
  84. }
  85. //
  86. // Convert characters into unicode
  87. // Explictly specify BIG5 here for compatibility with codepage auto-detection
  88. //
  89. nChars = PAL_MultiByteToWideCharCP(CP_BIG5, char_buf, nBytes, NULL, 0);
  90. if (NULL == (wchar_buf = (wchar_t *)malloc(nChars * sizeof(wchar_t))))
  91. {
  92. free(char_buf);
  93. return;
  94. }
  95. PAL_MultiByteToWideCharCP(CP_BIG5, char_buf, nBytes, wchar_buf, nChars);
  96. free(char_buf);
  97. //
  98. // Read bitmaps from wor16.fon file.
  99. //
  100. fp = UTIL_OpenFile("wor16.fon");
  101. //
  102. // The font glyph data begins at offset 0x682 in wor16.fon.
  103. //
  104. fseek(fp, 0x682, SEEK_SET);
  105. //
  106. // Replace the original fonts
  107. //
  108. for (i = 0; i < nChars; i++)
  109. {
  110. wchar_t w = (wchar_buf[i] >= unicode_upper_base) ? (wchar_buf[i] - unicode_upper_base + unicode_lower_top) : wchar_buf[i];
  111. if (fread(unicode_font[w], 30, 1, fp) == 1)
  112. {
  113. unicode_font[w][30] = 0;
  114. unicode_font[w][31] = 0;
  115. }
  116. font_width[w] = 32;
  117. }
  118. free(wchar_buf);
  119. fclose(fp);
  120. for (i = 0; i < 0x80; i++)
  121. {
  122. int j=-1;while(j++<16)unicode_font[i][j]=reverseBits(iso_font[i*15+j]);
  123. unicode_font[i][15] = 0;
  124. }
  125. _font_height = 15;
  126. }
  127. INT
  128. PAL_LoadUserFont(
  129. LPCSTR pszBdfFileName
  130. )
  131. /*++
  132. Purpose:
  133. Loads a BDF bitmap font file.
  134. Parameters:
  135. [IN] pszBdfFileName - Name of BDF bitmap font file..
  136. Return value:
  137. 0 = success, -1 = failure.
  138. --*/
  139. {
  140. char buf[4096];
  141. int state = 0;
  142. int codepage = -1;
  143. DWORD dwEncoding = 0;
  144. BYTE bFontGlyph[32] = {0};
  145. int iCurHeight = 0;
  146. FILE *fp = UTIL_OpenFileForMode(pszBdfFileName, "r");
  147. if (fp == NULL)
  148. {
  149. return -1;
  150. }
  151. while (fgets(buf, 4096, fp) != NULL)
  152. {
  153. if (state == 0)
  154. {
  155. if (strncmp(buf, "CHARSET_REGISTRY", 16) == 0)
  156. {
  157. if (strstr(buf, "Big5") != NULL)
  158. {
  159. codepage = CP_BIG5;
  160. }
  161. else if (strstr(buf, "BIG5") != NULL)
  162. {
  163. codepage = CP_BIG5;
  164. }
  165. //else if (strstr(buf, "JISX0208") != NULL)
  166. //
  167. // codepage = CP_JISX0208;
  168. //}
  169. }
  170. else if (strncmp(buf, "ENCODING", 8) == 0)
  171. {
  172. dwEncoding = atoi(buf + 8);
  173. }
  174. else if (strncmp(buf, "BITMAP", 6) == 0)
  175. {
  176. state = 1;
  177. iCurHeight = 0;
  178. memset(bFontGlyph, 0, sizeof(bFontGlyph));
  179. }
  180. }
  181. else if (state == 1)
  182. {
  183. if (strncmp(buf, "ENDCHAR", 7) == 0)
  184. {
  185. //
  186. // Replace the original fonts
  187. //
  188. BYTE szCp[3];
  189. szCp[0] = (dwEncoding >> 8) & 0xFF;
  190. szCp[1] = dwEncoding & 0xFF;
  191. szCp[2] = 0;
  192. wchar_t wc[2] = { 0 };
  193. PAL_MultiByteToWideCharCP(codepage, (LPCSTR)szCp, 2, wc, 1);
  194. if (wc[0] != 0)
  195. {
  196. wchar_t w = (wc[0] >= unicode_upper_base) ? (wc[0] - unicode_upper_base + unicode_lower_top) : wc[0];
  197. memcpy(unicode_font[w], bFontGlyph, sizeof(bFontGlyph));
  198. }
  199. state = 0;
  200. }
  201. else
  202. {
  203. if (iCurHeight < 16)
  204. {
  205. WORD wCode = strtoul(buf, NULL, 16);
  206. bFontGlyph[iCurHeight * 2] = (wCode >> 8);
  207. bFontGlyph[iCurHeight * 2 + 1] = (wCode & 0xFF);
  208. iCurHeight++;
  209. }
  210. }
  211. }
  212. }
  213. _font_height = 16;
  214. fclose(fp);
  215. return 0;
  216. }
  217. int
  218. PAL_InitFont(
  219. const CONFIGURATION* cfg
  220. )
  221. {
  222. if (!cfg->fIsWIN95)
  223. {
  224. PAL_LoadEmbeddedFont();
  225. }
  226. if (cfg->pszFontFile)
  227. {
  228. PAL_LoadUserFont(cfg->pszFontFile);
  229. }
  230. return 0;
  231. }
  232. void
  233. PAL_FreeFont(
  234. void
  235. )
  236. {
  237. }
  238. void
  239. PAL_DrawCharOnSurface(
  240. uint16_t wChar,
  241. SDL_Surface *lpSurface,
  242. PAL_POS pos,
  243. uint8_t bColor,
  244. BOOL fUse8x8Font
  245. )
  246. {
  247. int i, j;
  248. int x = PAL_X(pos), y = PAL_Y(pos);
  249. //
  250. // Check for NULL pointer & invalid char code.
  251. //
  252. if (lpSurface == NULL || (wChar >= unicode_lower_top && wChar < unicode_upper_base) ||
  253. wChar >= unicode_upper_top || (_font_height == 8 && wChar >= 0x100))
  254. {
  255. return;
  256. }
  257. //
  258. // Locate for this character in the font lib.
  259. //
  260. if (wChar >= unicode_upper_base)
  261. {
  262. wChar -= (unicode_upper_base - unicode_lower_top);
  263. }
  264. //
  265. // Draw the character to the surface.
  266. //
  267. LPBYTE dest = (LPBYTE)lpSurface->pixels + y * lpSurface->pitch + x;
  268. LPBYTE top = (LPBYTE)lpSurface->pixels + lpSurface->h * lpSurface->pitch;
  269. if (fUse8x8Font)
  270. {
  271. for (i = 0; i < 8 && dest < top; i++, dest += lpSurface->pitch)
  272. {
  273. for (j = 0; j < 8 && x + j < lpSurface->w; j++)
  274. {
  275. if (iso_font_8x8[wChar][i] & (1 << j))
  276. {
  277. dest[j] = bColor;
  278. }
  279. }
  280. }
  281. }
  282. else
  283. {
  284. if (font_width[wChar] == 32)
  285. {
  286. for (i = 0; i < _font_height * 2 && dest < top; i += 2, dest += lpSurface->pitch)
  287. {
  288. for (j = 0; j < 8 && x + j < lpSurface->w; j++)
  289. {
  290. if (unicode_font[wChar][i] & (1 << (7 - j)))
  291. {
  292. dest[j] = bColor;
  293. }
  294. }
  295. for (j = 0; j < 8 && x + j + 8 < lpSurface->w; j++)
  296. {
  297. if (unicode_font[wChar][i + 1] & (1 << (7 - j)))
  298. {
  299. dest[j + 8] = bColor;
  300. }
  301. }
  302. }
  303. }
  304. else
  305. {
  306. for (i = 0; i < _font_height && dest < top; i++, dest += lpSurface->pitch)
  307. {
  308. for (j = 0; j < 8 && x + j < lpSurface->w; j++)
  309. {
  310. if (unicode_font[wChar][i] & (1 << (7 - j)))
  311. {
  312. dest[j] = bColor;
  313. }
  314. }
  315. }
  316. }
  317. }
  318. }
  319. int
  320. PAL_CharWidth(
  321. uint16_t wChar
  322. )
  323. {
  324. if ((wChar >= unicode_lower_top && wChar < unicode_upper_base) || wChar >= unicode_upper_top)
  325. {
  326. return 0;
  327. }
  328. //
  329. // Locate for this character in the font lib.
  330. //
  331. if (wChar >= unicode_upper_base)
  332. {
  333. wChar -= (unicode_upper_base - unicode_lower_top);
  334. }
  335. return font_width[wChar] >> 1;
  336. }
  337. int
  338. PAL_FontHeight(
  339. void
  340. )
  341. {
  342. return _font_height;
  343. }