|
|
@@ -0,0 +1,1214 @@
|
|
|
+/*
|
|
|
+ general font collections
|
|
|
+ http://www.smashingmagazine.com/2007/11/08/40-excellent-freefonts-for-professional-design/
|
|
|
+ http://techmagazine.ws/most-popular-free-quality-fonts/
|
|
|
+ http://openfontlibrary.org/
|
|
|
+ bitmap font collections
|
|
|
+ http://www.orgdot.com/aliasfonts/ (includes links)
|
|
|
+ http://www.04.jp.org/
|
|
|
+ http://www.miniml.com
|
|
|
+ http://www.fontspace.com/010bus
|
|
|
+
|
|
|
+ http://en.wikipedia.org/wiki/Unicode_typeface
|
|
|
+ da könnten auch ein paar fonts dabei sein, die die m2tklib sonderzeichen beinhalten:
|
|
|
+ Caslon Roman http://en.wikipedia.org/wiki/Caslon_Roman
|
|
|
+ Charis Sil http://en.wikipedia.org/wiki/Charis_SIL
|
|
|
+ DejaVu Sans http://en.wikipedia.org/wiki/DejaVu_fonts
|
|
|
+ Doulos http://en.wikipedia.org/wiki/Doulos_SIL
|
|
|
+ Free Serif http://en.wikipedia.org/wiki/FreeSerif http://ftp.gnu.org/gnu/freefont/
|
|
|
+ --> keine box, aber es gibt pfeile/invertierte pfeile und kreise für m2tklib
|
|
|
+ Gentium Plus ???? http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=Gentium_download#02b091ae
|
|
|
+ --> keine graphic
|
|
|
+ GNU Unifont http://en.wikipedia.org/wiki/GNU_Unifont, http://unifoundry.com/unifont.html
|
|
|
+
|
|
|
+ Titus cyberbit Basic http://en.wikipedia.org/wiki/TITUS_Cyberbit_Basic
|
|
|
+
|
|
|
+ fonts
|
|
|
+ Gentium
|
|
|
+ http://openfontlibrary.org/font/gentium
|
|
|
+ license: OFL
|
|
|
+ Old-Standard
|
|
|
+ http://openfontlibrary.org/font/old-standard
|
|
|
+ license: OFL
|
|
|
+ Hanuman
|
|
|
+ http://openfontlibrary.org/font/hanumanb
|
|
|
+ license: OFL
|
|
|
+ FreeUniversal
|
|
|
+ http://openfontlibrary.org/font/freeuniversal
|
|
|
+ license: OFL
|
|
|
+ FriendShip-Code <--- nicht so sicher...
|
|
|
+ http://openfontlibrary.org/font/friendship-code
|
|
|
+ license: CC-BY-SA
|
|
|
+ LinuxLibertine
|
|
|
+ http://de.wikipedia.org/wiki/Linux_Libertine
|
|
|
+ http://sourceforge.net/projects/linuxlibertine/files/linuxlibertine/5.1.3-2/
|
|
|
+ license: OFL
|
|
|
+ DidactGothic
|
|
|
+ source: http://openfontlibrary.org/
|
|
|
+ judson
|
|
|
+ source: http://openfontlibrary.org/
|
|
|
+ unicons
|
|
|
+ source: http://openfontlibrary.org/
|
|
|
+ license: OFL
|
|
|
+ suggested pt: 26, 30
|
|
|
+ org_V01, fixed_V0
|
|
|
+ source: http://www.orgdot.com/aliasfonts/
|
|
|
+ license: open source, individual, cite required
|
|
|
+ suggested pt: 8
|
|
|
+ 04b_03b.zip 04b_03.zip 04b_09.zip 04b_11.zip 04b_19.zip 04b_21.zip 04b_25.zip 04b_30.zip
|
|
|
+ source: http://www.04.jp.org/
|
|
|
+ license: "Freeware: You may use them as you like"
|
|
|
+ 7px4bus
|
|
|
+ source: http://www.fontspace.com/010bus
|
|
|
+ license: Licensed as: Freeware, Commercial use allowed!
|
|
|
+ suggested 7pt
|
|
|
+ 8pxbus
|
|
|
+ source: http://www.fontspace.com/010bus
|
|
|
+ license: Licensed as: Freeware, Commercial use allowed!
|
|
|
+ suggested 8pt
|
|
|
+
|
|
|
+*/
|
|
|
+
|
|
|
+/*
|
|
|
+ only supports metric set "0"
|
|
|
+ assume DWIDTH second arg to be 0 for all glyphs
|
|
|
+ assumes that (0,0) of the BBX is placed on the base line
|
|
|
+ assumes ISO10646 encoding of the BDF file
|
|
|
+
|
|
|
+ font information
|
|
|
+ offset
|
|
|
+ 0 font format
|
|
|
+ 1 FONTBOUNDINGBOX width unsigned
|
|
|
+ 2 FONTBOUNDINGBOX height unsigned
|
|
|
+ 3 FONTBOUNDINGBOX x-offset signed
|
|
|
+ 4 FONTBOUNDINGBOX y-offset signed
|
|
|
+ 5 capital A height unsigned
|
|
|
+ 6 start 'A'
|
|
|
+ 8 start 'a'
|
|
|
+ 10 encoding start
|
|
|
+ 11 encoding end
|
|
|
+ 12 descent 'g' negative: below baseline
|
|
|
+ 13 font max ascent
|
|
|
+ 14 font min decent negative: below baseline
|
|
|
+ 15 xascent (ascent of "(")
|
|
|
+ 16 xdescent (descent of ")")
|
|
|
+
|
|
|
+format 0
|
|
|
+ glyph information
|
|
|
+ offset
|
|
|
+ 0 BBX width unsigned
|
|
|
+ 1 BBX height unsigned
|
|
|
+ 2 data size unsigned (BBX width + 7)/8 * BBX height
|
|
|
+ 3 DWIDTH signed
|
|
|
+ 4 BBX xoffset signed
|
|
|
+ 5 BBX yoffset signed
|
|
|
+
|
|
|
+format 1
|
|
|
+ 0 BBX xoffset signed --> upper 4 Bit
|
|
|
+ 0 BBX yoffset signed --> lower 4 Bit
|
|
|
+ 1 BBX width unsigned --> upper 4 Bit
|
|
|
+ 1 BBX height unsigned --> lower 4 Bit
|
|
|
+ 2 data size unsigned -(BBX width + 7)/8 * BBX height --> lower 4 Bit
|
|
|
+ 2 DWIDTH signed --> upper 4 Bit
|
|
|
+ byte 0 == 255 indicates empty glyph
|
|
|
+
|
|
|
+format 2
|
|
|
+ like format 0, but 4 gray levels for the glyph (4 pixel per byte in the glyph data)
|
|
|
+
|
|
|
+ The glyph bitmap size is defined by BBX width and BBX height
|
|
|
+ number of bytes in the bitmap data (BBX width + 7)/8 * BBX height (format 0 and 1)
|
|
|
+
|
|
|
+ draw_text(x,y,str)
|
|
|
+ get_text_frame(x,y,str, &x1, &y1, &width, &height)
|
|
|
+ frame( x1, y1, width, height)
|
|
|
+ underline( x1, y-1, width )
|
|
|
+
|
|
|
+ size of the surrounding bbox
|
|
|
+
|
|
|
+ width = - xoffset(c1) + DWIDTH(c1) + DWIDTH(c2) + ... + DWIDTH(cn-1) + width(cn) + xoffset(cn)
|
|
|
+ height = FONTBOUNDINGBOX height
|
|
|
+ x1 = x + xoffset(c1)
|
|
|
+ y1 = y + yoffset(c1)
|
|
|
+
|
|
|
+ISO-8859-1 was incorporated as the first 256 code points of ISO/IEC 10646 and Unicode.
|
|
|
+
|
|
|
+*/
|
|
|
+
|
|
|
+#include <stdio.h>
|
|
|
+#include <stdlib.h>
|
|
|
+#include <string.h>
|
|
|
+#include <assert.h>
|
|
|
+
|
|
|
+#define BDF2U8G_COMPACT_OUTPUT
|
|
|
+#define BDF2U8G_VERSION "1.01"
|
|
|
+//#define VERBOSE
|
|
|
+
|
|
|
+/*=== forward declaration ===*/
|
|
|
+void bdf_aa_ClearDoShow(void);
|
|
|
+void bdf_aa_Do(void);
|
|
|
+
|
|
|
+/*=== result data ===*/
|
|
|
+#define DATA_BUF_SIZE (1024 * 64)
|
|
|
+unsigned char data_buf[DATA_BUF_SIZE];
|
|
|
+int data_pos = 0;
|
|
|
+
|
|
|
+void data_Init(void) {
|
|
|
+ data_pos = 0;
|
|
|
+}
|
|
|
+
|
|
|
+void data_Put(unsigned char c) {
|
|
|
+ data_buf[data_pos] = c;
|
|
|
+ data_pos++;
|
|
|
+}
|
|
|
+
|
|
|
+void data_Write(FILE *out_fp, const char *indent) {
|
|
|
+ int i;
|
|
|
+ int bytes_per_line = 16;
|
|
|
+ for (i = 0; i < data_pos; i++) {
|
|
|
+ fprintf(out_fp, "0x%02X", data_buf[i]);
|
|
|
+ if (i + 1 != data_pos)
|
|
|
+ fprintf(out_fp, ",");
|
|
|
+ if ((i + 1) % bytes_per_line == 0)
|
|
|
+ fprintf(out_fp, "\n%s", indent);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*=== low level parser ===*/
|
|
|
+#define P_BUF_SIZE (1024 * 4)
|
|
|
+int p_current_char;
|
|
|
+const char *p_line;
|
|
|
+char p_buf[P_BUF_SIZE];
|
|
|
+
|
|
|
+/* put next char into p_current_char */
|
|
|
+static int p_next_char(void) {
|
|
|
+ p_current_char = *p_line;
|
|
|
+ if (p_current_char == '\0')
|
|
|
+ return 0;
|
|
|
+ p_line++;
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+int p_first_char(const char *line) {
|
|
|
+ p_line = line;
|
|
|
+ return p_next_char();
|
|
|
+}
|
|
|
+
|
|
|
+void p_err(const char *msg) {
|
|
|
+}
|
|
|
+
|
|
|
+int p_skip_space(void) {
|
|
|
+ for (;;) {
|
|
|
+ if (p_current_char == 0 || p_current_char > 32)
|
|
|
+ break;
|
|
|
+ if (p_next_char() == 0)
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+/* put identifier into p_buf */
|
|
|
+int p_get_identifier(void) {
|
|
|
+ int i = 0;
|
|
|
+ if (p_current_char == '\0')
|
|
|
+ return p_err("unexpected EOF (expected identifier)"), 0;
|
|
|
+ for (;;) {
|
|
|
+ if (p_current_char <= 32)
|
|
|
+ break;
|
|
|
+ p_buf[i++] = p_current_char;
|
|
|
+ if (p_next_char() == 0)
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ p_buf[i++] = '\0';
|
|
|
+ p_skip_space();
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+/* put identifier into p_buf */
|
|
|
+int p_get_identifier_with_blank(void) {
|
|
|
+ int i = 0;
|
|
|
+ for (;;) {
|
|
|
+ if (p_current_char < 32)
|
|
|
+ break;
|
|
|
+ p_buf[i++] = p_current_char;
|
|
|
+ if (p_next_char() == 0)
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ p_buf[i++] = '\0';
|
|
|
+ p_skip_space();
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+int p_get_string(void) {
|
|
|
+ int i = 0;
|
|
|
+ if (p_current_char == '\0')
|
|
|
+ return 0;
|
|
|
+ if (p_current_char != '\"')
|
|
|
+ return p_err("\" expected"), 0;
|
|
|
+ if (p_next_char() == 0)
|
|
|
+ return p_err("unexpected EOF (\")"), 0;
|
|
|
+ for (;;) {
|
|
|
+ if (p_current_char == '\\') {
|
|
|
+ if (p_next_char() == 0)
|
|
|
+ return p_err("unexpected EOF (\\)"), 0;
|
|
|
+ }
|
|
|
+ else if (p_current_char == '\"') {
|
|
|
+ p_next_char();
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ p_buf[i++] = p_current_char;
|
|
|
+ if (p_next_char() == 0)
|
|
|
+ return p_err("unexpected EOF (\")"), 0;
|
|
|
+ }
|
|
|
+ p_buf[i] = '\0';
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+int p_get_any(void) {
|
|
|
+ if (p_current_char == '\"')
|
|
|
+ return p_get_string();
|
|
|
+ return p_get_identifier();
|
|
|
+}
|
|
|
+
|
|
|
+int p_get_val(void) {
|
|
|
+ p_get_any();
|
|
|
+ return atoi(p_buf);
|
|
|
+}
|
|
|
+
|
|
|
+int p_get_hex(void) {
|
|
|
+ int value = 0;
|
|
|
+ if (p_current_char >= '0' && p_current_char <= '9')
|
|
|
+ value = p_current_char - '0';
|
|
|
+ else if (p_current_char >= 'a' && p_current_char <= 'f')
|
|
|
+ value = p_current_char - 'a' + 10;
|
|
|
+ else if (p_current_char >= 'A' && p_current_char <= 'F')
|
|
|
+ value = p_current_char - 'A' + 10;
|
|
|
+ p_next_char();
|
|
|
+ return value;
|
|
|
+}
|
|
|
+
|
|
|
+int p_get_hex_byte(void) {
|
|
|
+ int v;
|
|
|
+ v = p_get_hex();
|
|
|
+ v *= 16;
|
|
|
+ v += p_get_hex();
|
|
|
+ return v;
|
|
|
+}
|
|
|
+
|
|
|
+/*=== encoding mapping ===*/
|
|
|
+/* the internal u8g index number (0..255) is mapped to the unicode number */
|
|
|
+/* for the conversion we need the reverse search */
|
|
|
+/* 0 is special and means not found */
|
|
|
+int map_u8g_to_unicode[256];
|
|
|
+
|
|
|
+int map_UnicodeToU8G(int unicode) {
|
|
|
+ int i;
|
|
|
+ for (i = 0; i < 256; i++)
|
|
|
+ if (map_u8g_to_unicode[i] == unicode)
|
|
|
+ return i;
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+void map_Init(void) {
|
|
|
+ int i;
|
|
|
+ map_u8g_to_unicode[0] = 0;
|
|
|
+ for (i = 0; i < 256; i++) map_u8g_to_unicode[i] = i;
|
|
|
+}
|
|
|
+
|
|
|
+void map_UpperLowerPage(int lower_page, int upper_page, int shift, int upper_shift) {
|
|
|
+ int i;
|
|
|
+ int encoding;
|
|
|
+ int tmp[256];
|
|
|
+ // map_u8g_to_unicode[0] = 0;
|
|
|
+ for (i = 0; i < 128; i++) {
|
|
|
+ encoding = i + lower_page * 128;
|
|
|
+ map_u8g_to_unicode[i] = encoding;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (i = 128; i < 256; i++) {
|
|
|
+ encoding = i - 128 + upper_page * 128;
|
|
|
+ if (i + upper_shift < 256)
|
|
|
+ map_u8g_to_unicode[i + upper_shift] = encoding;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (i = 0; i < 256; i++) tmp[i] = map_u8g_to_unicode[i];
|
|
|
+
|
|
|
+ for (i = 0; i < shift; i++) map_u8g_to_unicode[i] = -1;
|
|
|
+
|
|
|
+ for (i = shift; i < 256; i++) map_u8g_to_unicode[i] = tmp[(i + 256 - shift) % 256];
|
|
|
+ /*
|
|
|
+ printf("map_u8g_to_unicode[ 32 ] = %d\n", map_u8g_to_unicode[ 32 ]);
|
|
|
+ printf("map_u8g_to_unicode[ 33 ] = %d\n", map_u8g_to_unicode[ 33 ]);
|
|
|
+ */
|
|
|
+}
|
|
|
+
|
|
|
+/*=== store bdf file positions ===*/
|
|
|
+
|
|
|
+long bdf_last_line_start_pos;
|
|
|
+long bdf_encoding_pos[256];
|
|
|
+
|
|
|
+void bdf_InitFilePos(void) {
|
|
|
+ int i;
|
|
|
+ for (i = 0; i < 256; i++) bdf_encoding_pos[i] = 0;
|
|
|
+}
|
|
|
+
|
|
|
+void bdf_SetFilePos(FILE *fp, int encoding) {
|
|
|
+ if (encoding < 0)
|
|
|
+ return;
|
|
|
+ if (bdf_encoding_pos[encoding] == 0L)
|
|
|
+ return;
|
|
|
+ fseek(fp, bdf_encoding_pos[encoding], SEEK_SET);
|
|
|
+ // fprintf(stderr, "setting file for encoding %d to pos %ld\n", encoding, bdf_encoding_pos[encoding]);
|
|
|
+}
|
|
|
+
|
|
|
+int bdf_IsEncodingAvailable(int encoding) {
|
|
|
+ if (bdf_encoding_pos[encoding] == 0L)
|
|
|
+ // printf("encoding %d not availabe\n", encoding);
|
|
|
+ return 0;
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+void bdf_StoreFilePos(int encoding, long pos) {
|
|
|
+ // if ( encoding == 33 )
|
|
|
+ // printf("encoding %d at pos %ld\n", encoding, pos);
|
|
|
+ if (bdf_encoding_pos[encoding] != 0L)
|
|
|
+ return;
|
|
|
+ bdf_encoding_pos[encoding] = pos;
|
|
|
+}
|
|
|
+
|
|
|
+/*=== bdf file read ===*/
|
|
|
+
|
|
|
+int bdf_font_format = 0;
|
|
|
+
|
|
|
+#define BDF_STATE_FONT_DATA 0
|
|
|
+#define BDF_STATE_ENCODING 1
|
|
|
+
|
|
|
+int bdf_state = BDF_STATE_FONT_DATA;
|
|
|
+int bdf_requested_encoding = 0;
|
|
|
+
|
|
|
+#define BDF_LINE_MAX (1024 * 4)
|
|
|
+#define BDF_LINE_STATE_KEYWORDS 0
|
|
|
+#define BDF_LINE_STATE_BITMAP 1
|
|
|
+#define BDF_MAX_HEIGHT 200
|
|
|
+#define BDF_AA_OFFSET 1
|
|
|
+
|
|
|
+char bdf_copyright[BDF_LINE_MAX];
|
|
|
+char bdf_font[BDF_LINE_MAX];
|
|
|
+unsigned char bdf_bitmap_line[BDF_MAX_HEIGHT][20];
|
|
|
+unsigned char bdf_aa_bitmap_line[BDF_MAX_HEIGHT + 2 * BDF_AA_OFFSET][(20 + 2 * BDF_AA_OFFSET) * 8];
|
|
|
+
|
|
|
+int bdf_line_state = BDF_LINE_STATE_KEYWORDS;
|
|
|
+int bdf_line_bm_line = 0;
|
|
|
+
|
|
|
+int bdf_font_size; /* point font size */
|
|
|
+
|
|
|
+int bdf_font_width; /* FONTBOUNDINGBOX arg 1 */
|
|
|
+int bdf_font_height; /* FONTBOUNDINGBOX arg 2 */
|
|
|
+int bdf_font_x; /* FONTBOUNDINGBOX arg 3 */
|
|
|
+int bdf_font_y; /* FONTBOUNDINGBOX arg 4 */
|
|
|
+
|
|
|
+int bdf_capital_A_height;
|
|
|
+int bdf_capital_1_height;
|
|
|
+int bdf_lower_g_descent;
|
|
|
+
|
|
|
+int bdf_char_width; /* BBX arg 1 */
|
|
|
+int bdf_char_max_width;
|
|
|
+int bdf_char_height; /* BBX arg 2 */
|
|
|
+int bdf_char_ascent; /* defined as BBX arg 2 + BBX arg 4 */
|
|
|
+int bdf_char_xascent;
|
|
|
+int bdf_char_xdescent;
|
|
|
+int bdf_char_max_ascent;
|
|
|
+int bdf_char_max_height;
|
|
|
+int bdf_char_x; /* BBX arg 3 */
|
|
|
+int bdf_char_max_x;
|
|
|
+int bdf_char_min_x;
|
|
|
+int bdf_char_y; /* BBX arg 4 */
|
|
|
+int bdf_char_max_y;
|
|
|
+int bdf_char_min_y;
|
|
|
+
|
|
|
+int bdf_delta_x_default = -1;
|
|
|
+int bdf_delta_x = -1; /* DWIDTH arg 1 */
|
|
|
+int bdf_delta_max_x;
|
|
|
+int bdf_delta_min_x;
|
|
|
+int bdf_delta_y; /* DWIDTH arg 2 */
|
|
|
+int bdf_delta_max_y;
|
|
|
+int bdf_delta_min_y;
|
|
|
+
|
|
|
+int bdf_glyph_data_len;
|
|
|
+int bdf_glyph_data_max_len;
|
|
|
+
|
|
|
+int bdf_encoding;
|
|
|
+
|
|
|
+int bdf_encoding_65_pos;
|
|
|
+int bdf_encoding_97_pos;
|
|
|
+int bdf_is_encoding_successfully_done;
|
|
|
+
|
|
|
+char bdf_info[32000 * 2];
|
|
|
+
|
|
|
+int bdf_is_put_glyph_completed = 0; /* indicator, when the glyph has been processed */
|
|
|
+
|
|
|
+void bdf_ResetMax(void) {
|
|
|
+ bdf_char_max_width = 0;
|
|
|
+ bdf_char_max_height = 0;
|
|
|
+ bdf_char_max_x = 0;
|
|
|
+ bdf_char_max_y = 0;
|
|
|
+ bdf_delta_max_x = 0;
|
|
|
+ bdf_delta_max_y = 0;
|
|
|
+ bdf_char_min_x = 0;
|
|
|
+ bdf_char_min_y = 0;
|
|
|
+ bdf_delta_min_x = 0;
|
|
|
+ bdf_delta_min_y = 0;
|
|
|
+ bdf_glyph_data_max_len = 0;
|
|
|
+ bdf_char_max_ascent = 0;
|
|
|
+ bdf_char_xascent = 0;
|
|
|
+ bdf_char_xdescent = 0;
|
|
|
+}
|
|
|
+
|
|
|
+void bdf_UpdateMax(void) {
|
|
|
+ if (bdf_char_max_width < bdf_char_width)
|
|
|
+ bdf_char_max_width = bdf_char_width;
|
|
|
+ if (bdf_char_max_height < bdf_char_height)
|
|
|
+ bdf_char_max_height = bdf_char_height;
|
|
|
+
|
|
|
+ if (bdf_char_max_x < bdf_char_x)
|
|
|
+ bdf_char_max_x = bdf_char_x;
|
|
|
+
|
|
|
+ if (bdf_char_max_y < bdf_char_y)
|
|
|
+ bdf_char_max_y = bdf_char_y;
|
|
|
+
|
|
|
+ if (bdf_delta_max_x < bdf_delta_x)
|
|
|
+ bdf_delta_max_x = bdf_delta_x;
|
|
|
+ if (bdf_delta_max_y < bdf_delta_y)
|
|
|
+ bdf_delta_max_y = bdf_delta_y;
|
|
|
+
|
|
|
+ if (bdf_char_min_x > bdf_char_x)
|
|
|
+ bdf_char_min_x = bdf_char_x;
|
|
|
+
|
|
|
+ if (bdf_char_min_y > bdf_char_y)
|
|
|
+ bdf_char_min_y = bdf_char_y;
|
|
|
+
|
|
|
+ if (bdf_delta_min_x > bdf_delta_x)
|
|
|
+ bdf_delta_min_x = bdf_delta_x;
|
|
|
+ if (bdf_delta_min_y > bdf_delta_y)
|
|
|
+ bdf_delta_min_y = bdf_delta_y;
|
|
|
+
|
|
|
+ if (bdf_glyph_data_max_len < bdf_glyph_data_len)
|
|
|
+ bdf_glyph_data_max_len = bdf_glyph_data_len;
|
|
|
+
|
|
|
+ if (bdf_char_max_ascent < bdf_char_ascent)
|
|
|
+ bdf_char_max_ascent = bdf_char_ascent;
|
|
|
+}
|
|
|
+
|
|
|
+void bdf_ShowGlyph(void) {
|
|
|
+ #ifdef VERBOSE
|
|
|
+ int x, y, byte, bit;
|
|
|
+ int gx, gy;
|
|
|
+ char *p;
|
|
|
+ gy = bdf_char_height - 1 + bdf_char_y;
|
|
|
+ printf("bbx %d %d %d %d encoding %d\n", bdf_char_width, bdf_char_height, bdf_char_x, bdf_char_y, bdf_encoding);
|
|
|
+ for (y = 0; y < bdf_line_bm_line; y++) {
|
|
|
+ printf("%02d ", gy);
|
|
|
+ gx = bdf_char_x;
|
|
|
+ for (x = 0; x < bdf_char_width; x++) {
|
|
|
+ byte = x >> 3;
|
|
|
+ bit = 7 - (x & 7);
|
|
|
+ if ((bdf_bitmap_line[y][byte] & (1 << bit)) == 0)
|
|
|
+ p = " .";
|
|
|
+ else
|
|
|
+ p = " *";
|
|
|
+ if (gy == 0 && gx == 0)
|
|
|
+ p = " o";
|
|
|
+ printf("%s", p);
|
|
|
+ gx++;
|
|
|
+ }
|
|
|
+ printf(" ");
|
|
|
+ for (x = 0; x < ((bdf_char_width + 7) / 8); x++) printf( "%02X", bdf_bitmap_line[y][x]);
|
|
|
+ gy--;
|
|
|
+ printf("\n");
|
|
|
+ }
|
|
|
+ #else
|
|
|
+ printf("bbx %d %d %d %d encoding %d\n", bdf_char_width, bdf_char_height, bdf_char_x, bdf_char_y, bdf_encoding);
|
|
|
+ fflush(stdout);
|
|
|
+ #endif
|
|
|
+}
|
|
|
+
|
|
|
+void bdf_ClearGlyphBuffer(void) {
|
|
|
+ int x, y;
|
|
|
+ for (y = 0; y < BDF_MAX_HEIGHT; y++)
|
|
|
+ for (x = 0; x < 20; x++) bdf_bitmap_line[y][x] = 0;
|
|
|
+}
|
|
|
+
|
|
|
+void bdf_PutGlyph(void) {
|
|
|
+ int len;
|
|
|
+ int y, x;
|
|
|
+
|
|
|
+ if (bdf_state == BDF_STATE_ENCODING) {
|
|
|
+ //if (bdf_char_width == 0 && bdf_char_height == 0) bdf_char_y = 0;
|
|
|
+
|
|
|
+ bdf_char_ascent = bdf_char_height + bdf_char_y;
|
|
|
+ //printf("h:%d w:%d ascent: %d\n", bdf_char_height, bdf_char_width, bdf_char_ascent);
|
|
|
+
|
|
|
+ if (bdf_encoding == 'A')
|
|
|
+ bdf_capital_A_height = bdf_char_height;
|
|
|
+ if (bdf_encoding == '1')
|
|
|
+ bdf_capital_1_height = bdf_char_height;
|
|
|
+
|
|
|
+ if (bdf_encoding == 'g')
|
|
|
+ bdf_lower_g_descent = bdf_char_y;
|
|
|
+
|
|
|
+ if (bdf_char_xascent < bdf_capital_A_height)
|
|
|
+ bdf_char_xascent = bdf_capital_A_height;
|
|
|
+ if (bdf_char_xascent < bdf_capital_1_height)
|
|
|
+ bdf_char_xascent = bdf_capital_1_height;
|
|
|
+ if (bdf_encoding == '(')
|
|
|
+ if (bdf_char_xascent < bdf_char_ascent)
|
|
|
+ bdf_char_xascent = bdf_char_ascent;
|
|
|
+ if (bdf_encoding == '[')
|
|
|
+ if (bdf_char_xascent < bdf_char_ascent)
|
|
|
+ bdf_char_xascent = bdf_char_ascent;
|
|
|
+
|
|
|
+ if (bdf_char_xdescent > bdf_lower_g_descent)
|
|
|
+ bdf_char_xdescent = bdf_lower_g_descent;
|
|
|
+ if (bdf_encoding == '(')
|
|
|
+ if (bdf_char_xdescent > bdf_char_y)
|
|
|
+ bdf_char_xdescent = bdf_char_y;
|
|
|
+ if (bdf_encoding == '[')
|
|
|
+ if (bdf_char_xdescent > bdf_char_y)
|
|
|
+ bdf_char_xdescent = bdf_char_y;
|
|
|
+
|
|
|
+ if (bdf_requested_encoding != bdf_encoding)
|
|
|
+ return;
|
|
|
+
|
|
|
+ assert( bdf_line_bm_line == bdf_char_height);
|
|
|
+
|
|
|
+ bdf_ShowGlyph();
|
|
|
+ #ifdef VERBOSE
|
|
|
+ bdf_aa_ClearDoShow();
|
|
|
+ #endif
|
|
|
+
|
|
|
+ bdf_UpdateMax();
|
|
|
+
|
|
|
+ if (bdf_font_format <= 1)
|
|
|
+ len = (bdf_char_width + 7) / 8 * bdf_char_height;
|
|
|
+ else
|
|
|
+ len = (bdf_char_width + 2 * BDF_AA_OFFSET + 3) / 4 * (bdf_char_height + 2 * BDF_AA_OFFSET);
|
|
|
+ if (len > 255) {
|
|
|
+ fprintf(stderr, "Glyph with encoding %d is too large (%d > 255)\n", bdf_encoding, len);
|
|
|
+ exit(1);
|
|
|
+ }
|
|
|
+
|
|
|
+ bdf_glyph_data_len = len;
|
|
|
+
|
|
|
+ /*
|
|
|
+ format 0 and format 2
|
|
|
+ glyph information
|
|
|
+ offset
|
|
|
+ 0 BBX width unsigned
|
|
|
+ 1 BBX height unsigned
|
|
|
+ 2 data size unsigned (BBX width + 7)/8 * BBX height
|
|
|
+ 3 DWIDTH signed
|
|
|
+ 4 BBX xoffset signed
|
|
|
+ 5 BBX yoffset signed
|
|
|
+ */
|
|
|
+
|
|
|
+ if (bdf_font_format == 0) {
|
|
|
+ data_Put(bdf_char_width);
|
|
|
+ data_Put(bdf_char_height);
|
|
|
+ data_Put(bdf_glyph_data_len);
|
|
|
+ data_Put(bdf_delta_x);
|
|
|
+ data_Put(bdf_char_x);
|
|
|
+ data_Put(bdf_char_y);
|
|
|
+ // data_Put(bdf_encoding);
|
|
|
+ bdf_is_encoding_successfully_done = 1;
|
|
|
+ }
|
|
|
+ else if (bdf_font_format == 2) {
|
|
|
+ data_Put(bdf_char_width + 2 * BDF_AA_OFFSET);
|
|
|
+ data_Put(bdf_char_height + 2 * BDF_AA_OFFSET);
|
|
|
+ data_Put(bdf_glyph_data_len);
|
|
|
+ data_Put(bdf_delta_x);
|
|
|
+ data_Put(bdf_char_x - BDF_AA_OFFSET);
|
|
|
+ data_Put(bdf_char_y - BDF_AA_OFFSET);
|
|
|
+ // data_Put(bdf_encoding);
|
|
|
+ bdf_is_encoding_successfully_done = 1;
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ /**
|
|
|
+ * format 1
|
|
|
+ * 0 BBX xoffset signed --> upper 4 Bit
|
|
|
+ * 0 BBX yoffset signed --> lower 4 Bit
|
|
|
+ * 1 BBX width unsigned --> upper 4 Bit
|
|
|
+ * 1 BBX height unsigned --> lower 4 Bit
|
|
|
+ * 2 data size unsigned -(BBX width + 7)/8 * BBX height --> lower 4 Bit
|
|
|
+ * 2 DWIDTH signed --> upper 4 Bit
|
|
|
+ * byte 0 == 255 indicates empty glyph
|
|
|
+ */
|
|
|
+ if (bdf_glyph_data_len < 0 || bdf_glyph_data_len > 15) {
|
|
|
+ fprintf(stderr, "Glyph with encoding %d does not fit for format 1 (data len = %d)\n", bdf_encoding, bdf_glyph_data_len);
|
|
|
+ exit(1);
|
|
|
+ }
|
|
|
+ if (bdf_delta_x < 0 || bdf_delta_x > 15) {
|
|
|
+ fprintf(stderr, "Glyph with encoding %d does not fit for format 1 (DWIDTH = %d)\n", bdf_encoding, bdf_delta_x);
|
|
|
+ exit(1);
|
|
|
+ }
|
|
|
+ if (bdf_char_x < 0 || bdf_char_x > 15) {
|
|
|
+ fprintf(stderr, "Glyph with encoding %d does not fit for format 1 (x-off = %d)\n", bdf_encoding, bdf_char_x);
|
|
|
+ exit(1);
|
|
|
+ }
|
|
|
+ if (bdf_char_y < -2 || bdf_char_y > 13) {
|
|
|
+ fprintf(stderr, "Glyph with encoding %d does not fit for format 1 (y-off = %d [%d..%d])\n", bdf_encoding, bdf_char_y, bdf_char_min_y, bdf_char_max_y);
|
|
|
+ exit(1);
|
|
|
+ }
|
|
|
+ if (bdf_char_width < 0 || bdf_char_width > 15) {
|
|
|
+ fprintf(stderr, "Glyph with encoding %d does not fit for format 1 (width = %d)\n", bdf_encoding, bdf_char_width);
|
|
|
+ exit(1);
|
|
|
+ }
|
|
|
+ if (bdf_char_height < 0 || bdf_char_height > 15) {
|
|
|
+ fprintf(stderr, "Glyph with encoding %d does not fit for format 1 (height = %d)\n", bdf_encoding, bdf_char_height);
|
|
|
+ exit(1);
|
|
|
+ }
|
|
|
+ // data_Put(bdf_encoding);
|
|
|
+ if (((bdf_char_x << 4) | (bdf_char_y + 2)) == 255) {
|
|
|
+ fprintf(stderr, "Glyph with encoding %d does not fit for format 1 (skip mark generated)\n", bdf_encoding);
|
|
|
+ exit(1);
|
|
|
+ }
|
|
|
+ data_Put((bdf_char_x << 4) | (bdf_char_y + 2));
|
|
|
+ data_Put((bdf_char_width << 4) | bdf_char_height );
|
|
|
+ data_Put((bdf_delta_x << 4) | bdf_glyph_data_len );
|
|
|
+ bdf_is_encoding_successfully_done = 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ sprintf(bdf_info + strlen(bdf_info), "/* encoding %d %c, bbx %d %d %d %d asc %d dx %d*/\n",
|
|
|
+ bdf_encoding,
|
|
|
+ bdf_encoding > 32 && bdf_encoding <= 'z' ? bdf_encoding : ' ',
|
|
|
+ bdf_char_width,
|
|
|
+ bdf_char_height,
|
|
|
+ bdf_char_x,
|
|
|
+ bdf_char_y,
|
|
|
+ bdf_char_ascent,
|
|
|
+ bdf_delta_x);
|
|
|
+
|
|
|
+ if (bdf_font_format <= 1) {
|
|
|
+ for (y = 0; y < bdf_char_height; y++)
|
|
|
+ for (x = 0; x < ((bdf_char_width + 7) / 8); x++) {
|
|
|
+ data_Put(bdf_bitmap_line[y][x]);
|
|
|
+ len--;
|
|
|
+ }
|
|
|
+ assert( len == 0 );
|
|
|
+ bdf_is_put_glyph_completed = 1;
|
|
|
+ }
|
|
|
+ else { /* format == 2 */
|
|
|
+ int b, cnt;
|
|
|
+ bdf_aa_Do();
|
|
|
+ for (y = 0; y < bdf_char_height + 2 * BDF_AA_OFFSET; y++) {
|
|
|
+ b = 0;
|
|
|
+ cnt = 0;
|
|
|
+ for (x = 0; x < bdf_char_width + 2 * BDF_AA_OFFSET; x++) {
|
|
|
+ b <<= 2;
|
|
|
+ b |= bdf_aa_bitmap_line[y][x] & 3;
|
|
|
+ cnt++;
|
|
|
+ if (cnt == 4) {
|
|
|
+ data_Put(b);
|
|
|
+ b = 0;
|
|
|
+ cnt = 0;
|
|
|
+ len--;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (cnt != 0) {
|
|
|
+ b <<= 2 * (4 - cnt);
|
|
|
+ data_Put(b);
|
|
|
+ b = 0;
|
|
|
+ cnt = 0;
|
|
|
+ len--;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ assert( len == 0 );
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*=========================================================================*/
|
|
|
+/* Glyph Clipping */
|
|
|
+
|
|
|
+int bdf_IsColZero(int x) {
|
|
|
+ int y, byte, bit;
|
|
|
+ for (y = 0; y < bdf_char_height; y++) {
|
|
|
+ byte = x >> 3;
|
|
|
+ bit = 7 - (x & 7);
|
|
|
+ if ((bdf_bitmap_line[y][byte] & (1 << bit)) != 0)
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+int bdf_IsRowZero(int y) {
|
|
|
+ int x, byte, bit;
|
|
|
+ for (x = 0; x < bdf_char_width; x++) {
|
|
|
+ byte = x >> 3;
|
|
|
+ bit = 7 - (x & 7);
|
|
|
+ if ((bdf_bitmap_line[y][byte] & (1 << bit)) != 0)
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+void bdf_DeleteFirstCol(void) {
|
|
|
+ int m = (bdf_char_width + 7) / 8;
|
|
|
+ int x, y;
|
|
|
+ for (y = 0; y < bdf_char_height; y++)
|
|
|
+ for (x = 0; x < m; x++) {
|
|
|
+ bdf_bitmap_line[y][x] <<= 1;
|
|
|
+ bdf_bitmap_line[y][x] |= bdf_bitmap_line[y][x + 1] >> 7;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void bdf_DeleteFirstRow(void) {
|
|
|
+ int m = (bdf_char_width + 7) / 8;
|
|
|
+ int x, y;
|
|
|
+ for (y = 0; y + 1 < bdf_char_height; y++)
|
|
|
+ for (x = 0; x < m; x++)
|
|
|
+ bdf_bitmap_line[y][x] = bdf_bitmap_line[y + 1][x];
|
|
|
+}
|
|
|
+
|
|
|
+void bdf_ReduceGlyph(void) {
|
|
|
+ while (bdf_char_width > 0) {
|
|
|
+ if (bdf_IsColZero(bdf_char_width - 1) == 0)
|
|
|
+ break;
|
|
|
+ bdf_char_width--;
|
|
|
+ }
|
|
|
+
|
|
|
+ while (bdf_char_height > 0) {
|
|
|
+ if (bdf_IsRowZero(bdf_char_height - 1) == 0)
|
|
|
+ break;
|
|
|
+ bdf_line_bm_line--;
|
|
|
+ bdf_char_height--;
|
|
|
+ bdf_char_y++;
|
|
|
+ }
|
|
|
+
|
|
|
+ while (bdf_IsColZero(0) != 0 && bdf_char_width > 0) {
|
|
|
+ bdf_DeleteFirstCol();
|
|
|
+ bdf_char_x++;
|
|
|
+ bdf_char_width--;
|
|
|
+ }
|
|
|
+
|
|
|
+ while (bdf_char_height > 0) {
|
|
|
+ if (bdf_IsRowZero(0) == 0)
|
|
|
+ break;
|
|
|
+ bdf_DeleteFirstRow();
|
|
|
+ bdf_line_bm_line--;
|
|
|
+ bdf_char_height--;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*=========================================================================*/
|
|
|
+/* Anti Aliasing / Graylevel Glyph */
|
|
|
+
|
|
|
+int bdf_GetXYVal(int x, int y) {
|
|
|
+ int byte, bit;
|
|
|
+
|
|
|
+ if (x < 0) return 0;
|
|
|
+ if (y < 0) return 0;
|
|
|
+ if (x >= bdf_char_width) return 0;
|
|
|
+ if (y >= bdf_char_height) return 0;
|
|
|
+
|
|
|
+ byte = x >> 3;
|
|
|
+ bit = 7 - (x & 7);
|
|
|
+ if ((bdf_bitmap_line[y][byte] & (1 << bit)) != 0) return 1;
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+void bdf_aa_Clear(void) {
|
|
|
+ int x, y;
|
|
|
+ for (y = 0; y < BDF_MAX_HEIGHT + 2 * BDF_AA_OFFSET; y++)
|
|
|
+ for (x = 0; x < (20 + 2 * BDF_AA_OFFSET) * 8; x++)
|
|
|
+ bdf_aa_bitmap_line[y][x] = 0;
|
|
|
+}
|
|
|
+
|
|
|
+void bdf_aa_SetXYVal(int x, int y, int val) {
|
|
|
+ bdf_aa_bitmap_line[y][x] = val;
|
|
|
+}
|
|
|
+
|
|
|
+int bdf_aa_matrix[9] = {
|
|
|
+ 1, 3, 1,
|
|
|
+ 3, 4, 3,
|
|
|
+ 1, 3, 1
|
|
|
+};
|
|
|
+int bdf_aa_sum = 20;
|
|
|
+int bdf_aa_gray_levels = 4;
|
|
|
+
|
|
|
+void bdf_aa_Do(void) {
|
|
|
+ int x, y, val, sx, sy, sum, gray;
|
|
|
+ bdf_aa_Clear();
|
|
|
+ for (y = 0; y < bdf_char_height + 2 * BDF_AA_OFFSET; y++)
|
|
|
+ for (x = 0; x < bdf_char_width + 2 * BDF_AA_OFFSET; x++) {
|
|
|
+ if (bdf_GetXYVal(x - BDF_AA_OFFSET, y - BDF_AA_OFFSET) == 0) {
|
|
|
+ sum = 0;
|
|
|
+ for (sy = -BDF_AA_OFFSET; sy <= BDF_AA_OFFSET; sy++)
|
|
|
+ for (sx = -BDF_AA_OFFSET; sx <= BDF_AA_OFFSET; sx++) {
|
|
|
+ val = bdf_GetXYVal(x + sx - BDF_AA_OFFSET, y + sy - BDF_AA_OFFSET);
|
|
|
+ val *= bdf_aa_matrix[(sy + BDF_AA_OFFSET) * (2 * BDF_AA_OFFSET + 1) + sx + BDF_AA_OFFSET];
|
|
|
+ sum += val;
|
|
|
+ }
|
|
|
+ if (sum <= 5)
|
|
|
+ gray = 0;
|
|
|
+ else
|
|
|
+ gray = (sum * (bdf_aa_gray_levels - 1) + (bdf_aa_sum / 2)) / bdf_aa_sum;
|
|
|
+ if (gray >= bdf_aa_gray_levels)
|
|
|
+ gray = bdf_aa_gray_levels - 1;
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ gray = bdf_aa_gray_levels - 1;
|
|
|
+ }
|
|
|
+ bdf_aa_SetXYVal(x, y, gray);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void bdf_aa_Show(void) {
|
|
|
+ int x, y;
|
|
|
+ if (bdf_font_format == 2) {
|
|
|
+ for (y = 0; y < bdf_char_height + 2 * BDF_AA_OFFSET; y++) {
|
|
|
+ for (x = 0; x < bdf_char_width + 2 * BDF_AA_OFFSET; x++)
|
|
|
+ switch (bdf_aa_bitmap_line[y][x]) {
|
|
|
+ case 0: printf("."); break;
|
|
|
+ case 1: printf("-"); break;
|
|
|
+ case 2: printf("+"); break;
|
|
|
+ case 3: printf("#"); break;
|
|
|
+ }
|
|
|
+ printf("\n");
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void bdf_aa_ClearDoShow(void) {
|
|
|
+ bdf_aa_Do();
|
|
|
+ bdf_aa_Show();
|
|
|
+}
|
|
|
+
|
|
|
+/*=========================================================================*/
|
|
|
+/* Parser */
|
|
|
+
|
|
|
+void bdf_ReadLine(const char *s) {
|
|
|
+ /*
|
|
|
+ if ( bdf_line_state == BDF_LINE_STATE_BITMAP && bdf_requested_encoding != bdf_encoding && *s != 'E' )
|
|
|
+ return;
|
|
|
+ */
|
|
|
+
|
|
|
+ if (p_first_char(s) == 0) return;
|
|
|
+ if (p_skip_space() == 0) return;
|
|
|
+
|
|
|
+ if (bdf_line_state == BDF_LINE_STATE_KEYWORDS) {
|
|
|
+ p_get_identifier();
|
|
|
+ if (strcmp(p_buf, "COPYRIGHT") == 0) {
|
|
|
+ p_get_any();
|
|
|
+ strcpy(bdf_copyright, p_buf);
|
|
|
+ }
|
|
|
+ else if (strcmp(p_buf, "FONT") == 0) {
|
|
|
+ /* p_get_any(); */
|
|
|
+ p_get_identifier_with_blank();
|
|
|
+ strcpy(bdf_font, p_buf);
|
|
|
+ }
|
|
|
+ else if (strcmp(p_buf, "SIZE") == 0) {
|
|
|
+ bdf_font_size = p_get_val();
|
|
|
+ }
|
|
|
+ else if (strcmp(p_buf, "ENCODING") == 0) {
|
|
|
+ bdf_encoding = map_UnicodeToU8G(p_get_val());
|
|
|
+ bdf_StoreFilePos(bdf_encoding, bdf_last_line_start_pos);
|
|
|
+ }
|
|
|
+ else if (strcmp(p_buf, "DWIDTH") == 0) {
|
|
|
+ bdf_delta_x = p_get_val();
|
|
|
+ bdf_delta_y = p_get_val();
|
|
|
+ }
|
|
|
+ else if (strcmp(p_buf, "FONTBOUNDINGBOX") == 0) {
|
|
|
+ bdf_font_width = p_get_val();
|
|
|
+ bdf_font_height = p_get_val();
|
|
|
+ bdf_font_x = p_get_val();
|
|
|
+ bdf_font_y = p_get_val();
|
|
|
+ }
|
|
|
+ else if (strcmp(p_buf, "BBX") == 0) {
|
|
|
+ bdf_char_width = p_get_val();
|
|
|
+ bdf_char_height = p_get_val();
|
|
|
+ bdf_char_x = p_get_val();
|
|
|
+ bdf_char_y = p_get_val();
|
|
|
+ bdf_char_ascent = bdf_char_height + bdf_char_y;
|
|
|
+ // printf("h:%d w:%d ascent: %d\n", bdf_char_height, bdf_char_width, bdf_char_ascent);
|
|
|
+ }
|
|
|
+ else if (strcmp(p_buf, "CHARS") == 0) {
|
|
|
+ if (bdf_delta_x < 0)
|
|
|
+ bdf_delta_x = 0;
|
|
|
+ if (bdf_delta_x_default < 0)
|
|
|
+ bdf_delta_x_default = bdf_delta_x;
|
|
|
+ }
|
|
|
+ else if (strcmp(p_buf, "STARTCHAR") == 0) {
|
|
|
+ if (bdf_delta_x_default < 0)
|
|
|
+ bdf_delta_x_default = 0;
|
|
|
+ bdf_delta_x = bdf_delta_x_default;
|
|
|
+ }
|
|
|
+ else if (strcmp(p_buf, "BITMAP") == 0) {
|
|
|
+ bdf_line_state = BDF_LINE_STATE_BITMAP;
|
|
|
+ bdf_line_bm_line = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else if (bdf_line_state == BDF_LINE_STATE_BITMAP) {
|
|
|
+ if (strncmp(s, "ENDCHAR", 7) == 0) {
|
|
|
+ bdf_ReduceGlyph();
|
|
|
+ bdf_PutGlyph();
|
|
|
+ bdf_line_state = BDF_LINE_STATE_KEYWORDS;
|
|
|
+ bdf_line_bm_line = 0;
|
|
|
+ }
|
|
|
+ else if (bdf_requested_encoding == bdf_encoding) {
|
|
|
+ int i = 0;
|
|
|
+ for (;;) {
|
|
|
+ if (p_current_char < '0') break;
|
|
|
+ bdf_bitmap_line[bdf_line_bm_line][i] = p_get_hex_byte();
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+ bdf_line_bm_line++;
|
|
|
+ assert(bdf_line_bm_line < BDF_MAX_HEIGHT);
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+int bdf_ReadFP(FILE *fp) {
|
|
|
+ static char bdf_line[BDF_LINE_MAX];
|
|
|
+ bdf_is_put_glyph_completed = 0;
|
|
|
+ for (;;) {
|
|
|
+ bdf_last_line_start_pos = ftell(fp);
|
|
|
+ if (fgets(bdf_line, BDF_LINE_MAX - 1, fp) == NULL)
|
|
|
+ break;
|
|
|
+ bdf_ReadLine(bdf_line);
|
|
|
+ if (bdf_is_put_glyph_completed != 0)
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+int bdf_ReadFile(const char *filename, int encoding) {
|
|
|
+ int r;
|
|
|
+ FILE *fp;
|
|
|
+ fp = fopen(filename, "rb");
|
|
|
+ if (fp != NULL) {
|
|
|
+ bdf_SetFilePos(fp, encoding);
|
|
|
+ r = bdf_ReadFP(fp);
|
|
|
+ fclose(fp);
|
|
|
+ return r;
|
|
|
+ }
|
|
|
+ return 0; /* open error */
|
|
|
+}
|
|
|
+
|
|
|
+void bdf_GenerateFontData(const char *filename, int begin, int end) {
|
|
|
+ bdf_state = BDF_STATE_FONT_DATA;
|
|
|
+ bdf_ReadFile(filename, -1);
|
|
|
+ /**
|
|
|
+ * font information
|
|
|
+ *
|
|
|
+ * offset
|
|
|
+ * 0 font format
|
|
|
+ * 1 FONTBOUNDINGBOX width unsigned
|
|
|
+ * 2 FONTBOUNDINGBOX height unsigned
|
|
|
+ * 3 FONTBOUNDINGBOX x-offset signed
|
|
|
+ * 4 FONTBOUNDINGBOX y-offset signed
|
|
|
+ * 5 Capital A Height unsigned
|
|
|
+ * 6 position of encoding 65 'A' high byte first
|
|
|
+ * 8 position of encoding 97 'a' high byte first
|
|
|
+ */
|
|
|
+ data_Put(bdf_font_format);
|
|
|
+ data_Put(bdf_font_width);
|
|
|
+ data_Put(bdf_font_height);
|
|
|
+ data_Put(bdf_font_x);
|
|
|
+ data_Put(bdf_font_y);
|
|
|
+ data_Put(bdf_capital_A_height > 0 ? bdf_capital_A_height : bdf_capital_1_height);
|
|
|
+ data_Put(0);
|
|
|
+ data_Put(0);
|
|
|
+ data_Put(0);
|
|
|
+ data_Put(0);
|
|
|
+ data_Put(begin);
|
|
|
+ data_Put(end); /* will be overwritten later */
|
|
|
+ data_Put(0); /* lower g descent */
|
|
|
+ data_Put(0); /* max ascent */
|
|
|
+ data_Put(0); /* min y = descent */
|
|
|
+ data_Put(0); /* x ascent */
|
|
|
+ data_Put(0); /* x descent */
|
|
|
+}
|
|
|
+
|
|
|
+void bdf_GenerateGlyph(const char *filename, int encoding) {
|
|
|
+ bdf_ClearGlyphBuffer();
|
|
|
+ bdf_requested_encoding = encoding;
|
|
|
+ bdf_state = BDF_STATE_ENCODING;
|
|
|
+ bdf_ReadFile(filename, encoding);
|
|
|
+}
|
|
|
+
|
|
|
+void bdf_Generate(const char *filename, int begin, int end) {
|
|
|
+ int i;
|
|
|
+ int last_valid_encoding;
|
|
|
+
|
|
|
+ bdf_encoding_65_pos = 0;
|
|
|
+ bdf_encoding_97_pos = 0;
|
|
|
+
|
|
|
+ bdf_InitFilePos();
|
|
|
+ bdf_ResetMax();
|
|
|
+ bdf_info[0] = '\0';
|
|
|
+ bdf_font[0] = '\0';
|
|
|
+ bdf_copyright[0] = '\0';
|
|
|
+
|
|
|
+ bdf_GenerateFontData(filename, begin, end);
|
|
|
+ for (i = begin; i <= end; i++) {
|
|
|
+
|
|
|
+ if (i == 65) bdf_encoding_65_pos = data_pos;
|
|
|
+ if (i == 97) bdf_encoding_97_pos = data_pos;
|
|
|
+
|
|
|
+ bdf_is_encoding_successfully_done = 0;
|
|
|
+ if (bdf_IsEncodingAvailable(i))
|
|
|
+ bdf_GenerateGlyph(filename, i);
|
|
|
+ if (bdf_is_encoding_successfully_done == 0)
|
|
|
+ data_Put(255); /* no char encoding */
|
|
|
+ if (bdf_is_encoding_successfully_done != 0)
|
|
|
+ last_valid_encoding = i;
|
|
|
+ }
|
|
|
+ /* data_Put(255); obsolete, not required any more for format 0 */ /* encoding 255, end of font data (format 0) */
|
|
|
+
|
|
|
+ data_buf[5] = bdf_capital_A_height > 0 ? bdf_capital_A_height : bdf_capital_1_height;
|
|
|
+
|
|
|
+ data_buf[6] = (bdf_encoding_65_pos >> 8);
|
|
|
+ data_buf[7] = (bdf_encoding_65_pos & 255);
|
|
|
+ data_buf[8] = (bdf_encoding_97_pos >> 8);
|
|
|
+ data_buf[9] = (bdf_encoding_97_pos & 255);
|
|
|
+
|
|
|
+ data_buf[12] = bdf_lower_g_descent;
|
|
|
+ data_buf[13] = bdf_char_max_ascent;
|
|
|
+ data_buf[14] = bdf_char_min_y;
|
|
|
+ data_buf[15] = bdf_char_xascent;
|
|
|
+ data_buf[16] = bdf_char_xdescent;
|
|
|
+
|
|
|
+ if (0) data_buf[11] = last_valid_encoding;
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+void bdf_WriteC(const char *outname, const char *fontname) {
|
|
|
+ int capital_ascent;
|
|
|
+ FILE *out_fp;
|
|
|
+ out_fp = fopen(outname, "wb");
|
|
|
+ assert( out_fp != NULL );
|
|
|
+
|
|
|
+ capital_ascent = bdf_capital_A_height > 0 ? bdf_capital_A_height : bdf_capital_1_height;
|
|
|
+
|
|
|
+ fprintf(out_fp, "/*\n");
|
|
|
+ fprintf(out_fp, " Fontname: %s\n", bdf_font);
|
|
|
+ fprintf(out_fp, " Copyright: %s\n", bdf_copyright);
|
|
|
+ fprintf(out_fp, " Capital A Height: %d, '1' Height: %d\n", bdf_capital_A_height, bdf_capital_1_height);
|
|
|
+ fprintf(out_fp, " Calculated Max Values w=%2d h=%2d x=%2d y=%2d dx=%2d dy=%2d ascent=%2d len=%2d\n",
|
|
|
+ bdf_char_max_width, bdf_char_max_height, bdf_char_max_x, bdf_char_max_y, bdf_delta_max_x, bdf_delta_max_y,
|
|
|
+ bdf_char_max_ascent, bdf_glyph_data_max_len);
|
|
|
+ fprintf(out_fp, " Font Bounding box w=%2d h=%2d x=%2d y=%2d\n",
|
|
|
+ bdf_font_width, bdf_font_height, bdf_font_x, bdf_font_y);
|
|
|
+ fprintf(out_fp, " Calculated Min Values x=%2d y=%2d dx=%2d dy=%2d\n",
|
|
|
+ bdf_char_min_x, bdf_char_min_y, bdf_delta_min_x, bdf_delta_min_y);
|
|
|
+
|
|
|
+ fprintf(out_fp, " Pure Font ascent =%2d descent=%2d\n", capital_ascent, bdf_lower_g_descent);
|
|
|
+ fprintf(out_fp, " X Font ascent =%2d descent=%2d\n", bdf_char_xascent, bdf_char_xdescent);
|
|
|
+ fprintf(out_fp, " Max Font ascent =%2d descent=%2d\n", bdf_char_max_ascent, bdf_char_min_y);
|
|
|
+
|
|
|
+ fprintf(out_fp, "*/\n");
|
|
|
+ fprintf(out_fp, "const u8g_fntpgm_uint8_t %s[%d] U8G_FONT_SECTION(\"%s\") = {\n", fontname, data_pos, fontname);
|
|
|
+ fprintf(out_fp, " ");
|
|
|
+ data_Write(out_fp, " ");
|
|
|
+ fprintf(out_fp, "};\n");
|
|
|
+ #ifndef BDF2U8G_COMPACT_OUTPUT
|
|
|
+ fprintf(out_fp, "%s\n", bdf_info);
|
|
|
+ #endif
|
|
|
+
|
|
|
+ fclose(out_fp);
|
|
|
+}
|
|
|
+
|
|
|
+int ga_argc;
|
|
|
+char **ga_argv;
|
|
|
+
|
|
|
+void ga_remove_arg(void) {
|
|
|
+ if (ga_argc == 0) return;
|
|
|
+ ga_argc--;
|
|
|
+ ga_argv++;
|
|
|
+}
|
|
|
+
|
|
|
+int ga_is_arg(char opt) {
|
|
|
+ if (ga_argc == 0) return 0;
|
|
|
+ if (ga_argv[0] == NULL) return 0;
|
|
|
+ if (ga_argv[0][0] != '-') return 0;
|
|
|
+ if (ga_argv[0][1] != opt) return 0;
|
|
|
+ ga_remove_arg();
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+int main(int argc, char **argv) {
|
|
|
+ int lower_page = 0;
|
|
|
+ int upper_page = 1;
|
|
|
+ int mapping_shift = 0;
|
|
|
+ int upper_mapping_shift = 0;
|
|
|
+ int begin = 32;
|
|
|
+ int end = 255;
|
|
|
+
|
|
|
+ if (argc < 4) {
|
|
|
+ printf("bdf to u8glib font format converter v" BDF2U8G_VERSION "\n");
|
|
|
+ printf("%s [-l page] [-u page] [-s shift] [-S upper-shift] [-b begin] [-e end] [-f format] fontfile fontname outputfile\n", argv[0]);
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ ga_argc = argc;
|
|
|
+ ga_argv = argv;
|
|
|
+ ga_remove_arg(); /* remove program name */
|
|
|
+
|
|
|
+ for (;;) {
|
|
|
+ if (ga_is_arg('l')) {
|
|
|
+ lower_page = atoi(ga_argv[0]);
|
|
|
+ ga_remove_arg();
|
|
|
+ }
|
|
|
+ else if (ga_is_arg('u')) {
|
|
|
+ upper_page = atoi(ga_argv[0]);
|
|
|
+ ga_remove_arg();
|
|
|
+ }
|
|
|
+ else if (ga_is_arg('s')) {
|
|
|
+ mapping_shift = atoi(ga_argv[0]);
|
|
|
+ ga_remove_arg();
|
|
|
+ }
|
|
|
+ else if (ga_is_arg('S')) {
|
|
|
+ upper_mapping_shift = atoi(ga_argv[0]);
|
|
|
+ ga_remove_arg();
|
|
|
+ }
|
|
|
+ else if (ga_is_arg('b')) {
|
|
|
+ begin = atoi(ga_argv[0]);
|
|
|
+ ga_remove_arg();
|
|
|
+ }
|
|
|
+ else if (ga_is_arg('e')) {
|
|
|
+ end = atoi(ga_argv[0]);
|
|
|
+ ga_remove_arg();
|
|
|
+ }
|
|
|
+ else if (ga_is_arg('f')) {
|
|
|
+ bdf_font_format = atoi(ga_argv[0]);
|
|
|
+ ga_remove_arg();
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ printf("encoding range %d..%d\n", begin, end);
|
|
|
+
|
|
|
+ data_Init();
|
|
|
+ map_Init();
|
|
|
+ map_UpperLowerPage(lower_page, upper_page, mapping_shift, upper_mapping_shift);
|
|
|
+
|
|
|
+ /*
|
|
|
+ puts(bdf_font);
|
|
|
+ puts(bdf_copyright);
|
|
|
+ if (ga_argc < 3) {
|
|
|
+ printf("from page %d to page %d\n", lower_page, upper_page);
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ */
|
|
|
+
|
|
|
+ bdf_Generate(ga_argv[0], begin, end);
|
|
|
+ bdf_WriteC(ga_argv[2], ga_argv[1]);
|
|
|
+
|
|
|
+ printf("input file '%s'\n", ga_argv[0]);
|
|
|
+ printf("u8g font name '%s'\n", ga_argv[1]);
|
|
|
+ printf("output file '%s'\n", ga_argv[2]);
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
Scott Lahteine