font.c 7.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372
  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. // Convert characters into unicode
  77. //
  78. nChars = PAL_MultiByteToWideChar(char_buf, nBytes, NULL, 0);
  79. if (NULL == (wchar_buf = (wchar_t *)malloc(nChars * sizeof(wchar_t))))
  80. {
  81. free(char_buf);
  82. return;
  83. }
  84. PAL_MultiByteToWideChar(char_buf, nBytes, wchar_buf, nChars);
  85. free(char_buf);
  86. //
  87. // Read bitmaps from wor16.fon file.
  88. //
  89. fp = UTIL_OpenFile("wor16.fon");
  90. //
  91. // The font glyph data begins at offset 0x682 in wor16.fon.
  92. //
  93. fseek(fp, 0x682, SEEK_SET);
  94. //
  95. // Replace the original fonts
  96. //
  97. for (i = 0; i < nChars; i++)
  98. {
  99. wchar_t w = (wchar_buf[i] >= unicode_upper_base) ? (wchar_buf[i] - unicode_upper_base + unicode_lower_top) : wchar_buf[i];
  100. if (fread(unicode_font[w], 30, 1, fp) == 1)
  101. {
  102. unicode_font[w][30] = 0;
  103. unicode_font[w][31] = 0;
  104. }
  105. }
  106. free(wchar_buf);
  107. fclose(fp);
  108. for (i = 0; i < 0x80; i++)
  109. {
  110. int j=-1;while(j++<16)unicode_font[i][j]=reverseBits(iso_font[i*15+j]);
  111. unicode_font[i][15] = 0;
  112. }
  113. _font_height = 15;
  114. }
  115. INT
  116. PAL_LoadUserFont(
  117. LPCSTR pszBdfFileName
  118. )
  119. /*++
  120. Purpose:
  121. Loads a BDF bitmap font file.
  122. Parameters:
  123. [IN] pszBdfFileName - Name of BDF bitmap font file..
  124. Return value:
  125. 0 = success, -1 = failure.
  126. --*/
  127. {
  128. char buf[4096];
  129. int state = 0;
  130. int codepage = -1;
  131. DWORD dwEncoding = 0;
  132. BYTE bFontGlyph[32] = {0};
  133. int iCurHeight = 0;
  134. FILE *fp = UTIL_OpenFileForMode(pszBdfFileName, "r");
  135. if (fp == NULL)
  136. {
  137. return -1;
  138. }
  139. while (fgets(buf, 4096, fp) != NULL)
  140. {
  141. if (state == 0)
  142. {
  143. if (strncmp(buf, "CHARSET_REGISTRY", 16) == 0)
  144. {
  145. if (strstr(buf, "Big5") != NULL)
  146. {
  147. codepage = CP_BIG5;
  148. }
  149. else if (strstr(buf, "BIG5") != NULL)
  150. {
  151. codepage = CP_BIG5;
  152. }
  153. //else if (strstr(buf, "JISX0208") != NULL)
  154. //
  155. // codepage = CP_JISX0208;
  156. //}
  157. }
  158. else if (strncmp(buf, "ENCODING", 8) == 0)
  159. {
  160. dwEncoding = atoi(buf + 8);
  161. }
  162. else if (strncmp(buf, "BITMAP", 6) == 0)
  163. {
  164. state = 1;
  165. iCurHeight = 0;
  166. memset(bFontGlyph, 0, sizeof(bFontGlyph));
  167. }
  168. }
  169. else if (state == 1)
  170. {
  171. if (strncmp(buf, "ENDCHAR", 7) == 0)
  172. {
  173. //
  174. // Replace the original fonts
  175. //
  176. BYTE szCp[3];
  177. szCp[0] = (dwEncoding >> 8) & 0xFF;
  178. szCp[1] = dwEncoding & 0xFF;
  179. szCp[2] = 0;
  180. wchar_t wc[2] = { 0 };
  181. PAL_MultiByteToWideCharCP(codepage, (LPCSTR)szCp, 2, wc, 1);
  182. if (wc[0] != 0)
  183. {
  184. wchar_t w = (wc[0] >= unicode_upper_base) ? (wc[0] - unicode_upper_base + unicode_lower_top) : wc[0];
  185. memcpy(unicode_font[w], bFontGlyph, sizeof(bFontGlyph));
  186. }
  187. state = 0;
  188. }
  189. else
  190. {
  191. if (iCurHeight < 16)
  192. {
  193. WORD wCode = strtoul(buf, NULL, 16);
  194. bFontGlyph[iCurHeight * 2] = (wCode >> 8);
  195. bFontGlyph[iCurHeight * 2 + 1] = (wCode & 0xFF);
  196. iCurHeight++;
  197. }
  198. }
  199. }
  200. }
  201. _font_height = 16;
  202. fclose(fp);
  203. return 0;
  204. }
  205. int
  206. PAL_InitFont(
  207. const CONFIGURATION* cfg
  208. )
  209. {
  210. if (!cfg->fIsWIN95)
  211. {
  212. PAL_LoadEmbeddedFont();
  213. }
  214. if (cfg->pszFontFile)
  215. {
  216. PAL_LoadUserFont(cfg->pszFontFile);
  217. }
  218. return 0;
  219. }
  220. void
  221. PAL_FreeFont(
  222. void
  223. )
  224. {
  225. }
  226. void
  227. PAL_DrawCharOnSurface(
  228. uint16_t wChar,
  229. SDL_Surface *lpSurface,
  230. PAL_POS pos,
  231. uint8_t bColor,
  232. BOOL fUse8x8Font
  233. )
  234. {
  235. int i, j;
  236. int x = PAL_X(pos), y = PAL_Y(pos);
  237. //
  238. // Check for NULL pointer & invalid char code.
  239. //
  240. if (lpSurface == NULL || (wChar >= unicode_lower_top && wChar < unicode_upper_base) ||
  241. wChar >= unicode_upper_top || (_font_height == 8 && wChar >= 0x100))
  242. {
  243. return;
  244. }
  245. //
  246. // Locate for this character in the font lib.
  247. //
  248. if (wChar >= unicode_upper_base)
  249. {
  250. wChar -= (unicode_upper_base - unicode_lower_top);
  251. }
  252. //
  253. // Draw the character to the surface.
  254. //
  255. LPBYTE dest = (LPBYTE)lpSurface->pixels + y * lpSurface->pitch + x;
  256. LPBYTE top = (LPBYTE)lpSurface->pixels + lpSurface->h * lpSurface->pitch;
  257. if (fUse8x8Font)
  258. {
  259. for (i = 0; i < 8 && dest < top; i++, dest += lpSurface->pitch)
  260. {
  261. for (j = 0; j < 8 && x + j < lpSurface->w; j++)
  262. {
  263. if (iso_font_8x8[wChar][i] & (1 << j))
  264. {
  265. dest[j] = bColor;
  266. }
  267. }
  268. }
  269. }
  270. else
  271. {
  272. if (font_width[wChar] == 32)
  273. {
  274. for (i = 0; i < _font_height * 2 && dest < top; i += 2, dest += lpSurface->pitch)
  275. {
  276. for (j = 0; j < 8 && x + j < lpSurface->w; j++)
  277. {
  278. if (unicode_font[wChar][i] & (1 << (7 - j)))
  279. {
  280. dest[j] = bColor;
  281. }
  282. }
  283. for (j = 0; j < 8 && x + j + 8 < lpSurface->w; j++)
  284. {
  285. if (unicode_font[wChar][i + 1] & (1 << (7 - j)))
  286. {
  287. dest[j + 8] = bColor;
  288. }
  289. }
  290. }
  291. }
  292. else
  293. {
  294. for (i = 0; i < _font_height && dest < top; i++, dest += lpSurface->pitch)
  295. {
  296. for (j = 0; j < 8 && x + j < lpSurface->w; j++)
  297. {
  298. if (unicode_font[wChar][i] & (1 << (7 - j)))
  299. {
  300. dest[j] = bColor;
  301. }
  302. }
  303. }
  304. }
  305. }
  306. }
  307. int
  308. PAL_CharWidth(
  309. uint16_t wChar
  310. )
  311. {
  312. if ((wChar >= unicode_lower_top && wChar < unicode_upper_base) || wChar >= unicode_upper_top)
  313. {
  314. return 0;
  315. }
  316. //
  317. // Locate for this character in the font lib.
  318. //
  319. if (wChar >= unicode_upper_base)
  320. {
  321. wChar -= (unicode_upper_base - unicode_lower_top);
  322. }
  323. return font_width[wChar] >> 1;
  324. }
  325. int
  326. PAL_FontHeight(
  327. void
  328. )
  329. {
  330. return _font_height;
  331. }