diff options
| -rw-r--r-- | tools/sci/5x8.font | 2307 | ||||
| -rw-r--r-- | tools/sci/6x10.font | 2819 | ||||
| -rw-r--r-- | tools/sci/bdf.cpp | 7434 | ||||
| -rw-r--r-- | tools/sci/bdf.h | 675 | ||||
| -rw-r--r-- | tools/sci/bdfP.h | 142 | ||||
| -rw-r--r-- | tools/sci/bdfgname.cpp | 439 | ||||
| -rw-r--r-- | tools/sci/bdfgrid.cpp | 3515 | ||||
| -rw-r--r-- | tools/sci/bdftofont.cpp | 177 | ||||
| -rw-r--r-- | tools/sci/fonttoc.cpp | 256 |
9 files changed, 0 insertions, 17764 deletions
diff --git a/tools/sci/5x8.font b/tools/sci/5x8.font deleted file mode 100644 index 53fc58c70d..0000000000 --- a/tools/sci/5x8.font +++ /dev/null @@ -1,2307 +0,0 @@ -# 256 8 -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x00 ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x01 ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x02 ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x03 ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x04 ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x05 ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x06 ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x07 ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x08 ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x09 ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x0a ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x0b ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x0c ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x0d ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x0e ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x0f ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x10 ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x11 ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x12 ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x13 ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x14 ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x15 ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x16 ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x17 ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x18 ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x19 ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x1a ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x1b ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x1c ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x1d ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x1e ('.') */ -..... -#.#.. -...#. -#.... -...#. -#.... -.#.#. -..... ----- 0x1f ('.') */ -..... -..... -..... -..... -..... -..... -..... -..... ----- 0x20 (' ') */ -.. -#. -#. -#. -#. -.. -#. -.. ----- 0x21 ('!') */ -.... -#.#. -#.#. -.... -.... -.... -.... -.... ----- 0x22 ('"') */ -.#.#.. -.#.#.. -#####. -.#.#.. -#####. -.#.#.. -.#.#.. -...... ----- 0x23 ('#') */ -..#... -.###.. -#.#... -.###.. -..#.#. -.###.. -..#... -...... ----- 0x24 ('$') */ -...... -##..#. -#..#.. -..#... -.#..#. -#..##. -...... -...... ----- 0x25 ('%') */ -.#.... -#.#... -#.#... -.#.... -#.###. -#..#.. -.##.#. -...... ----- 0x26 ('&') */ -.. -#. -#. -.. -.. -.. -.. -.. ----- 0x27 (''') */ -... -.#. -#.. -#.. -#.. -#.. -.#. -... ----- 0x28 ('(') */ -... -#.. -.#. -.#. -.#. -.#. -#.. -... ----- 0x29 (')') */ -..... -..... -#..#. -.##.. -####. -.##.. -#..#. -..... ----- 0x2a ('*') */ -...... -...... -..#... -..#... -#####. -..#... -..#... -...... ----- 0x2b ('+') */ -... -... -... -... -... -.#. -.#. -#.. ----- 0x2c (',') */ -..... -..... -..... -..... -####. -..... -..... -..... ----- 0x2d ('-') */ -.. -.. -.. -.. -.. -.. -#. -.. ----- 0x2e ('.') */ -....... -.....#. -....#.. -...#... -..#.... -.#..... -#...... -....... ----- 0x2f ('/') */ -..... -.##.. -#..#. -#..#. -#..#. -#..#. -.##.. -..... ----- 0x30 ('0') */ -.... -.#.. -##.. -.#.. -.#.. -.#.. -###. -.... ----- 0x31 ('1') */ -..... -.##.. -#..#. -...#. -.##.. -#.... -####. -..... ----- 0x32 ('2') */ -..... -####. -..#.. -.##.. -...#. -#..#. -.##.. -..... ----- 0x33 ('3') */ -..... -..#.. -.##.. -#.#.. -####. -..#.. -..#.. -..... ----- 0x34 ('4') */ -..... -####. -#.... -###.. -...#. -#..#. -.##.. -..... ----- 0x35 ('5') */ -..... -.##.. -#.... -###.. -#..#. -#..#. -.##.. -..... ----- 0x36 ('6') */ -..... -####. -...#. -..#.. -..#.. -.#... -.#... -..... ----- 0x37 ('7') */ -..... -.##.. -#..#. -.##.. -#..#. -#..#. -.##.. -..... ----- 0x38 ('8') */ -..... -.##.. -#..#. -#..#. -.###. -...#. -.##.. -..... ----- 0x39 ('9') */ -.. -.. -#. -.. -.. -#. -.. -.. ----- 0x3a (':') */ -... -... -.#. -... -... -.#. -.#. -#.. ----- 0x3b (';') */ -.... -..#. -.#.. -#... -#... -.#.. -..#. -.... ----- 0x3c ('<') */ -..... -..... -..... -####. -..... -####. -..... -..... ----- 0x3d ('=') */ -.... -#... -.#.. -..#. -..#. -.#.. -#... -.... ----- 0x3e ('>') */ -..... -.##.. -#..#. -...#. -..#.. -..... -..#.. -..... ----- 0x3f ('?') */ -..##.. -.#..#. -#..##. -#.#.#. -#.#.#. -#..#.. -.#.... -..##.. ----- 0x40 ('@') */ -..... -.##.. -#..#. -#..#. -####. -#..#. -#..#. -..... ----- 0x41 ('A') */ -..... -###.. -#..#. -###.. -#..#. -#..#. -###.. -..... ----- 0x42 ('B') */ -..... -.##.. -#..#. -#.... -#.... -#..#. -.##.. -..... ----- 0x43 ('C') */ -..... -###.. -#..#. -#..#. -#..#. -#..#. -###.. -..... ----- 0x44 ('D') */ -..... -####. -#.... -###.. -#.... -#.... -####. -..... ----- 0x45 ('E') */ -..... -####. -#.... -###.. -#.... -#.... -#.... -..... ----- 0x46 ('F') */ -..... -.##.. -#..#. -#.... -#.##. -#..#. -.##.. -..... ----- 0x47 ('G') */ -..... -#..#. -#..#. -####. -#..#. -#..#. -#..#. -..... ----- 0x48 ('H') */ -.... -###. -.#.. -.#.. -.#.. -.#.. -###. -.... ----- 0x49 ('I') */ -..... -.###. -..#.. -..#.. -..#.. -#.#.. -.#... -..... ----- 0x4a ('J') */ -..... -#..#. -#.#.. -##... -#.#.. -#.#.. -#..#. -..... ----- 0x4b ('K') */ -..... -#.... -#.... -#.... -#.... -#.... -####. -..... ----- 0x4c ('L') */ -...... -#...#. -##.##. -#.#.#. -#...#. -#...#. -#...#. -...... ----- 0x4d ('M') */ -..... -#..#. -##.#. -##.#. -#.##. -#.##. -#..#. -..... ----- 0x4e ('N') */ -..... -.##.. -#..#. -#..#. -#..#. -#..#. -.##.. -..... ----- 0x4f ('O') */ -..... -###.. -#..#. -#..#. -###.. -#.... -#.... -..... ----- 0x50 ('P') */ -..... -.##.. -#..#. -#..#. -#..#. -#.##. -.##.. -...#. ----- 0x51 ('Q') */ -..... -###.. -#..#. -#..#. -###.. -#..#. -#..#. -..... ----- 0x52 ('R') */ -..... -.##.. -#..#. -.#... -..#.. -#..#. -.##.. -..... ----- 0x53 ('S') */ -.... -###. -.#.. -.#.. -.#.. -.#.. -.#.. -.... ----- 0x54 ('T') */ -..... -#..#. -#..#. -#..#. -#..#. -#..#. -.##.. -..... ----- 0x55 ('U') */ -..... -#..#. -#..#. -#..#. -#..#. -#.#.. -.#... -..... ----- 0x56 ('V') */ -...... -#...#. -#...#. -#...#. -#.#.#. -##.##. -#...#. -...... ----- 0x57 ('W') */ -..... -#..#. -#..#. -.##.. -.##.. -#..#. -#..#. -..... ----- 0x58 ('X') */ -...... -#...#. -#...#. -.#.#.. -..#... -..#... -..#... -...... ----- 0x59 ('Y') */ -..... -####. -...#. -..#.. -.#... -#.... -####. -..... ----- 0x5a ('Z') */ -.... -###. -#... -#... -#... -#... -###. -.... ----- 0x5b ('[') */ -....... -#...... -.#..... -..#.... -...#... -....#.. -.....#. -....... ----- 0x5c ('\') */ -.... -###. -..#. -..#. -..#. -..#. -###. -.... ----- 0x5d (']') */ -.... -.#.. -#.#. -.... -.... -.... -.... -.... ----- 0x5e ('^') */ -.... -.... -.... -.... -.... -.... -.... -#### ----- 0x5f ('_') */ -... -#.. -.#. -... -... -... -... -... ----- 0x60 ('`') */ -..... -..... -..... -.###. -#..#. -#..#. -.###. -..... ----- 0x61 ('a') */ -..... -#.... -#.... -###.. -#..#. -#..#. -###.. -..... ----- 0x62 ('b') */ -.... -.... -.... -.##. -#... -#... -.##. -.... ----- 0x63 ('c') */ -..... -...#. -...#. -.###. -#..#. -#..#. -.###. -..... ----- 0x64 ('d') */ -..... -..... -..... -.##.. -#.##. -##... -.##.. -..... ----- 0x65 ('e') */ -..... -..#.. -.#.#. -.#... -###.. -.#... -.#... -..... ----- 0x66 ('f') */ -..... -..... -..... -.##.. -#..#. -.###. -...#. -.##.. ----- 0x67 ('g') */ -..... -#.... -#.... -###.. -#..#. -#..#. -#..#. -..... ----- 0x68 ('h') */ -.... -.#.. -.... -##.. -.#.. -.#.. -###. -.... ----- 0x69 ('i') */ -.... -..#. -.... -..#. -..#. -..#. -#.#. -.#.. ----- 0x6a ('j') */ -..... -#.... -#.... -#..#. -###.. -#..#. -#..#. -..... ----- 0x6b ('k') */ -.... -##.. -.#.. -.#.. -.#.. -.#.. -###. -.... ----- 0x6c ('l') */ -...... -...... -...... -##.#.. -#.#.#. -#.#.#. -#.#.#. -...... ----- 0x6d ('m') */ -..... -..... -..... -###.. -#..#. -#..#. -#..#. -..... ----- 0x6e ('n') */ -..... -..... -..... -.##.. -#..#. -#..#. -.##.. -..... ----- 0x6f ('o') */ -..... -..... -..... -###.. -#..#. -###.. -#.... -#.... ----- 0x70 ('p') */ -..... -..... -..... -.###. -#..#. -.###. -...#. -...#. ----- 0x71 ('q') */ -..... -..... -..... -#.#.. -##.#. -#.... -#.... -..... ----- 0x72 ('r') */ -.... -.... -.... -.##. -##.. -..#. -##.. -.... ----- 0x73 ('s') */ -..... -.#... -.#... -###.. -.#... -.#.#. -..#.. -..... ----- 0x74 ('t') */ -..... -..... -..... -#..#. -#..#. -#..#. -.###. -..... ----- 0x75 ('u') */ -.... -.... -.... -#.#. -#.#. -#.#. -.#.. -.... ----- 0x76 ('v') */ -...... -...... -...... -#...#. -#.#.#. -#.#.#. -.#.#.. -...... ----- 0x77 ('w') */ -..... -..... -..... -#..#. -.##.. -.##.. -#..#. -..... ----- 0x78 ('x') */ -..... -..... -..... -#..#. -#..#. -.###. -#..#. -.##.. ----- 0x79 ('y') */ -..... -..... -..... -####. -..#.. -.#... -####. -..... ----- 0x7a ('z') */ -..##. -.#... -..#.. -##... -..#.. -.#... -..##. -..... ----- 0x7b ('{') */ -.. -#. -#. -#. -#. -#. -#. -.. ----- 0x7c ('|') */ -##... -..#.. -.#... -..##. -.#... -..#.. -##... -..... ----- 0x7d ('}') */ -..... -.#.#. -#.#.. -..... -..... -..... -..... -..... ----- 0x7e ('~') */ -..... -..... -..... -..... -..... -..... -..... -..... ----- 0x7f ('.') */ -..... -..#.. -..... -..#.. -..#.. -..#.. -..#.. -..... ----- 0x80 ('.') */ -..... -..... -..#.. -.###. -#.#.. -#.#.. -.###. -..#.. ----- 0x81 ('.') */ -..... -..#.. -.#.#. -###.. -.#... -.#.#. -#.#.. -..... ----- 0x82 ('.') */ -..... -..... -#...# -.###. -.#.#. -.###. -#...# -..... ----- 0x83 ('.') */ -..... -#...# -.#.#. -##### -..#.. -##### -..#.. -..... ----- 0x84 ('.') */ -..#.. -..#.. -..#.. -..... -..#.. -..#.. -..#.. -..... ----- 0x85 ('.') */ -.###. -#.... -###.. -#..#. -.###. -...#. -###.. -..... ----- 0x86 ('.') */ -..... -.#.#. -..... -..... -..... -..... -..... -..... ----- 0x87 ('.') */ -..... -.###. -#.#.# -##..# -##..# -#.#.# -.###. -..... ----- 0x88 ('.') */ -..##. -.#.#. -..##. -..... -.###. -..... -..... -..... ----- 0x89 ('.') */ -..... -..... -..... -.#.#. -#.#.. -.#.#. -..... -..... ----- 0x8a ('.') */ -..... -..... -..... -..... -.###. -...#. -...#. -..... ----- 0x8b ('.') */ -..... -..... -..... -..... -.###. -..... -..... -..... ----- 0x8c ('.') */ -..... -.###. -###.# -##.## -###.# -##.## -.###. -..... ----- 0x8d ('.') */ -..... -.###. -..... -..... -..... -..... -..... -..... ----- 0x8e ('.') */ -..... -..#.. -.#.#. -..#.. -..... -..... -..... -..... ----- 0x8f ('.') */ -..... -..... -..#.. -.###. -..#.. -..... -.###. -..... ----- 0x90 ('.') */ -..#.. -.#.#. -...#. -..#.. -.###. -..... -..... -..... ----- 0x91 ('.') */ -.##.. -...#. -.##.. -...#. -.##.. -..... -..... -..... ----- 0x92 ('.') */ -..... -..#.. -.#... -..... -..... -..... -..... -..... ----- 0x93 ('.') */ -..... -..... -..... -#..#. -#..#. -#..#. -###.. -#.... ----- 0x94 ('.') */ -..... -.#### -###.# -###.# -.##.# -..#.# -..#.# -..... ----- 0x95 ('.') */ -..... -..... -..... -..... -..#.. -..... -..... -..... ----- 0x96 ('.') */ -..... -..... -..... -..... -..... -..... -..#.. -.#... ----- 0x97 ('.') */ -..#.. -.##.. -..#.. -..#.. -.###. -..... -..... -..... ----- 0x98 ('.') */ -..#.. -.#.#. -..#.. -..... -.###. -..... -..... -..... ----- 0x99 ('.') */ -..... -..... -..... -#.#.. -.#.#. -#.#.. -..... -..... ----- 0x9a ('.') */ -#.... -#.... -#.... -#.#.. -.##.. -####. -..#.. -..... ----- 0x9b ('.') */ -#.... -#.... -#.#.. -##.#. -...#. -..#.. -.###. -..... ----- 0x9c ('.') */ -#.... -.#... -#.... -.##.. -#.#.. -####. -..#.. -..... ----- 0x9d ('.') */ -..... -..#.. -..... -..#.. -.#... -.#.#. -..#.. -..... ----- 0x9e ('.') */ -.#... -..#.. -.##.. -#..#. -####. -#..#. -#..#. -..... ----- 0x9f ('.') */ -..#.. -.#... -.##.. -#..#. -####. -#..#. -#..#. -..... ----- 0xa0 ('.') */ -.##.. -#..#. -.##.. -#..#. -####. -#..#. -#..#. -..... ----- 0xa1 ('.') */ -.#.#. -#.#.. -.##.. -#..#. -####. -#..#. -#..#. -..... ----- 0xa2 ('.') */ -#..#. -..... -.##.. -#..#. -####. -#..#. -#..#. -..... ----- 0xa3 ('.') */ -.##.. -#..#. -.##.. -#..#. -####. -#..#. -#..#. -..... ----- 0xa4 ('.') */ -..... -.###. -#.#.. -#.#.. -####. -#.#.. -#.##. -..... ----- 0xa5 ('.') */ -..... -.##.. -#..#. -#.... -#.... -#..#. -.##.. -.#... ----- 0xa6 ('.') */ -.#... -..#.. -####. -#.... -###.. -#.... -####. -..... ----- 0xa7 ('.') */ -..#.. -.#... -####. -#.... -###.. -#.... -####. -..... ----- 0xa8 ('.') */ -.##.. -#..#. -####. -#.... -###.. -#.... -####. -..... ----- 0xa9 ('.') */ -#..#. -..... -####. -#.... -###.. -#.... -####. -..... ----- 0xaa ('.') */ -.#... -..#.. -.###. -..#.. -..#.. -..#.. -.###. -..... ----- 0xab ('.') */ -...#. -..#.. -.###. -..#.. -..#.. -..#.. -.###. -..... ----- 0xac ('.') */ -..#.. -.#.#. -.###. -..#.. -..#.. -..#.. -.###. -..... ----- 0xad ('.') */ -.#.#. -..... -.###. -..#.. -..#.. -..#.. -.###. -..... ----- 0xae ('.') */ -..... -.###. -.#..# -###.# -.#..# -.#..# -.###. -..... ----- 0xaf ('.') */ -.#.#. -#.#.. -#..#. -##.#. -#.##. -#..#. -#..#. -..... ----- 0xb0 ('.') */ -.#... -..#.. -.##.. -#..#. -#..#. -#..#. -.##.. -..... ----- 0xb1 ('.') */ -..#.. -.#... -.##.. -#..#. -#..#. -#..#. -.##.. -..... ----- 0xb2 ('.') */ -.##.. -#..#. -.##.. -#..#. -#..#. -#..#. -.##.. -..... ----- 0xb3 ('.') */ -.#.#. -#.#.. -.##.. -#..#. -#..#. -#..#. -.##.. -..... ----- 0xb4 ('.') */ -#..#. -..... -.##.. -#..#. -#..#. -#..#. -.##.. -..... ----- 0xb5 ('.') */ -..... -..... -..... -..... -.#.#. -..#.. -.#.#. -..... ----- 0xb6 ('.') */ -..... -.###. -#.##. -#.##. -##.#. -##.#. -###.. -..... ----- 0xb7 ('.') */ -.#... -..#.. -#..#. -#..#. -#..#. -#..#. -.##.. -..... ----- 0xb8 ('.') */ -..#.. -.#... -#..#. -#..#. -#..#. -#..#. -.##.. -..... ----- 0xb9 ('.') */ -.##.. -#..#. -#..#. -#..#. -#..#. -#..#. -.##.. -..... ----- 0xba ('.') */ -#..#. -..... -#..#. -#..#. -#..#. -#..#. -.##.. -..... ----- 0xbb ('.') */ -...#. -..#.. -#...# -.#.#. -..#.. -..#.. -..#.. -..... ----- 0xbc ('.') */ -..... -#.... -###.. -#..#. -#..#. -###.. -#.... -..... ----- 0xbd ('.') */ -..... -.##.. -#..#. -#.#.. -#.#.. -#..#. -#.#.. -..... ----- 0xbe ('.') */ -.#... -..#.. -..... -.###. -#..#. -#..#. -.###. -..... ----- 0xbf ('.') */ -..#.. -.#... -..... -.###. -#..#. -#..#. -.###. -..... ----- 0xc0 ('.') */ -..#.. -.#.#. -..... -.###. -#..#. -#..#. -.###. -..... ----- 0xc1 ('.') */ -.#.#. -#.#.. -..... -.###. -#..#. -#..#. -.###. -..... ----- 0xc2 ('.') */ -..... -.#.#. -..... -.###. -#..#. -#..#. -.###. -..... ----- 0xc3 ('.') */ -.##.. -#..#. -.##.. -.###. -#..#. -#..#. -.###. -..... ----- 0xc4 ('.') */ -..... -..... -..... -####. -.##.# -#.##. -.#### -..... ----- 0xc5 ('.') */ -..... -..... -..... -..##. -.#... -.#... -..##. -..#.. ----- 0xc6 ('.') */ -.#... -..#.. -..... -.##.. -#.##. -##... -.##.. -..... ----- 0xc7 ('.') */ -..#.. -.#... -..... -.##.. -#.##. -##... -.##.. -..... ----- 0xc8 ('.') */ -.##.. -#..#. -..... -.##.. -#.##. -##... -.##.. -..... ----- 0xc9 ('.') */ -..... -.#.#. -..... -.##.. -#.##. -##... -.##.. -..... ----- 0xca ('.') */ -.#... -..#.. -..... -.##.. -..#.. -..#.. -.###. -..... ----- 0xcb ('.') */ -...#. -..#.. -..... -.##.. -..#.. -..#.. -.###. -..... ----- 0xcc ('.') */ -..#.. -.#.#. -..... -.##.. -..#.. -..#.. -.###. -..... ----- 0xcd ('.') */ -..... -.#.#. -..... -.##.. -..#.. -..#.. -.###. -..... ----- 0xce ('.') */ -#.#.. -.#... -#.#.. -...#. -.###. -#..#. -.##.. -..... ----- 0xcf ('.') */ -.#.#. -#.#.. -..... -###.. -#..#. -#..#. -#..#. -..... ----- 0xd0 ('.') */ -.#... -..#.. -..... -.##.. -#..#. -#..#. -.##.. -..... ----- 0xd1 ('.') */ -..#.. -.#... -..... -.##.. -#..#. -#..#. -.##.. -..... ----- 0xd2 ('.') */ -.##.. -#..#. -..... -.##.. -#..#. -#..#. -.##.. -..... ----- 0xd3 ('.') */ -.#.#. -#.#.. -..... -.##.. -#..#. -#..#. -.##.. -..... ----- 0xd4 ('.') */ -..... -#..#. -..... -.##.. -#..#. -#..#. -.##.. -..... ----- 0xd5 ('.') */ -..... -..... -..#.. -..... -.###. -..... -..#.. -..... ----- 0xd6 ('.') */ -..... -..... -..... -.###. -#.##. -##.#. -###.. -..... ----- 0xd7 ('.') */ -.#... -..#.. -..... -#..#. -#..#. -#..#. -.###. -..... ----- 0xd8 ('.') */ -..#.. -.#... -..... -#..#. -#..#. -#..#. -.###. -..... ----- 0xd9 ('.') */ -.##.. -#..#. -..... -#..#. -#..#. -#..#. -.###. -..... ----- 0xda ('.') */ -..... -#..#. -..... -#..#. -#..#. -#..#. -.###. -..... ----- 0xdb ('.') */ -..#.. -.#... -..... -#..#. -#..#. -.###. -#..#. -.##.. ----- 0xdc ('.') */ -..... -#.... -#.... -###.. -#..#. -###.. -#.... -#.... ----- 0xdd ('.') */ -..... -#..#. -..... -#..#. -#..#. -.###. -#..#. -.##.. ----- 0xde ('.') */ -####. -..... -.##.. -#..#. -####. -#..#. -#..#. -..... ----- 0xdf ('.') */ -..... -####. -..... -.###. -#..#. -#..#. -.###. -..... ----- 0xe0 ('.') */ -#..#. -.##.. -.##.. -#..#. -####. -#..#. -#..#. -..... ----- 0xe1 ('.') */ -#..#. -.##.. -..... -.###. -#..#. -#..#. -.###. -..... ----- 0xe2 ('.') */ -..... -.##.. -#..#. -#..#. -####. -#..#. -#..#. -..##. ----- 0xe3 ('.') */ -..... -..... -..... -.###. -#..#. -#..#. -.###. -..#.. ----- 0xe4 ('.') */ -..#.. -.#... -.##.. -#..#. -#.... -#..#. -.##.. -..... ----- 0xe5 ('.') */ -...#. -..#.. -..... -..##. -.#... -.#... -..##. -..... ----- 0xe6 ('.') */ -.##.. -#..#. -.##.. -#..#. -#.... -#..#. -.##.. -..... ----- 0xe7 ('.') */ -.##.. -#..#. -..... -.##.. -#.... -#.... -.##.. -..... ----- 0xe8 ('.') */ -.#... -..... -.##.. -#..#. -#.... -#..#. -.##.. -..... ----- 0xe9 ('.') */ -..... -..#.. -..... -..##. -.#... -.#... -..##. -..... ----- 0xea ('.') */ -#..#. -.##.. -.##.. -#..#. -#.... -#..#. -.##.. -..... ----- 0xeb ('.') */ -#..#. -.##.. -..... -.##.. -#.... -#.... -.##.. -..... ----- 0xec ('.') */ -#..#. -.##.. -###.. -#..#. -#..#. -#..#. -###.. -..... ----- 0xed ('.') */ -#.#.. -.#.#. -...#. -.###. -#..#. -#..#. -.###. -..... ----- 0xee ('.') */ -..... -.###. -.#..# -###.# -.#..# -.#..# -.###. -..... ----- 0xef ('.') */ -..... -..#.. -.###. -..#.. -.##.. -#.#.. -.##.. -..... ----- 0xf0 ('.') */ -####. -..... -####. -#.... -###.. -#.... -####. -..... ----- 0xf1 ('.') */ -..... -####. -..... -.##.. -#.##. -##... -.##.. -..... ----- 0xf2 ('.') */ -#..#. -.##.. -####. -#.... -###.. -#.... -####. -..... ----- 0xf3 ('.') */ -#..#. -.##.. -..... -.##.. -#.##. -##... -.##.. -..... ----- 0xf4 ('.') */ -.##.. -..... -####. -#.... -###.. -#.... -####. -..... ----- 0xf5 ('.') */ -..... -.##.. -..... -.##.. -#.##. -##... -.##.. -..... ----- 0xf6 ('.') */ -..... -####. -#.... -###.. -#.... -#.... -####. -..#.. ----- 0xf7 ('.') */ -..... -..... -..... -.##.. -#.##. -##... -.##.. -..#.. ----- 0xf8 ('.') */ -#..#. -.##.. -####. -#.... -###.. -#.... -####. -..... ----- 0xf9 ('.') */ -#..#. -.##.. -..... -.##.. -#.##. -##... -.##.. -..... ----- 0xfa ('.') */ -.##.. -#..#. -.###. -#.... -#.##. -#..#. -.##.. -..... ----- 0xfb ('.') */ -.##.. -#..#. -..... -.##.. -#..#. -.###. -...#. -.##.. ----- 0xfc ('.') */ -#..#. -.##.. -.###. -#.... -#.##. -#..#. -.##.. -..... ----- 0xfd ('.') */ -#..#. -.##.. -..... -.##.. -#..#. -.###. -...#. -.##.. ----- 0xfe ('.') */ -.##.. -..... -.###. -#.... -#.##. -#..#. -.##.. -..... ----- 0xff ('.') */ - - diff --git a/tools/sci/6x10.font b/tools/sci/6x10.font deleted file mode 100644 index c672d07b98..0000000000 --- a/tools/sci/6x10.font +++ /dev/null @@ -1,2819 +0,0 @@ -# 256 10 -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x00 ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x01 ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x02 ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x03 ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x04 ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x05 ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x06 ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x07 ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x08 ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x09 ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x0a ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x0b ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x0c ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x0d ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x0e ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x0f ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x10 ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x11 ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x12 ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x13 ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x14 ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x15 ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x16 ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x17 ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x18 ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x19 ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x1a ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x1b ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x1c ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x1d ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x1e ('.') */ -...... -#.#.#. -...... -#...#. -...... -#...#. -...... -#.#.#. -...... -...... ----- 0x1f ('.') */ -.... -.... -.... -.... -.... -.... -.... -.... -.... -.... ----- 0x20 (' ') */ -.... -.#.. -.#.. -.#.. -.#.. -.#.. -.... -.#.. -.... -.... ----- 0x21 ('!') */ -.... -#.#. -#.#. -#.#. -.... -.... -.... -.... -.... -.... ----- 0x22 ('"') */ -...... -.#.#.. -.#.#.. -#####. -.#.#.. -#####. -.#.#.. -.#.#.. -...... -...... ----- 0x23 ('#') */ -...... -..#... -.###.. -#.#... -.###.. -..#.#. -.###.. -..#... -...... -...... ----- 0x24 ('$') */ -...... -.#..#. -#.#.#. -.#.#.. -..#... -.#.#.. -#.#.#. -#..#.. -...... -...... ----- 0x25 ('%') */ -...... -.#.... -#.#... -#.#... -.#.... -#.#.#. -#..#.. -.##.#. -...... -...... ----- 0x26 ('&') */ -.. -#. -#. -#. -.. -.. -.. -.. -.. -.. ----- 0x27 (''') */ -..... -...#. -..#.. -.#... -.#... -.#... -..#.. -...#. -..... -..... ----- 0x28 ('(') */ -..... -.#... -..#.. -...#. -...#. -...#. -..#.. -.#... -..... -..... ----- 0x29 (')') */ -...... -...... -#...#. -.#.#.. -#####. -.#.#.. -#...#. -...... -...... -...... ----- 0x2a ('*') */ -...... -...... -..#... -..#... -#####. -..#... -..#... -...... -...... -...... ----- 0x2b ('+') */ -.... -.... -.... -.... -.... -.... -.##. -.#.. -#... -.... ----- 0x2c (',') */ -...... -...... -...... -...... -#####. -...... -...... -...... -...... -...... ----- 0x2d ('-') */ -..... -..... -..... -..... -..... -..... -.##.. -.##.. -..... -..... ----- 0x2e ('.') */ -....... -......# -.....#. -....#.. -...#... -..#.... -.#..... -#...... -....... -....... ----- 0x2f ('/') */ -...... -..#... -.#.#.. -#...#. -#...#. -#...#. -.#.#.. -..#... -...... -...... ----- 0x30 ('0') */ -.... -.#.. -##.. -.#.. -.#.. -.#.. -.#.. -###. -.... -.... ----- 0x31 ('1') */ -...... -.###.. -#...#. -....#. -..##.. -.#.... -#..... -#####. -...... -...... ----- 0x32 ('2') */ -...... -#####. -....#. -...#.. -..##.. -....#. -#...#. -.###.. -...... -...... ----- 0x33 ('3') */ -...... -...#.. -..##.. -.#.#.. -#..#.. -#####. -...#.. -...#.. -...... -...... ----- 0x34 ('4') */ -...... -#####. -#..... -#.##.. -##..#. -....#. -#...#. -.###.. -...... -...... ----- 0x35 ('5') */ -...... -..##.. -.#.... -#..... -#.##.. -##..#. -#...#. -.###.. -...... -...... ----- 0x36 ('6') */ -...... -#####. -....#. -...#.. -...#.. -..#... -.#.... -.#.... -...... -...... ----- 0x37 ('7') */ -...... -.###.. -#...#. -#...#. -.###.. -#...#. -#...#. -.###.. -...... -...... ----- 0x38 ('8') */ -...... -.###.. -#...#. -#..##. -.##.#. -....#. -...#.. -.##... -...... -...... ----- 0x39 ('9') */ -..... -..... -.##.. -.##.. -..... -..... -.##.. -.##.. -..... -..... ----- 0x3a (':') */ -..... -..... -.##.. -.##.. -..... -..... -.##.. -.#... -#.... -..... ----- 0x3b (';') */ -...... -....#. -...#.. -..#... -.#.... -..#... -...#.. -....#. -...... -...... ----- 0x3c ('<') */ -...... -...... -...... -#####. -...... -#####. -...... -...... -...... -...... ----- 0x3d ('=') */ -...... -.#.... -..#... -...#.. -....#. -...#.. -..#... -.#.... -...... -...... ----- 0x3e ('>') */ -...... -.###.. -#...#. -...#.. -..#... -..#... -...... -..#... -...... -...... ----- 0x3f ('?') */ -...... -.###.. -#...#. -#..##. -#.#.#. -#.##.. -#..... -.###.. -...... -...... ----- 0x40 ('@') */ -...... -..#... -.#.#.. -#...#. -#...#. -#####. -#...#. -#...#. -...... -...... ----- 0x41 ('A') */ -...... -####.. -.#..#. -.#..#. -.###.. -.#..#. -.#..#. -####.. -...... -...... ----- 0x42 ('B') */ -...... -.###.. -#...#. -#..... -#..... -#..... -#...#. -.###.. -...... -...... ----- 0x43 ('C') */ -...... -####.. -.#..#. -.#..#. -.#..#. -.#..#. -.#..#. -####.. -...... -...... ----- 0x44 ('D') */ -...... -#####. -#..... -#..... -####.. -#..... -#..... -#####. -...... -...... ----- 0x45 ('E') */ -...... -#####. -#..... -#..... -####.. -#..... -#..... -#..... -...... -...... ----- 0x46 ('F') */ -...... -.###.. -#...#. -#..... -#..... -#..##. -#...#. -.###.. -...... -...... ----- 0x47 ('G') */ -...... -#...#. -#...#. -#...#. -#####. -#...#. -#...#. -#...#. -...... -...... ----- 0x48 ('H') */ -.... -###. -.#.. -.#.. -.#.. -.#.. -.#.. -###. -.... -.... ----- 0x49 ('I') */ -...... -..###. -...#.. -...#.. -...#.. -...#.. -#..#.. -.##... -...... -...... ----- 0x4a ('J') */ -...... -#...#. -#..#.. -#.#... -##.... -#.#... -#..#.. -#...#. -...... -...... ----- 0x4b ('K') */ -...... -#..... -#..... -#..... -#..... -#..... -#..... -#####. -...... -...... ----- 0x4c ('L') */ -...... -#...#. -#...#. -##.##. -#.#.#. -#...#. -#...#. -#...#. -...... -...... ----- 0x4d ('M') */ -...... -#...#. -#...#. -##..#. -#.#.#. -#..##. -#...#. -#...#. -...... -...... ----- 0x4e ('N') */ -...... -.###.. -#...#. -#...#. -#...#. -#...#. -#...#. -.###.. -...... -...... ----- 0x4f ('O') */ -...... -####.. -#...#. -#...#. -####.. -#..... -#..... -#..... -...... -...... ----- 0x50 ('P') */ -...... -.###.. -#...#. -#...#. -#...#. -#...#. -#.#.#. -.###.. -....#. -...... ----- 0x51 ('Q') */ -...... -####.. -#...#. -#...#. -####.. -#.#... -#..#.. -#...#. -...... -...... ----- 0x52 ('R') */ -...... -.###.. -#...#. -#..... -.###.. -....#. -#...#. -.###.. -...... -...... ----- 0x53 ('S') */ -...... -#####. -..#... -..#... -..#... -..#... -..#... -..#... -...... -...... ----- 0x54 ('T') */ -...... -#...#. -#...#. -#...#. -#...#. -#...#. -#...#. -.###.. -...... -...... ----- 0x55 ('U') */ -...... -#...#. -#...#. -#...#. -.#.#.. -.#.#.. -.#.#.. -..#... -...... -...... ----- 0x56 ('V') */ -...... -#...#. -#...#. -#...#. -#.#.#. -#.#.#. -##.##. -#...#. -...... -...... ----- 0x57 ('W') */ -...... -#...#. -#...#. -.#.#.. -..#... -.#.#.. -#...#. -#...#. -...... -...... ----- 0x58 ('X') */ -...... -#...#. -#...#. -.#.#.. -..#... -..#... -..#... -..#... -...... -...... ----- 0x59 ('Y') */ -...... -#####. -....#. -...#.. -..#... -.#.... -#..... -#####. -...... -...... ----- 0x5a ('Z') */ -..... -.###. -.#... -.#... -.#... -.#... -.#... -.###. -..... -..... ----- 0x5b ('[') */ -....... -#...... -.#..... -..#.... -...#... -....#.. -.....#. -......# -....... -....... ----- 0x5c ('\') */ -..... -.###. -...#. -...#. -...#. -...#. -...#. -.###. -..... -..... ----- 0x5d (']') */ -...... -..#... -.#.#.. -#...#. -...... -...... -...... -...... -...... -...... ----- 0x5e ('^') */ -..... -..... -..... -..... -..... -..... -..... -..... -##### -..... ----- 0x5f ('_') */ -#.. -.#. -... -... -... -... -... -... -... -... ----- 0x60 ('`') */ -...... -...... -...... -.###.. -....#. -.####. -#...#. -.####. -...... -...... ----- 0x61 ('a') */ -...... -#..... -#..... -#.##.. -##..#. -#...#. -##..#. -#.##.. -...... -...... ----- 0x62 ('b') */ -...... -...... -...... -.###.. -#...#. -#..... -#...#. -.###.. -...... -...... ----- 0x63 ('c') */ -...... -....#. -....#. -.##.#. -#..##. -#...#. -#..##. -.##.#. -...... -...... ----- 0x64 ('d') */ -...... -...... -...... -.###.. -#...#. -#####. -#..... -.###.. -...... -...... ----- 0x65 ('e') */ -...... -..##.. -.#..#. -.#.... -####.. -.#.... -.#.... -.#.... -...... -...... ----- 0x66 ('f') */ -...... -...... -...... -.####. -#...#. -#...#. -.####. -....#. -#...#. -.###.. ----- 0x67 ('g') */ -...... -#..... -#..... -#.##.. -##..#. -#...#. -#...#. -#...#. -...... -...... ----- 0x68 ('h') */ -.... -.#.. -.... -##.. -.#.. -.#.. -.#.. -###. -.... -.... ----- 0x69 ('i') */ -..... -...#. -..... -..##. -...#. -...#. -...#. -#..#. -#..#. -.##.. ----- 0x6a ('j') */ -...... -#..... -#..... -#...#. -#..#.. -###... -#..#.. -#...#. -...... -...... ----- 0x6b ('k') */ -.... -##.. -.#.. -.#.. -.#.. -.#.. -.#.. -###. -.... -.... ----- 0x6c ('l') */ -...... -...... -...... -##.#.. -#.#.#. -#.#.#. -#.#.#. -#...#. -...... -...... ----- 0x6d ('m') */ -...... -...... -...... -#.##.. -##..#. -#...#. -#...#. -#...#. -...... -...... ----- 0x6e ('n') */ -...... -...... -...... -.###.. -#...#. -#...#. -#...#. -.###.. -...... -...... ----- 0x6f ('o') */ -...... -...... -...... -#.##.. -##..#. -#...#. -##..#. -#.##.. -#..... -#..... ----- 0x70 ('p') */ -...... -...... -...... -.##.#. -#..##. -#...#. -#..##. -.##.#. -....#. -....#. ----- 0x71 ('q') */ -...... -...... -...... -#.##.. -##..#. -#..... -#..... -#..... -...... -...... ----- 0x72 ('r') */ -...... -...... -...... -.###.. -#..... -.###.. -....#. -####.. -...... -...... ----- 0x73 ('s') */ -...... -.#.... -.#.... -####.. -.#.... -.#.... -.#..#. -..##.. -...... -...... ----- 0x74 ('t') */ -...... -...... -...... -#...#. -#...#. -#...#. -#..##. -.##.#. -...... -...... ----- 0x75 ('u') */ -...... -...... -...... -#...#. -#...#. -.#.#.. -.#.#.. -..#... -...... -...... ----- 0x76 ('v') */ -...... -...... -...... -#...#. -#...#. -#.#.#. -#.#.#. -.#.#.. -...... -...... ----- 0x77 ('w') */ -...... -...... -...... -#...#. -.#.#.. -..#... -.#.#.. -#...#. -...... -...... ----- 0x78 ('x') */ -...... -...... -...... -#...#. -#...#. -#..##. -.##.#. -....#. -#...#. -.###.. ----- 0x79 ('y') */ -...... -...... -...... -#####. -...#.. -..#... -.#.... -#####. -...... -...... ----- 0x7a ('z') */ -...... -...##. -..#... -...#.. -.##... -...#.. -..#... -...##. -...... -...... ----- 0x7b ('{') */ -... -.#. -.#. -.#. -.#. -.#. -.#. -.#. -... -... ----- 0x7c ('|') */ -...... -.##... -...#.. -..#... -...##. -..#... -...#.. -.##... -...... -...... ----- 0x7d ('}') */ -...... -.#..#. -#.#.#. -#..#.. -...... -...... -...... -...... -...... -...... ----- 0x7e ('~') */ -...... -...... -...... -...... -...... -...... -...... -...... -...... -...... ----- 0x7f ('.') */ -...... -..#... -...... -..#... -..#... -..#... -..#... -..#... -...... -...... ----- 0x80 ('.') */ -...... -...... -..#... -.####. -#.#... -#.#... -#.#... -.####. -..#... -...... ----- 0x81 ('.') */ -...... -..##.. -.#..#. -.#.... -###... -.#.... -.#..#. -#.##.. -...... -...... ----- 0x82 ('.') */ -...... -...... -...... -#...#. -.###.. -.#.#.. -.###.. -#...#. -...... -...... ----- 0x83 ('.') */ -...... -#...#. -#...#. -.#.#.. -..#... -#####. -..#... -..#... -..#... -...... ----- 0x84 ('.') */ -...... -..#... -..#... -..#... -...... -..#... -..#... -..#... -...... -...... ----- 0x85 ('.') */ -...... -.###.. -#..... -###... -#..#.. -.#..#. -..###. -....#. -.###.. -...... ----- 0x86 ('.') */ -.#.#.. -...... -...... -...... -...... -...... -...... -...... -...... -...... ----- 0x87 ('.') */ -...... -.###.. -#...#. -#.#.#. -##..#. -#.#.#. -#...#. -.###.. -...... -...... ----- 0x88 ('.') */ -...... -..###. -.#..#. -.#.##. -..#.#. -...... -.####. -...... -...... -...... ----- 0x89 ('.') */ -...... -...... -...... -..#..# -.#..#. -#..#.. -.#..#. -..#..# -...... -...... ----- 0x8a ('.') */ -...... -...... -...... -...... -.####. -....#. -...... -...... -...... -...... ----- 0x8b ('.') */ -...... -...... -...... -...... -.####. -...... -...... -...... -...... -...... ----- 0x8c ('.') */ -...... -.###.. -#...#. -###.#. -##..#. -##..#. -#...#. -.###.. -...... -...... ----- 0x8d ('.') */ -#####. -...... -...... -...... -...... -...... -...... -...... -...... -...... ----- 0x8e ('.') */ -...... -..#... -.#.#.. -..#... -...... -...... -...... -...... -...... -...... ----- 0x8f ('.') */ -...... -...... -..#... -..#... -#####. -..#... -..#... -#####. -...... -...... ----- 0x90 ('.') */ -..##.. -.#..#. -...#.. -..#... -.####. -...... -...... -...... -...... -...... ----- 0x91 ('.') */ -.###.. -....#. -..##.. -....#. -.###.. -...... -...... -...... -...... -...... ----- 0x92 ('.') */ -...#.. -..#... -...... -...... -...... -...... -...... -...... -...... -...... ----- 0x93 ('.') */ -...... -...... -...... -#...#. -#...#. -#...#. -##..#. -#.##.. -#..... -...... ----- 0x94 ('.') */ -...... -.####. -###.#. -###.#. -.##.#. -..#.#. -..#.#. -..#.#. -...... -...... ----- 0x95 ('.') */ -...... -...... -...... -...... -..#... -...... -...... -...... -...... -...... ----- 0x96 ('.') */ -...... -...... -...... -...... -...... -...... -...... -...... -...#.. -..#... ----- 0x97 ('.') */ -..#... -.##... -..#... -..#... -.###.. -...... -...... -...... -...... -...... ----- 0x98 ('.') */ -...... -..##.. -.#..#. -.#..#. -..##.. -...... -.####. -...... -...... -...... ----- 0x99 ('.') */ -...... -...... -...... -#..#.. -.#..#. -..#..# -.#..#. -#..#.. -...... -...... ----- 0x9a ('.') */ -.#.... -##.... -.#.... -.#.... -###..# -....## -...#.# -..#### -.....# -...... ----- 0x9b ('.') */ -.#.... -##.... -.#.... -.#.... -###.#. -...#.# -.....# -....#. -...### -...... ----- 0x9c ('.') */ -##.... -..#... -.#.... -..#... -##..#. -...##. -..#.#. -.####. -....#. -...... ----- 0x9d ('.') */ -...... -..#... -...... -..#... -..#... -.#.... -#...#. -.###.. -...... -...... ----- 0x9e ('.') */ -.#.... -..#... -.###.. -#...#. -#...#. -#####. -#...#. -#...#. -...... -...... ----- 0x9f ('.') */ -...#.. -..#... -.###.. -#...#. -#...#. -#####. -#...#. -#...#. -...... -...... ----- 0xa0 ('.') */ -..#... -.#.#.. -.###.. -#...#. -#...#. -#####. -#...#. -#...#. -...... -...... ----- 0xa1 ('.') */ -.#..#. -#.##.. -.###.. -#...#. -#...#. -#####. -#...#. -#...#. -...... -...... ----- 0xa2 ('.') */ -.#.#.. -...... -.###.. -#...#. -#...#. -#####. -#...#. -#...#. -...... -...... ----- 0xa3 ('.') */ -..#... -.#.#.. -.###.. -#...#. -#...#. -#####. -#...#. -#...#. -...... -...... ----- 0xa4 ('.') */ -...... -..#### -.#.#.. -#..#.. -#..### -####.. -#..#.. -#..### -...... -...... ----- 0xa5 ('.') */ -...... -.###.. -#...#. -#..... -#..... -#..... -#...#. -.###.. -..#... -.#.... ----- 0xa6 ('.') */ -.#.... -#####. -#..... -#..... -####.. -#..... -#..... -#####. -...... -...... ----- 0xa7 ('.') */ -...#.. -#####. -#..... -#..... -####.. -#..... -#..... -#####. -...... -...... ----- 0xa8 ('.') */ -..#... -#####. -#..... -#..... -####.. -#..... -#..... -#####. -...... -...... ----- 0xa9 ('.') */ -.#.#.. -#####. -#..... -#..... -####.. -#..... -#..... -#####. -...... -...... ----- 0xaa ('.') */ -.#.... -..#... -.###.. -..#... -..#... -..#... -..#... -.###.. -...... -...... ----- 0xab ('.') */ -...#.. -..#... -.###.. -..#... -..#... -..#... -..#... -.###.. -...... -...... ----- 0xac ('.') */ -..#... -.#.#.. -.###.. -..#... -..#... -..#... -..#... -.###.. -...... -...... ----- 0xad ('.') */ -.#.#.. -...... -.###.. -..#... -..#... -..#... -..#... -.###.. -...... -...... ----- 0xae ('.') */ -...... -####.. -.#..#. -.#..#. -###.#. -.#..#. -.#..#. -####.. -...... -...... ----- 0xaf ('.') */ -..#.#. -.#.#.. -#...#. -##..#. -#.#.#. -#..##. -#...#. -#...#. -...... -...... ----- 0xb0 ('.') */ -.#.... -..#... -.###.. -#...#. -#...#. -#...#. -#...#. -.###.. -...... -...... ----- 0xb1 ('.') */ -...#.. -..#... -.###.. -#...#. -#...#. -#...#. -#...#. -.###.. -...... -...... ----- 0xb2 ('.') */ -..#... -.#.#.. -.###.. -#...#. -#...#. -#...#. -#...#. -.###.. -...... -...... ----- 0xb3 ('.') */ -..#.#. -.#.#.. -.###.. -#...#. -#...#. -#...#. -#...#. -.###.. -...... -...... ----- 0xb4 ('.') */ -.#.#.. -...... -.###.. -#...#. -#...#. -#...#. -#...#. -.###.. -...... -...... ----- 0xb5 ('.') */ -...... -...... -...... -#...#. -.#.#.. -..#... -.#.#.. -#...#. -...... -...... ----- 0xb6 ('.') */ -...... -.###.. -#..##. -#..##. -#.#.#. -##..#. -##..#. -.###.. -...... -...... ----- 0xb7 ('.') */ -.#.... -..#... -#...#. -#...#. -#...#. -#...#. -#...#. -.###.. -...... -...... ----- 0xb8 ('.') */ -...#.. -..#... -#...#. -#...#. -#...#. -#...#. -#...#. -.###.. -...... -...... ----- 0xb9 ('.') */ -..#... -.#.#.. -...... -#...#. -#...#. -#...#. -#...#. -.###.. -...... -...... ----- 0xba ('.') */ -.#.#.. -...... -#...#. -#...#. -#...#. -#...#. -#...#. -.###.. -...... -...... ----- 0xbb ('.') */ -...#.. -..#... -#...#. -#...#. -.#.#.. -..#... -..#... -..#... -...... -...... ----- 0xbc ('.') */ -...... -#..... -####.. -#...#. -####.. -#..... -#..... -#..... -...... -...... ----- 0xbd ('.') */ -...... -.###.. -#...#. -#..#.. -#.#... -#..#.. -#...#. -#.##.. -...... -...... ----- 0xbe ('.') */ -.#.... -..#... -...... -.###.. -....#. -.####. -#...#. -.####. -...... -...... ----- 0xbf ('.') */ -...#.. -..#... -...... -.###.. -....#. -.####. -#...#. -.####. -...... -...... ----- 0xc0 ('.') */ -..#... -.#.#.. -...... -.###.. -....#. -.####. -#...#. -.####. -...... -...... ----- 0xc1 ('.') */ -..#.#. -.#.#.. -...... -.###.. -....#. -.####. -#...#. -.####. -...... -...... ----- 0xc2 ('.') */ -...... -.#.#.. -...... -.###.. -....#. -.####. -#...#. -.####. -...... -...... ----- 0xc3 ('.') */ -..#... -.#.#.. -..#... -.###.. -....#. -.####. -#...#. -.####. -...... -...... ----- 0xc4 ('.') */ -...... -...... -...... -.####. -...#.# -.##### -#..#.. -.##### -...... -...... ----- 0xc5 ('.') */ -...... -...... -...... -.###.. -#...#. -#..... -#...#. -.###.. -..#... -.#.... ----- 0xc6 ('.') */ -.#.... -..#... -...... -.###.. -#...#. -#####. -#..... -.###.. -...... -...... ----- 0xc7 ('.') */ -...#.. -..#... -...... -.###.. -#...#. -#####. -#..... -.###.. -...... -...... ----- 0xc8 ('.') */ -..#... -.#.#.. -...... -.###.. -#...#. -#####. -#..... -.###.. -...... -...... ----- 0xc9 ('.') */ -...... -.#.#.. -...... -.###.. -#...#. -#####. -#..... -.###.. -...... -...... ----- 0xca ('.') */ -.#.... -..#... -...... -.##... -..#... -..#... -..#... -.###.. -...... -...... ----- 0xcb ('.') */ -..#... -.#.... -...... -.##... -..#... -..#... -..#... -.###.. -...... -...... ----- 0xcc ('.') */ -..#... -.#.#.. -...... -.##... -..#... -..#... -..#... -.###.. -...... -...... ----- 0xcd ('.') */ -...... -.#.#.. -...... -.##... -..#... -..#... -..#... -.###.. -...... -...... ----- 0xce ('.') */ -...... -##.... -..##.. -.###.. -#...#. -#...#. -#...#. -.###.. -...... -...... ----- 0xcf ('.') */ -..#.#. -.#.#.. -...... -#.##.. -##..#. -#...#. -#...#. -#...#. -...... -...... ----- 0xd0 ('.') */ -.#.... -..#... -...... -.###.. -#...#. -#...#. -#...#. -.###.. -...... -...... ----- 0xd1 ('.') */ -...#.. -..#... -...... -.###.. -#...#. -#...#. -#...#. -.###.. -...... -...... ----- 0xd2 ('.') */ -..#... -.#.#.. -...... -.###.. -#...#. -#...#. -#...#. -.###.. -...... -...... ----- 0xd3 ('.') */ -..#.#. -.#.#.. -...... -.###.. -#...#. -#...#. -#...#. -.###.. -...... -...... ----- 0xd4 ('.') */ -...... -.#.#.. -...... -.###.. -#...#. -#...#. -#...#. -.###.. -...... -...... ----- 0xd5 ('.') */ -...... -...... -..#... -...... -#####. -...... -..#... -...... -...... -...... ----- 0xd6 ('.') */ -...... -...... -...... -.####. -#..##. -#.#.#. -##..#. -####.. -...... -...... ----- 0xd7 ('.') */ -.#.... -..#... -...... -#...#. -#...#. -#...#. -#..##. -.##.#. -...... -...... ----- 0xd8 ('.') */ -...#.. -..#... -...... -#...#. -#...#. -#...#. -#..##. -.##.#. -...... -...... ----- 0xd9 ('.') */ -..#... -.#.#.. -...... -#...#. -#...#. -#...#. -#..##. -.##.#. -...... -...... ----- 0xda ('.') */ -...... -.#.#.. -...... -#...#. -#...#. -#...#. -#..##. -.##.#. -...... -...... ----- 0xdb ('.') */ -...... -...#.. -..#... -#...#. -#...#. -#..##. -.##.#. -....#. -#...#. -.###.. ----- 0xdc ('.') */ -...... -...... -#..... -####.. -#...#. -#...#. -#...#. -####.. -#..... -#..... ----- 0xdd ('.') */ -...... -.#.#.. -...... -#...#. -#...#. -#..##. -.##.#. -....#. -#...#. -.###.. ----- 0xde ('.') */ -.###.. -...... -.###.. -#...#. -#...#. -#####. -#...#. -#...#. -...... -...... ----- 0xdf ('.') */ -...... -.###.. -...... -.###.. -....#. -.####. -#...#. -.####. -...... -...... ----- 0xe0 ('.') */ -#...#. -.###.. -.###.. -#...#. -#...#. -#####. -#...#. -#...#. -...... -...... ----- 0xe1 ('.') */ -#...#. -.###.. -...... -.###.. -....#. -.####. -#...#. -.####. -...... -...... ----- 0xe2 ('.') */ -...... -..#... -.#.#.. -#...#. -#...#. -#####. -#...#. -#...#. -...#.. -...##. ----- 0xe3 ('.') */ -...... -...... -...... -.###.. -....#. -.####. -#...#. -.####. -...#.. -...##. ----- 0xe4 ('.') */ -...#.. -..#... -.###.. -#...#. -#..... -#..... -#...#. -.###.. -...... -...... ----- 0xe5 ('.') */ -...#.. -..#... -...... -.###.. -#...#. -#..... -#...#. -.###.. -...... -...... ----- 0xe6 ('.') */ -..#... -.#.#.. -.###.. -#...#. -#..... -#..... -#...#. -.###.. -...... -...... ----- 0xe7 ('.') */ -..#... -.#.#.. -...... -.###.. -#...#. -#..... -#...#. -.###.. -...... -...... ----- 0xe8 ('.') */ -..#... -...... -.###.. -#...#. -#..... -#..... -#...#. -.###.. -...... -...... ----- 0xe9 ('.') */ -...... -..#... -...... -.###.. -#...#. -#..... -#...#. -.###.. -...... -...... ----- 0xea ('.') */ -.#.#.. -..#... -.###.. -#...#. -#..... -#..... -#...#. -.###.. -...... -...... ----- 0xeb ('.') */ -.#.#.. -..#... -...... -.###.. -#...#. -#..... -#...#. -.###.. -...... -...... ----- 0xec ('.') */ -.#.#.. -..#... -####.. -#...#. -#...#. -#...#. -#...#. -####.. -...... -...... ----- 0xed ('.') */ -.#.#.. -..#... -....#. -.##.#. -#..##. -#...#. -#..##. -.##.#. -...... -...... ----- 0xee ('.') */ -...... -.####. -.#...# -.#...# -###..# -.#...# -.#...# -.####. -...... -...... ----- 0xef ('.') */ -...... -...#.. -..###. -...#.. -.###.. -#..#.. -#..#.. -.###.. -...... -...... ----- 0xf0 ('.') */ -.###.. -...... -#####. -#..... -####.. -#..... -#..... -#####. -...... -...... ----- 0xf1 ('.') */ -...... -.###.. -...... -.###.. -#...#. -#####. -#..... -.###.. -...... -...... ----- 0xf2 ('.') */ -#...#. -.###.. -#####. -#..... -####.. -#..... -#..... -#####. -...... -...... ----- 0xf3 ('.') */ -#...#. -.###.. -...... -.###.. -#...#. -#####. -#..... -.###.. -...... -...... ----- 0xf4 ('.') */ -..#... -...... -#####. -#..... -####.. -#..... -#..... -#####. -...... -...... ----- 0xf5 ('.') */ -...... -..#... -...... -.###.. -#...#. -#####. -#..... -.###.. -...... -...... ----- 0xf6 ('.') */ -...... -#####. -#..... -#..... -####.. -#..... -#..... -#####. -..#... -..##.. ----- 0xf7 ('.') */ -...... -...... -...... -.###.. -#...#. -#####. -#..... -.###.. -..#... -..##.. ----- 0xf8 ('.') */ -.#.#.. -..#... -#####. -#..... -####.. -#..... -#..... -#####. -...... -...... ----- 0xf9 ('.') */ -.#.#.. -..#... -...... -.###.. -#...#. -#####. -#..... -.###.. -...... -...... ----- 0xfa ('.') */ -..#... -.#.#.. -.###.. -#...#. -#..... -#..##. -#...#. -.###.. -...... -...... ----- 0xfb ('.') */ -..#... -.#.#.. -...... -.##.#. -#..#.. -.##... -#..... -.###.. -#...#. -.###.. ----- 0xfc ('.') */ -#...#. -.###.. -.###.. -#...#. -#..... -#..##. -#...#. -.###.. -...... -...... ----- 0xfd ('.') */ -#...#. -.###.. -...... -.##.#. -#..#.. -.##... -#..... -.###.. -#...#. -.###.. ----- 0xfe ('.') */ -..#... -...... -.###.. -#...#. -#..... -#..##. -#...#. -.###.. -...... -...... ----- 0xff ('.') */ - - diff --git a/tools/sci/bdf.cpp b/tools/sci/bdf.cpp deleted file mode 100644 index 8606688f8c..0000000000 --- a/tools/sci/bdf.cpp +++ /dev/null @@ -1,7434 +0,0 @@ -/* - * Copyright 2001 Computing Research Labs, New Mexico State University - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY BE LIABLE FOR ANY - * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT - * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR - * THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ -#ifndef lint -#ifdef __GNUC__ -static char rcsid[] __attribute__((unused)) = "$Id$"; -#else -static char rcsid[] = "$Id$"; -#endif -#endif - -#include "bdfP.h" - -#ifdef HAVE_HBF -#include "hbf.h" -#endif - -#undef MAX -#define MAX(h, i) ((h) > (i) ? (h) : (i)) - -#undef MIN -#define MIN(l, o) ((l) < (o) ? (l) : (o)) - -/************************************************************************** - * - * Masks used for checking different bits per pixel cases. - * - **************************************************************************/ - -unsigned char onebpp[] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 }; -unsigned char twobpp[] = { 0xc0, 0x30, 0x0c, 0x03 }; -unsigned char fourbpp[] = { 0xf0, 0x0f }; -unsigned char eightbpp[] = { 0xff }; - -/************************************************************************** - * - * Default BDF font options. - * - **************************************************************************/ - -static bdf_options_t _bdf_opts = { - 1, /* Hint TTF glyphs. */ - 1, /* Correct metrics. */ - 1, /* Preserve unencoded glyphs. */ - 1, /* Preserve comments. */ - 1, /* Pad character-cells. */ - BDF_PROPORTIONAL, /* Default spacing. */ - 12, /* Default point size. */ - 0, /* Default horizontal resolution. */ - 0, /* Default vertical resolution. */ - 1, /* Bits per pixel. */ - BDF_UNIX_EOL, /* Line separator. */ -}; - -/************************************************************************** - * - * Builtin BDF font properties. - * - **************************************************************************/ - -/* - * List of most properties that might appear in a font. Doesn't include the - * RAW_* and AXIS_* properties in X11R6 polymorphic fonts. - */ -static bdf_property_t _bdf_properties[] = { - {"ADD_STYLE_NAME", BDF_ATOM, 1}, - {"AVERAGE_WIDTH", BDF_INTEGER, 1}, - {"AVG_CAPITAL_WIDTH", BDF_INTEGER, 1}, - {"AVG_LOWERCASE_WIDTH", BDF_INTEGER, 1}, - {"CAP_HEIGHT", BDF_INTEGER, 1}, - {"CHARSET_COLLECTIONS", BDF_ATOM, 1}, - {"CHARSET_ENCODING", BDF_ATOM, 1}, - {"CHARSET_REGISTRY", BDF_ATOM, 1}, - {"COMMENT", BDF_ATOM, 1}, - {"COPYRIGHT", BDF_ATOM, 1}, - {"DEFAULT_CHAR", BDF_CARDINAL, 1}, - {"DESTINATION", BDF_CARDINAL, 1}, - {"DEVICE_FONT_NAME", BDF_ATOM, 1}, - {"END_SPACE", BDF_INTEGER, 1}, - {"FACE_NAME", BDF_ATOM, 1}, - {"FAMILY_NAME", BDF_ATOM, 1}, - {"FIGURE_WIDTH", BDF_INTEGER, 1}, - {"FONT", BDF_ATOM, 1}, - {"FONTNAME_REGISTRY", BDF_ATOM, 1}, - {"FONT_ASCENT", BDF_INTEGER, 1}, - {"FONT_DESCENT", BDF_INTEGER, 1}, - {"FOUNDRY", BDF_ATOM, 1}, - {"FULL_NAME", BDF_ATOM, 1}, - {"ITALIC_ANGLE", BDF_INTEGER, 1}, - {"MAX_SPACE", BDF_INTEGER, 1}, - {"MIN_SPACE", BDF_INTEGER, 1}, - {"NORM_SPACE", BDF_INTEGER, 1}, - {"NOTICE", BDF_ATOM, 1}, - {"PIXEL_SIZE", BDF_INTEGER, 1}, - {"POINT_SIZE", BDF_INTEGER, 1}, - {"QUAD_WIDTH", BDF_INTEGER, 1}, - {"RAW_ASCENT", BDF_INTEGER, 1}, - {"RAW_AVERAGE_WIDTH", BDF_INTEGER, 1}, - {"RAW_AVG_CAPITAL_WIDTH", BDF_INTEGER, 1}, - {"RAW_AVG_LOWERCASE_WIDTH", BDF_INTEGER, 1}, - {"RAW_CAP_HEIGHT", BDF_INTEGER, 1}, - {"RAW_DESCENT", BDF_INTEGER, 1}, - {"RAW_END_SPACE", BDF_INTEGER, 1}, - {"RAW_FIGURE_WIDTH", BDF_INTEGER, 1}, - {"RAW_MAX_SPACE", BDF_INTEGER, 1}, - {"RAW_MIN_SPACE", BDF_INTEGER, 1}, - {"RAW_NORM_SPACE", BDF_INTEGER, 1}, - {"RAW_PIXEL_SIZE", BDF_INTEGER, 1}, - {"RAW_POINT_SIZE", BDF_INTEGER, 1}, - {"RAW_PIXELSIZE", BDF_INTEGER, 1}, - {"RAW_POINTSIZE", BDF_INTEGER, 1}, - {"RAW_QUAD_WIDTH", BDF_INTEGER, 1}, - {"RAW_SMALL_CAP_SIZE", BDF_INTEGER, 1}, - {"RAW_STRIKEOUT_ASCENT", BDF_INTEGER, 1}, - {"RAW_STRIKEOUT_DESCENT", BDF_INTEGER, 1}, - {"RAW_SUBSCRIPT_SIZE", BDF_INTEGER, 1}, - {"RAW_SUBSCRIPT_X", BDF_INTEGER, 1}, - {"RAW_SUBSCRIPT_Y", BDF_INTEGER, 1}, - {"RAW_SUPERSCRIPT_SIZE", BDF_INTEGER, 1}, - {"RAW_SUPERSCRIPT_X", BDF_INTEGER, 1}, - {"RAW_SUPERSCRIPT_Y", BDF_INTEGER, 1}, - {"RAW_UNDERLINE_POSITION", BDF_INTEGER, 1}, - {"RAW_UNDERLINE_THICKNESS", BDF_INTEGER, 1}, - {"RAW_X_HEIGHT", BDF_INTEGER, 1}, - {"RELATIVE_SETWIDTH", BDF_CARDINAL, 1}, - {"RELATIVE_WEIGHT", BDF_CARDINAL, 1}, - {"RESOLUTION", BDF_INTEGER, 1}, - {"RESOLUTION_X", BDF_CARDINAL, 1}, - {"RESOLUTION_Y", BDF_CARDINAL, 1}, - {"SETWIDTH_NAME", BDF_ATOM, 1}, - {"SLANT", BDF_ATOM, 1}, - {"SMALL_CAP_SIZE", BDF_INTEGER, 1}, - {"SPACING", BDF_ATOM, 1}, - {"STRIKEOUT_ASCENT", BDF_INTEGER, 1}, - {"STRIKEOUT_DESCENT", BDF_INTEGER, 1}, - {"SUBSCRIPT_SIZE", BDF_INTEGER, 1}, - {"SUBSCRIPT_X", BDF_INTEGER, 1}, - {"SUBSCRIPT_Y", BDF_INTEGER, 1}, - {"SUPERSCRIPT_SIZE", BDF_INTEGER, 1}, - {"SUPERSCRIPT_X", BDF_INTEGER, 1}, - {"SUPERSCRIPT_Y", BDF_INTEGER, 1}, - {"UNDERLINE_POSITION", BDF_INTEGER, 1}, - {"UNDERLINE_THICKNESS", BDF_INTEGER, 1}, - {"WEIGHT", BDF_CARDINAL, 1}, - {"WEIGHT_NAME", BDF_ATOM, 1}, - {"X_HEIGHT", BDF_INTEGER, 1}, - {"_MULE_BASELINE_OFFSET", BDF_INTEGER, 1}, - {"_MULE_RELATIVE_COMPOSE", BDF_INTEGER, 1}, -}; - -static unsigned long _num_bdf_properties = - sizeof(_bdf_properties) / sizeof(_bdf_properties[0]); - -/* - * User defined properties. - */ -static bdf_property_t *user_props; -static unsigned long nuser_props = 0; - -/************************************************************************** - * - * Hash table utilities for the properties. - * - **************************************************************************/ - -#define INITIAL_HT_SIZE 241 - -typedef struct { - char *key; - void *data; -} _hashnode, *hashnode; - -typedef struct { - int limit; - int size; - int used; - hashnode *table; -} hashtable; - -typedef void (*hash_free_func)( -#ifdef __STDC__ - hashnode node -#endif -); - -static hashnode * -#ifdef __STDC__ -hash_bucket(char *key, hashtable *ht) -#else -hash_bucket(key, ht) -char *key; -hashtable *ht; -#endif -{ - char *kp = key; - unsigned long res = 0; - hashnode *bp = ht->table, *ndp; - - /* - * Mocklisp hash function. - */ - while (*kp) - res = (res << 5) - res + *kp++; - - ndp = bp + (res % ht->size); - while (*ndp) { - kp = (*ndp)->key; - if (kp[0] == key[0] && strcmp(kp, key) == 0) - break; - ndp--; - if (ndp < bp) - ndp = bp + (ht->size - 1); - } - return ndp; -} - -static void -#ifdef __STDC__ -hash_rehash(hashtable *ht) -#else -hash_rehash(ht) -hashtable *ht; -#endif -{ - hashnode *obp = ht->table, *bp, *nbp; - int i, sz = ht->size; - - ht->size <<= 1; - ht->limit = ht->size / 3; - ht->table = (hashnode *) malloc(sizeof(hashnode) * ht->size); - (void) memset((char *) ht->table, 0, sizeof(hashnode) * ht->size); - - for (i = 0, bp = obp; i < sz; i++, bp++) { - if (*bp) { - nbp = hash_bucket((*bp)->key, ht); - *nbp = *bp; - } - } - free((char *) obp); -} - -static void -#ifdef __STDC__ -hash_init(hashtable *ht) -#else -hash_init(ht) -hashtable *ht; -#endif -{ - int sz = INITIAL_HT_SIZE; - - ht->size = sz; - ht->limit = sz / 3; - ht->used = 0; - ht->table = (hashnode *) malloc(sizeof(hashnode) * sz); - (void) memset((char *) ht->table, 0, sizeof(hashnode) * sz); -} - -static void -#ifdef __STDC__ -hash_free(hashtable *ht) -#else -hash_free(ht) -hashtable *ht; -#endif -{ - int i, sz = ht->size; - hashnode *bp = ht->table; - - for (i = 0; i < sz; i++, bp++) { - if (*bp) - free((char *) *bp); - } - if (sz > 0) - free((char *) ht->table); -} - -static void -#ifdef __STDC__ -hash_insert(char *key, void *data, hashtable *ht) -#else -hash_insert(key, data, ht) -char *key; -void *data; -hashtable *ht; -#endif -{ - hashnode nn, *bp = hash_bucket(key, ht); - - nn = *bp; - if (!nn) { - *bp = nn = (hashnode) malloc(sizeof(_hashnode)); - nn->key = key; - nn->data = data; - - if (ht->used >= ht->limit) - hash_rehash(ht); - ht->used++; - } else - nn->data = data; -} - -static hashnode -#ifdef __STDC__ -hash_lookup(char *key, hashtable *ht) -#else -hash_lookup(key, ht) -char *key; -hashtable *ht; -#endif -{ - hashnode *np = hash_bucket(key, ht); - return *np; -} - -static void -#ifdef __STDC__ -hash_delete(char *name, hashtable *ht) -#else -hash_delete(name, ht) -char *name; -hashtable *ht; -#endif -{ - hashnode *hp; - - hp = hash_bucket(name, ht); - if (*hp) { - free((char *) *hp); - *hp = 0; - } -} - -/* - * The builtin property table. - */ -static hashtable proptbl; - -/************************************************************************** - * - * Utility types and functions. - * - **************************************************************************/ - -/* - * Function type for parsing lines of a BDF font. - */ -typedef int (*_bdf_line_func_t)( -#ifdef __STDC__ - char *line, - unsigned long linelen, - unsigned long lineno, - void *call_data, - void *client_data -#endif -); - -/* - * List structure for splitting lines into fields. - */ -typedef struct { - char **field; - unsigned long size; - unsigned long used; - char *bfield; - unsigned long bsize; - unsigned long bused; -} _bdf_list_t; - -/* - * Structure used while loading BDF fonts. - */ -typedef struct { - unsigned long flags; - unsigned long cnt; - unsigned long row; - unsigned long bpr; - short minlb; - short maxlb; - short maxrb; - short maxas; - short maxds; - short rbearing; - char *glyph_name; - long glyph_enc; - bdf_font_t *font; - bdf_options_t *opts; - void *client_data; - bdf_callback_t callback; - bdf_callback_struct_t cb; - unsigned long have[2048]; - _bdf_list_t list; -} _bdf_parse_t; - -#define setsbit(m, cc) (m[(cc) >> 3] |= (1 << ((cc) & 7))) -#define sbitset(m, cc) (m[(cc) >> 3] & (1 << ((cc) & 7))) - -/* - * An empty string for empty fields. - */ -static char empty[1] = { 0 }; - -/* - * Assume the line is NULL terminated and that the `list' parameter was - * initialized the first time it was used. - */ -static void -#ifdef __STDC__ -_bdf_split(char *separators, char *line, unsigned long linelen, - _bdf_list_t *list) -#else -_bdf_split(separators, line, linelen, list) -char *separators, *line; -unsigned long linelen; -_bdf_list_t *list; -#endif -{ - int mult, final_empty; - char *sp, *ep, *end; - unsigned char seps[32]; - - /* - * Initialize the list. - */ - list->used = list->bused = 0; - - /* - * If the line is empty, then simply return. - */ - if (linelen == 0 || line[0] == 0) - return; - - /* - * If the `separators' parameter is NULL or empty, split the list into - * individual bytes. - */ - if (separators == 0 || *separators == 0) { - if (linelen > list->bsize) { - if (list->bsize) - list->bfield = (char *) malloc(linelen); - else - list->bfield = (char *) realloc(list->bfield, linelen); - list->bsize = linelen; - } - list->bused = linelen; - (void) memcpy(list->bfield, line, linelen); - return; - } - - /* - * Prepare the separator bitmap. - */ - (void) memset((char *) seps, 0, 32); - - /* - * If the very last character of the separator string is a plus, then set - * the `mult' flag to indicate that multiple separators should be - * collapsed into one. - */ - for (mult = 0, sp = separators; sp && *sp; sp++) { - if (*sp == '+' && *(sp + 1) == 0) - mult = 1; - else - setsbit(seps, *sp); - } - - /* - * Break the line up into fields. - */ - for (final_empty = 0, sp = ep = line, end = sp + linelen; - sp < end && *sp;) { - /* - * Collect everything that is not a separator. - */ - for (; *ep && !sbitset(seps, *ep); ep++) ; - - /* - * Resize the list if necessary. - */ - if (list->used == list->size) { - if (list->size == 0) - list->field = (char **) malloc(sizeof(char *) * 5); - else - list->field = (char **) - realloc((char *) list->field, - sizeof(char *) * (list->size + 5)); - - list->size += 5; - } - - /* - * Assign the field appropriately. - */ - list->field[list->used++] = (ep > sp) ? sp : empty; - - sp = ep; - if (mult) { - /* - * If multiple separators should be collapsed, do it now by - * setting all the separator characters to 0. - */ - for (; *ep && sbitset(seps, *ep); ep++) - *ep = 0; - } else if (*ep != 0) - /* - * Don't collapse multiple separators by making them 0, so just - * make the one encountered 0. - */ - *ep++ = 0; - final_empty = (ep > sp && *ep == 0); - sp = ep; - } - - /* - * Finally, NULL terminate the list. - */ - if (list->used + final_empty + 1 >= list->size) { - if (list->used == list->size) { - if (list->size == 0) - list->field = (char **) malloc(sizeof(char *) * 5); - else - list->field = (char **) - realloc((char *) list->field, - sizeof(char *) * (list->size + 5)); - list->size += 5; - } - } - if (final_empty) - list->field[list->used++] = empty; - - if (list->used == list->size) { - if (list->size == 0) - list->field = (char **) malloc(sizeof(char *) * 5); - else - list->field = (char **) - realloc((char *) list->field, - sizeof(char *) * (list->size + 5)); - list->size += 5; - } - list->field[list->used] = 0; -} - -static void -#ifdef __STDC__ -_bdf_shift(unsigned long n, _bdf_list_t *list) -#else -_bdf_shift(n, list) -unsigned long n; -_bdf_list_t *list; -#endif -{ - unsigned long i, u; - - if (list == 0 || list->used == 0 || n == 0) - return; - - if (n >= list->used) { - list->used = 0; - return; - } - for (u = n, i = 0; u < list->used; i++, u++) - list->field[i] = list->field[u]; - list->used -= n; -} - -static char * -#ifdef __STDC__ -_bdf_join(int c, unsigned long *len, _bdf_list_t *list) -#else -_bdf_join(c, len, list) -int c; -unsigned long *len; -_bdf_list_t *list; -#endif -{ - unsigned long i, j; - char *fp, *dp; - - if (list == 0 || list->used == 0) - return 0; - - *len = 0; - - dp = list->field[0]; - for (i = j = 0; i < list->used; i++) { - fp = list->field[i]; - while (*fp) - dp[j++] = *fp++; - if (i + 1 < list->used) - dp[j++] = c; - } - dp[j] = 0; - - *len = j; - return dp; -} - -/* - * High speed file reader that passes each line to a callback. - */ -static int -#ifdef __STDC__ -_bdf_readlines(int fd, _bdf_line_func_t callback, void *client_data, - unsigned long *lno) -#else -_bdf_readlines(fd, callback, client_data, lno) -int fd; -_bdf_line_func_t callback; -void *client_data; -unsigned long *lno; -#endif -{ - _bdf_line_func_t cb; - unsigned long lineno; - int n, res, done, refill, bytes, hold; - char *ls, *le, *pp, *pe, *hp; - char buf[65536]; - - if (callback == 0) - return -1; - - cb = callback; - lineno = 1; - buf[0] = 0; - res = done = 0; - pp = ls = le = buf; - bytes = 65536; - while (!done && (n = read(fd, pp, bytes)) > 0) { - /* - * Determine the new end of the buffer pages. - */ - pe = pp + n; - - for (refill = 0; done == 0 && refill == 0;) { - while (le < pe && *le != '\n' && *le != '\r') - le++; - - if (le == pe) { - /* - * Hit the end of the last page in the buffer. Need to find - * out how many pages to shift and how many pages need to be - * read in. Adjust the line start and end pointers down to - * point to the right places in the pages. - */ - pp = buf + (((ls - buf) >> 13) << 13); - n = pp - buf; - ls -= n; - le -= n; - n = pe - pp; - (void) memcpy(buf, pp, n); - pp = buf + n; - bytes = 65536 - n; - refill = 1; - } else { - /* - * Temporarily NULL terminate the line. - */ - hp = le; - hold = *le; - *le = 0; - - if (callback && *ls != '#' && *ls != 0x1a && le > ls && - (res = (*cb)(ls, le - ls, lineno, (void *) & cb, - client_data)) != 0) - done = 1; - else { - ls = ++le; - /* - * Handle the case of DOS crlf sequences. - */ - if (le < pe && hold == '\n' && *le == '\r') - ls = ++le; - } - - /* - * Increment the line number. - */ - lineno++; - - /* - * Restore the character at the end of the line. - */ - *hp = hold; - } - } - } - *lno = lineno; - return res; -} - -unsigned char * -#ifdef __STDC__ -_bdf_strdup(unsigned char *s, unsigned long len) -#else -_bdf_strdup(s, len) -unsigned char *s; -unsigned long len; -#endif -{ - unsigned char *ns; - - if (s == 0 || len == 0) - return 0; - - ns = (unsigned char *) malloc(len); - (void) memcpy((char *) ns, (char *) s, len); - return ns; -} - -void -_bdf_memmove(char *dest, char *src, unsigned long bytes) { - long i, j; - - i = (long) bytes; - j = i & 7; - i = (i + 7) >> 3; - - /* - * Do a memmove using Ye Olde Duff's Device for efficiency. - */ - if (src < dest) { - src += bytes; - dest += bytes; - - switch (j) { - case 0: - do { - *--dest = *--src; - case 7: - *--dest = *--src; - case 6: - *--dest = *--src; - case 5: - *--dest = *--src; - case 4: - *--dest = *--src; - case 3: - *--dest = *--src; - case 2: - *--dest = *--src; - case 1: - *--dest = *--src; - } while (--i > 0); - } - } else if (src > dest) { - switch (j) { - case 0: - do { - *dest++ = *src++; - case 7: - *dest++ = *src++; - case 6: - *dest++ = *src++; - case 5: - *dest++ = *src++; - case 4: - *dest++ = *src++; - case 3: - *dest++ = *src++; - case 2: - *dest++ = *src++; - case 1: - *dest++ = *src++; - } while (--i > 0); - } - } -} - -static unsigned char a2i[128] = { - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 -}; - -static unsigned char odigits[32] = { - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, -}; - -static unsigned char ddigits[32] = { - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, -}; - -static unsigned char hdigits[32] = { - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03, - 0x7e, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, -}; - -#define isdigok(m, d) (m[(d) >> 3] & (1 << ((d) & 7))) - -/* - * Routine to convert an ASCII string into an unsigned long integer. - */ -unsigned long -#ifdef __STDC__ -_bdf_atoul(char *s, char **end, int base) -#else -_bdf_atoul(s, end, base) -char *s, **end; -int base; -#endif -{ - unsigned long v; - unsigned char *dmap; - - if (s == 0 || *s == 0) - return 0; - - /* - * Make sure the radix is something recognizable. Default to 10. - */ - switch (base) { - case 8: - dmap = odigits; - break; - case 16: - dmap = hdigits; - break; - default: - base = 10; - dmap = ddigits; - break; - } - - /* - * Check for the special hex prefix. - */ - if (*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X')) { - base = 16; - dmap = hdigits; - s += 2; - } - - for (v = 0; isdigok(dmap, *s); s++) - v = (v * base) + a2i[(int) *s]; - - if (end != 0) - *end = s; - - return v; -} - -/* - * Routine to convert an ASCII string into an signed long integer. - */ -long -#ifdef __STDC__ -_bdf_atol(char *s, char **end, int base) -#else -_bdf_atol(s, end, base) -char *s, **end; -int base; -#endif -{ - long v, neg; - unsigned char *dmap; - - if (s == 0 || *s == 0) - return 0; - - /* - * Make sure the radix is something recognizable. Default to 10. - */ - switch (base) { - case 8: - dmap = odigits; - break; - case 16: - dmap = hdigits; - break; - default: - base = 10; - dmap = ddigits; - break; - } - - /* - * Check for a minus sign. - */ - neg = 0; - if (*s == '-') { - s++; - neg = 1; - } - - /* - * Check for the special hex prefix. - */ - if (*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X')) { - base = 16; - dmap = hdigits; - s += 2; - } - - for (v = 0; isdigok(dmap, *s); s++) - v = (v * base) + a2i[(int) *s]; - - if (end != 0) - *end = s; - - return (!neg) ? v : -v; -} - -/* - * Routine to convert an ASCII string into an signed short integer. - */ -short -#ifdef __STDC__ -_bdf_atos(char *s, char **end, int base) -#else -_bdf_atos(s, end, base) -char *s, **end; -int base; -#endif -{ - short v, neg; - unsigned char *dmap; - - if (s == 0 || *s == 0) - return 0; - - /* - * Make sure the radix is something recognizable. Default to 10. - */ - switch (base) { - case 8: - dmap = odigits; - break; - case 16: - dmap = hdigits; - break; - default: - base = 10; - dmap = ddigits; - break; - } - - /* - * Check for a minus. - */ - neg = 0; - if (*s == '-') { - s++; - neg = 1; - } - - /* - * Check for the special hex prefix. - */ - if (*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X')) { - base = 16; - dmap = hdigits; - s += 2; - } - - for (v = 0; isdigok(dmap, *s); s++) - v = (v * base) + a2i[(int) *s]; - - if (end != 0) - *end = s; - - return (!neg) ? v : -v; -} - -/* - * Routine to compare two glyphs by encoding so they can be sorted. - */ -static int -#ifdef __STDC__ -by_encoding(const void *a, const void *b) -#else -by_encoding(a, b) -char *a, *b; -#endif -{ - bdf_glyph_t *c1, *c2; - - c1 = (bdf_glyph_t *) a; - c2 = (bdf_glyph_t *) b; - if (c1->encoding < c2->encoding) - return -1; - else if (c1->encoding > c2->encoding) - return 1; - return 0; -} - -/************************************************************************** - * - * BDF font file parsing flags and functions. - * - **************************************************************************/ - -/* - * Parse flags. - */ -#define _BDF_START 0x0001 -#define _BDF_FONT_NAME 0x0002 -#define _BDF_SIZE 0x0004 -#define _BDF_FONT_BBX 0x0008 -#define _BDF_PROPS 0x0010 -#define _BDF_GLYPHS 0x0020 -#define _BDF_GLYPH 0x0040 -#define _BDF_ENCODING 0x0080 -#define _BDF_SWIDTH 0x0100 -#define _BDF_DWIDTH 0x0200 -#define _BDF_BBX 0x0400 -#define _BDF_BITMAP 0x0800 - -#define _BDF_SWIDTH_ADJ 0x1000 - -#define _BDF_GLYPH_BITS (_BDF_GLYPH|_BDF_ENCODING|_BDF_SWIDTH|\ - _BDF_DWIDTH|_BDF_BBX|_BDF_BITMAP) - -#define _BDF_GLYPH_WIDTH_CHECK 0x40000000 -#define _BDF_GLYPH_HEIGHT_CHECK 0x80000000 - -/* - * Auto correction messages. - */ -#define ACMSG1 "FONT_ASCENT property missing. Added \"FONT_ASCENT %hd\"." -#define ACMSG2 "FONT_DESCENT property missing. Added \"FONT_DESCENT %hd\"." -#define ACMSG3 "Font width != actual width. Old: %hd New: %hd." -#define ACMSG4 "Font left bearing != actual left bearing. Old: %hd New: %hd." -#define ACMSG5 "Font ascent != actual ascent. Old: %hd New: %hd." -#define ACMSG6 "Font descent != actual descent. Old: %hd New: %hd." -#define ACMSG7 "Font height != actual height. Old: %hd New: %hd." -#define ACMSG8 "Glyph scalable width (SWIDTH) adjustments made." -#define ACMSG9 "SWIDTH field missing at line %ld. Set automatically." -#define ACMSG10 "DWIDTH field missing at line %ld. Set to glyph width." -#define ACMSG11 "SIZE bits per pixel field adjusted to %hd." -#define ACMSG12 "Duplicate encoding %ld (%s) changed to unencoded." -#define ACMSG13 "Glyph %ld extra rows removed." -#define ACMSG14 "Glyph %ld extra columns removed." -#define ACMSG15 "Incorrect glyph count: %ld indicated but %ld found." - -/* - * Error messages. - */ -#define ERRMSG1 "[line %ld] Missing \"%s\" line." -#define ERRMSG2 "[line %ld] Font header corrupted or missing fields." -#define ERRMSG3 "[line %ld] Font glyphs corrupted or missing fields." - -void -#ifdef __STDC__ -_bdf_add_acmsg(bdf_font_t *font, char *msg, unsigned long len) -#else -_bdf_add_acmsg(font, msg, len) -bdf_font_t *font; -char *msg; -unsigned long len; -#endif -{ - char *cp; - - if (font->acmsgs_len == 0) - font->acmsgs = (char *) malloc(len + 1); - else - font->acmsgs = (char *) realloc(font->acmsgs, - font->acmsgs_len + len + 1); - - cp = font->acmsgs + font->acmsgs_len; - (void) memcpy(cp, msg, len); - cp += len; - *cp++ = '\n'; - font->acmsgs_len += len + 1; -} - -void -#ifdef __STDC__ -_bdf_add_comment(bdf_font_t *font, char *comment, unsigned long len) -#else -_bdf_add_comment(font, comment, len) -bdf_font_t *font; -char *comment; -unsigned long len; -#endif -{ - char *cp; - - if (font->comments_len == 0) - font->comments = (char *) malloc(len + 1); - else - font->comments = (char *) realloc(font->comments, - font->comments_len + len + 1); - - cp = font->comments + font->comments_len; - (void) memcpy(cp, comment, len); - cp += len; - *cp++ = '\n'; - font->comments_len += len + 1; -} - -/* - * Set the spacing from the font name if it exists, or set it to the default - * specified in the options. - */ -static void -#ifdef __STDC__ -_bdf_set_default_spacing(bdf_font_t *font, bdf_options_t *opts) -#else -_bdf_set_default_spacing(font, opts) -bdf_font_t *font; -bdf_options_t *opts; -#endif -{ - unsigned long len; - char name[128]; - _bdf_list_t list; - - if (font == 0 || font->name == 0 || font->name[0] == 0) - return; - - font->spacing = opts->font_spacing; - - len = (unsigned long)(strlen(font->name) + 1); - (void) memcpy(name, font->name, len); - list.size = list.used = 0; - _bdf_split("-", name, len, &list); - if (list.used == 15) { - switch (list.field[11][0]) { - case 'C': - case 'c': - font->spacing = BDF_CHARCELL; - break; - case 'M': - case 'm': - font->spacing = BDF_MONOWIDTH; - break; - case 'P': - case 'p': - font->spacing = BDF_PROPORTIONAL; - break; - } - } - if (list.size > 0) - free((char *) list.field); -} - -/* - * Determine if the property is an atom or not. If it is, then clean it up so - * the double quotes are removed if they exist. - */ -static int -#ifdef __STDC__ -_bdf_is_atom(char *line, unsigned long linelen, char **name, char **value) -#else -_bdf_is_atom(line, linelen, name, value) -char *line; -unsigned long linelen; -char **name, **value; -#endif -{ - int hold; - char *sp, *ep; - bdf_property_t *p; - - *name = sp = ep = line; - while (*ep && *ep != ' ' && *ep != '\t') - ep++; - - hold = -1; - if (*ep) { - hold = *ep; - *ep = 0; - } - - p = bdf_get_property(sp); - - /* - * Restore the character that was saved before any return can happen. - */ - if (hold != -1) - *ep = hold; - - /* - * If the propert exists and is not an atom, just return here. - */ - if (p && p->format != BDF_ATOM) - return 0; - - /* - * The property is an atom. Trim all leading and trailing whitespace and - * double quotes for the atom value. - */ - sp = ep; - ep = line + linelen; - - /* - * Trim the leading whitespace if it exists. - */ - *sp++ = 0; - while (*sp && (*sp == ' ' || *sp == '\t')) - sp++; - - /* - * Trim the leading double quote if it exists. - */ - if (*sp == '"') - sp++; - *value = sp; - - /* - * Trim the trailing whitespace if it exists. - */ - while (ep > sp && (*(ep - 1) == ' ' || *(ep - 1) == '\t')) - *--ep = 0; - - /* - * Trim the trailing double quote if it exists. - */ - if (ep > sp && *(ep - 1) == '"') - *--ep = 0; - - return 1; -} - -static void -#ifdef __STDC__ -_bdf_add_property(bdf_font_t *font, char *name, char *value) -#else -_bdf_add_property(font, name, value) -bdf_font_t *font; -char *name, *value; -#endif -{ - unsigned long propid; - hashnode hn; - int len; - bdf_property_t *prop, *fp; - - /* - * First, check to see if the property already exists in the font. - */ - if ((hn = hash_lookup(name, (hashtable *) font->internal)) != 0) { - /* - * The property already exists in the font, so simply replace - * the value of the property with the current value. - */ - fp = font->props + (unsigned long) hn->data; - - switch (fp->format) { - case BDF_ATOM: - /* - * Delete the current atom if it exists. - */ - if (fp->value.atom != 0) - free(fp->value.atom); - - if (value == 0) - len = 1; - else - len = strlen(value) + 1; - if (len > 1) { - fp->value.atom = (char *) malloc(len); - (void) memcpy(fp->value.atom, value, len); - } else - fp->value.atom = 0; - break; - case BDF_INTEGER: - fp->value.int32 = _bdf_atol(value, 0, 10); - break; - case BDF_CARDINAL: - fp->value.card32 = _bdf_atoul(value, 0, 10); - break; - } - return; - } - - /* - * See if this property type exists yet or not. If not, create it. - */ - hn = hash_lookup(name, &proptbl); - if (hn == 0) { - bdf_create_property(name, BDF_ATOM); - hn = hash_lookup(name, &proptbl); - } - - /* - * Allocate another property if this is overflow. - */ - if (font->props_used == font->props_size) { - if (font->props_size == 0) - font->props = (bdf_property_t *) malloc(sizeof(bdf_property_t)); - else - font->props = (bdf_property_t *) - realloc((char *) font->props, sizeof(bdf_property_t) * - (font->props_size + 1)); - fp = font->props + font->props_size; - (void) memset((char *) fp, 0, sizeof(bdf_property_t)); - font->props_size++; - } - - propid = (unsigned long) hn->data; - if (propid >= _num_bdf_properties) - prop = user_props + (propid - _num_bdf_properties); - else - prop = _bdf_properties + propid; - - fp = font->props + font->props_used; - - fp->name = prop->name; - fp->format = prop->format; - fp->builtin = prop->builtin; - - switch (prop->format) { - case BDF_ATOM: - if (value == 0) - len = 1; - else - len = strlen(value) + 1; - if (len > 1) { - fp->value.atom = (char *) malloc(len); - (void) memcpy(fp->value.atom, value, len); - } else - fp->value.atom = 0; - break; - case BDF_INTEGER: - fp->value.int32 = _bdf_atol(value, 0, 10); - break; - case BDF_CARDINAL: - fp->value.card32 = _bdf_atoul(value, 0, 10); - break; - } - - /* - * If the property happens to be a comment, then it doesn't need - * to be added to the internal hash table. - */ - if (memcmp(name, "COMMENT", 7) != 0) - /* - * Add the property to the font property table. - */ - hash_insert(fp->name, (void *) font->props_used, - (hashtable *) font->internal); - - font->props_used++; - - /* - * Some special cases need to be handled here. The DEFAULT_CHAR property - * needs to be located if it exists in the property list, the FONT_ASCENT - * and FONT_DESCENT need to be assigned if they are present, and the - * SPACING property should override the default spacing. - */ - if (memcmp(name, "DEFAULT_CHAR", 12) == 0) - font->default_glyph = fp->value.int32; - else if (memcmp(name, "FONT_ASCENT", 11) == 0) - font->font_ascent = fp->value.int32; - else if (memcmp(name, "FONT_DESCENT", 12) == 0) - font->font_descent = fp->value.int32; - else if (memcmp(name, "SPACING", 7) == 0) { - if (fp->value.atom[0] == 'p' || fp->value.atom[0] == 'P') - font->spacing = BDF_PROPORTIONAL; - else if (fp->value.atom[0] == 'm' || fp->value.atom[0] == 'M') - font->spacing = BDF_MONOWIDTH; - else if (fp->value.atom[0] == 'c' || fp->value.atom[0] == 'C') - font->spacing = BDF_CHARCELL; - } -} - -/* - * Actually parse the glyph info and bitmaps. - */ -static int -#ifdef __STDC__ -_bdf_parse_glyphs(char *line, unsigned long linelen, unsigned long lineno, - void *call_data, void *client_data) -#else -_bdf_parse_glyphs(line, linelen, lineno, call_data, client_data) -char *line; -unsigned long linelen, lineno; -void *call_data, *client_data; -#endif -{ - int c; - char *s; - unsigned char *bp; - unsigned long i, slen, nibbles; - double ps, rx, dw, sw; - _bdf_line_func_t *next; - _bdf_parse_t *p; - bdf_glyph_t *glyph; - bdf_font_t *font; - char nbuf[128]; - - next = (_bdf_line_func_t *) call_data; - p = (_bdf_parse_t *) client_data; - - font = p->font; - - /* - * Check for a comment. - */ - if (memcmp(line, "COMMENT", 7) == 0) { - linelen -= 7; - s = line + 7; - if (*s != 0) { - s++; - linelen--; - } - _bdf_add_comment(p->font, s, linelen); - return 0; - } - - /* - * The very first thing expected is the number of glyphs. - */ - if (!(p->flags & _BDF_GLYPHS)) { - if (memcmp(line, "CHARS", 5) != 0) { - sprintf(nbuf, ERRMSG1, lineno, "CHARS"); - _bdf_add_acmsg(p->font, nbuf, strlen(nbuf)); - return BDF_MISSING_CHARS; - } - _bdf_split(" +", line, linelen, &p->list); - p->cnt = font->glyphs_size = _bdf_atoul(p->list.field[1], 0, 10); - - /* - * Make sure the number of glyphs is non-zero. - */ - if (p->cnt == 0) - font->glyphs_size = 64; - - font->glyphs = (bdf_glyph_t *) malloc(sizeof(bdf_glyph_t) * - font->glyphs_size); - - /* - * Set up the callback to indicate the glyph loading is about to - * begin. - */ - if (p->callback != 0) { - p->cb.reason = BDF_LOAD_START; - p->cb.total = p->cnt; - p->cb.current = 0; - (*p->callback)(&p->cb, p->client_data); - } - p->flags |= _BDF_GLYPHS; - return 0; - } - - /* - * Check for the ENDFONT field. - */ - if (memcmp(line, "ENDFONT", 7) == 0) { - /* - * Sort the glyphs by encoding. - */ - qsort((char *) font->glyphs, font->glyphs_used, sizeof(bdf_glyph_t), - by_encoding); - - p->flags &= ~_BDF_START; - return 0; - } - - /* - * Check for the ENDCHAR field. - */ - if (memcmp(line, "ENDCHAR", 7) == 0) { - /* - * Set up and call the callback if it was passed. - */ - if (p->callback != 0) { - p->cb.reason = BDF_LOADING; - p->cb.total = font->glyphs_size; - p->cb.current = font->glyphs_used; - (*p->callback)(&p->cb, p->client_data); - } - p->glyph_enc = 0; - p->flags &= ~_BDF_GLYPH_BITS; - return 0; - } - - /* - * Check to see if a glyph is being scanned but should be ignored - * because it is an unencoded glyph. - */ - if ((p->flags & _BDF_GLYPH) && - p->glyph_enc == -1 && p->opts->keep_unencoded == 0) - return 0; - - /* - * Check for the STARTCHAR field. - */ - if (memcmp(line, "STARTCHAR", 9) == 0) { - /* - * Set the character name in the parse info first until the - * encoding can be checked for an unencoded character. - */ - if (p->glyph_name != 0) - free(p->glyph_name); - _bdf_split(" +", line, linelen, &p->list); - _bdf_shift(1, &p->list); - s = _bdf_join(' ', &slen, &p->list); - p->glyph_name = (char *) malloc(slen + 1); - (void) memcpy(p->glyph_name, s, slen + 1); - p->flags |= _BDF_GLYPH; - return 0; - } - - /* - * Check for the ENCODING field. - */ - if (memcmp(line, "ENCODING", 8) == 0) { - if (!(p->flags & _BDF_GLYPH)) { - /* - * Missing STARTCHAR field. - */ - sprintf(nbuf, ERRMSG1, lineno, "STARTCHAR"); - _bdf_add_acmsg(font, nbuf, strlen(nbuf)); - return BDF_MISSING_STARTCHAR; - } - _bdf_split(" +", line, linelen, &p->list); - p->glyph_enc = _bdf_atol(p->list.field[1], 0, 10); - - /* - * Check to see if this encoding has already been encountered. If it - * has then change it to unencoded so it gets added if indicated. - */ - if (p->glyph_enc >= 0) { - if (_bdf_glyph_modified(p->have, p->glyph_enc)) { - /* - * Add a message saying a glyph has been moved to the - * unencoded area. - */ - sprintf(nbuf, ACMSG12, p->glyph_enc, p->glyph_name); - _bdf_add_acmsg(font, nbuf, strlen(nbuf)); - p->glyph_enc = -1; - font->modified = 1; - } else - _bdf_set_glyph_modified(p->have, p->glyph_enc); - } - - if (p->glyph_enc >= 0) { - /* - * Make sure there are enough glyphs allocated in case the - * number of characters happen to be wrong. - */ - if (font->glyphs_used == font->glyphs_size) { - font->glyphs = (bdf_glyph_t *) - realloc((char *) font->glyphs, - sizeof(bdf_glyph_t) * (font->glyphs_size + 64)); - (void) memset((char *)(font->glyphs + font->glyphs_size), - 0, sizeof(bdf_glyph_t) << 6); - font->glyphs_size += 64; - } - - glyph = font->glyphs + font->glyphs_used++; - glyph->name = p->glyph_name; - glyph->encoding = p->glyph_enc; - - /* - * Reset the initial glyph info. - */ - p->glyph_name = 0; - } else { - /* - * Unencoded glyph. Check to see if it should be added or not. - */ - if (p->opts->keep_unencoded != 0) { - /* - * Allocate the next unencoded glyph. - */ - if (font->unencoded_used == font->unencoded_size) { - if (font->unencoded_size == 0) - font->unencoded = (bdf_glyph_t *) - malloc(sizeof(bdf_glyph_t) << 2); - else - font->unencoded = (bdf_glyph_t *) - realloc((char *) font->unencoded, - sizeof(bdf_glyph_t) * - (font->unencoded_size + 4)); - font->unencoded_size += 4; - } - - glyph = font->unencoded + font->unencoded_used; - glyph->name = p->glyph_name; - glyph->encoding = font->unencoded_used++; - } else - /* - * Free up the glyph name if the unencoded shouldn't be - * kept. - */ - free(p->glyph_name); - - p->glyph_name = 0; - } - - /* - * Clear the flags that might be added when width and height are - * checked for consistency. - */ - p->flags &= ~(_BDF_GLYPH_WIDTH_CHECK | _BDF_GLYPH_HEIGHT_CHECK); - - p->flags |= _BDF_ENCODING; - return 0; - } - - /* - * Point at the glyph being constructed. - */ - if (p->glyph_enc == -1) - glyph = font->unencoded + (font->unencoded_used - 1); - else - glyph = font->glyphs + (font->glyphs_used - 1); - - /* - * Check to see if a bitmap is being constructed. - */ - if (p->flags & _BDF_BITMAP) { - /* - * If there are more rows than are specified in the glyph metrics, - * ignore the remaining lines. - */ - if (p->row >= glyph->bbx.height) { - if (!(p->flags & _BDF_GLYPH_HEIGHT_CHECK)) { - sprintf(nbuf, ACMSG13, glyph->encoding); - _bdf_add_acmsg(font, nbuf, strlen(nbuf)); - p->flags |= _BDF_GLYPH_HEIGHT_CHECK; - font->modified = 1; - } - return 0; - } - - /* - * Only collect the number of nibbles indicated by the glyph metrics. - * If there are more columns, they are simply ignored. - */ - nibbles = p->bpr << 1; - bp = glyph->bitmap + (p->row * p->bpr); - for (i = 0, *bp = 0; i < nibbles; i++) { - c = line[i]; - *bp = (*bp << 4) + a2i[c]; - if (i + 1 < nibbles && (i & 1)) - *++bp = 0; - } - - /* - * If any line has extra columns, indicate they have been removed. - */ - if ((line[nibbles] == '0' || a2i[(int) line[nibbles]] != 0) && - !(p->flags & _BDF_GLYPH_WIDTH_CHECK)) { - sprintf(nbuf, ACMSG14, glyph->encoding); - _bdf_add_acmsg(font, nbuf, strlen(nbuf)); - p->flags |= _BDF_GLYPH_WIDTH_CHECK; - font->modified = 1; - } - - p->row++; - return 0; - } - - /* - * Expect the SWIDTH (scalable width) field next. - */ - if (memcmp(line, "SWIDTH", 6) == 0) { - if (!(p->flags & _BDF_ENCODING)) { - /* - * Missing ENCODING field. - */ - sprintf(nbuf, ERRMSG1, lineno, "ENCODING"); - _bdf_add_acmsg(font, nbuf, strlen(nbuf)); - return BDF_MISSING_ENCODING; - } - _bdf_split(" +", line, linelen, &p->list); - glyph->swidth = _bdf_atoul(p->list.field[1], 0, 10); - p->flags |= _BDF_SWIDTH; - return 0; - } - - /* - * Expect the DWIDTH (scalable width) field next. - */ - if (memcmp(line, "DWIDTH", 6) == 0) { - _bdf_split(" +", line, linelen, &p->list); - glyph->dwidth = _bdf_atoul(p->list.field[1], 0, 10); - - if (!(p->flags & _BDF_SWIDTH)) { - /* - * Missing SWIDTH field. Add an auto correction message and set - * the scalable width from the device width. - */ - sprintf(nbuf, ACMSG9, lineno); - _bdf_add_acmsg(font, nbuf, strlen(nbuf)); - ps = (double) font->point_size; - rx = (double) font->resolution_x; - dw = (double) glyph->dwidth; - glyph->swidth = (unsigned short)((dw * 72000.0) / (ps * rx)); - } - - p->flags |= _BDF_DWIDTH; - return 0; - } - - /* - * Expect the BBX field next. - */ - if (memcmp(line, "BBX", 3) == 0) { - _bdf_split(" +", line, linelen, &p->list); - glyph->bbx.width = _bdf_atos(p->list.field[1], 0, 10); - glyph->bbx.height = _bdf_atos(p->list.field[2], 0, 10); - glyph->bbx.x_offset = _bdf_atos(p->list.field[3], 0, 10); - glyph->bbx.y_offset = _bdf_atos(p->list.field[4], 0, 10); - - /* - * Generate the ascent and descent of the character. - */ - glyph->bbx.ascent = glyph->bbx.height + glyph->bbx.y_offset; - glyph->bbx.descent = -glyph->bbx.y_offset; - - /* - * Determine the overall font bounding box as the characters are - * loaded so corrections can be done later if indicated. - */ - p->maxas = MAX(glyph->bbx.ascent, p->maxas); - p->maxds = MAX(glyph->bbx.descent, p->maxds); - p->rbearing = glyph->bbx.width + glyph->bbx.x_offset; - p->maxrb = MAX(p->rbearing, p->maxrb); - p->minlb = MIN(glyph->bbx.x_offset, p->minlb); - p->maxlb = MAX(glyph->bbx.x_offset, p->maxlb); - - if (!(p->flags & _BDF_DWIDTH)) { - /* - * Missing DWIDTH field. Add an auto correction message and set - * the device width to the glyph width. - */ - sprintf(nbuf, ACMSG10, lineno); - _bdf_add_acmsg(font, nbuf, strlen(nbuf)); - glyph->dwidth = glyph->bbx.width; - } - - /* - * If the BDF_CORRECT_METRICS flag is set, then adjust the SWIDTH - * value if necessary. - */ - if (p->opts->correct_metrics != 0) { - /* - * Determine the point size of the glyph. - */ - ps = (double) font->point_size; - rx = (double) font->resolution_x; - dw = (double) glyph->dwidth; - sw = (unsigned short)((dw * 72000.0) / (ps * rx)); - - if (sw != glyph->swidth) { - glyph->swidth = (unsigned short) sw; - if (p->glyph_enc == -1) - _bdf_set_glyph_modified(font->umod, - font->unencoded_used - 1); - else - _bdf_set_glyph_modified(font->nmod, glyph->encoding); - p->flags |= _BDF_SWIDTH_ADJ; - font->modified = 1; - } - } - p->flags |= _BDF_BBX; - return 0; - } - - /* - * And finally, gather up the bitmap. - */ - if (memcmp(line, "BITMAP", 6) == 0) { - if (!(p->flags & _BDF_BBX)) { - /* - * Missing BBX field. - */ - sprintf(nbuf, ERRMSG1, lineno, "BBX"); - _bdf_add_acmsg(font, nbuf, strlen(nbuf)); - return BDF_MISSING_BBX; - } - /* - * Allocate enough space for the bitmap. - */ - p->bpr = ((glyph->bbx.width * p->font->bpp) + 7) >> 3; - glyph->bytes = p->bpr * glyph->bbx.height; - glyph->bitmap = (unsigned char *) malloc(glyph->bytes); - p->row = 0; - p->flags |= _BDF_BITMAP; - return 0; - } - - return BDF_INVALID_LINE; -} - -/* - * Load the font properties. - */ -static int -#ifdef __STDC__ -_bdf_parse_properties(char *line, unsigned long linelen, unsigned long lineno, - void *call_data, void *client_data) -#else -_bdf_parse_properties(line, linelen, lineno, call_data, client_data) -char *line; -unsigned long linelen, lineno; -void *call_data, *client_data; -#endif -{ - unsigned long vlen; - _bdf_line_func_t *next; - _bdf_parse_t *p; - char *name, *value, nbuf[128]; - - next = (_bdf_line_func_t *) call_data; - p = (_bdf_parse_t *) client_data; - - /* - * Check for the end of the properties. - */ - if (memcmp(line, "ENDPROPERTIES", 13) == 0) { - /* - * If the FONT_ASCENT or FONT_DESCENT properties have not been - * encountered yet, then make sure they are added as properties and - * make sure they are set from the font bounding box info. - * - * This is *always* done regardless of the options, because X11 - * requires these two fields to compile fonts. - */ - if (bdf_get_font_property(p->font, "FONT_ASCENT") == 0) { - p->font->font_ascent = p->font->bbx.ascent; - sprintf(nbuf, "%hd", p->font->bbx.ascent); - _bdf_add_property(p->font, "FONT_ASCENT", nbuf); - sprintf(nbuf, ACMSG1, p->font->bbx.ascent); - _bdf_add_acmsg(p->font, nbuf, strlen(nbuf)); - p->font->modified = 1; - } - if (bdf_get_font_property(p->font, "FONT_DESCENT") == 0) { - p->font->font_descent = p->font->bbx.descent; - sprintf(nbuf, "%hd", p->font->bbx.descent); - _bdf_add_property(p->font, "FONT_DESCENT", nbuf); - sprintf(nbuf, ACMSG2, p->font->bbx.descent); - _bdf_add_acmsg(p->font, nbuf, strlen(nbuf)); - p->font->modified = 1; - } - p->flags &= ~_BDF_PROPS; - *next = _bdf_parse_glyphs; - return 0; - } - - /* - * Ignore the _XFREE86_GLYPH_RANGES properties. - */ - if (memcmp(line, "_XFREE86_GLYPH_RANGES", 21) == 0) - return 0; - - /* - * Handle COMMENT fields and properties in a special way to preserve - * the spacing. - */ - if (memcmp(line, "COMMENT", 7) == 0) { - name = value = line; - value += 7; - if (*value) - *value++ = 0; - _bdf_add_property(p->font, name, value); - } else if (_bdf_is_atom(line, linelen, &name, &value)) - _bdf_add_property(p->font, name, value); - else { - _bdf_split(" +", line, linelen, &p->list); - name = p->list.field[0]; - _bdf_shift(1, &p->list); - value = _bdf_join(' ', &vlen, &p->list); - _bdf_add_property(p->font, name, value); - } - - return 0; -} - -/* - * Load the font header. - */ -static int -#ifdef __STDC__ -_bdf_parse_start(char *line, unsigned long linelen, unsigned long lineno, - void *call_data, void *client_data) -#else -_bdf_parse_start(line, linelen, lineno, call_data, client_data) -char *line; -unsigned long linelen, lineno; -void *call_data, *client_data; -#endif -{ - unsigned long slen; - _bdf_line_func_t *next; - _bdf_parse_t *p; - bdf_font_t *font; - char *s, nbuf[128]; - - next = (_bdf_line_func_t *) call_data; - p = (_bdf_parse_t *) client_data; - - /* - * Check for a comment. This is done to handle those fonts that have - * comments before the STARTFONT line for some reason. - */ - if (memcmp(line, "COMMENT", 7) == 0) { - if (p->opts->keep_comments != 0 && p->font != 0) { - linelen -= 7; - s = line + 7; - if (*s != 0) { - s++; - linelen--; - } - _bdf_add_comment(p->font, s, linelen); - } - return 0; - } - - if (!(p->flags & _BDF_START)) { - if (memcmp(line, "STARTFONT", 9) != 0) - /* - * No STARTFONT field is a good indication of a problem. - */ - return BDF_MISSING_START; - p->flags = _BDF_START; - p->font = font = (bdf_font_t *) calloc(1, sizeof(bdf_font_t)); - p->font->internal = (void *) malloc(sizeof(hashtable)); - hash_init((hashtable *) p->font->internal); - p->font->spacing = p->opts->font_spacing; - p->font->default_glyph = -1; - return 0; - } - - /* - * Check for the start of the properties. - */ - if (memcmp(line, "STARTPROPERTIES", 15) == 0) { - _bdf_split(" +", line, linelen, &p->list); - p->cnt = p->font->props_size = _bdf_atoul(p->list.field[1], 0, 10); - p->font->props = (bdf_property_t *) - malloc(sizeof(bdf_property_t) * p->cnt); - p->flags |= _BDF_PROPS; - *next = _bdf_parse_properties; - return 0; - } - - /* - * Check for the FONTBOUNDINGBOX field. - */ - if (memcmp(line, "FONTBOUNDINGBOX", 15) == 0) { - if (!(p->flags & _BDF_SIZE)) { - /* - * Missing the SIZE field. - */ - sprintf(nbuf, ERRMSG1, lineno, "SIZE"); - _bdf_add_acmsg(p->font, nbuf, strlen(nbuf)); - return BDF_MISSING_SIZE; - } - _bdf_split(" +", line, linelen, &p->list); - p->font->bbx.width = _bdf_atos(p->list.field[1], 0, 10); - p->font->bbx.height = _bdf_atos(p->list.field[2], 0, 10); - p->font->bbx.x_offset = _bdf_atos(p->list.field[3], 0, 10); - p->font->bbx.y_offset = _bdf_atos(p->list.field[4], 0, 10); - p->font->bbx.ascent = p->font->bbx.height + p->font->bbx.y_offset; - p->font->bbx.descent = -p->font->bbx.y_offset; - p->flags |= _BDF_FONT_BBX; - return 0; - } - - /* - * The next thing to check for is the FONT field. - */ - if (memcmp(line, "FONT", 4) == 0) { - _bdf_split(" +", line, linelen, &p->list); - _bdf_shift(1, &p->list); - s = _bdf_join(' ', &slen, &p->list); - p->font->name = (char *) malloc(slen + 1); - (void) memcpy(p->font->name, s, slen + 1); - /* - * If the font name is an XLFD name, set the spacing to the one in the - * font name. If there is no spacing fall back on the default. - */ - _bdf_set_default_spacing(p->font, p->opts); - p->flags |= _BDF_FONT_NAME; - return 0; - } - - /* - * Check for the SIZE field. - */ - if (memcmp(line, "SIZE", 4) == 0) { - if (!(p->flags & _BDF_FONT_NAME)) { - /* - * Missing the FONT field. - */ - sprintf(nbuf, ERRMSG1, lineno, "FONT"); - _bdf_add_acmsg(p->font, nbuf, strlen(nbuf)); - return BDF_MISSING_FONTNAME; - } - _bdf_split(" +", line, linelen, &p->list); - p->font->point_size = _bdf_atoul(p->list.field[1], 0, 10); - p->font->resolution_x = _bdf_atoul(p->list.field[2], 0, 10); - p->font->resolution_y = _bdf_atoul(p->list.field[3], 0, 10); - - /* - * Check for the bits per pixel field. - */ - if (p->list.used == 5) { - p->font->bpp = _bdf_atos(p->list.field[4], 0, 10); - if (p->font->bpp > 1 && (p->font->bpp & 1)) { - /* - * Move up to the next bits per pixel value if an odd number - * is encountered. - */ - p->font->bpp++; - if (p->font->bpp <= 4) { - sprintf(nbuf, ACMSG11, p->font->bpp); - _bdf_add_acmsg(p->font, nbuf, strlen(nbuf)); - } - } - if (p->font->bpp > 4) { - sprintf(nbuf, ACMSG11, p->font->bpp); - _bdf_add_acmsg(p->font, nbuf, strlen(nbuf)); - p->font->bpp = 4; - } - } else - p->font->bpp = 1; - - p->flags |= _BDF_SIZE; - return 0; - } - - return BDF_INVALID_LINE; -} - -/************************************************************************** - * - * API. - * - **************************************************************************/ - -void -#ifdef __STDC__ -bdf_setup(void) -#else -bdf_setup() -#endif -{ - unsigned long i; - bdf_property_t *prop; - - hash_init(&proptbl); - for (i = 0, prop = _bdf_properties; i < _num_bdf_properties; i++, prop++) - hash_insert(prop->name, (void *) i, &proptbl); -} - -void -#ifdef __STDC__ -bdf_cleanup(void) -#else -bdf_cleanup() -#endif -{ - unsigned long i; - bdf_property_t *prop; - - hash_free(&proptbl); - - /* - * Free up the user defined properties. - */ - for (prop = user_props, i = 0; i < nuser_props; i++, prop++) { - free(prop->name); - if (prop->format == BDF_ATOM && prop->value.atom != 0) - free(prop->value.atom); - } - if (nuser_props > 0) - free((char *) user_props); - - _bdf_glyph_name_cleanup(); -} - -bdf_font_t * -#ifdef __STDC__ -bdf_load_font(FILE *in, bdf_options_t *opts, bdf_callback_t callback, - void *data) -#else -bdf_load_font(in, opts, callback, data) -FILE *in; -bdf_options_t *opts; -bdf_callback_t callback; -void *data; -#endif -{ - int n; - unsigned long lineno; - char msgbuf[128]; - _bdf_parse_t p; - - (void) memset((char *) &p, 0, sizeof(_bdf_parse_t)); - p.opts = (opts != 0) ? opts : &_bdf_opts; - p.minlb = 32767; - p.callback = callback; - p.client_data = data; - n = _bdf_readlines(fileno(in), _bdf_parse_start, (void *) & p, &lineno); - - if (p.font != 0) { - /* - * If the font is not proportional, set the fonts monowidth - * field to the width of the font bounding box. - */ - if (p.font->spacing != BDF_PROPORTIONAL) - p.font->monowidth = p.font->bbx.width; - - /* - * If the number of glyphs loaded is not that of the original count, - * indicate the difference. - */ - if (p.cnt != p.font->glyphs_used + p.font->unencoded_used) { - sprintf(msgbuf, ACMSG15, p.cnt, - p.font->glyphs_used + p.font->unencoded_used); - _bdf_add_acmsg(p.font, msgbuf, strlen(msgbuf)); - p.font->modified = 1; - } - - /* - * Once the font has been loaded, adjust the overall font metrics if - * necessary. - */ - if (p.opts->correct_metrics != 0 && - (p.font->glyphs_used > 0 || p.font->unencoded_used > 0)) { - if (p.maxrb - p.minlb != p.font->bbx.width) { - sprintf(msgbuf, ACMSG3, p.font->bbx.width, p.maxrb - p.minlb); - _bdf_add_acmsg(p.font, msgbuf, strlen(msgbuf)); - p.font->bbx.width = p.maxrb - p.minlb; - p.font->modified = 1; - } - if (p.font->bbx.x_offset != p.minlb) { - sprintf(msgbuf, ACMSG4, p.font->bbx.x_offset, p.minlb); - _bdf_add_acmsg(p.font, msgbuf, strlen(msgbuf)); - p.font->bbx.x_offset = p.minlb; - p.font->modified = 1; - } - if (p.font->bbx.ascent != p.maxas) { - sprintf(msgbuf, ACMSG5, p.font->bbx.ascent, p.maxas); - _bdf_add_acmsg(p.font, msgbuf, strlen(msgbuf)); - p.font->bbx.ascent = p.maxas; - p.font->modified = 1; - } - if (p.font->bbx.descent != p.maxds) { - sprintf(msgbuf, ACMSG6, p.font->bbx.descent, p.maxds); - _bdf_add_acmsg(p.font, msgbuf, strlen(msgbuf)); - p.font->bbx.descent = p.maxds; - p.font->bbx.y_offset = -p.maxds; - p.font->modified = 1; - } - if (p.maxas + p.maxds != p.font->bbx.height) { - sprintf(msgbuf, ACMSG7, p.font->bbx.height, p.maxas + p.maxds); - _bdf_add_acmsg(p.font, msgbuf, strlen(msgbuf)); - } - p.font->bbx.height = p.maxas + p.maxds; - - if (p.flags & _BDF_SWIDTH_ADJ) - _bdf_add_acmsg(p.font, ACMSG8, strlen(ACMSG8)); - } - } - - /* - * Last, if an error happened during loading, handle the messages. - */ - if (n < 0 && callback != 0) { - /* - * An error was returned. Alert the client. - */ - p.cb.reason = BDF_ERROR; - p.cb.errlineno = lineno; - (*callback)(&p.cb, data); - } else if (p.flags & _BDF_START) { - if (p.font != 0) { - /* - * The ENDFONT field was never reached or did not exist. - */ - if (!(p.flags & _BDF_GLYPHS)) - /* - * Error happened while parsing header. - */ - sprintf(msgbuf, ERRMSG2, lineno); - else - /* - * Error happened when parsing glyphs. - */ - sprintf(msgbuf, ERRMSG3, lineno); - - _bdf_add_acmsg(p.font, msgbuf, strlen(msgbuf)); - } - - if (callback != 0) { - p.cb.reason = BDF_ERROR; - p.cb.errlineno = lineno; - (*callback)(&p.cb, data); - } - } else if (callback != 0) { - /* - * This forces the progress bar to always finish. - */ - p.cb.current = p.cb.total; - (*p.callback)(&p.cb, p.client_data); - } - - /* - * Free up the list used during the parsing. - */ - if (p.list.size > 0) - free((char *) p.list.field); - - if (p.font != 0) { - /* - * Make sure the comments are NULL terminated if they exist. - */ - if (p.font->comments_len > 0) { - p.font->comments = (char *) realloc(p.font->comments, - p.font->comments_len + 1); - p.font->comments[p.font->comments_len] = 0; - } - - /* - * Make sure the auto-correct messages are NULL terminated if they - * exist. - */ - if (p.font->acmsgs_len > 0) { - p.font->acmsgs = (char *) realloc(p.font->acmsgs, - p.font->acmsgs_len + 1); - p.font->acmsgs[p.font->acmsgs_len] = 0; - } - } - - return p.font; -} - -#ifdef HAVE_HBF -static int -#ifdef __STDC__ -_bdf_parse_hbf_header(char *line, unsigned long linelen, unsigned long lineno, - void *call_data, void *client_data) -#else -_bdf_parse_hbf_header(line, linelen, lineno, call_data, client_data) -char *line; -unsigned long linelen, lineno; -void *call_data, *client_data; -#endif -{ - unsigned long vlen; - char *name, *value; - _bdf_parse_t *p; - _bdf_line_func_t *next; - char nbuf[24]; - - next = (_bdf_line_func_t *) call_data; - p = (_bdf_parse_t *) client_data; - - /* - * Check for comments. - */ - if (memcmp(line, "COMMENT", 7) == 0) { - if (p->opts->keep_comments != 0 && p->font != 0) { - name = line; - value = name + 7; - vlen = linelen - 7; - if (*value) { - *value++ = 0; - vlen--; - } - /* - * If the properties are being parsed, add the comment as a - * property. Otherwise, simply add the comment in the normal - * fashion. - */ - if (p->flags & _BDF_PROPS) - _bdf_add_property(p->font, name, value); - else - _bdf_add_comment(p->font, value, vlen); - } - return 0; - } - - if (!(p->flags & _BDF_START)) { - if (memcmp(line, "HBF_START_FONT", 14) != 0) - return -1; - p->flags = _BDF_START; - p->font = (bdf_font_t *) calloc(1, sizeof(bdf_font_t)); - /* - * HBF fonts are always assumed to be 1 bit per pixel. - */ - p->font->bpp = 1; - p->font->internal = (void *) malloc(sizeof(hashtable)); - hash_init((hashtable *) p->font->internal); - p->font->hbf = 1; - p->font->spacing = p->opts->font_spacing; - p->font->default_glyph = -1; - return 0; - } - - /* - * Check for the HBF_END_FONT field. - */ - if (memcmp(line, "HBF_END_FONT", 12) == 0) - /* - * Need to perform some checks here to see whether some fields are - * missing or not. - */ - return 0; - - /* - * Check for HBF keywords which will be added as comments. These should - * never occur in the properties list. Assume they won't. - */ - if (memcmp(line, "HBF_", 4) == 0) { - if (p->opts->keep_comments != 0) - _bdf_add_comment(p->font, line, linelen); - return 0; - } - - if (!(p->flags & _BDF_PROPS)) { - /* - * Check for the start of the properties. - */ - if (memcmp(line, "STARTPROPERTIES", 15) == 0) { - _bdf_split(" +", line, linelen, &p->list); - p->cnt = p->font->props_size = _bdf_atoul(p->list.field[1], 0, 10); - p->font->props = (bdf_property_t *) - malloc(sizeof(bdf_property_t) * p->cnt); - p->flags |= _BDF_PROPS; - return 0; - } - - /* - * Check for the CHARS field. - */ - if (memcmp(line, "CHARS", 5) == 0) { - _bdf_split(" +", line, linelen, &p->list); - p->cnt = p->font->glyphs_size = - _bdf_atoul(p->list.field[1], 0, 10); - p->font->glyphs = (bdf_glyph_t *) - malloc(sizeof(bdf_glyph_t) * p->cnt); - return 0; - } - - /* - * Check for the FONTBOUNDINGBOX field. - */ - if (memcmp(line, "FONTBOUNDINGBOX", 15) == 0) { - if (!(p->flags & (_BDF_START | _BDF_FONT_NAME | _BDF_SIZE))) - return -1; - _bdf_split(" +", line, linelen, &p->list); - p->font->bbx.width = _bdf_atos(p->list.field[1], 0, 10); - p->font->bbx.height = _bdf_atos(p->list.field[2], 0, 10); - p->font->bbx.x_offset = _bdf_atos(p->list.field[3], 0, 10); - p->font->bbx.y_offset = _bdf_atos(p->list.field[4], 0, 10); - p->font->bbx.ascent = p->font->bbx.height + p->font->bbx.y_offset; - p->font->bbx.descent = -p->font->bbx.y_offset; - p->flags |= _BDF_FONT_BBX; - return 0; - } - - /* - * The next thing to check for is the FONT field. - */ - if (memcmp(line, "FONT", 4) == 0) { - if (!(p->flags & _BDF_START)) - return -1; - _bdf_split(" +", line, linelen, &p->list); - _bdf_shift(1, &p->list); - value = _bdf_join(' ', &vlen, &p->list); - p->font->name = (char *) malloc(vlen + 1); - (void) memcpy(p->font->name, value, vlen + 1); - /* - * If the font name is an XLFD name, set the spacing to the one in - * the font name. If there is no spacing fall back on the - * default. - */ - _bdf_set_default_spacing(p->font, p->opts); - p->flags |= _BDF_FONT_NAME; - return 0; - } - - /* - * Check for the SIZE field. - */ - if (memcmp(line, "SIZE", 4) == 0) { - if (!(p->flags & (_BDF_START | _BDF_FONT_NAME))) - return -1; - _bdf_split(" +", line, linelen, &p->list); - p->font->point_size = _bdf_atoul(p->list.field[1], 0, 10); - p->font->resolution_x = _bdf_atoul(p->list.field[2], 0, 10); - p->font->resolution_y = _bdf_atoul(p->list.field[3], 0, 10); - p->flags |= _BDF_SIZE; - return 0; - } - } else { - /* - * Check for the end of the properties. - */ - if (memcmp(line, "ENDPROPERTIES", 13) == 0) { - /* - * If the FONT_ASCENT or FONT_DESCENT properties have not been - * encountered yet, then make sure they are added as properties and - * make sure they are set from the font bounding box info. - * - * This is *always* done regardless of the options, because X11 - * requires these two fields to compile fonts. - */ - if (bdf_get_font_property(p->font, "FONT_ASCENT") == 0) { - p->font->font_ascent = p->font->bbx.ascent; - sprintf(nbuf, "%hd", p->font->bbx.ascent); - _bdf_add_property(p->font, "FONT_ASCENT", nbuf); - sprintf(nbuf, ACMSG1, p->font->bbx.ascent); - _bdf_add_acmsg(p->font, nbuf, strlen(nbuf)); - p->font->modified = 1; - } - if (bdf_get_font_property(p->font, "FONT_DESCENT") == 0) { - p->font->font_descent = p->font->bbx.descent; - sprintf(nbuf, "%hd", p->font->bbx.descent); - _bdf_add_property(p->font, "FONT_DESCENT", nbuf); - sprintf(nbuf, ACMSG2, p->font->bbx.descent); - _bdf_add_acmsg(p->font, nbuf, strlen(nbuf)); - p->font->modified = 1; - } - p->flags &= ~_BDF_PROPS; - return 0; - } - - /* - * Handle the next thing in the usual property fashion. - */ - if (_bdf_is_atom(line, linelen, &name, &value)) - _bdf_add_property(p->font, name, value); - else { - _bdf_split(" +", line, linelen, &p->list); - name = p->list.field[0]; - _bdf_shift(1, &p->list); - value = _bdf_join(' ', &vlen, &p->list); - _bdf_add_property(p->font, name, value); - } - return 0; - } - - /* - * Anything else is an error. - */ - return -1; -} - -#ifdef __STDC__ -#define CONST const -#else -#define CONST -#endif - -static void -#ifdef __STDC__ -_bdf_add_hbf_glyph(HBF *hbf, unsigned int code, void *callback_data) -#else -_bdf_add_hbf_glyph(hbf, code, callback_data) -HBF *hbf; -unsigned int code; -void *callback_data; -#endif -{ - CONST unsigned char *bmap; - unsigned long n; - bdf_glyph_t *gp; - bdf_font_t *font; - _bdf_parse_t *p; - HBF_BBOX *fbbx; - double ps, rx, dw; - char nbuf[24]; - - /* - * Attempt to get the bitmap. - */ - if ((bmap = hbfGetBitmap(hbf, code)) == 0) - /* - * Need some sort of error handling here. - */ - return; - - p = (_bdf_parse_t *) callback_data; - - fbbx = hbfFontBBox(hbf); - - font = p->font; - - /* - * Check to make sure there is enough space to hold this glyph. If not, - * allocate 10 more just in case. - */ - if (font->glyphs_used == font->glyphs_size) { - if (font->glyphs_size == 0) - font->glyphs = (bdf_glyph_t *) malloc(sizeof(bdf_glyph_t) * 16); - else - font->glyphs = (bdf_glyph_t *) - realloc((char *) font->glyphs, - sizeof(bdf_glyph_t) * (font->glyphs_used + 16)); - gp = font->glyphs + font->glyphs_size; - (void) memset((char *) gp, 0, sizeof(bdf_glyph_t) * 16); - font->glyphs_size += 16; - } - - gp = font->glyphs + font->glyphs_used++; - - /* - * Set the glyph name. - */ - sprintf(nbuf, "char%d", code); - n = (unsigned long) strlen(nbuf); - gp->name = (char *) malloc(n + 1); - (void) memcpy(gp->name, nbuf, n + 1); - - /* - * Set encoding. - */ - gp->encoding = (long) code; - - /* - * Set the device width. - */ - gp->dwidth = (unsigned short) fbbx->hbf_width; - - /* - * Set the scalable width. - */ - ps = (double) font->point_size; - rx = (double) font->resolution_x; - dw = (double) gp->dwidth; - gp->swidth = (unsigned short)((dw * 72000.0) / (ps * rx)); - - /* - * Set the glyph bounding box. - */ - gp->bbx.width = fbbx->hbf_width; - gp->bbx.height = fbbx->hbf_height; - gp->bbx.x_offset = fbbx->hbf_xDisplacement; - gp->bbx.y_offset = fbbx->hbf_yDisplacement; - gp->bbx.ascent = gp->bbx.height + gp->bbx.y_offset; - gp->bbx.descent = -gp->bbx.y_offset; - - /* - * Add the bitmap by making a copy. Assumes the font bbx is OK for - * determining the number of bytes needed for the glyph bitmap. - */ - gp->bytes = ((gp->bbx.width + 7) >> 3) * gp->bbx.height; - gp->bitmap = (unsigned char *) malloc(gp->bytes); - (void) memcpy((char *) gp->bitmap, (char *) bmap, gp->bytes); - - /* - * Call the callback if it was provided. - */ - if (p->callback != 0) { - p->cb.reason = BDF_LOADING; - p->cb.total = font->glyphs_size; - p->cb.current = font->glyphs_used; - (*p->callback)(&p->cb, p->client_data); - } -} - -bdf_font_t * -#ifdef __STDC__ -bdf_load_hbf_font(char *filename, bdf_options_t *opts, bdf_callback_t callback, - void *data) -#else -bdf_load_hbf_font(filename, opts, callback, data) -char *filename; -bdf_options_t *opts; -bdf_callback_t callback; -void *data; -#endif -{ - int n, diff; - unsigned long lineno; - FILE *in; - HBF *hbf; - bdf_property_t *pp; - char *name; - _bdf_parse_t p; - - if ((hbf = hbfOpen(filename)) == 0) - return 0; - - if ((in = fopen(hbfFileName(hbf), "r")) == 0) { - hbfClose(hbf); - return 0; - } - - /* - * Parse the HBF header for properties and other things. - */ - (void) memset((char *) &p, 0, sizeof(_bdf_parse_t)); - p.opts = (opts != 0) ? opts : &_bdf_opts; - p.minlb = 32767; - p.callback = callback; - p.client_data = data; - - n = _bdf_readlines(fileno(in), _bdf_parse_hbf_header, (void *) & p, - &lineno); - - fclose(in); - - /* - * Determine what spacing the font has so the monowidth field can be set - * if necessary. - */ - if ((pp = bdf_get_font_property(p.font, "SPACING")) != 0) { - switch (pp->value.atom[0]) { - case 'p': - case 'P': - p.font->spacing = BDF_PROPORTIONAL; - break; - case 'm': - case 'M': - p.font->spacing = BDF_MONOWIDTH; - break; - case 'c': - case 'C': - p.font->spacing = BDF_CHARCELL; - break; - } - } - - /* - * Set the monowidth field if necessary. - */ - if (p.font->spacing != BDF_PROPORTIONAL) - p.font->monowidth = p.font->bbx.width; - - /* - * Before loading the glyphs, check to see if any glyph structures have - * been added. If not, check the HBF font for the number of characters. - * Dynamically increasing glyph storage causes memory fragmentation on - * some machines and crashes. This takes care of the cases where the HBF - * file does not provide a "CHARS n" line. - */ - if (p.font->glyphs_size < hbfChars(hbf)) { - if (p.font->glyphs_size == 0) - p.font->glyphs = (bdf_glyph_t *) - malloc(sizeof(bdf_glyph_t) * hbfChars(hbf)); - else - p.font->glyphs = (bdf_glyph_t *) - realloc((char *) p.font->glyphs, - sizeof(bdf_glyph_t) * hbfChars(hbf)); - diff = hbfChars(hbf) - p.font->glyphs_size; - (void) memset((char *)(p.font->glyphs + p.font->glyphs_size), 0, - diff); - p.font->glyphs_size = hbfChars(hbf); - } - - /* - * Call the callback initially to set things up. - */ - if (p.callback != 0) { - p.cb.reason = BDF_LOAD_START; - p.cb.total = p.font->glyphs_size; - p.cb.current = 0; - (*p.callback)(&p.cb, p.client_data); - } - - /* - * Now load the glyphs. - */ - hbfForEach(hbf, _bdf_add_hbf_glyph, (void *) &p); - - /* - * Close the HBF font. - */ - hbfClose(hbf); - - /* - * Sort the glyphs by encoding. - */ - qsort((char *) p.font->glyphs, p.font->glyphs_used, sizeof(bdf_glyph_t), - by_encoding); - - /* - * After loading the HBF header, create an XLFD name. If the XLFD name - * cannot be made then preserve the name found in the HBF file. - */ - if ((name = bdf_make_xlfd_name(p.font, "HBF", "Unknown")) != 0) { - if (p.font->name != 0) - /* - * If a name already exists in the font, free it up. - */ - free(p.font->name); - - /* - * Replace the old name with the XLFD name. - */ - p.font->name = name; - } - - /* - * Mark the font as being modified and generate a message that says - * something about the font being converted from HBF format. - */ - p.font->modified = 1; - _bdf_add_acmsg(p.font, "Font converted from HBF to BDF.", 31); - - return p.font; -} -#endif /* HAVE_HBF */ - -/* - * Crop the glyph bitmap to the minimum rectangle needed to hold the bits that - * are set. Adjust the metrics based on the provided bounding box. - */ -static void -#ifdef __STDC__ -_bdf_crop_glyph(bdf_font_t *font, bdf_glyph_t *glyph) -#else -_bdf_crop_glyph(font, glyph) -bdf_font_t *font; -bdf_glyph_t *glyph; -#endif -{ - int byte; - unsigned short x, y, bpr, nbpr, col, colx, si, di; - unsigned short minx, maxx, miny, maxy; - unsigned long bytes; - unsigned char *bmap, *masks; - bdf_bbx_t nbbx; - - if (glyph == 0) - return; - - (void) memcpy((char *) &nbbx, (char *) &glyph->bbx, sizeof(bdf_bbx_t)); - - bpr = ((glyph->bbx.width * font->bpp) + 7) >> 3; - - maxx = maxy = 0; - minx = miny = 32767; - - masks = 0; - switch (font->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - for (y = 0; y < glyph->bbx.height; y++) { - for (col = x = 0; x < glyph->bbx.width; x++, col += font->bpp) { - si = (col & 7) / font->bpp; - if (glyph->bitmap[(y * bpr) + (col >> 3)] & masks[si]) { - minx = MIN(minx, x); - maxx = MAX(maxx, x); - miny = MIN(miny, y); - maxy = MAX(maxy, y); - } - } - } - - /* - * Handle an empty bitmap as a special case. - */ - if (minx == 32767) { - if (glyph->bytes > 0) - free((char *) glyph->bitmap); - glyph->bytes = 0; - (void) memset((char *) &glyph->bbx, 0, sizeof(bdf_bbx_t)); - return; - } - - /* - * Increment the max points so width and height calculations won't go - * wrong. - */ - maxx++; - maxy++; - - if (minx > 0) - nbbx.x_offset += minx; - if (maxx - minx != nbbx.width) - nbbx.width = maxx - minx; - - if (miny > 0) - nbbx.ascent -= miny; - if (maxy - miny != nbbx.height) - nbbx.height = maxy - miny; - nbbx.descent = nbbx.height - nbbx.ascent; - nbbx.y_offset = -nbbx.descent; - - nbpr = ((nbbx.width * font->bpp) + 7) >> 3; - - /* - * If nothing changed, then the glyph is already contained in the - * minimum rectangle. - */ - if (memcmp((char *) &nbbx, (char *) &glyph->bbx, - sizeof(bdf_bbx_t)) == 0 || - (nbpr == bpr && nbbx.height == glyph->bbx.height)) - return; - - /* - * The metrics changed, so a new bitmap is needed. - */ - bytes = nbpr * nbbx.height; - bmap = (unsigned char *) malloc(bytes); - (void) memset((char *) bmap, 0, bytes); - - colx = minx * font->bpp; - for (y = miny; y < maxy; y++) { - for (col = x = minx; x < maxx; x++, col += font->bpp) { - si = (col & 7) / font->bpp; - byte = glyph->bitmap[(y * bpr) + (col >> 3)] & masks[si]; - if (byte) { - /* - * Position the pixel in the byte if necessary. - */ - di = ((col - colx) & 7) / font->bpp; - if (di < si) - byte <<= (si - di) * font->bpp; - else if (di > si) - byte >>= (di - si) * font->bpp; - bmap[((y - miny) * nbpr) + ((col - colx) >> 3)] |= byte; - } - } - } - - if (glyph->bytes > 0) - free((char *) glyph->bitmap); - glyph->bytes = bytes; - glyph->bitmap = bmap; - - (void) memcpy((char *) &glyph->bbx, (char *) &nbbx, sizeof(bdf_bbx_t)); -} - -/* - * Pad a character-cell font glyph to match the bounds specified in the - * provided bounding box. - */ -static void -#ifdef __STDC__ -_bdf_pad_cell(bdf_font_t *font, bdf_glyph_t *glyph, bdf_glyph_t *cell) -#else -_bdf_pad_cell(font, glyph, cell) -bdf_font_t *font; -bdf_glyph_t *glyph, *cell; -#endif -{ - bdf_bbx_t *bbx; - unsigned short si, di, sx, byte; - unsigned short x, y, dx, dy, bx, by, bpr, nbpr; - unsigned char *bmap, *masks; - - masks = 0; - switch (font->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - bbx = &font->bbx; - - if (glyph->bbx.width == bbx->width && glyph->bbx.height == bbx->height) { - /* - * The glyph is already positioned in the cell. Copy the bitmap - * and return. - */ - (void) memcpy((char *) cell->bitmap, (char *) glyph->bitmap, - cell->bytes); - return; - } - - /* - * Determine the X and Y location of the baseline. - */ - bx = MYABS(bbx->x_offset - glyph->bbx.x_offset); - by = (bbx->ascent + bbx->descent) + bbx->y_offset; - - bpr = ((glyph->bbx.width * font->bpp) + 7) >> 3; - nbpr = ((bbx->width * font->bpp) + 7) >> 3; - - /* - * Set various cell values and clear the cell bitmap. - */ - bmap = cell->bitmap; - (void) memset((char *) bmap, 0, cell->bytes); - - for (dy = by - glyph->bbx.ascent, y = 0; y < glyph->bbx.height; - y++, dy++) { - for (dx = bx * font->bpp, sx = x = 0; x < glyph->bbx.width; - x++, dx += font->bpp, sx += font->bpp) { - si = (sx & 7) / font->bpp; - byte = glyph->bitmap[(y * bpr) + (sx >> 3)] & masks[si]; - if (byte) { - di = (dx & 7) / font->bpp; - if (di < si) - byte <<= (si - di) * font->bpp; - else if (di > si) - byte >>= (di - si) * font->bpp; - bmap[(dy * nbpr) + (dx >> 3)] |= byte; - } - } - } -} - -static char *unix_eol = "\n"; -static char *dos_eol = "\r\n"; -static char *mac_eol = "\r"; - -void -#ifdef __STDC__ -bdf_save_font(FILE *out, bdf_font_t *font, bdf_options_t *opts, - bdf_callback_t callback, void *data) -#else -bdf_save_font(out, font, opts, callback, data) -FILE *out; -bdf_font_t *font; -bdf_options_t *opts; -bdf_callback_t callback; -void *data; -#endif -{ - unsigned long i, j, bpr, pcnt; - double dw, ps, rx; - char *sp, *ep, *eol; - bdf_property_t *p; - bdf_glyph_t *c, *cp, cell; - bdf_callback_struct_t cb; - - if (font == 0) - return; - - eol = 0; - switch (opts->eol) { - case BDF_UNIX_EOL: - eol = unix_eol; - break; - case BDF_DOS_EOL: - eol = dos_eol; - break; - case BDF_MAC_EOL: - eol = mac_eol; - break; - } - - /* - * If the font is a character cell font, allocate some space for the - * bitmap. - */ - if (font->spacing == BDF_CHARCELL && opts->pad_cells != 0) { - bpr = ((font->bbx.width * font->bpp) + 7) >> 3; - cell.bytes = bpr * font->bbx.height; - cell.bitmap = (unsigned char *) malloc(cell.bytes); - } - - /* - * Emit the header. - */ - fprintf(out, "STARTFONT 2.1%s", eol); - - /* - * Emit the comments. - */ - if (font->comments_len > 0) { - for (sp = font->comments; *sp; sp++) { - ep = sp; - while (*ep && *ep != '\n') - ep++; - fprintf(out, "COMMENT %.*s%s", ep - sp, sp, eol); - sp = ep; - } - } - - /* - * Emit the font name. - */ - fprintf(out, "FONT %s%s", font->name, eol); - - /* - * Emit the size info. - */ - if (font->bpp == 1) - fprintf(out, "SIZE %ld %ld %ld%s", font->point_size, - font->resolution_x, font->resolution_y, eol); - else - fprintf(out, "SIZE %ld %ld %ld %hd%s", font->point_size, - font->resolution_x, font->resolution_y, font->bpp, eol); - - /* - * Emit the bounding box. - */ - fprintf(out, "FONTBOUNDINGBOX %hd %hd %hd %hd%s", - font->bbx.width, font->bbx.height, font->bbx.x_offset, - font->bbx.y_offset, eol); - - /* - * Emit the properties after counting how many are properties and - * how many are comments. - */ - for (i = pcnt = 0, p = font->props; i < font->props_used; i++, p++) { - if (memcmp(p->name, "COMMENT", 7) != 0) - pcnt++; - } - - fprintf(out, "STARTPROPERTIES %ld%s", pcnt, eol); - for (i = 0, p = font->props; i < font->props_used; i++, p++) { - fprintf(out, "%s ", p->name); - if (p->format == BDF_ATOM) { - if (p->value.atom == 0) - fprintf(out, "\"\"%s", eol); - else - fprintf(out, "\"%s\"%s", p->value.atom, eol); - } else - fprintf(out, "%ld%s", p->value.int32, eol); - } - - fprintf(out, "ENDPROPERTIES%s", eol); - - /* - * Emit the number of bitmaps in the font. - */ - fprintf(out, "CHARS %ld%s", font->unencoded_used + font->glyphs_used, eol); - - /* - * Call the callback if it was passed to start the save. - */ - if (callback != 0) { - cb.reason = BDF_SAVE_START; - cb.total = font->unencoded_used + font->glyphs_used; - cb.current = 0; - (*callback)(&cb, data); - } - - /* - * Emit the unencoded bitmaps. - */ - for (i = 0, cp = font->unencoded; i < font->unencoded_used; i++, cp++) { - /* - * If the font has character-cell spacing and the option to pad the - * glyphs to the size of the font bbx is set, then pad the glyph. - * Otherwise, crop the glyph to the minimum rectangle needed to hold - * the bitmap. - */ - if (font->spacing == BDF_CHARCELL && opts->pad_cells != 0) { - /* - * Point at the temporary glyph structure and copy the necessary - * glyph info into it. - */ - c = &cell; - c->name = cp->name; - c->encoding = cp->encoding; - c->swidth = cp->swidth; - c->dwidth = cp->dwidth; - (void) memcpy((char *) &c->bbx, (char *) &font->bbx, - sizeof(bdf_bbx_t)); - _bdf_pad_cell(font, cp, c); - } else { - c = cp; - _bdf_crop_glyph(font, c); - } - - /* - * If the font has monowidth or character-cell spacing, then assign - * the font monowidth field to the device width and recalculate the - * scalable width. - */ - if (font->spacing != BDF_PROPORTIONAL) { - c->dwidth = font->monowidth; - ps = (double) font->point_size; - rx = (double) font->resolution_x; - dw = (double) c->dwidth; - c->swidth = (unsigned short)((dw * 72000.0) / (ps * rx)); - } - if (c->name == 0) - fprintf(out, "STARTCHAR unencoded%ld%sENCODING -1%s", i, eol, eol); - else - fprintf(out, "STARTCHAR %s%sENCODING -1%s", c->name, eol, eol); - fprintf(out, "SWIDTH %hd 0%sDWIDTH %hd 0%s", - c->swidth, eol, c->dwidth, eol); - fprintf(out, "BBX %hd %hd %hd %hd%s", c->bbx.width, c->bbx.height, - c->bbx.x_offset, c->bbx.y_offset, eol); - fprintf(out, "BITMAP%s", eol); - bpr = ((c->bbx.width * font->bpp) + 7) >> 3; - for (j = 0; bpr != 0 && j < c->bytes; j++) { - if (j && j % bpr == 0) - fprintf(out, eol); - fprintf(out, "%02X", c->bitmap[j]); - } - /* - * Handle empty bitmaps like this. - */ - if (c->bbx.height > 0) - fprintf(out, eol); - fprintf(out, "ENDCHAR%s", eol); - - /* - * Call the callback if supplied. - */ - if (callback != 0) { - cb.reason = BDF_SAVING; - cb.current++; - (*callback)(&cb, data); - } - } - - /* - * Emit the other bitmaps. - */ - for (i = 0, cp = font->glyphs; i < font->glyphs_used; i++, cp++) { - /* - * If the font has character-cell spacing and the option to pad the - * glyphs to the size of the font bbx is set, then pad the glyph. - * Otherwise, crop the glyph to the minimum rectangle needed to hold - * the bitmap. - */ - if (font->spacing == BDF_CHARCELL && opts->pad_cells != 0) { - /* - * Point at the temporary glyph structure and copy the necessary - * glyph info into it. - */ - c = &cell; - c->name = cp->name; - c->encoding = cp->encoding; - c->swidth = cp->swidth; - c->dwidth = cp->dwidth; - (void) memcpy((char *) &c->bbx, (char *) &font->bbx, - sizeof(bdf_bbx_t)); - _bdf_pad_cell(font, cp, c); - } else { - c = cp; - _bdf_crop_glyph(font, c); - } - - /* - * If the font has monowidth or character-cell spacing, then assign - * the font monowidth field to the device width and recalculate the - * scalable width. - */ - if (font->spacing != BDF_PROPORTIONAL) { - c->dwidth = font->monowidth; - ps = (double) font->point_size; - rx = (double) font->resolution_x; - dw = (double) c->dwidth; - c->swidth = (unsigned short)((dw * 72000.0) / (ps * rx)); - } - if (c->name == 0) - fprintf(out, "STARTCHAR char%ld%sENCODING %ld%s", - c->encoding, eol, c->encoding, eol); - else - fprintf(out, "STARTCHAR %s%sENCODING %ld%s", - c->name, eol, c->encoding, eol); - fprintf(out, "SWIDTH %hd 0%sDWIDTH %hd 0%s", - c->swidth, eol, c->dwidth, eol); - fprintf(out, "BBX %hd %hd %hd %hd%s", c->bbx.width, c->bbx.height, - c->bbx.x_offset, c->bbx.y_offset, eol); - fprintf(out, "BITMAP%s", eol); - bpr = ((c->bbx.width * font->bpp) + 7) >> 3; - for (j = 0; bpr != 0 && j < c->bytes; j++) { - if (j && j % bpr == 0) - fprintf(out, eol); - fprintf(out, "%02X", c->bitmap[j]); - } - /* - * Handle empty bitmaps like this. - */ - if (c->bbx.height > 0) - fprintf(out, eol); - fprintf(out, "ENDCHAR%s", eol); - - /* - * Call the callback if supplied. - */ - if (callback != 0) { - cb.reason = BDF_SAVING; - cb.current++; - (*callback)(&cb, data); - } - } - - /* - * Emit the trailer. - */ - fprintf(out, "ENDFONT%s", eol); - - /* - * Always force a final call to the callback to make sure things - * get cleaned up. - */ - if (callback != 0) { - cb.reason = BDF_SAVING; - cb.current = cb.total; - (*callback)(&cb, data); - } - - /* - * If the font is a character cell font, clean up the temporary glyph. - */ - if (font->spacing == BDF_CHARCELL && opts->pad_cells != 0) - free((char *) cell.bitmap); -} - -/* - * Routine to write a single set of SBIT metrics. - */ -void -#ifdef __STDC__ -bdf_save_sbit_metrics(FILE *out, bdf_font_t *font, bdf_options_t *opts, - char *appname) -#else -bdf_save_sbit_metrics(out, font, opts, appname) -bdf_font_t *font; -bdf_options_t *opts; -char *appname; -#endif -{ - char *eol; - - eol = 0; - switch (opts->eol) { - case BDF_UNIX_EOL: - eol = unix_eol; - break; - case BDF_DOS_EOL: - eol = dos_eol; - break; - case BDF_MAC_EOL: - eol = mac_eol; - break; - } - - /* - * Throw a simple header in. - */ - if (appname) - fprintf(out, ";%s; SBIT metrics file generated by \"%s\".%s;%s%s", eol, - appname, eol, eol, eol); - - /* - * Save PPEM. - */ - fprintf(out, ";%s; Pixels Per Em.%s;%s", eol, eol, eol); - fprintf(out, "PPEM %ld%s%s", font->point_size, eol, eol); - - /* - * If the font is character cell or monowidth, set this boolean. - */ - if (font->spacing != BDF_PROPORTIONAL) { - fprintf(out, - ";%s; Font is not proportional, so use mono advance.%s;%s", - eol, eol, eol); - fprintf(out, "FORCECONSTANTMETRICS TRUE%s%s", eol, eol); - } else { - fprintf(out, - ";%s; Font is proportional, so do not use mono advance.%s;%s", - eol, eol, eol); - fprintf(out, "FORCECONSTANTMETRICS FALSE%s%s", eol, eol); - } - - /* - * Do the horizontal line metrics only. - */ - fprintf(out, ";%s; Horizontal line metrics.%s;%s", eol, eol, eol); - - fprintf(out, "H_ASCENDER %ld%sH_DESCENDER %ld%s", font->font_ascent, eol, - font->font_descent, eol); - fprintf(out, "H_WIDTHMAX %hd%s", font->bbx.width, eol); - fprintf(out, "H_MINORIGINSB %hd%sH_MINADVANCEBL %hd%s", - font->bbx.x_offset, eol, - font->bbx.width + font->bbx.x_offset, eol); - fprintf(out, "H_MAXBEFOREBL %hd%sH_MINAFTERBL %hd%s%s", - font->bbx.ascent, eol, font->bbx.y_offset, eol, eol); - - /* - * Write the default caret info. - */ - fprintf(out, ";%s; Caret slope and offset info.%s;%s", eol, eol, eol); - fprintf(out, "CARETSLOPENUMERATOR 1%sCARETSLOPEDENOMINATOR 0%s", eol, eol); - fprintf(out, "CARETOFFSET 0%s%s", eol, eol); - - /* - * Write the bitmap options. - */ - fprintf(out, ";%s; Bitmap options.%s;%s", eol, eol, eol); - fprintf(out, "DIRECTION H%sSTORAGE FAST%s%s", eol, eol, eol); - - /* - * Scaled bitmaps not implemented yet. - */ - fprintf(out, ";%s; Scaled bitmap info (Not Yet Implemented).%s;%s", - eol, eol, eol); -} - -/* - * Special routine to dump the font in the Roman Czyborra's hex format. It - * only dumps the encoded glyphs and assumes the bitmaps have the correct - * sizes. - */ -void -#ifdef __STDC__ -bdf_export_hex(FILE *out, bdf_font_t *font, bdf_callback_t callback, - void *data) -#else -bdf_export_hex(out, font, callback, data) -FILE *out; -bdf_font_t *font; -bdf_callback_t callback; -void *data; -#endif -{ - int bpr, fbpr, j, k; - unsigned long i, ng; - bdf_glyph_t *gp, cell; - bdf_callback_struct_t cb; - - if (font == 0 || out == 0) - return; - - if (font->glyphs_used == 0) - return; - - /* - * Call the callback if it was passed to start the export. - */ - if (callback != 0) { - cb.reason = BDF_EXPORT_START; - cb.total = font->glyphs_used; - cb.current = 0; - (*callback)(&cb, data); - } - - fbpr = ((font->bbx.width * font->bpp) + 7) >> 3; - bpr = (((font->bbx.width >> 1) * font->bpp) + 7) >> 3; - cell.bytes = fbpr * font->bbx.height; - cell.bitmap = (unsigned char *) malloc(cell.bytes); - - for (i = 0, ng = font->glyphs_used, gp = font->glyphs; i < ng; i++, gp++) { - _bdf_pad_cell(font, gp, &cell); - fprintf(out, "%04lX:", gp->encoding & 0xffff); - if (gp->bbx.width <= (font->bbx.width >> 1)) { - for (j = 0; j < cell.bytes; j += fbpr) { - for (k = 0; k < bpr; k++) - fprintf(out, "%02X", cell.bitmap[j + k]); - } - } else { - for (j = 0; j < cell.bytes; j++) - fprintf(out, "%02X", cell.bitmap[j]); - } - if (cell.bytes > 0) - putc('\n', out); - - /* - * Call the callback if supplied. - */ - if (callback != 0) { - cb.reason = BDF_EXPORTING; - cb.current++; - (*callback)(&cb, data); - } - } - - /* - * Clean up the cell. - */ - free((char *) cell.bitmap); - - /* - * Always call a final callback to make sure the client gets a chance to - * clean things up. - */ - if (callback != 0) { - cb.reason = BDF_EXPORTING; - cb.current = cb.total; - (*callback)(&cb, data); - } -} - -void -#ifdef __STDC__ -bdf_free_font(bdf_font_t *font) -#else -bdf_free_font(font) -bdf_font_t *font; -#endif -{ - unsigned long i; - bdf_glyph_t *glyphs; - - if (font == 0) - return; - - if (font->name != 0) - free(font->name); - - /* - * Free up the internal hash table of property names. - */ - hash_free((hashtable *) font->internal); - free((char *) font->internal); - - /* - * Free up the comment info. - */ - if (font->comments_len > 0) - free(font->comments); - - /* - * Free up the auto-correction messages. - */ - if (font->acmsgs_len > 0) - free(font->acmsgs); - - /* - * Free up the properties. - */ - for (i = 0; i < font->props_size; i++) { - if (font->props[i].format == BDF_ATOM && font->props[i].value.atom) - free(font->props[i].value.atom); - } - - if (font->props_size > 0 && font->props != 0) - free((char *) font->props); - - /* - * Free up the character info. - */ - for (i = 0, glyphs = font->glyphs; i < font->glyphs_used; i++, glyphs++) { - if (glyphs->name) - free(glyphs->name); - if (glyphs->bytes > 0 && glyphs->bitmap != 0) - free((char *) glyphs->bitmap); - } - - for (i = 0, glyphs = font->unencoded; i < font->unencoded_used; - i++, glyphs++) { - if (glyphs->name) - free(glyphs->name); - if (glyphs->bytes > 0) - free((char *) glyphs->bitmap); - } - - if (font->glyphs_size > 0) - free((char *) font->glyphs); - - if (font->unencoded_size > 0) - free((char *) font->unencoded); - - /* - * Free up the overflow storage if it was used. - */ - for (i = 0, glyphs = font->overflow.glyphs; i < font->overflow.glyphs_used; - i++, glyphs++) { - if (glyphs->name != 0) - free(glyphs->name); - if (glyphs->bytes > 0) - free((char *) glyphs->bitmap);; - } - if (font->overflow.glyphs_size > 0) - free((char *) font->overflow.glyphs); - - free((char *) font); -} - -void -#ifdef __STDC__ -bdf_create_property(char *name, int format) -#else -bdf_create_property(name, format) -char *name; -int format; -#endif -{ - unsigned long n; - bdf_property_t *p; - - /* - * First check to see if the property has - * already been added or not. If it has, then - * simply ignore it. - */ - - if (hash_lookup(name, &proptbl)) - return; - - if (nuser_props == 0) - user_props = (bdf_property_t *) malloc(sizeof(bdf_property_t)); - else - user_props = (bdf_property_t *) realloc((char *) user_props, - sizeof(bdf_property_t) * - (nuser_props + 1)); - - p = user_props + nuser_props; - (void) memset((char *) p, 0, sizeof(bdf_property_t)); - n = (unsigned long)(strlen(name) + 1); - p->name = (char *) malloc(n); - (void) memcpy(p->name, name, n); - p->format = format; - p->builtin = 0; - - n = _num_bdf_properties + nuser_props; - hash_insert(p->name, (void *) n, &proptbl); - - nuser_props++; -} - -bdf_property_t * -#ifdef __STDC__ -bdf_get_property(char *name) -#else -bdf_get_property(name) -char *name; -#endif -{ - hashnode hn; - unsigned long propid; - - if (name == 0 || *name == 0) - return 0; - - if ((hn = hash_lookup(name, &proptbl)) == 0) - return 0; - - propid = (unsigned long) hn->data; - if (propid >= _num_bdf_properties) - return user_props + (propid - _num_bdf_properties); - return _bdf_properties + propid; -} - -/* - * Routine to compare two property names. - */ -static int -#ifdef __STDC__ -by_prop_name(const void *a, const void *b) -#else -by_prop_name(a, b) -char *a, *b; -#endif -{ - bdf_property_t *p1, *p2; - - p1 = (bdf_property_t *) a; - p2 = (bdf_property_t *) b; - - return strcmp(p1->name, p2->name); -} - -unsigned long -#ifdef __STDC__ -bdf_property_list(bdf_property_t **props) -#else -bdf_property_list(props) -bdf_property_t **props; -#endif -{ - unsigned long n; - bdf_property_t *p; - - n = _num_bdf_properties + nuser_props; - if (props != 0 && n != 0) { - p = (bdf_property_t *) malloc(sizeof(bdf_property_t) * n); - (void) memcpy((char *) p, (char *) _bdf_properties, - sizeof(bdf_property_t) * _num_bdf_properties); - (void) memcpy((char *)(p + _num_bdf_properties), (char *) user_props, - sizeof(bdf_property_t) * nuser_props); - qsort((char *) p, n, sizeof(bdf_property_t), by_prop_name); - *props = p; - } - return n; -} - -int -#ifdef __STDC__ -bdf_replace_comments(bdf_font_t *font, char *comments, - unsigned long comments_len) -#else -bdf_replace_comments(font, comments, comments_len) -bdf_font_t *font; -char *comments; -unsigned long comments_len; -#endif -{ - if (font == 0 || comments_len == 0) - return 0; - - if (font->comments_len > 0) - free(font->comments); - - font->comments = (char *) malloc(comments_len + 1); - (void) memcpy(font->comments, comments, comments_len); - font->comments[comments_len] = 0; - font->comments_len = comments_len; - font->modified = 1; - return 1; -} - -unsigned long -#ifdef __STDC__ -bdf_font_property_list(bdf_font_t *font, bdf_property_t **props) -#else -bdf_font_property_list(font, props) -bdf_font_t *font; -bdf_property_t **props; -#endif -{ - bdf_property_t *p; - - if (font == 0 || font->props_used == 0) - return 0; - - if (props != 0) { - p = (bdf_property_t *) malloc(sizeof(bdf_property_t) * - font->props_used); - (void) memcpy((char *) p, (char *) font->props, - sizeof(bdf_property_t) * font->props_used); - qsort((char *) p, font->props_used, sizeof(bdf_property_t), - by_prop_name); - *props = p; - } - - return font->props_used; -} - -void -#ifdef __STDC__ -bdf_add_font_property(bdf_font_t *font, bdf_property_t *property) -#else -bdf_add_font_property(font, property) -bdf_font_t *font; -bdf_property_t *property; -#endif -{ - int len; - unsigned long propid; - hashnode hn; - bdf_property_t *p, *ip; - - if (property == 0 || property->name == 0 || property->name[0] == 0) - return; - - /* - * If the font does not have a property hash table yet, make - * sure it is allocated. - */ - if (font->internal == 0) { - font->internal = (void *) malloc(sizeof(hashtable)); - hash_init((hashtable *) font->internal); - } - - /* - * See if the property is in the general property table yet. - * If it isn't, then add it. - */ - if ((hn = hash_lookup(property->name, &proptbl)) == 0) - bdf_create_property(property->name, property->format); - else { - /* - * If the property exists and is a user defined property, make sure - * its format is updated to match the property being added. - */ - propid = (unsigned long) hn->data; - if (propid >= _num_bdf_properties) { - p = user_props + (propid - _num_bdf_properties); - if (p->format != property->format) - p->format = property->format; - } - } - - /* - * If the font already has this property, then change the existing one. - */ - hn = hash_lookup(property->name, (hashtable *) font->internal); - if (hn != 0) { - /* - * Changing an existing property value. - */ - p = font->props + ((unsigned long) hn->data); - - /* - * If the format changed, then free the atom value if the original - * format was an atom. - */ - if (p->format == BDF_ATOM && property->format != BDF_ATOM && - p->value.atom != 0) - free((char *) p->value.atom); - p->format = property->format; - - switch (p->format) { - case BDF_ATOM: - /* - * If the property value is the same, then just return. - */ - if (property->value.atom == p->value.atom || - (property->value.atom && p->value.atom && - strcmp(property->value.atom, p->value.atom) == 0)) - return; - if (property->value.atom == 0) - len = 1; - else - len = strlen(property->value.atom) + 1; - if (len > 1) { - p->value.atom = (char *) malloc(len); - (void) memcpy(p->value.atom, property->value.atom, len); - } else - p->value.atom = 0; - break; - case BDF_INTEGER: - /* - * If the property value is the same, then just return. - */ - if (p->value.int32 == property->value.int32) - return; - p->value.int32 = property->value.int32; - break; - case BDF_CARDINAL: - /* - * If the property value is the same, then just return. - */ - if (p->value.card32 == property->value.card32) - return; - p->value.card32 = property->value.card32; - break; - } - } else { - /* - * New property being added. - */ - - /* - * Get the internal table entry for a pointer to the - * name of the property. - */ - hn = hash_lookup(property->name, &proptbl); - propid = (unsigned long) hn->data; - if (propid >= _num_bdf_properties) - ip = user_props + (propid - _num_bdf_properties); - else - ip = _bdf_properties + propid; - - /* - * Add it to the property list first. - */ - if (font->props_used == font->props_size) { - if (font->props_size == 0) - font->props = (bdf_property_t *) malloc(sizeof(bdf_property_t)); - else - font->props = (bdf_property_t *) - realloc((char *) font->props, sizeof(bdf_property_t) * - (font->props_size + 1)); - font->props_size++; - } - p = font->props + font->props_used; - - p->name = ip->name; - p->format = ip->format; - p->builtin = ip->builtin; - - switch (p->format) { - case BDF_ATOM: - if (property->value.atom == 0) - len = 1; - else - len = strlen(property->value.atom) + 1; - if (len > 1) { - p->value.atom = (char *) malloc(len); - (void) memcpy(p->value.atom, property->value.atom, len); - } else - p->value.atom = 0; - break; - case BDF_INTEGER: - p->value.int32 = property->value.int32; - break; - case BDF_CARDINAL: - p->value.card32 = property->value.card32; - break; - } - - /* - * Now insert it into the internal hash table. - */ - hash_insert(p->name, (void *) font->props_used, - (hashtable *) font->internal); - font->props_used++; - } - - if (memcmp(property->name, "DEFAULT_CHAR", 12) == 0) - /* - * If the property just added is DEFAULT_CHAR, then make sure the - * default_glyph field is set. - */ - font->default_glyph = p->value.card32; - else if (memcmp(property->name, "FONT_ASCENT", 11) == 0) - /* - * If the property just added is FONT_ASCENT, then adjust the - * font_ascent field. - */ - font->font_ascent = p->value.int32; - else if (memcmp(property->name, "FONT_DESCENT", 12) == 0) - /* - * If the property just added is FONT_DESCENT, then adjust the - * font_descent field. - */ - font->font_descent = p->value.int32; - else if (memcmp(property->name, "RESOLUTION_X", 12) == 0) - /* - * If the property just added is RESOLUTION_X, then adjust the - * resolution_x field. - */ - font->resolution_x = p->value.card32; - else if (memcmp(property->name, "RESOLUTION_Y", 12) == 0) - /* - * If the property just added is RESOLUTION_Y, then adjust the - * resolution_y field. - */ - font->resolution_y = p->value.card32; - else if (memcmp(property->name, "POINT_SIZE", 10) == 0) - /* - * If the property just added is POINT_SIZE, then adjust the - * point_size field. - */ - font->point_size = p->value.int32 / 10; - else if (memcmp(property->name, "SPACING", 7) == 0) { - /* - * Make sure the font spacing is kept in synch if the property - * changes. If the spacing changes from proportional to one - * of the others, force the monowidth to be set. - */ - switch (p->value.atom[0]) { - case 'C': - case 'c': - if (font->spacing == BDF_PROPORTIONAL) - font->monowidth = font->bbx.width + font->bbx.x_offset; - font->spacing = BDF_CHARCELL; - break; - case 'M': - case 'm': - if (font->spacing == BDF_PROPORTIONAL) - font->monowidth = font->bbx.width + font->bbx.x_offset; - font->spacing = BDF_MONOWIDTH; - break; - case 'P': - case 'p': - font->spacing = BDF_PROPORTIONAL; - break; - } - } - - /* - * Make sure the font is marked as modified. - */ - font->modified = 1; -} - -void -#ifdef __STDC__ -bdf_delete_font_property(bdf_font_t *font, char *name) -#else -bdf_delete_font_property(font, name) -bdf_font_t *font; -char *name; -#endif -{ - hashnode hn; - unsigned long off; - bdf_property_t *p; - - if (font == 0 || name == 0 || *name == 0 || font->props_used == 0) - return; - - if ((hn = hash_lookup(name, (hashtable *) font->internal)) == 0) - return; - - off = (unsigned long) hn->data; - p = font->props + off; - - /* - * Delete the ATOM value if appropriate. - */ - if (p->format == BDF_ATOM && p->value.atom != 0) - free(p->value.atom); - - /* - * The property exists. Two things needs to be done: - * 1. Remove the property from the hash table. - * 2. Remove the property from the font's list of properties. - */ - hash_delete(name, (hashtable *) font->internal); - - /* - * Locate its offset in the font property list. - */ - if (off < font->props_used - 1) - /* - * We have to shift the property list down. - */ - _bdf_memmove((char *) p, (char *)(p + 1), - sizeof(bdf_property_t) * ((font->props_used - 1) - off)); - font->props_used--; - - /* - * If the font property happens to be DEFAULT_CHAR, then make sure the - * default_glyph field is reset. - */ - if (strncmp(name, "DEFAULT_CHAR", 12) == 0) - font->default_glyph = -1; - - /* - * Update the hash table with the correct indexes. - */ - for (off = 0, p = font->props; off < font->props_used; off++, p++) - hash_insert(p->name, (void *) off, (hashtable *) font->internal); - - /* - * Mark the font as being modified. - */ - font->modified = 1; -} - -bdf_property_t * -#ifdef __STDC__ -bdf_get_font_property(bdf_font_t *font, const char *name) -#else -bdf_get_font_property(font, name) -bdf_font_t *font; -const char *name; -#endif -{ - hashnode hn; - - if (font == 0 || font->props_size == 0 || name == 0 || *name == 0) - return 0; - - hn = hash_lookup((char*)name, (hashtable *) font->internal); - return (hn) ? (font->props + ((unsigned long) hn->data)) : 0; -} - -typedef struct { - bdf_options_t *opts; - bdf_options_callback_t callback; - void *client_data; - _bdf_list_t list; -} _bdf_opts_parse_t; - -static int -#ifdef __STDC__ -_bdf_get_boolean(char *val) -#else -_bdf_get_boolean(val) -char *val; -#endif -{ - int ok; - - ok = 0; - if (val == 0 || *val == 0) - return ok; - - switch (val[0]) { - case '0': - case 'F': - case 'f': - case 'N': - case 'n': - ok = 0; - break; - case '1': - case 'T': - case 't': - case 'Y': - case 'y': - ok = 1; - break; - } - return ok; -} - -static int -#ifdef __STDC__ -_bdf_parse_options(char *line, unsigned long linelen, unsigned long lineno, - void *call_data, void *client_data) -#else -_bdf_parse_options(line, linelen, lineno, call_data, client_data) -char *line; -unsigned long linelen, lineno; -void *call_data, *client_data; -#endif -{ - _bdf_list_t *lp; - _bdf_opts_parse_t *p; - long bpp; - - p = (_bdf_opts_parse_t *) client_data; - lp = &p->list; - - /* - * Split the line into fields. - */ - _bdf_split(" \t+", line, linelen, lp); - - if (lp->field[0][0] == 'b' && - memcmp(lp->field[0], "bits_per_pixel", 14) == 0) { - if (lp->used < 2) { - fprintf(stderr, - "bdf: warning: %ld: incorrect number of fields %ld.\n", - lineno, lp->used); - fprintf(stderr, - "bdf: warning: %ld: bits_per_pixel <1, 2, or 4>.\n", - lineno); - } else { - bpp = _bdf_atol(lp->field[1], 0, 10); - if (!(bpp == 1 || bpp == 2 || bpp == 4)) { - fprintf(stderr, - "bdf: warning: %ld: invalid bits per pixel %ld.\n", - lineno, bpp); - fprintf(stderr, - "bdf: warning: %ld: bits_per_pixel <1, 2, or 4>.\n", - lineno); - } else - p->opts->bits_per_pixel = bpp; - } - return 0; - } - - if (lp->field[0][0] == 'e' && memcmp(lp->field[0], "eol", 3) == 0) { - if (lp->used < 2) { - fprintf(stderr, - "bdf: warning: %ld: incorrect number of fields %ld.\n", - lineno, lp->used); - fprintf(stderr, - "bdf: warning: %ld: eol <eolname>.\n", lineno); - } else { - switch (lp->field[1][0]) { - case 'u': - case 'U': - p->opts->eol = BDF_UNIX_EOL; - break; - case 'd': - case 'D': - p->opts->eol = BDF_DOS_EOL; - break; - case 'm': - case 'M': - p->opts->eol = BDF_MAC_EOL; - break; - } - } - return 0; - } - - if (lp->field[0][0] == 'c' && - memcmp(lp->field[0], "correct_metrics", 15) == 0) { - if (lp->used < 2) { - fprintf(stderr, - "bdf: warning: %ld: incorrect number of fields %ld.\n", - lineno, lp->used); - fprintf(stderr, - "bdf: warning: %ld: correct_metrics <boolean>.\n", lineno); - } else - p->opts->correct_metrics = _bdf_get_boolean(lp->field[1]); - - return 0; - } - - if (lp->field[0][0] == 'k' && - memcmp(lp->field[0], "keep_unencoded", 14) == 0) { - if (lp->used < 2) { - fprintf(stderr, - "bdf: warning: %ld: incorrect number of fields %ld.\n", - lineno, lp->used); - fprintf(stderr, - "bdf: warning: %ld: keep_unencoded <boolean>.\n", lineno); - } else - p->opts->keep_unencoded = _bdf_get_boolean(lp->field[1]); - - return 0; - } - - if (lp->field[0][0] == 'k' && - memcmp(lp->field[0], "keep_comments", 13) == 0) { - if (lp->used < 2) { - fprintf(stderr, - "bdf: warning: %ld: incorrect number of fields %ld.\n", - lineno, lp->used); - fprintf(stderr, - "bdf: warning: %ld: keep_comments <boolean>.\n", lineno); - } else - p->opts->keep_comments = _bdf_get_boolean(lp->field[1]); - - return 0; - } - - if (lp->field[0][0] == 'p' && - memcmp(lp->field[0], "pad_character_cells", 19) == 0) { - if (lp->used < 2) { - fprintf(stderr, - "bdf: warning: %ld: incorrect number of fields %ld.\n", - lineno, lp->used); - fprintf(stderr, - "bdf: warning: %ld: pad_character_cells <boolean>.\n", - lineno); - } else - p->opts->pad_cells = _bdf_get_boolean(lp->field[1]); - - return 0; - } - - if (lp->field[0][0] == 'p' && - memcmp(lp->field[0], "point_size", 10) == 0) { - if (lp->used < 2) { - fprintf(stderr, - "bdf: warning: %ld: incorrect number of fields %ld.\n", - lineno, lp->used); - fprintf(stderr, - "bdf: warning: %ld: point_size <integer>.\n", lineno); - } else - p->opts->point_size = _bdf_atol(lp->field[1], 0, 10); - return 0; - } - - if (lp->field[0][0] == 'h' && - memcmp(lp->field[0], "horizontal_resolution", 21) == 0) { - if (lp->used < 2) { - fprintf(stderr, - "bdf: warning: %ld: incorrect number of fields %ld.\n", - lineno, lp->used); - fprintf(stderr, - "bdf: warning: %ld: horizontal_resolution <cardinal>.\n", - lineno); - } else - p->opts->resolution_x = _bdf_atoul(lp->field[1], 0, 10); - return 0; - } - - if (lp->field[0][0] == 'v' && - memcmp(lp->field[0], "vertical_resolution", 19) == 0) { - if (lp->used < 2) { - fprintf(stderr, - "bdf: warning: %ld: incorrect number of fields %ld.\n", - lineno, lp->used); - fprintf(stderr, - "bdf: warning: %ld: vertical_resolution <cardinal>.\n", - lineno); - } else - p->opts->resolution_y = _bdf_atoul(lp->field[1], 0, 10); - return 0; - } - - if (lp->field[0][0] == 'f' && - memcmp(lp->field[0], "font_spacing", 12) == 0) { - if (lp->used < 2) { - fprintf(stderr, - "bdf: warning: %ld: incorrect number of fields %ld.\n", - lineno, lp->used); - fprintf(stderr, - "bdf: warning: %ld: font_spacing <spacing name>.\n", - lineno); - } else { - switch (lp->field[1][0]) { - case 'P': - case 'p': - p->opts->font_spacing = BDF_PROPORTIONAL; - break; - case 'M': - case 'm': - p->opts->font_spacing = BDF_MONOWIDTH; - break; - case 'C': - case 'c': - p->opts->font_spacing = BDF_CHARCELL; - break; - default: - fprintf(stderr, - "bdf: warning: %ld: unknown font spacing '%s'.\n", - lineno, lp->field[1]); - } - } - return 0; - } - - if (lp->field[0][0] == 'p' && - memcmp(lp->field[0], "property", 8) == 0) { - if (lp->used < 3) { - fprintf(stderr, - "bdf: warning: %ld: incorrect number of fields %ld.\n", - lineno, lp->used); - fprintf(stderr, - "bdf: warning: %ld: property <name> <type>.\n", - lineno); - } else { - switch (lp->field[2][0]) { - case 'A': - case 'a': - bdf_create_property(lp->field[1], BDF_ATOM); - break; - case 'C': - case 'c': - bdf_create_property(lp->field[1], BDF_CARDINAL); - break; - case 'I': - case 'i': - bdf_create_property(lp->field[1], BDF_INTEGER); - break; - default: - fprintf(stderr, - "bdf: warning: %ld: unknown property type '%s'.\n", - lineno, lp->field[2]); - } - } - return 0; - } - - if (lp->field[0][0] == 'h' && - memcmp(lp->field[0], "hint_truetype_glyphs", 20) == 0) { - if (lp->used < 2) { - fprintf(stderr, - "bdf: warning: %ld: incorrect number of fields %ld.\n", - lineno, lp->used); - fprintf(stderr, - "bdf: warning: %ld: hint_truetype_glyphs <boolean>.\n", - lineno); - } else - p->opts->ttf_hint = _bdf_get_boolean(lp->field[1]); - - return 0; - } - - if (lp->field[0][0] == 'g' && - memcmp(lp->field[0], "generate_ranges", 15) == 0) - /* - * Simply ignore the glyph ranges entry in the config file. - */ - return 0; - - /* - * If the callback returns a non-zero value, the caller has handled the - * unknown option found in the file. - */ - if (p->callback != 0 && - (*p->callback)(p->opts, lp->field, lp->used, p->client_data) != 0) - return 0; - - fprintf(stderr, "bdf: warning: %ld: unknown configuration option '%s'.\n", - lineno, lp->field[0]); - return 0; -} - -void -#ifdef __STDC__ -bdf_load_options(FILE *in, bdf_options_t *opts, - bdf_options_callback_t callback, void *client_data) -#else -bdf_load_options(in, opts, callback, client_data) -FILE *in; -bdf_options_t *opts; -bdf_options_callback_t callback; -void *client_data; -#endif -{ - unsigned long lineno; - _bdf_opts_parse_t p; - - /* - * Don't bother loading the options if the file or options structure - * is NULL. - */ - if (in == 0 || opts == 0) - return; - - (void *) memset((char *) &p, 0, sizeof(_bdf_opts_parse_t)); - p.opts = opts; - p.callback = callback; - p.client_data = client_data; - (void) _bdf_readlines(fileno(in), _bdf_parse_options, (void *) &p, - &lineno); - - /* - * Free up the list if there is any space allocated. - */ - if (p.list.size > 0) - free((char *) p.list.field); -} - -void -#ifdef __STDC__ -bdf_save_options(FILE *out, bdf_options_t *opts) -#else -bdf_save_options(out, opts) -FILE *out; -bdf_options_t *opts; -#endif -{ - unsigned long i; - - if (out == 0 || opts == 0) - return; - - fprintf(out, "#\n# Metrics corrections.\n#\ncorrect_metrics "); - if (opts->correct_metrics) - fprintf(out, "true\n\n"); - else - fprintf(out, "false\n\n"); - - fprintf(out, "#\n# Preserve unencoded glyphs.\n#\nkeep_unencoded "); - if (opts->keep_unencoded) - fprintf(out, "true\n\n"); - else - fprintf(out, "false\n\n"); - - fprintf(out, "#\n# Preserve comments.\n#\nkeep_comments "); - if (opts->keep_comments) - fprintf(out, "true\n\n"); - else - fprintf(out, "false\n\n"); - - fprintf(out, "#\n# Pad character cells.\n#\npad_character_cells "); - if (opts->pad_cells) - fprintf(out, "true\n\n"); - else - fprintf(out, "false\n\n"); - - fprintf(out, "#\n# Font spacing.\n#\nfont_spacing "); - switch (opts->font_spacing) { - case BDF_PROPORTIONAL: - fprintf(out, "proportional\n\n"); - break; - case BDF_MONOWIDTH: - fprintf(out, "monowidth\n\n"); - break; - case BDF_CHARCELL: - fprintf(out, "charactercell\n\n"); - break; - } - - fprintf(out, "#\n# Point size.\n#\npoint_size %ld\n\n", opts->point_size); - - fprintf(out, - "#\n# Horizontal resolution.\n#\nhorizontal_resolution %ld\n\n", - opts->resolution_x); - - fprintf(out, - "#\n# Vertical resolution.\n#\nvertical_resolution %ld\n\n", - opts->resolution_x); - - fprintf(out, - "#\n# Bits per pixel.\n#\nbits_per_pixel %d\n\n", - opts->bits_per_pixel); - - fprintf(out, "#\n# Hint TrueType glyphs.\n#\nhint_truetype_glyphs "); - if (opts->ttf_hint) - fprintf(out, "true\n\n"); - else - fprintf(out, "false\n\n"); - - fprintf(out, "#\n# Set the EOL used when writing BDF fonts.\n#\neol "); - switch (opts->eol) { - case BDF_UNIX_EOL: - fprintf(out, "unix\n\n"); - break; - case BDF_DOS_EOL: - fprintf(out, "dos\n\n"); - break; - case BDF_MAC_EOL: - fprintf(out, "mac\n\n"); - break; - } - - /* - * Write out the user defined properties if they exist. - */ - if (nuser_props == 0) - return; - - fprintf(out, "#\n# User defined properties.\n#\n"); - - for (i = 0; i < nuser_props; i++) { - fprintf(out, "property %s ", user_props[i].name); - switch (user_props[i].format) { - case BDF_ATOM: - fprintf(out, "atom\n"); - break; - case BDF_CARDINAL: - fprintf(out, "cardinal\n"); - break; - case BDF_INTEGER: - fprintf(out, "integer\n"); - break; - } - } -} - -void -#ifdef __STDC__ -bdf_default_options(bdf_options_t *opts) -#else -bdf_default_options(opts) -bdf_options_t *opts; -#endif -{ - if (opts == 0) - return; - - (void) memcpy((char *) opts, (char *) &_bdf_opts, sizeof(bdf_options_t)); -} - -bdf_font_t * -#ifdef __STDC__ -bdf_new_font(char *name, long point_size, long resolution_x, long resolution_y, - long spacing, int bpp) -#else -bdf_new_font(name, point_size, resolution_x, resolution_y, spacing, bpp) -char *name; -long point_size, resolution_x, resolution_y, spacing; -int bpp; -#endif -{ - long psize; - char sp[2]; - bdf_font_t *font; - double dp, dr; - bdf_property_t prop; - - font = (bdf_font_t *) calloc(1, sizeof(bdf_font_t)); - if (name != 0 && *name != 0) { - font->name = (char *) malloc(strlen(name) + 1); - (void) strcpy(font->name, name); - } - - font->bpp = bpp; - font->point_size = point_size; - font->resolution_x = resolution_x; - font->resolution_y = resolution_y; - - /* - * Determine the pixel size of the new font based on the - * point size and resolution. - */ - dr = (double) resolution_y; - dp = (double)(point_size * 10); - psize = (long)(((dp * dr) / 722.7) + 0.5); - - /* - * Make the default width about 1.5 smaller than the height. - */ - font->bbx.height = psize; - font->bbx.width = (unsigned short)((double) psize) / 1.5; - - /* - * Now determine the default ascent and descent assuming a - * the descent is about 1/4 the ascent. - */ - font->bbx.descent = psize >> 2; - font->bbx.ascent = psize - font->bbx.descent; - - font->bbx.y_offset = -font->bbx.descent; - - /* - * Allocation the internal hash tables. - */ - font->internal = (void *) malloc(sizeof(hashtable)); - hash_init((hashtable *) font->internal); - - font->default_glyph = -1; - font->spacing = spacing; - - /* - * Add various useful properties. - */ - prop.name = "POINT_SIZE"; - prop.format = BDF_INTEGER; - prop.value.int32 = font->point_size * 10; - bdf_add_font_property(font, &prop); - - prop.name = "PIXEL_SIZE"; - prop.format = BDF_INTEGER; - prop.value.int32 = psize; - bdf_add_font_property(font, &prop); - - prop.name = "RESOLUTION_X"; - prop.format = BDF_CARDINAL; - prop.value.card32 = (unsigned long) font->resolution_x; - bdf_add_font_property(font, &prop); - - prop.name = "RESOLUTION_Y"; - prop.format = BDF_CARDINAL; - prop.value.card32 = (unsigned long) font->resolution_y; - bdf_add_font_property(font, &prop); - - prop.name = "FONT_ASCENT"; - prop.format = BDF_INTEGER; - prop.value.int32 = (long) font->bbx.ascent; - bdf_add_font_property(font, &prop); - - prop.name = "FONT_DESCENT"; - prop.format = BDF_INTEGER; - prop.value.int32 = (long) font->bbx.descent; - bdf_add_font_property(font, &prop); - - prop.name = "AVERAGE_WIDTH"; - prop.format = BDF_INTEGER; - prop.value.int32 = font->bbx.width * 10; - bdf_add_font_property(font, &prop); - - sp[0] = 'P'; - sp[1] = 0; - switch (spacing) { - case BDF_PROPORTIONAL: - sp[0] = 'P'; - break; - case BDF_MONOWIDTH: - sp[0] = 'M'; - break; - case BDF_CHARCELL: - sp[0] = 'C'; - break; - } - prop.name = "SPACING"; - prop.format = BDF_ATOM; - prop.value.atom = sp; - bdf_add_font_property(font, &prop); - - /* - * Mark the font as unmodified. - */ - font->modified = 0; - - return font; -} - -void -#ifdef __STDC__ -bdf_set_default_metrics(bdf_font_t *font) -#else -bdf_set_default_metrics(font) -bdf_font_t *font; -#endif -{ - long psize; - double dp, dr; - bdf_property_t prop; - - /* - * Determine the pixel size of the new font based on the - * point size and resolution. - */ - dr = (double) font->resolution_y; - dp = (double)(font->point_size * 10); - psize = (long)(((dp * dr) / 722.7) + 0.5); - - /* - * Make the default width about 1.5 smaller than the height. - */ - font->bbx.height = psize; - font->bbx.width = (unsigned short)((double) psize) / 1.5; - - /* - * Now determine the default ascent and descent assuming a - * the descent is about 1/4 the ascent. - */ - font->bbx.descent = psize >> 2; - font->bbx.ascent = psize - font->bbx.descent; - - font->bbx.y_offset = -font->bbx.descent; - - font->default_glyph = -1; - - /* - * Add various useful properties. - */ - prop.name = "FONT_ASCENT"; - prop.format = BDF_INTEGER; - prop.value.int32 = (long) font->bbx.ascent; - bdf_add_font_property(font, &prop); - - prop.name = "FONT_DESCENT"; - prop.format = BDF_INTEGER; - prop.value.int32 = (long) font->bbx.descent; - bdf_add_font_property(font, &prop); - - prop.name = "AVERAGE_WIDTH"; - prop.format = BDF_INTEGER; - prop.value.int32 = font->bbx.width * 10; - bdf_add_font_property(font, &prop); -} - -int -#ifdef __STDC__ -bdf_glyph_modified(bdf_font_t *font, long which, int unencoded) -#else -bdf_glyph_modified(font, which, unencoded) -bdf_font_t *font; -long which; -int unencoded; -#endif -{ - if (font == 0 || which < 0) - return 0; - - if (unencoded) - return _bdf_glyph_modified(font->umod, which); - else - return _bdf_glyph_modified(font->nmod, which); -} - -void -#ifdef __STDC__ -bdf_copy_glyphs(bdf_font_t *font, long start, long end, - bdf_glyphlist_t *glyphs, int unencoded) -#else -bdf_copy_glyphs(font, start, end, glyphs, unencoded) -bdf_font_t *font; -long start, end; -bdf_glyphlist_t *glyphs; -int unencoded; -#endif -{ - long tmp, i, nc; - bdf_glyph_t *cp, *dp; - short maxas, maxds, maxrb, minlb, maxlb, rb; - - if (start > end) { - tmp = end; - end = start; - start = tmp; - } - - glyphs->bpp = font->bpp; - glyphs->start = start; - glyphs->end = end; - glyphs->glyphs_used = 0; - - tmp = (end - start) + 1; - if (tmp > glyphs->glyphs_size) { - if (glyphs->glyphs_size == 0) - glyphs->glyphs = (bdf_glyph_t *) malloc(sizeof(bdf_glyph_t) * tmp); - else - glyphs->glyphs = (bdf_glyph_t *) realloc((char *) glyphs->glyphs, - sizeof(bdf_glyph_t) * tmp); - cp = glyphs->glyphs + glyphs->glyphs_size; - (void) memset((char *) cp, 0, - sizeof(bdf_glyph_t) * (tmp - glyphs->glyphs_size)); - glyphs->glyphs_size = tmp; - } - - /* - * Clear out bitmaps and names in the existing entries. - */ - for (cp = glyphs->glyphs, i = 0; i < glyphs->glyphs_size; i++, cp++) { - if (cp->name != 0) - free(cp->name); - if (cp->bytes > 0) - free((char *) cp->bitmap); - } - - /* - * Zero out everything. - */ - (void) memset((char *) &glyphs->bbx, 0, sizeof(bdf_bbx_t)); - (void) memset((char *) glyphs->glyphs, 0, - sizeof(bdf_glyph_t) * glyphs->glyphs_size); - - /* - * Initialize the bounds used to generate the overall bounding box for the - * set of glyphs being copied. - */ - minlb = font->bbx.width; - maxlb = maxrb = maxas = maxds = 0; - - /* - * Do the copy. - */ - nc = (unencoded == 0) ? font->glyphs_used : font->unencoded_used; - cp = (unencoded == 0) ? font->glyphs : font->unencoded; - dp = glyphs->glyphs; - - for (i = 0; - i < nc && ((unencoded && i <= end) || cp->encoding <= end); - i++, cp++) { - if ((unencoded && i >= start) || cp->encoding >= start) { - (void) memcpy((char *) dp, (char *) cp, sizeof(bdf_glyph_t)); - if (cp->name != 0) { - dp->name = (char *) malloc(strlen(cp->name) + 1); - (void) strcpy(dp->name, cp->name); - } - if (cp->bytes > 0) { - dp->bytes = cp->bytes; - dp->bitmap = (unsigned char *) malloc(cp->bytes); - (void) memcpy((char *) dp->bitmap, (char *) cp->bitmap, - cp->bytes); - } - - /* - * Determine the overall metrics for the group of characters being - * copied. - */ - maxas = MAX(cp->bbx.ascent, maxas); - maxds = MAX(cp->bbx.descent, maxds); - rb = cp->bbx.width + cp->bbx.x_offset; - maxrb = MAX(rb, maxrb); - minlb = MIN(cp->bbx.x_offset, minlb); - maxlb = MAX(cp->bbx.x_offset, maxlb); - - glyphs->glyphs_used++; - dp++; - } - } - - /* - * Set the overall metrics for this set of glyphs. - */ - glyphs->bbx.width = maxrb - minlb; - glyphs->bbx.x_offset = minlb; - - glyphs->bbx.height = maxas + maxds; - glyphs->bbx.ascent = maxas; - glyphs->bbx.descent = maxds; - glyphs->bbx.y_offset = -maxds; -} - -void -#ifdef __STDC__ -bdf_delete_glyphs(bdf_font_t *font, long start, long end, int unencoded) -#else -bdf_delete_glyphs(font, start, end, unencoded) -bdf_font_t *font; -long start, end; -int unencoded; -#endif -{ - long i, n, nc, cnt; - bdf_glyph_t *cp, *sp, *ep; - - if (font == 0) - return; - - if (start > end) { - cnt = end; - end = start; - start = cnt; - } - - nc = (unencoded == 0) ? font->glyphs_used : font->unencoded_used; - cp = (unencoded == 0) ? font->glyphs : font->unencoded; - sp = ep = 0; - - for (i = 0; i < nc && cp->encoding <= end; i++, cp++) { - if (cp->encoding >= start && sp == 0) - sp = cp; - } - ep = cp; - if (sp == 0) - sp = ep; - - if (ep > sp) { - /* - * There are some glyphs to delete. - * 1. Free the name and bitmap fields of the glyphs being deleted. - * 2. Move the end range down if necessary. - * 3. Clear the glyphs on the end if a move was done. - */ - - /* - * Mark the font as being modified. - */ - font->modified = 1; - - cnt = ep - sp; - - for (cp = sp; cp < ep; cp++) { - /* - * Mark the glyphs being deleted as also being modified so the - * empty cells can be shown correctly by the client programs. - */ - if (unencoded) - _bdf_set_glyph_modified(font->umod, cp->encoding); - else - _bdf_set_glyph_modified(font->nmod, cp->encoding); - - if (cp->name != 0) - free(cp->name); - if (cp->bytes > 0) - free((char *) cp->bitmap); - } - - cp = (unencoded == 0) ? font->glyphs : font->unencoded; - - /* - * Check to see if there are some glyphs that need to - * be moved down. - */ - if (ep - cp < nc) { - /* - * Shift the glyphs down. - */ - n = nc - (ep - cp); - _bdf_memmove((char *) sp, (char *) ep, sizeof(bdf_glyph_t) * n); - - /* - * Set the starting point for the clear. - */ - ep = sp + n; - } else - /* - * Set the starting point for the clear. - */ - ep = sp; - - /* - * Clear the glyph space just moved. - */ - n = nc - (ep - cp); - (void) memset((char *) ep, 0, sizeof(bdf_glyph_t) * n); - - /* - * Adjust the number of glyphs used. - */ - if (unencoded == 0) - font->glyphs_used -= cnt; - else - font->unencoded_used -= cnt; - - /* - * If unencoded glyphs were deleted, re-encode all - * of them to cause a shift when everything is redrawn. - */ - if (unencoded != 0) { - for (i = 0, cp = font->unencoded; i < font->unencoded_used; - i++, cp++) { - if (_bdf_glyph_modified(font->umod, cp->encoding)) { - _bdf_clear_glyph_modified(font->umod, cp->encoding); - _bdf_set_glyph_modified(font->umod, i); - } - cp->encoding = i; - } - } - } -} - -/* - * Routines for quick and dirty dithering. - */ -static void -#ifdef __STDC__ -_bdf_one_to_n(bdf_glyphlist_t *gl, int n) -#else -_bdf_one_to_n(gl, n) -bdf_glyphlist_t *gl; -int n; -#endif -{ - long i; - unsigned short bpr, sbpr, bytes, col, sx, sy; - unsigned char *nbmap, *masks; - bdf_glyph_t *gp; - - if (gl == 0 || gl->glyphs_used == 0) - return; - - masks = 0; - switch (n) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - gl->bpp = n; - for (gp = gl->glyphs, i = 0; i < gl->glyphs_used; i++, gp++) { - if (gp->bbx.width == 0 || gp->bbx.height == 0) - continue; - sbpr = (gp->bbx.width + 7) >> 3; - bpr = ((gp->bbx.width * n) + 7) >> 3; - bytes = bpr * gp->bbx.height; - nbmap = (unsigned char *) malloc(bytes); - (void) memset((char *) nbmap, 0, bytes); - - for (sy = 0; sy < gp->bbx.height; sy++) { - for (col = sx = 0; sx < gp->bbx.width; sx++, col += n) { - if (gp->bitmap[(sy * sbpr) + (sx >> 3)] & (0x80 >> (sx & 7))) - nbmap[(sy * bpr) + (col >> 3)] |= masks[(col & 7) / n]; - } - } - free((char *) gp->bitmap); - gp->bytes = bytes; - gp->bitmap = nbmap; - } -} - -static void -#ifdef __STDC__ -_bdf_n_to_one(bdf_glyphlist_t *gl) -#else -_bdf_n_to_one(gl) -bdf_glyphlist_t *gl; -#endif -{ - long i; - unsigned short bpr, sbpr, bytes, col, sx, sy; - unsigned char *nbmap, *masks; - bdf_glyph_t *gp; - - if (gl == 0 || gl->glyphs_used == 0) - return; - - masks = 0; - switch (gl->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - for (gp = gl->glyphs, i = 0; i < gl->glyphs_used; i++, gp++) { - if (gp->bbx.width == 0 || gp->bbx.height == 0) - continue; - sbpr = ((gp->bbx.width * gl->bpp) + 7) >> 3; - bpr = (gp->bbx.width + 7) >> 3; - bytes = bpr * gp->bbx.height; - nbmap = (unsigned char *) malloc(bytes); - (void) memset((char *) nbmap, 0, bytes); - - for (sy = 0; sy < gp->bbx.height; sy++) { - for (col = sx = 0; sx < gp->bbx.width; sx++, col += gl->bpp) { - if (gp->bitmap[(sy * sbpr) + (col >> 3)] & - masks[(col & 7) / gl->bpp]) - nbmap[(sy * bpr) + (sx >> 3)] |= (0x80 >> (sx & 7)); - } - } - free((char *) gp->bitmap); - gp->bytes = bytes; - gp->bitmap = nbmap; - } - gl->bpp = 1; -} - -static void -#ifdef __STDC__ -_bdf_two_to_four(bdf_glyphlist_t *gl) -#else -_bdf_two_to_four(gl) -bdf_glyphlist_t *gl; -#endif -{ - long i; - unsigned short bpr, sbpr, bytes, col, si, byte, sx, sy; - unsigned char *nbmap, *masks; - bdf_glyph_t *gp; - - if (gl == 0 || gl->glyphs_used == 0) - return; - - masks = twobpp; - - for (gp = gl->glyphs, i = 0; i < gl->glyphs_used; i++, gp++) { - if (gp->bbx.width == 0 || gp->bbx.height == 0) - continue; - sbpr = ((gp->bbx.width << 1) + 7) >> 3; - bpr = ((gp->bbx.width << 2) + 7) >> 3; - bytes = bpr * gp->bbx.height; - nbmap = (unsigned char *) malloc(bytes); - (void) memset((char *) nbmap, 0, bytes); - - for (sy = 0; sy < gp->bbx.height; sy++) { - for (col = sx = 0; sx < gp->bbx.width; sx++, col += 2) { - si = (col & 7) >> 1; - byte = gp->bitmap[(sy * sbpr) + (col >> 3)] & masks[si]; - if (byte) { - /* - * Shift the byte down to make an index. - */ - if (si < 3) - byte >>= (3 - si) * gl->bpp; - - /* - * Scale the index to four bits per pixel and shift it into - * place before adding it. - */ - byte = (byte << 2) + 3; - if ((sx & 1) == 0) - byte <<= 4; - nbmap[(sy * bpr) + ((sx << 2) >> 3)] |= byte; - } - } - } - free((char *) gp->bitmap); - gp->bytes = bytes; - gp->bitmap = nbmap; - } - gl->bpp = 4; -} - -static void -#ifdef __STDC__ -_bdf_four_to_two(bdf_glyphlist_t *gl) -#else -_bdf_four_to_two(gl) -bdf_glyphlist_t *gl; -#endif -{ - long i; - unsigned short bpr, sbpr, bytes, col, si, byte, sx, sy; - unsigned char *nbmap, *masks; - bdf_glyph_t *gp; - - if (gl == 0 || gl->glyphs_used == 0) - return; - - masks = fourbpp; - - gl->bpp = 2; - for (gp = gl->glyphs, i = 0; i < gl->glyphs_used; i++, gp++) { - sbpr = ((gp->bbx.width << 2) + 7) >> 3; - bpr = ((gp->bbx.width << 1) + 7) >> 3; - bytes = bpr * gp->bbx.height; - nbmap = (unsigned char *) malloc(bytes); - (void) memset((char *) nbmap, 0, bytes); - - for (sy = 0; sy < gp->bbx.height; sy++) { - for (col = sx = 0; sx < gp->bbx.width; sx++, col += 4) { - si = (col & 7) >> 2; - byte = gp->bitmap[(sy * sbpr) + (col >> 3)] & masks[si]; - if (byte) { - /* - * Shift the byte down to make an index. - */ - if (si == 0) - byte >>= 4; - - /* - * Scale the index to two bits per pixel and shift it into - * place if necessary. - */ - byte >>= 2; - - si = ((sx << 1) & 7) >> 1; - if (si < 3) - byte <<= (3 - si) << 1; - - nbmap[(sy * bpr) + ((sx << 1) >> 3)] |= byte; - } - } - } - free((char *) gp->bitmap); - gp->bytes = bytes; - gp->bitmap = nbmap; - } -} - -int -#ifdef __STDC__ -bdf_replace_glyphs(bdf_font_t *font, long start, bdf_glyphlist_t *glyphs, - int unencoded) -#else -bdf_replace_glyphs(font, start, glyphs, unencoded) -bdf_font_t *font; -long start; -bdf_glyphlist_t *glyphs; -int unencoded; -#endif -{ - int resize, appending; - long i, n, ng, end, del, remaining, off[2]; - bdf_glyph_t *sgp, *gp, *dgp; - short maxas, maxds, maxrb, minlb, maxlb, rb; - double ps, rx, dw; - bdf_bbx_t nbbx; - - resize = 0; - - if (font == 0) - return resize; - - /* - * Dither the incoming bitmaps so they match the same bits per pixel as - * the font. - */ - if (glyphs->bpp != font->bpp) { - if (glyphs->bpp == 1) - _bdf_one_to_n(glyphs, font->bpp); - else if (font->bpp == 1) - _bdf_n_to_one(glyphs); - else if (glyphs->bpp == 2) - _bdf_two_to_four(glyphs); - else - _bdf_four_to_two(glyphs); - } - - /* - * Set the point size and horizontal resolution so the scalable width can - * be determined. - */ - ps = (double) font->point_size; - rx = (double) font->resolution_x; - - /* - * Determine if a resize is needed. - */ - - /* - * Determine the bounding box for the font without the characters being - * replaced. - */ - minlb = 32767; - maxlb = maxrb = maxas = maxds = 0; - - /* - * Get the font bounds. - */ - maxas = MAX(font->bbx.ascent, maxas); - maxds = MAX(font->bbx.descent, maxds); - rb = font->bbx.width + font->bbx.x_offset; - maxrb = MAX(rb, maxrb); - minlb = MIN(font->bbx.x_offset, minlb); - maxlb = MAX(font->bbx.x_offset, maxlb); - - /* - * Get the bounds of the incoming glyphs. - */ - maxas = MAX(glyphs->bbx.ascent, maxas); - maxds = MAX(glyphs->bbx.descent, maxds); - rb = glyphs->bbx.width + glyphs->bbx.x_offset; - maxrb = MAX(rb, maxrb); - minlb = MIN(glyphs->bbx.x_offset, minlb); - maxlb = MAX(glyphs->bbx.x_offset, maxlb); - - /* - * Set up the new font bounding box, minus the characters that are being - * removed and with the new characters added. - */ - nbbx.width = maxrb - minlb; - nbbx.x_offset = minlb; - - nbbx.height = maxas + maxds; - nbbx.ascent = maxas; - nbbx.descent = maxds; - nbbx.y_offset = -maxds; - - /* - * Now determine if the combination of the glyphs removed and the new - * glyphs cause the font bounding box to be changed. - */ - resize = (nbbx.width > font->bbx.width || - nbbx.height > font->bbx.height) ? 1 : 0; - - /* - * Set the pointers to the glyphs. - */ - ng = (unencoded == 0) ? font->glyphs_used : font->unencoded_used; - sgp = gp = (unencoded == 0) ? font->glyphs : font->unencoded; - - /* - * Locate the closest glyph on or following `start'. - */ - for (i = 0; i < ng && gp->encoding < start; i++, gp++) ; - - appending = (i == ng); - - /* - * Set the starting point for copying the incoming glyphs. - */ - dgp = gp; - - n = glyphs->end - glyphs->start; - end = start + n; - - /* - * Delete all the glyphs between `start' and `end'. - */ - for (del = 0, i = start; i <= end; i++) { - /* - * Mark the character as being modified. - */ - if (ng > 0 && !appending && gp->encoding == i) { - if (unencoded == 0) - _bdf_set_glyph_modified(font->nmod, i); - else - _bdf_set_glyph_modified(font->umod, i); - - if (gp->name != 0) - free(gp->name); - if (gp->bytes > 0) - free((char *) gp->bitmap); - del++; - gp++; - } - } - - /* - * Determine how many glyphs remain following the last one deleted. - */ - remaining = ng - (gp - sgp); - - if (glyphs->glyphs_used == 0) { - /* - * If the glyph list is empty, then shift any remaining glyphs down - * to the destination. - */ - _bdf_memmove((char *) dgp, (char *) gp, - sizeof(bdf_glyph_t) * remaining); - if (unencoded == 0) - font->glyphs_used -= del; - else - font->unencoded_used -= del; - } else { - /* - * Insert the glyph list after making sure there is enough space to - * hold them. Also adjust the encoding and scalable width values - * after copying the glyphs. - */ - if (unencoded == 0) { - n = (font->glyphs_used - del) + glyphs->glyphs_used; - if (n > font->glyphs_size) { - off[0] = gp - sgp; - off[1] = dgp - sgp; - if (font->glyphs_size == 0) - font->glyphs = sgp = - (bdf_glyph_t *) malloc(sizeof(bdf_glyph_t) * n); - else - font->glyphs = sgp = - (bdf_glyph_t *) realloc((char *) font->glyphs, - sizeof(bdf_glyph_t) * n); - gp = sgp + off[0]; - dgp = sgp + off[1]; - font->glyphs_size = n; - } - - /* - * Calculate how many will need to be shifted. - */ - if ((n = glyphs->glyphs_used - del) >= font->glyphs_used) - n = 0; - } else { - n = (font->unencoded_used - del) + glyphs->glyphs_used; - if (n > font->unencoded_size) { - off[0] = gp - sgp; - off[1] = dgp - sgp; - if (font->unencoded_size == 0) - font->unencoded = sgp = - (bdf_glyph_t *) malloc(sizeof(bdf_glyph_t) * n); - else - font->unencoded = sgp = - (bdf_glyph_t *) realloc((char *) font->unencoded, - sizeof(bdf_glyph_t) * n); - gp = sgp + off[0]; - dgp = sgp + off[1]; - font->unencoded_size = n; - } - - /* - * Calculate how many will need to be shifted. - */ - if ((n = glyphs->glyphs_used - del) >= font->unencoded_used) - n = 0; - } - - /* - * Shift any following glyphs up or down if needed. - */ - if (n) - _bdf_memmove((char *)(gp + n), (char *) gp, - sizeof(bdf_glyph_t) * remaining); - - /* - * Copy the incoming glyphs, copy their names and bitmaps, - * set their encodings, and set their scalable widths. - */ - (void) memcpy((char *) dgp, (char *) glyphs->glyphs, - sizeof(bdf_glyph_t) * glyphs->glyphs_used); - for (i = 0; i < glyphs->glyphs_used; i++, dgp++) { - if (dgp->name != 0) - dgp->name = (char *) _bdf_strdup((unsigned char *) dgp->name, - strlen(dgp->name) + 1); - - if (dgp->bytes > 0) - dgp->bitmap = _bdf_strdup(dgp->bitmap, dgp->bytes); - - dgp->encoding = start + (dgp->encoding - glyphs->start); - - /* - * Mark the glyph as being modified in case it fills a cell that - * was empty before. - */ - _bdf_set_glyph_modified(font->nmod, dgp->encoding); - - dw = (double) dgp->dwidth; - dgp->swidth = (unsigned short)((dw * 72000.0) / (ps * rx)); - } - - /* - * Adjust the count of glyphs. - */ - ng = (ng - del) + glyphs->glyphs_used; - if (unencoded == 0) - font->glyphs_used = ng; - else - font->unencoded_used = ng; - } - - /* - * Last, if the replacement was done in the unencoded section, - * reencode all the glyphs so they show up properly. - */ - if (unencoded != 0) { - for (i = 0; i < ng; i++, sgp++) { - if (_bdf_glyph_modified(font->umod, sgp->encoding)) { - _bdf_clear_glyph_modified(font->umod, sgp->encoding); - _bdf_set_glyph_modified(font->umod, i); - } - sgp->encoding = i; - } - } - - if (resize) - (void) memcpy((char *) &font->bbx, (char *) &nbbx, sizeof(bdf_bbx_t)); - - font->modified = 1; - - return resize; -} - -int -#ifdef __STDC__ -bdf_insert_glyphs(bdf_font_t *font, long start, bdf_glyphlist_t *glyphs) -#else -bdf_insert_glyphs(font, start, glyphs) -bdf_font_t *font; -long start; -bdf_glyphlist_t *glyphs; -#endif -{ - int resize; - unsigned long i, ng, n, which; - bdf_glyph_t *gp; - - resize = 0; - - if (font == 0) - return resize; - - /* - * Dither the incoming bitmaps so they match the same bits per pixel as - * the font. - */ - if (glyphs->bpp != font->bpp) { - if (glyphs->bpp == 1) - _bdf_one_to_n(glyphs, font->bpp); - else if (font->bpp == 1) - _bdf_n_to_one(glyphs); - else if (glyphs->bpp == 2) - _bdf_two_to_four(glyphs); - else - _bdf_four_to_two(glyphs); - } - - /* - * Locate the starting glyph. - */ - gp = font->glyphs; - ng = font->glyphs_used; - for (i = 0; i < ng && gp->encoding < start; i++, gp++) ; - - /* - * If there are no glyphs at the starting point, then simply do a replace. - */ - if (i == ng) - return bdf_replace_glyphs(font, start, glyphs, 0); - - /* - * Go through the glyphs that would be shifted due to the insertion and - * determine if some of them will overflow the 0xffff boundary. - */ - n = (glyphs->end - glyphs->start) + 1; - for (which = i; i < ng; i++, gp++) { - if (gp->encoding + n > 0xffff) - break; - } - - if (i < ng) { - /* - * Some glyphs have to be moved to the unencoded area because they - * would overflow the 0xffff boundary if they were moved up. - */ - bdf_copy_glyphs(font, gp->encoding, font->glyphs[ng - 1].encoding, - &font->overflow, 0); - bdf_delete_glyphs(font, gp->encoding, font->glyphs[ng - 1].encoding, - 0); - resize += bdf_replace_glyphs(font, font->unencoded_used, - &font->overflow, 1); - } - - /* - * Go back to the insertion point and shift the remaining glyph encodings - * up by `n'. - */ - for (gp = font->glyphs + which; which < font->glyphs_used; which++, gp++) { - /* - * Mark the new glyph locations as being modified. - */ - gp->encoding += n; - _bdf_set_glyph_modified(font->nmod, gp->encoding); - } - - /* - * Finally, mark the font as being modified and insert the new glyphs. - */ - font->modified = 1; - - return resize + bdf_replace_glyphs(font, start, glyphs, 0); -} - -static void -#ifdef __STDC__ -_bdf_combine_glyphs(bdf_font_t *font, bdf_glyph_t *f, bdf_glyph_t *g) -#else -_bdf_combine_glyphs(font, f, g) -bdf_font_t *font; -bdf_glyph_t *f, *g; -#endif -{ - unsigned short x, sx, sy, si, dx, dy, di, byte, dbpr, fbpr, gbpr; - short maxas, maxds, maxrb, minlb, maxlb, rb; - unsigned char *masks; - bdf_bbx_t nbbx; - bdf_glyph_t tmp; - - /* - * Determine the max bounding box for the two glyphs. - */ - minlb = 32767; - maxlb = maxrb = maxas = maxds = 0; - - /* - * Get the font glyph bounds. - */ - maxas = MAX(f->bbx.ascent, maxas); - maxds = MAX(f->bbx.descent, maxds); - rb = f->bbx.width + f->bbx.x_offset; - maxrb = MAX(rb, maxrb); - minlb = MIN(f->bbx.x_offset, minlb); - maxlb = MAX(f->bbx.x_offset, maxlb); - - /* - * Get the bounds of the incoming glyph. - */ - maxas = MAX(g->bbx.ascent, maxas); - maxds = MAX(g->bbx.descent, maxds); - rb = g->bbx.width + g->bbx.x_offset; - maxrb = MAX(rb, maxrb); - minlb = MIN(g->bbx.x_offset, minlb); - maxlb = MAX(g->bbx.x_offset, maxlb); - - /* - * Set up the new glyph bounding box. - */ - nbbx.width = maxrb - minlb; - nbbx.x_offset = minlb; - nbbx.height = maxas + maxds; - nbbx.ascent = maxas; - nbbx.descent = maxds; - nbbx.y_offset = -maxds; - - masks = 0; - switch (font->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - fbpr = ((f->bbx.width * font->bpp) + 7) >> 3; - gbpr = ((g->bbx.width * font->bpp) + 7) >> 3; - dbpr = ((nbbx.width * font->bpp) + 7) >> 3; - - if (memcmp((char *) &nbbx, (char *) &f->bbx, sizeof(bdf_bbx_t)) == 0) { - /* - * The largest is the first, so merge the second in with it. - */ - dy = f->bbx.ascent - g->bbx.ascent; - for (sy = 0; sy < g->bbx.height; sy++, dy++) { - for (x = sx = 0; x < g->bbx.width; x++, sx += font->bpp) { - si = (sx & 7) / font->bpp; - if ((byte = g->bitmap[(sy * gbpr) + (sx >> 3)] & masks[si])) - /* - * No shifting of the byte is needed because the x offset - * is the same for both glyphs. - */ - f->bitmap[(dy * fbpr) + (sx >> 3)] |= byte; - } - } - } else if (memcmp((char *) &nbbx, (char *) &g->bbx, - sizeof(bdf_bbx_t)) == 0) { - /* - * The largest is the incoming glyph, so merge into that one and swap - * it with the font glyph. - */ - dy = g->bbx.ascent - f->bbx.ascent; - for (sy = 0; sy < f->bbx.height; sy++, dy++) { - for (x = sx = 0; x < f->bbx.width; x++, sx += font->bpp) { - si = (sx & 7) / font->bpp; - if ((byte = f->bitmap[(sy * gbpr) + (sx >> 3)] & masks[si])) - /* - * No shifting of the byte is needed because the x offset - * is the same for both glyphs. - */ - g->bitmap[(dy * fbpr) + (sx >> 3)] |= byte; - } - } - - /* - * Now swap the two glyphs while preserving the name and encoding of - * the first glyph. - */ - tmp.swidth = g->swidth; - tmp.dwidth = g->dwidth; - tmp.bytes = g->bytes; - tmp.bitmap = g->bitmap; - (void) memcpy((char *) &tmp.bbx, (char *) &g->bbx, sizeof(bdf_bbx_t)); - - g->swidth = f->swidth; - g->dwidth = f->dwidth; - g->bytes = f->bytes; - g->bitmap = f->bitmap; - (void) memcpy((char *) &g->bbx, (char *) &f->bbx, sizeof(bdf_bbx_t)); - - f->swidth = tmp.swidth; - f->dwidth = tmp.dwidth; - f->bytes = tmp.bytes; - f->bitmap = tmp.bitmap; - (void) memcpy((char *) &f->bbx, (char *) &tmp.bbx, sizeof(bdf_bbx_t)); - } else { - /* - * Need a new bitmap for the combination of the two. - */ - tmp.bytes = nbbx.height * dbpr; - tmp.bitmap = (unsigned char *) malloc(tmp.bytes); - (void) memset((char *) tmp.bitmap, 0, tmp.bytes); - - /* - * Merge the first glyph. - */ - dy = nbbx.ascent - f->bbx.ascent; - for (sy = 0; sy < f->bbx.height; sy++, dy++) { - dx = MYABS(nbbx.x_offset - f->bbx.x_offset) * font->bpp; - for (x = sx = 0; x < f->bbx.width; x++, - sx += font->bpp, dx += font->bpp) { - si = (sx & 7) / font->bpp; - if ((byte = f->bitmap[(sy * fbpr) + (sx >> 3)] & masks[si])) { - di = (dx & 7) / font->bpp; - if (di < si) - byte <<= (si - di) * font->bpp; - else if (di > si) - byte >>= (di - si) * font->bpp; - tmp.bitmap[(dy * dbpr) + (dx >> 3)] |= byte; - } - } - } - - /* - * Merge the second glyph. - */ - dy = nbbx.ascent - g->bbx.ascent; - for (sy = 0; sy < g->bbx.height; sy++, dy++) { - dx = MYABS(nbbx.x_offset - g->bbx.x_offset) * font->bpp; - for (x = sx = 0; x < g->bbx.width; x++, - sx += font->bpp, dx += font->bpp) { - si = (sx & 7) / font->bpp; - if ((byte = g->bitmap[(sy * gbpr) + (sx >> 3)] & masks[si])) { - di = (dx & 7) / font->bpp; - if (di < si) - byte <<= (si - di) * font->bpp; - else if (di > si) - byte >>= (di - si) * font->bpp; - tmp.bitmap[(dy * dbpr) + (dx >> 3)] |= byte; - } - } - } - - /* - * Now clear the font glyph and copy the temp glyph to it. - */ - if (f->bytes > 0) - free((char *) f->bitmap); - f->bytes = tmp.bytes; - f->bitmap = tmp.bitmap; - (void) memcpy((char *) &f->bbx, (char *) &nbbx, sizeof(bdf_bbx_t)); - - /* - * Set the device width. Pay attention to whether the font is - * monowidth or character cell. - */ - if (font->spacing != BDF_PROPORTIONAL) - f->dwidth = font->monowidth; - else - f->dwidth = MAX(f->dwidth, g->dwidth); - } -} - -int -#ifdef __STDC__ -bdf_merge_glyphs(bdf_font_t *font, long start, bdf_glyphlist_t *glyphs, - int unencoded) -#else -bdf_merge_glyphs(font, start, glyphs, unencoded) -bdf_font_t *font; -long start; -bdf_glyphlist_t *glyphs; -int unencoded; -#endif -{ - int resize; - long i, n, ng, end, add, enc, off; - bdf_glyph_t *sgp, *gp, *dgp, *base; - short maxas, maxds, maxrb, minlb, maxlb, rb; - double ps, rx, dw; - bdf_bbx_t nbbx; - - resize = 0; - - if (font == 0) - return resize; - - /* - * If the glyphs are being merged in the unencoded area, simply append - * them. The unencoded area is simply storage. - */ - if (unencoded) - return bdf_replace_glyphs(font, font->unencoded_used, glyphs, unencoded); - - /* - * Dither the incoming bitmaps so they match the same bits per pixel as - * the font. - */ - if (glyphs->bpp != font->bpp) { - if (glyphs->bpp == 1) - _bdf_one_to_n(glyphs, font->bpp); - else if (font->bpp == 1) - _bdf_n_to_one(glyphs); - else if (glyphs->bpp == 2) - _bdf_two_to_four(glyphs); - else - _bdf_four_to_two(glyphs); - } - - /* - * Set the point size and horizontal resolution so the scalable width can - * be determined. - */ - ps = (double) font->point_size; - rx = (double) font->resolution_x; - - /* - * Determine if a resize is needed. - */ - - /* - * Determine the bounding box for the font without the characters being - * replaced. - */ - minlb = 32767; - maxlb = maxrb = maxas = maxds = 0; - - /* - * Get the font bounds. - */ - maxas = MAX(font->bbx.ascent, maxas); - maxds = MAX(font->bbx.descent, maxds); - rb = font->bbx.width + font->bbx.x_offset; - maxrb = MAX(rb, maxrb); - minlb = MIN(font->bbx.x_offset, minlb); - maxlb = MAX(font->bbx.x_offset, maxlb); - - /* - * Get the bounds of the incoming glyphs. - */ - maxas = MAX(glyphs->bbx.ascent, maxas); - maxds = MAX(glyphs->bbx.descent, maxds); - rb = glyphs->bbx.width + glyphs->bbx.x_offset; - maxrb = MAX(rb, maxrb); - minlb = MIN(glyphs->bbx.x_offset, minlb); - maxlb = MAX(glyphs->bbx.x_offset, maxlb); - - /* - * Set up the new font bounding box, minus the characters that are being - * removed and with the new characters added. - */ - nbbx.width = maxrb - minlb; - nbbx.x_offset = minlb; - - nbbx.height = maxas + maxds; - nbbx.ascent = maxas; - nbbx.descent = maxds; - nbbx.y_offset = -maxds; - - /* - * Now determine if the combination of the glyphs removed and the new - * glyphs cause the font bounding box to be changed. - */ - resize = (nbbx.width > font->bbx.width || - nbbx.height > font->bbx.height) ? 1 : 0; - - /* - * Set the pointers to the glyphs. - */ - ng = (unencoded == 0) ? font->glyphs_used : font->unencoded_used; - gp = (unencoded == 0) ? font->glyphs : font->unencoded; - - /* - * Locate the closest glyph on or following `start'. - */ - for (i = 0; i < ng && gp->encoding < start; i++, gp++) ; - - if (i == ng) - /* - * If the gylphs are being added off the end of the list, simply insert - * them so any overflows can be handled. - */ - return bdf_insert_glyphs(font, start, glyphs); - - /* - * Set the starting point for copying the incoming glyphs. - */ - dgp = gp; - - n = glyphs->end - glyphs->start; - end = start + n; - - /* - * Count the number of glyphs that will be added and mark all the - * glyphs that will be modified. - */ - for (sgp = glyphs->glyphs, add = 0, i = start; i <= end; i++) { - enc = (sgp->encoding - glyphs->start) + start; - - /* - * Mark the glyph as being modified. - */ - if (unencoded == 0) - _bdf_set_glyph_modified(font->nmod, enc); - else - _bdf_set_glyph_modified(font->umod, enc); - - if (enc == gp->encoding) - sgp++; - else if (enc < gp->encoding) { - add++; - sgp++; - } - - if (gp->encoding == i) - gp++; - } - - if (add > 0) { - ng += add; - - /* - * Need to make room for some glyphs that will be added. - */ - if (unencoded) { - off = dgp - font->unencoded; - if (font->unencoded_used == 0) - font->unencoded = - (bdf_glyph_t *) malloc(sizeof(bdf_glyph_t) * ng); - else - font->unencoded = - (bdf_glyph_t *) realloc((char *) font->unencoded, - sizeof(bdf_glyph_t) * ng); - dgp = font->unencoded + off; - font->unencoded_used = ng; - } else { - off = dgp - font->glyphs; - if (font->glyphs_used == 0) - font->glyphs = - (bdf_glyph_t *) malloc(sizeof(bdf_glyph_t) * ng); - else - font->glyphs = - (bdf_glyph_t *) realloc((char *) font->glyphs, - sizeof(bdf_glyph_t) * ng); - dgp = font->glyphs + off; - font->glyphs_used = ng; - } - } - - /* - * Now go through and do two things: - * 1. Insert new incoming glyphs. - * 2. Combine two glyphs at the same location. - */ - base = (!unencoded) ? font->glyphs : font->unencoded; - for (gp = dgp, sgp = glyphs->glyphs, i = start; i <= end; i++) { - enc = (sgp->encoding - glyphs->start) + start; - if (enc < gp->encoding) { - /* - * Shift the glyphs up by one and add this one. - */ - if (gp - base < ng) - _bdf_memmove((char *)(gp + 1), (char *) gp, - sizeof(bdf_glyph_t) * (ng - (gp - base))); - (void) memcpy((char *) gp, (char *) sgp, sizeof(bdf_glyph_t)); - gp->name = (char *) _bdf_strdup((unsigned char *) gp->name, - strlen(gp->name) + 1); - if (gp->bytes > 0) - gp->bitmap = _bdf_strdup(gp->bitmap, gp->bytes); - gp->encoding = i; - sgp++; - dw = (double) gp->dwidth; - gp->swidth = (unsigned short)((dw * 72000.0) / (ps * rx)); - } else if (enc == gp->encoding) { - _bdf_combine_glyphs(font, gp, sgp); - dw = (double) gp->dwidth; - gp->swidth = (unsigned short)((dw * 72000.0) / (ps * rx)); - sgp++; - } - if (gp->encoding == i) - gp++; - } - - if (resize) - (void) memcpy((char *) &font->bbx, (char *) &nbbx, sizeof(bdf_bbx_t)); - - font->modified = 1; - - return resize; -} - -void -#ifdef __STDC__ -bdf_set_modified(bdf_font_t *font, int modified) -#else -bdf_set_modified(font, modified) -bdf_font_t *font; -int modified; -#endif -{ - if (font == 0 || font->modified == modified) - return; - - if (modified == 0) { - /* - * Clear out the modified bitmaps. - */ - (void) memset((char *) font->nmod, 0, sizeof(unsigned long) * 2048); - (void) memset((char *) font->umod, 0, sizeof(unsigned long) * 2048); - } - font->modified = modified; -} - -/************************************************************************** - * - * XLFD font name functions. - * - **************************************************************************/ - -static char *xlfdfields[] = { - "FOUNDRY", - "FAMILY_NAME", - "WEIGHT_NAME", - "SLANT", - "SETWIDTH_NAME", - "ADD_STYLE_NAME", - "PIXEL_SIZE", - "POINT_SIZE", - "RESOLUTION_X", - "RESOLUTION_Y", - "SPACING", - "AVERAGE_WIDTH", - "CHARSET_REGISTRY", - "CHARSET_ENCODING", -}; - -int -#ifdef __STDC__ -bdf_has_xlfd_name(bdf_font_t *font) -#else -bdf_has_xlfd_name(font) -bdf_font_t *font; -#endif -{ - unsigned long len; - char name[256]; - _bdf_list_t list; - - if (font == 0 || font->name == 0 || font->name[0] == 0) - return 0; - - len = (unsigned long)(strlen(font->name) + 1); - (void) memcpy(name, font->name, len); - list.size = list.used = 0; - _bdf_split("-", name, len, &list); - if (list.size > 0) - free((char *) list.field); - - return (list.used == 15); -} - -char * -#ifdef __STDC__ -bdf_make_xlfd_name(bdf_font_t *font, char *foundry, char *family) -#else -bdf_make_xlfd_name(font, foundry, family) -bdf_font_t *font; -char *foundry, *family; -#endif -{ - int len; - double dp, dr; - unsigned long i, width, used; - unsigned short awidth, pxsize; - bdf_property_t *pp; - bdf_glyph_t *gp; - char spacing, nbuf[256], *np, *name; - const char *val; - - if (font == 0 || bdf_has_xlfd_name(font)) - return 0; - - np = nbuf; - - /* - * Add the FOUNDRY field. - */ - if ((pp = bdf_get_font_property(font, "FOUNDRY")) != 0) - foundry = pp->value.atom; - sprintf(np, "-%s", foundry); - np += strlen(np); - - /* - * Add the FAMILY_NAME field. - */ - if ((pp = bdf_get_font_property(font, "FAMILY_NAME")) != 0) - family = pp->value.atom; - sprintf(np, "-%s", family); - np += strlen(np); - - /* - * Add the WEIGHT_NAME field. - */ - val = ((pp = bdf_get_font_property(font, "WEIGHT_NAME")) != 0) ? - pp->value.atom : "Medium"; - if (val == 0) - val = "Medium"; - sprintf(np, "-%s", val); - np += strlen(np); - - /* - * Add the SLANT field. - */ - val = ((pp = bdf_get_font_property(font, "SLANT")) != 0) ? - pp->value.atom : "R"; - if (val == 0) - val = "R"; - sprintf(np, "-%s", val); - np += strlen(np); - - /* - * Add the SETWIDTH_NAME field. - */ - val = ((pp = bdf_get_font_property(font, "SETWIDTH_NAME")) != 0) ? - pp->value.atom : "Normal"; - if (val == 0) - val = "Normal"; - sprintf(np, "-%s", val); - np += strlen(np); - - /* - * Add the ADD_STYLE_NAME field. - */ - val = ((pp = bdf_get_font_property(font, "ADD_STYLE_NAME")) != 0) ? - pp->value.atom : ""; - if (val == 0) - val = ""; - sprintf(np, "-%s", val); - np += strlen(np); - - /* - * Add the PIXEL_SIZE field. - */ - if ((pp = bdf_get_font_property(font, "PIXEL_SIZE")) != 0) - sprintf(np, "-%ld", pp->value.int32); - else { - /* - * Determine the pixel size. - */ - dp = (double)(font->point_size * 10); - dr = (double) font->resolution_y; - pxsize = (unsigned short)(((dp * dr) / 722.7) + 0.5); - sprintf(np, "-%hd", pxsize); - } - np += strlen(np); - - /* - * Add the POINT_SIZE field. - */ - if ((pp = bdf_get_font_property(font, "POINT_SIZE")) != 0) - sprintf(np, "-%ld", pp->value.int32); - else - sprintf(np, "-%ld", font->point_size * 10); - np += strlen(np); - - /* - * Add the RESOLUTION_X field. - */ - if ((pp = bdf_get_font_property(font, "RESOLUTION_X")) != 0) - sprintf(np, "-%ld", pp->value.card32); - else - sprintf(np, "-%ld", font->resolution_x); - np += strlen(np); - - /* - * Add the RESOLUTION_Y field. - */ - if ((pp = bdf_get_font_property(font, "RESOLUTION_Y")) != 0) - sprintf(np, "-%ld", pp->value.card32); - else - sprintf(np, "-%ld", font->resolution_y); - np += strlen(np); - - /* - * Add the SPACING field. - */ - if ((pp = bdf_get_font_property(font, "SPACING")) != 0) - spacing = pp->value.atom[0]; - else { - spacing = 'P'; - switch (font->spacing) { - case BDF_PROPORTIONAL: - spacing = 'P'; - break; - case BDF_MONOWIDTH: - spacing = 'M'; - break; - case BDF_CHARCELL: - spacing = 'C'; - break; - } - } - sprintf(np, "-%c", spacing); - np += strlen(np); - - /* - * Add the AVERAGE_WIDTH field. - */ - if ((pp = bdf_get_font_property(font, "AVERAGE_WIDTH")) != 0) - sprintf(np, "-%ld", pp->value.int32); - else { - /* - * Determine the average width of all the glyphs in the font. - */ - width = 0; - for (i = 0, gp = font->unencoded; i < font->unencoded_used; i++, gp++) - width += gp->dwidth; - for (i = 0, gp = font->glyphs; i < font->glyphs_used; i++, gp++) - width += gp->dwidth; - - used = font->unencoded_used + font->glyphs_used; - if (used == 0) - awidth = font->bbx.width * 10; - else - awidth = (unsigned short)((((float) width) / - ((float) used)) * 10.0); - sprintf(np, "-%hd", awidth); - } - np += strlen(np); - - /* - * Add the CHARSET_REGISTRY field. - */ - val = ((pp = bdf_get_font_property(font, "CHARSET_REGISTRY")) != 0) ? - pp->value.atom : "FontSpecific"; - sprintf(np, "-%s", val); - np += strlen(np); - - /* - * Add the CHARSET_ENCODING field. - */ - val = ((pp = bdf_get_font_property(font, "CHARSET_ENCODING")) != 0) ? - pp->value.atom : "0"; - sprintf(np, "-%s", val); - np += strlen(np); - - len = (np - nbuf) + 1; - name = (char *) malloc(len); - (void) memcpy(name, nbuf, len); - return name; -} - -void -#ifdef __STDC__ -bdf_update_name_from_properties(bdf_font_t *font) -#else -bdf_update_name_from_properties(font) -bdf_font_t *font; -#endif -{ - unsigned long i; - bdf_property_t *p; - _bdf_list_t list; - char *np, name[128], nname[128]; - - if (font == 0 || bdf_has_xlfd_name(font) == 0) - return; - - (void) memset((char *) &list, 0, sizeof(_bdf_list_t)); - - /* - * Split the name into fields and shift out the first empty field. - * This assumes that the font has a name. - */ - i = (unsigned long) strlen(font->name); - (void) memcpy(name, font->name, i + 1); - _bdf_split("-", name, i, &list); - _bdf_shift(1, &list); - - /* - * Initialize the pointer to the new name and add the '-' prefix. - */ - np = nname; - *np++ = '-'; - *np = 0; - - for (i = 0; i < 14; i++) { - if ((p = bdf_get_font_property(font, xlfdfields[i])) != 0) { - /* - * The property exists, so add it to the new font name. - */ - switch (p->format) { - case BDF_ATOM: - if (p->value.atom != 0) - sprintf(np, "%s", p->value.atom); - break; - case BDF_CARDINAL: - sprintf(np, "%ld", p->value.card32); - break; - case BDF_INTEGER: - sprintf(np, "%ld", p->value.int32); - break; - } - } else - /* - * The property does not exist, so add the original value to the - * new font name. - */ - sprintf(np, "%s", list.field[i]); - np += strlen(np); - if (i + 1 < 14) { - *np++ = '-'; - *np = 0; - } - } - - /* - * Replace the existing font name with the new one. - */ - free(font->name); - i = (unsigned long)(strlen(nname) + 1); - font->name = (char *) malloc(i); - (void) memcpy(font->name, nname, i); - - /* - * Free up the list. - */ - if (list.size > 0) - free((char *) list.field); - - font->modified = 1; -} - -void -#ifdef __STDC__ -bdf_update_properties_from_name(bdf_font_t *font) -#else -bdf_update_properties_from_name(font) -bdf_font_t *font; -#endif -{ - unsigned long i; - bdf_property_t *p, prop; - _bdf_list_t list; - char name[128]; - - if (font == 0 || font->name == 0 || bdf_has_xlfd_name(font) == 0) - return; - - (void) memset((char *) &list, 0, sizeof(_bdf_list_t)); - - /* - * Split the name into fields and shift out the first empty field. - */ - i = (unsigned long) strlen(font->name); - (void) memcpy(name, font->name, i + 1); - _bdf_split("-", name, i, &list); - _bdf_shift(1, &list); - - for (i = 0; i < 14; i++) { - p = bdf_get_property(xlfdfields[i]); - prop.name = p->name; - prop.format = p->format; - switch (prop.format) { - case BDF_ATOM: - prop.value.atom = list.field[i]; - break; - case BDF_CARDINAL: - prop.value.card32 = _bdf_atoul(list.field[i], 0, 10); - break; - case BDF_INTEGER: - prop.value.int32 = _bdf_atol(list.field[i], 0, 10); - break; - } - bdf_add_font_property(font, &prop); - } - - /* - * Free up the list. - */ - if (list.size > 0) - free((char *) list.field); - - font->modified = 1; -} - -int -#ifdef __STDC__ -bdf_update_average_width(bdf_font_t *font) -#else -bdf_update_average_width(font) -bdf_font_t *font; -#endif -{ - int changed; - unsigned long i; - long oaw, awidth, used; - bdf_glyph_t *gp; - _bdf_list_t list; - bdf_property_t *pp, prop; - char *np, num[16], nbuf[128]; - - changed = 0; - - used = font->unencoded_used + font->glyphs_used; - if (used == 0) - awidth = font->bbx.width * 10; - else { - for (i = 0, awidth = 0, gp = font->unencoded; i < font->unencoded_used; - i++, gp++) - awidth += gp->dwidth; - for (i = 0, gp = font->glyphs; i < font->glyphs_used; i++, gp++) - awidth += gp->dwidth; - awidth = (long)((((double) awidth) / ((double) used)) * 10.0); - } - - /* - * Check to see if it is different than the average width in the font - * name. - */ - if (bdf_has_xlfd_name(font)) { - (void) memset((char *) &list, 0, sizeof(_bdf_list_t)); - i = (unsigned long) strlen(font->name); - (void) memcpy(nbuf, font->name, i + 1); - _bdf_split("-", nbuf, i, &list); - oaw = _bdf_atol(list.field[12], 0, 10); - if (oaw != awidth) { - /* - * Construct a new font name with the new average width. - */ - changed = 1; - sprintf(num, "%ld", awidth); - used = strlen(num) - strlen(list.field[12]); - if (used > 0) { - /* - * Resize the string used for the font name instead of - * creating a new one. - */ - used += i; - font->name = (char *) realloc(font->name, used); - } - - /* - * Copy the elements of the list back into the new font name. - */ - np = font->name; - *np++ = '-'; - for (i = 1; i < list.used; i++) { - if (i == 12) - strcpy(np, num); - else - strcpy(np, list.field[i]); - np += strlen(np); - if (i + 1 < list.used) - *np++ = '-'; - } - } - - /* - * Clear up any space allocated for the list. - */ - if (list.size > 0) - free((char *) list.field); - } - - /* - * Now check for the AVERAGE_WIDTH property. - */ - if ((pp = bdf_get_font_property(font, "AVERAGE_WIDTH")) != 0) { - if (pp->value.int32 != awidth) { - changed = 1; - pp->value.int32 = awidth; - } - } else { - /* - * Property doesn't exist yet, so add it. - */ - changed = 1; - prop.name = "AVERAGE_WIDTH"; - prop.format = BDF_INTEGER; - prop.value.int32 = awidth; - bdf_add_font_property(font, &prop); - } - - if (changed) - font->modified = 1; - - return changed; -} - -/* - * Change the font bounding box and return a non-zero number if this causes - * the font to get larger or smaller. - */ -int -#ifdef __STDC__ -bdf_set_font_bbx(bdf_font_t *font, bdf_metrics_t *metrics) -#else -bdf_set_font_bbx(font, metrics) -bdf_font_t *font; -bdf_metrics_t *metrics; -#endif -{ - int resize; - - resize = 0; - - if (font == 0 || metrics == 0) - return resize; - - resize = (font->bbx.width != metrics->width || - font->bbx.height != metrics->height) ? 1 : 0; - - font->bbx.width = metrics->width; - font->bbx.height = metrics->height; - font->bbx.x_offset = metrics->x_offset; - font->bbx.y_offset = metrics->y_offset; - font->bbx.ascent = metrics->ascent; - font->bbx.descent = metrics->descent; - - /* - * If the font is not proportional, then make sure the monowidth field is - * set to the font bounding box. - */ - if (font->spacing != BDF_PROPORTIONAL) - font->monowidth = font->bbx.width; - - return resize; -} - -static bdf_glyph_t * -#ifdef __STDC__ -_bdf_locate_glyph(bdf_font_t *font, long code, int unencoded) -#else -_bdf_locate_glyph(font, code, unencoded) -bdf_font_t *font; -long code; -int unencoded; -#endif -{ - long l, r, m, nc; - bdf_glyph_t *gl; - - if (code < 0 || font == 0) - return 0; - - if ((unencoded && font->unencoded_used == 0) || - font->glyphs_used == 0) - return 0; - - if (unencoded) { - gl = font->unencoded; - nc = font->unencoded_used; - } else { - gl = font->glyphs; - nc = font->glyphs_used; - } - for (l = m = 0, r = nc - 1; l < r;) { - m = (l + r) >> 1; - if (gl[m].encoding < code) - l = m + 1; - else if (gl[m].encoding > code) - r = m - 1; - else - break; - } - - /* - * Go back until we hit the beginning of the glyphs or until - * we find the glyph with a code less than the specified code. - */ - while (m > 0 && gl[m].encoding > code) - m--; - - /* - * Look forward if necessary. - */ - while (m < nc && gl[m].encoding < code) - m++; - - return (m < nc) ? &gl[m] : &gl[nc - 1]; -} - -int -#ifdef __STDC__ -bdf_translate_glyphs(bdf_font_t *font, short dx, short dy, long start, - long end, bdf_callback_t callback, void *data, - int unencoded) -#else -bdf_translate_glyphs(font, dx, dy, start, end, callback, data, unencoded) -bdf_font_t *font; -short dx, dy; -long start, end; -bdf_callback_t callback; -void *data; -int unencoded; -#endif -{ - int resize, diff; - bdf_glyph_t *gp, *sp, *ep; - bdf_callback_struct_t cb; - - if (font == 0 || (dx == 0 && dy == 0)) - return 0; - - if ((unencoded && font->unencoded_used == 0) || font->glyphs_used == 0) - return 0; - - /* - * Call the progress initialization callback. - */ - if (callback != 0) { - cb.reason = BDF_TRANSLATE_START; - cb.total = (end - start) + 1; - cb.current = 0; - (*callback)(&cb, data); - } - - /* - * Locate the first and last glyphs to be shifted. - */ - sp = _bdf_locate_glyph(font, start, unencoded); - ep = _bdf_locate_glyph(font, end, unencoded); - for (resize = 0, gp = sp; sp <= ep; sp++) { - /* - * Call the callback if one was provided. - */ - if (sp != gp && callback != 0) { - cb.reason = BDF_TRANSLATING; - cb.current = (sp->encoding - start) + 1; - (*callback)(&cb, data); - } - - /* - * Apply the X translation. - */ - if (dx != 0) { - sp->bbx.x_offset += dx; - diff = sp->bbx.x_offset - font->bbx.x_offset; - if (sp->bbx.x_offset < font->bbx.x_offset) { - font->bbx.x_offset = sp->bbx.x_offset; - font->bbx.width += MYABS(diff); - resize = 1; - } else if (sp->bbx.width + sp->bbx.x_offset > - font->bbx.width + font->bbx.x_offset) { - font->bbx.width += MYABS(diff); - resize = 1; - } - - /* - * Mark the glyph as modified appropriately. - */ - if (unencoded) - _bdf_set_glyph_modified(font->umod, sp->encoding); - else - _bdf_set_glyph_modified(font->nmod, sp->encoding); - } - - /* - * Apply the Y translation. - */ - if (dy != 0) { - sp->bbx.y_offset += dy; - sp->bbx.descent = -sp->bbx.y_offset; - sp->bbx.ascent = sp->bbx.height - sp->bbx.descent; - diff = sp->bbx.y_offset - font->bbx.y_offset; - if (sp->bbx.y_offset < font->bbx.y_offset) { - font->bbx.y_offset = sp->bbx.y_offset; - font->bbx.descent = -font->bbx.y_offset; - font->bbx.height += MYABS(diff); - resize = 1; - } else if (sp->bbx.ascent > font->bbx.ascent) { - font->bbx.ascent += MYABS(diff); - font->bbx.height += MYABS(diff); - resize = 1; - } - - /* - * Mark the glyph as modified appropriately. - */ - if (unencoded) - _bdf_set_glyph_modified(font->umod, sp->encoding); - else - _bdf_set_glyph_modified(font->nmod, sp->encoding); - } - } - - /* - * Call the callback one more time to make sure the client knows - * this is done. - */ - if (callback != 0 && cb.current < cb.total) { - cb.reason = BDF_TRANSLATING; - cb.current = cb.total; - (*callback)(&cb, data); - } - - if (resize) - font->modified = 1; - - return resize; -} - -static void -#ifdef __STDC__ -_bdf_resize_rotation(bdf_font_t *font, int mul90, short degrees, - bdf_glyph_t *glyph, bdf_bitmap_t *scratch, - unsigned short *width, unsigned short *height) -#else -_bdf_resize_rotation(font, mul90, degrees, glyph, scratch, width, height) -bdf_font_t *font; -int mul90; -short degrees; -bdf_glyph_t *glyph; -bdf_bitmap_t *scratch; -unsigned short *width, *height; -#endif -{ - unsigned short w, h, wd, ht, bytes; - short cx, cy, x1, y1, x2, y2; - double dx1, dy1, dx2, dy2; - - w = h = 0; - - cx = glyph->bbx.width >> 1; - cy = glyph->bbx.height >> 1; - - /* - * Rotate the lower left and upper right corners and check for a potential - * resize. - */ - x1 = 0; - y1 = glyph->bbx.height; - x2 = glyph->bbx.width; - y2 = 0; - - dx1 = (double)(x1 - cx); - dy1 = (double)(y1 - cy); - dx2 = (double)(x2 - cx); - dy2 = (double)(y2 - cx); - - if (mul90) { - x1 = cx + (short)((dx1 * _bdf_cos_tbl[degrees]) - - (dy1 * _bdf_sin_tbl[degrees])); - y1 = cy + (short)((dx1 * _bdf_sin_tbl[degrees]) + - (dy1 * _bdf_cos_tbl[degrees])); - x2 = cx + (short)((dx2 * _bdf_cos_tbl[degrees]) - - (dy2 * _bdf_sin_tbl[degrees])); - y2 = cy + (short)((dx2 * _bdf_sin_tbl[degrees]) + - (dy2 * _bdf_cos_tbl[degrees])); - } else { - x1 = cx + _bdf_ceiling((dx1 * _bdf_cos_tbl[degrees]) - - (dy1 * _bdf_sin_tbl[degrees])); - y1 = cy + _bdf_ceiling((dx1 * _bdf_sin_tbl[degrees]) + - (dy1 * _bdf_cos_tbl[degrees])); - x2 = cx + _bdf_ceiling((dx2 * _bdf_cos_tbl[degrees]) - - (dy2 * _bdf_sin_tbl[degrees])); - y2 = cy + _bdf_ceiling((dx2 * _bdf_sin_tbl[degrees]) + - (dy2 * _bdf_cos_tbl[degrees])); - } - - wd = MYABS(x2 - x1); - ht = MYABS(y2 - y1); - - w = MAX(wd, w); - h = MAX(ht, h); - - if (wd > font->bbx.width) - font->bbx.width += wd - font->bbx.width; - if (ht > font->bbx.height) { - font->bbx.ascent += ht - font->bbx.height; - font->bbx.height += ht - font->bbx.height; - } - - /* - * Rotate the upper left and lower right corners and check for a potential - * resize. - */ - x1 = 0; - y1 = 0; - x2 = glyph->bbx.width; - y2 = glyph->bbx.height; - - dx1 = (double)(x1 - cx); - dy1 = (double)(y1 - cy); - dx2 = (double)(x2 - cx); - dy2 = (double)(y2 - cx); - - if (mul90) { - x1 = cx + (short)((dx1 * _bdf_cos_tbl[degrees]) - - (dy1 * _bdf_sin_tbl[degrees])); - y1 = cy + (short)((dx1 * _bdf_sin_tbl[degrees]) + - (dy1 * _bdf_cos_tbl[degrees])); - x2 = cx + (short)((dx2 * _bdf_cos_tbl[degrees]) - - (dy2 * _bdf_sin_tbl[degrees])); - y2 = cy + (short)((dx2 * _bdf_sin_tbl[degrees]) + - (dy2 * _bdf_cos_tbl[degrees])); - } else { - x1 = cx + _bdf_ceiling((dx1 * _bdf_cos_tbl[degrees]) - - (dy1 * _bdf_sin_tbl[degrees])); - y1 = cy + _bdf_ceiling((dx1 * _bdf_sin_tbl[degrees]) + - (dy1 * _bdf_cos_tbl[degrees])); - x2 = cx + _bdf_ceiling((dx2 * _bdf_cos_tbl[degrees]) - - (dy2 * _bdf_sin_tbl[degrees])); - y2 = cy + _bdf_ceiling((dx2 * _bdf_sin_tbl[degrees]) + - (dy2 * _bdf_cos_tbl[degrees])); - } - - wd = MYABS(x2 - x1); - ht = MYABS(y2 - y1); - - w = MAX(wd, w); - h = MAX(ht, h); - - if (wd > font->bbx.width) - font->bbx.width += wd - font->bbx.width; - if (ht > font->bbx.height) { - font->bbx.ascent += ht - font->bbx.height; - font->bbx.height += ht - font->bbx.height; - } - - if (font->bbx.width > scratch->width || - font->bbx.height > scratch->height) { - scratch->width = MAX(font->bbx.width, scratch->width); - scratch->height = MAX(font->bbx.height, scratch->height); - bytes = (((font->bbx.width * font->bpp) + 7) >> 3) * font->bbx.height; - if (scratch->bytes == 0) - scratch->bitmap = (unsigned char *) malloc(bytes); - else - scratch->bitmap = (unsigned char *) - realloc((char *) scratch->bitmap, bytes); - scratch->bytes = bytes; - } - - /* - * Clear the bitmap. - */ - (void) memset((char *) scratch->bitmap, 0, scratch->bytes); - - /* - * Return the new glyph width and height. - */ - *width = w; - *height = h; -} - -int -#ifdef __STDC__ -bdf_rotate_glyphs(bdf_font_t *font, short degrees, long start, - long end, bdf_callback_t callback, void *data, - int unencoded) -#else -bdf_rotate_glyphs(font, degrees, start, end, callback, data, unencoded) -bdf_font_t *font; -short degrees; -long start, end; -bdf_callback_t callback; -void *data; -int unencoded; -#endif -{ - int mul90, bpr, sbpr; - unsigned short wd, ht, si, di, byte, col; - short x, y, cx, cy, nx, ny, ox, oy, shiftx, shifty; - bdf_glyph_t *gp, *sp, *ep; - unsigned char *masks; - double dx, dy; - bdf_bitmap_t scratch; - bdf_callback_struct_t cb; - - if (font == 0 || (unencoded && font->unencoded_used == 0) || - font->glyphs_used == 0) - return 0; - - while (degrees < 0) - degrees += 360; - while (degrees >= 360) - degrees -= 360; - - if (degrees == 0) - return 0; - - mul90 = ((degrees % 90) == 0) ? 1 : 0; - - masks = 0; - switch (font->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - /* - * Initialize the scratch bitmap. - */ - (void) memset((char *) &scratch, 0, sizeof(bdf_bitmap_t)); - - /* - * Call the progress initialization callback. - */ - if (callback != 0) { - cb.reason = BDF_ROTATE_START; - cb.total = (end - start) + 1; - cb.current = 0; - (*callback)(&cb, data); - } - - sp = _bdf_locate_glyph(font, start, unencoded); - ep = _bdf_locate_glyph(font, end, unencoded); - for (gp = sp; sp <= ep; sp++) { - /* - * Call the callback if one was provided. - */ - if (sp != gp && callback != 0) { - cb.reason = BDF_ROTATING; - cb.current = (sp->encoding - start) + 1; - (*callback)(&cb, data); - } - - /* - * Resize the bitmap, adjust the font bounding box, and get the new - * glyph width and height. - */ - _bdf_resize_rotation(font, mul90, degrees, sp, &scratch, &wd, &ht); - - cx = sp->bbx.width >> 1; - cy = sp->bbx.height >> 1; - - shiftx = shifty = 0; - sbpr = ((wd * font->bpp) + 7) >> 3; - bpr = ((sp->bbx.width * font->bpp) + 7) >> 3; - for (y = 0; y < sp->bbx.height; y++) { - for (col = x = 0; x < sp->bbx.width; x++, col += font->bpp) { - si = (col & 7) / font->bpp; - byte = sp->bitmap[(y * bpr) + (col >> 3)] & masks[si]; - if (byte) { - dx = (double)(x - cx); - dy = (double)(y - cy); - if (mul90) { - nx = cx + (short)((dx * _bdf_cos_tbl[degrees]) - - (dy * _bdf_sin_tbl[degrees])); - ny = cy + (short)((dx * _bdf_sin_tbl[degrees]) + - (dy * _bdf_cos_tbl[degrees])); - } else { - nx = cx + _bdf_ceiling((dx * _bdf_cos_tbl[degrees]) - - (dy * _bdf_sin_tbl[degrees])); - ny = cy + _bdf_ceiling((dx * _bdf_sin_tbl[degrees]) + - (dy * _bdf_cos_tbl[degrees])); - } - if (nx < 0) { - shiftx = MIN(shiftx, nx); - nx += wd; - } else if (nx >= wd) { - ox = (nx - wd) + 1; - shiftx = MAX(shiftx, ox); - nx -= wd; - } - if (ny < 0) { - shifty = MIN(shifty, ny); - ny += ht; - } else if (ny >= ht) { - oy = (ny - ht) + 1; - shifty = MAX(shifty, oy); - ny -= ht; - } - nx *= font->bpp; - di = (nx & 7) / font->bpp; - if (di < si) - byte <<= (si - di) * font->bpp; - else if (di > si) - byte >>= (di - si) * font->bpp; - scratch.bitmap[(ny * sbpr) + (nx >> 3)] |= byte; - } - } - } - /* - * Resize the glyph bitmap if necessary. - */ - if (wd != sp->bbx.width || ht != sp->bbx.height) { - sp->bbx.width = wd; - sp->bbx.height = ht; - sp->bbx.ascent = ht - sp->bbx.descent; - sp->bytes = (((wd * font->bpp) + 7) >> 3) * ht; - sp->bitmap = (unsigned char *) - realloc((char *) sp->bitmap, sp->bytes); - } - (void) memset((char *) sp->bitmap, 0, sp->bytes); - - /* - * Copy the glyph from the scratch area to the glyph bitmap, - * adjusting for any shift values encountered. - */ - bpr = ((sp->bbx.width * font->bpp) + 7) >> 3; - for (y = 0; y < sp->bbx.height; y++) { - for (col = x = 0; x < sp->bbx.width; x++, col += font->bpp) { - si = (col & 7) / font->bpp; - byte = scratch.bitmap[(y * bpr) + (col >> 3)] & masks[si]; - if (byte) { - nx = x - shiftx; - ny = y - shifty; - if (nx < 0) - nx += sp->bbx.width; - else if (nx >= sp->bbx.width) - nx -= sp->bbx.width; - if (ny < 0) - ny += sp->bbx.height; - else if (ny >= sp->bbx.height) - ny -= sp->bbx.height; - nx *= font->bpp; - di = (nx & 7) / font->bpp; - if (di < si) - byte <<= (si - di) * font->bpp; - else if (di > si) - byte >>= (di - si) * font->bpp; - sp->bitmap[(ny * bpr) + (nx >> 3)] |= byte; - } - } - } - /* - * Mark the glyph as modified. - */ - if (unencoded) - _bdf_set_glyph_modified(font->umod, sp->encoding); - else - _bdf_set_glyph_modified(font->nmod, sp->encoding); - } - - /* - * Call the callback one more time to make sure the client knows - * this is done. - */ - if (callback != 0 && cb.current < cb.total) { - cb.reason = BDF_TRANSLATING; - cb.current = cb.total; - (*callback)(&cb, data); - } - - if (scratch.bytes > 0) - free((char *) scratch.bitmap); - - /* - * Rotations always change things, so just return a value indicating this. - */ - font->modified = 1; - return 1; -} - -static void -#ifdef __STDC__ -_bdf_resize_shear(bdf_font_t *font, int neg, short degrees, - bdf_glyph_t *glyph, bdf_bitmap_t *scratch, - unsigned short *width, unsigned short *height) -#else -_bdf_resize_shear(font, neg, degrees, glyph, scratch, width, height) -bdf_font_t *font; -int neg; -short degrees; -bdf_glyph_t *glyph; -bdf_bitmap_t *scratch; -unsigned short *width, *height; -#endif -{ - unsigned short wd, w, bytes; - short x1, y1, x2, y2; - - w = 0; - *height = glyph->bbx.height; - - /* - * Shear the lower left and upper right corners and check for a potential - * resize. - */ - x1 = 0; - y1 = glyph->bbx.height; - x2 = glyph->bbx.width; - y2 = 0; - - if (neg) { - x1 += (short)((double) y1 * _bdf_tan_tbl[degrees]); - x2 += (short)((double) y2 * _bdf_tan_tbl[degrees]); - } else { - x1 += (short)((double)(glyph->bbx.height - y1) * - _bdf_tan_tbl[degrees]); - x2 += (short)((double)(glyph->bbx.height - y2) * - _bdf_tan_tbl[degrees]); - } - - wd = MYABS(x2 - x1); - w = MAX(w, wd); - - if (wd > font->bbx.width) - font->bbx.width += wd - font->bbx.width; - - /* - * Shear the upper left and lower right corners and check for a potential - * resize. - */ - x1 = 0; - y1 = 0; - x2 = glyph->bbx.width; - y2 = glyph->bbx.height; - - if (neg) { - x1 += (short)((double) y1 * _bdf_tan_tbl[degrees]); - x2 += (short)((double) y2 * _bdf_tan_tbl[degrees]); - } else { - x1 += (short)((double)(glyph->bbx.height - y1) * - _bdf_tan_tbl[degrees]); - x2 += (short)((double)(glyph->bbx.height - y2) * - _bdf_tan_tbl[degrees]); - } - - wd = MYABS(x2 - x1); - w = MAX(w, wd); - - if (wd > font->bbx.width) - font->bbx.width += wd - font->bbx.width; - - if (font->bbx.width > scratch->width || - font->bbx.height > scratch->height) { - scratch->width = MAX(font->bbx.width, scratch->width); - scratch->height = MAX(font->bbx.height, scratch->height); - bytes = (((font->bbx.width * font->bpp) + 7) >> 3) * font->bbx.height; - if (scratch->bytes == 0) - scratch->bitmap = (unsigned char *) malloc(bytes); - else - scratch->bitmap = (unsigned char *) - realloc((char *) scratch->bitmap, bytes); - scratch->bytes = bytes; - } - - /* - * Clear the bitmap. - */ - (void) memset((char *) scratch->bitmap, 0, scratch->bytes); - - /* - * Return the new glyph width. - */ - *width = w; -} - -int -#ifdef __STDC__ -bdf_shear_glyphs(bdf_font_t *font, short degrees, long start, - long end, bdf_callback_t callback, void *data, - int unencoded) -#else -bdf_shear_glyphs(font, degrees, start, end, callback, data, unencoded) -bdf_font_t *font; -short degrees; -long start, end; -bdf_callback_t callback; -void *data; -int unencoded; -#endif -{ - int neg, bpr, sbpr; - unsigned short wd, ht, si, di, byte, col; - short x, y, nx, shiftx, ox; - bdf_glyph_t *gp, *sp, *ep; - unsigned char *masks; - bdf_bitmap_t scratch; - bdf_callback_struct_t cb; - - if (font == 0 || (unencoded && font->unencoded_used == 0) || - font->glyphs_used == 0) - return 0; - - if (degrees == 0 || degrees < -45 || degrees > 45) - return 0; - - if ((neg = (degrees < 0))) - degrees = -degrees; - - masks = 0; - switch (font->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - /* - * Initialize the scratch bitmap. - */ - (void) memset((char *) &scratch, 0, sizeof(bdf_bitmap_t)); - - /* - * Call the progress initialization callback. - */ - if (callback != 0) { - cb.reason = BDF_SHEAR_START; - cb.total = (end - start) + 1; - cb.current = 0; - (*callback)(&cb, data); - } - - sp = _bdf_locate_glyph(font, start, unencoded); - ep = _bdf_locate_glyph(font, end, unencoded); - for (gp = sp; sp <= ep; sp++) { - /* - * Call the callback if one was provided. - */ - if (sp != gp && callback != 0) { - cb.reason = BDF_SHEARING; - cb.current = (sp->encoding - start) + 1; - (*callback)(&cb, data); - } - - /* - * Resize the bitmap, adjust the font bounding box, and get the new - * glyph width and height. - */ - _bdf_resize_shear(font, neg, degrees, sp, &scratch, &wd, &ht); - - shiftx = 0; - sbpr = ((wd * font->bpp) + 7) >> 3; - bpr = ((sp->bbx.width * font->bpp) + 7) >> 3; - for (y = 0; y < sp->bbx.height; y++) { - for (col = x = 0; x < sp->bbx.width; x++, col += font->bpp) { - si = (col & 7) / font->bpp; - byte = sp->bitmap[(y * bpr) + (col >> 3)] & masks[si]; - if (byte) { - if (neg) - nx = x + (short)((double) y * _bdf_tan_tbl[degrees]); - else - nx = x + (short)((double)(sp->bbx.height - y) * - _bdf_tan_tbl[degrees]); - - if (nx < 0) { - shiftx = MIN(shiftx, nx); - nx += wd; - } else if (nx >= wd) { - ox = (nx - wd) + 1; - shiftx = MAX(shiftx, ox); - nx -= wd; - } - nx *= font->bpp; - di = (nx & 7) / font->bpp; - if (di < si) - byte <<= (si - di) * font->bpp; - else if (di > si) - byte >>= (di - si) * font->bpp; - scratch.bitmap[(y * sbpr) + (nx >> 3)] |= byte; - } - } - } - /* - * Resize the glyph bitmap if necessary. - */ - if (wd != sp->bbx.width || ht != sp->bbx.height) { - sp->bbx.width = wd; - sp->bbx.height = ht; - sp->bbx.ascent = ht - sp->bbx.descent; - sp->bytes = (((wd * font->bpp) + 7) >> 3) * ht; - sp->bitmap = (unsigned char *) - realloc((char *) sp->bitmap, sp->bytes); - } - (void) memset((char *) sp->bitmap, 0, sp->bytes); - - /* - * Copy the glyph from the scratch area to the glyph bitmap, - * adjusting for any shift values encountered. - */ - bpr = ((sp->bbx.width * font->bpp) + 7) >> 3; - for (y = 0; y < sp->bbx.height; y++) { - for (col = x = 0; x < sp->bbx.width; x++, col += font->bpp) { - si = (col & 7) / font->bpp; - byte = scratch.bitmap[(y * bpr) + (col >> 3)] & masks[si]; - if (byte) { - nx = x - shiftx; - if (nx < 0) - nx += sp->bbx.width; - else if (nx >= sp->bbx.width) - nx -= sp->bbx.width; - nx *= font->bpp; - di = (nx & 7) / font->bpp; - if (di < si) - byte <<= (si - di) * font->bpp; - else if (di > si) - byte >>= (di - si) * font->bpp; - sp->bitmap[(y * bpr) + (nx >> 3)] |= byte; - } - } - } - /* - * Mark the glyph as modified. - */ - if (unencoded) - _bdf_set_glyph_modified(font->umod, sp->encoding); - else - _bdf_set_glyph_modified(font->nmod, sp->encoding); - } - - /* - * Call the callback one more time to make sure the client knows - * this is done. - */ - if (callback != 0 && cb.current < cb.total) { - cb.reason = BDF_TRANSLATING; - cb.current = cb.total; - (*callback)(&cb, data); - } - - if (scratch.bytes > 0) - free((char *) scratch.bitmap); - - /* - * Rotations always change things, so just return a value indicating this. - */ - font->modified = 1; - return 1; -} - -static void -#ifdef __STDC__ -_bdf_widen_by(bdf_font_t *f, bdf_glyph_t *g, bdf_bitmap_t *s, int n) -#else -_bdf_widen_by(f, g, s, n) -bdf_font_t *f; -bdf_glyph_t *g; -bdf_bitmap_t *s; -int n; -#endif -{ - int bytes, sbpr, dbpr, col; - short x, y, si, di; - unsigned char *bmap, *masks; - - masks = 0; - switch (f->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - s->height = g->bbx.height; - s->width = g->bbx.width + n; - - bytes = (((s->width * f->bpp) + 7) >> 3) * s->height; - - if (s->bytes == 0) - s->bitmap = (unsigned char *) malloc(bytes); - else - s->bitmap = (unsigned char *) - realloc((char *) s->bitmap, bytes); - s->bytes = bytes; - - (void) memset((char *) s->bitmap, 0, s->bytes); - - /* - * Copy the glyph bitmap to the scratch area, and then swap the bitmaps. - */ - sbpr = ((g->bbx.width * f->bpp) + 7) >> 3; - dbpr = ((s->width * f->bpp) + 7) >> 3; - for (y = 0; y < g->bbx.height; y++) { - for (col = x = 0; x < g->bbx.width; x++, col += f->bpp) { - si = (col & 7) / f->bpp; - bytes = g->bitmap[(y * sbpr) + (col >> 3)] & masks[si]; - if (bytes) { - di = ((x * f->bpp) & 7) / f->bpp; - if (di < si) - bytes <<= (si - di) * f->bpp; - else if (di > si) - bytes >>= (di - si) * f->bpp; - s->bitmap[(y * dbpr) + (col >> 3)] |= bytes; - } - } - } - g->bbx.width = s->width; - - /* - * Swap the bytes and bitmap fields from the scratch area and the glyph. - */ - bytes = g->bytes; - g->bytes = s->bytes; - s->bytes = bytes; - - bmap = g->bitmap; - g->bitmap = s->bitmap; - s->bitmap = bmap; -} - -int -#ifdef __STDC__ -bdf_embolden_glyphs(bdf_font_t *font, long start, long end, - bdf_callback_t callback, void *data, int unencoded, - int *resize) -#else -bdf_embolden_glyphs(font, start, end, callback, data, unencoded, resize) -bdf_font_t *font; -long start, end; -bdf_callback_t callback; -void *data; -int unencoded, *resize; -#endif -{ - int mod, gmod, bpr; - short x, y; - unsigned short si, di, b1, b2, col; - unsigned char *masks; - bdf_glyph_t *gp, *sp, *ep; - bdf_bitmap_t scratch; - bdf_callback_struct_t cb; - - if (font == 0 || (unencoded && font->unencoded_used == 0) || - font->glyphs_used == 0) - return 0; - - /* - * Initialize the scratch bitmap which may be needed. - */ - (void) memset((char *) &scratch, 0, sizeof(bdf_bitmap_t)); - - mod = 0; - gp = 0; - - masks = 0; - switch (font->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - /* - * Call the progress initialization callback. - */ - if (callback != 0) { - cb.reason = BDF_EMBOLDEN_START; - cb.total = (end - start) + 1; - cb.current = 0; - (*callback)(&cb, data); - } - - /* - * Initialize the resize flag for the caller. - */ - *resize = 0; - - sp = _bdf_locate_glyph(font, start, unencoded); - ep = _bdf_locate_glyph(font, end, unencoded); - for (; sp <= ep; sp++) { - /* - * Call the callback if one was provided. - */ - if (sp != gp && callback != 0) { - cb.reason = BDF_EMBOLDENING; - cb.current = (sp->encoding - start) + 1; - (*callback)(&cb, data); - } - - if (font->spacing == BDF_PROPORTIONAL || - (font->spacing == BDF_MONOWIDTH && - sp->bbx.width < font->bbx.width)) { - /* - * Only widen the glyph if it is within reason. - */ - _bdf_widen_by(font, sp, &scratch, 1); - - if (sp->bbx.width > font->bbx.width) { - /* - * Bump the font width up by the difference. - */ - font->bbx.width += sp->bbx.width - font->bbx.width; - *resize = 1; - } - } - - gmod = 0; - bpr = ((sp->bbx.width * font->bpp) + 7) >> 3; - for (y = 0; y < sp->bbx.height; y++) { - col = (sp->bbx.width - 1) * font->bpp; - for (x = sp->bbx.width - 1; x > 0; x--, col -= font->bpp) { - si = (col & 7) / font->bpp; - di = ((col - font->bpp) & 7) / font->bpp; - b1 = (x == sp->bbx.width) ? 0 : - sp->bitmap[(y * bpr) + (col >> 3)] & masks[si]; - b2 = sp->bitmap[(y * bpr) + ((col - font->bpp) >> 3)] & - masks[di]; - if (!b1 && b2) { - if (di < si) - b2 >>= (si - di) * font->bpp; - else if (di > si) - b2 <<= (di - si) * font->bpp; - sp->bitmap[(y * bpr) + (col >> 3)] |= b2; - gmod = mod = 1; - } - } - } - /* - * Mark the glyph as modified. - */ - if (gmod) { - if (unencoded) - _bdf_set_glyph_modified(font->umod, sp->encoding); - else - _bdf_set_glyph_modified(font->nmod, sp->encoding); - } - } - - /* - * Call the callback one more time to make sure the client knows - * this is done. - */ - if (callback != 0 && cb.current < cb.total) { - cb.reason = BDF_EMBOLDENING; - cb.current = cb.total; - (*callback)(&cb, data); - } - - /* - * Deallocate the scratch bitmap if necessary. - */ - if (scratch.bytes > 0) - free((char *) scratch.bitmap); - - font->modified = mod; - - return mod; -} - -static int _endian = 1; -static char *little_endian = (char *) & _endian; - -int -#ifdef __STDC__ -bdf_little_endian(void) -#else -bdf_little_endian() -#endif -{ - return *little_endian; -} diff --git a/tools/sci/bdf.h b/tools/sci/bdf.h deleted file mode 100644 index fe51caf020..0000000000 --- a/tools/sci/bdf.h +++ /dev/null @@ -1,675 +0,0 @@ -/* - * Copyright 2001 Computing Research Labs, New Mexico State University - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY BE LIABLE FOR ANY - * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT - * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR - * THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ -#ifndef _h_bdf -#define _h_bdf - -/* - * $Id$ - */ - -#include <stdio.h> -#include <stdlib.h> -#ifndef __digital__ -#include <unistd.h> -#endif -#include <string.h> - -#ifdef HAVE_XLIB -#include <X11/Xlib.h> -#include <X11/Xutil.h> -#include <X11/Xatom.h> -#endif /* HAVE_XLIB */ - -#ifdef HAVE_FREETYPE -#include <freetype.h> -#include <ftxsbit.h> -#endif /* HAVE_FREETYPE */ - -#ifdef __cplusplus -extern "C" { -#endif - - /* - * A macro for prototypes. - */ -#undef __ -#ifdef __STDC__ -#define __(x) x -#else -#define __(x) () -#endif - - /************************************************************************** - * - * BDF font options macros and types. - * - **************************************************************************/ - -#define BDF_UNIX_EOL 1 /* Save fonts with Unix LF. */ -#define BDF_DOS_EOL 2 /* Save fonts with DOS CRLF. */ -#define BDF_MAC_EOL 3 /* Save fonts with Mac CR. */ - -#define BDF_CORRECT_METRICS 0x01 /* Correct invalid metrics when loading. */ -#define BDF_KEEP_COMMENTS 0x02 /* Preserve the font comments. */ -#define BDF_KEEP_UNENCODED 0x04 /* Keep the unencoded glyphs. */ -#define BDF_PROPORTIONAL 0x08 /* Font has proportional spacing. */ -#define BDF_MONOWIDTH 0x10 /* Font has mono width. */ -#define BDF_CHARCELL 0x20 /* Font has charcell spacing. */ - -#define BDF_ALL_SPACING (BDF_PROPORTIONAL|BDF_MONOWIDTH|BDF_CHARCELL) - -#define BDF_DEFAULT_LOAD_OPTIONS \ - (BDF_CORRECT_METRICS|BDF_KEEP_COMMENTS|BDF_KEEP_UNENCODED|BDF_PROPORTIONAL) - - typedef struct { - int ttf_hint; - int correct_metrics; - int keep_unencoded; - int keep_comments; - int pad_cells; - int font_spacing; - long point_size; - unsigned long resolution_x; - unsigned long resolution_y; - int bits_per_pixel; - int eol; - } bdf_options_t; - - /* - * Callback function type for unknown configuration options. - */ - typedef int (*bdf_options_callback_t) __((bdf_options_t *opts, - char **params, - unsigned long nparams, - void *client_data)); - - /************************************************************************** - * - * BDF font property macros and types. - * - **************************************************************************/ - -#define BDF_ATOM 1 -#define BDF_INTEGER 2 -#define BDF_CARDINAL 3 - - /* - * This structure represents a particular property of a font. - * There are a set of defaults and each font has their own. - */ - typedef struct { - char *name; /* Name of the property. */ - int format; /* Format of the property. */ - int builtin; /* A builtin property. */ - union { - char *atom; - long int32; - unsigned long card32; - } value; /* Value of the property. */ - } bdf_property_t; - - /************************************************************************** - * - * SBIT metrics specific structures. - * - **************************************************************************/ - - /* - * Boolean flags for SBIT metrics files. - */ -#define BDF_SBIT_MONO_ADVANCE 0x0001 -#define BDF_SBIT_ADD_EBLC 0x0002 -#define BDF_SBIT_APPLE_COMPAT 0x0004 - - /* - * Direction macros (inclusive, can be combined). - */ -#define BDF_SBIT_HORIZONTAL 0x0008 -#define BDF_SBIT_VERTICAL 0x0010 - - /* - * Bitmap storage options (exclusive, cannot be combined). - */ -#define BDF_SBIT_STORE_SMALL 0x0020 -#define BDF_SBIT_STORE_FAST 0x0040 - - typedef struct { - short cnum; /* Caret slope numerator. */ - short cdenom; /* Caret slope denominator. */ - short coff; /* Caret offset. */ - short sx; /* Scaled version horizontal PPEM size. */ - short sy; /* Scaled version vertical PPEM size (optional).*/ - short flags; /* Booleans and other non-numeric values. */ - } bdf_sbit_t; - - /************************************************************************** - * - * BDF opaque undo information types. - * - **************************************************************************/ - - typedef struct _bdf_undo_struct *bdf_undo_t; - - /************************************************************************** - * - * BDF font metric and glyph types. - * - **************************************************************************/ - - /* - * A general bitmap type, mostly used when the glyph bitmap is being edited. - */ - typedef struct { - short x; - short y; - unsigned short width; - unsigned short height; - unsigned short bpp; - unsigned short pad; - unsigned char *bitmap; - unsigned long bytes; - } bdf_bitmap_t; - - typedef struct { - int font_spacing; - unsigned short swidth; - unsigned short dwidth; - unsigned short width; - unsigned short height; - short x_offset; - short y_offset; - short ascent; - short descent; - } bdf_metrics_t; - - typedef struct { - unsigned short width; - unsigned short height; - short x_offset; - short y_offset; - short ascent; - short descent; - } bdf_bbx_t; - - typedef struct { - char *name; /* Glyph name. */ - long encoding; /* Glyph encoding. */ - unsigned short swidth; /* Scalable width. */ - unsigned short dwidth; /* Device width. */ - bdf_bbx_t bbx; /* Glyph bounding box. */ - unsigned char *bitmap; /* Glyph bitmap. */ - unsigned short bytes; /* Number of bytes used for the bitmap. */ - } bdf_glyph_t; - - typedef struct { - unsigned short pad; /* Pad to 4-byte boundary. */ - unsigned short bpp; /* Bits per pixel. */ - long start; /* Beginning encoding value of glyphs. */ - long end; /* Ending encoding value of glyphs. */ - bdf_glyph_t *glyphs; /* Glyphs themselves. */ - unsigned long glyphs_size; /* Glyph structures allocated. */ - unsigned long glyphs_used; /* Glyph structures used. */ - bdf_bbx_t bbx; /* Overall bounding box of glyphs. */ - } bdf_glyphlist_t; - - typedef struct { - char *name; /* Name of the font. */ - bdf_bbx_t bbx; /* Font bounding box. */ - - long point_size; /* Point size of the font. */ - unsigned long resolution_x; /* Font horizontal resolution. */ - unsigned long resolution_y; /* Font vertical resolution. */ - - int hbf; /* Font came from an HBF font. */ - - int spacing; /* Font spacing value. */ - - unsigned short monowidth; /* Logical width for monowidth font. */ - - long default_glyph; /* Encoding of the default glyph. */ - - long font_ascent; /* Font ascent. */ - long font_descent; /* Font descent. */ - - long glyphs_size; /* Glyph structures allocated. */ - long glyphs_used; /* Glyph structures used. */ - bdf_glyph_t *glyphs; /* Glyphs themselves. */ - - long unencoded_size; /* Unencoded glyph structures allocated. */ - long unencoded_used; /* Unencoded glyph structures used. */ - bdf_glyph_t *unencoded; /* Unencoded glyphs themselves. */ - - unsigned long props_size; /* Font properties allocated. */ - unsigned long props_used; /* Font properties used. */ - bdf_property_t *props; /* Font properties themselves. */ - - char *comments; /* Font comments. */ - unsigned long comments_len; /* Length of comment string. */ - - char *acmsgs; /* Auto-correction messages. */ - unsigned long acmsgs_len; /* Length of auto-correction messages. */ - - bdf_glyphlist_t overflow; /* Storage used for glyph insertion. */ - - void *internal; /* Internal data for the font. */ - - unsigned long nmod[2048]; /* Bitmap indicating modified glyphs. */ - unsigned long umod[2048]; /* Bitmap indicating modified unencoded. */ - - unsigned short modified; /* Boolean indicating font modified. */ - unsigned short bpp; /* Bits per pixel. */ - - bdf_sbit_t *sbits; /* Associcated SBIT metrics. */ - unsigned long sbits_used; /* Number of SBIT metrics entries. */ - unsigned long sbits_size; /* Amount of entries allocated. */ - - bdf_undo_t *undo_stack; /* Record of undoable operations. */ - unsigned long undo_used; /* Amount of undo stack used. */ - unsigned long undo_size; /* Amount of undo stack allocated. */ - } bdf_font_t; - - /************************************************************************** - * - * BDF glyph grid structures for editing glyph bitmaps. - * - **************************************************************************/ - - typedef struct { - char *name; - long encoding; /* The glyph encoding. */ - unsigned short unencoded; /* Whether the glyph was unencoded. */ - unsigned short bpp; /* Bits per pixel. */ - int spacing; /* Font spacing. */ - long resolution_x; /* Horizontal resolution. */ - long resolution_y; /* Vertical resolution. */ - unsigned long point_size; /* Font point size. */ - unsigned short swidth; /* Scalable width. */ - unsigned short dwidth; /* Device width. */ - bdf_bbx_t font_bbx; /* Font bounding box. */ - bdf_bbx_t glyph_bbx; /* Glyph bounding box. */ - unsigned char *bitmap; /* The grid bitmap. */ - unsigned short bytes; /* Number of bytes in the grid bitmap. */ - short grid_width; /* Width of the grid. */ - short grid_height; /* Height of the grid. */ - short base_x; /* Baseline X coordinate. */ - short base_y; /* Baseline Y coordinate. */ - short glyph_x; /* Top-left X position of glyph. */ - short glyph_y; /* Top-left Y position of glyph. */ - unsigned short modified; /* Flag indicating if bitmap modified. */ - short cap_height; /* Font CAP_HEIGHT if it exists. */ - short x_height; /* Font X_HEIGHT if it exists. */ - bdf_bitmap_t sel; /* Selected portion of the glyph bitmap.*/ - } bdf_glyph_grid_t; - - /************************************************************************** - * - * Types for load/save callbacks. - * - **************************************************************************/ - - /* - * Callback reasons. - */ -#define BDF_LOAD_START 1 -#define BDF_LOADING 2 -#define BDF_SAVE_START 3 -#define BDF_SAVING 4 -#define BDF_TRANSLATE_START 5 -#define BDF_TRANSLATING 6 -#define BDF_ROTATE_START 7 -#define BDF_ROTATING 8 -#define BDF_SHEAR_START 9 -#define BDF_SHEARING 10 -#define BDF_GLYPH_NAME_START 11 -#define BDF_GLYPH_NAME 12 -#define BDF_EXPORT_START 13 -#define BDF_EXPORTING 14 -#define BDF_EMBOLDEN_START 15 -#define BDF_EMBOLDENING 16 -#define BDF_WARNING 20 -#define BDF_ERROR 21 - - /* - * Error codes. - */ -#define BDF_OK 0 -#define BDF_MISSING_START -1 -#define BDF_MISSING_FONTNAME -2 -#define BDF_MISSING_SIZE -3 -#define BDF_MISSING_FONTBBX -4 -#define BDF_MISSING_CHARS -5 -#define BDF_MISSING_STARTCHAR -6 -#define BDF_MISSING_ENCODING -7 -#define BDF_MISSING_BBX -8 - -#define BDF_NOT_CONSOLE_FONT -10 -#define BDF_NOT_MF_FONT -11 -#define BDF_NOT_PSF_FONT -12 -#define BDF_EMPTY_FONT -99 -#define BDF_INVALID_LINE -100 - - typedef struct { - unsigned long reason; - unsigned long current; - unsigned long total; - unsigned long errlineno; - } bdf_callback_struct_t; - - typedef void (*bdf_callback_t) __((bdf_callback_struct_t *call_data, - void *client_data)); - - /************************************************************************** - * - * BDF font API. - * - **************************************************************************/ - - /* - * Startup and shutdown functions. - */ - extern void bdf_setup __((void)); - extern void bdf_cleanup __((void)); - - /* - * Configuration file loading and saving. - */ - extern void bdf_load_options __((FILE *in, bdf_options_t *opts, - bdf_options_callback_t callback, - void *client_data)); - extern void bdf_save_options __((FILE *out, bdf_options_t *opts)); - - /* - * Font options functions. - */ - extern void bdf_default_options __((bdf_options_t *opts)); - - /* - * Font load, create, save and free functions. - */ - extern bdf_font_t *bdf_new_font __((char *name, long point_size, - long resolution_x, long resolution_y, - long spacing, int bpp)); - extern bdf_font_t *bdf_load_font __((FILE *in, bdf_options_t *opts, - bdf_callback_t callback, void *data)); - extern bdf_font_t *bdf_load_hbf_font __((char *filename, bdf_options_t *opts, - bdf_callback_t callback, void *data)); - -#ifdef HAVE_XLIB - extern bdf_font_t *bdf_load_server_font __((Display *d, XFontStruct *f, - char *name, bdf_options_t *opts, - bdf_callback_t callback, - void *data)); -#endif /* HAVE_XLIB */ - - extern int bdf_load_console_font __((FILE *in, bdf_options_t *opts, - bdf_callback_t callback, void *data, - bdf_font_t *fonts[3], int *nfonts)); - - extern int bdf_load_mf_font __((FILE *in, bdf_options_t *opts, - bdf_callback_t callback, void *data, - bdf_font_t **font)); - - extern void bdf_save_font __((FILE *out, bdf_font_t *font, - bdf_options_t *opts, bdf_callback_t callback, - void *data)); - - extern void bdf_save_sbit_metrics __((FILE *out, bdf_font_t *font, - bdf_options_t *opts, char *appname)); - - extern void bdf_export_hex __((FILE *out, bdf_font_t *font, - bdf_callback_t callback, void *data)); - - extern int bdf_export_psf __((FILE *out, bdf_font_t *font)); - - extern void bdf_free_font __((bdf_font_t *font)); - -#ifdef HAVE_FREETYPE - - /* - * TrueType related macros and functions. - */ - - /* - * ID numbers of the strings that can appear in a TrueType font. - */ -#define BDFTTF_COPYRIGHT_STRING 0 -#define BDFTTF_FAMILY_STRING 1 -#define BDFTTF_SUBFAMILY_STRING 2 -#define BDFTTF_UNIQUEID_STRING 3 -#define BDFTTF_FULLNAME_STRING 4 -#define BDFTTF_VENDOR_STRING 5 -#define BDFTTF_POSTSCRIPT_STRING 6 -#define BDFTTF_TRADEMARK_STRING 7 - - extern char *bdfttf_platform_name __((short pid)); - extern char *bdfttf_encoding_name __((short pid, short eid)); - extern int bdfttf_get_english_string __((TT_Face face, int nameID, - int dash_to_space, char *name)); - - extern int bdfttf_load_font __((TT_Face face, TT_Face_Properties *properties, - short pid, short eid, bdf_options_t *opts, - bdf_callback_t callback, void *data, - bdf_font_t **font)); - -#endif /* HAVE_FREETYPE */ - - /* - * FON/FNT related functions. - */ - - /* - * String ID numbers for FON/FNT fonts. - */ -#define BDFFNT_COPYRIGHT 1 -#define BDFFNT_TYPEFACE 2 - - /* - * Opaque font type. - */ - typedef struct _bdffnt_font_t *bdffnt_font_t; - - extern int bdffnt_open_font __((char *path, bdffnt_font_t *font)); - extern void bdffnt_close_font __((bdffnt_font_t font)); - extern int bdffnt_font_count __((bdffnt_font_t font)); - extern int bdffnt_get_copyright __((bdffnt_font_t font, unsigned long fontID, - unsigned char *string)); - extern int bdffnt_get_facename __((bdffnt_font_t font, unsigned long fontID, - int for_xlfd, unsigned char *string)); - extern int bdffnt_char_count __((bdffnt_font_t font, unsigned long fontID)); - extern int bdffnt_font_pointsize __((bdffnt_font_t font, - unsigned long fontID)); - extern int bdffnt_load_font __((bdffnt_font_t font, unsigned long fontID, - bdf_callback_t callback, void *data, - bdf_font_t **out)); - - /* - * Font property functions. - */ - extern void bdf_create_property __((char *name, int type)); - extern bdf_property_t *bdf_get_property __((char *name)); - extern unsigned long bdf_property_list __((bdf_property_t **props)); - - extern void bdf_add_font_property __((bdf_font_t *font, - bdf_property_t *property)); - extern void bdf_delete_font_property __((bdf_font_t *font, char *name)); - extern bdf_property_t *bdf_get_font_property __((bdf_font_t *font, - const char *name)); - extern unsigned long bdf_font_property_list __((bdf_font_t *font, - bdf_property_t **props)); - - /* - * Font comment functions. - */ - extern int bdf_replace_comments __((bdf_font_t *font, char *comments, - unsigned long comments_len)); - - /* - * Other miscellaneous functions. - */ - extern void bdf_set_default_metrics __((bdf_font_t *font)); - - /* - * Font glyph editing functions. - */ - extern int bdf_glyph_modified __((bdf_font_t *font, long which, - int unencoded)); - - extern void bdf_copy_glyphs __((bdf_font_t *font, long start, long end, - bdf_glyphlist_t *glyphs, int unencoded)); - - extern void bdf_delete_glyphs __((bdf_font_t *font, long start, long end, - int unencoded)); - - extern int bdf_insert_glyphs __((bdf_font_t *font, long start, - bdf_glyphlist_t *glyphs)); - - extern int bdf_replace_glyphs __((bdf_font_t *font, long start, - bdf_glyphlist_t *glyphs, int unencoded)); - - extern int bdf_merge_glyphs __((bdf_font_t *font, long start, - bdf_glyphlist_t *glyphs, int unencoded)); - - /************************************************************************** - * - * Other API functions. - * - **************************************************************************/ - - extern int bdf_set_font_bbx __((bdf_font_t *font, bdf_metrics_t *metrics)); - - extern void bdf_set_modified __((bdf_font_t *font, int modified)); - - extern int bdf_has_xlfd_name __((bdf_font_t *font)); - - extern char *bdf_make_xlfd_name __((bdf_font_t *font, char *foundry, - char *family)); - - extern void bdf_update_name_from_properties __((bdf_font_t *font)); - - extern void bdf_update_properties_from_name __((bdf_font_t *font)); - - extern int bdf_update_average_width __((bdf_font_t *font)); - - extern int bdf_set_unicode_glyph_names __((FILE *in, bdf_font_t *font, - bdf_callback_t callback)); - - extern int bdf_set_adobe_glyph_names __((FILE *in, bdf_font_t *font, - bdf_callback_t callback)); - - extern int bdf_set_glyph_code_names __((int prefix, bdf_font_t *font, - bdf_callback_t callback)); - - /************************************************************************** - * - * Glyph grid API. - * - **************************************************************************/ - - /* - * Glyph grid allocation and deallocation functions. - */ - extern bdf_glyph_grid_t *bdf_make_glyph_grid __((bdf_font_t *font, - long code, - int unencoded)); - extern void bdf_free_glyph_grid __((bdf_glyph_grid_t *grid)); - - /* - * Glyph grid information functions. - */ - extern void bdf_grid_image __((bdf_glyph_grid_t *grid, bdf_bitmap_t *image)); - extern void bdf_grid_origin __((bdf_glyph_grid_t *grid, short *x, short *y)); - extern bdf_glyph_t *bdf_grid_glyph __((bdf_glyph_grid_t *grid)); - - /* - * Glyph grid editing functions. - */ - extern int bdf_grid_enlarge __((bdf_glyph_grid_t *grid, unsigned short width, - unsigned short height)); - extern int bdf_grid_resize __((bdf_glyph_grid_t *grid, - bdf_metrics_t *metrics)); - extern int bdf_grid_crop __((bdf_glyph_grid_t *grid, int grid_modified)); - - extern int bdf_grid_set_pixel __((bdf_glyph_grid_t *grid, short x, short y, - int val)); - extern int bdf_grid_clear_pixel __((bdf_glyph_grid_t *grid, short x, short y)); - extern int bdf_grid_invert_pixel __((bdf_glyph_grid_t *grid, - short x, short y, int val)); - extern int bdf_grid_shift __((bdf_glyph_grid_t *grid, short xcount, - short ycount)); - extern int bdf_grid_flip __((bdf_glyph_grid_t *grid, short dir)); - extern int bdf_grid_rotate __((bdf_glyph_grid_t *grid, short degrees, - int *resize)); - extern int bdf_grid_shear __((bdf_glyph_grid_t *grid, short degrees, - int *resize)); - extern int bdf_grid_embolden __((bdf_glyph_grid_t *grid)); - - /* - * Glyph grid selection functions. - */ - extern int bdf_has_selection __((bdf_glyph_grid_t *grid, short *x, short *y, - short *width, short *height)); - extern void bdf_set_selection __((bdf_glyph_grid_t *grid, short x, short y, - short width, short height)); - extern void bdf_lose_selection __((bdf_glyph_grid_t *grid)); - extern void bdf_detach_selection __((bdf_glyph_grid_t *grid)); - extern void bdf_attach_selection __((bdf_glyph_grid_t *grid)); - extern void bdf_delete_selection __((bdf_glyph_grid_t *grid)); - extern int bdf_in_selection __((bdf_glyph_grid_t *grid, short x, short y, - short *set)); - extern void bdf_add_selection __((bdf_glyph_grid_t *grid, bdf_bitmap_t *sel)); - - /* - * Glyph grid misc functions. - */ - extern int bdf_grid_color_at __((bdf_glyph_grid_t *grid, short x, short y)); - - /* - * Graphical transformation functions. - */ - extern int bdf_translate_glyphs __((bdf_font_t *font, short dx, short dy, - long start, long end, - bdf_callback_t callback, void *data, - int unencoded)); - - extern int bdf_rotate_glyphs __((bdf_font_t *font, short degrees, - long start, long end, - bdf_callback_t callback, void *data, - int unencoded)); - - extern int bdf_shear_glyphs __((bdf_font_t *font, short degrees, - long start, long end, - bdf_callback_t callback, void *data, - int unencoded)); - - extern int bdf_embolden_glyphs __((bdf_font_t *font, long start, long end, - bdf_callback_t callback, void *data, - int unencoded, int *resize)); - - extern int bdf_little_endian __((void)); - -#undef __ - -#ifdef __cplusplus -} -#endif - -#endif /* _h_bdf */ diff --git a/tools/sci/bdfP.h b/tools/sci/bdfP.h deleted file mode 100644 index 518cc76711..0000000000 --- a/tools/sci/bdfP.h +++ /dev/null @@ -1,142 +0,0 @@ -/* - * Copyright 2001 Computing Research Labs, New Mexico State University - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY BE LIABLE FOR ANY - * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT - * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR - * THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ -#ifndef _h_bdfP -#define _h_bdfP - -/* - * $Id$ - */ - -#include "bdf.h" - -#ifdef __cplusplus -extern "C" { -#endif - - /* - * A macro for prototypes. - */ -#undef __ -#ifdef __STDC__ -#define __(x) x -#else -#define __(x) () -#endif - -#ifndef MYABS -#define MYABS(xx) ((xx) < 0 ? -(xx) : (xx)) -#endif - - /* - * Macros and structures used for undo operations in the font. - */ -#define _UNDO_REPLACE_GLYPHS 1 -#define _UNDO_INSERT_GLYPHS 2 -#define _UNDO_MERGE_GLYPHS 3 - - /* - * This structure is for undo operations of replacing and merging glyphs - * in the font. - */ - typedef struct { - bdf_bbx_t b; - bdf_glyphlist_t g; - } _bdf_undo1_t; - - /* - * This structure is for undo operations of inserting glyphs. - */ - typedef struct { - bdf_bbx_t b; - long start; - long end; - } _bdf_undo2_t; - - /* - * This is the final undo structure used to store undo information with the - * font. - */ - typedef struct _bdf_undo_struct { - int type; - union { - _bdf_undo1_t one; - _bdf_undo2_t two; - } field; - } bdf_undo_struct_t; - - /* - * Tables for rotation and shearing. - */ - extern double _bdf_cos_tbl[]; - extern double _bdf_sin_tbl[]; - extern double _bdf_tan_tbl[]; - - /* - * Arrays of masks for test with different bits per pixel. - */ - extern unsigned char onebpp[]; - extern unsigned char twobpp[]; - extern unsigned char fourbpp[]; - - /* - * Simple routine for determining the ceiling. - */ - extern short _bdf_ceiling __((double v)); - - extern unsigned char *_bdf_strdup __((unsigned char *s, unsigned long len)); - extern void _bdf_memmove __((char *dest, char *src, unsigned long bytes)); - - extern short _bdf_atos __((char *s, char **end, int base)); - extern long _bdf_atol __((char *s, char **end, int base)); - extern unsigned long _bdf_atoul __((char *s, char **end, int base)); - - /* - * Macros to test/set the modified status of a glyph. - */ -#define _bdf_glyph_modified(map, e) ((map)[(e) >> 5] & (1 << ((e) & 31))) -#define _bdf_set_glyph_modified(map, e) (map)[(e) >> 5] |= (1 << ((e) & 31)) -#define _bdf_clear_glyph_modified(map, e) (map)[(e) >> 5] &= ~(1 << ((e) & 31)) - - /* - * Function to add a message to the font. - */ - extern void _bdf_add_acmsg __((bdf_font_t *font, char *msg, - unsigned long len)); - - /* - * Function to add a comment to the font. - */ - extern void _bdf_add_comment __((bdf_font_t *font, char *comment, - unsigned long len)); - - /* - * Function to do glyph name table cleanup when exiting. - */ - extern void _bdf_glyph_name_cleanup __((void)); - -#undef __ - -#ifdef __cplusplus -} -#endif - -#endif /* _h_bdfP */ diff --git a/tools/sci/bdfgname.cpp b/tools/sci/bdfgname.cpp deleted file mode 100644 index 694d82405c..0000000000 --- a/tools/sci/bdfgname.cpp +++ /dev/null @@ -1,439 +0,0 @@ -/* - * Copyright 2001 Computing Research Labs, New Mexico State University - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY BE LIABLE FOR ANY - * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT - * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR - * THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ -#ifndef lint -#ifdef __GNUC__ -static char rcsid[] __attribute__((unused)) = "$Id$"; -#else -static char rcsid[] = "$Id$"; -#endif -#endif - -#include "bdfP.h" - -typedef struct { - long code; - long start; - long end; - long pad; -} _bdf_adobe_name_t; - -static _bdf_adobe_name_t *adobe_names; -static unsigned long adobe_names_size; -static unsigned long adobe_names_used; - -/* - * Provide a maximum length for glyph names just to make things clearer. - */ -#define MAX_GLYPH_NAME_LEN 127 - -static int -#ifdef __STDC__ -getline(FILE *in, char *buf, int limit) -#else -getline(in, buf, limit) -FILE *in; -char *buf; -int limit; -#endif -{ - int c, i; - - c = EOF; - - for (i = 0; i < limit - 1; i++) { - if ((c = getc(in)) == EOF || (c == '\n' || c == '\r')) - break; - buf[i] = c; - } - buf[i] = 0; - - /* - * Discard the rest of the line which did not fit into the buffer. - */ - while (c != EOF && c != '\n' && c != '\r') - c = getc(in); - - if (c == '\r') { - /* - * Check for a trailing newline. - */ - c = getc(in); - if (c != '\n') - ungetc(c, in); - } - - return i; -} - -static long -#ifdef __STDC__ -_bdf_find_name(long code, char *name, FILE *in) -#else -_bdf_find_name(code, name, in) -long code; -char *name; -FILE *in; -#endif -{ - long c, i, pos; - char *sp, buf[256]; - - while (!feof(in)) { - pos = ftell(in); - (void) getline(in, buf, 256); - while (!feof(in) && (buf[0] == 0 || buf[0] == '#')) { - buf[0] = 0; - pos = ftell(in); - (void) getline(in, buf, 256); - } - - if (buf[0] == 0) - return -1; - - c = _bdf_atol(buf, 0, 16); - - if (c > code) { - /* - * Restore the last position read in case the code is not in the - * file and the current code is greater than the expected code. - */ - fseek(in, pos, 0L); - return -1; - } - - if (c == code) { - for (sp = buf; *sp != ';'; sp++) ; - sp++; - for (i = 0; *sp != ';' && i < MAX_GLYPH_NAME_LEN; sp++, i++) - name[i] = *sp; - name[i] = 0; - return i; - } - } - return -1; -} - -static int -#ifdef __STDC__ -by_encoding(const void *a, const void *b) -#else -by_encoding(a, b) -char *a, *b; -#endif -{ - _bdf_adobe_name_t *c1, *c2; - - c1 = (_bdf_adobe_name_t *) a; - c2 = (_bdf_adobe_name_t *) b; - if (c1->code < c2->code) - return -1; - else if (c1->code > c2->code) - return 1; - return 0; -} - -static void -#ifdef __STDC__ -_bdf_load_adobe_names(FILE *in) -#else -_bdf_load_adobe_names(in) -FILE *in; -#endif -{ - long c, pos; - char *sp, buf[256]; - - /* - * Go back to the beginning of the file to look for the code because the - * codes are not in order in the current Adobe Glyph Name list file. - */ - fseek(in, 0, 0); - - while (!feof(in)) { - pos = ftell(in); - (void) getline(in, buf, 256); - while (!feof(in) && (buf[0] == 0 || buf[0] == '#')) { - buf[0] = 0; - pos = ftell(in); - (void) getline(in, buf, 256); - } - - c = _bdf_atol(buf, 0, 16); - - /* - * Ignore the Adobe-specific names in the Private Use Area. - */ - if (c >= 0xe000 && c <= 0xf8ff) - continue; - - if (adobe_names_used == adobe_names_size) { - if (adobe_names_size == 0) - adobe_names = (_bdf_adobe_name_t *) - malloc(sizeof(_bdf_adobe_name_t) << 9); - else - adobe_names = (_bdf_adobe_name_t *) - realloc((char *) adobe_names, - sizeof(_bdf_adobe_name_t) * - (adobe_names_size + 512)); - (void) memset((char *)(adobe_names + adobe_names_size), 0, - sizeof(_bdf_adobe_name_t) << 9); - adobe_names_size += 512; - } - - adobe_names[adobe_names_used].code = c; - for (sp = buf; *sp != ';'; sp++) ; - sp++; - adobe_names[adobe_names_used].start = pos + (sp - buf); - for (; *sp != ';'; sp++) ; - adobe_names[adobe_names_used].end = pos + (sp - buf); - adobe_names_used++; - } - - /* - * Sort the results by code. - */ - qsort((char *) adobe_names, adobe_names_used, sizeof(_bdf_adobe_name_t), - by_encoding); -} - -static long -#ifdef __STDC__ -_bdf_find_adobe_name(long code, char *name, FILE *in) -#else -_bdf_find_adobe_name(code, name, in) -long code; -char *name; -FILE *in; -#endif -{ - long len; - int l, r, m; - - if (code < 0x20 || (code >= 0x7f && code <= 0x9f) || - code == 0xfffe || code == 0xffff) { - sprintf(name, "char%lu", code); - return (long) strlen(name); - } - - if (code >= 0xe000 && code <= 0xf8ff) { - sprintf(name, "uni%04lX", code & 0xffff); - return (long) strlen(name); - } - - if (adobe_names_size == 0) - _bdf_load_adobe_names(in); - - l = 0; - r = adobe_names_used - 1; - while (l <= r) { - m = (l + r) >> 1; - if (adobe_names[m].code < code) - l = m + 1; - else if (adobe_names[m].code > code) - r = m - 1; - else { - fseek(in, adobe_names[m].start, 0); - len = adobe_names[m].end - adobe_names[m].start; - if (len > MAX_GLYPH_NAME_LEN) - len = MAX_GLYPH_NAME_LEN; - len = (long) fread(name, sizeof(char), len, in); - name[len] = 0; - return len; - } - } - - sprintf(name, "uni%04lX", code & 0xffff); - return (long) strlen(name); -} - -static int -#ifdef __STDC__ -_bdf_set_glyph_names(FILE *in, bdf_font_t *font, bdf_callback_t callback, - int adobe) -#else -_bdf_set_glyph_names(in, font, callback, adobe) -FILE *in; -bdf_font_t *font; -bdf_callback_t callback; -int adobe; -#endif -{ - int changed; - long i, size, len; - bdf_glyph_t *gp; - bdf_callback_struct_t cb; - char name[MAX_GLYPH_NAME_LEN + 1]; - - if (callback != 0) { - cb.reason = BDF_GLYPH_NAME_START; - cb.current = 0; - cb.total = font->glyphs_used; - (*callback)(&cb, 0); - } - for (changed = 0, i = 0, gp = font->glyphs; i < font->glyphs_used; - i++, gp++) { - size = (adobe) ? - _bdf_find_adobe_name(gp->encoding, name, in) : - _bdf_find_name(gp->encoding, name, in); - if (size < 0) - continue; - - len = (gp->name) ? strlen(gp->name) : 0; - if (len == 0) { - gp->name = (char *) _bdf_strdup((unsigned char *) name, size + 1); - changed = 1; - } else if (size != len || strcmp(gp->name, name) != 0) { - /* - * Simply resize existing storage so lots of memory allocations - * are not needed. - */ - if (size > len) - gp->name = (char *) realloc(gp->name, size + 1); - (void) strcpy(gp->name, name); - changed = 1; - } - - if (callback != 0) { - cb.reason = BDF_GLYPH_NAME; - cb.current = i; - (*callback)(&cb, 0); - } - } - - if (callback != 0) { - cb.reason = BDF_GLYPH_NAME; - cb.current = cb.total; - (*callback)(&cb, 0); - } - - return changed; -} - -int -#ifdef __STDC__ -bdf_set_unicode_glyph_names(FILE *in, bdf_font_t *font, - bdf_callback_t callback) -#else -bdf_set_unicode_glyph_names(in, font, callback) -FILE *in; -bdf_font_t *font; -bdf_callback_t callback; -#endif -{ - return _bdf_set_glyph_names(in, font, callback, 0); -} - -int -#ifdef __STDC__ -bdf_set_adobe_glyph_names(FILE *in, bdf_font_t *font, bdf_callback_t callback) -#else -bdf_set_adobe_glyph_names(in, font, callback) -FILE *in; -bdf_font_t *font; -bdf_callback_t callback; -#endif -{ - return _bdf_set_glyph_names(in, font, callback, 1); -} - -int -#ifdef __STDC__ -bdf_set_glyph_code_names(int prefix, bdf_font_t *font, bdf_callback_t callback) -#else -bdf_set_glyph_code_names(prefix, font, callback) -int prefix; -bdf_font_t *font; -bdf_callback_t callback; -#endif -{ - int changed; - long i, size, len; - bdf_glyph_t *gp; - bdf_callback_struct_t cb; - char name[128]; - - if (callback != 0) { - cb.reason = BDF_GLYPH_NAME_START; - cb.current = 0; - cb.total = font->glyphs_used; - (*callback)(&cb, 0); - } - for (changed = 0, i = 0, gp = font->glyphs; i < font->glyphs_used; - i++, gp++) { - switch (prefix) { - case 'u': - sprintf(name, "uni%04lX", gp->encoding & 0xffff); - break; - case 'x': - sprintf(name, "0x%04lX", gp->encoding & 0xffff); - break; - case '+': - sprintf(name, "U+%04lX", gp->encoding & 0xffff); - break; - case '\\': - sprintf(name, "\\u%04lX", gp->encoding & 0xffff); - break; - } - size = 6; - - len = (gp->name) ? strlen(gp->name) : 0; - if (len == 0) { - gp->name = (char *) _bdf_strdup((unsigned char *) name, size + 1); - changed = 1; - } else if (size != len || strcmp(gp->name, name) != 0) { - /* - * Simply resize existing storage so lots of memory allocations - * are not needed. - */ - if (size > len) - gp->name = (char *) realloc(gp->name, size + 1); - (void) strcpy(gp->name, name); - changed = 1; - } - - if (callback != 0) { - cb.reason = BDF_GLYPH_NAME; - cb.current = i; - (*callback)(&cb, 0); - } - } - - if (callback != 0) { - cb.reason = BDF_GLYPH_NAME; - cb.current = cb.total; - (*callback)(&cb, 0); - } - - return changed; -} - -void -#ifdef __STDC__ -_bdf_glyph_name_cleanup(void) -#else -_bdf_glyph_name_cleanup() -#endif -{ - if (adobe_names_size > 0) - free((char *) adobe_names); - adobe_names_size = adobe_names_used = 0; -} diff --git a/tools/sci/bdfgrid.cpp b/tools/sci/bdfgrid.cpp deleted file mode 100644 index 81dd35a4fa..0000000000 --- a/tools/sci/bdfgrid.cpp +++ /dev/null @@ -1,3515 +0,0 @@ -/* - * Copyright 2001 Computing Research Labs, New Mexico State University - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY BE LIABLE FOR ANY - * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT - * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR - * THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ -#ifndef lint -#ifdef __GNUC__ -static char rcsid[] __attribute__((unused)) = "$Id$"; -#else -static char rcsid[] = "$Id$"; -#endif -#endif - -#include "bdfP.h" - -#ifndef MYABS -#define MYABS(n) ((n) < 0 ? -(n) : (n)) -#endif - -#undef MAX -#define MAX(h, i) ((h) > (i) ? (h) : (i)) - -#undef MIN -#define MIN(l, o) ((l) < (o) ? (l) : (o)) - -double _bdf_cos_tbl[360] = { - 0.000000, 0.999848, 0.999391, 0.998630, 0.997564, 0.996195, - 0.994522, 0.992546, 0.990268, 0.987688, 0.984808, 0.981627, - 0.978148, 0.974370, 0.970296, 0.965926, 0.961262, 0.956305, - 0.951057, 0.945519, 0.939693, 0.933580, 0.927184, 0.920505, - 0.913545, 0.906308, 0.898794, 0.891007, 0.882948, 0.874620, - 0.866025, 0.857167, 0.848048, 0.838671, 0.829038, 0.819152, - 0.809017, 0.798636, 0.788011, 0.777146, 0.766044, 0.754710, - 0.743145, 0.731354, 0.719340, 0.707107, 0.694658, 0.681998, - 0.669131, 0.656059, 0.642788, 0.629320, 0.615661, 0.601815, - 0.587785, 0.573576, 0.559193, 0.544639, 0.529919, 0.515038, - 0.500000, 0.484810, 0.469472, 0.453990, 0.438371, 0.422618, - 0.406737, 0.390731, 0.374607, 0.358368, 0.342020, 0.325568, - 0.309017, 0.292372, 0.275637, 0.258819, 0.241922, 0.224951, - 0.207912, 0.190809, 0.173648, 0.156434, 0.139173, 0.121869, - 0.104528, 0.087156, 0.069756, 0.052336, 0.034899, 0.017452, - 0.000000, -0.017452, -0.034899, -0.052336, -0.069756, -0.087156, - -0.104528, -0.121869, -0.139173, -0.156434, -0.173648, -0.190809, - -0.207912, -0.224951, -0.241922, -0.258819, -0.275637, -0.292372, - -0.309017, -0.325568, -0.342020, -0.358368, -0.374607, -0.390731, - -0.406737, -0.422618, -0.438371, -0.453990, -0.469472, -0.484810, - -0.500000, -0.515038, -0.529919, -0.544639, -0.559193, -0.573576, - -0.587785, -0.601815, -0.615661, -0.629320, -0.642788, -0.656059, - -0.669131, -0.681998, -0.694658, -0.707107, -0.719340, -0.731354, - -0.743145, -0.754710, -0.766044, -0.777146, -0.788011, -0.798636, - -0.809017, -0.819152, -0.829038, -0.838671, -0.848048, -0.857167, - -0.866025, -0.874620, -0.882948, -0.891007, -0.898794, -0.906308, - -0.913545, -0.920505, -0.927184, -0.933580, -0.939693, -0.945519, - -0.951057, -0.956305, -0.961262, -0.965926, -0.970296, -0.974370, - -0.978148, -0.981627, -0.984808, -0.987688, -0.990268, -0.992546, - -0.994522, -0.996195, -0.997564, -0.998630, -0.999391, -0.999848, - -1.000000, -0.999848, -0.999391, -0.998630, -0.997564, -0.996195, - -0.994522, -0.992546, -0.990268, -0.987688, -0.984808, -0.981627, - -0.978148, -0.974370, -0.970296, -0.965926, -0.961262, -0.956305, - -0.951057, -0.945519, -0.939693, -0.933580, -0.927184, -0.920505, - -0.913545, -0.906308, -0.898794, -0.891007, -0.882948, -0.874620, - -0.866025, -0.857167, -0.848048, -0.838671, -0.829038, -0.819152, - -0.809017, -0.798636, -0.788011, -0.777146, -0.766044, -0.754710, - -0.743145, -0.731354, -0.719340, -0.707107, -0.694658, -0.681998, - -0.669131, -0.656059, -0.642788, -0.629320, -0.615661, -0.601815, - -0.587785, -0.573576, -0.559193, -0.544639, -0.529919, -0.515038, - -0.500000, -0.484810, -0.469472, -0.453990, -0.438371, -0.422618, - -0.406737, -0.390731, -0.374607, -0.358368, -0.342020, -0.325568, - -0.309017, -0.292372, -0.275637, -0.258819, -0.241922, -0.224951, - -0.207912, -0.190809, -0.173648, -0.156434, -0.139173, -0.121869, - -0.104528, -0.087156, -0.069756, -0.052336, -0.034899, -0.017452, - -0.000000, 0.017452, 0.034899, 0.052336, 0.069756, 0.087156, - 0.104528, 0.121869, 0.139173, 0.156434, 0.173648, 0.190809, - 0.207912, 0.224951, 0.241922, 0.258819, 0.275637, 0.292372, - 0.309017, 0.325568, 0.342020, 0.358368, 0.374607, 0.390731, - 0.406737, 0.422618, 0.438371, 0.453990, 0.469472, 0.484810, - 0.500000, 0.515038, 0.529919, 0.544639, 0.559193, 0.573576, - 0.587785, 0.601815, 0.615661, 0.629320, 0.642788, 0.656059, - 0.669131, 0.681998, 0.694658, 0.707107, 0.719340, 0.731354, - 0.743145, 0.754710, 0.766044, 0.777146, 0.788011, 0.798636, - 0.809017, 0.819152, 0.829038, 0.838671, 0.848048, 0.857167, - 0.866025, 0.874620, 0.882948, 0.891007, 0.898794, 0.906308, - 0.913545, 0.920505, 0.927184, 0.933580, 0.939693, 0.945519, - 0.951057, 0.956305, 0.961262, 0.965926, 0.970296, 0.974370, - 0.978148, 0.981627, 0.984808, 0.987688, 0.990268, 0.992546, - 0.994522, 0.996195, 0.997564, 0.998630, 0.999391, 0.999848, -}; - -double _bdf_sin_tbl[360] = { - 0.000000, 0.017452, 0.034899, 0.052336, 0.069756, 0.087156, - 0.104528, 0.121869, 0.139173, 0.156434, 0.173648, 0.190809, - 0.207912, 0.224951, 0.241922, 0.258819, 0.275637, 0.292372, - 0.309017, 0.325568, 0.342020, 0.358368, 0.374607, 0.390731, - 0.406737, 0.422618, 0.438371, 0.453990, 0.469472, 0.484810, - 0.500000, 0.515038, 0.529919, 0.544639, 0.559193, 0.573576, - 0.587785, 0.601815, 0.615661, 0.629320, 0.642788, 0.656059, - 0.669131, 0.681998, 0.694658, 0.707107, 0.719340, 0.731354, - 0.743145, 0.754710, 0.766044, 0.777146, 0.788011, 0.798636, - 0.809017, 0.819152, 0.829038, 0.838671, 0.848048, 0.857167, - 0.866025, 0.874620, 0.882948, 0.891007, 0.898794, 0.906308, - 0.913545, 0.920505, 0.927184, 0.933580, 0.939693, 0.945519, - 0.951057, 0.956305, 0.961262, 0.965926, 0.970296, 0.974370, - 0.978148, 0.981627, 0.984808, 0.987688, 0.990268, 0.992546, - 0.994522, 0.996195, 0.997564, 0.998630, 0.999391, 0.999848, - 1.000000, 0.999848, 0.999391, 0.998630, 0.997564, 0.996195, - 0.994522, 0.992546, 0.990268, 0.987688, 0.984808, 0.981627, - 0.978148, 0.974370, 0.970296, 0.965926, 0.961262, 0.956305, - 0.951057, 0.945519, 0.939693, 0.933580, 0.927184, 0.920505, - 0.913545, 0.906308, 0.898794, 0.891007, 0.882948, 0.874620, - 0.866025, 0.857167, 0.848048, 0.838671, 0.829038, 0.819152, - 0.809017, 0.798636, 0.788011, 0.777146, 0.766044, 0.754710, - 0.743145, 0.731354, 0.719340, 0.707107, 0.694658, 0.681998, - 0.669131, 0.656059, 0.642788, 0.629320, 0.615661, 0.601815, - 0.587785, 0.573576, 0.559193, 0.544639, 0.529919, 0.515038, - 0.500000, 0.484810, 0.469472, 0.453990, 0.438371, 0.422618, - 0.406737, 0.390731, 0.374607, 0.358368, 0.342020, 0.325568, - 0.309017, 0.292372, 0.275637, 0.258819, 0.241922, 0.224951, - 0.207912, 0.190809, 0.173648, 0.156434, 0.139173, 0.121869, - 0.104528, 0.087156, 0.069756, 0.052336, 0.034899, 0.017452, - 0.000000, -0.017452, -0.034899, -0.052336, -0.069756, -0.087156, - -0.104528, -0.121869, -0.139173, -0.156434, -0.173648, -0.190809, - -0.207912, -0.224951, -0.241922, -0.258819, -0.275637, -0.292372, - -0.309017, -0.325568, -0.342020, -0.358368, -0.374607, -0.390731, - -0.406737, -0.422618, -0.438371, -0.453990, -0.469472, -0.484810, - -0.500000, -0.515038, -0.529919, -0.544639, -0.559193, -0.573576, - -0.587785, -0.601815, -0.615661, -0.629320, -0.642788, -0.656059, - -0.669131, -0.681998, -0.694658, -0.707107, -0.719340, -0.731354, - -0.743145, -0.754710, -0.766044, -0.777146, -0.788011, -0.798636, - -0.809017, -0.819152, -0.829038, -0.838671, -0.848048, -0.857167, - -0.866025, -0.874620, -0.882948, -0.891007, -0.898794, -0.906308, - -0.913545, -0.920505, -0.927184, -0.933580, -0.939693, -0.945519, - -0.951057, -0.956305, -0.961262, -0.965926, -0.970296, -0.974370, - -0.978148, -0.981627, -0.984808, -0.987688, -0.990268, -0.992546, - -0.994522, -0.996195, -0.997564, -0.998630, -0.999391, -0.999848, - -1.000000, -0.999848, -0.999391, -0.998630, -0.997564, -0.996195, - -0.994522, -0.992546, -0.990268, -0.987688, -0.984808, -0.981627, - -0.978148, -0.974370, -0.970296, -0.965926, -0.961262, -0.956305, - -0.951057, -0.945519, -0.939693, -0.933580, -0.927184, -0.920505, - -0.913545, -0.906308, -0.898794, -0.891007, -0.882948, -0.874620, - -0.866025, -0.857167, -0.848048, -0.838671, -0.829038, -0.819152, - -0.809017, -0.798636, -0.788011, -0.777146, -0.766044, -0.754710, - -0.743145, -0.731354, -0.719340, -0.707107, -0.694658, -0.681998, - -0.669131, -0.656059, -0.642788, -0.629320, -0.615661, -0.601815, - -0.587785, -0.573576, -0.559193, -0.544639, -0.529919, -0.515038, - -0.500000, -0.484810, -0.469472, -0.453990, -0.438371, -0.422618, - -0.406737, -0.390731, -0.374607, -0.358368, -0.342020, -0.325568, - -0.309017, -0.292372, -0.275637, -0.258819, -0.241922, -0.224951, - -0.207912, -0.190809, -0.173648, -0.156434, -0.139173, -0.121869, - -0.104528, -0.087156, -0.069756, -0.052336, -0.034899, -0.017452, -}; - -double _bdf_tan_tbl[90] = { - 0.000000, 0.017455, 0.034921, 0.052408, 0.069927, 0.087489, - 0.105104, 0.122785, 0.140541, 0.158384, 0.176327, 0.194380, - 0.212557, 0.230868, 0.249328, 0.267949, 0.286745, 0.305731, - 0.324920, 0.344328, 0.363970, 0.383864, 0.404026, 0.424475, - 0.445229, 0.466308, 0.487733, 0.509525, 0.531709, 0.554309, - 0.577350, 0.600861, 0.624869, 0.649408, 0.674509, 0.700208, - 0.726543, 0.753554, 0.781286, 0.809784, 0.839100, 0.869287, - 0.900404, 0.932515, 0.965689, 1.000000, 1.035530, 1.072369, - 1.110613, 1.150368, 1.191754, 1.234897, 1.279942, 1.327045, - 1.376382, 1.428148, 1.482561, 1.539865, 1.600335, 1.664279, - 1.732051, 1.804048, 1.880726, 1.962611, 2.050304, 2.144507, - 2.246037, 2.355852, 2.475087, 2.605089, 2.747477, 2.904211, - 3.077684, 3.270853, 3.487414, 3.732051, 4.010781, 4.331476, - 4.704630, 5.144554, 5.671282, 6.313752, 7.115370, 8.144346, - 9.514364, 11.430052, 14.300666, 19.081137, 28.636253, 57.289962, -}; - -/* - * Determine the actual ink bounds. - */ -static int -#ifdef __STDC__ -_bdf_grid_ink_bounds(bdf_glyph_grid_t *grid, short *x, short *y, - short *width, short *height) -#else -_bdf_grid_ink_bounds(grid, x, y, width, height) -bdf_glyph_grid_t *grid; -short *x, *y, *width, *height; -#endif -{ - short bx, by, bwd, bht, minx, maxx, miny, maxy, dx, dy; - unsigned short bpr, ink, sel, col; - unsigned char *bmap, *masks; - - masks = 0; - switch (grid->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - if (grid->sel.width != 0 && grid->sel.height != 0) { - sel = 1; - bx = by = 0; - bwd = grid->sel.width; - bht = grid->sel.height; - bmap = grid->sel.bitmap; - } else { - sel = 0; - bx = grid->glyph_x; - by = grid->glyph_y; - bwd = grid->glyph_bbx.width; - bht = grid->glyph_bbx.height; - bmap = grid->bitmap; - } - maxx = maxy = 0; - minx = bx + bwd; - miny = by + bht; - - bpr = ((bwd * grid->bpp) + 7) >> 3; - ink = 0; - - bwd += bx; - bht += by; - for (dy = by; dy < bht; dy++) { - for (col = bx * grid->bpp, dx = bx; dx < bwd; dx++, col += grid->bpp) { - if (bmap[(dy * bpr) + (col >> 3)] & masks[(col & 7) / grid->bpp]) { - ink = 1; - minx = MIN(minx, dx); - miny = MIN(miny, dy); - maxx = MAX(maxx, dx); - maxy = MAX(maxy, dy); - } - } - } - - *x = minx + ((sel) ? grid->sel.x : 0); - *y = miny + ((sel) ? grid->sel.y : 0); - if (ink == 0) - *width = *height = 0; - else { - *width = (maxx - minx) + 1; - *height = (maxy - miny) + 1; - } - return ink; -} - -/************************************************************************** - * - * Glyph grid create and destroy functions. - * - **************************************************************************/ - -/* - * Make a glyph grid with the glyph bitmap set in the bitmap. - */ -bdf_glyph_grid_t * -#ifdef __STDC__ -bdf_make_glyph_grid(bdf_font_t *font, long code, int unencoded) -#else -bdf_make_glyph_grid(font, code, unencoded) -bdf_font_t *font; -long code; -int unencoded; -#endif -{ - unsigned short si, di, col, colx, byte; - short ht, as, ds, gsize, bpr, x, y, nx, ny; - long l, r, m; - bdf_glyph_grid_t *gr; - bdf_glyph_t *gl, *glp; - bdf_property_t *p; - unsigned char *masks; - char name[24]; - - if (font == 0) - return 0; - - /* - * Allocate the grid and initialize it. - */ - gr = (bdf_glyph_grid_t *) malloc(sizeof(bdf_glyph_grid_t)); - (void) memset((char *) gr, 0, sizeof(bdf_glyph_grid_t)); - - /* - * Set the encoding and the unencoded flag. - */ - gr->bpp = font->bpp; - gr->encoding = code; - gr->unencoded = unencoded; - - /* - * Set the glyph grid spacing. - */ - gr->spacing = font->spacing; - - /* - * Set the point size and resolutions. - */ - gr->point_size = font->point_size; - gr->resolution_x = font->resolution_x; - gr->resolution_y = font->resolution_y; - - /* - * Set the CAP_HEIGHT and X_HEIGHT if they exist in the font. - */ - if ((p = bdf_get_font_property(font, "CAP_HEIGHT")) != 0) - gr->cap_height = (short) p->value.int32; - if ((p = bdf_get_font_property(font, "X_HEIGHT")) != 0) - gr->x_height = (short) p->value.int32; - - masks = 0; - switch (gr->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - /* - * Copy the font bounding box into the grid. - */ - (void) memcpy((char *) &gr->font_bbx, (char *) &font->bbx, - sizeof(bdf_bbx_t)); - - if (unencoded) { - gl = font->unencoded; - r = font->unencoded_used; - } else { - gl = font->glyphs; - r = font->glyphs_used; - } - - /* - * Locate the specified glyph using a simple binary search. - */ - glp = 0; - if (r > 0) { - for (l = 0; r >= l;) { - m = (l + r) >> 1; - glp = gl + m; - if (glp->encoding == code) - break; - if (glp->encoding > code) - r = m - 1; - else if (glp->encoding < code) - l = m + 1; - glp = 0; - } - } - - ht = gr->font_bbx.height; - as = gr->font_bbx.ascent; - ds = gr->font_bbx.descent; - - /* - * 1. Determine width and height needed from the largest of the - * width or height. - */ - gr->grid_width = gr->grid_height = - MAX(gr->font_bbx.width, gr->font_bbx.height); - - /* - * 2. Make sure the grid is at least a square of the largest of the width - * or height of the glyph itself to allow room for transformations. - */ - if (glp != 0) { - /* - * Set the glyph name and other metrics. - */ - if (glp->name) { - gr->name = (char *) malloc(strlen(glp->name) + 1); - (void) memcpy(gr->name, glp->name, strlen(glp->name) + 1); - } else { - sprintf(name, "char%ld", code); - gr->name = (char *) malloc(strlen(name) + 1); - (void) memcpy(gr->name, name, strlen(name) + 1); - } - gr->dwidth = glp->dwidth; - - /* - * Copy the glyph bounding box into the grid. - */ - (void) memcpy((char *) &gr->glyph_bbx, (char *) &glp->bbx, - sizeof(bdf_bbx_t)); - - if (glp->bbx.height < glp->bbx.ascent + glp->bbx.descent) - gsize = glp->bbx.ascent + glp->bbx.descent; - else - gsize = glp->bbx.height; - - /* - * Figure the maximum of the glyph width and height. - */ - gsize = MAX(gr->glyph_bbx.width, gsize); - - /* - * If either the grid width or grid height is less than the - * grid size just determined, then adjust them to the new grid size. - */ - gr->grid_width = MAX(gr->grid_width, gsize); - gr->grid_height = MAX(gr->grid_height, gsize); - } else { - /* - * The glyph doesn't exist, so make up a name for it. - */ - if (unencoded) - sprintf(name, "unencoded%ld", code); - else - sprintf(name, "char%ld", code); - gr->name = (char *) malloc(strlen(name) + 1); - (void) memcpy(gr->name, name, strlen(name) + 1); - } - - /* - * If the font has character-cell or mono spacing, make sure the grid - * device width is set to the width stored in the font. - */ - if (gr->spacing != BDF_PROPORTIONAL) - gr->dwidth = font->monowidth; - - /* - * Determine the vertical origin based on the font bounding box. - */ - if (ht >= as + ds) - gr->base_y = (((gr->grid_height >> 1) - (ht >> 1)) + ht) - ds; - else - gr->base_y = ((gr->grid_height >> 1) - ((as + ds) >> 1)) + as; - - /* - * The final adjust is to check to see if the glyph positioned relative to - * the baseline would cause the grid to change size. This sometimes - * happens in fonts that have incorrect metrics. - */ - if (gr->base_y + gr->glyph_bbx.descent > gr->grid_height) { - gsize = gr->base_y + gr->glyph_bbx.descent; - gr->grid_width = MAX(gsize, gr->grid_width); - gr->grid_height = MAX(gsize, gr->grid_height); - } - - /* - * Determine the horizontal origin based on the font bounding box and - * centered within the grid. - */ - gr->base_x = (gr->grid_width >> 1) - (gr->font_bbx.width >> 1); - if (gr->font_bbx.x_offset < 0) - gr->base_x += MYABS(gr->font_bbx.x_offset); - - /* - * Allocate double the storage needed for the grid bitmap. The extra - * storage will be used for transformations. - */ - gr->bytes = ((((gr->grid_width * gr->bpp) + 7) >> 3) * - gr->grid_height) << 1; - gr->bitmap = (unsigned char *) malloc(gr->bytes); - (void) memset((char *) gr->bitmap, 0, gr->bytes); - - /* - * Initialize the top-left coordinates of the glyph to the baseline - * coordinates. - */ - gr->glyph_x = gr->base_x; - gr->glyph_y = gr->base_y; - - /* - * If the glyph was not found, simply return the empty grid. - */ - if (glp == 0) - return gr; - - /* - * Determine the top-left coordinates of the glyph with respect to the - * baseline coordinates. - */ - gr->glyph_x = nx = gr->base_x + gr->glyph_bbx.x_offset; - gr->glyph_y = ny = gr->base_y - gr->glyph_bbx.ascent; - - /* - * Now copy the glyph bitmap to the appropriate location in the - * grid. - */ - bpr = ((gr->glyph_bbx.width * gr->bpp) + 7) >> 3; - gsize = ((gr->grid_width * gr->bpp) + 7) >> 3; - for (y = 0; y < gr->glyph_bbx.height; y++, ny++) { - for (colx = nx * gr->bpp, col = x = 0; x < gr->glyph_bbx.width; - x++, col += gr->bpp, colx += gr->bpp) { - si = (col & 7) / gr->bpp; - byte = glp->bitmap[(y * bpr) + (col >> 3)] & masks[si]; - if (byte) { - di = (colx & 7) / gr->bpp; - if (di < si) - byte <<= (si - di) * gr->bpp; - else if (di > si) - byte >>= (di - si) * gr->bpp; - gr->bitmap[(ny * gsize) + (colx >> 3)] |= byte; - } - } - } - - /* - * Always crop the glyph to the ink bounds before editing. - */ - bdf_grid_crop(gr, 0); - - /* - * Return the grid. - */ - return gr; -} - -void -#ifdef __STDC__ -bdf_free_glyph_grid(bdf_glyph_grid_t *grid) -#else -bdf_free_glyph_grid(grid) -bdf_glyph_grid_t *grid; -#endif -{ - if (grid == 0) - return; - - if (grid->name != 0) - free(grid->name); - if (grid->bytes > 0) - free((char *) grid->bitmap); - if (grid->sel.bytes > 0) - free((char *) grid->sel.bitmap); - free((char *) grid); -} - -/************************************************************************** - * - * Glyph grid resize functions. - * - **************************************************************************/ - -/* - * Enlarge the grid without affecting the font or glyph metrics. - */ -int -#ifdef __STDC__ -bdf_grid_enlarge(bdf_glyph_grid_t *grid, unsigned short width, - unsigned short height) -#else -bdf_grid_enlarge(grid, width, height) -bdf_glyph_grid_t *grid; -unsigned short width, height; -#endif -{ - unsigned short si, di, col, colx, byte; - short ht, wd, as, ds, x, y, nx, ny; - unsigned short gwd, ght, bytes, obpr, nbpr, gsize; - unsigned char *bitmap, *masks; - - if (grid == 0 || (width < grid->grid_width && height < grid->grid_height)) - return 0; - - masks = 0; - switch (grid->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - ht = height; - as = grid->font_bbx.ascent; - ds = grid->font_bbx.descent; - - gwd = MAX(width, grid->grid_width); - ght = MAX(height, grid->grid_height); - gsize = MAX(gwd, ght); - - nbpr = ((gsize * grid->bpp) + 7) >> 3; - bytes = (nbpr * ght) << 1; - bitmap = (unsigned char *) malloc(bytes); - (void) memset((char *) bitmap, 0, bytes); - - /* - * Determine the new baseline. - */ - if (ht >= as + ds) - grid->base_y = (((ght >> 1) - (ht >> 1)) + ht) - ds; - else - grid->base_y = ((ght >> 1) - ((as + ds) >> 1)) + as; - - grid->base_x = (gwd >> 1) - (grid->font_bbx.width >> 1); - if (grid->font_bbx.x_offset < 0) - grid->base_x += MYABS(grid->font_bbx.x_offset); - - nx = grid->base_x + grid->glyph_bbx.x_offset; - ny = grid->base_y - grid->glyph_bbx.ascent; - - /* - * Now copy the bitmap into the new storage base on the new metrics - * values. - */ - obpr = ((grid->grid_width * grid->bpp) + 7) >> 3; - wd = grid->glyph_x + grid->glyph_bbx.width; - ht = grid->glyph_y + grid->glyph_bbx.height; - for (y = grid->glyph_y; y < ht; y++, ny++) { - col = grid->glyph_x * grid->bpp; - colx = nx * grid->bpp; - for (x = grid->glyph_x; x < wd; - x++, col += grid->bpp, colx += grid->bpp) { - si = (col & 7) / grid->bpp; - byte = grid->bitmap[(y * obpr) + (col >> 3)] & masks[si]; - if (byte) { - di = (colx & 7) / grid->bpp; - if (di < si) - byte <<= (si - di) * grid->bpp; - else if (di > si) - byte >>= (di - si) * grid->bpp; - bitmap[(ny * nbpr) + (colx >> 3)] |= byte; - } - } - } - - /* - * Adjust the glyph coordinates. - */ - grid->glyph_x = grid->base_x + grid->glyph_bbx.x_offset; - grid->glyph_y = grid->base_y - grid->glyph_bbx.ascent; - - /* - * Get rid of the old grid bitmap and replace it with the new one. - */ - free((char *) grid->bitmap); - grid->bytes = bytes; - grid->bitmap = bitmap; - - /* - * Update the new grid width and height. - */ - grid->grid_width = grid->grid_height = gsize; - - /* - * Always mark the grid as being modified on a resize. - */ - grid->modified = 1; - - return 1; -} - -/* - * Change the font bounding box values and resize the grid bitmap if - * necessary. - */ -int -#ifdef __STDC__ -bdf_grid_resize(bdf_glyph_grid_t *grid, bdf_metrics_t *metrics) -#else -bdf_grid_resize(grid, metrics) -bdf_glyph_grid_t *grid; -bdf_metrics_t *metrics; -#endif -{ - int changed; - unsigned short si, di, col, colx, byte; - short ht, wd, as, ds, x, y, nx, ny; - unsigned short gwd, ght, bytes, obpr, nbpr, gsize; - unsigned char *bitmap, *masks; - - changed = 0; - - if (grid == 0 || metrics == 0) - return changed; - - masks = 0; - switch (grid->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - /* - * Create new grid bitmaps in preparation for the various metrics changing. - */ - if (metrics->width > grid->grid_width || - metrics->height > grid->grid_height) { - changed = 1; - - ht = metrics->height; - as = metrics->ascent; - ds = metrics->descent; - - gwd = MAX(metrics->width, grid->grid_width); - ght = MAX(metrics->height, grid->grid_height); - - /* - * Get the larger of the two dimensions. - */ - gsize = MAX(gwd, ght); - - nbpr = ((gsize * grid->bpp) + 7) >> 3; - bytes = (nbpr * gsize) << 1; - bitmap = (unsigned char *) malloc(bytes); - (void) memset((char *) bitmap, 0, bytes); - - /* - * Determine the new baseline. - */ - if (ht >= as + ds) - grid->base_y = (((ght >> 1) - (ht >> 1)) + ht) - ds; - else - grid->base_y = ((ght >> 1) - ((as + ds) >> 1)) + as; - - grid->base_x = (gwd >> 1) - (metrics->width >> 1); - if (metrics->x_offset < 0) - grid->base_x += MYABS(metrics->x_offset); - - nx = grid->base_x + grid->glyph_bbx.x_offset; - ny = grid->base_y - grid->glyph_bbx.ascent; - - /* - * Now copy the bitmap into the new storage base on the new metrics - * values. - */ - obpr = ((grid->grid_width * grid->bpp) + 7) >> 3; - wd = grid->glyph_x + grid->glyph_bbx.width; - ht = grid->glyph_y + grid->glyph_bbx.height; - for (y = grid->glyph_y; y < ht; y++, ny++) { - col = grid->glyph_x * grid->bpp; - colx = nx * grid->bpp; - for (x = grid->glyph_x; x < wd; - x++, col += grid->bpp, colx += grid->bpp) { - si = (col & 7) / grid->bpp; - byte = grid->bitmap[(y * obpr) + (col >> 3)] & masks[si]; - if (byte) { - di = (colx & 7) / grid->bpp; - if (di < si) - byte <<= (si - di) * grid->bpp; - else if (di > si) - byte >>= (di - si) * grid->bpp; - bitmap[(ny * nbpr) + (colx >> 3)] |= byte; - } - } - } - - /* - * Adjust the glyph coordinates. - */ - grid->glyph_x = grid->base_x + grid->glyph_bbx.x_offset; - grid->glyph_y = grid->base_y - grid->glyph_bbx.ascent; - - /* - * Get rid of the old grid bitmap and replace it with the new one. - */ - free((char *) grid->bitmap); - grid->bytes = bytes; - grid->bitmap = bitmap; - - /* - * Update the new grid width and height. - */ - grid->grid_width = grid->grid_height = gsize; - - /* - * Copy the metrics info into the font bounding box. - */ - grid->font_bbx.width = metrics->width; - grid->font_bbx.x_offset = metrics->x_offset; - grid->font_bbx.height = metrics->height; - grid->font_bbx.ascent = metrics->ascent; - grid->font_bbx.descent = metrics->descent; - grid->font_bbx.y_offset = metrics->y_offset; - } else { - /* - * The grid does not need to resized, but the baseline must - * be recalculated and the bitmap copied again. - */ - bytes = grid->bytes >> 1; - bitmap = grid->bitmap + bytes; - (void) memset((char *) bitmap, 0, bytes); - - ht = metrics->height; - as = metrics->ascent; - ds = metrics->descent; - - gwd = grid->grid_width; - ght = grid->grid_height; - - /* - * Determine the new baseline. - */ - if (ht >= as + ds) - grid->base_y = (((ght >> 1) - (ht >> 1)) + ht) - ds; - else - grid->base_y = ((ght >> 1) - ((as + ds) >> 1)) + as; - - grid->base_x = (gwd >> 1) - (metrics->width >> 1); - if (metrics->x_offset < 0) - grid->base_x += MYABS(metrics->x_offset); - - nx = grid->base_x + grid->glyph_bbx.x_offset; - ny = grid->base_y - grid->glyph_bbx.ascent; - - wd = grid->glyph_x + grid->glyph_bbx.width; - ht = grid->glyph_y + grid->glyph_bbx.height; - - obpr = nbpr = ((grid->grid_width * grid->bpp) + 7) >> 3; - for (y = grid->glyph_y; y < ht; y++, ny++) { - col = grid->glyph_x * grid->bpp; - colx = nx * grid->bpp; - for (x = grid->glyph_x; x < wd; - x++, col += grid->bpp, colx += grid->bpp) { - si = (col & 7) / grid->bpp; - byte = grid->bitmap[(y * obpr) + (col >> 3)] & masks[si]; - if (byte) { - di = (colx & 7) / grid->bpp; - if (di < si) - byte <<= (si - di) * grid->bpp; - else if (di > si) - byte >>= (di - si) * grid->bpp; - bitmap[(ny * nbpr) + (colx >> 3)] |= byte; - } - } - } - - /* - * Copy the adjusted bitmap back into the main area. - */ - (void) memcpy((char *) grid->bitmap, (char *) bitmap, bytes); - - /* - * Adjust the glyph coordinates. - */ - grid->glyph_x = grid->base_x + grid->glyph_bbx.x_offset; - grid->glyph_y = grid->base_y - grid->glyph_bbx.ascent; - - /* - * Copy the metrics info into the font bounding box. - */ - grid->font_bbx.width = metrics->width; - grid->font_bbx.x_offset = metrics->x_offset; - grid->font_bbx.height = metrics->height; - grid->font_bbx.ascent = metrics->ascent; - grid->font_bbx.descent = metrics->descent; - grid->font_bbx.y_offset = metrics->y_offset; - } - - /* - * If the font is not proportional, make sure the device width is adjusted - * to meet the new font bounding box. - */ - if (changed && grid->spacing != BDF_PROPORTIONAL) - grid->dwidth = grid->font_bbx.width; - - /* - * Always mark the grid as being modified on a resize. - */ - grid->modified = 1; - - return changed; -} - -int -#ifdef __STDC__ -bdf_grid_crop(bdf_glyph_grid_t *grid, int grid_modified) -#else -bdf_grid_crop(grid, grid_modified) -bdf_glyph_grid_t *grid; -int grid_modified; -#endif -{ - int cropped; - short x, y, delta, maxx, minx, maxy, miny, col; - unsigned short bpr; - unsigned char *masks; - - cropped = 0; - if (grid == 0) - return cropped; - - masks = 0; - switch (grid->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - bpr = ((grid->grid_width * grid->bpp) + 7) >> 3; - - maxx = maxy = -1; - minx = miny = grid->grid_width; - for (y = 0; y < grid->grid_height; y++) { - for (col = x = 0; x < grid->grid_width; x++, col += grid->bpp) { - if (grid->bitmap[(y * bpr) + (col >> 3)] & - masks[(col & 7) / grid->bpp]) { - minx = MIN(minx, x); - maxx = MAX(maxx, x); - miny = MIN(miny, y); - maxy = MAX(maxy, y); - } - } - } - - /* - * Handle an empty bitmap as a special case. - */ - if (maxx == -1) { - /* - * If the glyph bounding box indicated something was there originally, - * then indicate that it was cropped. - */ - if (grid->glyph_bbx.width != 0 || grid->glyph_bbx.height != 0) - cropped = 1; - (void) memset((char *) &grid->glyph_bbx, 0, sizeof(bdf_bbx_t)); - grid->glyph_x = grid->base_x; - grid->glyph_y = grid->base_y; - if (cropped) - grid->modified = 1; - return cropped; - } - - /* - * Increment the max points so width and height calculations won't go - * wrong. - */ - maxx++; - maxy++; - - if (minx != grid->glyph_x) { - cropped = 1; - delta = minx - grid->glyph_x; - grid->glyph_x += delta; - grid->glyph_bbx.x_offset += delta; - } - if (maxx - minx != grid->glyph_bbx.width) { - cropped = 1; - delta = (maxx - minx) - grid->glyph_bbx.width; - grid->glyph_bbx.width += delta; - if (grid->spacing == BDF_PROPORTIONAL) - grid->dwidth += delta; - } - - if (miny != grid->glyph_y) { - cropped = 1; - delta = miny - grid->glyph_y; - grid->glyph_y += delta; - grid->glyph_bbx.y_offset = - grid->base_y - (grid->glyph_y + (maxy - miny)); - } - if (maxy - miny != grid->glyph_bbx.height) { - cropped = 1; - delta = (maxy - miny) - grid->glyph_bbx.height; - grid->glyph_bbx.height += delta; - grid->glyph_bbx.y_offset = - grid->base_y - (grid->glyph_y + (maxy - miny)); - grid->glyph_bbx.ascent = - grid->glyph_bbx.height + grid->glyph_bbx.y_offset; - grid->glyph_bbx.descent = -grid->glyph_bbx.y_offset; - } - - /* - * Indicate that the grid was modified if the glyph had to be cropped. - */ - if (cropped && grid_modified) - grid->modified = 1; - - return cropped; -} - -/************************************************************************** - * - * Glyph grid pixel functions. - * - **************************************************************************/ - -int -#ifdef __STDC__ -bdf_grid_set_pixel(bdf_glyph_grid_t *grid, short x, short y, int val) -#else -bdf_grid_set_pixel(grid, x, y, val) -bdf_glyph_grid_t *grid; -short x, y; -int val; -#endif -{ - unsigned short si, di, dx; - int set, bpr, delta; - unsigned char *masks; - - set = 0; - - if (grid == 0 || x < 0 || x >= grid->grid_width || - y < 0 || y >= grid->grid_height) - return set; - - si = 0; - masks = 0; - switch (grid->bpp) { - case 1: - masks = onebpp; - si = 7; - break; - case 2: - masks = twobpp; - si = 3; - break; - case 4: - masks = fourbpp; - si = 1; - break; - } - - /* - * Remove any unused bits from the value. - */ - val &= masks[si]; - - dx = x * grid->bpp; - di = (dx & 7) / grid->bpp; - - /* - * Shift up the value to the appropriate place if necessary. - */ - if (di < si) - val <<= (si - di) * grid->bpp; - - /* - * Determine the bytes-per-row. - */ - bpr = ((grid->grid_width * grid->bpp) + 7) >> 3; - - /* - * If the bit is already set, simply return with an indication that - * nothing changed. - */ - if ((grid->bitmap[(y * bpr) + (dx >> 3)] & masks[di]) == val) - return set; - - /* - * Set the bit. - */ - set = 1; - - /* - * Clear the bits that will take the new value. - */ - grid->bitmap[(y * bpr) + (dx >> 3)] &= ~masks[di]; - grid->bitmap[(y * bpr) + (dx >> 3)] |= val; - - /* - * Adjust the glyph bounding box. - */ - if (x < grid->glyph_x) { - delta = grid->glyph_x - x; - grid->glyph_bbx.width += delta; - grid->glyph_bbx.x_offset -= delta; - if (grid->spacing == BDF_PROPORTIONAL) - grid->dwidth = grid->glyph_bbx.width + grid->glyph_bbx.x_offset; - grid->glyph_x -= delta; - } else if (x >= grid->glyph_x + grid->glyph_bbx.width) { - delta = x - (grid->glyph_x + grid->glyph_bbx.width) + 1; - grid->glyph_bbx.width += delta; - if (grid->spacing == BDF_PROPORTIONAL) - grid->dwidth = grid->glyph_bbx.width + grid->glyph_bbx.x_offset; - } - if (y < grid->glyph_y) { - delta = grid->glyph_y - y; - grid->glyph_bbx.ascent += delta; - grid->glyph_bbx.height += delta; - grid->glyph_y -= delta; - } else if (y >= grid->glyph_y + grid->glyph_bbx.height) { - delta = y - (grid->glyph_y + grid->glyph_bbx.height) + 1; - grid->glyph_bbx.descent += delta; - grid->glyph_bbx.height += delta; - grid->glyph_bbx.y_offset = -grid->glyph_bbx.descent; - } - - /* - * Indicate that the glyph was modified. - */ - grid->modified = 1; - - return set; -} - -int -#ifdef __STDC__ -bdf_grid_clear_pixel(bdf_glyph_grid_t *grid, short x, short y) -#else -bdf_grid_clear_pixel(grid, x, y) -bdf_glyph_grid_t *grid; -short x, y; -#endif -{ - int cleared, bpr; - short delta, maxx, minx, maxy, miny, wd, ht; - unsigned short di, dx; - unsigned char *masks; - - cleared = 0; - - if (grid == 0 || x < 0 || x >= grid->grid_width || - y < 0 || y >= grid->grid_height) - return cleared; - - masks = 0; - switch (grid->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - /* - * Determine the bytes-per-row. - */ - bpr = ((grid->grid_width * grid->bpp) + 7) >> 3; - - dx = x * grid->bpp; - di = (dx & 7) / grid->bpp; - - /* - * If the bit is already clear, simply return with an indication that - * nothing changed. - */ - if (!(grid->bitmap[(y * bpr) + (dx >> 3)] & masks[di])) - return cleared; - - /* - * Clear the bit. - */ - cleared = 1; - grid->bitmap[(y * bpr) + (dx >> 3)] &= ~masks[di]; - - /* - * Determine the new min and max values. - */ - maxx = maxy = 0; - minx = miny = 32767; - - wd = grid->glyph_x + grid->glyph_bbx.width; - ht = grid->glyph_y + grid->glyph_bbx.height; - - for (y = grid->glyph_y; y < ht; y++) { - dx = grid->glyph_x * grid->bpp; - for (x = grid->glyph_x; x < wd; x++, dx += grid->bpp) { - di = (dx & 7) / grid->bpp; - if (grid->bitmap[(y * bpr) + (dx >> 3)] & masks[di]) { - minx = MIN(minx, x); - maxx = MAX(maxx, x); - miny = MIN(miny, y); - maxy = MAX(maxy, y); - } - } - } - - /* - * If this call clears the last bit in the image, set the glyph origin - * to the base and return. - */ - if (maxx == 0) { - grid->glyph_x = grid->base_x; - grid->glyph_y = grid->base_y; - if (grid->spacing == BDF_PROPORTIONAL) - grid->dwidth = 0; - (void) memset((char *) &grid->glyph_bbx, 0, sizeof(grid->glyph_bbx)); - grid->modified = 1; - return cleared; - } - - /* - * Figure out the left and right bearing changes. - */ - if (minx > grid->glyph_x) { - delta = minx - grid->glyph_x; - grid->glyph_bbx.width -= delta; - grid->glyph_bbx.x_offset += delta; - if (grid->spacing == BDF_PROPORTIONAL) - grid->dwidth = grid->glyph_bbx.width + grid->glyph_bbx.x_offset; - grid->glyph_x += delta; - } else if (maxx < wd - 1) { - delta = (wd - 1) - maxx; - grid->glyph_bbx.width -= delta; - if (grid->spacing == BDF_PROPORTIONAL) - grid->dwidth = grid->glyph_bbx.width + grid->glyph_bbx.x_offset; - } - - if (miny > grid->glyph_y) { - delta = miny - grid->glyph_y; - grid->glyph_bbx.ascent -= delta; - grid->glyph_bbx.height -= delta; - grid->glyph_y += delta; - } else if (maxy < ht - 1) { - delta = (ht - 1) - maxy; - grid->glyph_bbx.descent -= delta; - grid->glyph_bbx.height -= delta; - grid->glyph_bbx.y_offset = -grid->glyph_bbx.descent; - } - - /* - * Indicate that the glyph was modified. - */ - grid->modified = 1; - - return cleared; -} - -int -#ifdef __STDC__ -bdf_grid_invert_pixel(bdf_glyph_grid_t *grid, short x, short y, int val) -#else -bdf_grid_invert_pixel(grid, x, y, val) -bdf_glyph_grid_t *grid; -short x, y; -int val; -#endif -{ - short bpr, di; - unsigned char *masks; - - if (grid == 0 || x < 0 || x >= grid->grid_width || - y < 0 || y >= grid->grid_height) - return 0; - - masks = 0; - switch (grid->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - /* - * Determine the bytes-per-row and mask index. - */ - bpr = ((grid->grid_width * grid->bpp) + 7) >> 3; - di = ((x * grid->bpp) & 7) / grid->bpp; - - /* - * If the bit is set, then clear it, otherwise, set it. - */ - if (grid->bitmap[(y * bpr) + ((x * grid->bpp) >> 3)] & masks[di]) - return bdf_grid_clear_pixel(grid, x, y); - else - return bdf_grid_set_pixel(grid, x, y, val); -} - -/************************************************************************** - * - * Glyph grid bitmap transformation functions. - * - **************************************************************************/ - -short -#ifdef __STDC__ -_bdf_ceiling(double v) -#else -_bdf_ceiling(v) -double v; -#endif -{ - short val, neg; - - val = neg = 0; - if (v < 0) { - neg = 1; - while (v < -1.0) { - val++; - v += 1.0; - } - } else if (v > 0) { - while (v > 1.0) { - val++; - v -= 1.0; - } - if (v > 0.0) - val++; - } - return (!neg) ? val : -val; -} - -static int -#ifdef __STDC__ -_bdf_rotate_selection(bdf_glyph_grid_t *grid, int mul90, short degrees) -#else -_bdf_rotate_selection(grid, mul90, degrees) -bdf_glyph_grid_t *grid; -int mul90; -short degrees; -#endif -{ - int rotated, byte; - short wd, ht, nx, ny, cx, cy, x, y, col; - short ox, oy, shiftx, shifty, si, di; - double dx, dy; - unsigned short bytes, bpr; - unsigned char *scratch, *masks; - - rotated = 0; - - /* - * Check to see if the number of rotations would have no affect by - * checking if the count is a multiple of 4 (mod 4 == 0). - */ - if (grid == 0 || degrees == 0) - return rotated; - - masks = 0; - switch (grid->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - bytes = grid->sel.bytes >> 1; - scratch = grid->sel.bitmap + bytes; - (void) memset((char *) scratch, 0, bytes); - - cx = grid->sel.width >> 1; - cy = grid->sel.height >> 1; - - wd = ht = MAX(grid->sel.width, grid->sel.height); - cx = cy = wd >> 1; - - bpr = ((wd * grid->bpp) + 7) >> 3; - - for (shiftx = shifty = y = 0; y < ht; y++) { - for (col = x = 0; x < wd; x++, col += grid->bpp) { - dx = (double)(x - cx); - dy = (double)(y - cy); - if (mul90) { - nx = cx + (short)((dx * _bdf_cos_tbl[degrees]) - - (dy * _bdf_sin_tbl[degrees])); - ny = cy + (short)((dx * _bdf_sin_tbl[degrees]) + - (dy * _bdf_cos_tbl[degrees])); - } else { - nx = cx + _bdf_ceiling((dx * _bdf_cos_tbl[degrees]) - - (dy * _bdf_sin_tbl[degrees])); - ny = cy + _bdf_ceiling((dx * _bdf_sin_tbl[degrees]) + - (dy * _bdf_cos_tbl[degrees])); - } - - /* - * Wrap the coordinates around the edges if necessary. - */ - if (nx < 0) { - shiftx = MIN(shiftx, nx); - nx += wd; - } else if (nx >= wd) { - ox = (nx - wd) + 1; - shiftx = MAX(shiftx, ox); - nx -= wd; - } - if (ny < 0) { - shifty = MIN(shifty, ny); - ny += ht; - } else if (ny >= ht) { - oy = (ny - ht) + 1; - shifty = MAX(shifty, oy); - ny -= ht; - } - - si = (col & 7) / grid->bpp; - byte = grid->sel.bitmap[(y * bpr) + (col >> 3)] & masks[si]; - if (byte) { - rotated = 1; - nx *= grid->bpp; - di = (nx & 7) / grid->bpp; - if (di < si) - byte <<= (si - di) * grid->bpp; - else if (di > si) - byte >>= (di - si) * grid->bpp; - scratch[(ny * bpr) + (nx >> 3)] |= byte; - } - } - } - - if (rotated) { - /* - * If a shift is required, then shift the scratch area back into - * the main bitmap. - */ - if (shiftx || shifty) { - (void) memset((char *) grid->sel.bitmap, 0, bytes); - for (y = 0; y < ht; y++) { - for (col = x = 0; x < wd; x++, col += grid->bpp) { - si = (col & 7) / grid->bpp; - byte = scratch[(y * bpr) + (col >> 3)] & masks[si]; - if (byte) { - nx = x - shiftx; - ny = y - shifty; - - if (nx < 0) - nx += wd; - else if (nx >= wd) - nx -= wd; - if (ny < 0) - ny += ht; - else if (ny >= ht) - ny -= ht; - - nx *= grid->bpp; - di = (nx & 7) / grid->bpp; - if (di < si) - byte <<= (si - di) * grid->bpp; - else if (di > si) - byte >>= (di - si) * grid->bpp; - grid->sel.bitmap[(ny * bpr) + (nx >> 3)] |= byte; - } - } - } - } else - /* - * Copy the scratch buffer back to the main buffer. - */ - (void) memcpy((char *) grid->sel.bitmap, (char *) scratch, bytes); - - /* - * Determine the new selection width and height. - */ - ox = oy = 0; - nx = ny = 16384; - for (y = 0; y < ht; y++) { - for (col = x = 0; x < wd; x++, col += grid->bpp) { - si = (col & 7) / grid->bpp; - if (grid->sel.bitmap[(y * bpr) + (col >> 3)] & masks[si]) { - ox = MAX(ox, x); - nx = MIN(nx, x); - oy = MAX(oy, y); - ny = MIN(ny, y); - } - } - } - - /* - * Recalculate the center corrdinates so the selection will be - * positioned nicely once it is shifted to the upper left corner. - */ - cx = grid->sel.width >> 1; - cy = grid->sel.height >> 1; - - /* - * Set the new width and height. - */ - grid->sel.width = (ox - nx) + 1; - grid->sel.height = (oy - ny) + 1; - - /* - * Shift again to force the selection to the upper left corner. - */ - if (nx || ny) { - (void) memset((char *) scratch, 0, bytes); - for (y = 0; y < ht; y++) { - for (col = x = 0; x < wd; x++, col += grid->bpp) { - si = (col & 7) / grid->bpp; - byte = grid->sel.bitmap[(y * bpr) + (col >> 3)] & - masks[si]; - if (byte) { - oy = y - ny; - ox = (x - nx) * grid->bpp; - di = (ox & 7) / grid->bpp; - if (di < si) - byte <<= (si - di) * grid->bpp; - else if (di > si) - byte >>= (di - si) * grid->bpp; - scratch[(oy * bpr) + (ox >> 3)] |= byte; - } - } - } - (void) memcpy((char *) grid->sel.bitmap, (char *) scratch, bytes); - } - - /* - * Determine the new top left coordinates from the center coordinates. - */ - grid->sel.x = (grid->sel.x + cx) - (grid->sel.width >> 1); - grid->sel.y = (grid->sel.y + cy) - (grid->sel.height >> 1); - - /* - * If the rotation caused the selection rectangle to overlap the edges - * of the grid, shift it so it is completely visible again. - */ - if (grid->sel.x + grid->sel.width > grid->grid_width) - grid->sel.x -= (grid->sel.x + grid->sel.width) - grid->grid_width; - if (grid->sel.y + grid->sel.height > grid->grid_height) - grid->sel.y -= (grid->sel.y + grid->sel.height) - grid->grid_height; - - /* - * Mark the grid as being modified. - */ - grid->modified = 1; - } - - return rotated; -} - -static void -#ifdef __STDC__ -_bdf_rotate_resize(bdf_glyph_grid_t *grid, int mul90, short degrees, - int *resize) -#else -_bdf_rotate_resize(grid, mul90, degrees, resize) -bdf_glyph_grid_t *grid; -int mul90; -short degrees; -int *resize; -#endif -{ - unsigned short wd, ht; - short cx, cy, x1, y1, x2, y2; - double dx1, dy1, dx2, dy2; - bdf_metrics_t metrics; - - *resize = 0; - (void) memset((char *) &metrics, 0, sizeof(bdf_metrics_t)); - - metrics.x_offset = grid->font_bbx.x_offset; - metrics.width = grid->font_bbx.width; - metrics.ascent = grid->font_bbx.ascent; - metrics.descent = grid->font_bbx.descent; - metrics.height = grid->font_bbx.height; - metrics.y_offset = grid->font_bbx.y_offset; - - cx = grid->glyph_x + (grid->glyph_bbx.width >> 1); - cy = grid->glyph_y + (grid->glyph_bbx.height >> 1); - - /* - * Rotate the lower left and upper right corners and check for a potential - * resize. - */ - x1 = grid->glyph_x; - y1 = grid->glyph_y + grid->glyph_bbx.height; - x2 = grid->glyph_x + grid->glyph_bbx.width; - y2 = grid->glyph_y; - - dx1 = (double)(x1 - cx); - dy1 = (double)(y1 - cy); - dx2 = (double)(x2 - cx); - dy2 = (double)(y2 - cx); - - if (mul90) { - x1 = cx + (short)((dx1 * _bdf_cos_tbl[degrees]) - - (dy1 * _bdf_sin_tbl[degrees])); - y1 = cy + (short)((dx1 * _bdf_sin_tbl[degrees]) + - (dy1 * _bdf_cos_tbl[degrees])); - x2 = cx + (short)((dx2 * _bdf_cos_tbl[degrees]) - - (dy2 * _bdf_sin_tbl[degrees])); - y2 = cy + (short)((dx2 * _bdf_sin_tbl[degrees]) + - (dy2 * _bdf_cos_tbl[degrees])); - } else { - x1 = cx + _bdf_ceiling((dx1 * _bdf_cos_tbl[degrees]) - - (dy1 * _bdf_sin_tbl[degrees])); - y1 = cy + _bdf_ceiling((dx1 * _bdf_sin_tbl[degrees]) + - (dy1 * _bdf_cos_tbl[degrees])); - x2 = cx + _bdf_ceiling((dx2 * _bdf_cos_tbl[degrees]) - - (dy2 * _bdf_sin_tbl[degrees])); - y2 = cy + _bdf_ceiling((dx2 * _bdf_sin_tbl[degrees]) + - (dy2 * _bdf_cos_tbl[degrees])); - } - - wd = MYABS(x2 - x1); - ht = MYABS(y2 - y1); - if (wd > metrics.width) { - metrics.width += wd - grid->font_bbx.width; - *resize = 1; - } - if (ht > metrics.height) { - metrics.ascent += ht - grid->font_bbx.height; - metrics.height += ht - grid->font_bbx.height; - *resize = 1; - } - - /* - * Rotate the upper left and lower right corners and check for a potential - * resize. - */ - x1 = grid->glyph_x; - y1 = grid->glyph_y; - x2 = grid->glyph_x + grid->glyph_bbx.width; - y2 = grid->glyph_y + grid->glyph_bbx.height; - - dx1 = (double)(x1 - cx); - dy1 = (double)(y1 - cy); - dx2 = (double)(x2 - cx); - dy2 = (double)(y2 - cx); - - if (mul90) { - x1 = cx + (short)((dx1 * _bdf_cos_tbl[degrees]) - - (dy1 * _bdf_sin_tbl[degrees])); - y1 = cy + (short)((dx1 * _bdf_sin_tbl[degrees]) + - (dy1 * _bdf_cos_tbl[degrees])); - x2 = cx + (short)((dx2 * _bdf_cos_tbl[degrees]) - - (dy2 * _bdf_sin_tbl[degrees])); - y2 = cy + (short)((dx2 * _bdf_sin_tbl[degrees]) + - (dy2 * _bdf_cos_tbl[degrees])); - } else { - x1 = cx + _bdf_ceiling((dx1 * _bdf_cos_tbl[degrees]) - - (dy1 * _bdf_sin_tbl[degrees])); - y1 = cy + _bdf_ceiling((dx1 * _bdf_sin_tbl[degrees]) + - (dy1 * _bdf_cos_tbl[degrees])); - x2 = cx + _bdf_ceiling((dx2 * _bdf_cos_tbl[degrees]) - - (dy2 * _bdf_sin_tbl[degrees])); - y2 = cy + _bdf_ceiling((dx2 * _bdf_sin_tbl[degrees]) + - (dy2 * _bdf_cos_tbl[degrees])); - } - - wd = MYABS(x2 - x1); - ht = MYABS(y2 - y1); - if (wd > metrics.width) { - metrics.width += wd - grid->font_bbx.width; - *resize = 1; - } - if (ht > metrics.height) { - metrics.ascent += ht - grid->font_bbx.height; - metrics.height += ht - grid->font_bbx.height; - *resize = 1; - } - - if (*resize) - (void) bdf_grid_resize(grid, &metrics); -} - -static void -#ifdef __STDC__ -_bdf_shear_resize(bdf_glyph_grid_t *grid, short degrees, int neg, int *resize) -#else -_bdf_shear_resize(grid, degrees, neg, resize) -bdf_glyph_grid_t *grid; -short degrees; -int neg, *resize; -#endif -{ - unsigned short wd; - short x1, y1, x2, y2; - bdf_metrics_t metrics; - - *resize = 0; - (void) memset((char *) &metrics, 0, sizeof(bdf_metrics_t)); - - metrics.x_offset = grid->font_bbx.x_offset; - metrics.width = grid->font_bbx.width; - metrics.ascent = grid->font_bbx.ascent; - metrics.descent = grid->font_bbx.descent; - metrics.height = grid->font_bbx.height; - metrics.y_offset = grid->font_bbx.y_offset; - - /* - * Shear the lower left and upper right corners and check for a potential - * resize. - */ - x1 = 0; - y1 = grid->glyph_bbx.height; - x2 = grid->glyph_bbx.width; - y2 = 0; - - if (neg) { - x1 += (short)((double) y1 * _bdf_tan_tbl[degrees]); - x2 += (short)((double) y2 * _bdf_tan_tbl[degrees]); - } else { - x1 += (short)((double)(grid->glyph_bbx.height - y1) * - _bdf_tan_tbl[degrees]); - x2 += (short)((double)(grid->glyph_bbx.height - y2) * - _bdf_tan_tbl[degrees]); - } - - wd = MYABS(x2 - x1); - if (wd > metrics.width) { - metrics.width += wd - grid->font_bbx.width; - *resize = 1; - } - - /* - * Shear the upper left and lower right corners and check for a potential - * resize. - */ - x1 = 0; - y1 = 0; - x2 = grid->glyph_bbx.width; - y2 = grid->glyph_bbx.height; - - if (neg) { - x1 += (short)((double) y1 * _bdf_tan_tbl[degrees]); - x2 += (short)((double) y2 * _bdf_tan_tbl[degrees]); - } else { - x1 += (short)((double)(grid->glyph_bbx.height - y1) * - _bdf_tan_tbl[degrees]); - x2 += (short)((double)(grid->glyph_bbx.height - y2) * - _bdf_tan_tbl[degrees]); - } - - wd = MYABS(x2 - x1); - if (wd > metrics.width) { - metrics.width += wd - grid->font_bbx.width; - *resize = 1; - } - - if (*resize) - (void) bdf_grid_resize(grid, &metrics); -} - -/* - * Rotate the bitmap in the grid by some number of degrees. - */ -int -#ifdef __STDC__ -bdf_grid_rotate(bdf_glyph_grid_t *grid, short degrees, int *resize) -#else -bdf_grid_rotate(grid, degrees, resize) -bdf_glyph_grid_t *grid; -short degrees; -int *resize; -#endif -{ - int rotated, mul90; - short nx, ny, cx, cy, x, y, wd, ht; - short ox, oy, gx, gy, shiftx, shifty; - unsigned short si, di, col, byte; - double dx, dy; - unsigned short bytes, bpr; - unsigned char *scratch, *masks; - - rotated = 0; - - /* - * Make sure the number of degrees is between 0 and 359 and adjusted to a - * positive number of degrees if necessary. - */ - while (degrees < 0) - degrees += 360; - while (degrees >= 360) - degrees -= 360; - - if (grid == 0 || degrees == 0 || - (grid->glyph_bbx.width == 0 && grid->glyph_bbx.height == 0)) - return rotated; - - masks = 0; - switch (grid->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - mul90 = ((degrees % 90) == 0) ? 1 : 0; - - /* - * Force the grid to resize if the rotation requires it. - */ - _bdf_rotate_resize(grid, mul90, degrees, resize); - - if (grid->sel.width != 0 && grid->sel.height != 0) - return _bdf_rotate_selection(grid, mul90, degrees); - - /* - * Halve the byte count in the grid for later use. - */ - bytes = grid->bytes >> 1; - - /* - * Point at the scratch buffer area and initialize it. - */ - scratch = grid->bitmap + bytes; - (void) memset((char *) scratch, 0, bytes); - - /* - * Determine the bytes per row. - */ - bpr = ((grid->grid_width * grid->bpp) + 7) >> 3; - - /* - * Determine the center coordinates of the glyph bitmap rectangle. - */ - cx = grid->glyph_x + (grid->glyph_bbx.width >> 1); - cy = grid->glyph_y + (grid->glyph_bbx.height >> 1); - - /* - * Only run over the rectangle containing the glyph itself. - */ - gx = grid->glyph_x; - gy = grid->glyph_y; - - wd = gx + grid->glyph_bbx.width; - ht = gy + grid->glyph_bbx.height; - - /* - * Initialize the adjustment counts used if the bitmap - * wraps around the edge. - */ - shiftx = shifty = 0; - - for (y = gy; y < ht; y++) { - col = gx * grid->bpp; - for (x = gx; x < wd; x++, col += grid->bpp) { - - /* - * Rotate the point. - */ - dx = (double)(x - cx); - dy = (double)(y - cy); - if (mul90) { - nx = cx + (short)((dx * _bdf_cos_tbl[degrees]) - - (dy * _bdf_sin_tbl[degrees])); - ny = cy + (short)((dx * _bdf_sin_tbl[degrees]) + - (dy * _bdf_cos_tbl[degrees])); - } else { - nx = cx + _bdf_ceiling((dx * _bdf_cos_tbl[degrees]) - - (dy * _bdf_sin_tbl[degrees])); - ny = cy + _bdf_ceiling((dx * _bdf_sin_tbl[degrees]) + - (dy * _bdf_cos_tbl[degrees])); - } - - /* - * Wrap the coordinates around the edges if necessary. - */ - if (nx < 0) { - shiftx = MIN(shiftx, nx); - nx += grid->grid_width; - } else if (nx >= grid->grid_width) { - ox = (nx - grid->grid_width) + 1; - shiftx = MAX(shiftx, ox); - nx -= grid->grid_width; - } - if (ny < 0) { - shifty = MIN(shifty, ny); - ny += grid->grid_height; - } else if (ny >= grid->grid_height) { - oy = (ny - grid->grid_height) + 1; - shifty = MAX(shifty, oy); - ny -= grid->grid_height; - } - - si = (col & 7) / grid->bpp; - byte = grid->bitmap[(y * bpr) + (col >> 3)] & masks[si]; - if (byte) { - rotated = 1; - nx *= grid->bpp; - di = (nx & 7) / grid->bpp; - if (di < si) - byte <<= (si - di) * grid->bpp; - else if (di > si) - byte >>= (di - si) * grid->bpp; - scratch[(ny * bpr) + (nx >> 3)] |= byte; - } - } - } - - if (rotated) { - /* - * If a shift is required, then shift the scratch area back into - * the main bitmap. - */ - if (shiftx || shifty) { - (void) memset((char *) grid->bitmap, 0, bytes); - for (y = 0; y < grid->grid_height; y++) { - for (col = x = 0; x < grid->grid_width; - x++, col += grid->bpp) { - si = (col & 7) / grid->bpp; - byte = scratch[(y * bpr) + (col >> 3)] & masks[si]; - if (byte) { - nx = x - shiftx; - ny = y - shifty; - - if (nx < 0) - nx += grid->grid_width; - else if (nx >= grid->grid_width) - nx -= grid->grid_width; - if (ny < 0) - ny += grid->grid_height; - else if (ny >= grid->grid_height) - ny -= grid->grid_height; - - nx *= grid->bpp; - di = (nx & 7) / grid->bpp; - if (di < si) - byte <<= (si - di) * grid->bpp; - else if (di > si) - byte >>= (di - si) * grid->bpp; - grid->bitmap[(ny * bpr) + (nx >> 3)] |= byte; - } - } - } - } else - /* - * Copy the scratch buffer back to the main buffer. - */ - (void) memcpy((char *) grid->bitmap, (char *) scratch, bytes); - - /* - * Determine the new glyph bounding box and the top left coordinates. - */ - ox = oy = 0; - nx = ny = 16384; - for (y = 0; y < grid->grid_height; y++) { - for (col = x = 0; x < grid->grid_width; x++, col += grid->bpp) { - si = (col & 7) / grid->bpp; - if (grid->bitmap[(y * bpr) + (col >> 3)] & masks[si]) { - nx = MIN(nx, x); - ox = MAX(ox, x); - ny = MIN(ny, y); - oy = MAX(oy, y); - } - } - } - - /* - * Set the new top left corrdinates. - */ - grid->glyph_x = nx; - grid->glyph_y = ny; - - /* - * Set the new glyph bounding box. - */ - grid->glyph_bbx.width = (ox - nx) + 1; - grid->glyph_bbx.x_offset = nx - grid->base_x; - grid->glyph_bbx.height = (oy - ny) + 1; - grid->glyph_bbx.ascent = grid->base_y - ny; - grid->glyph_bbx.descent = grid->glyph_bbx.height - - grid->glyph_bbx.ascent; - grid->glyph_bbx.y_offset = -grid->glyph_bbx.descent; - - /* - * Mark the grid as being modified. - */ - grid->modified = 1; - } - - return rotated; -} - -int -#ifdef __STDC__ -bdf_grid_shear(bdf_glyph_grid_t *grid, short degrees, int *resize) -#else -bdf_grid_shear(grid, degrees, resize) -bdf_glyph_grid_t *grid; -short degrees; -int *resize; -#endif -{ - int sheared, neg; - short cx, cy, wd, ht, gx, gy, x, y; - short nx, ox, ny, oy, shiftx, shifty; - unsigned short bytes, bpr, si, di, col, byte; - unsigned char *scratch, *masks; - - sheared = 0; - - if (degrees == 0 || degrees < -45 || degrees > 45 || grid == 0 || - (grid->glyph_bbx.width == 0 && grid->glyph_bbx.height == 0)) - return sheared; - - if ((neg = (degrees < 0))) - degrees = -degrees; - - /* - * Check to see if the grid needs to be resized to hold the sheared glyph. - */ - _bdf_shear_resize(grid, degrees, neg, resize); - - masks = 0; - switch (grid->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - /* - * Halve the byte count in the grid for later use. - */ - bytes = grid->bytes >> 1; - - /* - * Point at the scratch buffer area and initialize it. - */ - scratch = grid->bitmap + bytes; - (void) memset((char *) scratch, 0, bytes); - - /* - * Determine the bytes per row. - */ - bpr = ((grid->grid_width * grid->bpp) + 7) >> 3; - - /* - * Determine the center coordinates of the glyph bitmap rectangle. - */ - gx = grid->glyph_x; - gy = grid->glyph_y; - - cx = gx + (grid->glyph_bbx.width >> 1); - cy = gy + (grid->glyph_bbx.height >> 1); - - wd = gx + grid->glyph_bbx.width; - ht = gy + grid->glyph_bbx.height; - - shiftx = shifty = 0; - for (y = gy; y < ht; y++) { - col = gx * grid->bpp; - for (x = gx; x < wd; x++, col += grid->bpp) { - ny = y; - if (neg) - nx = x + (short)((double) y * _bdf_tan_tbl[degrees]); - else - nx = x + (short)((double)(gy + (ht - y)) * - _bdf_tan_tbl[degrees]); - - if (nx < 0) { - shiftx = MIN(shiftx, nx); - nx += grid->grid_width; - } else if (nx >= grid->grid_width) { - ox = (nx - grid->grid_width) + 1; - shiftx = MAX(shiftx, ox); - nx -= grid->grid_width; - } - if (ny < 0) { - shifty = MIN(shifty, ny); - ny += grid->grid_height; - } else if (ny >= grid->grid_height) { - oy = (ny - grid->grid_height) + 1; - shifty = MAX(shifty, oy); - ny -= grid->grid_height; - } - - si = (col & 7) / grid->bpp; - byte = grid->bitmap[(y * bpr) + (col >> 3)] & masks[si]; - if (byte) { - sheared = 1; - nx *= grid->bpp; - di = (nx & 7) / grid->bpp; - if (di < si) - byte <<= (si - di) * grid->bpp; - else if (di > si) - byte >>= (di - si) * grid->bpp; - scratch[(y * bpr) + (nx >> 3)] |= byte; - } - } - } - - if (sheared) { - /* - * If a shift is required, then shift the scratch area back into - * the main bitmap. - */ - if (shiftx || shifty) { - (void) memset((char *) grid->bitmap, 0, bytes); - for (y = 0; y < grid->grid_height; y++) { - for (col = x = 0; x < grid->grid_width; - x++, col += grid->bpp) { - si = (col & 7) / grid->bpp; - byte = scratch[(y * bpr) + (col >> 3)] & masks[si]; - if (byte) { - nx = x - shiftx; - ny = y - shifty; - - if (nx < 0) - nx += grid->grid_width; - else if (nx >= grid->grid_width) - nx -= grid->grid_width; - if (ny < 0) - ny += grid->grid_height; - else if (ny >= grid->grid_height) - ny -= grid->grid_height; - - nx *= grid->bpp; - di = (nx & 7) / grid->bpp; - if (di < si) - byte <<= (si - di) * grid->bpp; - else if (di > si) - byte >>= (di - si) * grid->bpp; - grid->bitmap[(ny * bpr) + (nx >> 3)] |= byte; - } - } - } - } else - /* - * Copy the scratch buffer back to the main buffer. - */ - (void) memcpy((char *) grid->bitmap, (char *) scratch, bytes); - - ox = oy = 0; - nx = ny = 16384; - for (y = 0; y < grid->grid_height; y++) { - for (col = x = 0; x < grid->grid_width; x++, col += grid->bpp) { - si = (col & 7) / grid->bpp; - if (grid->bitmap[(y * bpr) + (col >> 3)] & masks[si]) { - ox = MAX(ox, x); - nx = MIN(nx, x); - oy = MAX(oy, y); - ny = MIN(ny, y); - } - } - } - - /* - * Set the new top left corrdinates. - */ - grid->glyph_x = nx; - grid->glyph_y = ny; - - /* - * Set the new glyph bounding box. - */ - grid->glyph_bbx.width = (ox - nx) + 1; - grid->glyph_bbx.x_offset = nx - grid->base_x; - grid->glyph_bbx.height = (oy - ny) + 1; - grid->glyph_bbx.ascent = grid->base_y - ny; - grid->glyph_bbx.descent = grid->glyph_bbx.height - - grid->glyph_bbx.ascent; - grid->glyph_bbx.y_offset = -grid->glyph_bbx.descent; - - /* - * Mark the grid as being modified. - */ - grid->modified = 1; - } - - return sheared; -} - -int -#ifdef __STDC__ -bdf_grid_embolden(bdf_glyph_grid_t *grid) -#else -bdf_grid_embolden(grid) -bdf_glyph_grid_t *grid; -#endif -{ - int done; - short wd, ht, gx, gy, x, y; - unsigned short b1, b2, bpr, si, di, col; - unsigned char *masks; - - done = 0; - - if (grid == 0 || - (grid->glyph_bbx.width == 0 && grid->glyph_bbx.height == 0)) - return done; - - masks = 0; - switch (grid->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - /* - * Determine the bytes per row. - */ - bpr = ((grid->grid_width * grid->bpp) + 7) >> 3; - - gx = grid->glyph_x; - gy = grid->glyph_y; - - wd = gx + grid->glyph_bbx.width; - ht = gy + grid->glyph_bbx.height; - - if (grid->spacing == BDF_PROPORTIONAL || - (grid->spacing == BDF_MONOWIDTH && - grid->glyph_bbx.width < grid->font_bbx.width)) - /* - * Only allow horizontal expansion in the cases that make sense. - */ - wd++; - - for (y = gy; y < ht; y++) { - col = (wd - 1) * grid->bpp; - for (x = wd - 1; x > gx; x--, col -= grid->bpp) { - si = (col & 7) / grid->bpp; - di = ((col - grid->bpp) & 7) / grid->bpp; - b1 = grid->bitmap[(y * bpr) + (col >> 3)] & masks[si]; - b2 = grid->bitmap[(y * bpr) + ((col - grid->bpp) >> 3)] & - masks[di]; - if (!b1 && b2) { - if (di < si) - b2 >>= (si - di) * grid->bpp; - else if (di > si) - b2 <<= (di - si) * grid->bpp; - grid->bitmap[(y * bpr) + (col >> 3)] |= b2; - /* - * Mark the grid as being modified. - */ - done = grid->modified = 1; - } - } - } - - /* - * Adjust the glyph width so it will be reflected when the glyph is stored - * back in the font. - */ - grid->glyph_bbx.width = wd - gx; - - return done; -} - -/************************************************************************** - * - * Glyph grid selection functions. - * - **************************************************************************/ - -int -#ifdef __STDC__ -bdf_has_selection(bdf_glyph_grid_t *grid, short *x, short *y, - short *width, short *height) -#else -bdf_has_selection(grid, x, y, width, height) -bdf_glyph_grid_t *grid; -short *x, *y, *width, *height; -#endif -{ - if (grid == 0 || (grid->sel.width == 0 && grid->sel.height == 0)) - return 0; - - if (x != 0) - *x = grid->sel.x; - if (y != 0) - *y = grid->sel.y; - if (width != 0) - *width = grid->sel.width; - if (height != 0) - *height = grid->sel.height; - - return 1; -} - -/* - * Select a rectangle on the grid. - */ -void -#ifdef __STDC__ -bdf_set_selection(bdf_glyph_grid_t *grid, short x, short y, - short width, short height) -#else -bdf_set_selection(grid, x, y, width, height) -bdf_glyph_grid_t *grid; -short x, y, width, height; -#endif -{ - short nx, ny, wd, ht, ssize, dx, dy, col; - unsigned short bytes, bpr, sbpr, si, di, byte; - unsigned char *masks; - - if (grid == 0) - return; - - /* - * Make sure the specified rectangle is within reasonable bounds. - */ - if (x < 0 || x >= grid->grid_width) - x = 0; - if (y < 0 || y >= grid->grid_height) - y = 0; - - if (x + width > grid->grid_width) - width = (x + width) - grid->grid_width; - if (y + height > grid->grid_height) - height = (y + height) - grid->grid_height; - - grid->sel.x = x; - grid->sel.y = y; - grid->sel.width = width; - grid->sel.height = height; - - /* - * Allocate enough space to represent a square the size of the largest - * of the width and height of the selection. This allows rotation and - * flipping of the selected bitmap. - */ - ssize = MAX(width, height); - - bytes = ((((ssize * grid->bpp) + 7) >> 3) * ssize) << 1; - - /* - * If the selection is being removed (width and height are 0), then simply - * return. - */ - if (bytes == 0) - return; - - masks = 0; - switch (grid->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - if (bytes > grid->sel.bytes) { - if (grid->sel.bytes == 0) - grid->sel.bitmap = (unsigned char *) malloc(bytes); - else - grid->sel.bitmap = (unsigned char *) - realloc((char *) grid->sel.bitmap, bytes); - grid->sel.bytes = bytes; - } else - bytes = grid->sel.bytes; - - /* - * Initialize the selection bitmap and copy the selected bits to it. - */ - (void) memset((char *) grid->sel.bitmap, 0, bytes); - - wd = x + width; - ht = y + height; - - bpr = ((grid->grid_width * grid->bpp) + 7) >> 3; - sbpr = ((grid->sel.width * grid->bpp) + 7) >> 3; - - for (ny = 0, dy = y; dy < ht; dy++, ny++) { - col = x * grid->bpp; - for (nx = 0, dx = x; dx < wd; - dx++, nx += grid->bpp, col += grid->bpp) { - si = (col & 7) / grid->bpp; - byte = grid->bitmap[(dy * bpr) + (col >> 3)] & masks[si]; - if (byte) { - di = (nx & 7) / grid->bpp; - if (di < si) - byte <<= (si - di) * grid->bpp; - else if (di > si) - byte >>= (di - si) * grid->bpp; - grid->sel.bitmap[(ny * sbpr) + (nx >> 3)] |= byte; - } - } - } -} - -/* - * Detach a selection in preparation for moving it. What is does is clear the - * bits set in the selection from the main grid. Again, this is only used for - * move operations. - */ -void -#ifdef __STDC__ -bdf_detach_selection(bdf_glyph_grid_t *grid) -#else -bdf_detach_selection(grid) -bdf_glyph_grid_t *grid; -#endif -{ - short sx, sy, x, y, wd, ht, dx; - unsigned short bpr, sbpr, si, di, byte; - unsigned char *masks; - - if (grid == 0 || (grid->sel.width == 0 && grid->sel.height == 0)) - return; - - masks = 0; - switch (grid->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - bpr = ((grid->grid_width * grid->bpp) + 7) >> 3; - sbpr = ((grid->sel.width * grid->bpp) + 7) >> 3; - - wd = grid->sel.x + grid->sel.width; - ht = grid->sel.y + grid->sel.height; - - for (sy = 0, y = grid->sel.y; y < ht; y++, sy++) { - for (sx = 0, x = grid->sel.x; x < wd; x++, sx += grid->bpp) { - si = (sx & 7) / grid->bpp; - byte = grid->sel.bitmap[(sy * sbpr) + (sx >> 3)] & masks[si]; - if (byte) { - dx = x * grid->bpp; - di = (dx & 7) / grid->bpp; - grid->bitmap[(y * bpr) + (dx >> 3)] &= ~masks[di]; - } - } - } - - /* - * Crop the new image to determine the new bounds with the selection. - */ - (void) bdf_grid_crop(grid, 1); -} - -void -#ifdef __STDC__ -bdf_attach_selection(bdf_glyph_grid_t *grid) -#else -bdf_attach_selection(grid) -bdf_glyph_grid_t *grid; -#endif -{ - short sx, sy, x, y, wd, ht; - unsigned short bpr, sbpr, dx, di, si, byte; - unsigned char *masks; - - if (grid == 0 || (grid->sel.width == 0 && grid->sel.height == 0)) - return; - - masks = 0; - switch (grid->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - bpr = ((grid->grid_width * grid->bpp) + 7) >> 3; - sbpr = ((grid->sel.width * grid->bpp) + 7) >> 3; - - wd = grid->sel.x + grid->sel.width; - ht = grid->sel.y + grid->sel.height; - - for (sy = 0, y = grid->sel.y; y < ht; y++, sy++) { - for (sx = 0, x = grid->sel.x; x < wd; x++, sx += grid->bpp) { - si = (sx & 7) / grid->bpp; - byte = grid->sel.bitmap[(sy * sbpr) + (sx >> 3)] & masks[si]; - if (byte) { - dx = x * grid->bpp; - di = (dx & 7) / grid->bpp; - if (di < si) - byte <<= (si - di) * grid->bpp; - else if (di > si) - byte >>= (di - si) * grid->bpp; - grid->bitmap[(y * bpr) + (dx >> 3)] |= byte; - } - } - } - - /* - * Crop the new image to determine the new bounds with the selection. - */ - (void) bdf_grid_crop(grid, 1); -} - -/* - * Indicate the selection no longer exists by setting the width and height to - * 0. - */ -void -#ifdef __STDC__ -bdf_lose_selection(bdf_glyph_grid_t *grid) -#else -bdf_lose_selection(grid) -bdf_glyph_grid_t *grid; -#endif -{ - if (grid == 0) - return; - grid->sel.width = grid->sel.height = 0; -} - -/* - * Delete the selection by first detaching it which will erase the rectangle - * on the grid and then losing the selection. - */ -void -#ifdef __STDC__ -bdf_delete_selection(bdf_glyph_grid_t *grid) -#else -bdf_delete_selection(grid) -bdf_glyph_grid_t *grid; -#endif -{ - bdf_detach_selection(grid); - bdf_lose_selection(grid); -} - -/* - * Check to see if a coordinate pair is in the selected region. - */ -int -#ifdef __STDC__ -bdf_in_selection(bdf_glyph_grid_t *grid, short x, short y, short *set) -#else -bdf_in_selection(grid, x, y, set) -bdf_glyph_grid_t *grid; -short x, y, *set; -#endif -{ - short wd, ht; - unsigned short bpr, si, di, byte; - unsigned char *masks; - - if (grid == 0 || (grid->sel.width == 0 && grid->sel.height == 0)) - return 0; - - di = 0; - masks = 0; - switch (grid->bpp) { - case 1: - masks = onebpp; - di = 7; - break; - case 2: - masks = twobpp; - di = 3; - break; - case 4: - masks = fourbpp; - di = 1; - break; - } - - bpr = ((grid->sel.width * grid->bpp) + 7) >> 3; - - wd = grid->sel.x + grid->sel.width; - ht = grid->sel.y + grid->sel.height; - - if ((x >= grid->sel.x && x < wd) && (y >= grid->sel.y && y < ht)) { - if (set) { - /* - * Adjust the byte back to an index value. - */ - x *= grid->bpp; - si = (x & 7) / grid->bpp; - byte = grid->sel.bitmap[(y * bpr) + (x >> 3)] & masks[si]; - if (di > si) - byte >>= (di - si) * grid->bpp; - *set = byte; - } - return 1; - } - - return 0; -} - -int -#ifdef __STDC__ -bdf_grid_shift(bdf_glyph_grid_t *grid, short xcount, short ycount) -#else -bdf_grid_shift(grid, xcount, ycount) -bdf_glyph_grid_t *grid; -short xcount, ycount; -#endif -{ - int sel, delta; - short xdir, ydir, x, y, wd, ht, dx, dy, nx, ny; - unsigned short bytes, bpr, si, di, byte, col; - unsigned char *scratch, *masks; - - if (grid == 0) - return 0; - - xdir = ydir = 1; - if (xcount < 0) { - xdir = -1; - xcount = -xcount; - } - - if (ycount < 0) { - ydir = -1; - ycount = -ycount; - } - - /* - * Adjust the shift counts if they are larger than they should be. - */ - if (xcount > grid->grid_width) - xcount -= grid->grid_width; - if (ycount > grid->grid_height) - ycount -= grid->grid_height; - - /* - * Adjust the counts to limit the shift to the boundaries of the grid. - */ - if (grid->sel.width != 0 && grid->sel.height != 0) { - /* - * The selection is being shifted. - */ - x = grid->sel.x; - y = grid->sel.y; - wd = grid->sel.width; - ht = grid->sel.height; - sel = 1; - } else { - x = grid->glyph_x; - y = grid->glyph_y; - wd = grid->glyph_bbx.width; - ht = grid->glyph_bbx.height; - sel = 0; - } - - /* - * If the width and height are 0, then simply return, because there - * is nothing to shift. - */ - if (wd == 0 && ht == 0) - return 0; - - if (xdir == 1 && x + wd + xcount > grid->grid_width) - xcount = grid->grid_width - (x + wd); - else if (xdir == -1 && xcount > x) - xcount = x; - - if (ydir == 1 && y + ht + ycount > grid->grid_height) - ycount = grid->grid_height - (y + ht); - else if (ydir == -1 && ycount > y) - ycount = y; - - if (xcount == 0 && ycount == 0) - return 0; - - /* - * If the selection is the one being shifted, adjust the X and Y - * coordinates and adjust the glyph metrics. - */ - if (sel) { - /* - * Determine the actual ink bounds of the selection so the - * glyph metrics can be adjusted if necessary. - */ - if (_bdf_grid_ink_bounds(grid, &x, &y, &wd, &ht)) { - /* - * Have to adjust the glyph metrics. - */ - x += xdir * xcount; - y += ydir * ycount; - if (x < grid->glyph_x) { - delta = grid->glyph_x - x; - grid->glyph_bbx.width += delta; - grid->glyph_bbx.x_offset -= delta; - if (grid->spacing == BDF_PROPORTIONAL) - grid->dwidth += delta; - grid->glyph_x -= delta; - } else if (x >= grid->glyph_x + grid->glyph_bbx.width) { - delta = x - (grid->glyph_x + grid->glyph_bbx.width); - grid->glyph_bbx.width += delta; - if (grid->spacing == BDF_PROPORTIONAL) - grid->dwidth += delta; - } - - if (y < grid->glyph_y) { - delta = grid->glyph_y - y; - grid->glyph_bbx.height += delta; - grid->glyph_bbx.ascent += delta; - grid->glyph_y -= delta; - } else if (y + ht >= grid->glyph_y + grid->glyph_bbx.height) { - delta = (y + ht) - (grid->glyph_y + grid->glyph_bbx.height); - grid->glyph_bbx.height += delta; - grid->glyph_bbx.y_offset -= delta; - grid->glyph_bbx.descent += delta; - } - - grid->modified = 1; - } - - /* - * Adjust the top-left coordinate of the selection rectangle. - */ - grid->sel.x += xdir * xcount; - grid->sel.y += ydir * ycount; - - return 1; - } - - masks = 0; - switch (grid->bpp) { - case 1: - masks = onebpp; - di = 7; - break; - case 2: - masks = twobpp; - di = 3; - break; - case 4: - masks = fourbpp; - di = 1; - break; - } - - /* - * The glyph itself is being shifted. - */ - bpr = ((grid->grid_width * grid->bpp) + 7) >> 3; - bytes = grid->bytes >> 1; - scratch = grid->bitmap + bytes; - (void) memset((char *) scratch, 0, bytes); - - /* - * Shift just the glyph rectangle to keep things fast. - */ - wd += x; - ht += y; - for (dy = y; dy < ht; dy++) { - col = x * grid->bpp; - for (dx = x; dx < wd; dx++, col += grid->bpp) { - si = (col & 7) / grid->bpp; - byte = grid->bitmap[(dy * bpr) + (col >> 3)] & masks[si]; - if (byte) { - nx = dx + (xdir * xcount); - ny = dy + (ydir * ycount); - nx *= grid->bpp; - di = (nx & 7) / grid->bpp; - if (di < si) - byte <<= (si - di) * grid->bpp; - else if (di > si) - byte >>= (di - si) * grid->bpp; - scratch[(ny * bpr) + (nx >> 3)] |= byte; - } - } - } - - /* - * Copy the scratch buffer back to the main buffer. - */ - (void) memcpy((char *) grid->bitmap, (char *) scratch, bytes); - - /* - * Adjust the top-left coordinate of the glyph rectangle. - */ - grid->glyph_x += xdir * xcount; - grid->glyph_y += ydir * ycount; - - /* - * Adjust the glyph offsets relative to the baseline coordinates. - */ - grid->glyph_bbx.x_offset = grid->glyph_x - grid->base_x; - grid->glyph_bbx.y_offset = grid->base_y - - (grid->glyph_y + grid->glyph_bbx.height); - - /* - * Adjust the glyph ascent and descent. - */ - grid->glyph_bbx.ascent = grid->base_y - grid->glyph_y; - grid->glyph_bbx.descent = (grid->glyph_y + grid->glyph_bbx.height) - - grid->base_y; - - /* - * Mark the grid as being modified. - */ - grid->modified = 1; - - return 1; -} - - -int -#ifdef __STDC__ -bdf_grid_flip(bdf_glyph_grid_t *grid, short dir) -#else -bdf_grid_flip(grid, dir) -bdf_glyph_grid_t *grid; -short dir; -#endif -{ - int flipped, sel, delta; - short dx, dy, x, y, nx, ny, wd, ht; - unsigned short bytes, bpr, si, di, col, colx, byte; - unsigned char *bmap, *scratch, *masks; - - flipped = 0; - - if (grid == 0) - return flipped; - - if (grid->sel.width != 0 && grid->sel.height != 0) { - sel = 1; - x = y = 0; - wd = grid->sel.width; - ht = grid->sel.height; - bpr = ((wd * grid->bpp) + 7) >> 3; - bytes = grid->sel.bytes >> 1; - bmap = grid->sel.bitmap; - } else { - sel = 0; - x = grid->glyph_x; - y = grid->glyph_y; - wd = grid->glyph_bbx.width; - ht = grid->glyph_bbx.height; - bpr = ((grid->grid_width * grid->bpp) + 7) >> 3; - bytes = grid->bytes >> 1; - bmap = grid->bitmap; - } - - /* - * If the width or height is 0, don't do anything. - */ - if (wd == 0 || ht == 0) - return flipped; - - nx = 0; - masks = 0; - switch (grid->bpp) { - case 1: - masks = onebpp; - di = 7; - break; - case 2: - masks = twobpp; - di = 3; - break; - case 4: - masks = fourbpp; - di = 1; - break; - } - - /* - * Set and initialize the scratch area. - */ - scratch = bmap + bytes; - (void) memset((char *) scratch, 0, bytes); - - wd += x; - ht += y; - - if (dir < 0) { - /* - * Flip horizontally. - */ - for (dy = y; dy < ht; dy++) { - col = x * grid->bpp; - for (nx = wd - 1, dx = x; dx < wd; dx++, nx--, col += grid->bpp) { - si = (col & 7) / grid->bpp; - byte = bmap[(dy * bpr) + (col >> 3)] & masks[si]; - if (byte) { - flipped = 1; - colx = nx * grid->bpp; - di = (colx & 7) / grid->bpp; - if (di < si) - byte <<= (si - di) * grid->bpp; - else if (di > si) - byte >>= (di - si) * grid->bpp; - scratch[(dy * bpr) + (colx >> 3)] |= byte; - } - } - } - if (flipped) { - if (sel) - grid->sel.x += nx + 1; - else { - grid->glyph_x = nx + 1; - grid->glyph_bbx.x_offset = grid->glyph_x - grid->base_x; - } - } - } else { - /* - * Flip vertically. - */ - for (ny = ht - 1, dy = y; dy < ht; dy++, ny--) { - col = x * grid->bpp; - for (dx = x; dx < wd; dx++, col += grid->bpp) { - si = (col & 7) / grid->bpp; - byte = bmap[(dy * bpr) + (col >> 3)] & masks[si]; - if (byte) { - flipped = 1; - scratch[(ny * bpr) + (col >> 3)] |= byte; - } - } - } - if (flipped) { - if (sel) - grid->sel.y += ny + 1; - else { - grid->glyph_y = ny + 1; - grid->glyph_bbx.y_offset = grid->base_y - - (grid->glyph_y + grid->glyph_bbx.height); - grid->glyph_bbx.ascent = grid->base_y - grid->glyph_y; - grid->glyph_bbx.descent = - (grid->glyph_y + grid->glyph_bbx.height) - grid->base_y; - } - } - } - - if (flipped) { - /* - * Copy the scratch area back to the working area. - */ - if (sel) - (void) memcpy((char *) grid->sel.bitmap, (char *) scratch, bytes); - else - (void) memcpy((char *) grid->bitmap, (char *) scratch, bytes); - - if (sel) { - /* - * Check to see if flipping the selection caused the glyph metrics - * to change. - */ - if (_bdf_grid_ink_bounds(grid, &x, &y, &wd, &ht)) { - if (x < grid->glyph_x) { - delta = grid->glyph_x - x; - grid->glyph_bbx.width += delta; - grid->glyph_bbx.x_offset -= delta; - grid->glyph_x -= delta; - if (grid->spacing == BDF_PROPORTIONAL) - grid->dwidth += delta; - } else if (x >= grid->glyph_x + grid->glyph_bbx.width) { - delta = x - (grid->glyph_x + grid->glyph_bbx.width); - grid->glyph_bbx.width += delta; - if (grid->spacing == BDF_PROPORTIONAL) - grid->dwidth += delta; - } - - if (y < grid->glyph_y) { - delta = grid->glyph_y - y; - grid->glyph_bbx.height += delta; - grid->glyph_bbx.ascent += delta; - grid->glyph_y -= delta; - } else if (y >= grid->glyph_y + grid->glyph_bbx.height) { - delta = y - (grid->glyph_y + grid->glyph_bbx.height); - grid->glyph_bbx.height += delta; - grid->glyph_bbx.y_offset -= delta; - grid->glyph_bbx.descent += delta; - } - } - } - - /* - * Mark the grid as being modified. - */ - grid->modified = 1; - } - - return flipped; -} - -void -#ifdef __STDC__ -bdf_grid_origin(bdf_glyph_grid_t *grid, short *x, short *y) -#else -bdf_grid_origin(grid, x, y) -bdf_glyph_grid_t *grid; -short *x, *y; -#endif -{ - if (grid == 0) - return; - - *x = grid->base_x; - *y = grid->base_y; -} - -bdf_glyph_t * -#ifdef __STDC__ -bdf_grid_glyph(bdf_glyph_grid_t *grid) -#else -bdf_grid_glyph(grid) -bdf_glyph_grid_t *grid; -#endif -{ - int len; - short x, y, nx, ny, wd, ht, gx, gy; - unsigned short bpr, nbpr, si, di, col, byte; - bdf_glyph_t *glyph; - unsigned char *masks; - double ps, dw, rx; - - if (grid == 0) - return 0; - - masks = 0; - switch (grid->bpp) { - case 1: - masks = onebpp; - di = 7; - break; - case 2: - masks = twobpp; - di = 3; - break; - case 4: - masks = fourbpp; - di = 1; - break; - } - - /* - * Create the new glyph. - */ - glyph = (bdf_glyph_t *) malloc(sizeof(bdf_glyph_t)); - (void) memset((char *) glyph, 0, sizeof(bdf_glyph_t)); - - gx = grid->glyph_x; - gy = grid->glyph_y; - - /* - * Copy the bounding box. - */ - (void) memcpy((char *) &glyph->bbx, (char *) &grid->glyph_bbx, - sizeof(bdf_bbx_t)); - - /* - * If the font has character-cell spacing, then make sure the bitmap is - * cropped to fit within the bounds of the font bbx. - */ - if (grid->spacing == BDF_CHARCELL) { - if (gx < grid->base_x) { - glyph->bbx.x_offset = 0; - glyph->bbx.width -= grid->base_x - gx; - gx += grid->base_x - gx; - } - if (glyph->bbx.width > grid->font_bbx.width) - glyph->bbx.width -= glyph->bbx.width - grid->font_bbx.width; - } - - /* - * Set up its bitmap. - */ - nbpr = ((glyph->bbx.width * grid->bpp) + 7) >> 3; - glyph->bytes = nbpr * glyph->bbx.height; - glyph->bitmap = (unsigned char *) malloc(glyph->bytes); - (void) memset((char *) glyph->bitmap, 0, glyph->bytes); - - /* - * Set the other values. - */ - if (grid->name != 0) { - len = strlen(grid->name) + 1; - glyph->name = (char *) malloc(len); - (void) memcpy(glyph->name, grid->name, len); - } - glyph->encoding = grid->encoding; - glyph->dwidth = grid->dwidth; - - /* - * Reset the glyph SWIDTH value. - */ - ps = (double) grid->point_size; - rx = (double) grid->resolution_x; - dw = (double) grid->dwidth; - glyph->swidth = (unsigned short)((dw * 72000.0) / (ps * rx)); - - bpr = ((grid->grid_width * grid->bpp) + 7) >> 3; - wd = gx + glyph->bbx.width; - ht = gy + glyph->bbx.height; - - /* - * Copy the bitmap from the grid into the glyph. - */ - for (ny = 0, y = gy; y < ht; y++, ny++) { - col = gx * grid->bpp; - for (nx = 0, x = gx; x < wd; x++, nx += grid->bpp, col += grid->bpp) { - si = (col & 7) / grid->bpp; - byte = grid->bitmap[(y * bpr) + (col >> 3)] & masks[si]; - if (byte) { - di = (nx & 7) / grid->bpp; - if (di < si) - byte <<= (si - di) * grid->bpp; - else if (di > si) - byte >>= (di - si) * grid->bpp; - glyph->bitmap[(ny * nbpr) + (nx >> 3)] |= byte; - } - } - } - - /* - * Return the new glyph. - */ - return glyph; -} - -/* - * Create a bitmap with the glyph image as well as the selection. - */ -void -#ifdef __STDC__ -bdf_grid_image(bdf_glyph_grid_t *grid, bdf_bitmap_t *image) -#else -bdf_grid_image(grid, image) -bdf_glyph_grid_t *grid; -bdf_bitmap_t *image; -#endif -{ - short x, y, ix, iy; - unsigned short bpr, ibpr, si, di, col, colx, byte; - unsigned char *masks; - - if (grid == 0 || image == 0) - return; - - masks = 0; - switch (grid->bpp) { - case 1: - masks = onebpp; - di = 7; - break; - case 2: - masks = twobpp; - di = 3; - break; - case 4: - masks = fourbpp; - di = 1; - break; - } - - image->bpp = grid->bpp; - image->x = image->y = 0; - image->width = grid->grid_width; - image->height = grid->grid_height; - image->bytes = grid->bytes >> 1; - image->bitmap = (unsigned char *) malloc(image->bytes); - (void) memcpy((char *) image->bitmap, (char *) grid->bitmap, image->bytes); - - /* - * Add the selection to the bitmap if it exists. - */ - if (grid->sel.width != 0 && grid->sel.height != 0) { - ibpr = ((image->width * grid->bpp) + 7) >> 3; - bpr = ((grid->sel.width * grid->bpp) + 7) >> 3; - for (iy = grid->sel.y, y = 0; y < grid->sel.height; y++, iy++) { - for (ix = grid->sel.x, col = x = 0; x < grid->sel.width; - x++, ix++, col += grid->bpp) { - si = (col & 7) / grid->bpp; - byte = grid->sel.bitmap[(y * bpr) + (col >> 3)] & masks[si]; - if (byte) { - colx = ix * grid->bpp; - di = (colx & 7) / grid->bpp; - if (di < si) - byte <<= (si - di) * grid->bpp; - else if (di > si) - byte >>= (di - si) * grid->bpp; - image->bitmap[(iy * ibpr) + (colx >> 3)] |= byte; - } - } - } - } -} - -/* - * Routines for quick and dirty dithering. - */ -static void -#ifdef __STDC__ -_bdf_one_to_n(bdf_bitmap_t *bmap, int n) -#else -_bdf_one_to_n(bmap, n) -bdf_bitmap_t *bmap; -int n; -#endif -{ - unsigned short bpr, sbpr, bytes, col, sx, sy; - unsigned char *nbmap, *masks; - - if (bmap == 0 || bmap->width == 0 || bmap->height == 0) - return; - - masks = 0; - switch (n) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - sbpr = (bmap->width + 7) >> 3; - bpr = ((bmap->width * n) + 7) >> 3; - bytes = bpr * bmap->height; - nbmap = (unsigned char *) malloc(bytes); - (void) memset((char *) nbmap, 0, bytes); - - for (sy = 0; sy < bmap->height; sy++) { - for (col = sx = 0; sx < bmap->width; sx++, col += n) { - if (bmap->bitmap[(sy * sbpr) + (sx >> 3)] & (0x80 >> (sx & 7))) - nbmap[(sy * bpr) + (col >> 3)] |= masks[(col & 7) / n]; - } - } - free((char *) bmap->bitmap); - bmap->bpp = n; - bmap->bytes = bytes; - bmap->bitmap = nbmap; -} - -static void -#ifdef __STDC__ -_bdf_n_to_one(bdf_bitmap_t *bmap) -#else -_bdf_n_to_one(bmap) -bdf_bitmap_t *bmap; -#endif -{ - unsigned short bpr, sbpr, bytes, col, sx, sy; - unsigned char *nbmap, *masks; - - if (bmap == 0 || bmap->width == 0 || bmap->height == 0) - return; - - masks = 0; - switch (bmap->bpp) { - case 1: - masks = onebpp; - break; - case 2: - masks = twobpp; - break; - case 4: - masks = fourbpp; - break; - } - - sbpr = ((bmap->width * bmap->bpp) + 7) >> 3; - bpr = (bmap->width + 7) >> 3; - bytes = bpr * bmap->height; - nbmap = (unsigned char *) malloc(bytes); - (void) memset((char *) nbmap, 0, bytes); - - for (sy = 0; sy < bmap->height; sy++) { - for (col = sx = 0; sx < bmap->width; sx++, col += bmap->bpp) { - if (bmap->bitmap[(sy * sbpr) + (col >> 3)] & - masks[(col & 7) / bmap->bpp]) - nbmap[(sy * bpr) + (sx >> 3)] |= (0x80 >> (sx & 7)); - } - } - free((char *) bmap->bitmap); - bmap->bpp = 1; - bmap->bytes = bytes; - bmap->bitmap = nbmap; -} - -static void -#ifdef __STDC__ -_bdf_two_to_four(bdf_bitmap_t *bmap) -#else -_bdf_two_to_four(bmap) -bdf_bitmap_t *bmap; -#endif -{ - unsigned short bpr, sbpr, bytes, col, si, byte, sx, sy; - unsigned char *nbmap, *masks; - - if (bmap == 0 || bmap->width == 0 || bmap->height == 0) - return; - - masks = twobpp; - - sbpr = ((bmap->width << 1) + 7) >> 3; - bpr = ((bmap->width << 2) + 7) >> 3; - bytes = bpr * bmap->height; - nbmap = (unsigned char *) malloc(bytes); - (void) memset((char *) nbmap, 0, bytes); - - for (sy = 0; sy < bmap->height; sy++) { - for (col = sx = 0; sx < bmap->width; sx++, col += 2) { - si = (col & 7) >> 1; - byte = bmap->bitmap[(sy * sbpr) + (col >> 3)] & masks[si]; - if (byte) { - /* - * Shift the byte down to make an index. - */ - if (si < 3) - byte >>= (3 - si) << 1; - - /* - * Scale the index to four bits per pixel and shift it into - * place before adding it. - */ - byte = (byte << 2) + 3; - if ((sx & 1) == 0) - byte <<= 4; - nbmap[(sy * bpr) + ((sx << 2) >> 3)] |= byte; - } - } - } - free((char *) bmap->bitmap); - bmap->bpp = 4; - bmap->bytes = bytes; - bmap->bitmap = nbmap; -} - -static void -#ifdef __STDC__ -_bdf_four_to_two(bdf_bitmap_t *bmap) -#else -_bdf_four_to_two(bmap) -bdf_bitmap_t *bmap; -#endif -{ - unsigned short bpr, sbpr, bytes, col, si, byte, sx, sy; - unsigned char *nbmap, *masks; - - if (bmap == 0 || bmap->width == 0 || bmap->height == 0) - return; - - masks = fourbpp; - - sbpr = ((bmap->width << 2) + 7) >> 3; - bpr = ((bmap->width << 1) + 7) >> 3; - bytes = bpr * bmap->height; - nbmap = (unsigned char *) malloc(bytes); - (void) memset((char *) nbmap, 0, bytes); - - for (sy = 0; sy < bmap->height; sy++) { - for (col = sx = 0; sx < bmap->width; sx++, col += 4) { - si = (col & 7) >> 2; - byte = bmap->bitmap[(sy * sbpr) + (col >> 3)] & masks[si]; - if (byte) { - /* - * Shift the byte down to make an index. - */ - if (si == 0) - byte >>= 4; - - /* - * Scale the index to two bits per pixel and shift it into - * place if necessary. - */ - byte >>= 2; - - si = ((sx << 1) & 7) >> 1; - if (si < 3) - byte <<= (3 - si) << 1; - - nbmap[(sy * bpr) + ((sx << 1) >> 3)] |= byte; - } - } - } - free((char *) bmap->bitmap); - bmap->bpp = 2; - bmap->bytes = bytes; - bmap->bitmap = nbmap; -} - -/* - * Add a bitmap to a grid as a selection. - */ -void -#ifdef __STDC__ -bdf_add_selection(bdf_glyph_grid_t *grid, bdf_bitmap_t *sel) -#else -bdf_add_selection(grid, sel) -bdf_glyph_grid_t *grid; -bdf_bitmap_t *sel; -#endif -{ - unsigned short bytes, bpr; - - if (grid == 0 || sel == 0 || sel->width == 0 || sel->height == 0 || - sel->bytes == 0) - return; - - if (sel->bpp != grid->bpp) { - /* - * Dither the incoming bitmap to match the same bits per pixel as the - * grid it is being added to. - */ - if (sel->bpp == 1) - _bdf_one_to_n(sel, grid->bpp); - else if (grid->bpp == 1) - _bdf_n_to_one(sel); - else if (sel->bpp == 2) - _bdf_two_to_four(sel); - else - _bdf_four_to_two(sel); - } - - /* - * If the bitmap is too big then trim the right and/or the bottom to fit - * in the grid. - */ - if (sel->width > grid->grid_width) - sel->width = grid->grid_width; - if (sel->height > grid->grid_height) - sel->height = grid->grid_height; - - /* - * If the positioning puts the selection bitmap off one of the edges, - * adjust it so it is completely on the grid. - */ - if (sel->x + sel->width > grid->grid_width) - sel->x -= (sel->x + sel->width) - grid->grid_width; - if (sel->y + sel->height > grid->grid_height) - sel->y -= (sel->y + sel->height) - grid->grid_height; - - bpr = ((sel->width * grid->bpp) + 7) >> 3; - bytes = (bpr * sel->height) << 1; - - /* - * Resize the storage for the selection bitmap if necessary. - */ - if (bytes > grid->sel.bytes) { - if (grid->sel.bytes == 0) - grid->sel.bitmap = (unsigned char *) malloc(bytes); - else - grid->sel.bitmap = (unsigned char *) - realloc((char *) grid->sel.bitmap, bytes); - grid->sel.bytes = bytes; - } - - /* - * Copy the width and height values. - */ - grid->sel.x = sel->x; - grid->sel.y = sel->y; - grid->sel.width = sel->width; - grid->sel.height = sel->height; - - /* - * Copy the incoming bitmap to the new selection bitmap. - */ - (void) memcpy((char *) grid->sel.bitmap, (char *) sel->bitmap, - bytes >> 1); - - /* - * Crop the image to adjust the glyph bounding box. - */ - (void) bdf_grid_crop(grid, 1); -} - -int -#ifdef __STDC__ -bdf_grid_color_at(bdf_glyph_grid_t *grid, short x, short y) -#else -bdf_grid_color_at(grid, x, y) -bdf_glyph_grid_t *grid; -short x, y; -#endif -{ - unsigned short bpr, si, di, byte; - unsigned char *masks; - - if (grid->bpp == 1) - return -1; - - masks = twobpp; - di = 0; - switch (grid->bpp) { - case 2: - di = 3; - break; - case 4: - di = 1; - break; - } - - x *= grid->bpp; - - bpr = ((grid->grid_width * grid->bpp) + 7) >> 3; - si = (x & 7) / grid->bpp; - - byte = grid->bitmap[(y * bpr) + (x >> 3)] & masks[si]; - if (di > si) - byte >>= (di - si) * grid->bpp; - return (int) byte; -} diff --git a/tools/sci/bdftofont.cpp b/tools/sci/bdftofont.cpp deleted file mode 100644 index c09543bfc0..0000000000 --- a/tools/sci/bdftofont.cpp +++ /dev/null @@ -1,177 +0,0 @@ -/* ScummVM - Graphic Adventure Engine - * - * ScummVM is the legal property of its developers, whose names - * are too numerous to list here. Please refer to the COPYRIGHT - * file distributed with this source distribution. - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - * - * $URL$ - * $Id$ - * - */ - -#include <bdf.h> -#include <config.h> -#include <stdlib.h> -#include <stdio.h> - - -bdf_options_t bdf_opts = { - 0, /* ttf_hint */ - 0, /* correct_metrics */ - 0, /* keep_unencoded */ - 0, /* keep_comments */ - 0, /* pad_cells */ - 0, /* font_spacing */ - 0, /* point_size */ - 0, /* resolution_x */ - 0, /* resolution_y */ - 0, /* bits_per_pixel */ - BDF_UNIX_EOL /* eol */ -}; - - -#define GLYPH(n) glyphs[(((n) > 31)? ((n) - 31) : 0)] - -void -convert_font(FILE *in_file, FILE *out_file) { - bdf_font_t *font = - bdf_load_font(in_file, - &bdf_opts, - NULL, NULL); - - int chars_nr = font->glyphs_used; - int width = font->monowidth; - int bytes_per_row = (width + 7) >> 3; - int line_height; - int char_height = 0; - int char_byte_size; - int i; - bdf_glyph_t *glyphs = font->glyphs; - - fclose(in_file); - - if (!font) { - fprintf(stderr, "Not a BDF file? Aborting!\n"); - exit(1); - } - - printf("Res = %d/%d; pointsize = %d, spacing = %d, width=%d, asc=%ld, desc=%ld, glyphs=%ld\n", - font->resolution_x, - font->resolution_y, - font->point_size, - font->spacing, - font->monowidth, - font->font_ascent, - font->font_descent, - chars_nr); - - if (chars_nr > 256) - chars_nr = 256; - - for (i = 0; i < chars_nr; i++) { - int rh = GLYPH(i).bbx.height; - - if (rh > char_height) - char_height = rh; - } - - - - line_height = char_height + 1; - char_byte_size = bytes_per_row * char_height; - - fprintf(out_file, "# %d %d\n", chars_nr, char_height + 1); - - for (i = 0; i < chars_nr; i++) { - int rh = GLYPH(i).bbx.height; - int rw = GLYPH(i).bbx.width; - int xoff = 0; /* GLYPH(i).bbx.x_offset; */ - int yoff = 0; /* GLYPH(i).bbx.y_offset; */ - int j, k; - int top_pad = yoff; - int bot_pad = (char_height - rh) - top_pad; - int bytes_to_read = (GLYPH(i).bytes) / rh; - unsigned char *data = GLYPH(i).bitmap; - - if (bytes_to_read <= 0) { - fprintf(stderr, "No bytes per row: bytes=%d, w=%d, h=%d\n", - GLYPH(i).bytes, rw, rh); - exit(1); - } - - if (bot_pad < 0) { - fprintf(stderr, "Bottom padding <0: height=%d/%d, top_pad=%d\n", - rh, char_height, yoff); - exit(1); - } - - /* First, pad everything */ - for (j = 0; j < top_pad; j++) { - for (k = 0; k < rw; k++) - fprintf(out_file, "."); - fprintf(out_file, "\n"); - } - - /* Write char data */ - for (j = 0; j < rh; j++) { - unsigned int b = 0; - unsigned int oldb; - for (k = 0; k < bytes_to_read; k++) { - int shift_offset = 8 * (bytes_to_read - 1 - k); - b |= (*data++ << shift_offset); - } - - oldb = b; - - for (k = 0; k < rw; k++) - fprintf(out_file, (oldb & (1 << ((bytes_per_row * 8) - 1 - k))) ? "#" : "."); - - fprintf(out_file, "\n"); - } - - /* Pad bottom */ - for (j = 0; j < bot_pad; j++) { - for (k = 0; k < rw; k++) - fprintf(out_file, "."); - fprintf(out_file, "\n"); - } - fprintf(out_file, "----\t 0x%02x ('%c') */\n", i, ((i > 31) && (i < 0x7f)) ? i : '.'); - } - fprintf(out_file, "\n\n"); - - fclose(out_file); -} - - -int -main(int argc, char **argv) { - FILE *f = NULL; - bdf_setup(); - - if (argc < 3) { - fprintf(stderr, "Usage: %s <font.bdf> <outfile.font>\n ", argv[0]); - exit(1); - } - - f = fopen(argv[1], "r"); - if (f) - convert_font(f, fopen(argv[2], "w")); - else - perror(argv[1]); - - bdf_cleanup(); -} diff --git a/tools/sci/fonttoc.cpp b/tools/sci/fonttoc.cpp deleted file mode 100644 index 9f7a9a2011..0000000000 --- a/tools/sci/fonttoc.cpp +++ /dev/null @@ -1,256 +0,0 @@ -/* ScummVM - Graphic Adventure Engine - * - * ScummVM is the legal property of its developers, whose names - * are too numerous to list here. Please refer to the COPYRIGHT - * file distributed with this source distribution. - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - * - * $URL$ - * $Id$ - * - */ - -#include <config.h> -#include <stdlib.h> -#include <stdio.h> -#include <string.h> - - -#define GLYPH(n) glyphs[n] - - -int max_width = 0; - -char inbuf[256]; - -typedef struct { - int bytes; - int width; - unsigned char *bitmap; -} glyph_t; - - -unsigned int -invert_bits(unsigned int s, int bits) { - unsigned int rv = 0; - int i; - for (i = 0; i < bits; i++) - if (s & (1 << i)) - rv |= (1 << (bits - 1 - i)); - - return rv; -} - -void -read_single_glyph(FILE *in_file, glyph_t *dest, int index, int char_height) { - int width = -1; - int bytes = 0; - int i; - unsigned char *data - = dest->bitmap = (unsigned char *) malloc(char_height * 4); /* Let's waste memory */ - - do { - unsigned int d = 0; - - fgets(inbuf, 255, in_file); - - if (char_height-- == -1) { - fprintf(stderr, "Char 0x%02x is too long!\n", index); - exit(1); - } - - if (inbuf[0] == '.' || inbuf[0] == '#') { - int cw; - - if (width == -1) - width = strlen(inbuf) - 1; - else if (strlen(inbuf) - 1 != width) { - fprintf(stderr, "Char 0x%02x uses inconsistent width\n", index); - exit(1); - } - - for (i = 0; i < width; i++) - if (inbuf[i] == '#') - d |= (1 << i); - - d = invert_bits(d, ((width + 7) / 8) * 8); - - cw = width; - do { - *data = d & 0xff; - d >>= 8; - data++; - cw -= 8; - ++bytes; - } while (cw > 0); - } - - } while (inbuf[0] == '.' || inbuf[0] == '#'); - - if (char_height >= 0) { - fprintf(stderr, "Char 0x%02x is too short (by %d)!\n", index, char_height); - exit(1); - } - - dest->width = width; - if (width > max_width) - max_width = width; - - dest->bytes = bytes; -} - -glyph_t * -read_glyphs(FILE *in_file, int nr, int char_height) { - int i; - glyph_t *glyphs = (glyph_t *) calloc(sizeof(glyph_t), nr); - - for (i = 0; i < nr; i++) - read_single_glyph(in_file, glyphs + i, i, char_height); - - return glyphs; -} - -void -convert_font(FILE *in_file, char *structname, FILE *out_file) { - int chars_nr; - glyph_t *glyphs; - int bytes_per_row; - int line_height; - int char_height = 0; - int char_byte_size; - int i; - - fscanf(in_file, "# %d %d\n", &chars_nr, &char_height); - printf("Parsing %d characters at height %d\n", chars_nr, char_height); - glyphs = read_glyphs(in_file, chars_nr, char_height); - - bytes_per_row = (max_width + 7) >> 3; - line_height = char_height + 1; - fclose(in_file); - - char_byte_size = bytes_per_row * char_height; - - fprintf(out_file, "/* Auto-generated by bdftofont.c */\n\n"); - - fprintf(out_file, "#include <gfx_system.h>\n\n"); - - fprintf(out_file, "static int %s_widths[] = {\n", structname); - for (i = 0; i < chars_nr; i++) { - int rw = GLYPH(i).width; - fprintf(out_file, "\t%d%s\t/* 0x%02x */\n", rw, - (i < (chars_nr - 1)) ? "," : "", i); - } - fprintf(out_file, "};\n\n"); - - fprintf(out_file, "static unsigned char %s_data[] = {\n", structname); - for (i = 0; i < chars_nr; i++) { - int rh = char_height; - int rw = GLYPH(i).width; - int xoff = 0; - int yoff = 0; - int j, k; - - int top_pad = yoff; - int bot_pad = (char_height - rh) - top_pad; - int bytes_to_read = (GLYPH(i).bytes) / rh; - unsigned char *data = GLYPH(i).bitmap; - - if (bytes_to_read <= 0) { - fprintf(stderr, "No bytes per row: bytes=%d, w=%d, h=%d\n", - GLYPH(i).bytes, rw, rh); - exit(1); - } - - if (bot_pad < 0) { - fprintf(stderr, "Bottom padding <0: height=%d/%d, top_pad=%d\n", - rh, char_height, yoff); - exit(1); - } - - fprintf(out_file, "\t/* 0x%02x ('%c') */\n", i, ((i > 31) && (i < 0x7f)) ? i : '.'); - /* First, pad everything */ - for (j = 0; j < top_pad; j++) { - fprintf(out_file, "\t"); - for (k = 0; k < bytes_per_row; k++) - fprintf(out_file, "0x00, "); - fprintf(out_file, "\n"); - } - - /* Write char data */ - for (j = 0; j < rh; j++) { - unsigned int b = 0; - unsigned int oldb; - fprintf(out_file, "\t"); - for (k = 0; k < bytes_to_read; k++) { - int shift_offset = 8 * (bytes_to_read - 1 - k); - b |= (*data++ << shift_offset); - } - - oldb = b; - - for (k = 0; k < bytes_per_row; k++) { - fprintf(out_file, "0x%02x%s", (b & 0xff), (bot_pad || (i + 1 < chars_nr) || (j + 1 < rh) || (k + 1 < bytes_per_row)) ? ", " : ""); - b >>= 8; - } - fprintf(out_file, "\t/* "); - for (k = 0; k < rw; k++) - fprintf(out_file, (oldb & (1 << ((bytes_per_row * 8) - 1 - k))) ? "##" : ".."); - fprintf(out_file, " */"); - - fprintf(out_file, "\n"); - } - - /* Pad bottom */ - for (j = 0; j < bot_pad; j++) { - fprintf(out_file, "\t"); - for (k = 0; k < bytes_per_row; k++) - fprintf(out_file, "0x00%s", ((i + 1 < chars_nr) || (j + 1 < bot_pad) || (k + 1 < bytes_per_row)) ? ", " : ""); - fprintf(out_file, "\n"); - } - } - fprintf(out_file, "};\n\n"); - - fprintf(out_file, "gfx_bitmap_font_t %s = {\n", structname); - fprintf(out_file, "\t-1, /* resource ID */\n"); - fprintf(out_file, "\t%d, /* # of characters */\n", chars_nr); - fprintf(out_file, "\t%s_widths, /* Widths */\n", structname); - fprintf(out_file, "\t%d, /* Bytes per row */\n", bytes_per_row); - fprintf(out_file, "\t%d, /* Line height */\n", line_height); - fprintf(out_file, "\t%d, /* Char height */\n", char_height); - fprintf(out_file, "\t%d, /* Char size (occupied, in bytes) */\n", char_byte_size); - fprintf(out_file, "\t%s_data /* Bulk data */\n", structname); - fprintf(out_file, "};\n"); - - fclose(out_file); -} - - -int -main(int argc, char **argv) { - FILE *f = NULL; - - if (argc < 4) { - fprintf(stderr, "Usage: %s <font.font> <structname> <outfile.c>\n ", argv[0]); - exit(1); - } - - f = fopen(argv[1], "r"); - if (f) - convert_font(f, argv[2], fopen(argv[3], "w")); - else - perror(argv[1]); - -} |