diff options
Diffstat (limited to 'nx-X11/lib/font/Speedo')
33 files changed, 13842 insertions, 0 deletions
diff --git a/nx-X11/lib/font/Speedo/Imakefile b/nx-X11/lib/font/Speedo/Imakefile new file mode 100644 index 000000000..e2d9dcdeb --- /dev/null +++ b/nx-X11/lib/font/Speedo/Imakefile @@ -0,0 +1,46 @@ +XCOMM $Xorg: Imakefile,v 1.3 2000/08/17 19:46:24 cpqbld Exp $ + + + + +XCOMM $XFree86: xc/lib/font/Speedo/Imakefile,v 1.10 2001/01/19 08:13:29 dawes Exp $ + +#if BuildServer && DoLoadableServer +#define IHaveSubdirs +#define NoLibSubdirs +#define PassCDebugFlags +SUBDIRS = module +#endif + + INCLUDES = -I$(FONTINCSRC) -I../include -I$(SERVERSRC)/include + HEADERS = + SPEEDOSRCS = do_char.c do_trns.c out_bl2d.c out_blk.c \ + out_scrn.c out_util.c reset.c set_spcs.c set_trns.c + SPEEDOOBJS = do_char.o do_trns.o out_bl2d.o out_blk.o \ + out_scrn.o out_util.o reset.o set_spcs.o set_trns.o + + SRCS = spfuncs.c spfile.c spinfo.c sperr.c spfont.c spglyph.c \ + spencode.c bics-unicode.c \ + $(SPEEDOSRCS) + OBJS = spfuncs.o spfile.o spinfo.o sperr.o spfont.o spglyph.o \ + spencode.o bics-unicode.o \ + $(SPEEDOOBJS) + +#if BuildFontLib +#define DoNormalLib NormalLibFont +#define DoSharedLib SharedLibFont +#define DoDebugLib DebugLibFont +#define DoProfileLib ProfileLibFont +#include <Library.tmpl> +LibraryObjectRule() + +SubdirLibraryRule($(OBJS)) +NormalLintTarget($(SRCS)) +#endif + +#if BuildServer && DoLoadableServer +MakeSubdirs($(SUBDIRS)) +DependSubdirs($(SUBDIRS)) +#endif + +DependTarget() diff --git a/nx-X11/lib/font/Speedo/adobe-iso.h b/nx-X11/lib/font/Speedo/adobe-iso.h new file mode 100644 index 000000000..e1eeef1c5 --- /dev/null +++ b/nx-X11/lib/font/Speedo/adobe-iso.h @@ -0,0 +1,200 @@ +/* $Xorg: adobe-iso.h,v 1.3 2000/08/17 19:46:24 cpqbld Exp $ */ + +/* + * Latin 1 format from masterset format 11 (ps) + * 0 implies no valid mapping + */ + +int adobe_map[] = { + 32, 32, + 33, 33, + 34, 34, + 35, 35, + 36, 36, + 37, 37, + 38, 38, + 39, 169, + 40, 40, + 41, 41, + 42, 42, + 43, 43, + 44, 44, + 45, 45, + 46, 46, + 47, 47, + 48, 48, + 49, 49, + 50, 50, + 51, 51, + 52, 52, + 53, 53, + 54, 54, + 55, 55, + 56, 56, + 57, 57, + 58, 58, + 59, 59, + 60, 60, + 61, 61, + 62, 62, + 63, 63, + 64, 64, + 65, 65, + 66, 66, + 67, 67, + 68, 68, + 69, 69, + 70, 70, + 71, 71, + 72, 72, + 73, 73, + 74, 74, + 75, 75, + 76, 76, + 77, 77, + 78, 78, + 79, 79, + 80, 80, + 81, 81, + 82, 82, + 83, 83, + 84, 84, + 85, 85, + 86, 86, + 87, 87, + 88, 88, + 89, 89, + 90, 90, + 91, 91, + 92, 92, + 93, 93, + 94, 195, + 95, 95, + 96, 193, + 97, 97, + 98, 98, + 99, 99, + 100, 100, + 101, 101, + 102, 102, + 103, 103, + 104, 104, + 105, 105, + 106, 106, + 107, 107, + 108, 108, + 109, 109, + 110, 110, + 111, 111, + 112, 112, + 113, 113, + 114, 114, + 115, 115, + 116, 116, + 117, 117, + 118, 118, + 119, 119, + 120, 120, + 121, 121, + 122, 122, + 123, 123, + 124, 124, + 125, 125, + 126, 196, /* lc tilde */ + 127, 0, /* */ + 161, 161, /* invert exclamation */ + 162, 162, /* cent */ + 163, 163, /* pound sterling */ + 164, 168, /* intl currency */ + 165, 165, /* yen */ + 166, 320, /* split vert bar */ + 167, 167, /* section mark */ + 168, 200, /* dierisis */ + 169, 0, /* superior copyright */ + 170, 0, /* feminine ordinal */ + 171, 171, /* dbl left guillemot */ + 172, 314, /* math not */ + 173, 0, /* hyphen ? */ + 174, 0, /* superior registered */ + 175, 0, /* overscore */ + 176, 321, /* degree */ + 177, 329, /* math +- */ + 178, 333, /* superior 2 */ + 179, 332, /* superior 3 */ + 180, 194, /* lc acute */ + 181, 324, /* greek lc mu */ + 182, 182, /* Paragraph */ + 183, 180, /* center dot */ + 184, 203, /* cedilla lc */ + 185, 328, /* superior 1 */ + 186, 0, /* masculine ordinal(using superior o) */ + 187, 187, /* right dbl guillemot */ + 188, 327, /* 1/4 */ + 189, 326, /* 1/2 */ + 190, 331, /* 3/4 */ + 191, 191, /* invert question */ + 192, 259, /* A grave */ + 193, 256, /* A acute */ + 194, 257, /* A circumflex */ + 195, 261, /* A tilde */ + 196, 258, /* A dierisis */ + 197, 260, /* A angstrom */ + 198, 225, /* AE ligature */ + 199, 262, /* C cedilla */ + 200, 266, /* E grave */ + 201, 263, /* E acute */ + 202, 264, /* E circumflex */ + 203, 265, /* E dierisis */ + 204, 270, /* I grave */ + 205, 267, /* I acute */ + 206, 268, /* I circumflex */ + 207, 269, /* I dierisis */ + 208, 317, /* D bar */ + 209, 271, /* N tilde */ + 210, 275, /* O grave */ + 211, 272, /* O acute */ + 212, 273, /* O circumflex */ + 213, 276, /* O tilde */ + 214, 274, /* O dierisis */ + 215, 325, /* math multiply */ + 216, 233, /* O bar */ + 217, 281, /* U grave */ + 218, 278, /* U acute */ + 219, 279, /* U circumflex */ + 220, 280, /* U dierisis */ + 221, 319, /* Y acute */ + 222, 318, /* icelandic thorn lc */ + 223, 251, /* German dbl s */ + 224, 287, /* a grave */ + 225, 284, /* a acute */ + 226, 285, /* a circumflex */ + 227, 289, /* a tilde */ + 228, 286, /* a dierisis */ + 229, 288, /* a angstrom */ + 230, 241, /* ae ligature */ + 231, 290, /* c cedilla */ + 232, 294, /* e grave */ + 233, 291, /* e acute */ + 234, 292, /* e circumflex */ + 235, 293, /* e dierisis */ + 236, 298, /* i grave */ + 237, 295, /* i acute */ + 238, 296, /* i circumflex */ + 239, 297, /* i dierisis */ + 240, 323, /* icelandic eth lc */ + 241, 299, /* n tilde */ + 242, 303, /* o grave */ + 243, 300, /* o acute */ + 244, 301, /* o circumflex */ + 245, 304, /* o tilde */ + 246, 302, /* o dierisis */ + 247, 322, /* math divide */ + 248, 249, /* o bar */ + 249, 309, /* u grave */ + 250, 306, /* u acute */ + 251, 307, /* u circumflex */ + 252, 308, /* u dierisis */ + 253, 334, /* y acute */ + 254, 330, /* icelandic thorn uc */ + 255, 310, /* y dierisis */ +}; diff --git a/nx-X11/lib/font/Speedo/bics-iso.h b/nx-X11/lib/font/Speedo/bics-iso.h new file mode 100644 index 000000000..4964fa34e --- /dev/null +++ b/nx-X11/lib/font/Speedo/bics-iso.h @@ -0,0 +1,224 @@ +/* $Xorg: bics-iso.h,v 1.4 2001/02/09 02:04:00 xorgcvs Exp $ */ +/* + +Copyright 1993, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +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 OPEN GROUP 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. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + +*/ +/* $XFree86: xc/lib/font/Speedo/bics-iso.h,v 1.6 2001/01/17 19:43:17 dawes Exp $ */ + +int sp_bics_map[] = { + 32, 0, + 33, 1, + 34, 2, + 35, 3, + 36, 4, + 37, 5, + 38, 6, + 39, 264, + 40, 8, + 41, 9, + 42, 10, + 43, 11, + 44, 12, + 45, 13, + 46, 14, + 47, 15, + 48, 16, + 49, 17, + 50, 18, + 51, 19, + 52, 20, + 53, 21, + 54, 22, + 55, 23, + 56, 24, + 57, 25, + 58, 26, + 59, 27, + 60, 28, + 61, 29, + 62, 30, + 63, 31, + 64, 32, + 65, 33, + 66, 34, + 67, 35, + 68, 36, + 69, 37, + 70, 38, + 71, 39, + 72, 40, + 73, 41, + 74, 42, + 75, 43, + 76, 44, + 77, 45, + 78, 46, + 79, 47, + 80, 48, + 81, 49, + 82, 50, + 83, 51, + 84, 52, + 85, 53, + 86, 54, + 87, 55, + 88, 56, + 89, 57, + 90, 58, + 91, 59, + 92, 60, + 93, 61, + 94, 133, + 95, 63, + 96, 131, + 97, 65, + 98, 66, + 99, 67, + 100, 68, + 101, 69, + 102, 70, + 103, 71, + 104, 72, + 105, 73, + 106, 74, + 107, 75, + 108, 76, + 109, 77, + 110, 78, + 111, 79, + 112, 80, + 113, 81, + 114, 82, + 115, 83, + 116, 84, + 117, 85, + 118, 86, + 119, 87, + 120, 88, + 121, 89, + 122, 90, + 123, 91, + 124, 92, + 125, 93, + 126, 137, + 127, 358, + 161, 128, + 162, 98, + 163, 97, + 164, 278, + 165, 274, + 166, 277, + 167, 110, + 168, 135, + 169, 503, + 170, 538, + 171, 125, + 172, 309, + 173, 191, + 174, 504, + 175, 230, + 176, 339, + 177, 286, + 178, 160, + 179, 161, + 180, 129, + 181, 325, + 182, 279, + 183, 102, + 184, 141, + 185, 159, + 186, 544, + 187, 126, + 188, 151, + 189, 153, + 190, 155, + 191, 127, + 192, 259, + 193, 261, + 194, 257, + 195, 253, + 196, 255, + 197, 113, + 198, 114, + 199, 148, + 200, 249, + 201, 251, + 202, 247, + 203, 245, + 204, 239, + 205, 241, + 206, 237, + 207, 235, + 208, 169, + 209, 196, + 210, 202, + 211, 200, + 212, 204, + 213, 208, + 214, 206, + 215, 284, + 216, 115, + 217, 212, + 218, 210, + 219, 214, + 220, 216, + 221, 224, + 222, 271, + 223, 121, + 224, 260, + 225, 262, + 226, 258, + 227, 254, + 228, 256, + 229, 117, + 230, 118, + 231, 149, + 232, 250, + 233, 252, + 234, 248, + 235, 246, + 236, 240, + 237, 242, + 238, 238, + 239, 236, + 240, 273, + 241, 195, + 242, 201, + 243, 199, + 244, 203, + 245, 207, + 246, 205, + 247, 285, + 248, 119, + 249, 211, + 250, 209, + 251, 213, + 252, 215, + 253, 223, + 254, 272, + 255, 221, +}; + diff --git a/nx-X11/lib/font/Speedo/bics-unicode.c b/nx-X11/lib/font/Speedo/bics-unicode.c new file mode 100644 index 000000000..735508268 --- /dev/null +++ b/nx-X11/lib/font/Speedo/bics-unicode.c @@ -0,0 +1,138 @@ +/* +Copyright (c) 1998 by Juliusz Chroboczek + +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 +AUTHORS OR COPYRIGHT HOLDERS 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. +*/ + +/* $XFree86$ */ + +/* These data are very dodgy. */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include "bics-unicode.h" + +static short table_160[]= +{0, 128, 98, 97, 278, 274, 277, 110, 135, 503, 538, 125, 309, 191, 504, + 230, 339, 286, 160, 161, 129, 325, 279, 102, 141, 159, 544, 126, 151, + 153, 155, 127, 259, 261, 257, 253, 255, 113, 114, 148, 249, 251, 247, + 245, 239, 241, 237, 235, 169, 196, 202, 200, 204, 208, 206, 284, 115, + 212, 210, 214, 216, 224, 271, 121, 260, 262, 258, 254, 256, 117, 118, + 149, 250, 252, 248, 246, 240, 242, 238, 236, 273, 195, 201, 199, 203, + 207, 205, 285, 119, 211, 209, 213, 215, 223, 272, 221, 477, 476, 374, + 373, 171, 177, 376, 375, -1, -1, -1, -1, 378, 377, 379, -1, 169, 173, + 383, 382, -1, -1, -1, -1, 172, 178, 243, 244, -1, -1, -1, -1, -1, -1, + 385, -1, -1, -1, -1, -1, 233, 234, 387, 386, -1, -1, 391, 390, 389, + 122, 276, 275, -1, -1, 393, 392, -1, 395, 394, 399, 398, -1, -1, -1, + -1, 170, 174, 194, 193, 402, 401, 198, 197, 263, -1, -1, -1, -1, -1, + -1, 404, 403, 116, 120, -1, -1, 408, 407, 406, 405, 410, 409, -1, -1, + 486, 485, 412, 411, 419, 418, 364, 363, -1, -1, 218, 217, 421, 420, -1, + -1, 220, 219, 423, 422, -1, 268, 425, 424, -1, -1, 222, 368, 367, 372, + 371, 370, 369}; + +static short table_728[]={144, 181, 146, 731, 137, 183}; + +static short table_915[]= +{313, 314, -1, -1, -1, 315, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 316, -1, -1, 317, -1, -1, 318, -1, -1, -1, -1, -1, -1, -1, 319, 320, + -1, 321, 322, -1, 323, 324, -1, -1, -1, 325, -1, -1, -1, 326, -1, -1, + 327, 328, -1, 329}; + +static short table_8211[]= +{111, 112, -1, -1, -1, -1, -1, 106, -1, 103, 105, 107, 104, 108, 109, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 100, -1, -1, + -1, -1, -1, -1, -1, -1, 123, 124, -1, 265}; + +static short table_8319[]= +{543, 475, 466, 467, 468, 469, 470, 471, 472, 473, 474, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 491, -1, -1, -1, 266}; + +static short table_8592[]={293, 295, 294, 292, 297, 296}; + +static short table_8712[]= +{298, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 492, -1, -1, -1, -1, -1, + -1, 302, -1, -1, -1, 303, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 299, + -1, -1, -1, -1, 428}; + + +static short table_8800[]={288, -1, -1, -1, 291, 290}; + +static short table_9600[]= +{304, -1, -1, -1, 305, -1, -1, -1, 308, -1, -1, -1, 306, -1, -1, -1, + 307, 357, 358, 359, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 335, 336, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 348, -1, -1, -1, 345, -1, -1, -1, -1, -1, 347, -1, -1, -1, 346, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 339, -1, -1, -1, 342, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 344}; + +static short table_9784[]={360, -1, 361, 362, -1, -1, -1, -1, 350, -1, 349}; + +static short table_9824[]= +{354, -1, -1, 352, -1, 351, 353, -1, -1, -1, 330, 331}; + +static short table_64256[]={282, 95, 96, 281}; + +int +unicode_to_bics(unsigned code) +{ + if(code<32) return -1; + else if(code<127) return code-32; + else if(code<160) return -1; + else if(code<383) return table_160[code-160]; + else if(code==402) return 99; + else if(code==486) return 480; + else if(code==487) return 379; + else if(code==501) return 384; + else if(code==711) return 139; + else if(code<728) return -1; + else if(code<734) return table_728[code-728]; + else if(code<915) return -1; + else if(code<967) return table_915[code-915]; + else if(code<8211) return -1; + else if(code<8253) return table_8211[code-8211]; + else if(code<8319) return -1; + else if(code<8360) return table_8319[code-8319]; + else if(code<8592) return -1; + else if(code<8598) return table_8592[code-8592]; + else if(code==8616) return 340; + else if(code<8712) return -1; + else if(code<8751) return table_8712[code-8712]; + else if(code<8800) return -1; + else if(code<8806) return table_8800[code-8800]; + else if(code==8976) return 310; + else if(code==8992) return 300; + else if(code==8993) return 301; + else if(code==9400) return 332; + else if(code==9415) return 333; + else if(code==9473) return 355; + else if(code==9475) return 356; + else if(code<9600) return -1; + else if(code<9690) return table_9600[code-9600]; + else if(code==9711) return 343; + else if(code<9784) return -1; + else if(code<9795) return table_9784[code-9784]; + else if(code<9824) return -1; + else if(code<9836) return table_9824[code-9824]; + else if(code<64256) return -1; + else if(code<64261) return table_64256[code-64256]; + else return -1; +} + diff --git a/nx-X11/lib/font/Speedo/bics-unicode.h b/nx-X11/lib/font/Speedo/bics-unicode.h new file mode 100644 index 000000000..90fa1885b --- /dev/null +++ b/nx-X11/lib/font/Speedo/bics-unicode.h @@ -0,0 +1,3 @@ +/* $XFree86$ */ + +int unicode_to_bics(unsigned); diff --git a/nx-X11/lib/font/Speedo/do_char.c b/nx-X11/lib/font/Speedo/do_char.c new file mode 100644 index 000000000..410d6339a --- /dev/null +++ b/nx-X11/lib/font/Speedo/do_char.c @@ -0,0 +1,1016 @@ +/* $Xorg: do_char.c,v 1.3 2000/08/17 19:46:24 cpqbld Exp $ */ + +/* + +Copyright 1989-1991, Bitstream Inc., Cambridge, MA. +You are hereby granted permission under all Bitstream propriety rights to +use, copy, modify, sublicense, sell, and redistribute the Bitstream Speedo +software and the Bitstream Charter outline font for any purpose and without +restrictions; provided, that this notice is left intact on all copies of such +software or font and that Bitstream's trademark is acknowledged as shown below +on all unmodified copies of such font. + +BITSTREAM CHARTER is a registered trademark of Bitstream Inc. + + +BITSTREAM INC. DISCLAIMS ANY AND ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING +WITHOUT LIMITATION THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE. BITSTREAM SHALL NOT BE LIABLE FOR ANY DIRECT OR INDIRECT +DAMAGES, INCLUDING BUT NOT LIMITED TO LOST PROFITS, LOST DATA, OR ANY OTHER +INCIDENTAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF OR IN ANY WAY CONNECTED +WITH THE SPEEDO SOFTWARE OR THE BITSTREAM CHARTER OUTLINE FONT. + +*/ +/* $XFree86: xc/lib/font/Speedo/do_char.c,v 1.3 2001/01/17 19:43:17 dawes Exp $ */ + +/***************************** D O - C H A R . C ***************************** + * * + * This is the top level module for processing one simple or composite * + * character. + * * + ****************************************************************************/ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include "spdo_prv.h" /* General definitions for Speedo */ + +#define DEBUG 0 + +#if DEBUG +#include <stdio.h> +#define SHOW(X) printf("X = %d\n", X) +#else +#define SHOW(X) +#endif + +/***** GLOBAL VARIABLES *****/ + +/***** GLOBAL FUNCTIONS *****/ + +/***** EXTERNAL VARIABLES *****/ + +/***** EXTERNAL FUNCTIONS *****/ + +/***** STATIC VARIABLES *****/ + +/***** STATIC FUNCTIONS *****/ + +static boolean sp_make_simp_char(PROTO_DECL2 ufix8 FONTFAR *pointer,ufix8 format); +static boolean sp_make_comp_char(PROTO_DECL2 ufix8 FONTFAR *pointer); +static ufix8 FONTFAR *sp_get_char_org(PROTO_DECL2 ufix16 char_index,boolean top_level); +static fix15 sp_get_posn_arg(PROTO_DECL2 ufix8 FONTFAR *STACKFAR *ppointer,ufix8 format); +static fix15 sp_get_scale_arg(PROTO_DECL2 ufix8 FONTFAR *STACKFAR *ppointer,ufix8 format); + + +FUNCTION ufix16 get_char_id( +GDECL +ufix16 char_index) /* Index to character in char directory */ +/* + * Returns character id for specified character index in currently + * selected font. + * Reports Error 10 and returns 0 if no font selected. + * Reports Error 12 and returns 0 if character data not available. + */ +{ +ufix8 FONTFAR *pointer; /* Pointer to character data */ + +if (!sp_globals.specs_valid) /* Font specs not defined? */ + { + report_error(10); /* Report font not specified */ + return (ufix16)0; /* Return zero character id */ + } + +pointer = sp_get_char_org(char_index, TRUE); /* Get pointer to character data */ +if (pointer == NULL) /* Character data not available? */ + { + report_error(12); /* Report character data not avail */ + return (ufix16)0; /* Return zero character id */ + } + +return 0xffff & NEXT_WORD(pointer); /* Return character id */ +} + + +#if INCL_METRICS +FUNCTION fix31 get_char_width( +GDECL +ufix16 char_index) /* Index to character in char directory */ +/* + * Returns character set width for specified character index in currently + * selected font in units of 1/65536 em. + * Reports Error 10 and returns 0 if no font selected. + * Reports Error 12 and returns 0 if character data not available. + */ +{ +ufix8 FONTFAR *pointer; /* Pointer to character data */ +fix31 set_width; /* Set width of character */ + +if (!sp_globals.specs_valid) /* Font specs not defined? */ + { + report_error(10); /* Report font not specified */ + return (fix31)0; /* Return zero character width */ + } + +pointer = sp_get_char_org(char_index, TRUE); /* Get pointer to character data */ +if (pointer == NULL) /* Character data not available? */ + { + report_error(12); /* Report character data not avail */ + return (fix31)0; /* Return zero character width */ + } + +pointer += 2; /* Skip over character id */ +set_width = (fix31)NEXT_WORD(pointer); /* Read set width and Convert units */ +set_width = ((set_width << 16) + (sp_globals.metric_resolution >> 1)) / sp_globals.metric_resolution; +return set_width; /* Return in 1/65536 em units */ +} +#endif + +#if INCL_METRICS +FUNCTION fix15 get_track_kern( +GDECL +fix15 track, /* Track required (0 - 3) */ +fix15 point_size) /* Point size (units of whole points) */ +/* + * Returns inter-character spacing adjustment in units of 1/256 + * points for the specified kerning track and point size. + * If the specified point size is larger than the maximum point + * size for the specified track, the adjustment for the maximum + * point size is used. + * If the specified point size is smaller than the minimum point + * size for the specified track, the adjustment for the minimum + * point size is used. + * If the specified point size is between the minimum point size + * and the maximum point size for the specified track, the + * adjustment is interpolated linearly between the minimum and + * maximum adjustments. + * Reports Error 10 and returns 0 if no font selected. + * Reports Error 13 and returns 0 if track kerning data not in font. + */ +{ +ufix8 FONTFAR *pointer; /* Pointer to character data */ +fix15 no_tracks; /* Number of kerning tracks in font */ +ufix8 format; /* Track kerning format byte */ +fix15 i; /* Track counter */ +fix15 min_pt_size = 0; /* Minimum point size for track */ +fix15 max_pt_size = 0; /* Maximum point size for track */ +fix15 min_adj = 0; /* Adjustment for min point size */ +fix15 max_adj = 0; /* Adjustment for max point size */ +fix31 delta_pt_size; /* Max point size - min point size */ +fix31 delta_adj; /* Min adjustment - max adjustment */ +fix15 adj = 0; /* Interpolated adjustment */ + +if (track == 0) /* Track zero selected? */ + { + return adj; /* Return zero track kerning adjustment */ + } + +if (!sp_globals.specs_valid) /* Font specs not defined? */ + { + report_error(10); /* Report font not specified */ + return adj; /* Return zero track kerning adjustment */ + } + +no_tracks = sp_globals.kern.no_tracks; /* Number of kerning tracks */ +if (track > no_tracks) /* Required track not available? */ + { + report_error(13); /* Report track kerning data not avail */ + return adj; /* Return zero track kerning adjustment */ + } + +pointer = sp_globals.kern.tkorg; /* Point to start of track kern data */ +for (i = 0; i < track; i++) /* Read until track required is read */ + { + format = NEXT_BYTE(pointer); /* Read track kerning format byte */ + min_pt_size = (format & BIT0)? + NEXT_WORD(pointer): + (fix15)NEXT_BYTE(pointer); + min_adj = (format & BIT1)? + NEXT_WORD(pointer): + (fix15)NEXT_BYTE(pointer); + max_pt_size = (format & BIT2)? + NEXT_WORD(pointer): + (fix15)NEXT_BYTE(pointer); + max_adj = (format & BIT3)? + NEXT_WORD(pointer): + (fix15)NEXT_BYTE(pointer); + } + +if (point_size <= min_pt_size) /* Smaller than minimum point size? */ + { + return min_adj; /* Return minimum adjustment (1/256 points) */ + } + +if (point_size >= max_pt_size) /* Larger than maximum point size? */ + { + return max_adj; /* Return maximum adjustment (1/256 points) */ + } + +delta_pt_size = (fix31)(max_pt_size - min_pt_size); +delta_adj = (fix31)(min_adj - max_adj); +adj = (fix15)(min_adj - + (((fix31)(point_size - min_pt_size) * delta_adj + + (delta_pt_size >> 1)) / delta_pt_size)); +return adj; /* Return interpolated adjustment (1/256 points) */ +} +#endif + +#if INCL_METRICS +FUNCTION fix31 get_pair_kern( +GDECL +ufix16 char_index1, /* Index to first character in char directory */ +ufix16 char_index2) /* Index to second character in char directory */ +/* + * Returns inter-character spacing adjustment in units of 1/65536 em + * for the specified pair of characters. + * Reports Error 10 and returns 0 if no font selected. + * Reports Error 14 and returns 0 if pair kerning data not in font. + */ +{ +ufix8 FONTFAR *origin; /* Pointer to first kerning pair record */ +ufix8 FONTFAR *pointer; /* Pointer to character data */ +ufix16 tmpufix16; /* Temporary workspace */ +fix15 no_pairs; /* Number of kerning pairs in font */ +ufix8 format; /* Track kerning format byte */ +boolean long_id; /* TRUE if 2-byte character ids */ +fix15 rec_size; /* Number of bytes in kern pair record */ +fix15 n; /* Number of remaining kern pairs */ +fix15 nn; /* Number of kern pairs in first partition */ +fix15 base; /* Index to first record in rem kern pairs */ +fix15 i; /* Index to kern pair being tested */ +fix31 adj = 0; /* Returned value of adjustment */ +fix15 adj_base = 0; /* Adjustment base for relative adjustments */ + +if (!sp_globals.specs_valid) /* Font specs not defined? */ + { + report_error(10); /* Report font not specified */ + return adj; /* Return zero pair kerning adjustment */ + } + +no_pairs = sp_globals.kern.no_pairs; /* Number of kerning pairs */ +if (no_pairs == 0) /* Pair kerning data not available? */ + { + report_error(14); /* Report pair kerning data not avail */ + return adj; /* Return zero pair kerning adjustment */ + } + +pointer = sp_globals.kern.pkorg; /* Point to start of pair kern data */ +format = NEXT_BYTE(pointer); /* Read pair kerning format byte */ +if (!(format & BIT0)) /* One-byte adjustment values? */ + adj_base = NEXT_WORD(pointer); /* Read base adjustment */ +origin = pointer; /* First byte of kerning pair data */ +rec_size = format + 3; /* Compute kerning pair record size */ +long_id = format & BIT1; /* Set flag for 2-byte char index */ + +n = no_pairs; /* Consider all kerning pairs */ +base = 0; /* Set base at first kern pair record */ +while (n != 0) /* While 1 or more kern pairs remain ... */ + { + nn = n >> 1; /* Size of first partition */ + i = base + nn; /* Index to record to be tested */ + pointer = origin + (i * rec_size); + tmpufix16 = NEXT_CHNDX(pointer, long_id); + if (char_index1 < tmpufix16) + { + n = nn; /* Number remaining in first partition */ + continue; + } + if (char_index1 > tmpufix16) + { + n -= nn + 1; /* Number remaining in second partition */ + base = i + 1; /* Base index for second partition */ + continue; + } + tmpufix16 = NEXT_CHNDX(pointer, long_id); + if (char_index2 < tmpufix16) + { + n = nn; /* Number remaining in first partition */ + continue; + } + if (char_index2 > tmpufix16) + { + n -= nn + 1; /* Number remaining in second partition */ + base = i + 1; /* Base index for second partition */ + continue; + } + adj = (format & BIT0)? + (fix31)NEXT_WORD(pointer): + (fix31)(adj_base + (fix15)NEXT_BYTE(pointer)); + adj = ((adj << 16) + (sp_globals.orus_per_em >> 1)) / sp_globals.orus_per_em; /* Convert units */ + n = 0; /* No more to consider */ + } +return adj; /* Return pair kerning adjustment */ +} +#endif + + +#if INCL_METRICS +#ifdef old +FUNCTION boolean get_char_bbox( +GDECL +ufix16 char_index, +bbox_t *bbox) +{ +/* + * returns true if character exists, false if it doesn't + * provides transformed character bounding box in 1/65536 pixels + * in the provided bbox_t structure. Bounding box may be + * conservative in the event that the transformation is not + * normal or the character is compound. + */ + +ufix8 FONTFAR *pointer; +fix15 tmp; +point_t Pmin, Pmax; + +#if REENTRANT_ALLOC +plaid_t plaid; +sp_globals.plaid = &plaid; +#endif + +if (!sp_globals.specs_valid) /* Font specs not defined? */ + { + report_error(10); /* Report font not specified */ + return FALSE; /* Error return */ + } + +init_tcb(); /* Initialize transformation control block */ + +pointer = sp_get_char_org(char_index, TRUE); /* Point to start of character data */ +if (pointer == NULL) /* Character data not available? */ + { + report_error(12); /* Report character data not avail */ + return FALSE; /* Error return */ + } + +pointer += 2; /* Skip over character id */ +tmp = NEXT_WORD(pointer); /* Read set width */ + +tmp = NEXT_BYTE(pointer); +if (tmp & BIT1) /* Optional data in header? */ + { + tmp = (ufix8)NEXT_BYTE(pointer); /* Read size of optional data */ + pointer += tmp; /* Skip optional data */ + } + +pointer = plaid_tcb(pointer, tmp); /* Process plaid data */ +pointer = read_bbox(pointer, &Pmin, &Pmax,(boolean)FALSE); /* Read bounding box */ +bbox->xmin = (fix31)Pmin.x << sp_globals.poshift; +bbox->xmax = (fix31)Pmax.x << sp_globals.poshift; +bbox->ymin = (fix31)Pmin.y << sp_globals.poshift; +bbox->ymax = (fix31)Pmax.y << sp_globals.poshift; +return TRUE; +} + +#else /* new code, 4/25/91 */ + +FUNCTION boolean get_char_bbox( +GDECL +ufix16 char_index, +bbox_t *bbox) +{ +/* + * returns true if character exists, false if it doesn't + * provides transformed character bounding box in 1/65536 pixels + * in the provided bbox_t structure. Bounding box may be + * conservative in the event that the transformation is not + * normal or the character is compound. + */ + +ufix8 FONTFAR *pointer; +fix15 tmp; +fix15 format; +ufix16 pix_adj; +point_t Pmin, Pmax; + +#if REENTRANT_ALLOC +plaid_t plaid; +sp_globals.plaid = &plaid; +#endif + +if (!sp_globals.specs_valid) /* Font specs not defined? */ + { + report_error(10); /* Report font not specified */ + return FALSE; /* Error return */ + } + +init_tcb(); /* Initialize transformation control block */ + +pointer = sp_get_char_org(char_index, TRUE); /* Point to start of character data */ +if (pointer == NULL) /* Character data not available? */ + { + report_error(12); /* Report character data not avail */ + return FALSE; /* Error return */ + } + +pointer += 2; /* Skip over character id */ +tmp = NEXT_WORD(pointer); /* Read set width */ + +format = NEXT_BYTE(pointer); +if (format & BIT1) /* Optional data in header? */ + { + tmp = (ufix8)NEXT_BYTE(pointer); /* Read size of optional data */ + pointer += tmp; /* Skip optional data */ + } + +if (format & BIT0) + { + pix_adj = sp_globals.onepix << 1; /* Allow 2 pixel expansion ... */ + } +else + { + pix_adj = 0; + } + +pointer = plaid_tcb(pointer, format); /* Process plaid data */ +pointer = read_bbox(pointer, &Pmin, &Pmax,(boolean)FALSE); /* Read bounding box */ + +Pmin.x -= pix_adj; /* ... of components of ... */ +Pmin.y -= pix_adj; /* ... compound ... */ +Pmax.x += pix_adj; /* ... character ... */ +Pmax.y += pix_adj; /* ... bounding box. */ + + +bbox->xmin = (fix31)Pmin.x << sp_globals.poshift; +bbox->xmax = (fix31)Pmax.x << sp_globals.poshift; +bbox->ymin = (fix31)Pmin.y << sp_globals.poshift; +bbox->ymax = (fix31)Pmax.y << sp_globals.poshift; +return TRUE; +} +#endif /* new code */ + +#endif + + +#if INCL_ISW +FUNCTION boolean make_char_isw( +GDECL +ufix16 char_index, +ufix32 imported_setwidth) +{ +fix15 xmin; /* Minimum X ORU value in font */ +fix15 xmax; /* Maximum X ORU value in font */ +fix15 ymin; /* Minimum Y ORU value in font */ +fix15 ymax; /* Maximum Y ORU value in font */ +ufix16 return_value; + +sp_globals.import_setwidth_act = TRUE; +/* convert imported width to orus */ +sp_globals.imported_width = (sp_globals.metric_resolution * + imported_setwidth) >> 16; +return_value = do_make_char(char_index); + +if (sp_globals.isw_modified_constants) + { + /* reset fixed point constants */ + xmin = read_word_u(sp_globals.font_org + FH_FXMIN); + ymin = read_word_u(sp_globals.font_org + FH_FYMIN); + ymax = read_word_u(sp_globals.font_org + FH_FYMAX); + sp_globals.constr.data_valid = FALSE; + xmax = read_word_u(sp_globals.font_org + FH_FXMAX); + if (!setup_consts(xmin,xmax,ymin,ymax)) + { + report_error(3); /* Requested specs out of range */ + return FALSE; + } + } +return (return_value); +} + +FUNCTION boolean make_char( +GDECL +ufix16 char_index) /* Index to character in char directory */ +{ +sp_globals.import_setwidth_act = FALSE; +return (do_make_char(char_index)); +} + +FUNCTION static boolean do_make_char(GDECL ufix16 char_index) +#else +FUNCTION boolean make_char(GDECL ufix16 char_index) +#endif +/* + * Outputs specified character using the currently selected font and + * scaling and output specifications. + * Reports Error 10 and returns FALSE if no font specifications + * previously set. + * Reports Error 12 and returns FALSE if character data not available. + */ +{ +ufix8 FONTFAR *pointer; /* Pointer to character data */ +fix15 x_orus; +fix15 tmpfix15; +ufix8 format; + +#if INCL_ISW +sp_globals.isw_modified_constants = FALSE; +#endif + +#if REENTRANT_ALLOC + +plaid_t plaid; + +#if INCL_BLACK || INCL_SCREEN || INCL_2D +intercepts_t intercepts; +sp_globals.intercepts = &intercepts; +#endif + +sp_globals.plaid = &plaid; +#endif + +if (!sp_globals.specs_valid) /* Font specs not defined? */ + { + report_error(10); /* Report font not specified */ + return FALSE; /* Error return */ + } + +#if INCL_MULTIDEV +#if INCL_OUTLINE +if (sp_globals.output_mode == MODE_OUTLINE && !sp_globals.outline_device_set) + { + report_error(2); + return FALSE; + } +else +#endif + if (!sp_globals.bitmap_device_set) + { + report_error(2); + return FALSE; + } +#endif + + +init_tcb(); /* Initialize transformation control block */ + +pointer = sp_get_char_org(char_index, TRUE); /* Point to start of character data */ +SHOW(pointer); +if (pointer == NULL) /* Character data not available? */ + { + report_error(12); /* Report character data not avail */ + return FALSE; /* Error return */ + } + +pointer += 2; /* Skip over character id */ +x_orus = NEXT_WORD(pointer); /* Read set width */ +#if INCL_SQUEEZING || INCL_ISW +sp_globals.setwidth_orus = x_orus; +#endif + +#if INCL_ISW +if (sp_globals.import_setwidth_act) + x_orus = sp_globals.imported_width; +#endif +sp_globals.Psw.x = (fix15)((fix31) + (((fix31)x_orus * (sp_globals.specs.xxmult>>16) + + ( ((fix31)x_orus * (sp_globals.specs.xxmult&0xffffL) )>>16) + ) << sp_globals.pixshift) / sp_globals.metric_resolution); + +sp_globals.Psw.y = (fix15)( + (fix31)( + ((fix31)x_orus * (sp_globals.specs.yxmult>>16) + + ( ((fix31)x_orus * (sp_globals.specs.yxmult&0xffffL) )>>16) + ) << sp_globals.pixshift) / sp_globals.metric_resolution); + +format = NEXT_BYTE(pointer); +if (format & BIT1) /* Optional data in header? */ + { + tmpfix15 = (ufix8)NEXT_BYTE(pointer); /* Read size of optional data */ + pointer += tmpfix15; /* Skip optional data */ + } +if (format & BIT0) + { + return sp_make_comp_char(pointer); /* Output compound character */ + } +else + { + return sp_make_simp_char(pointer, format); /* Output simple character */ + } +} + +FUNCTION static boolean sp_make_simp_char( +GDECL +ufix8 FONTFAR *pointer, /* Pointer to first byte of position argument */ +ufix8 format) /* Character format byte */ +/* + * Called by sp_make_char() to output a simple (non-compound) character. + * Returns TRUE on completion. + */ +{ +point_t Pmin, Pmax; /* Transformed corners of bounding box */ +#if INCL_SQUEEZING || INCL_ISW +ufix8 FONTFAR *save_pointer; +#endif +#if INCL_ISW +fix31 char_width; +fix31 isw_scale; +#endif + +#if INCL_SQUEEZING +sp_globals.squeezing_compound = FALSE; +if ((sp_globals.pspecs->flags & SQUEEZE_LEFT) || + (sp_globals.pspecs->flags & SQUEEZE_RIGHT) || + (sp_globals.pspecs->flags & SQUEEZE_TOP) || + (sp_globals.pspecs->flags & SQUEEZE_BOTTOM) ) + { + /* get the bounding box data before processing the character */ + save_pointer = pointer; + preview_bounding_box (pointer, format); + pointer = save_pointer; + } +#endif +#if (INCL_ISW) +if (sp_globals.import_setwidth_act) + { + save_pointer = pointer; + preview_bounding_box (pointer, format); + pointer = save_pointer; + /* make sure I'm not going to get fixed point overflow */ + isw_scale = compute_isw_scale(); + if (sp_globals.bbox_xmin_orus < 0) + char_width = SQUEEZE_MULT((sp_globals.bbox_xmax_orus - sp_globals.bbox_xmin_orus), isw_scale); + else + char_width = SQUEEZE_MULT(sp_globals.bbox_xmax_orus, isw_scale); + if (char_width >= sp_globals.isw_xmax) + if (!reset_xmax(char_width)) + return FALSE; + } +#endif +pointer = plaid_tcb(pointer, format); /* Process plaid data */ +pointer = read_bbox(pointer, &Pmin, &Pmax, FALSE); /* Read bounding box */ +if (fn_begin_char(sp_globals.Psw, Pmin, Pmax)) /* Signal start of character output */ + { + do + { + proc_outl_data(pointer); /* Process outline data */ + } + while (!fn_end_char()); /* Repeat if not done */ + } +return TRUE; +} + +FUNCTION static boolean sp_make_comp_char( +GDECL +ufix8 FONTFAR *pointer) /* Pointer to first byte of position argument */ +/* + * Called by sp_make_char() to output a compound character. + * Returns FALSE if data for any sub-character is not available. + * Returns TRUE if output completed with no error. + */ +{ +point_t Pmin, Pmax; /* Transformed corners of bounding box */ +point_t Pssw; /* Transformed escapement vector */ +ufix8 FONTFAR *pointer_sav; /* Saved pointer to compound character data */ +ufix8 FONTFAR *sub_pointer; /* Pointer to sub-character data */ +ufix8 format; /* Format of DOCH instruction */ +ufix16 sub_char_index; /* Index to sub-character in character directory */ +fix15 x_posn; /* X position of sub-character (outline res units) */ +fix15 y_posn; /* Y position of sub-character (outline res units) */ +fix15 x_scale; /* X scale factor of sub-character (scale units) */ +fix15 y_scale; /* Y scale factor of sub-character (scale units) */ +fix15 tmpfix15; /* Temporary workspace */ +fix15 x_orus; /* Set width in outline resolution units */ +fix15 pix_adj; /* Pixel adjustment to compound char bounding box */ +#if INCL_SQUEEZING +fix31 x_factor, x_offset, top_scale, bottom_scale; +boolean squeezed_x, squeezed_y; +#endif +#if INCL_SQUEEZING || INCL_ISW +fix15 x_offset_pix; +#endif +#if INCL_ISW +fix31 char_width; +fix31 isw_scale; +#endif + + +#if INCL_SQUEEZING +sp_globals.squeezing_compound = TRUE; +#endif +pointer = read_bbox(pointer, &Pmin, &Pmax, TRUE); /* Read bounding box data */ +pix_adj = sp_globals.onepix << 1; /* Allow 2 pixel expansion ... */ +Pmin.x -= pix_adj; /* ... of components of ... */ +Pmin.y -= pix_adj; /* ... compound ... */ +Pmax.x += pix_adj; /* ... character ... */ +Pmax.y += pix_adj; /* ... bounding box. */ + +#if INCL_SQUEEZING +/* scale the bounding box if necessary before calling begin_char */ +squeezed_x = calculate_x_scale(&x_factor, &x_offset, 0); +squeezed_y = calculate_y_scale(&top_scale, &bottom_scale,0,0); + +if (squeezed_x) + { /* scale the x coordinates of the bbox */ + x_offset_pix = (fix15)(((x_offset >> 16) * sp_globals.tcb0.xppo) + >> sp_globals.mpshift); + if ((x_offset_pix >0) && (x_offset_pix < sp_globals.onepix)) + x_offset_pix = sp_globals.onepix; + Pmin.x = SQUEEZE_MULT (x_factor, Pmin.x) + x_offset_pix - pix_adj; + Pmax.x = SQUEEZE_MULT (x_factor, Pmax.x) + x_offset_pix + pix_adj; + } +if (squeezed_y) + { /* scale the y coordinates of the bbox */ + if ((Pmin.y) < 0) + Pmin.y = SQUEEZE_MULT (bottom_scale, Pmin.y) - pix_adj; + else + Pmin.y = SQUEEZE_MULT (top_scale, Pmin.y) - pix_adj; + if ((Pmax.y) < 0) + Pmax.y = SQUEEZE_MULT (bottom_scale, Pmax.y) + pix_adj; + else + Pmax.y = SQUEEZE_MULT (top_scale, Pmax.y) + pix_adj; + } +#endif +#if (INCL_ISW) +if (sp_globals.import_setwidth_act) + { + /* make sure I'm not going to get fixed point overflow */ + isw_scale = ((fix31)sp_globals.imported_width << 16)/ + (fix31)sp_globals.setwidth_orus; + char_width = SQUEEZE_MULT((sp_globals.bbox_xmax_orus - + sp_globals.bbox_xmin_orus), +isw_scale); + if (char_width >= sp_globals.isw_xmax) + if (!reset_xmax(char_width)) + return FALSE; + } +#endif + +if (fn_begin_char(sp_globals.Psw, Pmin, Pmax)) /* Signal start of character data */ + { + pointer_sav = pointer; + do + { + pointer = pointer_sav; /* Point to next DOCH or END instruction */ + while ((format = NEXT_BYTE(pointer))) /* DOCH instruction? */ + { + init_tcb(); /* Initialize transformation control block */ + x_posn = sp_get_posn_arg(&pointer, format); + y_posn = sp_get_posn_arg(&pointer, (ufix8)(format >> 2)); + x_scale = sp_get_scale_arg(&pointer, (ufix8)(format & BIT4)); + y_scale = sp_get_scale_arg(&pointer, (ufix8)(format & BIT5)); + scale_tcb(&sp_globals.tcb, x_posn, y_posn, x_scale, y_scale); /* Scale for sub-char */ + sub_char_index = (format & BIT6)? /* Read sub-char index */ + 0xffff & NEXT_WORD(pointer): + 0xffff & NEXT_BYTE(pointer); + sub_pointer = sp_get_char_org(sub_char_index, FALSE); /* Point to start of sub-char */ + if (sub_pointer == NULL) /* Character data not available? */ + { + return FALSE; /* Abort character output */ + } + sub_pointer += 2; /* Skip over character id */ + x_orus = NEXT_WORD(sub_pointer); /* Read set_width of sub-character */ + + Pssw.x = (fix15)( + (fix31)( + ((fix31)x_orus * (sp_globals.specs.xxmult>>16) + + ( ((fix31)x_orus * (sp_globals.specs.xxmult&0xffffL) )>>16) + ) << sp_globals.pixshift) / sp_globals.metric_resolution); + Pssw.y = (fix15)( + (fix31)( + ((fix31)x_orus * (sp_globals.specs.yxmult>>16) + + ( ((fix31)x_orus * (sp_globals.specs.yxmult&0xffffL) )>>16) + ) << sp_globals.pixshift) / sp_globals.metric_resolution); + + format = NEXT_BYTE(sub_pointer); /* Read sub-character format */ + if (format & BIT1) /* Optional data in header? */ + { + tmpfix15 = (ufix8)NEXT_BYTE(sub_pointer); /* Read size of optional data */ + sub_pointer += tmpfix15; /* Skip optional data */ + } + sub_pointer = plaid_tcb(sub_pointer, format); /* Process sub-character plaid data */ + sub_pointer = read_bbox(sub_pointer, &Pmin, &Pmax, FALSE); /* Read bounding box */ + fn_begin_sub_char(Pssw, Pmin, Pmax); /* Signal start of sub-character data */ + proc_outl_data(sub_pointer); /* Process sub-character data */ + fn_end_sub_char(); /* Signal end of sub-character data */ + } + } + while (!fn_end_char()); /* Signal end of character; repeat if required */ + } +return TRUE; +} + +#if INCL_LCD /* Dynamic load character data supported? */ +FUNCTION static ufix8 FONTFAR *sp_get_char_org( +GDECL +ufix16 char_index, /* Index of character to be accessed */ +boolean top_level) /* Not a compound character element */ +/* + * Called by sp_get_char_id(), sp_get_char_width(), sp_make_char() and + * sp_make_comp_char() to get a pointer to the start of the character data + * for the specified character index. + * Version for configuration supporting dynamic character data loading. + * Calls load_char_data() to load character data if not already loaded + * as part of the original font buffer. + * Returns NULL if character data not available + */ +{ +buff_t *pchar_data; /* Buffer descriptor requested */ +ufix8 FONTFAR *pointer; /* Pointer into character directory */ +ufix8 format; /* Character directory format byte */ +fix31 char_offset; /* Offset of char data from start of font file */ +fix31 next_char_offset; /* Offset of char data from start of font file */ +fix15 no_bytes; /* Number of bytes required for char data */ + +if (top_level) /* Not element of compound char? */ + { + if (char_index < sp_globals.first_char_idx) /* Before start of character set? */ + return NULL; + char_index -= sp_globals.first_char_idx; + if (char_index >= sp_globals.no_chars_avail) /* Beyond end of character set? */ + return NULL; + sp_globals.cb_offset = 0; /* Reset char buffer offset */ + } + +pointer = sp_globals.pchar_dir; +format = NEXT_BYTE(pointer); /* Read character directory format byte */ +pointer += char_index << 1; /* Point to indexed character entry */ +if (format) /* 3-byte entries in char directory? */ + { + pointer += char_index; /* Adjust for 3-byte entries */ + char_offset = read_long(pointer); /* Read file offset to char data */ + next_char_offset = read_long(pointer + 3); /* Read offset to next char */ + } +else + { + char_offset = (fix31)(0xffff & NEXT_WORD(pointer)); /* Read file offset to char data */ + next_char_offset = (fix31)(0xffff & NEXT_WORD(pointer)); /* Read offset to next char */ + } + +no_bytes = next_char_offset - char_offset; +if (no_bytes == 0) /* Character not in directory? */ + return NULL; + +if (next_char_offset <= sp_globals.font_buff_size)/* Character data already in font buffer? */ + return sp_globals.pfont->org + char_offset; /* Return pointer into font buffer */ + +pchar_data = load_char_data(char_offset, no_bytes, sp_globals.cb_offset); /* Request char data load */ +if (pchar_data->no_bytes < no_bytes) /* Correct number of bytes loaded? */ + return NULL; + +if (top_level) /* Not element of compound char? */ + { + sp_globals.cb_offset = no_bytes; + } + +return pchar_data->org; /* Return pointer into character data buffer */ +} +#endif + +#if INCL_LCD +#else /* Dynamic load character data not supported? */ +FUNCTION static ufix8 FONTFAR *sp_get_char_org( +GDECL +ufix16 char_index, /* Index of character to be accessed */ +boolean top_level) /* Not a compound character element */ +/* + * Called by sp_get_char_id(), sp_get_char_width(), sp_make_char() and + * sp_make_comp_char() to get a pointer to the start of the character data + * for the specified character index. + * Version for configuration not supporting dynamic character data loading. + * Returns NULL if character data not available + */ +{ +ufix8 FONTFAR *pointer; /* Pointer into character directory */ +ufix8 format; /* Character directory format byte */ +fix31 char_offset; /* Offset of char data from start of font file */ +fix31 next_char_offset; /* Offset of char data from start of font file */ +fix15 no_bytes; /* Number of bytes required for char data */ + +if (top_level) /* Not element of compound char? */ + { + if (char_index < sp_globals.first_char_idx) /* Before start of character set? */ + return NULL; + char_index -= sp_globals.first_char_idx; + if (char_index >= sp_globals.no_chars_avail) /* Beyond end of character set? */ + return NULL; + } + +pointer = sp_globals.pchar_dir; +format = NEXT_BYTE(pointer); /* Read character directory format byte */ +pointer += char_index << 1; /* Point to indexed character entry */ +if (format) /* 3-byte entries in char directory? */ + { + pointer += char_index; /* Adjust for 3-byte entries */ + char_offset = read_long(pointer); /* Read file offset to char data */ + next_char_offset = read_long(pointer + 3); /* Read offset to next char */ + } +else + { + char_offset = (fix31)(0xffff & NEXT_WORD(pointer)); /* Read file offset to char data */ + next_char_offset = (fix31)(0xffff & NEXT_WORD(pointer)); /* Read offset to next char */ + } + +no_bytes = next_char_offset - char_offset; +if (no_bytes == 0) /* Character not in directory? */ + return NULL; + +return sp_globals.pfont->org + char_offset; /* Return pointer into font buffer */ +} +#endif + + +FUNCTION static fix15 sp_get_posn_arg( +GDECL +ufix8 FONTFAR * STACKFAR *ppointer, /* Pointer to first byte of position argument */ +ufix8 format) /* Format of DOCH arguments */ +/* + * Called by sp_make_comp_char() to read a position argument from the + * specified point in the font/char buffer. + * Updates pointer to byte following position argument. + * Returns value of position argument in outline resolution units + */ +{ +switch (format & 0x03) + { +case 1: + return NEXT_WORD(*ppointer); + +case 2: + return (fix15)((fix7)NEXT_BYTE(*ppointer)); + +default: + return (fix15)0; + } +} + +FUNCTION static fix15 sp_get_scale_arg( +GDECL +ufix8 FONTFAR *STACKFAR *ppointer, /* Pointer to first byte of position argument */ +ufix8 format) /* Format of DOCH arguments */ +/* + * Called by sp_make_comp_char() to read a scale argument from the + * specified point in the font/char buffer. + * Updates pointer to byte following scale argument. + * Returns value of scale argument in scale units (normally 1/4096) + */ +{ +if (format) + return NEXT_WORD(*ppointer); +else + return (fix15)ONE_SCALE; +} +#if INCL_ISW || INCL_SQUEEZING +FUNCTION static void preview_bounding_box( +GDECL +ufix8 FONTFAR *pointer, /* Pointer to first byte of position argument */ +ufix8 format) /* Character format byte */ +{ +point_t Pmin, Pmax; /* Transformed corners of bounding box */ + + sp_globals.no_X_orus = (format & BIT2)? + (fix15)NEXT_BYTE(pointer): + 0; + sp_globals.no_Y_orus = (format & BIT3)? + (fix15)NEXT_BYTE(pointer): + 0; + pointer = read_oru_table(pointer); + + /* Skip over control zone table */ + pointer = skip_control_zone(pointer,format); + + /* Skip over interpolation table */ + pointer = skip_interpolation_table(pointer,format); + /* get_args has a pathological need for this value to be set */ + sp_globals.Y_edge_org = sp_globals.no_X_orus; + pointer = read_bbox(pointer, &Pmin, &Pmax, TRUE); /* Read bounding bo +x */ + +} +#endif +#if INCL_ISW +FUNCTION static boolean reset_xmax( +GDECL +fix31 xmax) + +{ +fix15 xmin; /* Minimum X ORU value in font */ +fix15 ymin; /* Minimum Y ORU value in font */ +fix15 ymax; /* Maximum Y ORU value in font */ + + +sp_globals.isw_modified_constants = TRUE; +xmin = read_word_u(sp_globals.font_org + FH_FXMIN); +ymin = read_word_u(sp_globals.font_org + FH_FYMIN); +ymax = read_word_u(sp_globals.font_org + FH_FYMAX); + +if (!setup_consts(xmin,xmax,ymin,ymax)) + { + report_error(3); /* Requested specs out of range */ + return FALSE; + } +sp_globals.constr.data_valid = FALSE; +/* recompute setwidth */ +sp_globals.Psw.x = (fix15)((fix31)( + ((fix31)sp_globals.imported_width * (sp_globals.specs.xxmult>>16) + + ( ((fix31)sp_globals.imported_width * + (sp_globals.specs.xxmult&0xffffL) )>>16) + ) << sp_globals.pixshift) / sp_globals.metric_resolution); +sp_globals.Psw.y = (fix15)( + (fix31)( + ((fix31)sp_globals.imported_width * (sp_globals.specs.yxmult>>16) + + ( ((fix31)sp_globals.imported_width * (sp_globals.specs.yxmult&0xffffL) )>>16) + ) << sp_globals.pixshift) / sp_globals.metric_resolution); + +return TRUE; +} +#endif diff --git a/nx-X11/lib/font/Speedo/do_trns.c b/nx-X11/lib/font/Speedo/do_trns.c new file mode 100644 index 000000000..2e0f1dbed --- /dev/null +++ b/nx-X11/lib/font/Speedo/do_trns.c @@ -0,0 +1,512 @@ +/* $Xorg: do_trns.c,v 1.3 2000/08/17 19:46:25 cpqbld Exp $ */ + +/* + +Copyright 1989-1991, Bitstream Inc., Cambridge, MA. +You are hereby granted permission under all Bitstream propriety rights to +use, copy, modify, sublicense, sell, and redistribute the Bitstream Speedo +software and the Bitstream Charter outline font for any purpose and without +restrictions; provided, that this notice is left intact on all copies of such +software or font and that Bitstream's trademark is acknowledged as shown below +on all unmodified copies of such font. + +BITSTREAM CHARTER is a registered trademark of Bitstream Inc. + + +BITSTREAM INC. DISCLAIMS ANY AND ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING +WITHOUT LIMITATION THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE. BITSTREAM SHALL NOT BE LIABLE FOR ANY DIRECT OR INDIRECT +DAMAGES, INCLUDING BUT NOT LIMITED TO LOST PROFITS, LOST DATA, OR ANY OTHER +INCIDENTAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF OR IN ANY WAY CONNECTED +WITH THE SPEEDO SOFTWARE OR THE BITSTREAM CHARTER OUTLINE FONT. + +*/ +/* $XFree86: xc/lib/font/Speedo/do_trns.c,v 1.3 2001/01/17 19:43:17 dawes Exp $ */ + +/**************************** D O _ T R N S . C ****************************** + * * + * This module is responsible for executing all intelligent transformation * + * for bounding box and outline data * + * * + ****************************************************************************/ + + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include "spdo_prv.h" /* General definitions for Speedo */ + +#define DEBUG 0 + +#if DEBUG +#include <stdio.h> +#define SHOW(X) printf("X = %d\n", X) +#else +#define SHOW(X) +#endif + +/***** GLOBAL VARIABLES *****/ + +/***** GLOBAL FUNCTIONS *****/ + +/***** EXTERNAL VARIABLES *****/ + +/***** EXTERNAL FUNCTIONS *****/ + +/***** STATIC VARIABLES *****/ + +/***** STATIC FUNCTIONS *****/ + +static void sp_split_curve(PROTO_DECL2 point_t P1,point_t P2,point_t P3,fix15 depth); +static ufix8 FONTFAR *sp_get_args(PROTO_DECL2 ufix8 FONTFAR *pointer,ufix8 format,point_t STACKFAR *pP); + + +FUNCTION ufix8 FONTFAR *read_bbox( +GDECL +ufix8 FONTFAR *pointer, /* Pointer to next byte in char data */ +point_t STACKFAR *pPmin, /* Lower left corner of bounding box */ +point_t STACKFAR *pPmax, /* Upper right corner of bounding box */ +boolean set_flag) /* flag to indicate whether global oru bbox should be saved */ +/* + * Called by make_simp_char() and make_comp_char() to read the + * bounding box data from the font. + * Sets Pmin and Pmax to the bottom left and top right corners + * of the bounding box after transformation into device space. + * The units of Pmin and Pmax are sub-pixels. + * Updates *ppointer to point to the byte following the + * bounding box data. + */ +{ +ufix8 format1; +ufix8 format = 0; +fix15 i; +point_t P; + +sp_globals.x_int = 0; +sp_globals.y_int = sp_globals.Y_int_org; +sp_globals.x_orus = sp_globals.y_orus = 0; +format1 = NEXT_BYTE(pointer); +pointer = sp_get_args(pointer, format1, pPmin); +#if INCL_SQUEEZING || INCL_ISW +if (set_flag) + { + sp_globals.bbox_xmin_orus = sp_globals.x_orus; + sp_globals.bbox_ymin_orus = sp_globals.y_orus; + } +#endif +*pPmax = *pPmin; +for (i = 1; i < 4; i++) + { + switch(i) + { + case 1: + if (format1 & BIT6) /* Xmax requires X int zone 1? */ + sp_globals.x_int++; + format = (format1 >> 4) | 0x0c; + break; + + case 2: + if (format1 & BIT7) /* Ymax requires Y int zone 1? */ + sp_globals.y_int++; + format = NEXT_BYTE(pointer); + break; + + case 3: + sp_globals.x_int = 0; + format >>= 4; + break; + + default: + break; + } + + pointer = sp_get_args(pointer, format, &P); +#if INCL_SQUEEZING || INCL_ISW + if (set_flag && (i==2)) + { + sp_globals.bbox_xmax_orus = sp_globals.x_orus; + sp_globals.bbox_ymax_orus = sp_globals.y_orus; + } +#endif + if ((i == 2) || (!sp_globals.normal)) + { + if (P.x < pPmin->x) + pPmin->x = P.x; + if (P.y < pPmin->y) + pPmin->y = P.y; + if (P.x > pPmax->x) + pPmax->x = P.x; + if (P.y > pPmax->y) + pPmax->y = P.y; + } + } + +#if DEBUG +printf("BBOX %6.1f(Xint 0), %6.1f(Yint 0), %6.1f(Xint %d), %6.1f(Yint %d)\n", + (real)pPmin->x / (real)sp_globals.onepix, + (real)pPmin->y / (real)sp_globals.onepix, + (real)pPmax->x / (real)sp_globals.onepix, + (format1 >> 6) & 0x01, + (real)pPmax->y / (real)sp_globals.onepix, + (format1 >> 7) & 0x01); + +#endif +return pointer; +} + +FUNCTION void proc_outl_data( +GDECL +ufix8 FONTFAR *pointer) /* Pointer to next byte in char data */ +/* + * Called by make_simp_char() and make_comp_char() to read the + * outline data from the font. + * The outline data is parsed, transformed into device coordinates + * and passed to an output module for further processing. + * Note that pointer is not updated to facilitate repeated + * processing of the outline data when banding mode is in effect. + */ +{ +ufix8 format1, format2; +point_t P0, P1, P2, P3; +fix15 depth; +fix15 curve_count; + +sp_globals.x_int = 0; +sp_globals.y_int = sp_globals.Y_int_org; +#if INCL_PLAID_OUT /* Plaid data monitoring included? */ +record_xint((fix15)sp_globals.x_int); /* Record xint data */ +record_yint((fix15)(sp_globals.y_int - sp_globals.Y_int_org)); /* Record yint data */ +#endif + +sp_globals.x_orus = sp_globals.y_orus = 0; +curve_count = 0; +while(TRUE) + { + format1 = NEXT_BYTE(pointer); + switch(format1 >> 4) + { + case 0: /* LINE */ + pointer = sp_get_args(pointer, format1, &P1); +#if DEBUG + printf("LINE %6.1f, %6.1f\n", + (real)P1.x / (real)sp_globals.onepix, (real)P1.y / (real)sp_globals.onepix); +#endif + fn_line(P1); + sp_globals.P0 = P1; + continue; + + case 1: /* Short XINT */ + sp_globals.x_int = format1 & 0x0f; +#if DEBUG + printf("XINT %d\n", sp_globals.x_int); +#endif +#if INCL_PLAID_OUT /* Plaid data monitoring included? */ +record_xint((fix15)sp_globals.x_int); /* Record xint data */ +#endif + continue; + + case 2: /* Short YINT */ + sp_globals.y_int = sp_globals.Y_int_org + (format1 & 0x0f); +#if DEBUG + printf("YINT %d\n", sp_globals.y_int - sp_globals.Y_int_org); +#endif +#if INCL_PLAID_OUT /* Plaid data monitoring included? */ +record_yint((fix15)(sp_globals.y_int - sp_globals.Y_int_org)); /* Record yint data */ +#endif + continue; + + case 3: /* Miscellaneous */ + switch(format1 & 0x0f) + { + case 0: /* END */ + if (curve_count) + { + fn_end_contour(); + } + return; + + case 1: /* Long XINT */ + sp_globals.x_int = NEXT_BYTE(pointer); +#if DEBUG + printf("XINT %d\n", sp_globals.x_int); +#endif +#if INCL_PLAID_OUT /* Plaid data monitoring included? */ +record_xint((fix15)sp_globals.x_int); /* Record xint data */ +#endif + continue; + + case 2: /* Long YINT */ + sp_globals.y_int = sp_globals.Y_int_org + NEXT_BYTE(pointer); +#if DEBUG + printf("YINT %d\n", sp_globals.y_int - sp_globals.Y_int_org); +#endif +#if INCL_PLAID_OUT /* Plaid data monitoring included? */ +record_yint((fix15)(sp_globals.y_int - sp_globals.Y_int_org)); /* Record yint data */ +#endif + continue; + + default: /* Not used */ + continue; + } + + case 4: /* MOVE Inside */ + case 5: /* MOVE Outside */ + if (curve_count++) + { + fn_end_contour(); + } + + pointer = sp_get_args(pointer, format1, &P0); + sp_globals.P0 = P0; +#if DEBUG + printf("MOVE %6.1f, %6.1f\n", + (real)sp_globals.P0.x / (real)sp_globals.onepix, (real)sp_globals.P0.y / (real)sp_globals.onepix); +#endif + fn_begin_contour(sp_globals.P0, (boolean)(format1 & BIT4)); + continue; + + case 6: /* Undefined */ +#if DEBUG + printf("*** Undefined instruction (Hex %4x)\n", format1); +#endif + continue; + + case 7: /* Undefined */ +#if DEBUG + printf("*** Undefined instruction (Hex %4x)\n", format1); +#endif + continue; + + default: /* CRVE */ + format2 = NEXT_BYTE(pointer); + pointer = sp_get_args(pointer, format1, &P1); + pointer = sp_get_args(pointer, format2, &P2); + pointer = sp_get_args(pointer, (ufix8)(format2 >> 4), &P3); + depth = (format1 >> 4) & 0x07; +#if DEBUG + printf("CRVE %6.1f, %6.1f, %6.1f, %6.1f, %6.1f, %6.1f, %d\n", + (real)P1.x / (real)sp_globals.onepix, (real)P1.y / (real)sp_globals.onepix, + (real)P2.x / (real)sp_globals.onepix, (real)P2.y / (real)sp_globals.onepix, + (real)P3.x / (real)sp_globals.onepix, (real)P3.y / (real)sp_globals.onepix, + depth); +#endif + depth += sp_globals.depth_adj; + if (sp_globals.curves_out) + { + fn_curve(P1, P2, P3, depth); + sp_globals.P0 = P3; + continue; + } + if (depth <= 0) + { + fn_line(P3); + sp_globals.P0 = P3; + continue; + } + sp_split_curve(P1, P2, P3, depth); + continue; + } + } +} + +FUNCTION static void sp_split_curve( +GDECL +point_t P1, /* First control point of Bezier curve */ +point_t P2, /* Second control point of Bezier curve */ +point_t P3, /* End point of Bezier curve */ +fix15 depth) /* Levels of recursive subdivision required */ +/* + * Called by proc_outl_data() to subdivide Bezier curves into an + * appropriate number of vectors, whenever curves are not enabled + * for output to the currently selected output module. + * sp_split_curve() calls itself recursively to the depth specified + * at which point it calls line() to deliver each vector resulting + * from the spliting process. + */ +{ +fix31 X0 = (fix31)sp_globals.P0.x; +fix31 Y0 = (fix31)sp_globals.P0.y; +fix31 X1 = (fix31)P1.x; +fix31 Y1 = (fix31)P1.y; +fix31 X2 = (fix31)P2.x; +fix31 Y2 = (fix31)P2.y; +fix31 X3 = (fix31)P3.x; +fix31 Y3 = (fix31)P3.y; +point_t Pmid; +point_t Pctrl1; +point_t Pctrl2; + +#if DEBUG +printf("CRVE(%3.1f, %3.1f, %3.1f, %3.1f, %3.1f, %3.1f)\n", + (real)P1.x / (real)sp_globals.onepix, (real)P1.y / (real)sp_globals.onepix, + (real)P2.x / (real)sp_globals.onepix, (real)P2.y / (real)sp_globals.onepix, + (real)P3.x / (real)sp_globals.onepix, (real)P3.y / (real)sp_globals.onepix); +#endif + + +Pmid.x = (X0 + (X1 + X2) * 3 + X3 + 4) >> 3; +Pmid.y = (Y0 + (Y1 + Y2) * 3 + Y3 + 4) >> 3; +if ((--depth) <= 0) + { + fn_line(Pmid); + sp_globals.P0 = Pmid; + fn_line(P3); + sp_globals.P0 = P3; + } +else + { + Pctrl1.x = (X0 + X1 + 1) >> 1; + Pctrl1.y = (Y0 + Y1 + 1) >> 1; + Pctrl2.x = (X0 + (X1 << 1) + X2 + 2) >> 2; + Pctrl2.y = (Y0 + (Y1 << 1) + Y2 + 2) >> 2; + sp_split_curve(Pctrl1, Pctrl2, Pmid, depth); + Pctrl1.x = (X1 + (X2 << 1) + X3 + 2) >> 2; + Pctrl1.y = (Y1 + (Y2 << 1) + Y3 + 2) >> 2; + Pctrl2.x = (X2 + X3 + 1) >> 1; + Pctrl2.y = (Y2 + Y3 + 1) >> 1; + sp_split_curve(Pctrl1, Pctrl2, P3, depth); + } +} + +FUNCTION static ufix8 FONTFAR *sp_get_args( +GDECL +ufix8 FONTFAR *pointer, /* Pointer to next byte in char data */ +ufix8 format, /* Format specifiaction of argument pair */ +point_t STACKFAR *pP) /* Resulting transformed point */ +/* + * Called by read_bbox() and proc_outl_data() to read an X Y argument + * pair from the font. + * The format is specified as follows: + * Bits 0-1: Type of X argument. + * Bits 2-3: Type of Y argument. + * where the 4 possible argument types are: + * Type 0: Controlled coordinate represented by one byte + * index into the X or Y controlled coordinate table. + * Type 1: Interpolated coordinate represented by a two-byte + * signed integer. + * Type 2: Interpolated coordinate represented by a one-byte + * signed increment/decrement relative to the + * proceding X or Y coordinate. + * Type 3: Repeat of preceding X or Y argument value and type. + * The units of P are sub-pixels. + * Updates *ppointer to point to the byte following the + * argument pair. + */ +{ +ufix8 edge; + +/* Read X argument */ +switch(format & 0x03) + { +case 0: /* Index to controlled oru */ + edge = NEXT_BYTE(pointer); + sp_globals.x_orus = sp_plaid.orus[edge]; +#if INCL_RULES + sp_globals.x_pix = sp_plaid.pix[edge]; +#endif + break; + +case 1: /* 2 byte interpolated oru value */ + sp_globals.x_orus = NEXT_WORD(pointer); + goto L1; + +case 2: /* 1 byte signed oru increment */ + sp_globals.x_orus += (fix15)((fix7)NEXT_BYTE(pointer)); +L1: +#if INCL_RULES + sp_globals.x_pix = TRANS(sp_globals.x_orus, sp_plaid.mult[sp_globals.x_int], sp_plaid.offset[sp_globals.x_int], sp_globals.mpshift); +#endif + break; + +default: /* No change in X value */ + break; + } + +/* Read Y argument */ +switch((format >> 2) & 0x03) + { +case 0: /* Index to controlled oru */ + edge = sp_globals.Y_edge_org + NEXT_BYTE(pointer); + sp_globals.y_orus = sp_plaid.orus[edge]; +#if INCL_RULES + sp_globals.y_pix = sp_plaid.pix[edge]; +#endif + break; + +case 1: /* 2 byte interpolated oru value */ + sp_globals.y_orus = NEXT_WORD(pointer); + goto L2; + +case 2: /* 1 byte signed oru increment */ + sp_globals.y_orus += (fix15)((fix7)NEXT_BYTE(pointer)); +L2: +#if INCL_RULES + sp_globals.y_pix = TRANS(sp_globals.y_orus, sp_plaid.mult[sp_globals.y_int], sp_plaid.offset[sp_globals.y_int], sp_globals.mpshift); +#endif + break; + +default: /* No change in X value */ + break; + } + +#if INCL_RULES +switch(sp_globals.tcb.xmode) + { +case 0: /* X mode 0 */ + pP->x = sp_globals.x_pix; + break; + +case 1: /* X mode 1 */ + pP->x = -sp_globals.x_pix; + break; + +case 2: /* X mode 2 */ + pP->x = sp_globals.y_pix; + break; + +case 3: /* X mode 3 */ + pP->x = -sp_globals.y_pix; + break; + +default: /* X mode 4 */ +#endif + pP->x = (MULT16(sp_globals.x_orus, sp_globals.tcb.xxmult) + + MULT16(sp_globals.y_orus, sp_globals.tcb.xymult) + + sp_globals.tcb.xoffset) >> sp_globals.mpshift; +#if INCL_RULES + break; + } + +switch(sp_globals.tcb.ymode) + { +case 0: /* Y mode 0 */ + pP->y = sp_globals.y_pix; + break; + +case 1: /* Y mode 1 */ + pP->y = -sp_globals.y_pix; + break; + +case 2: /* Y mode 2 */ + pP->y = sp_globals.x_pix; + break; + +case 3: /* Y mode 3 */ + pP->y = -sp_globals.x_pix; + break; + +default: /* Y mode 4 */ +#endif + pP->y = (MULT16(sp_globals.x_orus, sp_globals.tcb.yxmult) + + MULT16(sp_globals.y_orus, sp_globals.tcb.yymult) + + sp_globals.tcb.yoffset) >> sp_globals.mpshift; +#if INCL_RULES + break; + } +#endif + +return pointer; +} + + + diff --git a/nx-X11/lib/font/Speedo/htest.c b/nx-X11/lib/font/Speedo/htest.c new file mode 100644 index 000000000..235b76560 --- /dev/null +++ b/nx-X11/lib/font/Speedo/htest.c @@ -0,0 +1,361 @@ +/* $Xorg: htest.c,v 1.3 2000/08/17 19:46:25 cpqbld Exp $ */ + +/* + +Copyright 1989-1991, Bitstream Inc., Cambridge, MA. +You are hereby granted permission under all Bitstream propriety rights to +use, copy, modify, sublicense, sell, and redistribute the Bitstream Speedo +software and the Bitstream Charter outline font for any purpose and without +restrictions; provided, that this notice is left intact on all copies of such +software or font and that Bitstream's trademark is acknowledged as shown below +on all unmodified copies of such font. + +BITSTREAM CHARTER is a registered trademark of Bitstream Inc. + + +BITSTREAM INC. DISCLAIMS ANY AND ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING +WITHOUT LIMITATION THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE. BITSTREAM SHALL NOT BE LIABLE FOR ANY DIRECT OR INDIRECT +DAMAGES, INCLUDING BUT NOT LIMITED TO LOST PROFITS, LOST DATA, OR ANY OTHER +INCIDENTAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF OR IN ANY WAY CONNECTED +WITH THE SPEEDO SOFTWARE OR THE BITSTREAM CHARTER OUTLINE FONT. + +*/ + +/****************************** H T E S T . C ******************************** + * * + * SPEEDO FONT HEADER TEST MODULE * + * * + ****************************************************************************/ + + +#include "speedo.h" /* General definition for make_bmap */ +#include <stdio.h> + +#define DEBUG 0 + +#if DEBUG +#define SHOW(X) printf("X = %d\n", X) +#else +#define SHOW(X) +#endif + +#define FONT_BUFFER_SIZE 1000 + +/***** EXTERNAL FUNCTIONS *****/ + +/***** STATIC VARIABLES *****/ +static char pathname[100]; /* Name of font file to be output */ +static ufix8 font_buffer[FONT_BUFFER_SIZE]; /* Font buffer */ +static FILE *fdescr; /* Speedo outline file descriptor */ + + + +FUNCTION main(argc,argv) +int argc; +char *argv[]; +{ +int bytes_read; /* Number of bytes read from font file */ +ufix8 tmpufix8; /* Temporary workspace */ +fix15 tmpfix15; /* Temporary workspace */ +ufix16 tmpufix16; /* Temporary workspace */ +ufix32 tmpufix32; /* Temporary workspace */ +ufix8 *pvt_header_org; /* Origin of provate header data */ + +ufix8 read_1b(); /* Read 1 byte field from font header */ +fix15 read_2b(); /* Read 2 byte field from font header */ +fix31 read_4b(); /* Read 4 byte field from font header */ + +if (argc != 2) + { + fprintf(stderr,"Usage: htest {fontfile}\n\n"); + exit (1); + } + +sprintf(pathname, argv[1]); + +/* Initialization */ +printf("\n SPEEDO FONT FILE HEADER DATA\n"); +printf(" -------------------------\n\n"); +/* Load Speedo outline file */ +fdescr = fopen (pathname, "rb"); +if (fdescr == NULL) + { + printf("****** Cannot open file %s\n", pathname); + return; + } + +bytes_read = fread(font_buffer, sizeof(ufix8), sizeof(font_buffer), fdescr); +if (bytes_read == 0) + { + printf("****** Error on reading %s: %x\n", pathname, bytes_read); + fclose(fdescr); + return; + } + +printf("Format Identifier ...................... %.4s\n", font_buffer + FH_FMVER); + +tmpufix32 = (ufix32)read_4b(font_buffer + FH_FMVER + 4); +printf("CR-LF-NULL-NULL data ............... %8.8lx %s\n", tmpufix32, (tmpufix32 != 0x0d0a0000)? "(incorrect)": " "); + +printf("Font Size .............................. %4ld\n", (ufix32)read_4b(font_buffer + FH_FNTSZ)); + +printf("Minimum Font Buffer Size ............... %4ld\n", (ufix32)read_4b(font_buffer + FH_FBFSZ)); + +printf("Minimum Character Buffer Size .......... %4d\n", (ufix16)read_2b(font_buffer + FH_CBFSZ)); + +printf("Header Size ............................ %4d\n", (ufix16)read_2b(font_buffer + FH_HEDSZ)); + +printf("Font ID ................................ %4.4d\n", (ufix16)read_2b(font_buffer + FH_FNTID)); + +printf("Font Version Number .................... %4d\n", (ufix16)read_1b(font_buffer + FH_SFVNR)); + +printf("Font Full Name:\n %.70s\n", font_buffer + FH_FNTNM); + +printf("Manufacturing Date ................ %10.10s\n", font_buffer + FH_MDATE); + +printf("Character Set Name:\n %s\n", font_buffer + FH_LAYNM); + +printf("Character Set ID: ...................... %.4s\n", font_buffer + FH_LAYNM + 66); + +printf("Copyright Notice:\n %.70s\n", font_buffer + FH_CPYRT); + +printf("Number of Char. Indexes in Char. Set ... %4d\n", (ufix16)read_2b(font_buffer + FH_NCHRL)); + +printf("Total number of Char. Indexes in Font .. %4d\n", (ufix16)read_2b(font_buffer + FH_NCHRF)); + +printf("Index of First Character ............... %4d\n", (ufix16)read_2b(font_buffer + FH_FCHRF)); + +printf("Number of Kerning Tracks ............... %4d\n", (ufix16)read_2b(font_buffer + FH_NKTKS)); + +printf("Number of Kerning Pairs ................ %4d\n", (ufix16)read_2b(font_buffer + FH_NKPRS)); + +printf("Font Flags:\n"); +tmpufix8 = read_1b(font_buffer + FH_FLAGS); +printf(" Extended font ...................... %s\n", (tmpufix8 & BIT0)? " Yes": " No"); + +printf("Classification Flags:\n"); +tmpufix8 = read_1b(font_buffer + FH_CLFGS); +printf(" Italic ............................. %s\n", (tmpufix8 & BIT0)? " Yes": " No"); +printf(" Monospace .......................... %s\n", (tmpufix8 & BIT1)? " Yes": " No"); +printf(" Serif .............................. %s\n", (tmpufix8 & BIT2)? " Yes": " No"); +printf(" Display ............................ %s\n", (tmpufix8 & BIT3)? " Yes": " No"); + +tmpufix8 = read_1b(font_buffer + FH_FAMCL); +printf("Family Classification .................. %4d ", tmpufix8); +switch (tmpufix8) + { +case 0: + printf("(Don't care)\n"); + break; +case 1: + printf("(Serif)\n"); + break; +case 2: + printf("(Sans serif)\n"); + break; +case 3: + printf("(Monospace)\n"); + break; +case 4: + printf("(Script or calligraphic)\n"); + break; +case 5: + printf("(Decorative)\n"); + break; +default: + printf("\n"); + break; + } + +printf("Font Form Classification:\n"); +tmpufix8 = read_1b(font_buffer + FH_FRMCL); +printf(" Width Type ......................... %4d ", (tmpufix8 & 0x0f)); +switch (tmpufix8 & 0x0f) + { +case 4: + printf("(Condensed)\n"); + break; +case 6: + printf("(Semi-condensed)\n"); + break; +case 8: + printf("(Normal)\n"); + break; +case 10: + printf("(Semi-expanded)\n"); + break; +case 12: + printf("(Expanded)\n"); + break; +default: + printf("\n"); + break; + } +printf(" Weight ............................. %4d ", (tmpufix8 >> 4)); +switch (tmpufix8 >> 4) + { +case 1: + printf("(Thin)\n"); + break; +case 2: + printf("(Ultralight)\n"); + break; +case 3: + printf("(Extra light)\n"); + break; +case 4: + printf("(Light)\n"); + break; +case 5: + printf("(Book)\n"); + break; +case 6: + printf("(Normal)\n"); + break; +case 7: + printf("(Medium)\n"); + break; +case 8: + printf("(Semibold)\n"); + break; +case 9: + printf("(Demibold)\n"); + break; +case 10: + printf("(Bold)\n"); + break; +case 11: + printf("(Extrabold)\n"); + break; +case 12: + printf("(Ultrabold)\n"); + break; +case 13: + printf("(Heavy)\n"); + break; +case 14: + printf("(Black)\n"); + break; +default: + printf("\n"); + break; + } + +printf("Short Font Name ........................ %.16s\n", font_buffer + FH_SFNTN); + +printf("Short Face Name ........................ %.16s\n", font_buffer + FH_SFACN); + +printf("Font Form .............................. %.14s\n", font_buffer + FH_FNTFM); + +printf("Italic Angle ........................... %7.2f\n", ((real)read_2b(font_buffer + FH_ITANG) / 256.0)); + +printf("ORUs per Em ............................ %4d\n", (ufix16)read_2b(font_buffer + FH_ORUPM)); + +printf("Width of Word Space .................... %4d\n", (ufix16)read_2b(font_buffer + FH_WDWTH)); + +printf("Width of Em Space ...................... %4d\n", (ufix16)read_2b(font_buffer + FH_EMWTH)); + +printf("Width of En Space ...................... %4d\n", (ufix16)read_2b(font_buffer + FH_ENWTH)); + +printf("Width of Thin Space .................... %4d\n", (ufix16)read_2b(font_buffer + FH_TNWTH)); + +printf("Width of Figure Space .................. %4d\n", (ufix16)read_2b(font_buffer + FH_FGWTH)); + +printf("Min X coordinate in font ............... %4d\n", (fix15)read_2b(font_buffer + FH_FXMIN)); + +printf("Min Y coordinate in font ............... %4d\n", (fix15)read_2b(font_buffer + FH_FYMIN)); + +printf("Max X coordinate in font ............... %4d\n", (fix15)read_2b(font_buffer + FH_FXMAX)); + +printf("Max Y coordinate in font ............... %4d\n", (fix15)read_2b(font_buffer + FH_FYMAX)); + +printf("Underline Position ..................... %4d\n", (fix15)read_2b(font_buffer + FH_ULPOS)); + +printf("Underline Thickness .................... %4d\n", (fix15)read_2b(font_buffer + FH_ULTHK)); + +printf("Small Caps Y position .................. %4d\n", (fix15)read_2b(font_buffer + FH_SMCTR)); +printf("Small Caps X scale ..................... %7.2f\n", ((real)read_2b(font_buffer + FH_SMCTR + 2) / 4096.0)); +printf("Small Caps Y scale ..................... %7.2f\n", ((real)(fix15)read_2b(font_buffer + FH_SMCTR + 4) / 4096.0)); + +printf("Display Superiors Y position ........... %4d\n", (fix15)read_2b(font_buffer + FH_SMCTR)); +printf("Display Superiors X scale .............. %7.2f\n", ((real)read_2b(font_buffer + FH_SMCTR + 2) / 4096.0)); +printf("Display Superiors Y scale .............. %7.2f\n", ((real)read_2b(font_buffer + FH_SMCTR + 4) / 4096.0)); + +printf("Footnote Superiors Y position .......... %4d\n", (fix15)read_2b(font_buffer + FH_FNSTR)); +printf("Footnote Superiors X scale ............. %7.2f\n", ((real)read_2b(font_buffer + FH_FNSTR + 2) / 4096.0)); +printf("Footnote Superiors Y scale ............. %7.2f\n", ((real)read_2b(font_buffer + FH_FNSTR + 4) / 4096.0)); + +printf("Alpha Superiors Y position ............. %4d\n", (fix15)read_2b(font_buffer + FH_ALSTR)); +printf("Alpha Superiors X scale ................ %7.2f\n", ((real)read_2b(font_buffer + FH_ALSTR + 2) / 4096.0)); +printf("Alpha Superiors Y scale ................ %7.2f\n", ((real)read_2b(font_buffer + FH_ALSTR + 4) / 4096.0)); + +printf("Chemical Inferiors Y position .......... %4d\n", (fix15)read_2b(font_buffer + FH_CMITR)); +printf("Chemical Inferiors X scale ............. %7.2f\n", ((real)read_2b(font_buffer + FH_CMITR + 2) / 4096.0)); +printf("Chemical Inferiors Y scale ............. %7.2f\n", ((real)read_2b(font_buffer + FH_CMITR + 4) / 4096.0)); + +printf("Small Numerators Y position ............ %4d\n", (fix15)read_2b(font_buffer + FH_SNMTR)); +printf("Small Numerators X scale ............... %7.2f\n", ((real)read_2b(font_buffer + FH_SNMTR + 2) / 4096.0)); +printf("Small Numerators Y scale ............... %7.2f\n", ((real)read_2b(font_buffer + FH_SNMTR + 4) / 4096.0)); + +printf("Small Denominators Y position .......... %4d\n", (fix15)read_2b(font_buffer + FH_SDNTR)); +printf("Small Denominators X scale ............. %7.2f\n", ((real)read_2b(font_buffer + FH_SDNTR + 2) / 4096.0)); +printf("Small Denominators Y scale ............. %7.2f\n", ((real)read_2b(font_buffer + FH_SDNTR + 4) / 4096.0)); + +printf("Medium Numerators Y position ........... %4d\n", (fix15)read_2b(font_buffer + FH_MNMTR)); +printf("Medium Numerators X scale .............. %7.2f\n", ((real)read_2b(font_buffer + FH_MNMTR + 2) / 4096.0)); +printf("Medium Numerators Y scale .............. %7.2f\n", ((real)read_2b(font_buffer + FH_MNMTR + 4) / 4096.0)); + +printf("Medium Denominators Y position ......... %4d\n", (fix15)read_2b(font_buffer + FH_MDNTR)); +printf("Medium Denominators X scale ............ %7.2f\n", ((real)read_2b(font_buffer + FH_MDNTR + 2) / 4096.0)); +printf("Medium Denominators Y scale ............ %7.2f\n", ((real)read_2b(font_buffer + FH_MDNTR + 4) / 4096.0)); + +printf("Large Numerators Y position ............ %4d\n", (fix15)read_2b(font_buffer + FH_LNMTR)); +printf("Large Numerators X scale ............... %7.2f\n", ((real)read_2b(font_buffer + FH_LNMTR + 2) / 4096.0)); +printf("Large Numerators Y scale ............... %7.2f\n", ((real)read_2b(font_buffer + FH_LNMTR + 4) / 4096.0)); + +printf("Large Denominators Y position .......... %4d\n", (fix15)read_2b(font_buffer + FH_LDNTR)); +printf("Large Denominators X scale ............. %7.2f\n", ((real)read_2b(font_buffer + FH_LDNTR + 2) / 4096.0)); +printf("Large Denominators Y scale ............. %7.2f\n", ((real)read_2b(font_buffer + FH_LDNTR + 4) / 4096.0)); + +fclose(fdescr); +} + + +FUNCTION ufix8 read_1b(pointer) +ufix8 *pointer; +/* + * Reads 1-byte field from font buffer + */ +{ +return *pointer; +} + +FUNCTION fix15 read_2b(pointer) +ufix8 *pointer; +/* + * Reads 2-byte field from font buffer + */ +{ +fix31 temp; + +temp = *pointer++; +temp = (temp << 8) + *(pointer); +return temp; +} + +FUNCTION fix31 read_4b(pointer) +ufix8 *pointer; +/* + * Reads 4-byte field from font buffer + */ +{ +fix31 temp; + +temp = *pointer++; +temp = (temp << 8) + *(pointer++); +temp = (temp << 8) + *(pointer++); +temp = (temp << 8) + *(pointer); +return temp; +} + diff --git a/nx-X11/lib/font/Speedo/iface.c b/nx-X11/lib/font/Speedo/iface.c new file mode 100644 index 000000000..1dad5ae48 --- /dev/null +++ b/nx-X11/lib/font/Speedo/iface.c @@ -0,0 +1,650 @@ +/* $Xorg: iface.c,v 1.3 2000/08/17 19:46:25 cpqbld Exp $ */ + +/* + +Copyright 1989-1991, Bitstream Inc., Cambridge, MA. +You are hereby granted permission under all Bitstream propriety rights to +use, copy, modify, sublicense, sell, and redistribute the Bitstream Speedo +software and the Bitstream Charter outline font for any purpose and without +restrictions; provided, that this notice is left intact on all copies of such +software or font and that Bitstream's trademark is acknowledged as shown below +on all unmodified copies of such font. + +BITSTREAM CHARTER is a registered trademark of Bitstream Inc. + + +BITSTREAM INC. DISCLAIMS ANY AND ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING +WITHOUT LIMITATION THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE. BITSTREAM SHALL NOT BE LIABLE FOR ANY DIRECT OR INDIRECT +DAMAGES, INCLUDING BUT NOT LIMITED TO LOST PROFITS, LOST DATA, OR ANY OTHER +INCIDENTAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF OR IN ANY WAY CONNECTED +WITH THE SPEEDO SOFTWARE OR THE BITSTREAM CHARTER OUTLINE FONT. + +*/ +/* $XFree86: xc/lib/font/Speedo/iface.c,v 1.2 1998/07/25 06:56:53 dawes Exp $ */ + +/***************************** I F A C E . C ********************************* + * * + * This module provides a layer to make Speedo function calls to and * + * from it compatible with Fontware 2.X function calls. * + * * + ****************************************************************************/ + +#include "speedo.h" /* General definitions for Speedo */ +#ifndef FONTMODULE +#include <math.h> +#else +#include "xf86_ansic.h" +#endif + +#define DEBUG 0 + +#if DEBUG +#include <stdio.h> +#define SHOW(X) printf("X = %d\n", X) +#else +#define SHOW(X) +#endif + +#define PI 3.1415926536 /* pi */ +#define PTPERINCH 72.2892 /* nbr points per inch, exactly! */ + +#define BIT8 0x0100 +#define BIT9 0x0200 +#define BIT10 0x0400 +#define BIT11 0x0800 +#define BIT12 0x1000 +#define BIT13 0x2000 +#define BIT14 0x4000 +#define BIT15 0x8000 + +#define READ 0 + +typedef short bool16; +typedef int bool; + +typedef +struct + { + bool16 left; + bool16 right; + bool16 top; + bool16 bottom; + } lrtb; + + +typedef +struct + { + buff_t *pfont; /* Pointer to font data */ + ufix16 mode; /* what mode is the font generator in */ + real point_size_x; /* Point size in X dimension */ + real point_size_y; /* Point size in Y dimension */ + real res_hor; /* Horizontal resolution of output device */ + real res_ver; /* Vertical resolution of output device */ + real rot_angle; /* Rotation angle in degrees (clockwise) */ + real obl_angle; /* Obliquing angle in degrees (clockwise) */ + bool16 whitewrite; /* if T, generate bitmaps for whitewriters */ + fix15 thresh; /* Scan conversion threshold * + * Thickens characters on each edge by * + * <thresh> sub-pixels */ + bool16 import_widths; /* Use imported width table */ + lrtb clip; /* Clip to standard character cell */ + lrtb squeeze; /* Squeeze to standard character cell */ + bool16 bogus_mode; /* if T, ignore plaid data */ + } comp_char_desc; /* character attributes for scan conv */ + +/***** GLOBAL VARIABLES *****/ + +/***** GLOBAL FUNCTIONS *****/ + fw_reset(); /* Fontware 2.X reset call */ + fw_set_specs(); /* Fontware 2.X set specs call */ +bool fw_make_char(); /* Fontware 2.X make character call */ + +/***** EXTERNAL VARIABLES *****/ + +/***** EXTERNAL FUNCTIONS *****/ +void _open_bitmap(); +void _close_bitmap(); +void _set_bitmap_bits(); +void _open_outline(); +void _open_outline(); +void _start_new_char(); +void _start_curve(); +void _line_to(); +void _close_curve(); +void _close_outline(); + +/***** STATIC VARIABLES *****/ +static specs_t *pspecs; +static buff_t *pfont; +static buff_t char_data; +static fix15 set_width_x; +static specs_t specsarg; + +/***** STATIC FUNCTIONS *****/ +static fix31 make_mult(); + + +FUNCTION fw_reset() +{ +sp_reset(); +} + +FUNCTION fw_set_specs(pspecs) +comp_char_desc *pspecs; /* Pointer to scan conversion parameters structure */ + +/* Fontware 2.X character generator call to set font specifications + * compc -- pointer to structure containing scan conversion parameters. + * ->compf -- compressed font data structure + * ->point_size_x -- x pointsize + * ->point_size_y -- y pointsize + * ->res_hor -- horizontal pixels per inch + * ->res_ver -- vertical pixels per inch + * ->rot_angle -- rotation angle in degrees (clockwise) + * ->obl_angle -- obliquing angle in degrees (clockwise) + * ->whitewrite -- if true, generate bitmaps for whitewriters + * ->thresh -- scan-conversion threshold + * ->import_widths -- if true, use external width table + * ->clip.left -- clips min x at left of emsquare + * ->clip.right -- clips max x at right of emsquare + * ->clip.bottom -- clips min x at bottom of emsquare + * ->clip.top -- clips max x at top of emsquare + * ->squeeze.left -- squeezes min x at left of emsquare + * ->squeeze.right, .top, .bottom &c + * ->sw_fixed -- if TRUE, match pixel widths to scaled outline widths + * ->bogus_mode -- ignore plaid data if TRUE + */ + +{ +fix15 irot; +fix15 iobl; +fix15 x_trans_type; +fix15 y_trans_type; +fix31 xx_mult; +fix31 xy_mult; +fix31 yx_mult; +fix31 yy_mult; +real sinrot, cosrot, tanobl; +real x_distortion; +real pixperem_h; +real pixperem_v; +real point_size_x; +real point_size_y; +real res_hor; +real res_ver; +fix15 mode; + +specsarg.pfont = pspecs->pfont; + +irot = floor(pspecs->rot_angle + 0.5); +iobl = floor(pspecs->obl_angle + 0.5); +if (iobl > 85) + iobl = 85; +if (iobl < -85) + iobl = -85; +if ((irot % 90) == 0) + { + x_trans_type = y_trans_type = irot / 90 & 0x0003; + if (iobl != 0) + { + if (x_trans_type & 0x01) + y_trans_type = 4; + else + x_trans_type = 4; + } + } +else if (((irot + iobl) % 90) == 0) + { + x_trans_type = y_trans_type = (irot + iobl) / 90 & 0x0003; + if (iobl != 0) + { + if (x_trans_type & 0x01) + x_trans_type = 4; + else + y_trans_type = 4; + } + } +else + { + x_trans_type = y_trans_type = 4; + } + +point_size_x = pspecs->point_size_x; +point_size_y = pspecs->point_size_y; +res_hor = pspecs->res_hor; +res_ver = pspecs->res_ver; + +switch (x_trans_type) + { +case 0: + xx_mult = make_mult(point_size_x, res_hor); + xy_mult = 0; + break; + +case 1: + xx_mult = 0; + xy_mult = make_mult(point_size_y, res_hor); + break; + +case 2: + xx_mult = -make_mult(point_size_x, res_hor); + xy_mult = 0; + break; + +case 3: + xx_mult = 0; + xy_mult = -make_mult(point_size_y, res_hor); + break; + +default: + sinrot = sin((real)irot * PI / 180.); + cosrot = cos((real)irot * PI / 180.); + tanobl = tan((real)iobl * PI / 180.); + x_distortion = point_size_x / point_size_y; + pixperem_h = point_size_y * res_hor / (real)PTPERINCH; /* this is NOT a bug */ + xx_mult = floor(cosrot * x_distortion * pixperem_h * 65536.0 + 0.5); + xy_mult = floor((sinrot + cosrot * tanobl) * pixperem_h * 65536.0 + 0.5); + break; + } + +switch (y_trans_type) + { +case 0: + yx_mult = 0; + yy_mult = make_mult(point_size_y, res_ver); + break; + +case 1: + yx_mult = -make_mult(point_size_x, res_hor); + yy_mult = 0; + break; + +case 2: + yx_mult = 0; + yy_mult = -make_mult(point_size_y, res_ver); + break; + +case 3: + yx_mult = make_mult(point_size_x, res_ver); + yy_mult = 0; + break; + +default: + sinrot = sin((real)irot * PI / 180.); + cosrot = cos((real)irot * PI / 180.); + tanobl = tan((real)iobl * PI / 180.); + x_distortion = point_size_x / point_size_y; + pixperem_v = point_size_y * res_ver / (real)PTPERINCH; + yx_mult = floor(-sinrot * x_distortion * pixperem_v * 65536.0 + 0.5); + yy_mult = floor((cosrot - sinrot * tanobl) * pixperem_v * 65536.0 + 0.5); + break; + } + +specsarg.xxmult = xx_mult; +specsarg.xymult = xy_mult; +specsarg.xoffset = 0; +specsarg.yxmult = yx_mult; +specsarg.yymult = yy_mult; +specsarg.yoffset = 0; +specsarg.out_info = 0; + +/* Select processing mode */ +switch (pspecs->mode) + { +case 1: + if (pspecs->whitewrite) /* White-write requested? */ + { + mode = 1; + } + else + { + mode = 0; + } + break; + +case 2: + mode = 2; + break; + +default: + mode = pspecs->mode; + break; + } + +if (pspecs->bogus_mode) /* Linear transformation requested? */ + { + mode |= BIT4; /* Set linear tranformation flag */ + } + +if (pspecs->import_widths) /* Imported widths requested? */ + { + mode |= BIT6; /* Set imported width flag */ + } + +if (pspecs->clip.left) /* Clip left requested? */ + { + mode |= BIT8; /* Set clip left flag */ + } + +if (pspecs->clip.right) /* Clip right requested? */ + { + mode |= BIT9; /* Set clip right flag */ + } + +if (pspecs->clip.top) /* Clip top requested? */ + { + mode |= BIT10; /* Set clip top flag */ + } + +if (pspecs->clip.bottom) /* Clip bottom requested? */ + { + mode |= BIT11; /* Set clip bottom flag */ + } + +if (pspecs->squeeze.left) /* Squeeze left requested? */ + { + mode |= BIT12; /* Set squeeze left flag */ + } + +if (pspecs->squeeze.right) /* Squeeze right requested? */ + { + mode |= BIT13; /* Set squeeze right flag */ + } + +if (pspecs->squeeze.top) /* Squeeze top requested? */ + { + mode |= BIT14; /* Set squeeze top flag */ + } + +if (pspecs->squeeze.bottom) /* Squeeze bottom requested? */ + { + mode |= BIT15; /* Set squeeze bottom flag */ + } + +specsarg.flags = mode; + +sp_set_specs(&specsarg); +} + +FUNCTION static fix31 make_mult(point_size, resolution) +real point_size; +real resolution; +{ +real ms_factor; + +return (fix31)floor((point_size * resolution * 65536.0) / (real)PTPERINCH + 0.5); +} + +FUNCTION bool fw_make_char(char_index) +ufix16 char_index; +{ +return sp_make_char(char_index); +} + +FUNCTION buff_t *sp_load_char_data(file_offset, no_bytes, cb_offset) +fix31 file_offset; +fix15 no_bytes; +fix15 cb_offset; +/* + * Called by Speedo character generator to request that character + * data be loaded from the font file. + * This is a dummy function that assumes that the entire font has + * been loaded. + */ +{ +#if DEBUG +printf("load_char_data(%d, %d, %d)\n", file_offset, no_bytes, char_offset); +#endif +char_data.org = pfont->org + file_offset; +char_data.no_bytes = no_bytes; +return &char_data; +} + +FUNCTION void sp_report_error(n) +fix15 n; /* Error identification number */ +/* + * Called by Speedo character generator to report an error. + */ +{ +switch(n) + { +case 1: + printf("Insufficient font data loaded\n"); + break; + +case 3: + printf("Transformation matrix out of range\n"); + break; + +case 4: + printf("Font format error\n"); + break; + +case 5: + printf("Requested specs not compatible with output module\n"); + break; + +case 7: + printf("Intelligent transformation requested but not supported\n"); + break; + +case 8: + printf("Unsupported output mode requested\n"); + break; + +case 9: + printf("Extended font loaded but only compact fonts supported\n"); + break; + +case 10: + printf("Font specs not set prior to use of font\n"); + break; + +case 12: + printf("Character data not available()\n"); + break; + +case 13: + printf("Track kerning data not available()\n"); + break; + +case 14: + printf("Pair kerning data not available()\n"); + break; + +default: + printf("report_error(%d)\n", n); + break; + } +} + + + +FUNCTION void sp_open_bitmap(sw_x, sw_y, xorg, yorg, xsize, ysize) +fix31 sw_x; /* X component of escapement vector */ +fix31 sw_y; /* Y component of escapement vector */ +fix31 xorg; /* X origin */ +fix31 yorg; /* Y origin */ +fix15 xsize; /* width of bitmap */ +fix15 ysize; /* height of bitmap */ +/* + * Called by Speedo character generator to initialize a buffer prior + * to receiving bitmap data. + */ +{ + +fix15 xmin,xmax,ymin,ymax; + +#if DEBUG +printf("sp_open_bitmap:\n"); +printf(" X component of set width vector = %3.1f\n", (real)sw_x / 65536.0); +printf(" Y component of set width vector = %3.1f\n", (real)sw_y / 65536.0); +printf(" Bounding box is (%d, %d, %d, %d)\n", xmin, ymin, xmax, ymax); +#endif + +xmin = xorg >> 16; +ymin = yorg >> 16; +xmax = xmin + xsize; +ymax = ymin + ysize; + +set_width_x = ((sw_x >> 15) + 1) >> 1; +open_bitmap(set_width_x, xmin, xmax, ymin, ymax); +} + +FUNCTION void sp_set_bitmap_bits(y, x1, x2) +fix15 y, x1, x2; +/* + * Called by Speedo character generator to write one row of pixels + * into the generated bitmap character. + */ +{ +#if DEBUG +printf("set_bitmap_bits(%d, %d, %d)\n", y, x1, x2); +#endif + +set_bitmap_bits(y, x1, x2); +} + +FUNCTION void sp_close_bitmap() +/* + * Called by Speedo character generator to indicate all bitmap data + * has been generated. + */ +{ +#if DEBUG +printf("close_bitmap()\n"); +#endif + +close_bitmap(); +} + +FUNCTION void sp_open_outline(sw_x, sw_y, xmin, xmax, ymin, ymax) +fix31 sw_x; /* X component of escapement vector */ +fix31 sw_y; /* Y component of escapement vector */ +fix31 xmin; /* Minimum X value in outline */ +fix31 xmax; /* Maximum X value in outline */ +fix31 ymin; /* Minimum Y value in outline */ +fix31 ymax; /* Maximum Y value in outline */ +/* + * Called by Speedo character generator to initialize prior to + * outputting scaled outline data. + */ +{ +#if DEBUG +printf("open_outline(%3.1f, %3.1f, %3.1f, %3.1f, %3.1f, %3.1f)\n", + (real)sw_x / 65536.0, (real)sw_y / 65536.0, + (real)xmin / 65536.0, (real)xmax / 65536.0, (real)ymin / 65536.0, (real)ymax / 65536.0); +#endif + +set_width_x = ((sw_x >> 15) + 1) >> 1; +open_outline(set_width_x); +} + +FUNCTION void sp_start_new_char() +/* + * Called by Speedo character generator to initialize prior to + * outputting scaled outline data for a sub-character in a compound + * character. + */ +{ +#if DEBUG +printf("start_new_char()\n"); +#endif + +start_new_char(); +} + +FUNCTION void sp_start_contour(x, y, outside) +fix31 x; /* X coordinate of start point in 1/65536 pixels */ +fix31 y; /* Y coordinate of start point in 1/65536 pixels */ +boolean outside; /* TRUE if curve encloses ink (Counter-clockwise) */ +/* + * Called by Speedo character generator at the start of each contour + * in the outline data of the character. + */ +{ +real realx, realy; + +realx = (real)x / 65536.0; +realy = (real)y / 65536.0; + +#if DEBUG +printf("start_curve(%3.1f, %3.1f, %s)\n", + realx, realy, + outside? "outside": "inside"); +#endif + +start_curve(realx, realy, outside); +} + +FUNCTION void sp_curve_to(x1, y1, x2, y2, x3, y3) +fix31 x1; /* X coordinate of first control point in 1/65536 pixels */ +fix31 y1; /* Y coordinate of first control point in 1/65536 pixels */ +fix31 x2; /* X coordinate of second control point in 1/65536 pixels */ +fix31 y2; /* Y coordinate of second control point in 1/65536 pixels */ +fix31 x3; /* X coordinate of curve end point in 1/65536 pixels */ +fix31 y3; /* Y coordinate of curve end point in 1/65536 pixels */ +/* + * Called by Speedo character generator once for each curve in the + * scaled outline data of the character. This function is only called if curve + * output is enabled in the set_specs() call. + */ +{ +#if DEBUG +printf("curve_to(%3.1f, %3.1f, %3.1f, %3.1f, %3.1f, %3.1f)\n", + (real)x1 / 65536.0, (real)y1 / 65536.0, + (real)x2 / 65536.0, (real)y2 / 65536.0, + (real)x3 / 65536.0, (real)y3 / 65536.0); +#endif +} + +FUNCTION void sp_line_to(x, y) +fix31 x; /* X coordinate of vector end point in 1/65536 pixels */ +fix31 y; /* Y coordinate of vector end point in 1/65536 pixels */ +/* + * Called by Speedo character generator onece for each vector in the + * scaled outline data for the character. This include curve data that has + * been sub-divided into vectors if curve output has not been enabled + * in the set_specs() call. + */ +{ +real realx, realy; + +realx = (real)x / 65536.0; +realy = (real)y / 65536.0; + +#if DEBUG +printf("line_to(%3.1f, %3.1f)\n", + realx, realy); +#endif + +line_to(realx, realy); +} + +FUNCTION void sp_close_contour() +/* + * Called by Speedo character generator at the end of each contour + * in the outline data of the character. + */ +{ +#if DEBUG +printf("close_curve()\n"); +#endif + +close_curve(); +} + +FUNCTION void sp_close_outline() +/* + * Called by Speedo character generator at the end of output of the + * scaled outline of the character. + */ +{ +#if DEBUG +printf("close_outline()\n"); +#endif + +close_outline(set_width_x); +} + diff --git a/nx-X11/lib/font/Speedo/keys.h b/nx-X11/lib/font/Speedo/keys.h new file mode 100644 index 000000000..dd9d0bff7 --- /dev/null +++ b/nx-X11/lib/font/Speedo/keys.h @@ -0,0 +1,56 @@ +/* $Xorg: keys.h,v 1.3 2000/08/17 19:46:25 cpqbld Exp $ */ + +/* + +Copyright 1989-1991, Bitstream Inc., Cambridge, MA. +You are hereby granted permission under all Bitstream propriety rights to +use, copy, modify, sublicense, sell, and redistribute the Bitstream Speedo +software and the Bitstream Charter outline font for any purpose and without +restrictions; provided, that this notice is left intact on all copies of such +software or font and that Bitstream's trademark is acknowledged as shown below +on all unmodified copies of such font. + +BITSTREAM CHARTER is a registered trademark of Bitstream Inc. + + +BITSTREAM INC. DISCLAIMS ANY AND ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING +WITHOUT LIMITATION THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE. BITSTREAM SHALL NOT BE LIABLE FOR ANY DIRECT OR INDIRECT +DAMAGES, INCLUDING BUT NOT LIMITED TO LOST PROFITS, LOST DATA, OR ANY OTHER +INCIDENTAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF OR IN ANY WAY CONNECTED +WITH THE SPEEDO SOFTWARE OR THE BITSTREAM CHARTER OUTLINE FONT. + +*/ + + +/***** DECRYPTION KEY CONSTANTS (PC Platform) *****/ + +#define CUS0 432 /* Customer number */ + +#define KEY0 0 /* Decryption key 0 */ +#define KEY1 72 /* Decryption key 1 */ +#define KEY2 123 /* Decryption key 2 */ +#define KEY3 1 /* Decryption key 3 */ +#define KEY4 222 /* Decryption key 4 */ +#define KEY5 194 /* Decryption key 5 */ +#define KEY6 113 /* Decryption key 6 */ +#define KEY7 119 /* Decryption key 7 */ +#define KEY8 52 /* Decryption key 8 */ + +/***** DECRYPTION KEY CONSTANTS (Sample) *****/ + +#define XSAMPLEFONTS + +#define XCUS0 0 /* Customer number */ + +#define XKEY0 0 /* Decryption key 0 */ +#define XKEY1 0 /* Decryption key 1 */ +#define XKEY2 0 /* Decryption key 2 */ +#define XKEY3 0 /* Decryption key 3 */ +#define XKEY4 0 /* Decryption key 4 */ +#define XKEY5 0 /* Decryption key 5 */ +#define XKEY6 0 /* Decryption key 6 */ +#define XKEY7 0 /* Decryption key 7 */ +#define XKEY8 0 /* Decryption key 8 */ + + diff --git a/nx-X11/lib/font/Speedo/module/Imakefile b/nx-X11/lib/font/Speedo/module/Imakefile new file mode 100644 index 000000000..e517707c5 --- /dev/null +++ b/nx-X11/lib/font/Speedo/module/Imakefile @@ -0,0 +1,47 @@ +XCOMM $XFree86: xc/lib/font/Speedo/module/Imakefile,v 1.5 1999/08/14 10:49:18 dawes Exp $ + +#define IHaveModules +#include <Server.tmpl> + + INCLUDES = -I$(FONTINCSRC) -I../../include -I$(SERVERSRC)/include \ + -I$(XINCLUDESRC) -I../ + HEADERS = + DEFINES = -DFONTMODULE + + SPEEDOSRCS = do_char.c do_trns.c out_bl2d.c out_blk.c speedomod.c \ + out_scrn.c out_util.c reset.c set_spcs.c set_trns.c + SPEEDOOBJS = do_char.o do_trns.o out_bl2d.o out_blk.o speedomod.o \ + out_scrn.o out_util.o reset.o set_spcs.o set_trns.o + + SRCS = spfuncs.c spfile.c spinfo.c sperr.c spfont.c spglyph.c \ + spencode.c bics-unicode.c \ + $(SPEEDOSRCS) + OBJS = spfuncs.o spfile.o spinfo.o sperr.o spfont.o spglyph.o \ + spencode.o bics-unicode.o \ + $(SPEEDOOBJS) + +LinkSourceFile(bics-unicode.c,..) +LinkSourceFile(do_char.c,..) +LinkSourceFile(do_trns.c,..) +LinkSourceFile(out_bl2d.c,..) +LinkSourceFile(out_blk.c,..) +LinkSourceFile(out_scrn.c,..) +LinkSourceFile(out_util.c,..) +LinkSourceFile(reset.c,..) +LinkSourceFile(set_spcs.c,..) +LinkSourceFile(set_trns.c,..) +LinkSourceFile(spfuncs.c,..) +LinkSourceFile(spfile.c,..) +LinkSourceFile(spinfo.c,..) +LinkSourceFile(sperr.c,..) +LinkSourceFile(spfont.c,..) +LinkSourceFile(spglyph.c,..) +LinkSourceFile(spencode.c,..) + +ModuleObjectRule() +LibraryModuleTarget(speedo,$(OBJS)) +InstallLibraryModule(speedo,$(MODULEDIR),fonts) + +DependTarget() + +InstallDriverSDKLibraryModule(speedo,$(DRIVERSDKMODULEDIR),fonts) diff --git a/nx-X11/lib/font/Speedo/module/speedomod.c b/nx-X11/lib/font/Speedo/module/speedomod.c new file mode 100644 index 000000000..94820fe44 --- /dev/null +++ b/nx-X11/lib/font/Speedo/module/speedomod.c @@ -0,0 +1,72 @@ +/* + * Copyright (C) 1998 The XFree86 Project, Inc. All Rights Reserved. + * + * 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 + * XFREE86 PROJECT 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. + * + * Except as contained in this notice, the name of the XFree86 Project shall + * not be used in advertising or otherwise to promote the sale, use or other + * dealings in this Software without prior written authorization from the + * XFree86 Project. + */ +/* $XFree86: xc/lib/font/Speedo/module/speedomod.c,v 1.8 2001/09/04 13:49:16 dawes Exp $ */ + +#include "misc.h" + +#include <X11/fonts/fontmod.h> +#include "xf86Module.h" + +static MODULESETUPPROTO(speedoSetup); + + /* + * This is the module data function that is accessed when loading + * libspeedo as a module. + */ + +static XF86ModuleVersionInfo VersRec = +{ + "speedo", + MODULEVENDORSTRING, + MODINFOSTRING1, + MODINFOSTRING2, + XORG_VERSION_CURRENT, + 1, 0, 1, + ABI_CLASS_FONT, /* A font module */ + ABI_FONT_VERSION, + MOD_CLASS_FONT, + {0,0,0,0} /* signature, to be patched into the file by a tool */ +}; + +XF86ModuleData speedoModuleData = { &VersRec, speedoSetup, NULL }; + +extern void SpeedoRegisterFontFileFunctions(void); + +FontModule speedoModule = { + SpeedoRegisterFontFileFunctions, + "Speedo", + NULL +}; + +static pointer +speedoSetup(pointer module, pointer opts, int *errmaj, int *errmin) +{ + speedoModule.module = module; + LoadFont(&speedoModule); + + /* Need a non-NULL return */ + return (pointer)1; +} diff --git a/nx-X11/lib/font/Speedo/nsample.c b/nx-X11/lib/font/Speedo/nsample.c new file mode 100644 index 000000000..a90367f0a --- /dev/null +++ b/nx-X11/lib/font/Speedo/nsample.c @@ -0,0 +1,745 @@ +/* $Xorg: nsample.c,v 1.3 2000/08/17 19:46:26 cpqbld Exp $ */ + +/* + +Copyright 1989-1991, Bitstream Inc., Cambridge, MA. +You are hereby granted permission under all Bitstream propriety rights to +use, copy, modify, sublicense, sell, and redistribute the Bitstream Speedo +software and the Bitstream Charter outline font for any purpose and without +restrictions; provided, that this notice is left intact on all copies of such +software or font and that Bitstream's trademark is acknowledged as shown below +on all unmodified copies of such font. + +BITSTREAM CHARTER is a registered trademark of Bitstream Inc. + + +BITSTREAM INC. DISCLAIMS ANY AND ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING +WITHOUT LIMITATION THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE. BITSTREAM SHALL NOT BE LIABLE FOR ANY DIRECT OR INDIRECT +DAMAGES, INCLUDING BUT NOT LIMITED TO LOST PROFITS, LOST DATA, OR ANY OTHER +INCIDENTAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF OR IN ANY WAY CONNECTED +WITH THE SPEEDO SOFTWARE OR THE BITSTREAM CHARTER OUTLINE FONT. + +*/ + + +/*************************** N S A M P L E . C ******************************* + * * + * SPEEDO CHARACTER GENERATOR TEST MODULE * + * * + * This is an illustration of what external resources are required to * + * load a Speedo outline and use the Speedo character generator to generate * + * bitmaps or scaled outlines according to the desired specification. * * + * * + * This program loads a Speedo outline, defines a set of character * + * generation specifications, generates bitmap (or outline) data for each * + * character in the font and prints them on the standard output. * + * * + * If the font buffer is too small to hold the entire font, the first * + * part of the font is loaded. Character data is then loaded dynamically * + * as required. * + * * + ****************************************************************************/ + +#include <stdio.h> +#if PROTOS_AVAIL +#include <stddef.h> +#include <malloc.h> +#include <stdlib.h> +void main(int argc,char *argv[]); +#else +void* malloc(); +#endif + +#include "speedo.h" /* General definition for make_bmap */ +#include "keys.h" /* Font decryption keys */ + +#define DEBUG 0 + +#if DEBUG +#define SHOW(X) printf("X = %d\n", X) +#else +#define SHOW(X) +#endif + +#define MAX_BITS 256 /* Max line length of generated bitmap */ + +/***** GLOBAL FUNCTIONS *****/ + +/***** EXTERNAL FUNCTIONS *****/ + +/***** STATIC FUNCTIONS *****/ + +#if PROTOS_AVAIL +fix31 read_4b(ufix8 FONTFAR *ptr); +fix15 read_2b(ufix8 FONTFAR *ptr); +#else +fix31 read_4b(); +fix15 read_2b(); +#endif +/***** STATIC VARIABLES *****/ +static char pathname[100]; /* Name of font file to be output */ +static ufix8 FONTFAR *font_buffer; /* Pointer to allocated Font buffer */ +static ufix8 FONTFAR *char_buffer; /* Pointer to allocate Character buffer */ +static buff_t font; /* Buffer descriptor for font data */ +#if INCL_LCD +static buff_t char_data; /* Buffer descriptor for character data */ +#endif +static FILE *fdescr; /* Speedo outline file descriptor */ +static ufix16 char_index; /* Index of character to be generated */ +static ufix16 char_id; /* Character ID */ +static ufix16 minchrsz; /* minimum character buffer size */ + +static ufix8 key[] = + { + KEY0, + KEY1, + KEY2, + KEY3, + KEY4, + KEY5, + KEY6, + KEY7, + KEY8 + }; /* Font decryption key */ + +static fix15 raswid; /* raster width */ +static fix15 rashgt; /* raster height */ +static fix15 offhor; /* horizontal offset from left edge of emsquare */ +static fix15 offver; /* vertical offset from baseline */ +static fix15 set_width; /* character set width */ +static fix15 y_cur; /* Current y value being generated and printed */ +static char line_of_bits[2 * MAX_BITS + 1]; /* Buffer for row of generated bits */ + +#if INCL_MULTIDEV +#if INCL_BLACK || INCL_SCREEN || INCL_2D +bitmap_t bfuncs = { sp_open_bitmap, sp_set_bitmap_bits, sp_close_bitmap }; +#endif +#if INCL_OUTLINE +outline_t ofuncs = { sp_open_outline, sp_start_new_char, sp_start_contour, sp_curve_to, + sp_line_to, sp_close_contour, sp_close_outline }; +#endif +#endif + + +ufix8 temp[16]; /* temp buffer for first 16 bytes of font */ + + +FUNCTION void main(argc,argv) +int argc; +char *argv[]; +{ +ufix16 bytes_read; /* Number of bytes read from font file */ +specs_t specs; /* Bundle of character generation specs */ +int first_char_index; /* Index of first character in font */ +int no_layout_chars; /* number of characters in layout */ +ufix32 i; +ufix32 minbufsz; /* minimum font buffer size to allocate */ +ufix16 cust_no; +ufix8 FONTFAR *byte_ptr; + +#if REENTRANT_ALLOC +SPEEDO_GLOBALS* sp_global_ptr; +#endif + + +if (argc != 2) + { + fprintf(stderr,"Usage: nsample {fontfile}\n\n"); + exit (1); + } + +sprintf(pathname, argv[1]); + +/* Load Speedo outline file */ +fdescr = fopen (pathname, "rb"); +if (fdescr == NULL) + { + printf("****** Cannot open file %s\n", pathname); + return; + } + +/* get minimum font buffer size - read first 16 bytes to get the minimum + size field from the header, then allocate buffer dynamically */ + +bytes_read = fread(temp, sizeof(ufix8), 16, fdescr); + +if (bytes_read != 16) + { + printf("****** Error on reading %s: %x\n", pathname, bytes_read); + fclose(fdescr); + return; + } +#if INCL_LCD +minbufsz = (ufix32)read_4b(temp+FH_FBFSZ); +#else +minbufsz = (ufix32)read_4b(temp+FH_FNTSZ); +if (minbufsz >= 0x10000) + { + printf("****** Cannot process fonts greater than 64K - use dynamic character loading configuration option\n"); + fclose(fdescr); + return; + } +#endif + +#if (defined(M_I86SM) || defined(M_I86MM)) +font_buffer = (ufix8 FONTFAR *)_fmalloc((ufix16)minbufsz); +#else +font_buffer = (ufix8 *)malloc((ufix16)minbufsz); +#endif + +if (font_buffer == NULL) + { + printf("****** Unable to allocate memory for font buffer\n"); + fclose(fdescr); + return; + } + +#if DEBUG +printf("Loading font file %s\n", pathname); +#endif + +fseek(fdescr, (ufix32)0, 0); +#if (defined(M_I86SM) || (defined(M_I86MM))) +byte_ptr = font_buffer; +for (i=0; i< minbufsz; i++){ + int ch; + ch = getc(fdescr); + if (ch == EOF) + {printf ("Premature EOF in reading font buffer, %ld bytes read\n",i); + exit(2);} + *byte_ptr=(ufix8)ch; + byte_ptr++; + } +bytes_read = i; +#else +bytes_read = fread((ufix8 *)font_buffer, sizeof(ufix8), (ufix16)minbufsz, fdescr); +if (bytes_read == 0) + { + printf("****** Error on reading %s: %x\n", pathname, bytes_read); + fclose(fdescr); + return; + } +#endif + +#if INCL_LCD +/* now allocate minimum character buffer */ + +minchrsz = read_2b(font_buffer+FH_CBFSZ); +#if (defined(M_I86SM) || (defined(M_I86MM))) +char_buffer = (ufix8 FONTFAR *)_fmalloc(minchrsz); +#else +char_buffer = (ufix8*)malloc(minchrsz); +#endif + +if (char_buffer == NULL) + { + printf("****** Unable to allocate memory for character buffer\n"); + fclose(fdescr); + return; + } +#endif + +#if DYNAMIC_ALLOC || REENTRANT_ALLOC + sp_global_ptr = (SPEEDO_GLOBALS *)malloc(sizeof(SPEEDO_GLOBALS)); + memset(sp_global_ptr,(ufix8)0,sizeof(SPEEDO_GLOBALS)); +#endif + + +/* Initialization */ +#if REENTRANT_ALLOC +sp_reset(sp_global_ptr); /* Reset Speedo character generator */ +#else +sp_reset(); /* Reset Speedo character generator */ +#endif + +font.org = font_buffer; +font.no_bytes = bytes_read; + +#if REENTRANT_ALLOC +if ((cust_no=sp_get_cust_no(sp_global_ptr,font)) != CUS0 && /* NOT STANDARD ENCRYPTION */ +#else +if ((cust_no=sp_get_cust_no(font)) != CUS0 && /* NOT STANDARD ENCRYPTION */ +#endif + cust_no != 0) + { +#if REENTRANT_ALLOC + printf("Unable to use fonts for customer number %d\n", + sp_get_cust_no(sp_global_ptr(font))); +#else + printf("Unable to use fonts for customer number %d\n", + sp_get_cust_no(font)); +#endif + fclose(fdescr); + return; + } + +#if INCL_KEYS +#if REENTRANT_ALLOC +sp_set_key(sp_global_ptr,key); /* Set decryption key */ +#else +sp_set_key(key); /* Set decryption key */ +#endif +#endif + +#if INCL_MULTIDEV +#if INCL_BLACK || INCL_SCREEN || INCL_2D +#if REENTRANT_ALLOC +sp_set_bitmap_device(sp_global_ptr,&bfuncs,sizeof(bfuncs)); /* Set decryption key */ +#else +sp_set_bitmap_device(&bfuncs,sizeof(bfuncs)); /* Set decryption key */ +#endif +#endif +#if INCL_OUTLINE +#if REENTRANT_ALLOC +sp_set_outline_device(sp_global_ptr,&ofuncs,sizeof(ofuncs)); /* Set decryption key */ +#else +sp_set_outline_device(&ofuncs,sizeof(ofuncs)); /* Set decryption key */ +#endif +#endif +#endif + +first_char_index = read_2b(font_buffer + FH_FCHRF); +no_layout_chars = read_2b(font_buffer + FH_NCHRL); + +/* Set specifications for character to be generated */ +specs.pfont = &font; /* Pointer to Speedo outline structure */ +specs.xxmult = 25L << 16; /* Coeff of X to calculate X pixels */ +specs.xymult = 0L << 16; /* Coeff of Y to calculate X pixels */ +specs.xoffset = 0L << 16; /* Position of X origin */ +specs.yxmult = 0L << 16; /* Coeff of X to calculate Y pixels */ +specs.yymult = 25L << 16; /* Coeff of Y to calculate Y pixels */ +specs.yoffset = 0L << 16; /* Position of Y origin */ +specs.flags = 0; /* Mode flags */ +specs.out_info = NULL; + + +#if REENTRANT_ALLOC +if (!sp_set_specs(sp_global_ptr,&specs)) /* Set character generation specifications */ +#else +if (!sp_set_specs(&specs)) /* Set character generation specifications */ +#endif + { + printf("****** Cannot set requested specs\n"); + } +else + { + for (i = 0; i < no_layout_chars; i++) /* For each character in font */ + { + char_index = i + first_char_index; +#if REENTRANT_ALLOC + char_id = sp_get_char_id(sp_global_ptr,char_index); +#else + char_id = sp_get_char_id(char_index); +#endif + if (char_id != 0) + { +#if REENTRANT_ALLOC + if (!sp_make_char(sp_global_ptr,char_index)) +#else + if (!sp_make_char(char_index)) +#endif + { + printf("****** Cannot generate character %d\n", char_index); + } + } + } + } + +fclose(fdescr); +} + +#if INCL_LCD +#if REENTRANT_ALLOC +FUNCTION buff_t *sp_load_char_data(sp_global_ptr, file_offset, no_bytes, cb_offset) +SPEEDO_GLOBALS *sp_global_ptr; +#else +FUNCTION buff_t *sp_load_char_data(file_offset, no_bytes, cb_offset) +#endif +fix31 file_offset; /* Offset in bytes from the start of the font file */ +fix15 no_bytes; /* Number of bytes to be loaded */ +fix15 cb_offset; /* Offset in bytes from start of char buffer */ +/* + * Called by Speedo character generator to request that character + * data be loaded from the font file into a character data buffer. + * The character buffer offset is zero for all characters except elements + * of compound characters. If a single buffer is allocated for character + * data, cb_offset ensures that sub-character data is loaded after the + * top-level compound character. + * Returns a pointer to a buffer descriptor. + */ +{ +int bytes_read; + +#if DEBUG +printf("\nCharacter data(%d, %d, %d) requested\n", file_offset, no_bytes, cb_offset); +#endif +if (fseek(fdescr, (long)file_offset, (int)0) != 0) + { + printf("****** Error in seeking character\n"); + fclose(fdescr); + exit(1); + } + +if ((no_bytes + cb_offset) > minchrsz) + { + printf("****** Character buffer overflow\n"); + fclose(fdescr); + exit(3); + } + +bytes_read = fread((char_buffer + cb_offset), sizeof(ufix8), no_bytes, fdescr); +if (bytes_read != no_bytes) + { + printf("****** Error on reading character data\n"); + fclose(fdescr); + exit(2); + } + +#if DEBUG +printf("Character data loaded\n"); +#endif + +char_data.org = (ufix8 FONTFAR *)char_buffer + cb_offset; +char_data.no_bytes = no_bytes; +return &char_data; +} +#endif + + +#if REENTRANT_ALLOC +FUNCTION void sp_report_error(sp_global_ptr,n) +SPEEDO_GLOBALS *sp_global_ptr; +#else +FUNCTION void sp_report_error(n) +#endif +fix15 n; /* Error identification number */ +/* + * Called by Speedo character generator to report an error. + * + * Since character data not available is one of those errors + * that happens many times, don't report it to user + */ +{ + +switch(n) + { +case 1: + printf("Insufficient font data loaded\n"); + break; + +case 3: + printf("Transformation matrix out of range\n"); + break; + +case 4: + printf("Font format error\n"); + break; + +case 5: + printf("Requested specs not compatible with output module\n"); + break; + +case 7: + printf("Intelligent transformation requested but not supported\n"); + break; + +case 8: + printf("Unsupported output mode requested\n"); + break; + +case 9: + printf("Extended font loaded but only compact fonts supported\n"); + break; + +case 10: + printf("Font specs not set prior to use of font\n"); + break; + +case 12: + break; + +case 13: + printf("Track kerning data not available()\n"); + break; + +case 14: + printf("Pair kerning data not available()\n"); + break; + +default: + printf("report_error(%d)\n", n); + break; + } +} + +#if REENTRANT_ALLOC +FUNCTION void sp_open_bitmap(sp_global_ptr, x_set_width, y_set_width, xorg, yorg, xsize, ysize) +SPEEDO_GLOBALS *sp_global_ptr; +#else +FUNCTION void sp_open_bitmap(x_set_width, y_set_width, xorg, yorg, xsize, ysize) +#endif +fix31 x_set_width; +fix31 y_set_width; /* Set width vector */ +fix31 xorg; /* Pixel boundary at left extent of bitmap character */ +fix31 yorg; /* Pixel boundary at right extent of bitmap character */ +fix15 xsize; /* Pixel boundary of bottom extent of bitmap character */ +fix15 ysize; /* Pixel boundary of top extent of bitmap character */ +/* + * Called by Speedo character generator to initialize a buffer prior + * to receiving bitmap data. + */ +{ +fix15 i; + +#if DEBUG +printf("open_bitmap(%3.1f, %3.1f, %3.1f, %3.1f, %d, %d)\n", + (real)x_set_width / 65536.0, (real)y_set_width / 65536.0, + (real)xorg / 65536.0, (real)yorg / 65536.0, (int)xsize, (int)ysize); +#endif +raswid = xsize; +rashgt = ysize; +offhor = (fix15)(xorg >> 16); +offver = (fix15)(yorg >> 16); + +if (raswid > MAX_BITS) + raswid = MAX_BITS; + +printf("\nCharacter index = %d, ID = %d\n", char_index, char_id); +printf("set width = %3.1f, %3.1f\n", (real)x_set_width / 65536.0, (real)y_set_width / 65536.0); +printf("X offset = %d\n", offhor); +printf("Y offset = %d\n\n", offver); +for (i = 0; i < raswid; i++) + { + line_of_bits[i << 1] = '.'; + line_of_bits[(i << 1) + 1] = ' '; + } +line_of_bits[raswid << 1] = '\0'; +y_cur = 0; +} + +#if REENTRANT_ALLOC +FUNCTION void sp_set_bitmap_bits (sp_global_ptr, y, xbit1, xbit2) +SPEEDO_GLOBALS *sp_global_ptr; +#else +FUNCTION void sp_set_bitmap_bits (y, xbit1, xbit2) +#endif + fix15 y; /* Scan line (0 = first row above baseline) */ + fix15 xbit1; /* Pixel boundary where run starts */ + fix15 xbit2; /* Pixel boundary where run ends */ + +/* + * Called by Speedo character generator to write one row of pixels + * into the generated bitmap character. + */ + +{ +fix15 i; + +#if DEBUG +printf("set_bitmap_bits(%d, %d, %d)\n", (int)y, (int)xbit1, (int)xbit2); +#endif +/* Clip runs beyond end of buffer */ +if (xbit1 > MAX_BITS) + xbit1 = MAX_BITS; + +if (xbit2 > MAX_BITS) + xbit2 = MAX_BITS; + +/* Output backlog lines if any */ +while (y_cur != y) + { + printf(" %s\n", line_of_bits); + for (i = 0; i < raswid; i++) + { + line_of_bits[i << 1] = '.'; + } + y_cur++; + } + +/* Add bits to current line */ +for (i = xbit1; i < xbit2; i++) + { + line_of_bits[i << 1] = 'X'; + } +} + +#if REENTRANT_ALLOC +FUNCTION void sp_close_bitmap(sp_global_ptr) +SPEEDO_GLOBALS *sp_global_ptr; +#else +FUNCTION void sp_close_bitmap() +#endif +/* + * Called by Speedo character generator to indicate all bitmap data + * has been generated. + */ +{ +#if DEBUG +printf("close_bitmap()\n"); +#endif +printf(" %s\n", line_of_bits); +} + +#if INCL_OUTLINE +#if REENTRANT_ALLOC +FUNCTION void sp_open_outline(sp_global_ptr, x_set_width, y_set_width, xmin, xmax, ymin, ymax) +SPEEDO_GLOBALS *sp_global_ptr; +#else +FUNCTION void sp_open_outline(x_set_width, y_set_width, xmin, xmax, ymin, ymax) +#endif +fix31 x_set_width; +fix31 y_set_width; /* Transformed escapement vector */ +fix31 xmin; /* Minimum X value in outline */ +fix31 xmax; /* Maximum X value in outline */ +fix31 ymin; /* Minimum Y value in outline */ +fix31 ymax; /* Maximum Y value in outline */ +/* + * Called by Speedo character generator to initialize prior to + * outputting scaled outline data. + */ +{ +printf("\nopen_outline(%3.1f, %3.1f, %3.1f, %3.1f, %3.1f, %3.1f)\n", + (real)x_set_width / 65536.0, (real)y_set_width / 65536.0, + (real)xmin / 65536.0, (real)xmax / 65536.0, (real)ymin / 65536.0, (real)ymax / 65536.0); +} + + +#if REENTRANT_ALLOC +FUNCTION void sp_start_new_char(sp_global_ptr) +SPEEDO_GLOBALS *sp_global_ptr; +#else +FUNCTION void sp_start_new_char() +#endif +/* + * Called by Speedo character generator to initialize prior to + * outputting scaled outline data for a sub-character in a compound + * character. + */ +{ +printf("start_new_char()\n"); +} + +#if REENTRANT_ALLOC +FUNCTION void sp_start_contour(sp_global_ptr, x, y, outside) +SPEEDO_GLOBALS *sp_global_ptr; +#else +FUNCTION void sp_start_contour(x, y, outside) +#endif +fix31 x; /* X coordinate of start point in 1/65536 pixels */ +fix31 y; /* Y coordinate of start point in 1/65536 pixels */ +boolean outside; /* TRUE if curve encloses ink (Counter-clockwise) */ +/* + * Called by Speedo character generator at the start of each contour + * in the outline data of the character. + */ +{ +printf("start_contour(%3.1f, %3.1f, %s)\n", + (real)x / 65536.0, (real)y / 65536.0, + outside? "outside": "inside"); +} + +#if REENTRANT_ALLOC +FUNCTION void sp_curve_to(sp_global_ptr, x1, y1, x2, y2, x3, y3) +SPEEDO_GLOBALS *sp_global_ptr; +#else +FUNCTION void sp_curve_to(x1, y1, x2, y2, x3, y3) +#endif +fix31 x1; /* X coordinate of first control point in 1/65536 pixels */ +fix31 y1; /* Y coordinate of first control point in 1/65536 pixels */ +fix31 x2; /* X coordinate of second control point in 1/65536 pixels */ +fix31 y2; /* Y coordinate of second control point in 1/65536 pixels */ +fix31 x3; /* X coordinate of curve end point in 1/65536 pixels */ +fix31 y3; /* Y coordinate of curve end point in 1/65536 pixels */ +/* + * Called by Speedo character generator onece for each curve in the + * scaled outline data of the character. This function is only called if curve + * output is enabled in the set_specs() call. + */ +{ +printf("curve_to(%3.1f, %3.1f, %3.1f, %3.1f, %3.1f, %3.1f)\n", + (real)x1 / 65536.0, (real)y1 / 65536.0, + (real)x2 / 65536.0, (real)y2 / 65536.0, + (real)x3 / 65536.0, (real)y3 / 65536.0); +} + +#if REENTRANT_ALLOC +FUNCTION void sp_line_to(sp_global_ptr, x, y) +SPEEDO_GLOBALS *sp_global_ptr; +#else +FUNCTION void sp_line_to(x, y) +#endif +fix31 x; /* X coordinate of vector end point in 1/65536 pixels */ +fix31 y; /* Y coordinate of vector end point in 1/65536 pixels */ +/* + * Called by Speedo character generator onece for each vector in the + * scaled outline data for the character. This include curve data that has + * been sub-divided into vectors if curve output has not been enabled + * in the set_specs() call. + */ +{ +printf("line_to(%3.1f, %3.1f)\n", + (real)x / 65536.0, (real)y / 65536.0); +} + + +#if REENTRANT_ALLOC +FUNCTION void sp_close_contour(sp_global_ptr) +SPEEDO_GLOBALS *sp_global_ptr; +#else +FUNCTION void sp_close_contour() +#endif +/* + * Called by Speedo character generator at the end of each contour + * in the outline data of the character. + */ +{ +printf("close_contour()\n"); +} + +#if REENTRANT_ALLOC +FUNCTION void sp_close_outline(sp_global_ptr) +SPEEDO_GLOBALS *sp_global_ptr; +#else +FUNCTION void sp_close_outline() +#endif +/* + * Called by Speedo character generator at the end of output of the + * scaled outline of the character. + */ +{ +printf("close_outline()\n"); +} + +#endif + +FUNCTION fix15 read_2b(pointer) +ufix8 FONTFAR *pointer; +/* + * Reads 2-byte field from font buffer + */ +{ +fix15 temp; + +temp = *pointer++; +temp = (temp << 8) + *(pointer); +return temp; +} + + + FUNCTION fix31 read_4b(pointer) +ufix8 FONTFAR *pointer; +/* + * Reads 4-byte field from font buffer + */ +{ +fix31 temp; + +temp = *pointer++; +temp = (temp << 8) + *(pointer++); +temp = (temp << 8) + *(pointer++); +temp = (temp << 8) + *(pointer); +return temp; +} + + diff --git a/nx-X11/lib/font/Speedo/out_bl2d.c b/nx-X11/lib/font/Speedo/out_bl2d.c new file mode 100644 index 000000000..6c38cb30d --- /dev/null +++ b/nx-X11/lib/font/Speedo/out_bl2d.c @@ -0,0 +1,772 @@ +/* $Xorg: out_bl2d.c,v 1.3 2000/08/17 19:46:26 cpqbld Exp $ */ + +/* + +Copyright 1989-1991, Bitstream Inc., Cambridge, MA. +You are hereby granted permission under all Bitstream propriety rights to +use, copy, modify, sublicense, sell, and redistribute the Bitstream Speedo +software and the Bitstream Charter outline font for any purpose and without +restrictions; provided, that this notice is left intact on all copies of such +software or font and that Bitstream's trademark is acknowledged as shown below +on all unmodified copies of such font. + +BITSTREAM CHARTER is a registered trademark of Bitstream Inc. + + +BITSTREAM INC. DISCLAIMS ANY AND ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING +WITHOUT LIMITATION THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE. BITSTREAM SHALL NOT BE LIABLE FOR ANY DIRECT OR INDIRECT +DAMAGES, INCLUDING BUT NOT LIMITED TO LOST PROFITS, LOST DATA, OR ANY OTHER +INCIDENTAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF OR IN ANY WAY CONNECTED +WITH THE SPEEDO SOFTWARE OR THE BITSTREAM CHARTER OUTLINE FONT. + +*/ +/* $XFree86: xc/lib/font/Speedo/out_bl2d.c,v 1.3 1999/02/07 11:47:14 dawes Exp $ */ + +/*************************** O U T _ B L 2 D . C ***************************** + * * + * This is an output module for screen writer using two dimensional scanning * + ****************************************************************************/ + + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include "spdo_prv.h" /* General definitions for speedo */ + +#define CLOCKWISE 1 +#define DEBUG 0 +#define ABS(X) ( (X < 0) ? -X : X) + +#if DEBUG +#include <stdio.h> +#define SHOW(X) printf("X = %d\n", X) +#else +#define SHOW(X) +#endif + +/***** GLOBAL VARIABLES *****/ + +/***** GLOBAL FUNCTIONS *****/ + +/***** EXTERNAL VARIABLES *****/ + +/***** EXTERNAL FUNCTIONS *****/ + +/***** STATIC VARIABLES *****/ + +/***** STATIC FUNCTIONS *****/ + +#if INCL_2D +static void sp_draw_vector_to_2d(PROTO_DECL2 fix15 x0,fix15 y0,fix15 x1,fix15 y1,band_t GLOBALFAR *band); +static void sp_add_intercept_2d(PROTO_DECL2 fix15 y,fix15 x); +static void sp_proc_intercepts_2d(PROTO_DECL1); +#endif + +#if INCL_2D +FUNCTION boolean init_2d( +GDECL +specs_t GLOBALFAR *specsarg) +/* + * init_out_2d() is called by sp_set_specs() to initialize the output module. + * Returns TRUE if output module can accept requested specifications. + * Returns FALSE otherwise. + */ +{ + +if (specsarg->flags & CURVES_OUT) + return FALSE; /* Curves out, clipping not supported */ + +#if DEBUG +printf("INIT_OUT__2d()\n"); +#endif +return TRUE; +} +#endif + +#if INCL_2D +FUNCTION boolean begin_char_2d( +GDECL +point_t Psw, +point_t Pmin, +point_t Pmax) +/* Called once at the start of the character generation process + * Initializes intercept table, either calculates pixel maxima or + * decides that they need to be collected + */ +{ +#if DEBUG +printf("BEGIN_CHAR__2d(%3.1f, %3.1f, %3.1f, %3.1f, %3.1f, %3.1f\n", + (real)Psw.x / (real)sp_globals.onepix, (real)Psw.y / (real)sp_globals.onepix, + (real)Pmin.x / (real)sp_globals.onepix, (real)Pmin.y / (real)sp_globals.onepix, + (real)Pmax.x / (real)sp_globals.onepix, (real)Pmax.y / (real)sp_globals.onepix); +#endif +/* Convert PIX.FRAC to 16.16 form */ +sp_globals.x_scan_active = TRUE; /* Assume x-scanning from the start */ + +init_char_out(Psw,Pmin,Pmax); +return TRUE; +} +#endif + + +#if INCL_2D +FUNCTION void begin_contour_2d( +GDECL +point_t P1, +boolean outside) +/* Called at the start of each contour + */ +{ + +#if DEBUG +printf("BEGIN_CONTOUR__2d(%3.4f, %3.4f, %s)\n", + (real)P1.x / (real)sp_globals.onepix, + (real)P1.y / (real)sp_globals.onepix, + outside? "outside": "inside"); +#endif +sp_globals.x0_spxl = P1.x; +sp_globals.y0_spxl = P1.y; +} +#endif + +#if INCL_2D +FUNCTION void line_2d( +GDECL +point_t P1) +/* + * Called for each vector in the transformed character + * "draws" vector into intercept table + */ +{ + +#if DEBUG +printf("LINE_0(%3.4f, %3.4f)\n", + (real)P1.x / (real)sp_globals.onepix, + (real)P1.y / (real)sp_globals.onepix); +#endif + +if (sp_globals.extents_running) + { + if (sp_globals.x0_spxl > sp_globals.bmap_xmax) + sp_globals.bmap_xmax = sp_globals.x0_spxl; + if (sp_globals.x0_spxl < sp_globals.bmap_xmin) + sp_globals.bmap_xmin = sp_globals.x0_spxl; + if (sp_globals.y0_spxl > sp_globals.bmap_ymax) + sp_globals.bmap_ymax = sp_globals.y0_spxl; + if (sp_globals.y0_spxl < sp_globals.bmap_ymin) + sp_globals.bmap_ymin = sp_globals.y0_spxl; + } + +if (!sp_globals.intercept_oflo) + { + sp_draw_vector_to_2d(sp_globals.x0_spxl, + sp_globals.y0_spxl, + P1.x, + P1.y, + &sp_globals.y_band); /* y-scan */ + + if (sp_globals.x_scan_active) + sp_draw_vector_to_2d(sp_globals.y0_spxl, + sp_globals.x0_spxl, + P1.y, + P1.x, + &sp_globals.x_band); /* x-scan if selected */ + } + +sp_globals.x0_spxl = P1.x; +sp_globals.y0_spxl = P1.y; /* update endpoint */ +} + +FUNCTION static void sp_draw_vector_to_2d( +GDECL +fix15 x0, /* X coordinate */ +fix15 y0, /* Y coordinate */ +fix15 x1, +fix15 y1, +band_t GLOBALFAR *band) +{ +register fix15 how_many_y; /* # of intercepts at y = n + 1/2 */ +register fix15 yc; /* Current scan-line */ + fix15 temp1; /* various uses */ + fix15 temp2; /* various uses */ +register fix31 dx_dy; /* slope of line in 16.16 form */ +register fix31 xc; /* high-precision (16.16) x coordinate */ + fix15 y_pxl; + +yc = (y0 + sp_globals.pixrnd) >> sp_globals.pixshift; /* current scan line = end of last line */ +y_pxl = (y1 + sp_globals.pixrnd) >> sp_globals.pixshift; /* calculate new end-scan line */ + +if ((how_many_y = y_pxl - yc) == 0) return; /* Don't draw a null line */ + +if (how_many_y < 0) yc--; /* Predecrment downward lines */ + +if (yc > band->band_max) /* Is start point above band? */ + { + if (y_pxl > band->band_max) return; /* line has to go down! */ + how_many_y = y_pxl - (yc = band->band_max) - 1; /* Yes, limit it */ + } + +if (yc < band->band_min) /* Is start point below band? */ + { + if (y_pxl < band->band_min) return; /* line has to go up! */ + how_many_y = y_pxl - (yc = band->band_min); /* Yes, limit it */ + } + +xc = (fix31)(x0 + sp_globals.pixrnd) << 16; /* Original x coordinate with built in */ + /* rounding. int.16 + pixshift form */ + +if ( (temp1 = (x1 - x0)) == 0) /* check for vertical line */ + { + dx_dy = 0L; /* Zero slope, leave xc alone */ + goto skip_calc; + } + +/* calculate dx_dy at 16.16 fixed point */ + +dx_dy = ( (fix31)temp1 << 16 )/(fix31)(y1 - y0); + +/* We have to check for a @#$%@# possible multiply overflow */ +/* by doing another @#$*& multiply. In assembly language, */ +/* the program could just check the OVerflow flag or whatever*/ +/* works on the particular processor. This C code is meant */ +/* to be processor independent. */ + +temp1 = (yc << sp_globals.pixshift) - y0 + sp_globals.pixrnd; +/* This sees if the sign bits start at bit 15 */ +/* if they do, no overflow has occurred */ + +temp2 = (fix15)(MULT16(temp1,(fix15)(dx_dy >> 16)) >> 15); + +if ( (temp2 != (fix15)0xFFFF) && + (temp2 != 0x0000) ) + { /* Overflow. Pick point closest to yc + .5 */ + if (ABS(temp1) < ABS((yc << sp_globals.pixshift) - y1 + sp_globals.pixrnd)) + { /* use x1 instead of x0 */ + xc = (fix31)(x1 + sp_globals.pixrnd) << (16 - sp_globals.pixshift); + } + goto skip_calc; + } +/* calculate new xc at the center of the *current* scan line */ +/* due to banding, yc may be several lines away from y0 */ +/* xc += (yc + .5 - y0) * dx_dy */ +/* This multiply generates a subpixel delta. */ +/* So we leave it as an int.pixshift + 16 delta */ + +xc += (fix31)temp1 * dx_dy; +dx_dy <<= sp_globals.pixshift; +skip_calc: + +yc -= band->band_array_offset; /* yc is now an offset relative to the band */ + +if (how_many_y < 0) + { /* Vector down */ + if ((how_many_y += yc + 1) < band->band_floor) + how_many_y = band->band_floor; /* can't go below floor */ + while(yc >= how_many_y) + { + temp1 = (fix15)(xc >> 16); + sp_add_intercept_2d(yc--,temp1); + xc -= dx_dy; + } + } + else + { /* Vector up */ + /* check to see that line doesn't extend beyond top of band */ + if ((how_many_y += yc) > band->band_ceiling) + how_many_y = band->band_ceiling; + while(yc < how_many_y) + { + temp1 = (fix15)(xc >> 16); + sp_add_intercept_2d(yc++,temp1); + xc += dx_dy; + } + } +} + +#endif + +#if INCL_2D +FUNCTION boolean end_char_2d() +/* Called when all character data has been output + * Return TRUE if output process is complete + * Return FALSE to repeat output of the transformed data beginning + * with the first contour + */ +{ + +fix31 xorg; +fix31 yorg; +#if INCL_CLIPPING +fix31 em_max, em_min, bmap_max, bmap_min; +#endif + +#if DEBUG +printf("END_CHAR__2d()\n"); +#endif + +if (sp_globals.first_pass) + { + if (sp_globals.bmap_xmax >= sp_globals.bmap_xmin) + { + sp_globals.xmin = (sp_globals.bmap_xmin + sp_globals.pixrnd + 1) >> sp_globals.pixshift; + sp_globals.xmax = (sp_globals.bmap_xmax + sp_globals.pixrnd) >> sp_globals.pixshift; + } + else + { + sp_globals.xmin = sp_globals.xmax = 0; + } + if (sp_globals.bmap_ymax >= sp_globals.bmap_ymin) + { + +#if INCL_CLIPPING + switch(sp_globals.tcb0.xtype) + { + case 1: /* 180 degree rotation */ + if (sp_globals.specs.flags & CLIP_TOP) + { + sp_globals.clip_ymin = (fix31)((fix31)EM_TOP * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_ymin = sp_globals.clip_ymin >> sp_globals.multshift; + bmap_min = (sp_globals.bmap_ymin + sp_globals.pixrnd + 1) >> sp_globals.pixshift; + sp_globals.clip_ymin = -1 * sp_globals.clip_ymin; + if (bmap_min < sp_globals.clip_ymin) + sp_globals.ymin = sp_globals.clip_ymin; + else + sp_globals.ymin = bmap_min; + } + if (sp_globals.specs.flags & CLIP_BOTTOM) + { + sp_globals.clip_ymax = (fix31)((fix31)(-1 * EM_BOT) * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_ymax = sp_globals.clip_ymax >> sp_globals.multshift; + bmap_max = (sp_globals.bmap_ymax + sp_globals.pixrnd) >> sp_globals.pixshift; + if (bmap_max < sp_globals.clip_ymax) + sp_globals.ymax = bmap_max; + else + sp_globals.ymax = sp_globals.clip_ymax; + } + sp_globals.clip_xmax = -sp_globals.xmin; + sp_globals.clip_xmin = ((sp_globals.set_width.x+32768L) >> 16) - + sp_globals.xmin; + break; + case 2: /* 90 degree rotation */ + if (sp_globals.specs.flags & CLIP_TOP) + { + sp_globals.clip_xmin = (fix31)((fix31)(-1 * EM_BOT) * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_xmin = sp_globals.clip_xmin >> sp_globals.multshift; + sp_globals.clip_xmin = -1 * sp_globals.clip_xmin; + bmap_min = (sp_globals.bmap_xmin + sp_globals.pixrnd + 1) >> sp_globals.pixshift; + if (bmap_min > sp_globals.clip_xmin) + sp_globals.clip_xmin = bmap_min; + + /* normalize to x origin */ + sp_globals.clip_xmin -= sp_globals.xmin; + } + if (sp_globals.specs.flags & CLIP_BOTTOM) + { + sp_globals.clip_xmax = (fix31)((fix31)EM_TOP * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_xmax = sp_globals.clip_xmax >> sp_globals.multshift; + bmap_max = (sp_globals.bmap_xmax + sp_globals.pixrnd) >> sp_globals.pixshift; + if (bmap_max < sp_globals.clip_xmax) + sp_globals.xmax = bmap_max; + else + sp_globals.xmax = sp_globals.clip_xmax; + sp_globals.clip_ymax = 0; + if ((sp_globals.specs.flags & CLIP_TOP) && + (sp_globals.ymax > sp_globals.clip_ymax)) + sp_globals.ymax = sp_globals.clip_ymax; + sp_globals.clip_ymin = ((sp_globals.set_width.y+32768L) >> 16); + if ((sp_globals.specs.flags & CLIP_BOTTOM) && + (sp_globals.ymin < sp_globals.clip_ymin)) + sp_globals.ymin = sp_globals.clip_ymin; + /* normalize to x origin */ + sp_globals.clip_xmax -= sp_globals.xmin; + } + break; + case 3: /* 270 degree rotation */ + if (sp_globals.specs.flags & CLIP_TOP) + { + sp_globals.clip_xmin = (fix31)((fix31)EM_TOP * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_xmin = sp_globals.clip_xmin >> sp_globals.multshift; + sp_globals.clip_xmin = -1 * sp_globals.clip_xmin; + bmap_min = (sp_globals.bmap_xmin + sp_globals.pixrnd + 1) >> sp_globals.pixshift; + + /* let the minimum be the larger of these two values */ + if (bmap_min > sp_globals.clip_xmin) + sp_globals.clip_xmin = bmap_min; + + /* normalize the x value to new xorgin */ + sp_globals.clip_xmin -= sp_globals.xmin; + } + if (sp_globals.specs.flags & CLIP_BOTTOM) + { + sp_globals.clip_xmax = (fix31)((fix31)(-1 * EM_BOT) * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_xmax = sp_globals.clip_xmax >> sp_globals.multshift; + bmap_max = (sp_globals.bmap_xmax + sp_globals.pixrnd) >> sp_globals.pixshift; + + /* let the max be the lesser of these two values */ + if (bmap_max < sp_globals.clip_xmax) + { + sp_globals.xmax = bmap_max; + sp_globals.clip_xmax = bmap_max; + } + else + sp_globals.xmax = sp_globals.clip_xmax; + + /* normalize the x value to new x origin */ + sp_globals.clip_xmax -= sp_globals.xmin; + } + /* compute y clip values */ + sp_globals.clip_ymax = ((sp_globals.set_width.y+32768L) >> 16); + if ((sp_globals.specs.flags & CLIP_TOP) && + (sp_globals.ymax > sp_globals.clip_ymax)) + sp_globals.ymax = sp_globals.clip_ymax; + sp_globals.clip_ymin = 0; + if ((sp_globals.specs.flags & CLIP_BOTTOM) && + (sp_globals.ymin < sp_globals.clip_ymin)) + sp_globals.ymin = sp_globals.clip_ymin; + break; + default: /* this is for zero degree rotation and arbitrary rotation */ + if (sp_globals.specs.flags & CLIP_TOP) + { + sp_globals.clip_ymax = (fix31)((fix31)EM_TOP * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_ymax = sp_globals.clip_ymax >> sp_globals.multshift; + bmap_max = (sp_globals.bmap_ymax + sp_globals.pixrnd) >> sp_globals.pixshift; + if (bmap_max > sp_globals.clip_ymax) + sp_globals.ymax = bmap_max; + else + sp_globals.ymax = sp_globals.clip_ymax; + } + if (sp_globals.specs.flags & CLIP_BOTTOM) + { + sp_globals.clip_ymin = (fix31)((fix31)(-1 * EM_BOT) * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_ymin = sp_globals.clip_ymin >> sp_globals.multshift; + sp_globals.clip_ymin = - sp_globals.clip_ymin; + bmap_min = (sp_globals.bmap_ymin + sp_globals.pixrnd + 1) >> sp_globals.pixshift; + if (bmap_min < sp_globals.clip_ymin) + sp_globals.ymin = sp_globals.clip_ymin; + else + sp_globals.ymin = bmap_min; + } + sp_globals.clip_xmin = -sp_globals.xmin; + sp_globals.clip_xmax = ((sp_globals.set_width.x+32768L) >> 16) - + sp_globals.xmin; + break; + } +if ( !(sp_globals.specs.flags & CLIP_TOP)) +#endif + sp_globals.ymax = (sp_globals.bmap_ymax + sp_globals.pixrnd) >> sp_globals.pixshift; + +#if INCL_CLIPPING +if ( !(sp_globals.specs.flags & CLIP_BOTTOM)) +#endif + sp_globals.ymin = (sp_globals.bmap_ymin + sp_globals.pixrnd + 1) >> sp_globals.pixshift; + } + else + { + sp_globals.ymin = sp_globals.ymax = 0; + } + + /* add in the rounded out part (from xform.) of the left edge */ + if (sp_globals.tcb.xmode == 0) /* for X pix is function of X orus only add the round */ + xorg = (((fix31)sp_globals.xmin << 16) + (sp_globals.rnd_xmin << sp_globals.poshift)); + else + if (sp_globals.tcb.xmode == 1) /* for X pix is function of -X orus only, subtr. round */ + xorg = (((fix31)sp_globals.xmin << 16) - (sp_globals.rnd_xmin << sp_globals.poshift)) ; + else + xorg = (fix31)sp_globals.xmin << 16; /* for other cases don't use round on x */ + + if (sp_globals.tcb.ymode == 2) /* for Y pix is function of X orus only, add round error */ + yorg = (((fix31)sp_globals.ymin << 16) + (sp_globals.rnd_xmin << sp_globals.poshift)); + else + if (sp_globals.tcb.ymode == 3) /* for Y pix is function of -X orus only, sub round */ + yorg = (((fix31)sp_globals.ymin << 16) - (sp_globals.rnd_xmin << sp_globals.poshift)); + else /* all other cases have no round error on yorg */ + yorg = (fix31)sp_globals.ymin << 16; + + open_bitmap(sp_globals.set_width.x, sp_globals.set_width.y, xorg, yorg, + sp_globals.xmax - sp_globals.xmin, sp_globals.ymax - sp_globals.ymin); + if (sp_globals.intercept_oflo) + { + sp_globals.y_band.band_min = sp_globals.ymin; + sp_globals.y_band.band_max = sp_globals.ymax; + sp_globals.x_scan_active = FALSE; + sp_globals.no_x_lists = 0; + init_intercepts_out(); + sp_globals.first_pass = FALSE; + sp_globals.extents_running = FALSE; + return FALSE; + } + else + { + sp_proc_intercepts_2d(); + close_bitmap(); + return TRUE; + } + } +else + { + if (sp_globals.intercept_oflo) + { + reduce_band_size_out(); + init_intercepts_out(); + return FALSE; + } + else + { + sp_proc_intercepts_2d(); + if (next_band_out()) + { + init_intercepts_out(); + return FALSE; + } + close_bitmap(); + return TRUE; + } + } +} +#endif + +#if INCL_2D +FUNCTION static void sp_add_intercept_2d( +GDECL +fix15 y, /* Y coordinate in relative pixel units */ + /* (0 is lowest sample in band) */ +fix15 x) /* X coordinate of intercept in subpixel units */ + +/* Called by line() to add an intercept to the intercept list structure + */ + +{ +register fix15 from; /* Insertion pointers for the linked list sort */ +register fix15 to; + +#if DEBUG +/* Bounds checking IS done in debug mode */ +if ((y >= MAX_INTERCEPTS) || (y < 0)) + { + printf("Intercept out of table!!!!! (%d)\n",y); + return; + } + +if (y >= sp_globals.no_y_lists) + { + printf(" Add x intercept(%2d, %f)\n", + y + sp_globals.x_band.band_min - sp_globals.no_y_lists, + (real)x/(real)sp_globals.onepix); + if (y > (sp_globals.no_x_lists + sp_globals.no_y_lists)) + { + printf(" Intercept too big for band!!!!!\007\n"); + return; + } + } + else + { + printf(" Add y intercept(%2d, %f)\n", y + sp_globals.y_band.band_min,(real)x/(real)sp_globals.onepix); + } + +if (y < 0) /* Y value below bottom of current band? */ + { + printf(" Intecerpt less than 0!!!\007\n"); + return; + } +#endif + +/* Store new values */ + +sp_intercepts.car[sp_globals.next_offset] = x; + +/* Find slot to insert new element (between from and to) */ + +from = y; /* Start at list head */ + +while( (to = sp_intercepts.cdr[from]) >= sp_globals.first_offset) /* Until to == end of list */ + { + if (x <= sp_intercepts.car[to]) /* If next item is larger than or same as this one... */ + goto insert_element; /* ... drop out and insert here */ + from = to; /* move forward in list */ + } + +insert_element: /* insert element "next_offset" between elements "from" */ + /* and "to" */ + +sp_intercepts.cdr[from] = sp_globals.next_offset; +sp_intercepts.cdr[sp_globals.next_offset] = to; + +if (++sp_globals.next_offset >= MAX_INTERCEPTS) /* Intercept buffer full? */ + { + sp_globals.intercept_oflo = TRUE; +/* There may be a few more calls to "add_intercept" from the current line */ +/* To avoid problems, we set next_offset to a safe value. We don't care */ +/* if the intercept table gets trashed at this point */ + sp_globals.next_offset = sp_globals.first_offset; + } +} + +#endif + +#if INCL_2D +FUNCTION static void sp_proc_intercepts_2d() +/* Called by sp_make_char to output accumulated intercept lists + * Clips output to xmin, xmax, sp_globals.ymin, ymax boundaries + */ +{ +register fix15 i; +register fix15 from, to; /* Start and end of run in pixel units + relative to left extent of character */ +register fix15 y; +register fix15 scan_line; + fix15 local_bmap_xmin; + fix15 local_bmap_xmax; + fix15 first_y, last_y; + fix15 j,k; + +#if INCL_CLIPPING +if ((sp_globals.specs.flags & CLIP_LEFT) != 0) + clipleft = TRUE; +else + clipleft = FALSE; +if ((sp_globals.specs.flags & CLIP_RIGHT) != 0) + clipright = TRUE; +else + clipright = FALSE; +if (clipleft || clipright) + { + xmax = sp_globals.clip_xmax << sp_globals.pixshift; + xmin = sp_globals.clip_xmin << sp_globals.pixshift; + } +if (!clipright) + xmax = ((sp_globals.set_width.x+32768L) >> 16); +#endif + +if (sp_globals.x_scan_active) /* If xscanning, we need to make sure we don't miss any important pixels */ + { + first_y = sp_globals.x_band.band_floor; /* start of x lists */ + last_y = sp_globals.x_band.band_ceiling; /* end of x lists */ + for (y = first_y; y != last_y; y++) /* scan all xlists */ + { + i = sp_intercepts.cdr[y]; /* Index head of intercept list */ + while (i != 0) /* Link to next intercept if present */ + { + from = sp_intercepts.car[i]; + j = i; + i = sp_intercepts.cdr[i]; /* Link to next intercept */ + if (i == 0) /* End of list? */ + { +#if DEBUG + printf("****** proc_intercepts: odd number of intercepts in x list\n"); +#endif + break; + } + to = sp_intercepts.car[i]; + k = sp_intercepts.cdr[i]; + if (((to >> sp_globals.pixshift) >= (from >> sp_globals.pixshift)) && + ((to - from) < (sp_globals.onepix + 1))) + { + from = ((fix31)to + (fix31)from - (fix31)sp_globals.onepix) >> (sp_globals.pixshift + 1); + if (from > sp_globals.y_band.band_max) + from = sp_globals.y_band.band_max; + if ((from -= sp_globals.y_band.band_min) < 0) + from = 0; + to = ((y - sp_globals.x_band.band_floor + sp_globals.x_band.band_min) + << sp_globals.pixshift) + + sp_globals.pixrnd; + sp_intercepts.car[j] = to; + sp_intercepts.car[i] = to + sp_globals.onepix; + sp_intercepts.cdr[i] = sp_intercepts.cdr[from]; + sp_intercepts.cdr[from] = j; + } + i = k; + } + } + } +#if DEBUG +printf("\nIntercept lists:\n"); +#endif + +if ((first_y = sp_globals.y_band.band_max) >= sp_globals.ymax) + first_y = sp_globals.ymax - 1; /* Clip to ymax boundary */ + +if ((last_y = sp_globals.y_band.band_min) < sp_globals.ymin) + last_y = sp_globals.ymin; /* Clip to sp_globals.ymin boundary */ + +last_y -= sp_globals.y_band.band_array_offset; + +local_bmap_xmin = sp_globals.xmin << sp_globals.pixshift; +local_bmap_xmax = (sp_globals.xmax << sp_globals.pixshift) + sp_globals.pixrnd; + +#if DEBUG +/* Print out all of the intercept info */ +scan_line = sp_globals.ymax - first_y - 1; + +for (y = first_y - sp_globals.y_band.band_min; y >= last_y; y--, scan_line++) + { + i = y; /* Index head of intercept list */ + while ((i = sp_intercepts.cdr[i]) != 0) /* Link to next intercept if present */ + { + if ((from = sp_intercepts.car[i] - local_bmap_xmin) < 0) + from = 0; /* Clip to xmin boundary */ + i = sp_intercepts.cdr[i]; /* Link to next intercept */ + if (i == 0) /* End of list? */ + { + printf("****** proc_intercepts: odd number of intercepts\n"); + break; + } + if ((to = sp_intercepts.car[i]) > sp_globals.bmap_xmax) + to = sp_globals.bmap_xmax - local_bmap_xmin; /* Clip to xmax boundary */ + else + to -= local_bmap_xmin; + printf(" Y = %2d (scanline %2d): %3.4f %3.4f:\n", + y + sp_globals.y_band.band_min, + scan_line, + (real)from / (real)sp_globals.onepix, + (real)to / (real)sp_globals.onepix); + } + } +#endif + +/* Draw the image */ +scan_line = sp_globals.ymax - first_y - 1; + +for (y = first_y - sp_globals.y_band.band_min; y >= last_y; y--, scan_line++) + { + i = y; /* Index head of intercept list */ + while ((i = sp_intercepts.cdr[i]) != 0) /* Link to next intercept if present */ + { + if ((from = sp_intercepts.car[i] - local_bmap_xmin) < 0) + from = 0; /* Clip to xmin boundary */ + i = sp_intercepts.cdr[i]; /* Link to next intercept */ + + if ((to = sp_intercepts.car[i]) > local_bmap_xmax) + to = sp_globals.bmap_xmax - local_bmap_xmin; /* Clip to xmax boundary */ + else + to -= local_bmap_xmin; +#if INCL_CLIPPING + if (clipleft) + { + if (to <= xmin) + continue; + if (from < xmin) + from = xmin; + } + if (clipright) + { + if (from >= xmax) + continue; + if (to > xmax) + to = xmax; + } +#endif + if ( (to - from) <= sp_globals.onepix) + { + from = (to + from - sp_globals.onepix) >> (sp_globals.pixshift + 1); + set_bitmap_bits(scan_line, from, from + 1); + } + else + { + set_bitmap_bits(scan_line, from >> sp_globals.pixshift, to >> sp_globals.pixshift); + } + } + } +} + +#endif diff --git a/nx-X11/lib/font/Speedo/out_blk.c b/nx-X11/lib/font/Speedo/out_blk.c new file mode 100644 index 000000000..a5b669b2a --- /dev/null +++ b/nx-X11/lib/font/Speedo/out_blk.c @@ -0,0 +1,706 @@ +/* $Xorg: out_blk.c,v 1.3 2000/08/17 19:46:26 cpqbld Exp $ */ + +/* + +Copyright 1989-1991, Bitstream Inc., Cambridge, MA. +You are hereby granted permission under all Bitstream propriety rights to +use, copy, modify, sublicense, sell, and redistribute the Bitstream Speedo +software and the Bitstream Charter outline font for any purpose and without +restrictions; provided, that this notice is left intact on all copies of such +software or font and that Bitstream's trademark is acknowledged as shown below +on all unmodified copies of such font. + +BITSTREAM CHARTER is a registered trademark of Bitstream Inc. + + +BITSTREAM INC. DISCLAIMS ANY AND ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING +WITHOUT LIMITATION THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE. BITSTREAM SHALL NOT BE LIABLE FOR ANY DIRECT OR INDIRECT +DAMAGES, INCLUDING BUT NOT LIMITED TO LOST PROFITS, LOST DATA, OR ANY OTHER +INCIDENTAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF OR IN ANY WAY CONNECTED +WITH THE SPEEDO SOFTWARE OR THE BITSTREAM CHARTER OUTLINE FONT. + +*/ +/* $XFree86: xc/lib/font/Speedo/out_blk.c,v 1.2 1999/02/07 06:18:16 dawes Exp $ */ + + +/*************************** O U T _ B L K . C ********************************* + * * + * This is an output module for black-writer mode. * + * * + *****************************************************************************/ + + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include "spdo_prv.h" /* General definitions for Speedo */ + +#define DEBUG 0 +#define LOCAL static +#define ABS(X) ( (X < 0) ? -X : X) + +#if DEBUG +#include <stdio.h> +#define SHOW(X) printf("X = %d\n", X) +#else +#define SHOW(X) +#endif + + +/***** GLOBAL VARIABLES *****/ + +/***** GLOBAL FUNCTIONS *****/ + +/***** EXTERNAL VARIABLES *****/ + +/***** EXTERNAL FUNCTIONS *****/ + +/***** STATIC VARIABLES *****/ + +/***** STATIC FUNCTIONS *****/ + +#if INCL_BLACK +static void sp_add_intercept_black(PROTO_DECL2 fix15 y, fix15 x); +static void sp_proc_intercepts_black(PROTO_DECL1); +#endif + + +#if INCL_BLACK +FUNCTION boolean init_black( +GDECL +specs_t GLOBALFAR *specsarg) +/* + * init_out0() is called by sp_set_specs() to initialize the output module. + * Returns TRUE if output module can accept requested specifications. + * Returns FALSE otherwise. + */ +{ +#if DEBUG +printf("INIT_BLK()\n"); +#endif +if (specsarg->flags & CURVES_OUT) + return FALSE; /* Curves out not supported */ +return (TRUE); +} +#endif + + +#if INCL_BLACK +FUNCTION boolean begin_char_black( +GDECL +point_t Psw, +point_t Pmin, +point_t Pmax) +/* Called once at the start of the character generation process + */ +{ +#if DEBUG +printf("BEGIN_CHAR_BLACK(%3.1f, %3.1f, %3.1f, %3.1f, %3.1f, %3.1f\n", + (real)Psw.x / (real)sp_globals.onepix, (real)Psw.y / (real)sp_globals.onepix, + (real)Pmin.x / (real)sp_globals.onepix, (real)Pmin.y / (real)sp_globals.onepix, + (real)Pmax.x / (real)sp_globals.onepix, (real)Pmax.y / (real)sp_globals.onepix); +#endif +init_char_out(Psw,Pmin,Pmax); +return TRUE; +} +#endif + + +#if INCL_BLACK +FUNCTION void begin_contour_black( +GDECL +point_t P1, +boolean outside) +/* Called at the start of each contour + */ +{ + +#if DEBUG +printf("BEGIN_CONTOUR_BLACK(%3.1f, %3.1f, %s)\n", + (real)P1.x / (real)sp_globals.onepix, (real)P1.y / (real)sp_globals.onepix, outside? "outside": "inside"); +#endif +sp_globals.x0_spxl = P1.x; +sp_globals.y0_spxl = P1.y; +sp_globals.y_pxl = (sp_globals.y0_spxl + sp_globals.pixrnd) >> sp_globals.pixshift; +} +#endif + +#if INCL_BLACK +FUNCTION void line_black( +GDECL +point_t P1) +/* Called for each vector in the transformed character + */ +{ +register fix15 how_many_y; /* # of intercepts at y = n + 1/2 */ +register fix15 yc, i; /* Current scan-line */ + fix15 temp1; /* various uses */ + fix15 temp2; /* various uses */ +register fix31 dx_dy; /* slope of line in 16.16 form */ +register fix31 xc; /* high-precision (16.16) x coordinate */ + fix15 x0,y0,x1,y1; /* PIX.FRAC start and endpoints */ + +x0 = sp_globals.x0_spxl; /* get start of line (== current point) */ +y0 = sp_globals.y0_spxl; +sp_globals.x0_spxl = x1 = P1.x; /* end of line */ +sp_globals.y0_spxl = y1 = P1.y; /* (also update current point to end of line) */ + +yc = sp_globals.y_pxl; /* current scan line = end of last line */ +sp_globals.y_pxl = (y1 + sp_globals.pixrnd) >> sp_globals.pixshift; /* calculate new end-scan sp_globals.line */ + + +#if DEBUG +printf("LINE_BLACK(%3.4f, %3.4f)\n", + (real)P1.x/(real)sp_globals.onepix, + (real)P1.y/(real)sp_globals.onepix); +#endif + +if (sp_globals.extents_running) + { + if (sp_globals.x0_spxl > sp_globals.bmap_xmax) + sp_globals.bmap_xmax = sp_globals.x0_spxl; + if (sp_globals.x0_spxl < sp_globals.bmap_xmin) + sp_globals.bmap_xmin = sp_globals.x0_spxl; + if (sp_globals.y0_spxl > sp_globals.bmap_ymax) + sp_globals.bmap_ymax = sp_globals.y0_spxl; + if (sp_globals.y0_spxl < sp_globals.bmap_ymin) + sp_globals.bmap_ymin = sp_globals.y0_spxl; + } + +if (sp_globals.intercept_oflo) return; + +if ((how_many_y = sp_globals.y_pxl - yc) == 0) return; /* Don't draw a null line */ + +if (how_many_y < 0) yc--; /* Predecrment downward lines */ + +if (yc > sp_globals.y_band.band_max) /* Is start point above band? */ + { + if (sp_globals.y_pxl > sp_globals.y_band.band_max) return; /* line has to go down! */ + how_many_y = sp_globals.y_pxl - (yc = sp_globals.y_band.band_max) - 1; /* Yes, limit it */ + } + +if (yc < sp_globals.y_band.band_min) /* Is start point below band? */ + { + if (sp_globals.y_pxl < sp_globals.y_band.band_min) return; /* line has to go up! */ + how_many_y = sp_globals.y_pxl - (yc = sp_globals.y_band.band_min); /* Yes, limit it */ + } + +xc = (fix31)(x0 + sp_globals.pixrnd) << (16 - sp_globals.pixshift); /* Original x coordinate with built in */ + /* rounding. 16.16 form */ + + +if ( (temp1 = (x1 - x0)) == 0) /* check for vertical line */ + { + yc -= sp_globals.y_band.band_min; /* yc is now an offset relative to the band */ + temp1 = (fix15)(xc >> 16); + if (how_many_y < 0) + { /* Vector down */ + if ((how_many_y += yc + 1) < 0) how_many_y = 0; /* can't go below 0 */ + for (i = yc; i >= how_many_y; i--) + sp_add_intercept_black(i,temp1); + } + else + { /* Vector up */ + /* check to see that line doesn't extend beyond top of band */ + if ((how_many_y += yc) > sp_globals.no_y_lists) how_many_y = sp_globals.no_y_lists; + for (i = yc; i != how_many_y; i++) + sp_add_intercept_black(i,temp1); + } + return; + } + +/* calculate dx_dy at 16.16 fixed point */ + +dx_dy = ( (fix31)temp1 << 16 )/(fix31)(y1 - y0); + +/* We have to check for a @#$%@# possible multiply overflow */ +/* by doing another @#$*& multiply. In assembly language, */ +/* the program could just check the OVerflow flag or whatever*/ +/* works on the particular processor. This C code is meant */ +/* to be processor independant. */ + +temp1 = (yc << sp_globals.pixshift) - y0 + sp_globals.pixrnd; +/* This sees if the sign bits start at bit 15 */ +/* if they do, no overflow has occurred */ + +temp2 = (fix15)(MULT16(temp1,(fix15)(dx_dy >> 16)) >> 15); + +if ( (temp2 != (fix15)0xFFFF) && + (temp2 != 0x0000) && + /* Overflow. Pick point closest to yc + .5 */ + (ABS(temp1) < ABS((yc << sp_globals.pixshift) - y1 + sp_globals.pixrnd)) ) + { /* use x1 instead of x0 */ + xc = (fix31)(x1 + sp_globals.pixrnd) << (16 - sp_globals.pixshift); + } +else + { +/* calculate new xc at the center of the *current* scan line */ +/* due to banding, yc may be several lines away from y0 */ +/* xc += (yc + .5 - y0) * dx_dy */ +/* This multiply generates a subpixel delta. */ +/* So we shift it to be a 16.16 delta */ + + xc += ((fix31)temp1 * dx_dy) >> sp_globals.pixshift; + } + +yc -= sp_globals.y_band.band_min; /* yc is now an offset relative to the band */ + +if (how_many_y < 0) + { /* Vector down */ + if (how_many_y == -1) + sp_add_intercept_black(yc, (fix15) (xc >> 16)); + else + { + if ((how_many_y += yc + 1) < 0) how_many_y = 0; /* can't go below 0 */ + for (i = yc; i >= how_many_y; i--) + { + temp1 = (fix15)(xc >> 16); + sp_add_intercept_black(i,temp1); + xc -= dx_dy; + } + } + } + else + { /* Vector up */ + /* check to see that line doesn't extend beyond top of band */ + if (how_many_y == 1) + sp_add_intercept_black(yc, (fix15) (xc >> 16)); + else + { + if ((how_many_y += yc) > sp_globals.no_y_lists) how_many_y = sp_globals.no_y_lists; + for (i = yc; i != how_many_y; i++) + { + temp1 = (fix15)(xc >> 16); + sp_add_intercept_black(i,temp1); + xc += dx_dy; + } + } + } +} +#endif +#if INCL_BLACK +FUNCTION boolean end_char_black() +GDECL +/* Called when all character data has been output + * Return TRUE if output process is complete + * Return FALSE to repeat output of the transformed data beginning + * with the first contour + */ +{ + +fix31 xorg; +fix31 yorg; +#if INCL_CLIPPING +fix31 bmap_max, bmap_min; +#endif + +#if DEBUG +printf("END_CHAR_BLACK()\n"); +#endif + +if (sp_globals.first_pass) + { + if (sp_globals.bmap_xmax >= sp_globals.bmap_xmin) + { + sp_globals.xmin = (sp_globals.bmap_xmin + sp_globals.pixrnd + 1) >> sp_globals.pixshift; + sp_globals.xmax = (sp_globals.bmap_xmax + sp_globals.pixrnd) >> sp_globals.pixshift; + } + else + { + sp_globals.xmin = sp_globals.xmax = 0; + } + if (sp_globals.bmap_ymax >= sp_globals.bmap_ymin) + { + +#if INCL_CLIPPING + switch(sp_globals.tcb0.xtype) + { + case 1: /* 180 degree rotation */ + if (sp_globals.specs.flags & CLIP_TOP) + { + sp_globals.clip_ymin = (fix31)((fix31)EM_TOP * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_ymin = sp_globals.clip_ymin >> sp_globals.multshift; + bmap_min = (sp_globals.bmap_ymin + sp_globals.pixrnd + 1) >> sp_globals.pixshift; + sp_globals.clip_ymin = -1 * sp_globals.clip_ymin; + if (bmap_min < sp_globals.clip_ymin) + sp_globals.ymin = sp_globals.clip_ymin; + else + sp_globals.ymin = bmap_min; + } + if (sp_globals.specs.flags & CLIP_BOTTOM) + { + sp_globals.clip_ymax = (fix31)((fix31)(-1 * EM_BOT) * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_ymax = sp_globals.clip_ymax >> sp_globals.multshift; + bmap_max = (sp_globals.bmap_ymax + sp_globals.pixrnd) >> sp_globals.pixshift; + if (bmap_max < sp_globals.clip_ymax) + sp_globals.ymax = bmap_max; + else + sp_globals.ymax = sp_globals.clip_ymax; + } + sp_globals.clip_xmax = -sp_globals.xmin; + sp_globals.clip_xmin = ((sp_globals.set_width.x+32768L) >> 16) - + sp_globals.xmin; + break; + case 2: /* 90 degree rotation */ + if (sp_globals.specs.flags & CLIP_TOP) + { + sp_globals.clip_xmin = (fix31)((fix31)(-1 * EM_BOT) * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_xmin = sp_globals.clip_xmin >> sp_globals.multshift; + sp_globals.clip_xmin = -1 * sp_globals.clip_xmin; + bmap_min = (sp_globals.bmap_xmin + sp_globals.pixrnd + 1) >> sp_globals.pixshift; + if (bmap_min > sp_globals.clip_xmin) + sp_globals.clip_xmin = bmap_min; + + /* normalize to x origin */ + sp_globals.clip_xmin -= sp_globals.xmin; + } + if (sp_globals.specs.flags & CLIP_BOTTOM) + { + sp_globals.clip_xmax = (fix31)((fix31)EM_TOP * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_xmax = sp_globals.clip_xmax >> sp_globals.multshift; + bmap_max = (sp_globals.bmap_xmax + sp_globals.pixrnd) >> sp_globals.pixshift; + if (bmap_max < sp_globals.clip_xmax) + sp_globals.xmax = bmap_max; + else + sp_globals.xmax = sp_globals.clip_xmax; + sp_globals.clip_ymax = 0; + if ((sp_globals.specs.flags & CLIP_TOP) && + (sp_globals.ymax > sp_globals.clip_ymax)) + sp_globals.ymax = sp_globals.clip_ymax; + sp_globals.clip_ymin = ((sp_globals.set_width.y+32768L) >> 16); + if ((sp_globals.specs.flags & CLIP_BOTTOM) && + (sp_globals.ymin < sp_globals.clip_ymin)) + sp_globals.ymin = sp_globals.clip_ymin; + /* normalize to x origin */ + sp_globals.clip_xmax -= sp_globals.xmin; + } + break; + case 3: /* 270 degree rotation */ + if (sp_globals.specs.flags & CLIP_TOP) + { + sp_globals.clip_xmin = (fix31)((fix31)EM_TOP * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_xmin = sp_globals.clip_xmin >> sp_globals.multshift; + sp_globals.clip_xmin = -1 * sp_globals.clip_xmin; + bmap_min = (sp_globals.bmap_xmin + sp_globals.pixrnd + 1) >> sp_globals.pixshift; + + /* let the minimum be the larger of these two values */ + if (bmap_min > sp_globals.clip_xmin) + sp_globals.clip_xmin = bmap_min; + + /* normalize the x value to new xorgin */ + sp_globals.clip_xmin -= sp_globals.xmin; + } + if (sp_globals.specs.flags & CLIP_BOTTOM) + { + sp_globals.clip_xmax = (fix31)((fix31)(-1 * EM_BOT) * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_xmax = sp_globals.clip_xmax >> sp_globals.multshift; + bmap_max = (sp_globals.bmap_xmax + sp_globals.pixrnd) >> sp_globals.pixshift; + + /* let the max be the lesser of these two values */ + if (bmap_max < sp_globals.clip_xmax) + { + sp_globals.xmax = bmap_max; + sp_globals.clip_xmax = bmap_max; + } + else + sp_globals.xmax = sp_globals.clip_xmax; + + /* normalize the x value to new x origin */ + sp_globals.clip_xmax -= sp_globals.xmin; + } + /* compute y clip values */ + sp_globals.clip_ymax = ((sp_globals.set_width.y+32768L) >> 16); + if ((sp_globals.specs.flags & CLIP_TOP) && + (sp_globals.ymax > sp_globals.clip_ymax)) + sp_globals.ymax = sp_globals.clip_ymax; + sp_globals.clip_ymin = 0; + if ((sp_globals.specs.flags & CLIP_BOTTOM) && + (sp_globals.ymin < sp_globals.clip_ymin)) + sp_globals.ymin = sp_globals.clip_ymin; + break; + default: /* this is for zero degree rotation and arbitrary rotation */ + if (sp_globals.specs.flags & CLIP_TOP) + { + sp_globals.clip_ymax = (fix31)((fix31)EM_TOP * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_ymax = sp_globals.clip_ymax >> sp_globals.multshift; + bmap_max = (sp_globals.bmap_ymax + sp_globals.pixrnd) >> sp_globals.pixshift; + if (bmap_max > sp_globals.clip_ymax) + sp_globals.ymax = bmap_max; + else + sp_globals.ymax = sp_globals.clip_ymax; + } + if (sp_globals.specs.flags & CLIP_BOTTOM) + { + sp_globals.clip_ymin = (fix31)((fix31)(-1 * EM_BOT) * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_ymin = sp_globals.clip_ymin >> sp_globals.multshift; + sp_globals.clip_ymin = - sp_globals.clip_ymin; + bmap_min = (sp_globals.bmap_ymin + sp_globals.pixrnd + 1) >> sp_globals.pixshift; + if (bmap_min < sp_globals.clip_ymin) + sp_globals.ymin = sp_globals.clip_ymin; + else + sp_globals.ymin = bmap_min; + } + sp_globals.clip_xmin = -sp_globals.xmin; + sp_globals.clip_xmax = ((sp_globals.set_width.x+32768L) >> 16) - + sp_globals.xmin; + break; + } +if ( !(sp_globals.specs.flags & CLIP_TOP)) +#endif + sp_globals.ymax = (sp_globals.bmap_ymax + sp_globals.pixrnd) >> sp_globals.pixshift; + +#if INCL_CLIPPING +if ( !(sp_globals.specs.flags & CLIP_BOTTOM)) +#endif + + sp_globals.ymin = (sp_globals.bmap_ymin + sp_globals.pixrnd + 1) >> sp_globals.pixshift; + } + else + { + sp_globals.ymin = sp_globals.ymax = 0; + } + + /* add in the rounded out part (from xform.) of the left edge */ + if (sp_globals.tcb.xmode == 0) /* for X pix is function of X orus only add the round */ + xorg = (((fix31)sp_globals.xmin << 16) + (sp_globals.rnd_xmin << sp_globals.poshift)); + else + if (sp_globals.tcb.xmode == 1) /* for X pix is function of -X orus only, subtr. round */ + xorg = (((fix31)sp_globals.xmin << 16) - (sp_globals.rnd_xmin << sp_globals.poshift)) ; + else + xorg = (fix31)sp_globals.xmin << 16; /* for other cases don't use round on x */ + + if (sp_globals.tcb.ymode == 2) /* for Y pix is function of X orus only, add round error */ + yorg = (((fix31)sp_globals.ymin << 16) + (sp_globals.rnd_xmin << sp_globals.poshift)); + else + if (sp_globals.tcb.ymode == 3) /* for Y pix is function of -X orus only, sub round */ + yorg = (((fix31)sp_globals.ymin << 16) - (sp_globals.rnd_xmin << sp_globals.poshift)); + else /* all other cases have no round error on yorg */ + yorg = (fix31)sp_globals.ymin << 16; + + open_bitmap(sp_globals.set_width.x, sp_globals.set_width.y, xorg, yorg, + sp_globals.xmax - sp_globals.xmin, sp_globals.ymax - sp_globals.ymin); + if (sp_globals.intercept_oflo) + { + sp_globals.y_band.band_min = sp_globals.ymin; + sp_globals.y_band.band_max = sp_globals.ymax; + init_intercepts_out(); + sp_globals.first_pass = FALSE; + sp_globals.extents_running = FALSE; + return FALSE; + } + else + { + sp_proc_intercepts_black(); + close_bitmap(); + return TRUE; + } + } +else + { + if (sp_globals.intercept_oflo) + { + reduce_band_size_out(); + init_intercepts_out(); + return FALSE; + } + else + { + sp_proc_intercepts_black(); + if (next_band_out()) + { + init_intercepts_out(); + return FALSE; + } + close_bitmap(); + return TRUE; + } + } +} +#endif + +#if INCL_BLACK +FUNCTION LOCAL void sp_add_intercept_black( +GDECL +fix15 y, /* Y coordinate in relative pixel units */ + /* (0 is lowest sample in band) */ +fix15 x) /* X coordinate of intercept in subpixel units */ + +/* Called by line() to add an intercept to the intercept list structure + */ + +{ +register fix15 from; /* Insertion pointers for the linked list sort */ +register fix15 to; + +#if DEBUG +printf(" Add intercept(%2d, %d)\n", y + sp_globals.y_band.band_min,x); + +/* Bounds checking IS done in debug mode */ +if (y < 0) /* Y value below bottom of current band? */ + { + printf(" Intecerpt less than 0!!!\007\n"); + return; + } + +if (y > (sp_globals.no_y_lists - 1)) /* Y value above top of current band? */ + { + printf(" Intercept too big for band!!!!!\007\n"); + return; + } +#endif + +/* Store new values */ + +sp_intercepts.car[sp_globals.next_offset] = x; + +/* Find slot to insert new element (between from and to) */ + +from = y; /* Start at list head */ + +while( (to = sp_intercepts.cdr[from]) >= sp_globals.first_offset) /* Until to == end of list */ + { + if (x <= sp_intercepts.car[to]) /* If next item is larger than or same as this one... */ + goto insert_element; /* ... drop out and insert here */ + from = to; /* move forward in list */ + } + +insert_element: /* insert element "sp_globals.next_offset" between elements "from" */ + /* and "to" */ + +sp_intercepts.cdr[from] = sp_globals.next_offset; +sp_intercepts.cdr[sp_globals.next_offset] = to; + +if (++sp_globals.next_offset >= MAX_INTERCEPTS) /* Intercept buffer full? */ + { + sp_globals.intercept_oflo = TRUE; +/* There may be a few more calls to "add_intercept" from the current line */ +/* To avoid problems, we set next_offset to a safe value. We don't care */ +/* if the intercept table gets trashed at this point */ + sp_globals.next_offset = sp_globals.first_offset; + } +} + +#endif + +#if INCL_BLACK +FUNCTION LOCAL void sp_proc_intercepts_black() +GDECL + +/* Called by sp_make_char to output accumulated intercept lists + * Clips output to sp_globals.xmin, sp_globals.xmax, sp_globals.ymin, sp_globals.ymax boundaries + */ +{ +register fix15 i; +register fix15 from, to; /* Start and end of run in pixel units + relative to left extent of character */ +register fix15 y; +register fix15 scan_line; + fix15 first_y, last_y; + +#if DEBUG +printf("\nIntercept lists:\n"); +#endif + +#if INCL_CLIPPING +if ((sp_globals.specs.flags & CLIP_LEFT) != 0) + clipleft = TRUE; +else + clipleft = FALSE; +if ((sp_globals.specs.flags & CLIP_RIGHT) != 0) + clipright = TRUE; +else + clipright = FALSE; +if (clipleft || clipright) + { + xmax = sp_globals.clip_xmax; + xmin = sp_globals.clip_xmin; + } +if (!clipright) + xmax = ((sp_globals.set_width.x+32768L) >> 16); +#endif + +if ((first_y = sp_globals.y_band.band_max) >= sp_globals.ymax) + first_y = sp_globals.ymax - 1; /* Clip to sp_globals.ymax boundary */ + +if ((last_y = sp_globals.y_band.band_min) < sp_globals.ymin) + last_y = sp_globals.ymin; /* Clip to sp_globals.ymin boundary */ + +last_y -= sp_globals.y_band.band_min; +#if DEBUG +/* Print out all of the intercept info */ +scan_line = sp_globals.ymax - first_y - 1; + +for (y = first_y - sp_globals.y_band.band_min; y >= last_y; y--, scan_line++) + { + i = y; /* Index head of intercept list */ + while ((i = sp_intercepts.cdr[i]) != 0) /* Link to next intercept if present */ + { + if ((from = sp_intercepts.car[i] - sp_globals.xmin) < 0) + from = 0; /* Clip to sp_globals.xmin boundary */ + i = sp_intercepts.cdr[i]; /* Link to next intercept */ + if (i == 0) /* End of list? */ + { + printf("****** proc_intercepts: odd number of intercepts\n"); + break; + } + if ((to = sp_intercepts.car[i]) > sp_globals.xmax) + to = sp_globals.xmax - sp_globals.xmin; /* Clip to sp_globals.xmax boundary */ + else + to -= sp_globals.xmin; + printf(" Y = %2d (scanline %2d): %d %d:\n", + y + sp_globals.y_band.band_min, scan_line, from, to); + } + } +#endif + +/* Draw the image */ +scan_line = sp_globals.ymax - first_y - 1; + +for (y = first_y - sp_globals.y_band.band_min; y >= last_y; y--, scan_line++) + { + i = y; /* Index head of intercept list */ + while ((i = sp_intercepts.cdr[i]) != 0) /* Link to next intercept if present */ + { + if ((from = sp_intercepts.car[i] - sp_globals.xmin) < 0) + from = 0; /* Clip to sp_globals.xmin boundary */ + i = sp_intercepts.cdr[i]; /* Link to next intercept */ + + if ((to = sp_intercepts.car[i]) > sp_globals.xmax) + to = sp_globals.xmax - sp_globals.xmin; /* Clip to sp_globals.xmax boundary */ + else + to -= sp_globals.xmin; + if (from >= to) + { + if (from >= sp_globals.xmax - sp_globals.xmin) + { + --from ; + } + to = from+1; + } +#if INCL_CLIPPING + if (clipleft) + { + if (to <= xmin) + continue; + if (from < xmin) + from = xmin; + } + if (clipright) + { + if (from >= xmax) + continue; + if (to > xmax) + to = xmax; + } +#endif + set_bitmap_bits(scan_line, from, to); + } + } +} + +#endif + + + + diff --git a/nx-X11/lib/font/Speedo/out_outl.c b/nx-X11/lib/font/Speedo/out_outl.c new file mode 100644 index 000000000..013901092 --- /dev/null +++ b/nx-X11/lib/font/Speedo/out_outl.c @@ -0,0 +1,290 @@ +/* $Xorg: out_outl.c,v 1.3 2000/08/17 19:46:26 cpqbld Exp $ */ + +/* + +Copyright 1989-1991, Bitstream Inc., Cambridge, MA. +You are hereby granted permission under all Bitstream propriety rights to +use, copy, modify, sublicense, sell, and redistribute the Bitstream Speedo +software and the Bitstream Charter outline font for any purpose and without +restrictions; provided, that this notice is left intact on all copies of such +software or font and that Bitstream's trademark is acknowledged as shown below +on all unmodified copies of such font. + +BITSTREAM CHARTER is a registered trademark of Bitstream Inc. + + +BITSTREAM INC. DISCLAIMS ANY AND ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING +WITHOUT LIMITATION THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE. BITSTREAM SHALL NOT BE LIABLE FOR ANY DIRECT OR INDIRECT +DAMAGES, INCLUDING BUT NOT LIMITED TO LOST PROFITS, LOST DATA, OR ANY OTHER +INCIDENTAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF OR IN ANY WAY CONNECTED +WITH THE SPEEDO SOFTWARE OR THE BITSTREAM CHARTER OUTLINE FONT. + +*/ + + +/**************************** O U T _ 2 _ 1 . C ****************************** + * * + * This is the standard output module for vector output mode. * + * * + ****************************************************************************/ + + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include "spdo_prv.h" /* General definitions for Speedo */ + + +#define DEBUG 0 + +#if DEBUG +#include <stdio.h> +#define SHOW(X) printf("X = %d\n", X) +#else +#define SHOW(X) +#endif + +/* the following macro is used to limit points on the outline to the bounding box */ + +#define RANGECHECK(value,min,max) (((value) >= (min) ? (value) : (min)) < (max) ? (value) : (max)) +/***** GLOBAL VARIABLES *****/ + +/***** GLOBAL FUNCTIONS *****/ + +/***** EXTERNAL VARIABLES *****/ + +/***** EXTERNAL FUNCTIONS *****/ + +/***** STATIC VARIABLES *****/ + +/***** STATIC FUNCTIONS *****/ + + +#if INCL_OUTLINE +FUNCTION boolean init_outline(specsarg) +GDECL +specs_t GLOBALFAR *specsarg; +/* + * init_out2() is called by sp_set_specs() to initialize the output module. + * Returns TRUE if output module can accept requested specifications. + * Returns FALSE otherwise. + */ +{ +#if DEBUG +printf("INIT_OUT_2()\n"); +#endif +if (specsarg->flags & (CLIP_LEFT + CLIP_RIGHT + CLIP_TOP + CLIP_BOTTOM)) + return FALSE; /* Clipping not supported */ +return (TRUE); +} +#endif + +#if INCL_OUTLINE +FUNCTION boolean begin_char_outline(Psw, Pmin, Pmax) +GDECL +point_t Psw; /* End of escapement vector (sub-pixels) */ +point_t Pmin; /* Bottom left corner of bounding box */ +point_t Pmax; /* Top right corner of bounding box */ +/* + * If two or more output modules are included in the configuration, begin_char2() + * is called by begin_char() to signal the start of character output data. + * If only one output module is included in the configuration, begin_char() is + * called by make_simp_char() and make_comp_char(). + */ +{ +fix31 set_width_x; +fix31 set_width_y; +fix31 xmin; +fix31 xmax; +fix31 ymin; +fix31 ymax; + +#if DEBUG +printf("BEGIN_CHAR_2(%3.1f, %3.1f, %3.1f, %3.1f, %3.1f, %3.1f\n", + (real)Psw.x / (real)onepix, (real)Psw.y / (real)onepix, + (real)Pmin.x / (real)onepix, (real)Pmin.y / (real)onepix, + (real)Pmax.x / (real)onepix, (real)Pmax.y / (real)onepix); +#endif +sp_globals.poshift = 16 - sp_globals.pixshift; +set_width_x = (fix31)Psw.x << sp_globals.poshift; +set_width_y = (fix31)Psw.y << sp_globals.poshift; +xmin = (fix31)Pmin.x << sp_globals.poshift; +xmax = (fix31)Pmax.x << sp_globals.poshift; +ymin = (fix31)Pmin.y << sp_globals.poshift; +ymax = (fix31)Pmax.y << sp_globals.poshift; +sp_globals.xmin = Pmin.x; +sp_globals.xmax = Pmax.x; +sp_globals.ymin = Pmin.y; +sp_globals.ymax = Pmax.y; +open_outline(set_width_x, set_width_y, xmin, xmax, ymin, ymax); +return TRUE; +} +#endif + +#if INCL_OUTLINE +FUNCTION void begin_sub_char_outline(Psw, Pmin, Pmax) +GDECL +point_t Psw; /* End of sub-char escapement vector */ +point_t Pmin; /* Bottom left corner of sub-char bounding box */ +point_t Pmax; /* Top right corner of sub-char bounding box */ +/* + * If two or more output modules are included in the configuration, begin_sub_char2() + * is called by begin_sub_char() to signal the start of sub-character output data. + * If only one output module is included in the configuration, begin_sub_char() is + * called by make_comp_char(). + */ +{ +#if DEBUG +printf("BEGIN_SUB_CHAR_2(%3.1f, %3.1f, %3.1f, %3.1f, %3.1f, %3.1f\n", + (real)Psw.x / (real)onepix, (real)Psw.y / (real)onepix, + (real)Pmin.x / (real)onepix, (real)Pmin.y / (real)onepix, + (real)Pmax.x / (real)onepix, (real)Pmax.y / (real)onepix); +#endif +start_new_char(); +} +#endif + + +#if INCL_OUTLINE +FUNCTION void begin_contour_outline(P1, outside) +GDECL +point_t P1; /* Start point of contour */ +boolean outside; /* TRUE if outside (counter-clockwise) contour */ +/* + * If two or more output modules are included in the configuration, begin_contour2() + * is called by begin_contour() to define the start point of a new contour + * and to indicate whether it is an outside (counter-clockwise) contour + * or an inside (clockwise) contour. + * If only one output module is included in the configuration, begin_sub_char() is + * called by proc_outl_data(). + */ +{ +fix15 x,y; +#if DEBUG +printf("BEGIN_CONTOUR_2(%3.1f, %3.1f, %s)\n", + (real)P1.x / (real)onepix, (real)P1.y / (real)onepix, outside? "outside": "inside"); +#endif +x = RANGECHECK(P1.x,sp_globals.xmin,sp_globals.xmax); +y = RANGECHECK(P1.y,sp_globals.ymin,sp_globals.ymax); + +start_contour((fix31)x << sp_globals.poshift, (fix31)y << sp_globals.poshift, outside); +} +#endif + +#if INCL_OUTLINE +FUNCTION void curve_outline(P1, P2, P3,depth) +GDECL +point_t P1; /* First control point of Bezier curve */ +point_t P2; /* Second control point of Bezier curve */ +point_t P3; /* End point of Bezier curve */ +fix15 depth; +/* + * If two or more output modules are included in the configuration, curve2() + * is called by curve() to output one curve segment. + * If only one output module is included in the configuration, curve() is + * called by proc_outl_data(). + * This function is only called when curve output is enabled. + */ +{ +fix15 x1,y1,x2,y2,x3,y3; +#if DEBUG +printf("CURVE_2(%3.1f, %3.1f, %3.1f, %3.1f, %3.1f, %3.1f)\n", + (real)P1.x / (real)onepix, (real)P1.y / (real)onepix, + (real)P2.x / (real)onepix, (real)P2.y / (real)onepix, + (real)P3.x / (real)onepix, (real)P3.y / (real)onepix); +#endif +x1= RANGECHECK(P1.x,sp_globals.xmin,sp_globals.xmax); +y1= RANGECHECK(P1.y,sp_globals.ymin,sp_globals.ymax); + +x2= RANGECHECK(P2.x,sp_globals.xmin,sp_globals.xmax); +y2= RANGECHECK(P2.y,sp_globals.ymin,sp_globals.ymax); + +x3= RANGECHECK(P3.x,sp_globals.xmin,sp_globals.xmax); +y3= RANGECHECK(P3.y,sp_globals.ymin,sp_globals.ymax); + +curve_to((fix31)x1 << sp_globals.poshift, (fix31)y1 << sp_globals.poshift, + (fix31)x2<< sp_globals.poshift, (fix31)y2 << sp_globals.poshift, + (fix31)x3 << sp_globals.poshift, (fix31)y3 << sp_globals.poshift); +} +#endif + +#if INCL_OUTLINE +FUNCTION void line_outline(P1) +GDECL +point_t P1; /* End point of vector */ +/* + * If two or more output modules are included in the configuration, line2() + * is called by line() to output one vector. + * If only one output module is included in the configuration, line() is + * called by proc_outl_data(). If curve output is enabled, line() is also + * called by split_curve(). + */ +{ +fix15 x1,y1; +#if DEBUG +printf("LINE_2(%3.1f, %3.1f)\n", (real)P1.x / (real)onepix, (real)P1.y / (real)onepix); +#endif +x1= RANGECHECK(P1.x,sp_globals.xmin,sp_globals.xmax); +y1= RANGECHECK(P1.y,sp_globals.ymin,sp_globals.ymax); + +line_to((fix31)x1 << sp_globals.poshift, (fix31)y1 << sp_globals.poshift); +} +#endif + +#if INCL_OUTLINE +FUNCTION void end_contour_outline() +GDECL +/* + * If two or more output modules are included in the configuration, end_contour2() + * is called by end_contour() to signal the end of a contour. + * If only one output module is included in the configuration, end_contour() is + * called by proc_outl_data(). + */ +{ +#if DEBUG +printf("END_CONTOUR_2()\n"); +#endif +close_contour(); +} +#endif + + +#if INCL_OUTLINE +FUNCTION void end_sub_char_outline() +GDECL +/* + * If two or more output modules are included in the configuration, end_sub_char2() + * is called by end_sub_char() to signal the end of sub-character data. + * If only one output module is included in the configuration, end_sub_char() is + * called by make_comp_char(). + */ +{ +#if DEBUG +printf("END_SUB_CHAR_2()\n"); +#endif +} +#endif + + +#if INCL_OUTLINE +FUNCTION boolean end_char_outline() +GDECL +/* + * If two or more output modules are included in the configuration, end_char2() + * is called by end_char() to signal the end of the character data. + * If only one output module is included in the configuration, end_char() is + * called by make_simp_char() and make_comp_char(). + * Returns TRUE if output process is complete + * Returns FALSE to repeat output of the transformed data beginning + * with the first contour (of the first sub-char if compound). + */ +{ +#if DEBUG +printf("END_CHAR_2()\n"); +#endif +close_outline(); +return TRUE; +} +#endif + diff --git a/nx-X11/lib/font/Speedo/out_scrn.c b/nx-X11/lib/font/Speedo/out_scrn.c new file mode 100644 index 000000000..0ea3b1976 --- /dev/null +++ b/nx-X11/lib/font/Speedo/out_scrn.c @@ -0,0 +1,1090 @@ +/* $Xorg: out_scrn.c,v 1.3 2000/08/17 19:46:26 cpqbld Exp $ */ + +/* + +Copyright 1989-1991, Bitstream Inc., Cambridge, MA. +You are hereby granted permission under all Bitstream propriety rights to +use, copy, modify, sublicense, sell, and redistribute the Bitstream Speedo +software and the Bitstream Charter outline font for any purpose and without +restrictions; provided, that this notice is left intact on all copies of such +software or font and that Bitstream's trademark is acknowledged as shown below +on all unmodified copies of such font. + +BITSTREAM CHARTER is a registered trademark of Bitstream Inc. + + +BITSTREAM INC. DISCLAIMS ANY AND ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING +WITHOUT LIMITATION THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE. BITSTREAM SHALL NOT BE LIABLE FOR ANY DIRECT OR INDIRECT +DAMAGES, INCLUDING BUT NOT LIMITED TO LOST PROFITS, LOST DATA, OR ANY OTHER +INCIDENTAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF OR IN ANY WAY CONNECTED +WITH THE SPEEDO SOFTWARE OR THE BITSTREAM CHARTER OUTLINE FONT. + +*/ +/* $XFree86: xc/lib/font/Speedo/out_scrn.c,v 1.4 1999/12/27 00:39:25 robin Exp $ */ + + +/*************************** O U T _ S C R N . C ***************************** + * * + * This is an output module for screen-writer mode. * + * * + *****************************************************************************/ + + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include "spdo_prv.h" /* General definitions for Speedo */ + +#define DEBUG 0 +#define LOCAL static +#define ABS(X) ( (X < 0) ? -X : X) + +#if DEBUG +#include <stdio.h> +#define SHOW(X) printf("X = %d\n", X) +#else +#define SHOW(X) +#endif + + +/***** GLOBAL VARIABLES *****/ + +/***** GLOBAL FUNCTIONS *****/ + +/***** EXTERNAL VARIABLES *****/ + +/***** EXTERNAL FUNCTIONS *****/ + +/***** STATIC VARIABLES *****/ + +/***** STATIC FUNCTIONS *****/ + +static void sp_add_intercept_screen(PROTO_DECL2 fix15 y,fix31 x); +static void sp_proc_intercepts_screen(PROTO_DECL1); + + +#if INCL_SCREEN +FUNCTION boolean init_screen( +GDECL +specs_t FONTFAR *specsarg) +/* + * init_out0() is called by sp_set_specs() to initialize the output module. + * Returns TRUE if output module can accept requested specifications. + * Returns FALSE otherwise. + */ +{ +#if DEBUG +printf("INIT_SCREEN()\n"); +#endif +return (TRUE); +} +#endif + + +#if INCL_SCREEN +FUNCTION boolean begin_char_screen( +GDECL +point_t Psw, +point_t Pmin, +point_t Pmax) +/* Called once at the start of the character generation process + */ +{ +#if DEBUG +printf("BEGIN_CHAR_SCREEN(%3.1f, %3.1f, %3.1f, %3.1f, %3.1f, %3.1f\n", + (real)Psw.x / (real)sp_globals.onepix, (real)Psw.y / (real)sp_globals.onepix, + (real)Pmin.x / (real)sp_globals.onepix, (real)Pmin.y / (real)sp_globals.onepix, + (real)Pmax.x / (real)sp_globals.onepix, (real)Pmax.y / (real)sp_globals.onepix); +#endif +if (sp_globals.pixshift > 8) + sp_intercepts.fracpix = sp_globals.onepix << (8 - sp_globals.pixshift); +else + sp_intercepts.fracpix = sp_globals.onepix >> (sp_globals.pixshift - 8); + +init_char_out(Psw,Pmin,Pmax); + +return TRUE; +} +#endif + + +#if INCL_SCREEN +FUNCTION void begin_contour_screen( +GDECL +point_t P1, +boolean outside) +/* Called at the start of each contour + */ +{ + +#if DEBUG +printf("BEGIN_CONTOUR_SCREEN(%3.1f, %3.1f, %s)\n", + (real)P1.x / (real)sp_globals.onepix, (real)P1.y / (real)sp_globals.onepix, outside? "outside": "inside"); +#endif +sp_globals.x0_spxl = P1.x; +sp_globals.y0_spxl = P1.y; +sp_globals.y_pxl = (sp_globals.y0_spxl + sp_globals.pixrnd) >> sp_globals.pixshift; +} +#endif + +#if INCL_SCREEN +FUNCTION void curve_screen( +GDECL +point_t P1, point_t P2, point_t P3, +fix15 depth) +{ +fix31 X0; +fix31 Y0; +fix31 X1; +fix31 Y1; +fix31 X2; +fix31 Y2; +fix31 X3; +fix31 Y3; +#if DEBUG +printf("CURVE_SCREEN(%6.4f, %6.4f, %6.4f, %6.4f, %6.4f, %6.4f)\n", + (real)P1.x / (real)sp_globals.onepix, (real)P1.y / (real)sp_globals.onepix, + (real)P2.x / (real)sp_globals.onepix, (real)P2.y / (real)sp_globals.onepix, + (real)P3.x / (real)sp_globals.onepix, (real)P3.y / (real)sp_globals.onepix); +#endif + + +if (sp_globals.extents_running) /* Accumulate actual character extents if required */ + { + if (P3.x > sp_globals.bmap_xmax) + sp_globals.bmap_xmax = P3.x; + if (P3.x < sp_globals.bmap_xmin) + sp_globals.bmap_xmin = P3.x; + if (P3.y > sp_globals.bmap_ymax) + sp_globals.bmap_ymax = P3.y; + if (P3.y < sp_globals.bmap_ymin) + sp_globals.bmap_ymin = P3.y; + } + +X0 = ((fix31)sp_globals.x0_spxl << sp_globals.poshift) + (fix31)32768; +Y0 = ((fix31)sp_globals.y0_spxl << sp_globals.poshift) + (fix31)32768; +X1 = ((fix31)P1.x << sp_globals.poshift) + (fix31)32768; +Y1 = ((fix31)P1.y << sp_globals.poshift) + (fix31)32768; +X2 = ((fix31)P2.x << sp_globals.poshift) + (fix31)32768; +Y2 = ((fix31)P2.y << sp_globals.poshift) + (fix31)32768; +X3 = ((fix31)P3.x << sp_globals.poshift) + (fix31)32768; +Y3 = ((fix31)P3.y << sp_globals.poshift) + (fix31)32768; + +if (((Y0 - Y3) * sp_globals.tcb.mirror) > 0) + { + sp_intercepts.leftedge = LEFT_INT; + } +else + { + sp_intercepts.leftedge = 0; + } + +scan_curve_screen(X0,Y0,X1,Y1,X2,Y2,X3,Y3); +sp_globals.x0_spxl = P3.x; +sp_globals.y0_spxl = P3.y; +sp_globals.y_pxl = (P3.y + sp_globals.pixrnd) >> sp_globals.pixshift; /* calculate new end-scan sp_globals.line */ +} + +FUNCTION void scan_curve_screen( +GDECL +fix31 X0, fix31 Y0, fix31 X1, fix31 Y1, fix31 X2, fix31 Y2, fix31 X3, fix31 Y3) +/* Called for each curve in the transformed character if curves out enabled + */ +{ +fix31 Pmidx; +fix31 Pmidy; +fix31 Pctrl1x; +fix31 Pctrl1y; +fix31 Pctrl2x; +fix31 Pctrl2y; + +#ifdef DBGCRV +printf("SCAN_CURVE_SCREEN(%6.4f, %6.4f, %6.4f, %6.4f, %6.4f, %6.4f, %6.4f, %6.4f)\n", + (real)(X0-32768) / 65536.0, (real)(Y0-32768) / 65536.0, + (real)(X1-32768) / 65536.0, (real)(Y1-32768) / 65536.0, + (real)(X2-32768) / 65536.0, (real)(Y2-32768) / 65536.0, + (real)(X3-32768) / 65536.0, (real)(Y3-32768) / 65536.0); +#endif + +if (((Y3 >> 16)) == (Y0 >> 16) || (Y3+1) == Y0 || Y3 == (Y0+1)) + { + return; + } +if ((X3 >> 16) == (X0 >> 16)) + { + vert_line_screen(X3,(fix15)(Y0>>16),(fix15)(Y3>>16)); + return; + } +Pmidx = (X0 + (X1 + X2) * 3 + X3 + 4 ) >> 3; +Pmidy = (Y0 + (Y1 + Y2) * 3 + Y3 + 4 ) >> 3; + +Pctrl1x = (X0 + X1 + 1 ) >> 1; +Pctrl1y = (Y0 + Y1 + 1) >> 1; +Pctrl2x = (X0 + (X1 << 1) + X2 + 2 ) >> 2; +Pctrl2y = (Y0 + (Y1 << 1) + Y2 + 2 ) >> 2; +scan_curve_screen(X0,Y0, Pctrl1x, Pctrl1y, Pctrl2x,Pctrl2y, Pmidx,Pmidy); + +Pctrl1x = (X1 + (X2 << 1) + X3 + 2 ) >> 2; +Pctrl1y = (Y1 + (Y2 << 1) + Y3 + 2 ) >> 2; +Pctrl2x = (X2 + X3 + 1 ) >> 1; +Pctrl2y = (Y2 + Y3 + 1 ) >> 1; +scan_curve_screen(Pmidx,Pmidy, Pctrl1x,Pctrl1y, Pctrl2x,Pctrl2y, X3,Y3); +} + +FUNCTION void vert_line_screen( +GDECL +fix31 x, +fix15 y1, fix15 y2) +{ + +#ifdef DBGCRV +printf("VERT_LINE_SCREEN(%6.4f, %6.4f, %6.4f)\n", + (real)(x - 32768) / 65536.0, + (real)(y1 - 32768) / 65536.0, + (real)(y2 - 32768) / 65536.0); +#endif + +if (sp_globals.intercept_oflo) + return; + +if (y1 > y2) /* Line goes downwards ? */ + { + if (y1 > (sp_globals.y_band.band_max + 1)) /* Start point above top of band? */ + y1 = sp_globals.y_band.band_max + 1; /* Adjust start point to top of band */ + if (y2 < sp_globals.y_band.band_min) /* End point below bottom of band? */ + y2 = sp_globals.y_band.band_min; /* Adjust end point bottom of band */ + + y1 -= sp_globals.y_band.band_min; /* Translate start point to band origin */ + y2 -= sp_globals.y_band.band_min; /* Translate end point to band origin */ + + while (y2 < y1) /* At least one intercept left? */ + { + sp_add_intercept_screen(--y1, x); /* Add intercept */ + } + } +else if (y2 > y1) /* Line goes upwards ? */ + { + if (y1 < sp_globals.y_band.band_min) /* Start point below bottom of band? */ + y1 = sp_globals.y_band.band_min; /* Adjust start point to bottom of band */ + if (y2 > (sp_globals.y_band.band_max + 1)) /* End point above top of band? */ + y2 = sp_globals.y_band.band_max + 1; /* Adjust end point to top of band */ + + y1 -= sp_globals.y_band.band_min; /* Translate start point to band origin */ + y2 -= sp_globals.y_band.band_min; /* Translate end point to band origin */ + + while (y1 < y2) /* At least one intercept left? */ + { + sp_add_intercept_screen(y1++, x); /* Add intercept */ + } + } + + +} + +#endif + + +#if INCL_SCREEN +FUNCTION void line_screen( +GDECL +point_t P1) +/* Called for each vector in the transformed character + */ +{ +register fix15 how_many_y; /* # of intercepts at y = n + 1/2 */ +register fix15 yc; /* Current scan-line */ + fix15 temp1; /* various uses */ + fix15 temp2; /* various uses */ +register fix31 dx_dy; /* slope of line in 16.16 form */ +register fix31 xc; /* high-precision (16.16) x coordinate */ + fix15 x0,y0,x1,y1; /* PIX.FRAC start and endpoints */ + +x0 = sp_globals.x0_spxl; /* get start of line (== current point) */ +y0 = sp_globals.y0_spxl; +sp_globals.x0_spxl = x1 = P1.x; /* end of line */ +sp_globals.y0_spxl = y1 = P1.y; /* (also update current point to end of line) */ + +yc = sp_globals.y_pxl; /* current scan line = end of last line */ +sp_globals.y_pxl = (y1 + sp_globals.pixrnd) >> sp_globals.pixshift; /* calculate new end-scan sp_globals.line */ + + +#if DEBUG +printf("LINE_SCREEN(%3.4f, %3.4f)\n", + (real)P1.x/(real)sp_globals.onepix, + (real)P1.y/(real)sp_globals.onepix); +#endif + +if (sp_globals.extents_running) + { + if (sp_globals.x0_spxl > sp_globals.bmap_xmax) + sp_globals.bmap_xmax = sp_globals.x0_spxl; + if (sp_globals.x0_spxl < sp_globals.bmap_xmin) + sp_globals.bmap_xmin = sp_globals.x0_spxl; + if (sp_globals.y0_spxl > sp_globals.bmap_ymax) + sp_globals.bmap_ymax = sp_globals.y0_spxl; + if (sp_globals.y0_spxl < sp_globals.bmap_ymin) + sp_globals.bmap_ymin = sp_globals.y0_spxl; + } + +if (sp_globals.intercept_oflo) return; + +if ((how_many_y = sp_globals.y_pxl - yc) == 0) return; /* Don't draw a null line */ + +xc = (fix31)(x0 + sp_globals.pixrnd) << (16 - sp_globals.pixshift); /* Original x coordinate with built in */ + /* rounding. 16.16 form */ + +if (how_many_y < 0) + { + yc--; /* Predecrment downward lines */ + } + +if ((how_many_y * sp_globals.tcb.mirror) < 0) + { + sp_intercepts.leftedge = LEFT_INT; + } +else + { + sp_intercepts.leftedge = 0; + } + +if (yc > sp_globals.y_band.band_max) /* Is start point above band? */ + { + if (sp_globals.y_pxl > sp_globals.y_band.band_max) return; /* line has to go down! */ + how_many_y = sp_globals.y_pxl - (yc = sp_globals.y_band.band_max) - 1; /* Yes, limit it */ + } + +if (yc < sp_globals.y_band.band_min) /* Is start point below band? */ + { + if (sp_globals.y_pxl < sp_globals.y_band.band_min) return; /* line has to go up! */ + how_many_y = sp_globals.y_pxl - (yc = sp_globals.y_band.band_min); /* Yes, limit it */ + } + +if ( (temp1 = (x1 - x0)) == 0) /* check for vertical line */ + { + dx_dy = 0L; /* Zero slope, leave xc alone */ + goto skip_calc; + } + +/* calculate dx_dy at 16.16 fixed point */ + +dx_dy = ( (fix31)temp1 << 16 )/(fix31)(y1 - y0); + +/* We have to check for a @#$%@# possible multiply overflow */ +/* by doing another @#$*& multiply. In assembly language, */ +/* the program could just check the OVerflow flag or whatever*/ +/* works on the particular processor. This C code is meant */ +/* to be processor independant. */ + +temp1 = (yc << sp_globals.pixshift) - y0 + sp_globals.pixrnd; +/* This sees if the sign bits start at bit 15 */ +/* if they do, no overflow has occurred */ + +temp2 = (fix15)(MULT16(temp1,(fix15)(dx_dy >> 16)) >> 15); + +if ( (temp2 != (fix15)-1) && + (temp2 != 0x0000) ) + { /* Overflow. Pick point closest to yc + .5 */ + if (ABS(temp1) < ABS((yc << sp_globals.pixshift) - y1 + sp_globals.pixrnd)) + { /* use x1 instead of x0 */ + xc = (fix31)(x1 + sp_globals.pixrnd) << (16 - sp_globals.pixshift); + } + goto skip_calc; + } +/* calculate new xc at the center of the *current* scan line */ +/* due to banding, yc may be several lines away from y0 */ +/* xc += (yc + .5 - y0) * dx_dy */ +/* This multiply generates a subpixel delta. */ +/* So we shift it to be a 16.16 delta */ + +xc += ((fix31)temp1 * dx_dy) >> sp_globals.pixshift; + +skip_calc: + +yc -= sp_globals.y_band.band_min; /* yc is now an offset relative to the band */ + +if (how_many_y < 0) + { /* Vector down */ + if ((how_many_y += yc + 1) < 0) how_many_y = 0; /* can't go below 0 */ + while(yc >= how_many_y) + { + sp_add_intercept_screen(yc--,xc); + xc -= dx_dy; + } + } + else + { /* Vector up */ + /* check to see that line doesn't extend beyond top of band */ + if ((how_many_y += yc) > sp_globals.no_y_lists) how_many_y = sp_globals.no_y_lists; + while(yc != how_many_y) + { + sp_add_intercept_screen(yc++,xc); + xc += dx_dy; + } + } +} +#endif + +#if INCL_SCREEN +FUNCTION void end_contour_screen() +GDECL +/* Called after the last vector in each contour + */ +{ +#if DEBUG +printf("END_CONTOUR_SCREEN()\n"); +#endif +sp_intercepts.inttype[sp_globals.next_offset-1] |= END_INT; +} +#endif + + + +#if INCL_SCREEN +FUNCTION boolean end_char_screen() +GDECL +/* Called when all character data has been output + * Return TRUE if output process is complete + * Return FALSE to repeat output of the transformed data beginning + * with the first contour + */ +{ + +fix31 xorg; +fix31 yorg; + +#if INCL_CLIPPING +fix31 em_max, em_min, bmap_max, bmap_min; +#endif + +#if DEBUG +printf("END_CHAR_SCREEN()\n"); +#endif + +if (sp_globals.first_pass) + { + if (sp_globals.bmap_xmax >= sp_globals.bmap_xmin) + { + sp_globals.xmin = (sp_globals.bmap_xmin + sp_globals.pixrnd + 1) >> sp_globals.pixshift; + sp_globals.xmax = (sp_globals.bmap_xmax + sp_globals.pixrnd) >> sp_globals.pixshift; + } + else + { + sp_globals.xmin = sp_globals.xmax = 0; + } + if (sp_globals.bmap_ymax >= sp_globals.bmap_ymin) + { + +#if INCL_CLIPPING + switch(sp_globals.tcb0.xtype) + { + case 1: /* 180 degree rotation */ + if (sp_globals.specs.flags & CLIP_TOP) + { + sp_globals.clip_ymin = (fix31)((fix31)EM_TOP * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_ymin = sp_globals.clip_ymin >> sp_globals.multshift; + bmap_min = (sp_globals.bmap_ymin + sp_globals.pixrnd + 1) >> sp_globals.pixshift; + sp_globals.clip_ymin = -1 * sp_globals.clip_ymin; + if (bmap_min < sp_globals.clip_ymin) + sp_globals.ymin = sp_globals.clip_ymin; + else + sp_globals.ymin = bmap_min; + } + if (sp_globals.specs.flags & CLIP_BOTTOM) + { + sp_globals.clip_ymax = (fix31)((fix31)(-1 * EM_BOT) * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_ymax = sp_globals.clip_ymax >> sp_globals.multshift; + bmap_max = (sp_globals.bmap_ymax + sp_globals.pixrnd) >> sp_globals.pixshift; + if (bmap_max < sp_globals.clip_ymax) + sp_globals.ymax = bmap_max; + else + sp_globals.ymax = sp_globals.clip_ymax; + } + sp_globals.clip_xmax = -sp_globals.xmin; + sp_globals.clip_xmin = ((sp_globals.set_width.x+32768L) >> 16) - + sp_globals.xmin; + break; + case 2: /* 90 degree rotation */ + if (sp_globals.specs.flags & CLIP_TOP) + { + sp_globals.clip_xmin = (fix31)((fix31)(-1 * EM_BOT) * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_xmin = sp_globals.clip_xmin >> sp_globals.multshift; + sp_globals.clip_xmin = -1 * sp_globals.clip_xmin; + bmap_min = (sp_globals.bmap_xmin + sp_globals.pixrnd + 1) >> sp_globals.pixshift; + if (bmap_min > sp_globals.clip_xmin) + sp_globals.clip_xmin = bmap_min; + + /* normalize to x origin */ + sp_globals.clip_xmin -= sp_globals.xmin; + } + if (sp_globals.specs.flags & CLIP_BOTTOM) + { + sp_globals.clip_xmax = (fix31)((fix31)EM_TOP * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_xmax = sp_globals.clip_xmax >> sp_globals.multshift; + bmap_max = (sp_globals.bmap_xmax + sp_globals.pixrnd) >> sp_globals.pixshift; + if (bmap_max < sp_globals.clip_xmax) + sp_globals.xmax = bmap_max; + else + sp_globals.xmax = sp_globals.clip_xmax; + sp_globals.clip_ymax = 0; + if ((sp_globals.specs.flags & CLIP_TOP) && + (sp_globals.ymax > sp_globals.clip_ymax)) + sp_globals.ymax = sp_globals.clip_ymax; + sp_globals.clip_ymin = ((sp_globals.set_width.y+32768L) >> 16); + if ((sp_globals.specs.flags & CLIP_BOTTOM) && + (sp_globals.ymin < sp_globals.clip_ymin)) + sp_globals.ymin = sp_globals.clip_ymin; + /* normalize to x origin */ + sp_globals.clip_xmax -= sp_globals.xmin; + } + break; + case 3: /* 270 degree rotation */ + if (sp_globals.specs.flags & CLIP_TOP) + { + sp_globals.clip_xmin = (fix31)((fix31)EM_TOP * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_xmin = sp_globals.clip_xmin >> sp_globals.multshift; + sp_globals.clip_xmin = -1 * sp_globals.clip_xmin; + bmap_min = (sp_globals.bmap_xmin + sp_globals.pixrnd + 1) >> sp_globals.pixshift; + + /* let the minimum be the larger of these two values */ + if (bmap_min > sp_globals.clip_xmin) + sp_globals.clip_xmin = bmap_min; + + /* normalize the x value to new xorgin */ + sp_globals.clip_xmin -= sp_globals.xmin; + } + if (sp_globals.specs.flags & CLIP_BOTTOM) + { + sp_globals.clip_xmax = (fix31)((fix31)(-1 * EM_BOT) * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_xmax = sp_globals.clip_xmax >> sp_globals.multshift; + bmap_max = (sp_globals.bmap_xmax + sp_globals.pixrnd) >> sp_globals.pixshift; + + /* let the max be the lesser of these two values */ + if (bmap_max < sp_globals.clip_xmax) + { + sp_globals.xmax = bmap_max; + sp_globals.clip_xmax = bmap_max; + } + else + sp_globals.xmax = sp_globals.clip_xmax; + + /* normalize the x value to new x origin */ + sp_globals.clip_xmax -= sp_globals.xmin; + } + /* compute y clip values */ + sp_globals.clip_ymax = ((sp_globals.set_width.y+32768L) >> 16); + if ((sp_globals.specs.flags & CLIP_TOP) && + (sp_globals.ymax > sp_globals.clip_ymax)) + sp_globals.ymax = sp_globals.clip_ymax; + sp_globals.clip_ymin = 0; + if ((sp_globals.specs.flags & CLIP_BOTTOM) && + (sp_globals.ymin < sp_globals.clip_ymin)) + sp_globals.ymin = sp_globals.clip_ymin; + break; + default: /* this is for zero degree rotation and arbitrary rotation */ + if (sp_globals.specs.flags & CLIP_TOP) + { + sp_globals.clip_ymax = (fix31)((fix31)EM_TOP * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_ymax = sp_globals.clip_ymax >> sp_globals.multshift; + bmap_max = (sp_globals.bmap_ymax + sp_globals.pixrnd) >> sp_globals.pixshift; + if (bmap_max > sp_globals.clip_ymax) + sp_globals.ymax = bmap_max; + else + sp_globals.ymax = sp_globals.clip_ymax; + } + if (sp_globals.specs.flags & CLIP_BOTTOM) + { + sp_globals.clip_ymin = (fix31)((fix31)(-1 * EM_BOT) * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_ymin = sp_globals.clip_ymin >> sp_globals.multshift; + sp_globals.clip_ymin = - sp_globals.clip_ymin; + bmap_min = (sp_globals.bmap_ymin + sp_globals.pixrnd + 1) >> sp_globals.pixshift; + if (bmap_min < sp_globals.clip_ymin) + sp_globals.ymin = sp_globals.clip_ymin; + else + sp_globals.ymin = bmap_min; + } + sp_globals.clip_xmin = -sp_globals.xmin; + sp_globals.clip_xmax = ((sp_globals.set_width.x+32768L) >> 16) - + sp_globals.xmin; + break; + } +if ( !(sp_globals.specs.flags & CLIP_TOP)) +#endif + sp_globals.ymax = (sp_globals.bmap_ymax + sp_globals.pixrnd) >> sp_globals.pixshift; + +#if INCL_CLIPPING +if ( !(sp_globals.specs.flags & CLIP_BOTTOM)) +#endif + + sp_globals.ymin = (sp_globals.bmap_ymin + sp_globals.pixrnd + 1) >> sp_globals.pixshift; + } + else + { + sp_globals.ymin = sp_globals.ymax = 0; + } + + /* add in the rounded out part (from xform.) of the left edge */ + if (sp_globals.tcb.xmode == 0) /* for X pix is function of X orus only add the round */ + xorg = (((fix31)sp_globals.xmin << 16) + (sp_globals.rnd_xmin << sp_globals.poshift)); + else + if (sp_globals.tcb.xmode == 1) /* for X pix is function of -X orus only, subtr. round */ + xorg = (((fix31)sp_globals.xmin << 16) - (sp_globals.rnd_xmin << sp_globals.poshift)) ; + else + xorg = (fix31)sp_globals.xmin << 16; /* for other cases don't use round on x */ + + if (sp_globals.tcb.ymode == 2) /* for Y pix is function of X orus only, add round error */ + yorg = (((fix31)sp_globals.ymin << 16) + (sp_globals.rnd_xmin << sp_globals.poshift)); + else + if (sp_globals.tcb.ymode == 3) /* for Y pix is function of -X orus only, sub round */ + yorg = (((fix31)sp_globals.ymin << 16) - (sp_globals.rnd_xmin << sp_globals.poshift)); + else /* all other cases have no round error on yorg */ + yorg = (fix31)sp_globals.ymin << 16; + + open_bitmap(sp_globals.set_width.x, sp_globals.set_width.y, xorg, yorg, + sp_globals.xmax - sp_globals.xmin, sp_globals.ymax - sp_globals.ymin); + if (sp_globals.intercept_oflo) + { + sp_globals.y_band.band_min = sp_globals.ymin; + sp_globals.y_band.band_max = sp_globals.ymax; + init_intercepts_out(); + sp_globals.first_pass = FALSE; + sp_globals.extents_running = FALSE; + return FALSE; + } + else + { + sp_proc_intercepts_screen(); + close_bitmap(); + return TRUE; + } + } +else + { + if (sp_globals.intercept_oflo) + { + reduce_band_size_out(); + init_intercepts_out(); + return FALSE; + } + else + { + sp_proc_intercepts_screen(); + if (next_band_out()) + { + init_intercepts_out(); + return FALSE; + } + close_bitmap(); + return TRUE; + } + } +} +#endif + +#if INCL_SCREEN +FUNCTION LOCAL void sp_add_intercept_screen( +GDECL +fix15 y, /* Y coordinate in relative pixel units */ + /* (0 is lowest sample in band) */ +fix31 x) /* X coordinate of intercept in subpixel units */ + +/* Called by line() to add an intercept to the intercept list structure + */ + +{ +register fix15 from; /* Insertion pointers for the linked list sort */ +register fix15 to; +register fix15 xloc; +register fix15 xfrac; + +#if DEBUG +printf(" Add intercept(%2d, %x)\n", y + sp_globals.y_band.band_min, x); + +/* Bounds checking IS done in debug mode */ +if (y < 0) /* Y value below bottom of current band? */ + { + printf(" Intecerpt less than 0!!!\007\n"); + return; + } + +if (y > (sp_globals.no_y_lists - 1)) /* Y value above top of current band? */ + { + printf(" Intercept too big for band!!!!!\007\n"); + return; + } +#endif + +/* Store new values */ + +sp_intercepts.car[sp_globals.next_offset] = xloc = (fix15)(x >> 16); +sp_intercepts.inttype[sp_globals.next_offset] = sp_intercepts.leftedge | (xfrac = ((x >> 8) & FRACTION)); + +/* Find slot to insert new element (between from and to) */ + +from = y; /* Start at list head */ + +while( (to = sp_intercepts.cdr[from]) != 0) /* Until to == end of list */ + { + if (xloc < sp_intercepts.car[to]) /* If next item is larger than or same as this one... */ + goto insert_element; /* ... drop out and insert here */ + else if (xloc == sp_intercepts.car[to] && xfrac < (sp_intercepts.inttype[to] & FRACTION)) + goto insert_element; /* ... drop out and insert here */ + from = to; /* move forward in list */ + } + +insert_element: /* insert element "sp_globals.next_offset" between elements "from" */ + /* and "to" */ + +sp_intercepts.cdr[from] = sp_globals.next_offset; +sp_intercepts.cdr[sp_globals.next_offset] = to; + +if (++sp_globals.next_offset >= MAX_INTERCEPTS) /* Intercept buffer full? */ + { + sp_globals.intercept_oflo = TRUE; +/* There may be a few more calls to "add_intercept" from the current line */ +/* To avoid problems, we set next_offset to a safe value. We don't care */ +/* if the intercept table gets trashed at this point */ + sp_globals.next_offset = sp_globals.first_offset; + } +} + +#endif + +#if INCL_SCREEN +FUNCTION LOCAL void sp_proc_intercepts_screen() +GDECL + +/* Called by sp_make_char to output accumulated intercept lists + * Clips output to sp_globals.xmin, sp_globals.xmax, sp_globals.ymin, sp_globals.ymax boundaries + */ +{ +register fix15 i,j, jplus1, iminus1; +fix15 k,nextk, previ; +register fix15 from, to; /* Start and end of run in pixel units + relative to left extent of character */ +register fix15 y; +register fix15 scan_line; + fix15 first_y, last_y; + fix15 xsave; + + +fix15 diff; + +#if DEBUG +printf("\nPROC_INTERCEPTS_SCREEN: Intercept lists before:\n"); +#endif + +#if INCL_CLIPPING +if ((sp_globals.specs.flags & CLIP_LEFT) != 0) + clipleft = TRUE; +else + clipleft = FALSE; +if ((sp_globals.specs.flags & CLIP_RIGHT) != 0) + clipright = TRUE; +else + clipright = FALSE; +if (clipleft || clipright) + { + xmax = sp_globals.clip_xmax + sp_globals.xmin; + xmin = sp_globals.clip_xmin + sp_globals.xmin; + } +if (!clipright) + xmax = ((sp_globals.set_width.x+32768L) >> 16); +#endif + +if ((first_y = sp_globals.y_band.band_max) >= sp_globals.ymax) + first_y = sp_globals.ymax - 1; /* Clip to sp_globals.ymax boundary */ + +if ((last_y = sp_globals.y_band.band_min) < sp_globals.ymin) + last_y = sp_globals.ymin; /* Clip to sp_globals.ymin boundary */ + +last_y -= sp_globals.y_band.band_min; + +#if DEBUG +/* Print out all of the intercept info */ +scan_line = sp_globals.ymax - first_y - 1; + +for (y = first_y - sp_globals.y_band.band_min; y >= last_y; y--, scan_line++) + { + i = y; /* Index head of intercept list */ + while ((i = sp_intercepts.cdr[i]) != 0) /* Link to next intercept if present */ + { + if ((from = sp_intercepts.car[i] - sp_globals.xmin) < 0) + from = 0; /* Clip to sp_globals.xmin boundary */ + i = sp_intercepts.cdr[i]; /* Link to next intercept */ + if (i == 0) /* End of list? */ + { + printf("****** proc_intercepts: odd number of intercepts\n"); + break; + } + if ((to = sp_intercepts.car[i]) > sp_globals.xmax) + to = sp_globals.xmax - sp_globals.xmin; /* Clip to sp_globals.xmax boundary */ + else + to -= sp_globals.xmin; + printf(" Y = %2d (scanline %2d): %d %d:\n", + y + sp_globals.y_band.band_min, scan_line, from, to); + } + } +#endif + +/* CHECK INTERCEPT LIST FOR DROPOUT AND WINDING, FIX IF NECESSARY */ + +for (y = first_y - sp_globals.y_band.band_min; y >= last_y; y--) + { + previ = y; + i = sp_intercepts.cdr[y]; /* Index head of intercept list */ + while (i != 0) /* Link to next intercept if present */ + { + j = i; + i = sp_intercepts.cdr[i]; /* Link to next intercept */ + if (sp_intercepts.inttype[i] & LEFT_INT) + { + if (sp_intercepts.inttype[j] & LEFT_INT) + { + do { i = sp_intercepts.cdr[i]; } while (sp_intercepts.inttype[i] & LEFT_INT); + do { i = sp_intercepts.cdr[i]; } while (sp_intercepts.cdr[i] && !(sp_intercepts.inttype[sp_intercepts.cdr[i]] & LEFT_INT)); + sp_intercepts.cdr[j] = i; + } + else + { + xsave = sp_intercepts.car[j]; + sp_intercepts.car[j] = sp_intercepts.car[i]; + sp_intercepts.car[i] = xsave; + + xsave = sp_intercepts.inttype[j]; + sp_intercepts.inttype[j] = sp_intercepts.inttype[i] & FRACTION; + sp_intercepts.inttype[i] = xsave | LEFT_INT; + + sp_intercepts.cdr[previ] = i; + sp_intercepts.cdr[j] = sp_intercepts.cdr[i]; + sp_intercepts.cdr[i] = j; + i = j; + j = sp_intercepts.cdr[previ]; + } + } + + if (sp_intercepts.car[j] < sp_globals.xmin) + sp_intercepts.car[j] = sp_globals.xmin; /* Clip to sp_globals.xmin boundary */ + + if (sp_intercepts.car[i] > sp_globals.xmax) + sp_intercepts.car[i] = sp_globals.xmax; + + if (sp_intercepts.car[j] >= sp_intercepts.car[i]) + { + if ((ufix16)(sp_intercepts.inttype[j] & FRACTION) + (ufix16)(sp_intercepts.inttype[i] & FRACTION) > sp_intercepts.fracpix) + ++sp_intercepts.car[i]; + else + --sp_intercepts.car[j]; + } + if (sp_globals.first_pass) + { + if (sp_intercepts.inttype[i-1] & END_INT) + { + for (iminus1 = i+1; !(sp_intercepts.inttype[iminus1] & END_INT); iminus1++) + ; + } + else + iminus1 = i-1; + + if (sp_intercepts.inttype[j] & END_INT) + { + for (jplus1 = j-1; !(sp_intercepts.inttype[jplus1] & END_INT); jplus1--) + ; + jplus1++; + } + else + jplus1 = j+1; + + if ((sp_intercepts.inttype[iminus1] & LEFT_INT)) + { + if ( sp_intercepts.car[jplus1] > sp_intercepts.car[i]) + { + diff = sp_intercepts.car[jplus1] - sp_intercepts.car[i]; + sp_intercepts.car[i] += diff/2; + sp_intercepts.car[jplus1] -= diff/2; + if (diff & 1) + { + if ((ufix16)(sp_intercepts.inttype[i] & FRACTION) + (ufix16)(sp_intercepts.inttype[jplus1] & FRACTION) > sp_intercepts.fracpix) + sp_intercepts.car[i] ++; + else + sp_intercepts.car[jplus1]--; + } + } + } + else if (!(sp_intercepts.inttype[jplus1] & LEFT_INT)) + { + if (sp_intercepts.car[iminus1] < sp_intercepts.car[j]) + { + diff = sp_intercepts.car[j] - sp_intercepts.car[iminus1]; + sp_intercepts.car[j] -= diff/2; + sp_intercepts.car[iminus1] += diff/2; + if (diff & 1) + { + if ((ufix16)(sp_intercepts.inttype[j] & FRACTION) + + (ufix16)(sp_intercepts.inttype[iminus1] & FRACTION) > sp_intercepts.fracpix) + sp_intercepts.car[iminus1]++; + else + sp_intercepts.car[j]--; + } + } + } + if (sp_globals.tcb.mirror == -1) + { + if (sp_intercepts.inttype[j-1] & END_INT) + { + for (jplus1 = j+1; !(sp_intercepts.inttype[jplus1] & END_INT); jplus1++) + ; + } + else + { + jplus1 = j-1; + } + } + + if (!(sp_intercepts.inttype[jplus1] & LEFT_INT) && + sp_intercepts.car[j] > sp_intercepts.car[jplus1]) + { + k = sp_intercepts.cdr[y - 1]; + while (k > 0) + { + nextk = sp_intercepts.cdr[k]; + if (!(sp_intercepts.inttype[k] & LEFT_INT) && + (sp_intercepts.inttype[nextk] & LEFT_INT) && + sp_intercepts.car[nextk] > sp_intercepts.car[jplus1]) + { + if ((diff=sp_intercepts.car[j] - sp_intercepts.car[k]) > 0) + { + if (diff <= (sp_intercepts.car[nextk] - sp_intercepts.car[jplus1])) + { + sp_intercepts.car[j] -= diff/2; + sp_intercepts.car[k] += diff/2; + if (diff & 1) + { + if ((ufix16)(sp_intercepts.inttype[j] & FRACTION) + + (ufix16)(sp_intercepts.inttype[k] & FRACTION) > sp_intercepts.fracpix) + sp_intercepts.car[j]--; + else + sp_intercepts.car[k]++; + } + } + else + { + diff = sp_intercepts.car[nextk] - sp_intercepts.car[jplus1]; + sp_intercepts.car[nextk] -= diff/2; + sp_intercepts.car[jplus1] += diff/2; + if (diff & 1) + { + if ((ufix16)(sp_intercepts.inttype[jplus1] & FRACTION) + + (ufix16)(sp_intercepts.inttype[nextk] & FRACTION) > sp_intercepts.fracpix) + sp_intercepts.car[nextk]--; + else + sp_intercepts.car[jplus1]++; + } + } + } + break; + } + k = nextk; + } + } + if (j > 0 && sp_intercepts.car[j-1] > sp_intercepts.car[i] && !(sp_intercepts.inttype[j-1] & END_INT)) + { + diff = sp_intercepts.car[j-1] - sp_intercepts.car[i]; + sp_intercepts.car[i] += diff/2; + sp_intercepts.car[j-1] -= diff/2; + if (diff & 1) + { + if ((ufix16)(sp_intercepts.inttype[i] & FRACTION) + (ufix16)(sp_intercepts.inttype[j-1] & FRACTION) > sp_intercepts.fracpix) + sp_intercepts.car[i]++; + else + sp_intercepts.car[j-1]--; + } + } + if (sp_intercepts.car[i+1] < sp_intercepts.car[j] && !(sp_intercepts.inttype[i] & END_INT)) + { + diff = sp_intercepts.car[j] - sp_intercepts.car[i+1]; + sp_intercepts.car[j] -= diff/2; + sp_intercepts.car[i+1] += diff/2; + if (diff & 1) + { + if ((ufix16)(sp_intercepts.inttype[j] & FRACTION) + (ufix16)(sp_intercepts.inttype[i+1] & FRACTION) > sp_intercepts.fracpix) + sp_intercepts.car[i+1]++; + else + sp_intercepts.car[j]--; + } + + } + previ = i; + } + i = sp_intercepts.cdr[i]; + } + } + +#if DEBUG +printf("\nPROC_INTERCEPTS_SCREEN: Intercept lists after:\n"); +/* Print out all of the intercept info */ +scan_line = sp_globals.ymax - first_y - 1; + +for (y = first_y - sp_globals.y_band.band_min; y >= last_y; y--, scan_line++) + { + i = y; /* Index head of intercept list */ + while ((i = sp_intercepts.cdr[i]) != 0) /* Link to next intercept if present */ + { + if ((from = sp_intercepts.car[i] - sp_globals.xmin) < 0) + from = 0; /* Clip to sp_globals.xmin boundary */ + i = sp_intercepts.cdr[i]; /* Link to next intercept */ + if (i == 0) /* End of list? */ + { + printf("****** proc_intercepts: odd number of intercepts\n"); + break; + } + if ((to = sp_intercepts.car[i]) > sp_globals.xmax) + to = sp_globals.xmax - sp_globals.xmin; /* Clip to sp_globals.xmax boundary */ + else + to -= sp_globals.xmin; + printf(" Y = %2d (scanline %2d): %d %d:\n", + y + sp_globals.y_band.band_min, scan_line, from, to); + } + } +#endif + +/* INTERCEPTS ALL PATCHED, NOW DRAW THE IMAGE */ +scan_line = sp_globals.ymax - first_y - 1; + +for (y = first_y - sp_globals.y_band.band_min; y >= last_y; y--, scan_line++) + { + i = sp_intercepts.cdr[y]; /* Index head of intercept list */ + while (i != 0) /* Link to next intercept if present */ + { + from = sp_intercepts.car[i]; + i = sp_intercepts.cdr[i]; /* Link to next intercept */ + to = sp_intercepts.car[i]; +#if INCL_CLIPPING + if (clipleft) + { + if (to <= xmin) + { + i = sp_intercepts.cdr[i]; + continue; + } + if (from < xmin) + from = xmin; + } + if (clipright) + { + if (from >= xmax) + { + i = sp_intercepts.cdr[i]; + continue; + } + if (to > xmax) + to = xmax; + } +#endif + set_bitmap_bits(scan_line, from-sp_globals.xmin, to-sp_globals.xmin); + i = sp_intercepts.cdr[i]; + } + } +} + +#endif diff --git a/nx-X11/lib/font/Speedo/out_util.c b/nx-X11/lib/font/Speedo/out_util.c new file mode 100644 index 000000000..171241030 --- /dev/null +++ b/nx-X11/lib/font/Speedo/out_util.c @@ -0,0 +1,341 @@ +/* $Xorg: out_util.c,v 1.3 2000/08/17 19:46:26 cpqbld Exp $ */ + +/* + +Copyright 1989-1991, Bitstream Inc., Cambridge, MA. +You are hereby granted permission under all Bitstream propriety rights to +use, copy, modify, sublicense, sell, and redistribute the Bitstream Speedo +software and the Bitstream Charter outline font for any purpose and without +restrictions; provided, that this notice is left intact on all copies of such +software or font and that Bitstream's trademark is acknowledged as shown below +on all unmodified copies of such font. + +BITSTREAM CHARTER is a registered trademark of Bitstream Inc. + + +BITSTREAM INC. DISCLAIMS ANY AND ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING +WITHOUT LIMITATION THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE. BITSTREAM SHALL NOT BE LIABLE FOR ANY DIRECT OR INDIRECT +DAMAGES, INCLUDING BUT NOT LIMITED TO LOST PROFITS, LOST DATA, OR ANY OTHER +INCIDENTAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF OR IN ANY WAY CONNECTED +WITH THE SPEEDO SOFTWARE OR THE BITSTREAM CHARTER OUTLINE FONT. + +*/ +/* $XFree86: xc/lib/font/Speedo/out_util.c,v 1.2 1999/02/07 06:18:17 dawes Exp $ */ + + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#define DEBUG 0 + +/*************************** O U T _ U T I L . C ***************************** + * * + * This is a utility module share by all bitmap output modules * + * * + *****************************************************************************/ + + +#include "spdo_prv.h" /* General definitions for Speedo */ +/* absolute value function */ +#define ABS(X) ( (X < 0) ? -X : X) +#if INCL_BLACK || INCL_2D || INCL_SCREEN + +FUNCTION void init_char_out( +GDECL +point_t Psw, point_t Pmin, point_t Pmax) +{ +sp_globals.set_width.x = (fix31)Psw.x << sp_globals.poshift; +sp_globals.set_width.y = (fix31)Psw.y << sp_globals.poshift; +set_first_band_out(Pmin, Pmax); +init_intercepts_out(); +if (sp_globals.normal) + { + sp_globals.bmap_xmin = Pmin.x; + sp_globals.bmap_xmax = Pmax.x; + sp_globals.bmap_ymin = Pmin.y; + sp_globals.bmap_ymax = Pmax.y; + sp_globals.extents_running = FALSE; + } +else + { + sp_globals.bmap_xmin = 32000; + sp_globals.bmap_xmax = -32000; + sp_globals.bmap_ymin = 32000; + sp_globals.bmap_ymax = -32000; + sp_globals.extents_running = TRUE; + } +sp_globals.first_pass = TRUE; +} + +FUNCTION void begin_sub_char_out( +GDECL +point_t Psw, +point_t Pmin, +point_t Pmax) +/* Called at the start of each sub-character in a composite character + */ +{ +#if DEBUG +printf("BEGIN_SUB_CHAR_out(%3.1f, %3.1f, %3.1f, %3.1f, %3.1f, %3.1f\n", + (real)Psw.x / (real)sp_globals.onepix, (real)Psw.y / (real)sp_globals.onepix, + (real)Pmin.x / (real)sp_globals.onepix, (real)Pmin.y / (real)sp_globals.onepix, + (real)Pmax.x / (real)sp_globals.onepix, (real)Pmax.y / (real)sp_globals.onepix); +#endif +restart_intercepts_out(); +if (!sp_globals.extents_running) + { + sp_globals.bmap_xmin = 32000; + sp_globals.bmap_xmax = -32000; + sp_globals.bmap_ymin = 32000; + sp_globals.bmap_ymax = -32000; + sp_globals.extents_running = TRUE; + } +} + +FUNCTION void curve_out( +GDECL +point_t P1, point_t P2, point_t P3, +fix15 depth) +/* Called for each curve in the transformed character if curves out enabled + */ +{ +#if DEBUG +printf("CURVE_OUT(%3.1f, %3.1f, %3.1f, %3.1f, %3.1f, %3.1f)\n", + (real)P1.x / (real)sp_globals.onepix, (real)P1.y / (real)sp_globals.onepix, + (real)P2.x / (real)sp_globals.onepix, (real)P2.y / (real)sp_globals.onepix, + (real)P3.x / (real)sp_globals.onepix, (real)P3.y / (real)sp_globals.onepix); +#endif +} + + + +FUNCTION void end_contour_out() +GDECL +/* Called after the last vector in each contour + */ +{ +#if DEBUG +printf("END_CONTOUR_OUT()\n"); +#endif +} + + +FUNCTION void end_sub_char_out() +GDECL +/* Called after the last contour in each sub-character in a compound character + */ +{ +#if DEBUG +printf("END_SUB_CHAR_OUT()\n"); +#endif +} + + +FUNCTION void init_intercepts_out() +GDECL +/* Called to initialize intercept storage data structure + */ + +{ +fix15 i; +fix15 no_lists; + +#if DEBUG +printf(" Init intercepts (Y band from %d to %d)\n", sp_globals.y_band.band_min, sp_globals.y_band.band_max); +if (sp_globals.x_scan_active) + printf(" (X band from %d to %d)\n", sp_globals.x_band.band_min, sp_globals.x_band.band_max); +#endif + +sp_globals.intercept_oflo = FALSE; + +sp_globals.no_y_lists = sp_globals.y_band.band_max - sp_globals.y_band.band_min + 1; +#if INCL_2D +if (sp_globals.output_mode == MODE_2D) + { + sp_globals.no_x_lists = sp_globals.x_scan_active ? + sp_globals.x_band.band_max - sp_globals.x_band.band_min + 1 : 0; + no_lists = sp_globals.no_y_lists + sp_globals.no_x_lists; + } +else +#endif + no_lists = sp_globals.no_y_lists; + +#if INCL_2D +sp_globals.y_band.band_floor = 0; +sp_globals.y_band.band_ceiling = sp_globals.no_y_lists; +#endif + +if (no_lists >= MAX_INTERCEPTS) /* Not enough room for list table? */ + { + no_lists = sp_globals.no_y_lists = MAX_INTERCEPTS; + sp_globals.intercept_oflo = TRUE; + sp_globals.y_band.band_min = sp_globals.y_band.band_max - sp_globals.no_y_lists + 1; +#if INCL_2D + sp_globals.y_band.band_array_offset = sp_globals.y_band.band_min; + sp_globals.y_band.band_ceiling = sp_globals.no_y_lists; + sp_globals.no_x_lists = 0; + sp_globals.x_scan_active = FALSE; +#endif + } + +for (i = 0; i < no_lists; i++) /* For each active value... */ + { +#if INCL_SCREEN + if (sp_globals.output_mode == MODE_SCREEN) + sp_intercepts.inttype[i]=0; +#endif + sp_intercepts.cdr[i] = 0; /* Mark each intercept list empty */ + } + +sp_globals.first_offset = sp_globals.next_offset = no_lists; + +#if INCL_2D +sp_globals.y_band.band_array_offset = sp_globals.y_band.band_min; +sp_globals.x_band.band_array_offset = sp_globals.x_band.band_min - sp_globals.no_y_lists; +sp_globals.x_band.band_floor = sp_globals.no_y_lists; +sp_globals.x_band.band_ceiling = no_lists; +#endif +#if INCL_SCREEN +sp_intercepts.inttype[sp_globals.no_y_lists-1] = END_INT; +#endif + +} + + +FUNCTION void restart_intercepts_out() +GDECL + +/* Called by sp_make_char when a new sub character is started + * Freezes current sorted lists + */ + +{ + +#if DEBUG +printf(" Restart intercepts:\n"); +#endif +sp_globals.first_offset = sp_globals.next_offset; +} + + + +FUNCTION void set_first_band_out( +GDECL +point_t Pmin, +point_t Pmax) +{ + +sp_globals.ymin = Pmin.y; +sp_globals.ymax = Pmax.y; + +sp_globals.ymin = (sp_globals.ymin - sp_globals.onepix + 1) >> sp_globals.pixshift; +sp_globals.ymax = (sp_globals.ymax + sp_globals.onepix - 1) >> sp_globals.pixshift; + +#if INCL_CLIPPING + switch(sp_globals.tcb0.xtype) + { + case 1: /* 180 degree rotation */ + if (sp_globals.specs.flags & CLIP_TOP) + { + sp_globals.clip_ymin = (fix31)((fix31)EM_TOP * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_ymin = sp_globals.clip_ymin >> sp_globals.multshift; + sp_globals.clip_ymin = -1* sp_globals.clip_ymin; + if (sp_globals.ymin < sp_globals.clip_ymin) + sp_globals.ymin = sp_globals.clip_ymin; + } + if (sp_globals.specs.flags & CLIP_BOTTOM) + { + sp_globals.clip_ymax = (fix31)((fix31)(-1 * EM_BOT) * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_ymax = sp_globals.clip_ymax >> sp_globals.multshift; + if (sp_globals.ymax > sp_globals.clip_ymax) + sp_globals.ymax = sp_globals.clip_ymax; + } + break; + case 2: /* 90 degree rotation */ + sp_globals.clip_ymax = 0; + if ((sp_globals.specs.flags & CLIP_TOP) && + (sp_globals.ymax > sp_globals.clip_ymax)) + sp_globals.ymax = sp_globals.clip_ymax; + sp_globals.clip_ymin = ((sp_globals.set_width.y+32768L) >> 16); + if ((sp_globals.specs.flags & CLIP_BOTTOM) && + (sp_globals.ymin < sp_globals.clip_ymin)) + sp_globals.ymin = sp_globals.clip_ymin; + break; + case 3: /* 270 degree rotation */ + sp_globals.clip_ymax = ((sp_globals.set_width.y+32768L) >> 16); + if ((sp_globals.specs.flags & CLIP_TOP) && + (sp_globals.ymax > sp_globals.clip_ymax)) + sp_globals.ymax = sp_globals.clip_ymax; + sp_globals.clip_ymin = 0; + if ((sp_globals.specs.flags & CLIP_BOTTOM) && + (sp_globals.ymin < sp_globals.clip_ymin)) + sp_globals.ymin = sp_globals.clip_ymin; + break; + default: /* this is for zero degree rotation and arbitrary rotation */ + if (sp_globals.specs.flags & CLIP_TOP) + { + sp_globals.clip_ymax = (fix31)((fix31)EM_TOP * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_ymax = sp_globals.clip_ymax >> sp_globals.multshift; + if (sp_globals.ymax > sp_globals.clip_ymax) + sp_globals.ymax = sp_globals.clip_ymax; + } + if (sp_globals.specs.flags & CLIP_BOTTOM) + { + sp_globals.clip_ymin = (fix31)((fix31)(-1 * EM_BOT) * sp_globals.tcb0.yppo + ((1<<sp_globals.multshift)/2)); + sp_globals.clip_ymin = sp_globals.clip_ymin >> sp_globals.multshift; + sp_globals.clip_ymin = - sp_globals.clip_ymin; + if (sp_globals.ymin < sp_globals.clip_ymin) + sp_globals.ymin = sp_globals.clip_ymin; + } + break; + } +#endif +sp_globals.y_band.band_min = sp_globals.ymin; +sp_globals.y_band.band_max = sp_globals.ymax - 1; + +sp_globals.xmin = (Pmin.x + sp_globals.pixrnd) >> sp_globals.pixshift; +sp_globals.xmax = (Pmax.x + sp_globals.pixrnd) >> sp_globals.pixshift; + + +#if INCL_2D +sp_globals.x_band.band_min = sp_globals.xmin - 1; /* subtract one pixel of "safety margin" */ +sp_globals.x_band.band_max = sp_globals.xmax /* - 1 + 1 */; /* Add one pixel of "safety margin" */ +#endif +} + + + + + + + +FUNCTION void reduce_band_size_out() +GDECL +{ +sp_globals.y_band.band_min = sp_globals.y_band.band_max - ((sp_globals.y_band.band_max - sp_globals.y_band.band_min) >> 1); +#if INCL_2D +sp_globals.y_band.band_array_offset = sp_globals.y_band.band_min; +#endif +} + + +FUNCTION boolean next_band_out() +GDECL +{ +fix15 tmpfix15; + +if (sp_globals.y_band.band_min <= sp_globals.ymin) + return FALSE; +tmpfix15 = sp_globals.y_band.band_max - sp_globals.y_band.band_min; +sp_globals.y_band.band_max = sp_globals.y_band.band_min - 1; +sp_globals.y_band.band_min = sp_globals.y_band.band_max - tmpfix15; +if (sp_globals.y_band.band_min < sp_globals.ymin) + sp_globals.y_band.band_min = sp_globals.ymin; +#if INCL_2D +sp_globals.y_band.band_array_offset = sp_globals.y_band.band_min; +#endif +return TRUE; +} +#endif + diff --git a/nx-X11/lib/font/Speedo/reset.c b/nx-X11/lib/font/Speedo/reset.c new file mode 100644 index 000000000..4cb9f7de0 --- /dev/null +++ b/nx-X11/lib/font/Speedo/reset.c @@ -0,0 +1,131 @@ +/* $Xorg: reset.c,v 1.3 2000/08/17 19:46:26 cpqbld Exp $ */ + +/* + +Copyright 1989-1991, Bitstream Inc., Cambridge, MA. +You are hereby granted permission under all Bitstream propriety rights to +use, copy, modify, sublicense, sell, and redistribute the Bitstream Speedo +software and the Bitstream Charter outline font for any purpose and without +restrictions; provided, that this notice is left intact on all copies of such +software or font and that Bitstream's trademark is acknowledged as shown below +on all unmodified copies of such font. + +BITSTREAM CHARTER is a registered trademark of Bitstream Inc. + + +BITSTREAM INC. DISCLAIMS ANY AND ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING +WITHOUT LIMITATION THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE. BITSTREAM SHALL NOT BE LIABLE FOR ANY DIRECT OR INDIRECT +DAMAGES, INCLUDING BUT NOT LIMITED TO LOST PROFITS, LOST DATA, OR ANY OTHER +INCIDENTAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF OR IN ANY WAY CONNECTED +WITH THE SPEEDO SOFTWARE OR THE BITSTREAM CHARTER OUTLINE FONT. + +*/ +/* $XFree86: xc/lib/font/Speedo/reset.c,v 1.2 1999/02/07 06:18:17 dawes Exp $ */ + + + +/******************************* R E S E T . C ******************************* + * * + * This module provides initialization functions. * + * * + ****************************************************************************/ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include "spdo_prv.h" /* General definitions for Speedo */ +#include "keys.h" /* Font decryption keys */ + +#define DEBUG 0 + +#if DEBUG +#include <stdio.h> +#define SHOW(X) printf("X = %d\n", X) +#else +#define SHOW(X) +#endif + +/***** GLOBAL VARIABLES *****/ + +/***** GLOBAL FUNCTIONS *****/ + +/***** EXTERNAL VARIABLES *****/ + +/***** EXTERNAL FUNCTIONS *****/ + +/***** STATIC VARIABLES *****/ + +/***** STATIC FUNCTIONS *****/ + + +FUNCTION void reset() +GDECL +/* + * Called by the host software to intialize the Speedo mechanism + */ +{ +sp_globals.specs_valid = FALSE; /* Flag specs not valid */ + +/* Reset decryption key */ +sp_globals.key32 = (KEY3 << 8) | KEY2; +sp_globals.key4 = KEY4; +sp_globals.key6 = KEY6; +sp_globals.key7 = KEY7; +sp_globals.key8 = KEY8; + +#if INCL_RULES +sp_globals.constr.font_id_valid = FALSE; +#endif + +#if INCL_MULTIDEV +#if INCL_BLACK || INCL_SCREEN || INCL_2D +sp_globals.bitmap_device_set = FALSE; +#endif +#if INCL_OUTLINE +sp_globals.outline_device_set = FALSE; +#endif +#endif +} + +#if INCL_KEYS +FUNCTION void set_key( +GDECL +ufix8 key[]) /* Specified decryption key */ +/* + * Dynamically sets font decryption key. + */ +{ +sp_globals.key32 = ((ufix16)key[3] << 8) | key[2]; +sp_globals.key4 = key[4]; +sp_globals.key6 = key[6]; +sp_globals.key7 = key[7]; +sp_globals.key8 = key[8]; +} +#endif + + + +FUNCTION ufix16 get_cust_no( +GDECL +buff_t font_buff) +/* + returns customer number from font +*/ +{ +ufix8 FONTFAR *hdr2_org; +ufix16 private_off; + +private_off = read_word_u(font_buff.org + FH_HEDSZ); +if (private_off + FH_CUSNR > font_buff.no_bytes) + { + report_error(1); /* Insufficient font data loaded */ + return FALSE; + } + +hdr2_org = font_buff.org + private_off; + +return (read_word_u(hdr2_org + FH_CUSNR)); +} + + diff --git a/nx-X11/lib/font/Speedo/set_spcs.c b/nx-X11/lib/font/Speedo/set_spcs.c new file mode 100644 index 000000000..b69b13f34 --- /dev/null +++ b/nx-X11/lib/font/Speedo/set_spcs.c @@ -0,0 +1,773 @@ +/* $Xorg: set_spcs.c,v 1.3 2000/08/17 19:46:26 cpqbld Exp $ */ + +/* + +Copyright 1989-1991, Bitstream Inc., Cambridge, MA. +You are hereby granted permission under all Bitstream propriety rights to +use, copy, modify, sublicense, sell, and redistribute the Bitstream Speedo +software and the Bitstream Charter outline font for any purpose and without +restrictions; provided, that this notice is left intact on all copies of such +software or font and that Bitstream's trademark is acknowledged as shown below +on all unmodified copies of such font. + +BITSTREAM CHARTER is a registered trademark of Bitstream Inc. + + +BITSTREAM INC. DISCLAIMS ANY AND ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING +WITHOUT LIMITATION THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE. BITSTREAM SHALL NOT BE LIABLE FOR ANY DIRECT OR INDIRECT +DAMAGES, INCLUDING BUT NOT LIMITED TO LOST PROFITS, LOST DATA, OR ANY OTHER +INCIDENTAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF OR IN ANY WAY CONNECTED +WITH THE SPEEDO SOFTWARE OR THE BITSTREAM CHARTER OUTLINE FONT. + +*/ +/* $XFree86: xc/lib/font/Speedo/set_spcs.c,v 1.3 2001/01/17 19:43:17 dawes Exp $ */ + + +/*************************** S E T _ S P C S . C ***************************** + * * + * This module implements all sp_set_specs() functionality. * + * * + ****************************************************************************/ +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#define SET_SPCS +#include "spdo_prv.h" /* General definitions for Speedo */ +#include "keys.h" + +#define DEBUG 0 + +#if DEBUG +#include <stdio.h> +#define SHOW(X) printf("X = %d\n", X) +#else +#define SHOW(X) +#endif + +/***** GLOBAL VARIABLES *****/ + +/***** GLOBAL FUNCTIONS *****/ + +/****** EXTERNAL VARIABLES *****/ + +/***** STATIC VARIABLES *****/ + + +/****** STATIC FUNCTIONS *****/ + +static boolean sp_setup_consts(PROTO_DECL2 fix15 xmin, fix15 xmax, + fix15 ymin, fix15 ymax); +static void sp_setup_tcb(PROTO_DECL2 tcb_t GLOBALFAR *ptcb); +static fix15 sp_setup_mult(PROTO_DECL2 fix31 input_mult); +static fix31 sp_setup_offset(PROTO_DECL2 fix31 input_offset); + + + +FUNCTION boolean set_specs( +GDECL +specs_t STACKFAR *specsarg) /* Bundle of conversion specifications */ +/* + * Called by host software to set character generation specifications + */ +{ +fix31 offcd; /* Offset to start of character directory */ +fix31 ofcns; /* Offset to start of constraint data */ +fix31 cd_size; /* Size of character directory */ +fix31 no_bytes_min; /* Min number of bytes in font buffer */ +ufix16 font_id; /* Font ID */ +ufix16 private_off; /* offset to private header */ +fix15 xmin; /* Minimum X ORU value in font */ +fix15 xmax; /* Maximum X ORU value in font */ +fix15 ymin; /* Minimum Y ORU value in font */ +fix15 ymax; /* Maximum Y ORU value in font */ + +sp_globals.specs_valid = FALSE; /* Flag specs not valid */ + +sp_globals.specs = *specsarg; /* copy specs structure into sp_globals */ +sp_globals.pspecs = &sp_globals.specs; +sp_globals.font = *sp_globals.pspecs->pfont; +sp_globals.pfont = &sp_globals.font; +sp_globals.font_org = sp_globals.font.org; + +if (read_word_u(sp_globals.font_org + FH_FMVER + 4) != 0x0d0a) + { + report_error(4); /* Font format error */ + return FALSE; + } +if (read_word_u(sp_globals.font_org + FH_FMVER + 6) != 0x0000) + { + report_error(4); /* Font format error */ + return FALSE; + } + +if (get_cust_no(*specsarg->pfont) == 0) + { + sp_globals.key32 = 0; + sp_globals.key4 = 0; + sp_globals.key6 = 0; + sp_globals.key7 = 0; + sp_globals.key8 = 0; + } +else + { + sp_globals.key32 = (KEY3 << 8) | KEY2; + sp_globals.key4 = KEY4; + sp_globals.key6 = KEY6; + sp_globals.key7 = KEY7; + sp_globals.key8 = KEY8; + } + + +sp_globals.no_chars_avail = read_word_u(sp_globals.font_org + FH_NCHRF); + +/* Read sp_globals.orus per em from font header */ +sp_globals.orus_per_em = read_word_u(sp_globals.font_org + FH_ORUPM); + +/* compute address of private header */ +private_off = read_word_u(sp_globals.font_org + FH_HEDSZ); +sp_globals.hdr2_org = sp_globals.font_org + private_off; + +/* set metric resolution if specified, default to outline res otherwise */ +if (private_off > EXP_FH_METRES) + { + sp_globals.metric_resolution = read_word_u(sp_globals.font_org + EXP_FH_METRES); + } +else + { + sp_globals.metric_resolution = sp_globals.orus_per_em; + } + +#if INCL_METRICS +sp_globals.kern.tkorg = sp_globals.font_org + read_long(sp_globals.hdr2_org + FH_OFFTK); +sp_globals.kern.pkorg = sp_globals.font_org + read_long(sp_globals.hdr2_org + FH_OFFPK); +sp_globals.kern.no_tracks = read_word_u(sp_globals.font_org + FH_NKTKS); +sp_globals.kern.no_pairs = read_word_u(sp_globals.font_org + FH_NKPRS); +#endif + +offcd = read_long(sp_globals.hdr2_org + FH_OFFCD); /* Read offset to character directory */ +ofcns = read_long(sp_globals.hdr2_org + FH_OFCNS); /* Read offset to constraint data */ +cd_size = ofcns - offcd; +if ((((sp_globals.no_chars_avail << 1) + 3) != cd_size) && + (((sp_globals.no_chars_avail * 3) + 4) != cd_size)) + { + report_error(4); /* Font format error */ + return FALSE; + } + +#if INCL_LCD /* Dynamic character data load suppoorted? */ +#if INCL_METRICS +no_bytes_min = read_long(sp_globals.hdr2_org + FH_OCHRD); /* Offset to character data */ +#else /* Dynamic character data load not supported? */ +no_bytes_min = read_long(sp_globals.hdr2_org + FH_OFFTK); /* Offset to track kerning data */ +#endif +#else /* Dynamic character data load not supported? */ +no_bytes_min = read_long(sp_globals.hdr2_org + FH_NBYTE); /* Offset to EOF + 1 */ +#endif + +sp_globals.font_buff_size = sp_globals.pfont->no_bytes; +if (sp_globals.font_buff_size < no_bytes_min) /* Minimum data not loaded? */ + { + report_error(1); /* Insufficient font data loaded */ + return FALSE; + } + +sp_globals.pchar_dir = sp_globals.font_org + offcd; +sp_globals.first_char_idx = read_word_u(sp_globals.font_org + FH_FCHRF); + +/* Register font name with sp_globals.constraint mechanism */ +#if INCL_RULES +font_id = read_word_u(sp_globals.font_org + FH_FNTID); +if (!(sp_globals.constr.font_id_valid) || (sp_globals.constr.font_id != font_id)) + { + sp_globals.constr.font_id = font_id; + sp_globals.constr.font_id_valid = TRUE; + sp_globals.constr.data_valid = FALSE; + } +sp_globals.constr.org = sp_globals.font_org + ofcns; +sp_globals.constr.active = ((sp_globals.pspecs->flags & CONSTR_OFF) == 0); +#endif + +/* Set up sliding point constants */ +/* Set pixel shift to accomodate largest transformed pixel value */ +xmin = read_word_u(sp_globals.font_org + FH_FXMIN); +xmax = read_word_u(sp_globals.font_org + FH_FXMAX); +ymin = read_word_u(sp_globals.font_org + FH_FYMIN); +ymax = read_word_u(sp_globals.font_org + FH_FYMAX); + +if (!sp_setup_consts(xmin,xmax,ymin,ymax)) + { + report_error(3); /* Requested specs out of range */ + return FALSE; + } +#if INCL_ISW +/* save the value of the max x oru that the fixed point constants are based on*/ +sp_globals.isw_xmax = xmax; +#endif + +/* Setup transformation control block */ +sp_setup_tcb(&sp_globals.tcb0); + + +/* Select output module */ +sp_globals.output_mode = sp_globals.pspecs->flags & 0x0007; + +#if INCL_USEROUT +if (!init_userout(sp_globals.pspecs)) +#endif + +switch (sp_globals.output_mode) + { +#if INCL_BLACK +case MODE_BLACK: /* Output mode 0 (Black writer) */ + sp_globals.init_out = sp_init_black; + sp_globals.begin_char = sp_begin_char_black; + sp_globals.begin_sub_char = sp_begin_sub_char_out; + sp_globals.begin_contour = sp_begin_contour_black; + sp_globals.curve = sp_curve_out; + sp_globals.line = sp_line_black; + sp_globals.end_contour = sp_end_contour_out; + sp_globals.end_sub_char = sp_end_sub_char_out; + sp_globals.end_char = sp_end_char_black; + break; +#endif + +#if INCL_SCREEN +case MODE_SCREEN: /* Output mode 1 (Screen writer) */ + sp_globals.init_out = sp_init_screen; + sp_globals.begin_char = sp_begin_char_screen; + sp_globals.begin_sub_char = sp_begin_sub_char_out; + sp_globals.begin_contour = sp_begin_contour_screen; + sp_globals.curve = sp_curve_screen; + sp_globals.line = sp_line_screen; + sp_globals.end_contour = sp_end_contour_screen; + sp_globals.end_sub_char = sp_end_sub_char_out; + sp_globals.end_char = sp_end_char_screen; + break; +#endif + +#if INCL_OUTLINE +case MODE_OUTLINE: /* Output mode 2 (Vector) */ + sp_globals.init_out = sp_init_outline; + sp_globals.begin_char = sp_begin_char_outline; + sp_globals.begin_sub_char = sp_begin_sub_char_outline; + sp_globals.begin_contour = sp_begin_contour_outline; + sp_globals.curve = sp_curve_outline; + sp_globals.line = sp_line_outline; + sp_globals.end_contour = sp_end_contour_outline; + sp_globals.end_sub_char = sp_end_sub_char_outline; + sp_globals.end_char = sp_end_char_outline; + break; +#endif + +#if INCL_2D +case MODE_2D: /* Output mode 3 */ + sp_globals.init_out = sp_init_2d; + sp_globals.begin_char = sp_begin_char_2d; + sp_globals.begin_sub_char = sp_begin_sub_char_out; + sp_globals.begin_contour = sp_begin_contour_2d; + sp_globals.curve = sp_curve_out; + sp_globals.line = sp_line_2d; + sp_globals.end_contour = sp_end_contour_out; + sp_globals.end_sub_char = sp_end_sub_char_out; + sp_globals.end_char = sp_end_char_2d; + break; +#endif + +default: + report_error(8); /* Unsupported mode requested */ + return FALSE; + } + + if (!fn_init_out(sp_globals.pspecs)) + { + report_error(5); + return FALSE; + } + + +sp_globals.curves_out = sp_globals.pspecs->flags & CURVES_OUT; + +if (sp_globals.pspecs->flags & BOGUS_MODE) /* Linear transformation requested? */ + { + sp_globals.tcb0.xtype = sp_globals.tcb0.ytype = 4; + } +else /* Intelligent transformation requested? */ + { +#if INCL_RULES +#else + report_error(7); /* Rules requested; not supported */ + return FALSE; +#endif + } + +if ((sp_globals.pspecs->flags & SQUEEZE_LEFT) || + (sp_globals.pspecs->flags & SQUEEZE_RIGHT) || + (sp_globals.pspecs->flags & SQUEEZE_TOP) || + (sp_globals.pspecs->flags & SQUEEZE_BOTTOM) ) + { +#if (INCL_SQUEEZING) +#else + report_error(11); + return FALSE; +#endif + } + +if ((sp_globals.pspecs->flags & CLIP_LEFT) || + (sp_globals.pspecs->flags & CLIP_RIGHT) || + (sp_globals.pspecs->flags & CLIP_TOP) || + (sp_globals.pspecs->flags & CLIP_BOTTOM) ) + { +#if (INCL_CLIPPING) +#else + report_error(11); + return FALSE; +#endif + } + +sp_globals.specs_valid = TRUE; +return TRUE; +} + + + +#if INCL_MULTIDEV +#if INCL_BLACK || INCL_SCREEN || INCL_2D +FUNCTION boolean set_bitmap_device( +GDECL +bitmap_t *bfuncs, +ufix16 size) +{ + +if (size != sizeof(sp_globals.bitmap_device)) + return FALSE; + +sp_globals.bitmap_device = *bfuncs; +sp_globals.bitmap_device_set = TRUE; +} +#endif + +#if INCL_OUTLINE +FUNCTION boolean set_outline_device( +GDECL +outline_t *ofuncs, +ufix16 size) +{ + +if (size != sizeof(sp_globals.outline_device)) + return FALSE; + +sp_globals.outline_device = *ofuncs; +sp_globals.outline_device_set = TRUE; +} +#endif +#endif + + +#ifdef old +FUNCTION boolean sp_setup_consts( +GDECL +fix15 xmin, /* Minimum X ORU value in font */ +fix15 xmax, /* Maximum X ORU value in font */ +fix15 ymin, /* Minimum Y ORU value in font */ +fix15 ymax) /* Maximum Y ORU value in font */ +#else +static FUNCTION boolean sp_setup_consts( +GDECL +fix15 xmin, /* Minimum X ORU value in font */ +fix15 xmax, /* Maximum X ORU value in font */ +fix15 ymin, /* Minimum Y ORU value in font */ +fix15 ymax) /* Maximum Y ORU value in font */ +#endif +/* + * Sets the following constants used for fixed point arithmetic: + * sp_globals.multshift multipliers and products; range is 14 to 8 + * sp_globals.pixshift pixels: range is 0 to 8 + * sp_globals.mpshift shift from product to sub-pixels (sp_globals.multshift - sp_globals.pixshift) + * sp_globals.multrnd rounding for products + * sp_globals.pixrnd rounding for pixels + * sp_globals.mprnd rounding for sub-pixels + * sp_globals.onepix 1 pixel in shifted pixel units + * sp_globals.pixfix mask to eliminate fractional bits of shifted pixels + * sp_globals.depth_adj curve splitting depth adjustment + * Returns FALSE if specs are out of range + */ +{ +fix31 mult; /* Successive multiplier values */ +ufix32 num; /* Numerator of largest multiplier value */ +ufix32 numcopy; /* Copy of numerator */ +ufix32 denom; /* Denominator of largest multiplier value */ +ufix32 denomcopy; /* Copy of denominator */ +ufix32 pix_max; /* Maximum pixel rounding error */ +fix31 xmult; /* Coefficient of X oru value in transformation */ +fix31 ymult; /* Coefficient of Y oru value in transformation */ +fix31 offset; /* Constant in transformation */ +fix15 i; /* Loop counter */ +fix15 x, y; /* Successive corners of bounding box in ORUs */ +fix31 pixval; /* Successive pixel values multiplied by orus per em */ +fix15 xx = 0, yy = 0;/* Bounding box corner that produces max pixel value */ + +/* Determine numerator and denominator of largest multiplier value */ +mult = sp_globals.pspecs->xxmult >> 16; +if (mult < 0) + mult = -mult; +num = mult; + +mult = sp_globals.pspecs->xymult >> 16; +if (mult < 0) + mult = -mult; +if (mult > num) + num = mult; + +mult = sp_globals.pspecs->yxmult >> 16; +if (mult < 0) + mult = -mult; +if (mult > num) + num = mult; + +mult = sp_globals.pspecs->yymult >> 16; +if (mult < 0) + mult = -mult; +if (mult > num) + num = mult; +num++; /* Max absolute pixels per em (rounded up) */ +denom = (ufix32)sp_globals.orus_per_em; + +/* Set curve splitting depth adjustment to accomodate largest multiplier value */ +sp_globals.depth_adj = 0; /* 0 = 0.5 pel, 1 = 0.13 pel, 2 = 0.04 pel accuracy */ +denomcopy = denom; +/* The following two occurances of a strange method of shifting twice by 1 + are intentional and should not be changed to a single shift by 2. + It prevents MicroSoft C 5.1 from generating functions calls to do the shift. + Worse, using the REENTRANT_ALLOC option in conjunction with the /AC compiler + option, the function appears to be called incorrectly, causing depth_adj to always + be set to -7, causing very angular characters. */ + +while ((num > denomcopy) && (sp_globals.depth_adj < 5)) /* > 1, 4, 16, ... pixels per oru? */ + { + denomcopy <<= 1; + denomcopy <<= 1; + sp_globals.depth_adj++; /* Add 1, 2, 3, ... to depth adjustment */ + } +numcopy = num << 2; +while ((numcopy <= denom) && (sp_globals.depth_adj > -4)) /* <= 1/4, 1/16, 1/64 pix per oru? */ + { + numcopy <<= 1; + numcopy <<= 1; + sp_globals.depth_adj--; /* Subtract 1, 2, 3, ... from depth adjustment */ + } +SHOW(sp_globals.depth_adj); + +/* Set multiplier shift to accomodate largest multiplier value */ +sp_globals.multshift = 14; +numcopy = num; +while (numcopy >= denom) /* More than 1, 2, 4, ... pix per oru? */ + { + numcopy >>= 1; + sp_globals.multshift--; /* sp_globals.multshift is 13, 12, 11, ... */ + } + +sp_globals.multrnd = ((fix31)1 << sp_globals.multshift) >> 1; +SHOW(sp_globals.multshift); + + +pix_max = (ufix32)( 0xffff & read_word_u(sp_globals.hdr2_org + FH_PIXMX)); + +num = 0; +xmult = ((sp_globals.pspecs->xxmult >> 16) + 1) >> 1; +ymult = ((sp_globals.pspecs->xymult >> 16) + 1) >> 1; +offset = ((sp_globals.pspecs->xoffset >> 16) + 1) >> 1; +for (i = 0; i < 8; i++) + { + if (i == 4) + { + xmult = ((sp_globals.pspecs->yxmult >> 16) + 1) >> 1; + ymult = ((sp_globals.pspecs->yymult >> 16) + 1) >> 1; + offset = ((sp_globals.pspecs->yoffset >> 16) + 1) >> 1; + } + x = (i & BIT1)? xmin: xmax; + y = (i & BIT0)? ymin: ymax; + pixval = (fix31)x * xmult + (fix31)y * ymult + offset * denom; + if (pixval < 0) + pixval = -pixval; + if (pixval > num) + { + num = pixval; + xx = x; + yy = y; + } + } +if (xx < 0) + xx = -xx; +if (yy < 0) + yy = -yy; +num += xx + yy + ((pix_max + 2) * denom); + /* Allow (with 2:1 safety margin) for 1 pixel rounding errors in */ + /* xmult, ymult and offset values, pix_max pixel expansion */ + /* due to intelligent scaling, and */ + /* 1 pixel rounding of overall character position */ +denom = denom << 14; /* Note num is in units of half pixels times orus per em */ + +sp_globals.pixshift = -1; +while ((num <= denom) && (sp_globals.pixshift < 8)) /* Max pixels <= 32768, 16384, 8192, ... pixels? */ + { + num <<= 1; + sp_globals.pixshift++; /* sp_globals.pixshift = 0, 1, 2, ... */ + } +if (sp_globals.pixshift < 0) + return FALSE; + +SHOW(sp_globals.pixshift); +sp_globals.poshift = 16 - sp_globals.pixshift; + +sp_globals.onepix = (fix15)1 << sp_globals.pixshift; +sp_globals.pixrnd = sp_globals.onepix >> 1; +sp_globals.pixfix = ~0 << sp_globals.pixshift; + +sp_globals.mpshift = sp_globals.multshift - sp_globals.pixshift; +if (sp_globals.mpshift < 0) + return FALSE; +sp_globals.mprnd = ((fix31)1 << sp_globals.mpshift) >> 1; + +return TRUE; +} + +#ifdef old +FUNCTION void sp_setup_tcb( +GDECL +tcb_t GLOBALFAR *ptcb) /* Pointer to transformation control bloxk */ +#else +static FUNCTION void sp_setup_tcb( +GDECL +tcb_t GLOBALFAR *ptcb) /* Pointer to transformation control bloxk */ +#endif +/* + * Convert transformation coeffs to internal form + */ +{ + +ptcb->xxmult = sp_setup_mult(sp_globals.pspecs->xxmult); +ptcb->xymult = sp_setup_mult(sp_globals.pspecs->xymult); +ptcb->xoffset = sp_setup_offset(sp_globals.pspecs->xoffset); +ptcb->yxmult = sp_setup_mult(sp_globals.pspecs->yxmult); +ptcb->yymult = sp_setup_mult(sp_globals.pspecs->yymult); +ptcb->yoffset = sp_setup_offset(sp_globals.pspecs->yoffset); + +SHOW(ptcb->xxmult); +SHOW(ptcb->xymult); +SHOW(ptcb->xoffset); +SHOW(ptcb->yxmult); +SHOW(ptcb->yymult); +SHOW(ptcb->yoffset); + +type_tcb(ptcb); /* Classify transformation type */ +} + +FUNCTION static fix15 sp_setup_mult( +GDECL +fix31 input_mult) /* Multiplier in input format */ +/* + * Called by sp_setup_tcb() to convert multiplier in transformation + * matrix from external to internal form. + */ +{ +fix15 imshift; /* Right shift to internal format */ +fix31 imdenom; /* Divisor to internal format */ +fix31 imrnd; /* Rounding for division operation */ + +imshift = 15 - sp_globals.multshift; +imdenom = (fix31)sp_globals.orus_per_em << imshift; +imrnd = imdenom >> 1; + +input_mult >>= 1; +if (input_mult >= 0) + return (fix15)((input_mult + imrnd) / imdenom); +else + return -(fix15)((-input_mult + imrnd) / imdenom); +} + +FUNCTION static fix31 sp_setup_offset( +GDECL +fix31 input_offset) /* Multiplier in input format */ +/* + * Called by sp_setup_tcb() to convert offset in transformation + * matrix from external to internal form. + */ +{ +fix15 imshift; /* Right shift to internal format */ +fix31 imrnd; /* Rounding for right shift operation */ + +imshift = 15 - sp_globals.multshift; +imrnd = ((fix31)1 << imshift) >> 1; + +return (((input_offset >> 1) + imrnd) >> imshift) + sp_globals.mprnd; +} + +FUNCTION void type_tcb( +GDECL +tcb_t GLOBALFAR *ptcb) /* Pointer to transformation control bloxk */ +{ +fix15 x_trans_type; +fix15 y_trans_type; +fix15 xx_mult; +fix15 xy_mult; +fix15 yx_mult; +fix15 yy_mult; +fix15 h_pos; +fix15 v_pos; +fix15 x_ppo; +fix15 y_ppo; +fix15 x_pos; +fix15 y_pos; + +/* check for mirror image transformations */ +xx_mult = ptcb->xxmult; +xy_mult = ptcb->xymult; +yx_mult = ptcb->yxmult; +yy_mult = ptcb->yymult; + +ptcb->mirror = ((((fix31)xx_mult*(fix31)yy_mult)- + ((fix31)xy_mult*(fix31)yx_mult)) < 0) ? -1 : 1; + +if (sp_globals.pspecs->flags & BOGUS_MODE) /* Linear transformation requested? */ + { + ptcb->xtype = 4; + ptcb->ytype = 4; + + ptcb->xppo = 0; + ptcb->yppo = 0; + ptcb->xpos = 0; + ptcb->ypos = 0; + } +else /* Intelligent tranformation requested? */ + { + h_pos = ((ptcb->xoffset >> sp_globals.mpshift) + sp_globals.pixrnd) & sp_globals.pixfix; + v_pos = ((ptcb->yoffset >> sp_globals.mpshift) + sp_globals.pixrnd) & sp_globals.pixfix; + + x_trans_type = 4; + x_ppo = 0; + x_pos = 0; + + y_trans_type = 4; + y_ppo = 0; + y_pos = 0; + + if (xy_mult == 0) + { + if (xx_mult >= 0) + { + x_trans_type = 0; /* X pix is function of X orus only */ + x_ppo = xx_mult; + x_pos = h_pos; + } + else + { + x_trans_type = 1; /* X pix is function of -X orus only */ + x_ppo = -xx_mult; + x_pos = -h_pos; + } + } + + else if (xx_mult == 0) + { + if (xy_mult >= 0) + { + x_trans_type = 2; /* X pix is function of Y orus only */ + y_ppo = xy_mult; + y_pos = h_pos; + } + else + { + x_trans_type = 3; /* X pix is function of -Y orus only */ + y_ppo = -xy_mult; + y_pos = -h_pos; + } + } + + if (yx_mult == 0) + { + if (yy_mult >= 0) + { + y_trans_type = 0; /* Y pix is function of Y orus only */ + y_ppo = yy_mult; + y_pos = v_pos; + } + else + { + y_trans_type = 1; /* Y pix is function of -Y orus only */ + y_ppo = -yy_mult; + y_pos = -v_pos; + } + } + else if (yy_mult == 0) + { + if (yx_mult >= 0) + { + y_trans_type = 2; /* Y pix is function of X orus only */ + x_ppo = yx_mult; + x_pos = v_pos; + } + else + { + y_trans_type = 3; /* Y pix is function of -X orus only */ + x_ppo = -yx_mult; + x_pos = -v_pos; + } + } + + ptcb->xtype = x_trans_type; + ptcb->ytype = y_trans_type; + + ptcb->xppo = x_ppo; + ptcb->yppo = y_ppo; + ptcb->xpos = x_pos; + ptcb->ypos = y_pos; + } + +sp_globals.normal = (ptcb->xtype != 4) && (ptcb->ytype != 4); + +ptcb->xmode = 4; +ptcb->ymode = 4; + +SHOW(ptcb->xtype); +SHOW(ptcb->ytype); +SHOW(ptcb->xppo); +SHOW(ptcb->yppo); +SHOW(ptcb->xpos); +SHOW(ptcb->ypos); +} + +FUNCTION fix31 read_long( +GDECL +ufix8 FONTFAR *pointer) /* Pointer to first byte of encrypted 3-byte integer */ +/* + * Reads a 3-byte encrypted integer from the byte string starting at + * the specified point. + * Returns the decrypted value read as a signed integer. + */ +{ +fix31 tmpfix31; + +tmpfix31 = (fix31)((*pointer++) ^ sp_globals.key4) << 8; /* Read middle byte */ +tmpfix31 += (fix31)(*pointer++) << 16; /* Read most significant byte */ +tmpfix31 += (fix31)((*pointer) ^ sp_globals.key6); /* Read least significant byte */ +return tmpfix31; +} + +FUNCTION fix15 read_word_u( +GDECL +ufix8 FONTFAR *pointer) /* Pointer to first byte of unencrypted 2-byte integer */ +/* + * Reads a 2-byte unencrypted integer from the byte string starting at + * the specified point. + * Returns the decrypted value read as a signed integer. + */ +{ +fix15 tmpfix15; + +tmpfix15 = (fix15)(*pointer++) << 8; /* Read most significant byte */ +tmpfix15 += (fix15)(*pointer); /* Add least significant byte */ +return tmpfix15; +} + + diff --git a/nx-X11/lib/font/Speedo/set_trns.c b/nx-X11/lib/font/Speedo/set_trns.c new file mode 100644 index 000000000..3b8f60378 --- /dev/null +++ b/nx-X11/lib/font/Speedo/set_trns.c @@ -0,0 +1,1324 @@ +/* $Xorg: set_trns.c,v 1.3 2000/08/17 19:46:27 cpqbld Exp $ */ + +/* + +Copyright 1989-1991, Bitstream Inc., Cambridge, MA. +You are hereby granted permission under all Bitstream propriety rights to +use, copy, modify, sublicense, sell, and redistribute the Bitstream Speedo +software and the Bitstream Charter outline font for any purpose and without +restrictions; provided, that this notice is left intact on all copies of such +software or font and that Bitstream's trademark is acknowledged as shown below +on all unmodified copies of such font. + +BITSTREAM CHARTER is a registered trademark of Bitstream Inc. + + +BITSTREAM INC. DISCLAIMS ANY AND ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING +WITHOUT LIMITATION THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE. BITSTREAM SHALL NOT BE LIABLE FOR ANY DIRECT OR INDIRECT +DAMAGES, INCLUDING BUT NOT LIMITED TO LOST PROFITS, LOST DATA, OR ANY OTHER +INCIDENTAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF OR IN ANY WAY CONNECTED +WITH THE SPEEDO SOFTWARE OR THE BITSTREAM CHARTER OUTLINE FONT. + +*/ +/* $XFree86: xc/lib/font/Speedo/set_trns.c,v 1.5tsi Exp $ */ + + + +/*************************** S E T _ T R N S . C ***************************** + * * + * This module is called from do_char.c to set up the intelligent * + * transformation for one character (or sub-character of a composite * + * character. + * * + ****************************************************************************/ + + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include "spdo_prv.h" /* General definitions for Speedo */ + +#define DEBUG 0 + +#if DEBUG +#include <stdio.h> +#define SHOW(X) printf("X = %d\n", X) +#else +#define SHOW(X) +#endif +/***** LOCAL MACROS *****/ + +#define SQUEEZE_X_ORU(A,B,C) ((((fix31)A * (fix31)B) + C) >> 16) +#define ABS(A) ((A < 0)? -A:A) /* absolute value */ +#define IMPORT_FACTOR \ + shift = 16;\ + while (*x_factor > (0x7fffffffL / (isw_scale >> (16 - shift))))\ + shift--;\ + *x_factor = (*x_factor * (isw_scale>>(16-shift))) >> shift; + +/***** GLOBAL VARIABLES *****/ + +/***** GLOBAL FUNCTIONS *****/ + +/***** EXTERNAL VARIABLES *****/ + +/***** EXTERNAL FUNCTIONS *****/ + +/***** STATIC VARIABLES *****/ + +/***** STATIC FUNCTIONS *****/ + +static void sp_constr_update(PROTO_DECL1); +static ufix8 FONTFAR *sp_setup_pix_table(PROTO_DECL2 ufix8 FONTFAR *pointer,boolean short_form,fix15 no_X_ctrl_zones,fix15 no_Y_ctrl_zones); +static ufix8 FONTFAR *sp_setup_int_table(PROTO_DECL2 ufix8 FONTFAR *pointer,fix15 no_X_int_zones,fix15 no_Y_int_zones); + + +FUNCTION void init_tcb() +GDECL +/* + * Called by sp_make_char() and make_comp_char() to initialize the current + * transformation control block to the top level transformation. + */ +{ +sp_globals.tcb = sp_globals.tcb0; +} + +FUNCTION void scale_tcb( +GDECL +tcb_t GLOBALFAR *ptcb, /* Transformation control block */ +fix15 x_pos, /* X position (outline res units) */ +fix15 y_pos, /* Y position (outline res units) */ +fix15 x_scale, /* X scale factor * ONE_SCALE */ +fix15 y_scale) /* Y scale factor * ONE_SCALE */ +/* + * Called by make_comp_char() to apply position and scale for each of the + * components of a compound character. + */ +{ +fix15 xx_mult = ptcb->xxmult; +fix15 xy_mult = ptcb->xymult; +fix31 x_offset = ptcb->xoffset; +fix15 yx_mult = ptcb->yxmult; +fix15 yy_mult = ptcb->yymult; +fix31 y_offset = ptcb->yoffset; + +ptcb->xxmult = TRANS(xx_mult, x_scale, (fix31)SCALE_RND, SCALE_SHIFT); +ptcb->xymult = TRANS(xy_mult, y_scale, (fix31)SCALE_RND, SCALE_SHIFT); +ptcb->xoffset = MULT16(xx_mult, x_pos) + MULT16(xy_mult, y_pos) + x_offset; +ptcb->yxmult = TRANS(yx_mult, x_scale, (fix31)SCALE_RND, SCALE_SHIFT); +ptcb->yymult = TRANS(yy_mult, y_scale, (fix31)SCALE_RND, SCALE_SHIFT); +ptcb->yoffset = MULT16(yx_mult, x_pos) + MULT16(yy_mult, y_pos) + y_offset; + +type_tcb(ptcb); /* Reclassify transformation types */ +} + +FUNCTION ufix8 FONTFAR *skip_interpolation_table( +GDECL +ufix8 FONTFAR *pointer, /* Pointer to next byte in char data */ +ufix8 format) /* Character format byte */ +{ +fix15 i,n; +ufix8 intsize[9]; + +intsize[0] = 1; +intsize[1] = 2; +intsize[2] = 3; +intsize[3] = 1; +intsize[4] = 2; +intsize[5] = 1; +intsize[6] = 2; +intsize[7] = 0; +intsize[8] = 0; + +n = ((format & BIT6)? (fix15)NEXT_BYTE(pointer): 0); +n += ((format & BIT7)? (fix15)NEXT_BYTE(pointer): 0); +for (i = 0; i < n; i++) /* For each entry in int table ... */ + { + format = NEXT_BYTE(pointer); /* Read format byte */ + if (format & BIT7) /* Short Start/End point spec? */ + { + pointer++; /* Skip Start/End point byte */ + } + else + { + pointer += intsize[format & 0x7]; /* Skip Start point spec */ + pointer += intsize[(format >> 3) & 0x7]; /* Skip End point spec */ + } + } +return pointer; +} +FUNCTION ufix8 FONTFAR *skip_control_zone( +GDECL +ufix8 FONTFAR *pointer, /* Pointer to next byte in char data */ +ufix8 format) /* Character format byte */ +{ +fix15 i,n; +ufix16 tmpufix16; + +n = sp_globals.no_X_orus + sp_globals.no_Y_orus - 2; +for (i = 0; i < n; i++) /* For each entry in control table ... */ + { + if (format & BIT4) + pointer++; /* Skip short form From/To fields */ + else + pointer += 2; /* Skip FROM and TO fields */ + /* skip constraints field */ + NEXT_BYTES (pointer, tmpufix16); + + } +return pointer; +} + +#if INCL_RULES +#else +FUNCTION ufix8 FONTFAR *plaid_tcb( +GDECL +ufix8 FONTFAR *pointer, /* Pointer to next byte in char data */ +ufix8 format) /* Character format byte */ +/* + * Called by make_simp_char() and make_comp_char() to set up the controlled + * coordinate table and skip all other intelligent scaling rules embedded + * in the character data. + * Updates pointer to first byte after plaid data. + * This is used only if intelligent scaling is not supported in the + * configuration definitions. + */ +{ +fix15 i, n; + + + +sp_globals.no_X_orus = (format & BIT2)? + (fix15)NEXT_BYTE(pointer): + 0; +sp_globals.no_Y_orus = (format & BIT3)? + (fix15)NEXT_BYTE(pointer): + 0; +pointer = read_oru_table(pointer); /* Updates no_X/Y/orus */ +sp_globals.Y_edge_org = sp_globals.no_X_orus; + +/* Skip over control zone table */ +pointer = skip_control_zone(pointer,format); + +/* Skip over interpolation table */ +pointer = skip_interpolation_table(pointer,format); +return pointer; +} +#endif + +#if INCL_RULES +FUNCTION ufix8 FONTFAR *plaid_tcb( +GDECL +ufix8 FONTFAR *pointer, /* Pointer to next byte in char data */ +ufix8 format) /* Character format byte */ +/* + * Called by make_simp_char() and make_comp_char() to set up the controlled + * coordinate table and process all intelligent scaling rules embedded + * in the character data. + * Updates pointer to first byte after plaid data. + * This is used only if intelligent scaling is enabled in the + * configuration definitions. + */ +{ +fix15 no_X_ctrl_zones; +fix15 no_Y_ctrl_zones; +fix15 no_X_int_zones; +fix15 no_Y_int_zones; + +#if INCL_PLAID_OUT /* Plaid data monitoring included? */ +begin_plaid_data(); +#endif + +sp_constr_update(); /* Update constraint table if required */ + +sp_globals.no_X_orus = (format & BIT2)? + (fix15)NEXT_BYTE(pointer): + 0; +sp_globals.no_Y_orus = (format & BIT3)? + (fix15)NEXT_BYTE(pointer): + 0; +pointer = read_oru_table(pointer); /* Updates no_X/Y/orus to include zero values */ +sp_globals.Y_edge_org = sp_globals.no_X_orus; +if (sp_globals.no_X_orus > 1) /* 2 or more controlled X coordinates? */ + sp_globals.tcb.xmode = sp_globals.tcb.xtype; /* Enable intelligent scaling in X */ + +if (sp_globals.no_Y_orus > 1) /* 2 or more controlled Y coordinates? */ + sp_globals.tcb.ymode = sp_globals.tcb.ytype; /* Enable intelligent scaling in Y */ + +no_X_ctrl_zones = sp_globals.no_X_orus - 1; +no_Y_ctrl_zones = sp_globals.no_Y_orus - 1; +pointer = sp_setup_pix_table(pointer, (boolean)(format & BIT4), + no_X_ctrl_zones, no_Y_ctrl_zones); + +no_X_int_zones = (format & BIT6)? + (fix15)NEXT_BYTE(pointer): + 0; +no_Y_int_zones = (format & BIT7)? + (fix15)NEXT_BYTE(pointer): + 0; +sp_globals.Y_int_org = no_X_int_zones; +pointer = sp_setup_int_table(pointer, no_X_int_zones, no_Y_int_zones); + +#if INCL_PLAID_OUT /* Plaid data monitoring included? */ +end_plaid_data(); +#endif + +return pointer; +} +#endif + +#if INCL_RULES +FUNCTION static void sp_constr_update() +GDECL +/* + * Called by plaid_tcb() to update the constraint table for the current + * transformation. + * This is always carried out whenever a character is generated following + * a change of font or scale factor or after initialization. + */ +{ +fix31 ppo; +fix15 xppo; +fix15 yppo; +ufix8 FONTFAR *pointer; +fix15 no_X_constr; +fix15 no_Y_constr; +fix15 i, j, k, l, n; +fix15 ppm; +ufix8 format; +ufix8 format1; +fix15 limit; +ufix16 constr_org; +fix15 constr_nr; +fix15 size; +fix31 off; +fix15 min; +fix15 orus; +fix15 pix; +ufix16 tmpufix16; /* in extended mode, macro uses secnd term */ + +if (sp_globals.constr.data_valid && /* Constr table already done and ... */ + (sp_globals.tcb.xppo == sp_globals.constr.xppo) && /* ... X pix per oru unchanged and ... */ + (sp_globals.tcb.yppo == sp_globals.constr.yppo)) /* ... Y pix per oru unchanged? */ + { + return; /* No need to update constraint table */ + } + +sp_globals.constr.xppo = xppo = sp_globals.tcb.xppo; /* Update X pixels per oru indicator */ +sp_globals.constr.yppo = yppo = sp_globals.tcb.yppo; /* Update Y pixels per oru indicator */ +sp_globals.constr.data_valid = TRUE; /* Mark constraint table valid */ + +pointer = sp_globals.constr.org; /* Point to first byte of constraint data */ +no_X_constr = NEXT_BYTES(pointer, tmpufix16); /* Read nmbr of X constraints */ +no_Y_constr = NEXT_BYTES(pointer, tmpufix16); /* Read nmbr of Y constraints */ + +i = 0; +constr_org = 0; +n = no_X_constr; +ppo = xppo; +for (j = 0; ; j++) + { + sp_globals.c_act[i] = FALSE; /* Flag constraint 0 not active */ + sp_globals.c_pix[i++] = 0; /* Constraint 0 implies no minimum */ + sp_globals.c_act[i] = FALSE; /* Flag constraint 1 not active */ + sp_globals.c_pix[i++] = sp_globals.onepix; /* Constraint 1 implies min 1 pixel*/ + ppm = (ppo * (fix31)sp_globals.orus_per_em) >> sp_globals.multshift; + for (k = 0; k < n; k++) + { + format = NEXT_BYTE(pointer); /* Read format byte */ + limit = (fix15)NEXT_BYTE(pointer); /* Read limit field */ + sp_globals.c_act[i] = + ((ppm < limit) || (limit == 255)) && + sp_globals.constr.active; + if (sp_globals.c_act[i]) /* Constraint active? */ + { + if ((format & BIT1) && /* Constraint specified and ... */ + (constr_nr = constr_org + + ((format & BIT0)? /* Read unsigned constraint value */ + NEXT_WORD(pointer): + (fix15)NEXT_BYTE(pointer)), + sp_globals.c_act[constr_nr])) /* ... and specified constraint active? */ + { + pix = sp_globals.c_pix[constr_nr]; /* Use constrained pixel value */ + format1 = format; + for (l = 2; l > 0; l--) /* Skip 2 arguments */ + { + format1 >>= 2; + if ((size = format1 & 0x03)) + pointer += size - 1; + } + } + else /* Constraint absent or inactive? */ + { + orus = (format & BIT2)? /* Read unsigned oru value */ + NEXT_WORD(pointer): + (fix15)NEXT_BYTE(pointer); + + if (format & BIT5) /* Specified offset value? */ + { + off = (fix31)((format & BIT4)? /* Read offset value */ + NEXT_WORD(pointer): + (fix7)NEXT_BYTE(pointer)); + off = (off << (sp_globals.multshift - 6)) + sp_globals.multrnd; + } + else /* Unspecified (zero) offset value? */ + { + off = sp_globals.multrnd; + } + + pix = (fix15)(((fix31)orus * ppo + off) / (1 << sp_globals.mpshift)) & sp_globals.pixfix; + } + } + else /* Constraint inactive? */ + { + format1 = format; + for (l = 3; l > 0; l--) /* Skip over 3 arguments */ + { + if ((size = format1 & 0x03)) + pointer += size - 1; + format1 >>= 2; + } + pix = 0; + } + + if (format & 0xc0) /* Specified minimum value? */ + { + min = (format & BIT7)? /* Read unsigned minimum value */ + (fix15)NEXT_BYTE(pointer) << sp_globals.pixshift: + sp_globals.onepix; + } + else /* Unspecified (zero) minimum value? */ + { + min = 0; + } + + sp_globals.c_pix[i] = (pix < min)? min: pix; + i++; + } + if (j) break; /* Finished if second time around loop */ + constr_org = sp_globals.Y_constr_org = i; + n = no_Y_constr; + ppo = yppo; + } + +#if DEBUG +printf("\nCONSTRAINT TABLE\n"); +n = no_X_constr + 2; +for (i = 0; i < n; i++) + { + printf("%3d ", i); + if (sp_globals.c_act[i]) + { + printf("T "); + } + else + { + printf("F "); + } + printf("%5.1f\n", ((real)sp_globals.c_pix[i] / (real)sp_globals.onepix)); + } +printf("--------------\n"); +n = no_Y_constr + 2; +for (i = 0; i < n; i++) + { + j = i + sp_globals.Y_constr_org; + printf("%3d ", i); + if (sp_globals.c_act[j]) + { + printf("T "); + } + else + { + printf("F "); + } + printf("%5.1f\n", ((real)sp_globals.c_pix[j] / (real)sp_globals.onepix)); + } +#endif + +} +#endif + +FUNCTION ufix8 FONTFAR *read_oru_table( +GDECL +ufix8 FONTFAR *pointer) /* Pointer to first byte in controlled coord table */ +/* + * Called by plaid_tcb() to read the controlled coordinate table from the + * character data in the font. + * Updates the pointer to the byte following the controlled coordinate + * data. + */ +{ +fix15 i, j, k, n; +boolean zero_not_in; +boolean zero_added; +fix15 oru; + +#if INCL_RULES +fix15 pos; +#endif + +i = 0; +n = sp_globals.no_X_orus; +#if INCL_RULES +pos = sp_globals.tcb.xpos; +#endif +for (j = 0; ; j++) + { + zero_not_in = TRUE; + zero_added = FALSE; + for (k = 0; k < n; k++) + { + oru = NEXT_WORD(pointer); + if (zero_not_in && (oru >= 0)) /* First positive oru value? */ + { +#if INCL_RULES + sp_plaid.pix[i] = pos; /* Insert position in pix array */ +#endif + if (oru != 0) /* Zero oru value omitted? */ + { + sp_plaid.orus[i++] = 0; /* Insert zero value in oru array */ + zero_added = TRUE; /* Remember to increment size of array */ + } + zero_not_in = FALSE; /* Inhibit further testing for zero ins */ + } + sp_plaid.orus[i++] = oru; /* Add specified oru value to array */ + } + if (zero_not_in) /* All specified oru values negative? */ + { +#if INCL_RULES + sp_plaid.pix[i] = pos; /* Insert position in pix array */ +#endif + sp_plaid.orus[i++] = 0; /* Add zero oru value */ + zero_added = TRUE; /* Remember to increment size of array */ + } + if (j) /* Both X and Y orus read? */ + break; + if (zero_added) + sp_globals.no_X_orus++; /* Increment X array size */ + n = sp_globals.no_Y_orus; /* Prepare to read Y oru values */ +#if INCL_RULES + pos = sp_globals.tcb.ypos; +#endif + } +if (zero_added) /* Zero Y oru value added to array? */ + sp_globals.no_Y_orus++; /* Increment Y array size */ + +#if DEBUG +printf("\nX ORUS\n"); +n = sp_globals.no_X_orus; +for (i = 0; i < n; i++) + { + printf("%2d %4d\n", i, sp_plaid.orus[i]); + } +printf("\nY ORUS\n"); +n = sp_globals.no_Y_orus; +for (i = 0; i < n; i++) + { + printf("%2d %4d\n", i, sp_plaid.orus[i + sp_globals.no_X_orus]); + } +#endif + +return pointer; /* Update pointer */ +} +#if INCL_SQUEEZING || INCL_ISW +FUNCTION static void calculate_x_pix( +GDECL +ufix8 start_edge, ufix8 end_edge, +ufix16 constr_nr, +fix31 x_scale, +fix31 x_offset, +fix31 ppo, +fix15 setwidth_pix) +/* + * Called by sp_setup_pix_table() when X squeezing is necessary + * to insert the correct edge in the global pix array + */ +{ +fix15 zone_pix; +fix15 start_oru, end_oru; + +/* compute scaled oru coordinates */ +start_oru= (fix15)(SQUEEZE_X_ORU(sp_plaid.orus[start_edge], x_scale, x_offset)); +end_oru = (fix15)(SQUEEZE_X_ORU(sp_plaid.orus[end_edge], x_scale, x_offset)); + +if (!sp_globals.c_act[constr_nr]) /* constraint inactive */ + { + /* calculate zone width */ + zone_pix = (fix15)(((((fix31)end_oru - (fix31)start_oru) * ppo) / + (1<<sp_globals.mpshift)) + sp_globals.pixrnd) & sp_globals.pixfix; + /* check for overflow */ + if (((end_oru-start_oru) > 0) && (zone_pix < 0)) + zone_pix = 0x7ffff; + /* check for minimum */ + if ((ABS(zone_pix)) >= sp_globals.c_pix[constr_nr]) + goto Lx; + } +/* use the zone size from the constr table - scale it */ +zone_pix = (fix15)(((SQUEEZE_MULT(x_scale,sp_globals.c_pix[constr_nr])) + + sp_globals.pixrnd) & sp_globals.pixfix); + +/* look for overflow */ +if ((sp_globals.c_pix[constr_nr] > 0) && (zone_pix < 0)) + zone_pix = 0x7fff; + +if (start_edge > end_edge) + { + zone_pix = -zone_pix; + } +Lx: +/* assign pixel value to global pix array */ +sp_plaid.pix[end_edge]=sp_plaid.pix[start_edge] + zone_pix; + +/* check for overflow */ +if (((sp_plaid.pix[start_edge] >0) && (zone_pix >0)) && + (sp_plaid.pix[end_edge] < 0)) + sp_plaid.pix[end_edge] = 0x7fff; /* set it to the max */ + +/* be sure to be in the setwidth !*/ +#if INCL_ISW +if (!sp_globals.import_setwidth_act) /* only check left edge if not isw only */ +#endif +if ((sp_globals.pspecs->flags & SQUEEZE_LEFT) && (sp_plaid.pix[end_edge] < 0)) + sp_plaid.pix[end_edge] = 0; +if ((sp_globals.pspecs->flags & SQUEEZE_RIGHT) && + (sp_plaid.pix[end_edge] > setwidth_pix)) + sp_plaid.pix[end_edge] = setwidth_pix; + +} +#endif + +#if INCL_SQUEEZING +FUNCTION static void calculate_y_pix( +GDECL +ufix8 start_edge, ufix8 end_edge, +ufix16 constr_nr, +fix31 top_scale, fix31 bottom_scale, +fix31 ppo, +fix15 em_top_pix, fix15 em_bot_pix) + +/* + * Called by sp_setup_pix_table() when Y squeezing is necessary + * to insert the correct edge in the global pix array + */ +{ +fix15 zone_pix; +fix15 start_oru, end_oru; +fix31 zone_width, above_base, below_base; + +/* check whether edge is above or below the baseline */ +/* and apply appropriate scale factor to get scaled oru coordinates */ +if (sp_plaid.orus[start_edge] < 0) + start_oru =(fix15)(SQUEEZE_MULT(sp_plaid.orus[start_edge], bottom_scale)); +else + start_oru =(fix15)(SQUEEZE_MULT(sp_plaid.orus[start_edge], top_scale)); + +if (sp_plaid.orus[end_edge] < 0) + end_oru =(fix15)(SQUEEZE_MULT(sp_plaid.orus[end_edge], bottom_scale)); +else + end_oru =(fix15)(SQUEEZE_MULT(sp_plaid.orus[end_edge], top_scale)); + +if (!sp_globals.c_act[constr_nr]) /* Constraint inactive? */ + { + /* calculate zone width */ + zone_pix = (fix15)(((((fix31)end_oru - (fix31)start_oru) * ppo) + >> sp_globals.mpshift)+ sp_globals.pixrnd) & sp_globals.pixfix; + /* check minimum */ + if ((ABS(zone_pix)) >= sp_globals.c_pix[constr_nr]) + goto Ly; + } + +/* Use zone size from constr table */ +if ((end_oru >= 0) && (start_oru >=0)) + /* all above baseline */ + zone_pix = (fix15)(SQUEEZE_MULT(top_scale, sp_globals.c_pix[constr_nr])); +else if ((end_oru <= 0) && (start_oru <=0)) + /* all below baseline */ + zone_pix = (fix15)(SQUEEZE_MULT(bottom_scale, sp_globals.c_pix[constr_nr])); +else + { + /* mixture */ + if (start_oru > 0) + { + zone_width = start_oru - end_oru; + /* get % above baseline in 16.16 fixed point */ + above_base = (((fix31)start_oru) << 16) / + ((fix31)zone_width) ; + /* get % below baseline in 16.16 fixed point */ + below_base = (((fix31)-end_oru) << 16) / + ((fix31)zone_width) ; + } + else + { + zone_width = end_oru - start_oru; + /* get % above baseline in 16.16 fixed point */ + above_base = (((fix31)-start_oru) << 16) / + ((fix31)zone_width) ; + /* get % below baseline in 16.16 fixed point */ + below_base = (((fix31)end_oru) << 16) / + ((fix31)zone_width) ; + } + /* % above baseline * total zone * top_scale + */ + /* % below baseline * total zone * bottom_scale */ + zone_pix = ((((above_base * (fix31)sp_globals.c_pix[constr_nr]) >> 16) * + top_scale) + + (((below_base * (fix31)sp_globals.c_pix[constr_nr]) >> 16) * + bottom_scale)) >> 16; + } + +/* make this zone pix fall on a pixel boundary */ +zone_pix = (zone_pix + sp_globals.pixrnd) & sp_globals.pixfix; + +/* if minimum is in effect make the zone one pixel */ +if ((sp_globals.c_pix[constr_nr] != 0) && (zone_pix < sp_globals.onepix)) + zone_pix = sp_globals.onepix; + +if (start_edge > end_edge) + { + zone_pix = -zone_pix; /* Use negatve zone size */ + } +Ly: +/* assign global pix value */ +sp_plaid.pix[end_edge] = sp_plaid.pix[start_edge] + zone_pix; /* Insert end pixels */ + +/* make sure it is in the EM !*/ +if ((sp_globals.pspecs->flags & SQUEEZE_TOP) && + (sp_plaid.pix[end_edge] > em_top_pix)) + sp_plaid.pix[end_edge] = em_top_pix; +if ((sp_globals.pspecs->flags & SQUEEZE_BOTTOM) && + (sp_plaid.pix[end_edge] < em_bot_pix)) + sp_plaid.pix[end_edge] = em_bot_pix; +} + +FUNCTION boolean calculate_x_scale(x_factor, x_offset, no_X_ctrl_zones) +GDECL +fix31 *x_factor, +fix31 *x_offset, +fix15 no_X_ctrl_zones) /* Number of X control zones */ +/* + * Called by sp_setup_pix_table() when squeezing is included + * to determine whether X scaling is necessary. If it is, the + * scale factor and offset are computed. This function returns + * a boolean value TRUE = X squeezind is necessary, FALSE = no + * X squeezing is necessary. + */ +{ +boolean squeeze_left, squeeze_right; +boolean out_on_right, out_on_left; +fix15 bbox_width,set_width; +fix15 bbox_xmin, bbox_xmax; +fix15 x_offset_pix; +fix15 i; +#if INCL_ISW +fix31 isw_scale; +fix15 shift; +#endif + + +/* set up some flags and common calculations */ +squeeze_left = (sp_globals.pspecs->flags & SQUEEZE_LEFT)? TRUE:FALSE; +squeeze_right = (sp_globals.pspecs->flags & SQUEEZE_RIGHT)? TRUE:FALSE; +bbox_xmin = sp_globals.bbox_xmin_orus; +bbox_xmax = sp_globals.bbox_xmax_orus; +set_width = sp_globals.setwidth_orus; + +if (bbox_xmax > set_width) + out_on_right = TRUE; +else + out_on_right = FALSE; +if (bbox_xmin < 0) + out_on_left = TRUE; +else + out_on_left = FALSE; +bbox_width =bbox_xmax - bbox_xmin; + +/* + * don't need X squeezing if: + * - X squeezing not enabled + * - bbox doesn't violate on left or right + * - left squeezing only is enabled and char isn't out on left + * - right squeezing only is enabled and char isn't out on right + */ + +if ((!squeeze_left && !squeeze_right) || + (!out_on_right && !out_on_left) || + (squeeze_left && !squeeze_right && !out_on_left) || + (squeeze_right && !squeeze_left && !out_on_right)) + return FALSE; + +#if INCL_ISW +if (sp_globals.import_setwidth_act) + { + /* if both isw and squeezing is going on - let the imported */ + /* setwidth factor be factored in with the squeeze */ + isw_scale = compute_isw_scale(); + /*sp_globals.setwidth_orus = sp_globals.imported_width;*/ + } +else + isw_scale = 0x10000L; /* 1 in 16.16 notation */ +#endif + +/* squeezing on left and right ? */ +if (squeeze_left && squeeze_right) + { + /* calculate scale factor */ + if (bbox_width < set_width) + *x_factor = 0x10000L; /* 1 in 16.16 notation */ + else + *x_factor = ((fix31)set_width<<16)/(fix31)bbox_width; +#if INCL_ISW + IMPORT_FACTOR +#endif + /* calculate offset */ + if (out_on_left) /* fall out on left ? */ + *x_offset = -(fix31)*x_factor * (fix31)bbox_xmin; + /* fall out on right and I am shifting only ? */ + else if (out_on_right && (*x_factor == 0x10000L)) + *x_offset = -(fix31)*x_factor * (fix31)(bbox_xmax - set_width); + else + *x_offset = 0x0L; /* 0 in 16.16 notation */ + } +/* squeezing on left only and violates left */ +else if (squeeze_left) + { + if (bbox_width < set_width) /* will it fit if I shift it ? */ + *x_factor = 0x10000L; /* 1 in 16.16 notation */ + else if (out_on_right) + *x_factor = ((fix31)set_width<<16)/(fix31)bbox_width; + else + *x_factor = ((fix31)set_width<<16)/ + (fix31)(bbox_width - (bbox_xmax-set_width)); +#if INCL_ISW + IMPORT_FACTOR +#endif + *x_offset = (fix31)-*x_factor * (fix31)bbox_xmin; + } + +/* I must be squeezing on right, and violates right */ +else + { + if (bbox_width < set_width) /* will it fit if I shift it ? */ + { /* just shift it left - it will fit in the bbox */ + *x_factor = 0x10000L; /* 1 in 16.16 notation */ +#if INCL_ISW + IMPORT_FACTOR +#endif + *x_offset = (fix31)-*x_factor * (fix31)bbox_xmin; + } + else if (out_on_left) + { + *x_factor = ((fix31)set_width<<16)/(fix31)bbox_width; +#if INCL_ISW + IMPORT_FACTOR +#endif + *x_offset = 0x0L; /* 0 in 16.16 notation */ + } + else + { + *x_factor = ((fix31)set_width<<16)/(fix31)bbox_xmax; +#if INCL_ISW + IMPORT_FACTOR +#endif + *x_offset = 0x0L; /* 0 in 16.16 notation */ + } + } + +x_offset_pix = (fix15)(((*x_offset >> 16) * sp_globals.tcb0.xppo) + / (1<<sp_globals.mpshift)); + +if ((x_offset_pix >0) && (x_offset_pix < sp_globals.onepix)) + x_offset_pix = sp_globals.onepix; + +/* look for the first non-negative oru value, scale and add the offset */ +/* to the corresponding pixel value - note that the pixel value */ +/* is set in read_oru_table. */ + +/* look at all the X edges */ +for (i=0; i < (no_X_ctrl_zones+1); i++) + if (sp_plaid.orus[i] >= 0) + { + sp_plaid.pix[i] = (SQUEEZE_MULT(sp_plaid.pix[i], *x_factor) + +sp_globals.pixrnd + x_offset_pix) & sp_globals.pixfix; + break; + } + +return TRUE; +} + +FUNCTION boolean calculate_y_scale( +GDECL +fix31 *top_scale, fix31 *bottom_scale, +fix15 first_Y_zone, +fix15 no_Y_ctrl_zones) +/* + * Called by sp_setup_pix_table() when squeezing is included + * to determine whether Y scaling is necessary. If it is, + * two scale factors are computed, one for above the baseline, + * and one for below the basline. + * This function returns a boolean value TRUE = Y squeezind is necessary, + * FALSE = no Y squeezing is necessary. + */ +{ +boolean squeeze_top, squeeze_bottom; +boolean out_on_top, out_on_bottom; +fix15 bbox_top, bbox_bottom; +fix15 bbox_height; +fix15 i; + +/* set up some flags and common calculations */ +squeeze_top = (sp_globals.pspecs->flags & SQUEEZE_TOP)? TRUE:FALSE; +squeeze_bottom = (sp_globals.pspecs->flags & SQUEEZE_BOTTOM)? TRUE:FALSE; +bbox_top = sp_globals.bbox_ymax_orus; +bbox_bottom = sp_globals.bbox_ymin_orus; +bbox_height = bbox_top - bbox_bottom; + +if (bbox_top > EM_TOP) + out_on_top = TRUE; +else + out_on_top = FALSE; + +if (bbox_bottom < EM_BOT) + out_on_bottom = TRUE; +else + out_on_bottom = FALSE; + +/* + * don't need Y squeezing if: + * - Y squeezing not enabled + * - bbox doesn't violate on top or bottom + * - top squeezing only is enabled and char isn't out on top + * - bottom squeezing only is enabled and char isn't out on bottom + */ +if ((!squeeze_top && !squeeze_bottom) || + (!out_on_top && !out_on_bottom) || + (squeeze_top && !squeeze_bottom && !out_on_top) || + (squeeze_bottom && !squeeze_top && !out_on_bottom)) + return FALSE; + +if (squeeze_top && (bbox_top > EM_TOP)) + *top_scale = ((fix31)EM_TOP << 16)/(fix31)(bbox_top); +else + *top_scale = 0x10000L; /* 1 in 16.16 fixed point */ + +if (squeeze_bottom && (bbox_bottom < EM_BOT)) + *bottom_scale = ((fix31)-(EM_BOT) << 16)/(fix31)-bbox_bottom; +else + *bottom_scale = 0x10000L; + +if (sp_globals.squeezing_compound) + { + for (i=first_Y_zone; i < (first_Y_zone + no_Y_ctrl_zones + 1); i++) + { + if (sp_plaid.orus[i] >= 0) + sp_plaid.pix[i] = (SQUEEZE_MULT(sp_plaid.pix[i], *top_scale) + +sp_globals.pixrnd) & sp_globals.pixfix; + else + sp_plaid.pix[i] = (SQUEEZE_MULT(sp_plaid.pix[i], *bottom_scale) + +sp_globals.pixrnd) & sp_globals.pixfix; + } + } +return TRUE; +} +#endif + +#if INCL_RULES +FUNCTION static ufix8 FONTFAR *sp_setup_pix_table( +GDECL +ufix8 FONTFAR *pointer, /* Pointer to first byte in control zone table */ +boolean short_form, /* TRUE if 1 byte from/to specification */ +fix15 no_X_ctrl_zones, /* Number of X control zones */ +fix15 no_Y_ctrl_zones) /* Number of Y control zones */ +/* + * Called by plaid_tcb() to read the control zone table from the + * character data in the font. + * Sets up a table of pixel values for all controlled coordinates. + * Updates the pointer to the byte following the control zone + * data. + */ +{ +fix15 i, j, n; +fix31 ppo; +#if INCL_SQUEEZING || INCL_ISW +fix31 xppo0; /* top level pixels per oru */ +fix31 yppo0; /* top level pixels per oru */ +#endif +ufix8 edge_org; +ufix8 edge; +ufix8 start_edge; +ufix8 end_edge; +ufix16 constr_org; +fix15 constr_nr; +fix15 zone_pix; +fix31 whole_zone; /* non-transformed value of the first X zone */ +ufix16 tmpufix16; /* in extended mode, macro uses secnd term */ +#if INCL_SQUEEZING +fix31 x_scale; +fix31 y_top_scale, y_bottom_scale; +fix31 x_offset; +boolean squeezed_y; +fix15 setwidth_pix, em_top_pix, em_bot_pix; +#endif + +#if INCL_ISW +boolean imported_width; +fix31 isw_scale; +fix15 isw_setwidth_pix; +#endif + +#if INCL_ISW || INCL_SQUEEZING +boolean squeezed_x; +#endif + +#if INCL_PLAID_OUT /* Plaid data monitoring included? */ +begin_ctrl_zones(no_X_ctrl_zones, no_Y_ctrl_zones); +#endif + + +edge_org = 0; +constr_org = 0; +sp_globals.rnd_xmin = 0; /* initialize the error for chars with no zone */ +n = no_X_ctrl_zones; +ppo = sp_globals.tcb.xppo; +#if INCL_SQUEEZING || INCL_ISW +xppo0 = sp_globals.tcb0.xppo; +yppo0 = sp_globals.tcb0.yppo; +squeezed_x = FALSE; +#endif + +#if INCL_SQUEEZING +squeezed_x = calculate_x_scale (&x_scale, &x_offset, no_X_ctrl_zones); +squeezed_y = calculate_y_scale(&y_top_scale,&y_bottom_scale,(n+1), + no_Y_ctrl_zones); +#if INCL_ISW +if (sp_globals.import_setwidth_act == TRUE) +setwidth_pix = ((fix15)(((fix31)sp_globals.imported_width * xppo0) >> + sp_globals.mpshift) + sp_globals.pixrnd) & sp_globals.pixfix; + +else +#endif +setwidth_pix = ((fix15)(((fix31)sp_globals.setwidth_orus * xppo0) >> + sp_globals.mpshift) + sp_globals.pixrnd) & sp_globals.pixfix; +/* check for overflow */ +if (setwidth_pix < 0) + setwidth_pix = 0x7fff; /* set to maximum */ +em_bot_pix = ((fix15)(((fix31)EM_BOT * yppo0) >> + sp_globals.mpshift) + sp_globals.pixrnd) & sp_globals.pixfix; +em_top_pix = ((fix15)(((fix31)EM_TOP * yppo0) >> + sp_globals.mpshift) + sp_globals.pixrnd) & sp_globals.pixfix; +#endif + +#if INCL_ISW +/* convert to pixels */ +isw_setwidth_pix = ((fix15)(((fix31)sp_globals.imported_width * xppo0) >> + sp_globals.mpshift) + sp_globals.pixrnd) & sp_globals.pixfix; +/* check for overflow */ +if (isw_setwidth_pix < 0) + isw_setwidth_pix = 0x7fff; /* set to maximum */ +if (!squeezed_x && ((imported_width = sp_globals.import_setwidth_act) == TRUE)) + { + isw_scale = compute_isw_scale(); + + /* look for the first non-negative oru value, scale and add the offset */ + /* to the corresponding pixel value - note that the pixel value */ + /* is set in read_oru_table. */ + + /* look at all the X edges */ + for (i=0; i < (no_X_ctrl_zones+1); i++) + if (sp_plaid.orus[i] >= 0) + { + sp_plaid.pix[i] = (SQUEEZE_MULT(sp_plaid.pix[i], isw_scale) + +sp_globals.pixrnd) & sp_globals.pixfix; + break; + } + + } +#endif + +for (i = 0; ; i++) /* For X and Y control zones... */ + { + for (j = 0; j < n; j++) /* For each zone in X or Y... */ + { + if (short_form) /* 1 byte from/to specification? */ + { + edge = NEXT_BYTE(pointer); /* Read packed from/to spec */ + start_edge = edge_org + (edge & 0x0f); /* Extract start edge */ + end_edge = edge_org + (edge >> 4); /* Extract end edge */ + } + else /* 2 byte from/to specification? */ + { + start_edge = edge_org + NEXT_BYTE(pointer); /* Read start edge */ + end_edge = edge_org + NEXT_BYTE(pointer); /* read end edge */ + } + constr_nr = constr_org + + NEXT_BYTES(pointer, tmpufix16); /* Read constraint number */ +#if INCL_SQUEEZING + if (i == 0 && squeezed_x) + calculate_x_pix(start_edge, end_edge, constr_nr, + x_scale, x_offset, ppo, setwidth_pix); + else if (i == 1 && squeezed_y) + calculate_y_pix(start_edge, end_edge,constr_nr, + y_top_scale, y_bottom_scale, ppo, em_top_pix, em_bot_pix); + else + { +#endif +#if INCL_ISW + if (i==0 && imported_width) + calculate_x_pix(start_edge, end_edge, constr_nr, + isw_scale, 0, ppo, isw_setwidth_pix); + else + { +#endif + if (!sp_globals.c_act[constr_nr]) /* Constraint inactive? */ + { + zone_pix = ((fix15)((((fix31)sp_plaid.orus[end_edge] - + (fix31)sp_plaid.orus[start_edge]) * ppo) / + (1<<sp_globals.mpshift)) + sp_globals.pixrnd) & + sp_globals.pixfix; + if ((ABS(zone_pix)) >= sp_globals.c_pix[constr_nr]) + goto L1; + } + zone_pix = sp_globals.c_pix[constr_nr]; /* Use zone size from constr table */ + if (start_edge > end_edge) /* sp_plaid.orus[start_edge] > sp_plaid.orus[end_edge]? */ + { + zone_pix = -zone_pix; /* Use negatve zone size */ + } + L1: + /* inter-character spacing fix */ + if ((j == 0) && (i == 0)) /* if this is the 1st X zone, save rounding error */ + { /* get the non-xformed - xformed zone, in right direction */ + whole_zone = (((fix31)sp_plaid.orus[end_edge] - + (fix31)sp_plaid.orus[start_edge]) * + ppo) / (1<<sp_globals.mpshift); + sp_globals.rnd_xmin = whole_zone - zone_pix; + } + sp_plaid.pix[end_edge] = sp_plaid.pix[start_edge] + zone_pix; /* Insert end pixels */ +#if INCL_SQUEEZING + if (i == 0) /* in the x direction */ + { /* brute force squeeze */ + if ((sp_globals.pspecs->flags & SQUEEZE_LEFT) && + (sp_plaid.pix[end_edge] < 0)) + sp_plaid.pix[end_edge] = 0; + if ((sp_globals.pspecs->flags & SQUEEZE_RIGHT) && + (sp_plaid.pix[end_edge] > setwidth_pix)) + sp_plaid.pix[end_edge] = setwidth_pix; + } + if (i == 1) /* in the y direction */ + { /* brute force squeeze */ + if ((sp_globals.pspecs->flags & SQUEEZE_TOP) && + (sp_plaid.pix[end_edge] > em_top_pix)) + sp_plaid.pix[end_edge] = em_top_pix; + if ((sp_globals.pspecs->flags & SQUEEZE_BOTTOM) && + (sp_plaid.pix[end_edge] < em_bot_pix)) + sp_plaid.pix[end_edge] = em_bot_pix; + } +#endif +#if INCL_SQUEEZING + } +#endif +#if INCL_ISW + } +#endif +#if INCL_PLAID_OUT /* Plaid data monitoring included? */ + record_ctrl_zone( + (fix31)sp_plaid.pix[start_edge] << (16 - sp_globals.pixshift), + (fix31)sp_plaid.pix[end_edge] << (16 - sp_globals.pixshift), + (fix15)(constr_nr - constr_org)); +#endif + } + if (i) /* Y pixels done? */ + break; + edge_org = sp_globals.Y_edge_org; /* Prepare to process Y ctrl zones */ + constr_org = sp_globals.Y_constr_org; + n = no_Y_ctrl_zones; + ppo = sp_globals.tcb.yppo; + } + +#if DEBUG +printf("\nX PIX TABLE\n"); +n = no_X_ctrl_zones + 1; +for (i = 0; i < n; i++) + printf("%2d %6.1f\n", i, (real)sp_plaid.pix[i] / (real)sp_globals.onepix); +printf("\nY PIX TABLE\n"); +n = no_Y_ctrl_zones + 1; +for (i = 0; i < n; i++) + { + j = i + no_X_ctrl_zones + 1; + printf("%2d %6.1f\n", i, (real)sp_plaid.pix[j] / (real)sp_globals.onepix); + } +#endif + +return pointer; +} +#endif + + +#if INCL_RULES +FUNCTION static ufix8 FONTFAR *sp_setup_int_table( +GDECL +ufix8 FONTFAR *pointer, /* Pointer to first byte in interpolation zone table */ +fix15 no_X_int_zones, /* Number of X interpolation zones */ +fix15 no_Y_int_zones) /* Number of X interpolation zones */ +/* + * Called by plaid_tcb() to read the interpolation zone table from the + * character data in the font. + * Sets up a table of interpolation coefficients with one entry for + * every X or Y interpolation zone. + * Updates the pointer to the byte following the interpolation zone + * data. + */ +{ +fix15 i, j, k, l, n; +ufix8 format; +ufix8 format_copy; +ufix8 tmpufix8; +fix15 start_orus = 0; +ufix8 edge_org; +ufix8 edge; +ufix16 adj_factor; +fix15 adj_orus; +fix15 end_orus = 0; +fix31 zone_orus; +fix15 start_pix = 0; +fix15 end_pix = 0; + + +#if INCL_PLAID_OUT /* Plaid data monitoring included? */ +begin_int_zones(no_X_int_zones, no_Y_int_zones); +#endif + +i = 0; +edge_org = 0; +n = no_X_int_zones; +for (j = 0; ; j++) + { + for (k = 0; k < n; k++) + { + format = NEXT_BYTE(pointer); + if (format & BIT7) /* Short start/end point spec? */ + { + tmpufix8 = NEXT_BYTE(pointer); + edge = edge_org + (tmpufix8 & 0xf); + start_orus = sp_plaid.orus[edge]; + start_pix = sp_plaid.pix[edge]; + edge = edge_org + (tmpufix8 >> 4); + end_orus = sp_plaid.orus[edge]; + end_pix = sp_plaid.pix[edge]; + } + else /* Standard start and end point spec? */ + { + format_copy = format; + for (l = 0; ; l++) /* Loop for start and end point */ + { + switch (format_copy & 0x7) /* Decode start/end point format */ + { + + case 0: /* Index to control edge */ + edge = edge_org + NEXT_BYTE(pointer); + end_orus = sp_plaid.orus[edge]; + end_pix = sp_plaid.pix[edge]; + break; + + case 1: /* 1 byte fractional distance to next edge */ + adj_factor = 0xffff & NEXT_BYTE(pointer) << 8; + goto L1; + + + case 2: /* 2 byte fractional distance to next edge */ + adj_factor = 0xffff & NEXT_WORD(pointer); + L1: edge = edge_org + NEXT_BYTE(pointer); + end_orus = sp_plaid.orus[edge] + + ((((fix31)sp_plaid.orus[edge + 1] - (fix31)sp_plaid.orus[edge]) * + (ufix32)adj_factor + (fix31)32768) >> 16); + end_pix = sp_plaid.pix[edge] + + ((((fix31)sp_plaid.pix[edge + 1] - (fix31)sp_plaid.pix[edge]) * + (ufix32)adj_factor + (fix31)32768) >> 16); + break; + + case 3: /* 1 byte delta orus before first edge */ + adj_orus = -(fix15)NEXT_BYTE(pointer); + goto L2; + + case 4: /* 2 byte delta orus before first edge */ + adj_orus = -NEXT_WORD(pointer); + L2: edge = edge_org; + goto L4; + + case 5: /* 1 byte delta orus after last edge */ + adj_orus = (fix15)NEXT_BYTE(pointer); + goto L3; + + case 6: /* 2 byte delta orus after last edge */ + adj_orus = NEXT_WORD(pointer); + L3: edge = j? sp_globals.Y_edge_org + sp_globals.no_Y_orus - 1: sp_globals.no_X_orus - 1; + L4: end_orus = sp_plaid.orus[edge] + adj_orus; + end_pix = sp_plaid.pix[edge] + + (((fix31)adj_orus * (fix31)(j? sp_globals.tcb.yppo: sp_globals.tcb.xppo) + + sp_globals.mprnd) / (1<<sp_globals.mpshift)); + break; + + } + + if (l) /* Second time round loop? */ + break; + format_copy >>= 3; /* Adj format to decode end point format */ + start_orus = end_orus; /* Save start point oru value */ + start_pix = end_pix; /* Save start point pixel value */ + } + } +#if INCL_PLAID_OUT /* Plaid data monitoring included? */ + record_int_zone( + (fix31)start_pix << (16 - sp_globals.pixshift), + (fix31)end_pix << (16 - sp_globals.pixshift)); +#endif + zone_orus = (fix31)end_orus - (fix31)start_orus; + sp_plaid.mult[i] = ((((fix31)end_pix - (fix31)start_pix) << sp_globals.mpshift) + + (zone_orus / 2)) / zone_orus; + sp_plaid.offset[i] = + (((((fix31)start_pix + (fix31)end_pix) << sp_globals.mpshift) - + ((fix31)sp_plaid.mult[i] * ((fix31)start_orus + (fix31)end_orus))) / 2) + + sp_globals.mprnd; + i++; + } + if (j) /* Finished? */ + break; + edge_org = sp_globals.Y_edge_org; /* Prepare to process Y ctrl zones */ + n = no_Y_int_zones; + } + +#if DEBUG +printf("\nX INT TABLE\n"); +n = no_X_int_zones; +for (i = 0; i < n; i++) + { + printf("%2d %7.4f %7.4f\n", i, + (real)sp_plaid.mult[i] / (real)(1 << sp_globals.multshift), + (real)sp_plaid.offset[i] / (real)(1 << sp_globals.multshift)); + } +printf("\nY INT TABLE\n"); +n = no_Y_int_zones; +for (i = 0; i < n; i++) + { + j = i + no_X_int_zones; + printf("%2d %7.4f %7.4f\n", i, + (real)sp_plaid.mult[j] / (real)(1 << sp_globals.multshift), + (real)sp_plaid.offset[j] / (real)(1 << sp_globals.multshift)); + } +#endif + +return pointer; +} +#endif +#if INCL_ISW +FUNCTION fix31 compute_isw_scale() +GDECL +{ +fix31 isw_scale; + +if (sp_globals.setwidth_orus == 0) + isw_scale = 0x00010000; +else + isw_scale = ((fix31)sp_globals.imported_width << 16)/ + (fix31)sp_globals.setwidth_orus; +return isw_scale; +} +#endif diff --git a/nx-X11/lib/font/Speedo/spdo_prv.h b/nx-X11/lib/font/Speedo/spdo_prv.h new file mode 100644 index 000000000..162c0fddd --- /dev/null +++ b/nx-X11/lib/font/Speedo/spdo_prv.h @@ -0,0 +1,421 @@ +/* $Xorg: spdo_prv.h,v 1.3 2000/08/17 19:46:27 cpqbld Exp $ */ + +/* + +Copyright 1989-1991, Bitstream Inc., Cambridge, MA. +You are hereby granted permission under all Bitstream propriety rights to +use, copy, modify, sublicense, sell, and redistribute the Bitstream Speedo +software and the Bitstream Charter outline font for any purpose and without +restrictions; provided, that this notice is left intact on all copies of such +software or font and that Bitstream's trademark is acknowledged as shown below +on all unmodified copies of such font. + +BITSTREAM CHARTER is a registered trademark of Bitstream Inc. + + +BITSTREAM INC. DISCLAIMS ANY AND ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING +WITHOUT LIMITATION THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE. BITSTREAM SHALL NOT BE LIABLE FOR ANY DIRECT OR INDIRECT +DAMAGES, INCLUDING BUT NOT LIMITED TO LOST PROFITS, LOST DATA, OR ANY OTHER +INCIDENTAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF OR IN ANY WAY CONNECTED +WITH THE SPEEDO SOFTWARE OR THE BITSTREAM CHARTER OUTLINE FONT. + +*/ +/* $XFree86: xc/lib/font/Speedo/spdo_prv.h,v 1.4 1999/03/14 03:21:17 dawes Exp $ */ + + + +/***************************** S P D O _ P R V . H *******************************/ + +#include "speedo.h" /* include public definitions */ + +/***** CONFIGURATION DEFINITIONS *****/ + + +/***** PRIVATE FONT HEADER OFFSET CONSTANTS *****/ +#define FH_ORUMX 0 /* U Max ORU value 2 bytes */ +#define FH_PIXMX 2 /* U Max Pixel value 2 bytes */ +#define FH_CUSNR 4 /* U Customer Number 2 bytes */ +#define FH_OFFCD 6 /* E Offset to Char Directory 3 bytes */ +#define FH_OFCNS 9 /* E Offset to Constraint Data 3 bytes */ +#define FH_OFFTK 12 /* E Offset to Track Kerning 3 bytes */ +#define FH_OFFPK 15 /* E Offset to Pair Kerning 3 bytes */ +#define FH_OCHRD 18 /* E Offset to Character Data 3 bytes */ +#define FH_NBYTE 21 /* E Number of Bytes in File 3 bytes */ + + +/***** MODE FLAGS CONSTANTS *****/ +#define CURVES_OUT 0X0008 /* Output module accepts curves */ +#define BOGUS_MODE 0X0010 /* Linear scaling mode */ +#define CONSTR_OFF 0X0020 /* Inhibit constraint table */ +#define IMPORT_WIDTHS 0X0040 /* Imported width mode */ +#define SQUEEZE_LEFT 0X0100 /* Squeeze left mode */ +#define SQUEEZE_RIGHT 0X0200 /* Squeeze right mode */ +#define SQUEEZE_TOP 0X0400 /* Squeeze top mode */ +#define SQUEEZE_BOTTOM 0X0800 /* Squeeze bottom mode */ +#define CLIP_LEFT 0X1000 /* Clip left mode */ +#define CLIP_RIGHT 0X2000 /* Clip right mode */ +#define CLIP_TOP 0X4000 /* Clip top mode */ +#define CLIP_BOTTOM 0X8000 /* Clip bottom mode */ + + +/***** MACRO DEFINITIONS *****/ + +#define SQUEEZE_MULT(A,B) (((fix31)A * (fix31)B) / (1 << 16)) + +#define NEXT_BYTE(A) (*(A)++) + +#define NEXT_WORD(A) \ + ((fix15)(sp_globals.key32 ^ ((A) += 2, \ + ((fix15)((A)[-1]) << 8) | (fix15)((A)[-2]) | \ + ((A)[-1] & 0x80? ~0xFFFF : 0)))) + +#if INCL_EXT /* Extended fonts supported? */ + +#define NEXT_BYTES(A, B) \ + (((B = (ufix16)(*(A)++) ^ sp_globals.key7) >= 248)? \ + ((ufix16)(B & 0x07) << 8) + ((*(A)++) ^ sp_globals.key8) + 248: \ + B) + +#else /* Compact fonts only supported? */ + +#define NEXT_BYTES(A, B) ((*(A)++) ^ sp_globals.key7) + +#endif + + +#define NEXT_BYTE_U(A) (*(A)++) + +#define NEXT_WORD_U(A, B) \ + (fix15)(B = (*(A)++) << 8, (fix15)(*(A)++) + B) + +#define NEXT_CHNDX(A, B) \ + ((B)? (ufix16)NEXT_WORD(A): (ufix16)NEXT_BYTE(A)) + +/* Multiply (fix15)X by (fix15)Y to produce (fix31)product */ +#define MULT16(X, Y) \ + ((fix31)X * (fix31)Y) + +/* Multiply (fix15)X by (fix15)MULT, add (fix31)OFFSET, + * shift right SHIFT bits to produce (fix15)result */ +#define TRANS(X, MULT, OFFSET, SHIFT) \ + ((fix15)((((fix31)X * (fix31)MULT) + OFFSET) / (1 << SHIFT))) + +/****************************************************************************** + * + * the following block of definitions redefines every function + * reference to be prefixed with an "sp_". In addition, if this + * is a reentrant version, the parameter sp_globals will be added + * as the first parameter. + * + *****************************************************************************/ + +#if STATIC_ALLOC || DYNAMIC_ALLOC + +#define GDECL + +#define get_char_id(char_index) sp_get_char_id(char_index) +#define get_char_width(char_index) sp_get_char_width(char_index) +#define get_track_kern(track,point_size) sp_get_track_kern(track,point_size) +#define get_pair_kern(char_index1,char_index2) sp_get_pair_kern(char_index1,char_index2) +#define get_char_bbox(char_index,bbox) sp_get_char_bbox(char_index,bbox) +#define make_char(char_index) sp_make_char(char_index) +#if INCL_ISW +#define compute_isw_scale() sp_compute_isw_scale() +#define do_make_char(char_index) sp_do_make_char(char_index) +#define make_char_isw(char_index,imported_width) sp_make_char_isw(char_index,imported_width) +#define reset_xmax(xmax) sp_reset_xmax(xmax) +#endif +#if INCL_ISW || INCL_SQUEEZING +#define preview_bounding_box(pointer,format) sp_preview_bounding_box(pointer,format) +#endif +#define make_simp_char(pointer,format) sp_make_simp_char(pointer,format) +#define make_comp_char(pointer) sp_make_comp_char(pointer) +#define get_char_org(char_index,top_level) sp_get_char_org(char_index,top_level) +#define get_posn_arg(ppointer,format) sp_get_posn_arg(ppointer,format) +#define get_scale_arg(ppointer,format) sp_get_scale_arg(ppointer,format) +#define read_bbox(ppointer,pPmin,pPmax,set_flag) sp_read_bbox(ppointer,pPmin,pPmax,set_flag) +#define proc_outl_data(pointer) sp_proc_outl_data(pointer) +#define split_curve(P1,P2,P3,depth) sp_split_curve(P1,P2,P3,depth) +#define get_args(ppointer,format,pP) sp_get_args(ppointer,format,pP) + +#define init_black(specsarg) sp_init_black(specsarg) +#define begin_char_black(Psw,Pmin,Pmax) sp_begin_char_black(Psw,Pmin,Pmax) +#define begin_contour_black(P1,outside) sp_begin_contour_black(P1,outside) +#define line_black(P1) sp_line_black(P1) +#define end_char_black() sp_end_char_black() +#define add_intercept_black(y,x) sp_add_intercept_black(y,x) +#define proc_intercepts_black() sp_proc_intercepts_black() + +#define init_screen(specsarg) sp_init_screen(specsarg) +#define begin_char_screen(Psw,Pmin,Pmax) sp_begin_char_screen(Psw,Pmin,Pmax) +#define begin_contour_screen(P1,outside) sp_begin_contour_screen(P1,outside) +#define curve_screen(P1,P2,P3,depth) sp_curve_screen(P1,P2,P3,depth) +#define scan_curve_screen(X0,Y0,X1,Y1,X2,Y2,X3,Y3) sp_scan_curve_screen(X0,Y0,X1,Y1,X2,Y2,X3,Y3) +#define vert_line_screen(x,y1,y2) sp_vert_line_screen(x,y1,y2) +#define line_screen(P1) sp_line_screen(P1) +#define end_contour_screen() sp_end_contour_screen() +#define end_char_screen() sp_end_char_screen() +#define add_intercept_screen(y,x) sp_add_intercept_screen(y,x) +#define proc_intercepts_screen() sp_proc_intercepts_screen() + +#define init_outline(specsarg) sp_init_outline(specsarg) +#define begin_char_outline(Psw,Pmin,Pmax) sp_begin_char_outline(Psw,Pmin,Pmax) +#define begin_sub_char_outline(Psw,Pmin,Pmax) sp_begin_sub_char_outline(Psw,Pmin,Pmax) +#define begin_contour_outline(P1,outside) sp_begin_contour_outline(P1,outside) +#define curve_outline(P1,P2,P3,depth) sp_curve_outline(P1,P2,P3,depth) +#define line_outline(P1) sp_line_outline(P1) +#define end_contour_outline() sp_end_contour_outline() +#define end_sub_char_outline() sp_end_sub_char_outline() +#define end_char_outline() sp_end_char_outline() + +#define init_2d(specsarg) sp_init_2d(specsarg) +#define begin_char_2d(Psw, Pmin, Pmax) sp_begin_char_2d(Psw, Pmin, Pmax) +#define begin_contour_2d(P1, outside) sp_begin_contour_2d(P1, outside) +#define line_2d(P1) sp_line_2d(P1) +#define end_char_2d() sp_end_char_2d() +#define add_intercept_2d(y, x) sp_add_intercept_2d(y, x) +#define proc_intercepts_2d() sp_proc_intercepts_2d() +#define draw_vector_to_2d(x0, y0, x1, y1, band) sp_draw_vector_to_2d(x0, y0, x1, y1, band) + +#define init_char_out(Psw,Pmin,Pmax) sp_init_char_out(Psw,Pmin,Pmax) +#define begin_sub_char_out(Psw,Pmin,Pmax) sp_begin_sub_char_out(Psw,Pmin,Pmax) +#define curve_out(P1,P2,P3,depth) sp_curve_out(P1,P2,P3,depth) +#define end_contour_out() sp_end_contour_out() +#define end_sub_char_out() sp_end_sub_char_out() +#define init_intercepts_out() sp_init_intercepts_out() +#define restart_intercepts_out() sp_restart_intercepts_out() +#define set_first_band_out(Pmin,Pmax) sp_set_first_band_out(Pmin,Pmax) +#define reduce_band_size_out() sp_reduce_band_size_out() +#define next_band_out() sp_next_band_out() + +#define init_userout(specsarg) sp_init_userout(specsarg) + +#define reset() sp_reset() +#define set_key(key) sp_set_key(key) +#define get_cust_no(font_buff) sp_get_cust_no(font_buff) +#define set_specs(specsarg) sp_set_specs(specsarg) +#define setup_consts(xmin,xmax,ymin,ymax) sp_setup_consts(xmin,xmax,ymin,ymax) +#define setup_tcb(ptcb) sp_setup_tcb(ptcb) +#define setup_mult(input_mult) sp_setup_mult(input_mult) +#define setup_offset(input_offset) sp_setup_offset(input_offset) +#define type_tcb(ptcb) sp_type_tcb(ptcb) +#define read_long(pointer) sp_read_long(pointer) +#define read_word_u(pointer) sp_read_word_u(pointer) +#define init_tcb() sp_init_tcb() +#define scale_tcb(ptcb,x_pos,y_pos,x_scale,y_scale) sp_scale_tcb(ptcb,x_pos,y_pos,x_scale,y_scale) +#define plaid_tcb(ppointer,format) sp_plaid_tcb(ppointer,format) +#define skip_orus(ppointer,short_form,no_ctrl_zones) sp_skip_orus(ppointer,short_form,no_ctrl_zones) +#define skip_interpolation_table(ppointer,format) sp_skip_interpolation_table(ppointer,format) +#define skip_control_zone(ppointer,format) sp_skip_control_zone(ppointer,format) +#define constr_update() sp_constr_update() +#define read_oru_table(ppointer) sp_read_oru_table(ppointer) +#define calculate_x_pix(start_edge,end_edge,constr_nr,x_scale,x_offset,ppo,setwidth_pix) sp_calculate_x_pix(start_edge,end_edge,constr_nr,x_scale,x_offset,ppo,setwidth_pix) +#define calculate_y_pix(start_edge,end_edge,constr_nr,top_scale,bottom_scale,ppo,emtop_pix,embot_pix) sp_calculate_y_pix(start_edge,end_edge,constr_nr,top_scale,bottom_scale,ppo,emtop_pix,embot_pix) +#define calculate_x_scale(x_factor,x_offset,no_x_ctrl_zones) sp_calculate_x_scale(x_factor,x_offset,no_x_ctrl_zones) +#define calculate_y_scale(top_scale,bottom_scale,first_y_zone,no_Y_ctrl_zones) sp_calculate_y_scale(top_scale,bottom_scale,first_y_zone,no_Y_ctrl_zones) +#define setup_pix_table(ppointer,short_form,no_X_ctrl_zones,no_Y_ctrl_zones) sp_setup_pix_table(ppointer,short_form,no_X_ctrl_zones,no_Y_ctrl_zones) +#define setup_int_table(ppointer,no_X_int_zones, no_Y_int_zones) sp_setup_int_table(ppointer,no_X_int_zones, no_Y_int_zones) + +#define fn_init_out(specsarg) (*sp_globals.init_out)(specsarg) +#define fn_begin_char(Psw,Pmin,Pmax) (*sp_globals.begin_char)(Psw,Pmin,Pmax) +#define fn_begin_sub_char(Psw,Pmin,Pmax) (*sp_globals.begin_sub_char)(Psw,Pmin,Pmax) +#define fn_end_sub_char() (*sp_globals.end_sub_char)() +#define fn_end_char() (*sp_globals.end_char)() +#define fn_line(P1) (*sp_globals.line)(P1) +#define fn_end_contour() (*sp_globals.end_contour)() +#define fn_begin_contour(P0,fmt) (*sp_globals.begin_contour)(P0,fmt) +#define fn_curve(P1,P2,P3,depth) (*sp_globals.curve)(P1,P2,P3,depth) + +#define load_char_data(offset, no_bytes, buff_off) sp_load_char_data(offset, no_bytes, buff_off) +#define report_error(n) sp_report_error(n) + +#if INCL_MULTIDEV + +#define set_bitmap_device(bfuncs,size) sp_set_bitmap_device(bfuncs,size) +#define set_outline_device(ofuncs,size) sp_set_outline_device(ofuncs,size) + +#define open_bitmap(x_set_width, y_set_width, xmin, xmax, ymin, ymax) (*sp_globals.bitmap_device.p_open_bitmap)(x_set_width, y_set_width, xmin, xmax, ymin, ymax) +#define set_bitmap_bits(y, xbit1, xbit2) (*sp_globals.bitmap_device.p_set_bits)(y, xbit1, xbit2) +#define close_bitmap() (*sp_globals.bitmap_device.p_close_bitmap)() + +#define open_outline(x_set_width, y_set_width, xmin, xmax, ymin, ymax) (*sp_globals.outline_device.p_open_outline)(x_set_width, y_set_width, xmin, xmax, ymin, ymax) +#define start_new_char() (*sp_globals.outline_device.p_start_char)() +#define start_contour(x,y,outside) (*sp_globals.outline_device.p_start_contour)(x,y,outside) +#define curve_to(x1,y1,x2,y2,x3,y3) (*sp_globals.outline_device.p_curve)(x1,y1,x2,y2,x3,y3) +#define line_to(x,y) (*sp_globals.outline_device.p_line)(x,y) +#define close_contour() (*sp_globals.outline_device.p_close_contour)() +#define close_outline() (*sp_globals.outline_device.p_close_outline)() + +#else + +#define open_bitmap(x_set_width, y_set_width, xmin, xmax, ymin, ymax) sp_open_bitmap(x_set_width, y_set_width, xmin, xmax, ymin, ymax) +#define set_bitmap_bits(y, xbit1, xbit2) sp_set_bitmap_bits(y, xbit1, xbit2) +#define close_bitmap() sp_close_bitmap() + +#define open_outline(x_set_width, y_set_width, xmin, xmax, ymin, ymax) sp_open_outline(x_set_width, y_set_width, xmin, xmax, ymin, ymax) +#define start_new_char() sp_start_new_char() +#define start_contour(x,y,outside) sp_start_contour(x,y,outside) +#define curve_to(x1,y1,x2,y2,x3,y3) sp_curve_to(x1,y1,x2,y2,x3,y3) +#define line_to(x,y) sp_line_to(x,y) +#define close_contour() sp_close_contour() +#define close_outline() sp_close_outline() + +#endif + +#else + +#define GDECL SPEEDO_GLOBALS* sp_global_ptr, + +#define get_char_id(char_index) sp_get_char_id(sp_global_ptr,char_index) +#define get_char_width(char_index) sp_get_char_width(sp_global_ptr,char_index) +#define get_track_kern(track,point_size) sp_get_track_kern(sp_global_ptr,track,point_size) +#define get_pair_kern(char_index1,char_index2) sp_get_pair_kern(sp_global_ptr,char_index1,char_index2) +#define get_char_bbox(char_index,bbox) sp_get_char_bbox(sp_global_ptr,char_index,bbox) +#define make_char(char_index) sp_make_char(sp_global_ptr,char_index) +#if INCL_ISW +#define compute_isw_scale() sp_compute_isw_scale(sp_global_ptr) +#define do_make_char(char_index) sp_do_make_char(sp_global_ptr,char_index) +#define make_char_isw(char_index,imported_width) sp_make_char_isw(sp_global_ptr,char_index,imported_width) +#define reset_xmax(xmax) sp_reset_xmax(sp_global_ptr,xmax) +#endif +#if INCL_ISW || INCL_SQUEEZING +#define preview_bounding_box(pointer,format) sp_preview_bounding_box(sp_global_ptr,pointer,format) +#endif +#define make_simp_char(pointer,format) sp_make_simp_char(sp_global_ptr,pointer,format) +#define make_comp_char(pointer) sp_make_comp_char(sp_global_ptr,pointer) +#define get_char_org(char_index,top_level) sp_get_char_org(sp_global_ptr,char_index,top_level) +#define get_posn_arg(ppointer,format) sp_get_posn_arg(sp_global_ptr,ppointer,format) +#define get_scale_arg(ppointer,format) sp_get_scale_arg(sp_global_ptr,ppointer,format) +#define read_bbox(ppointer,pPmin,pPmax,set_flag) sp_read_bbox(sp_global_ptr,ppointer,pPmin,pPmax,set_flag) +#define proc_outl_data(pointer) sp_proc_outl_data(sp_global_ptr,pointer) +#define split_curve(P1,P2,P3,depth) sp_split_curve(sp_global_ptr,P1,P2,P3,depth) +#define get_args(ppointer,format,pP) sp_get_args(sp_global_ptr,ppointer,format,pP) + +#define init_black(specsarg) sp_init_black(sp_global_ptr,specsarg) +#define begin_char_black(Psw,Pmin,Pmax) sp_begin_char_black(sp_global_ptr,Psw,Pmin,Pmax) +#define begin_contour_black(P1,outside) sp_begin_contour_black(sp_global_ptr,P1,outside) +#define line_black(P1) sp_line_black(sp_global_ptr,P1) +#define end_char_black() sp_end_char_black(sp_global_ptr) +#define add_intercept_black(y,x) sp_add_intercept_black(sp_global_ptr,y,x) +#define proc_intercepts_black() sp_proc_intercepts_black(sp_global_ptr) + +#define init_screen(specsarg) sp_init_screen(sp_global_ptr,specsarg) +#define begin_char_screen(Psw,Pmin,Pmax) sp_begin_char_screen(sp_global_ptr,Psw,Pmin,Pmax) +#define begin_contour_screen(P1,outside) sp_begin_contour_screen(sp_global_ptr,P1,outside) +#define curve_screen(P1,P2,P3,depth) sp_curve_screen(sp_global_ptr,P1,P2,P3,depth) +#define scan_curve_screen(X0,Y0,X1,Y1,X2,Y2,X3,Y3) sp_scan_curve_screen(sp_global_ptr,X0,Y0,X1,Y1,X2,Y2,X3,Y3) +#define vert_line_screen(x,y1,y2) sp_vert_line_screen(sp_global_ptr,x,y1,y2) +#define line_screen(P1) sp_line_screen(sp_global_ptr,P1) +#define end_char_screen() sp_end_char_screen(sp_global_ptr) +#define end_contour_screen() sp_end_contour_screen(sp_global_ptr) +#define add_intercept_screen(y,x) sp_add_intercept_screen(sp_global_ptr,y,x) +#define proc_intercepts_screen() sp_proc_intercepts_screen(sp_global_ptr) + +#define init_outline(specsarg) sp_init_outline(sp_global_ptr,specsarg) +#define begin_char_outline(Psw,Pmin,Pmax) sp_begin_char_outline(sp_global_ptr,Psw,Pmin,Pmax) +#define begin_sub_char_outline(Psw,Pmin,Pmax) sp_begin_sub_char_outline(sp_global_ptr,Psw,Pmin,Pmax) +#define begin_contour_outline(P1,outside) sp_begin_contour_outline(sp_global_ptr,P1,outside) +#define curve_outline(P1,P2,P3,depth) sp_curve_outline(sp_global_ptr,P1,P2,P3,depth) +#define line_outline(P1) sp_line_outline(sp_global_ptr,P1) +#define end_contour_outline() sp_end_contour_outline(sp_global_ptr) +#define end_sub_char_outline() sp_end_sub_char_outline(sp_global_ptr) +#define end_char_outline() sp_end_char_outline(sp_global_ptr) + +#define init_2d(specsarg) sp_init_2d(sp_global_ptr,specsarg) +#define begin_char_2d(Psw, Pmin, Pmax) sp_begin_char_2d(sp_global_ptr,Psw, Pmin, Pmax) +#define begin_contour_2d(P1, outside) sp_begin_contour_2d(sp_global_ptr,P1, outside) +#define line_2d(P1) sp_line_2d(sp_global_ptr,P1) +#define end_char_2d() sp_end_char_2d(sp_global_ptr) +#define add_intercept_2d(y, x) sp_add_intercept_2d(sp_global_ptr,y, x) +#define proc_intercepts_2d() sp_proc_intercepts_2d(sp_global_ptr) +#define draw_vector_to_2d(x0, y0, x1, y1, band) sp_draw_vector_to_2d(sp_global_ptr,x0, y0, x1, y1, band) + +#define init_char_out(Psw,Pmin,Pmax) sp_init_char_out(sp_global_ptr,Psw,Pmin,Pmax) +#define begin_sub_char_out(Psw,Pmin,Pmax) sp_begin_sub_char_out(sp_global_ptr,Psw,Pmin,Pmax) +#define curve_out(P1,P2,P3,depth) sp_curve_out(sp_global_ptr,P1,P2,P3,depth) +#define end_contour_out() sp_end_contour_out(sp_global_ptr) +#define end_sub_char_out() sp_end_sub_char_out(sp_global_ptr) +#define init_intercepts_out() sp_init_intercepts_out(sp_global_ptr) +#define restart_intercepts_out() sp_restart_intercepts_out(sp_global_ptr) +#define set_first_band_out(Pmin,Pmax) sp_set_first_band_out(sp_global_ptr,Pmin,Pmax) +#define reduce_band_size_out() sp_reduce_band_size_out(sp_global_ptr) +#define next_band_out() sp_next_band_out(sp_global_ptr) + +#define init_userout(specsarg) sp_init_userout(sp_global_ptr,specsarg) + +#define reset() sp_reset(sp_global_ptr) +#define set_key(key) sp_set_key(sp_global_ptr,key) +#define get_cust_no(font_buff) sp_get_cust_no(sp_global_ptr,font_buff) +#define set_specs(specsarg) sp_set_specs(sp_global_ptr,specsarg) +#define setup_consts(xmin,xmax,ymin,ymax) sp_setup_consts(sp_global_ptr,xmin,xmax,ymin,ymax) +#define setup_tcb(ptcb) sp_setup_tcb(sp_global_ptr,ptcb) +#define setup_mult(input_mult) sp_setup_mult(sp_global_ptr,input_mult) +#define setup_offset(input_offset) sp_setup_offset(sp_global_ptr,input_offset) +#define type_tcb(ptcb) sp_type_tcb(sp_global_ptr,ptcb) +#define read_long(pointer) sp_read_long(sp_global_ptr,pointer) +#define read_word_u(pointer) sp_read_word_u(sp_global_ptr,pointer) +#define init_tcb() sp_init_tcb(sp_global_ptr) +#define scale_tcb(ptcb,x_pos,y_pos,x_scale,y_scale) sp_scale_tcb(sp_global_ptr,ptcb,x_pos,y_pos,x_scale,y_scale) +#define plaid_tcb(ppointer,format) sp_plaid_tcb(sp_global_ptr,ppointer,format) +#define skip_orus(ppointer,short_form,no_ctrl_zones) sp_skip_orus(sp_global_ptr,ppointer,short_form,no_ctrl_zones) +#define skip_interpolation_table(ppointer,format) sp_skip_interpolation_table(sp_global_ptr,ppointer,format) +#define skip_control_zone(ppointer,format) sp_skip_control_zone(sp_global_ptr,ppointer,format) +#define constr_update() sp_constr_update(sp_global_ptr) +#define read_oru_table(ppointer) sp_read_oru_table(sp_global_ptr,ppointer) +#define calculate_x_pix(start_edge,end_edge,constr_nr,x_scale,x_offset,ppo,setwidth_pix) sp_calculate_x_pix(sp_global_ptr,start_edge,end_edge,constr_nr,x_scale,x_offset,ppo,setwidth_pix) +#define calculate_y_pix(start_edge,end_edge,constr_nr,top_scale,bottom_scale,ppo,emtop_pix,embot_pix) sp_calculate_y_pix(sp_global_ptr,start_edge,end_edge,constr_nr,top_scale,bottom_scale,ppo,emtop_pix,embot_pix) +#define calculate_x_scale(x_factor,x_offset,no_x_ctrl_zones) sp_calculate_x_scale(sp_global_ptr,x_factor,x_offset,no_x_ctrl_zones) +#define calculate_y_scale(top_scale,bottom_scale,first_y_zone,no_Y_ctrl_zones) sp_calculate_y_scale(sp_global_ptr,top_scale,bottom_scale,first_y_zone,no_Y_ctrl_zones) +#define setup_pix_table(ppointer,short_form,no_X_ctrl_zones,no_Y_ctrl_zones) sp_setup_pix_table(sp_global_ptr,ppointer,short_form,no_X_ctrl_zones,no_Y_ctrl_zones) +#define setup_int_table(ppointer,no_X_int_zones, no_Y_int_zones) sp_setup_int_table(sp_global_ptr,ppointer,no_X_int_zones, no_Y_int_zones) + +#define fn_init_out(specsarg) (*sp_globals.init_out)(sp_global_ptr,specsarg) +#define fn_begin_char(Psw,Pmin,Pmax) (*sp_globals.begin_char)(sp_global_ptr,Psw,Pmin,Pmax) +#define fn_begin_sub_char(Psw,Pmin,Pmax) (*sp_globals.begin_sub_char)(sp_global_ptr,Psw,Pmin,Pmax) +#define fn_end_sub_char() (*sp_globals.end_sub_char)(sp_global_ptr) +#define fn_end_char() (*sp_globals.end_char)(sp_global_ptr) +#define fn_line(P1) (*sp_globals.line)(sp_global_ptr,P1) +#define fn_end_contour() (*sp_globals.end_contour)(sp_global_ptr) +#define fn_begin_contour(P0,fmt) (*sp_globals.begin_contour)(sp_global_ptr,P0,fmt) +#define fn_curve(P1,P2,P3,depth) (*sp_globals.curve)(sp_global_ptr,P1,P2,P3,depth) + + +#define load_char_data(offset, no_bytes, buff_off) sp_load_char_data(sp_global_ptr, offset, no_bytes, buff_off) +#define report_error(n) sp_report_error(sp_global_ptr, n) + +#if INCL_MULTIDEV + +#define set_bitmap_device(bfuncs,size) sp_set_bitmap_device(sp_global_ptr,bfuncs,size) +#define set_outline_device(ofuncs,size) sp_set_outline_device(sp_global_ptr,ofuncs,size) + +#define open_bitmap(x_set_width, y_set_width, xmin, xmax, ymin, ymax)(*sp_globals.bitmap_device.p_open_bitmap)(sp_global_ptr,x_set_width, y_set_width, xmin, xmax, ymin, ymax) +#define set_bitmap_bits(y, xbit1, xbit2)(*sp_globals.bitmap_device.p_set_bits)(sp_global_ptr,y, xbit1, xbit2) +#define close_bitmap()(*sp_globals.bitmap_device.p_close_bitmap)(sp_global_ptr) + +#define open_outline(x_set_width, y_set_width, xmin, xmax, ymin, ymax)(*sp_globals.outline_device.p_open_outline)(sp_global_ptr,x_set_width, y_set_width, xmin, xmax, ymin, ymax) +#define start_new_char()(*sp_globals.outline_device.p_start_char)(sp_global_ptr) +#define start_contour(x,y,outside)(*sp_globals.outline_device.p_start_contour)(sp_global_ptr,x,y,outside) +#define curve_to(x1,y1,x2,y2,x3,y3)(*sp_globals.outline_device.p_curve)(sp_global_ptr,x1,y1,x2,y2,x3,y3) +#define line_to(x,y)(*sp_globals.outline_device.p_line)(sp_global_ptr,x,y) +#define close_contour()(*sp_globals.outline_device.p_close_contour)(sp_global_ptr) +#define close_outline()(*sp_globals.outline_device.p_close_outline)(sp_global_ptr) + +#else + +#define open_bitmap(x_set_width, y_set_width, xmin, xmax, ymin, ymax) sp_open_bitmap(sp_global_ptr, x_set_width, y_set_width, xmin, xmax, ymin, ymax) +#define set_bitmap_bits(y, xbit1, xbit2) sp_set_bitmap_bits(sp_global_ptr, y, xbit1, xbit2) +#define close_bitmap() sp_close_bitmap(sp_global_ptr) + +#define open_outline(x_set_width, y_set_width, xmin, xmax, ymin, ymax) sp_open_outline(sp_global_ptr, x_set_width, y_set_width, xmin, xmax, ymin, ymax) +#define start_new_char() sp_start_new_char(sp_global_ptr ) +#define start_contour(x,y,outside) sp_start_contour(sp_global_ptr, x,y,outside) +#define curve_to(x1,y1,x2,y2,x3,y3) sp_curve_to(sp_global_ptr, x1,y1,x2,y2,x3,y3) +#define line_to(x,y) sp_line_to(sp_global_ptr, x,y) +#define close_contour() sp_close_contour(sp_global_ptr) +#define close_outline() sp_close_outline(sp_global_ptr) + +#endif +#endif + + diff --git a/nx-X11/lib/font/Speedo/speedo.h b/nx-X11/lib/font/Speedo/speedo.h new file mode 100644 index 000000000..5eb516c1c --- /dev/null +++ b/nx-X11/lib/font/Speedo/speedo.h @@ -0,0 +1,890 @@ +/* $Xorg: speedo.h,v 1.3 2000/08/17 19:46:27 cpqbld Exp $ */ + +/* + +Copyright 1989-1991, Bitstream Inc., Cambridge, MA. +You are hereby granted permission under all Bitstream propriety rights to +use, copy, modify, sublicense, sell, and redistribute the Bitstream Speedo +software and the Bitstream Charter outline font for any purpose and without +restrictions; provided, that this notice is left intact on all copies of such +software or font and that Bitstream's trademark is acknowledged as shown below +on all unmodified copies of such font. + +BITSTREAM CHARTER is a registered trademark of Bitstream Inc. + + +BITSTREAM INC. DISCLAIMS ANY AND ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING +WITHOUT LIMITATION THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE. BITSTREAM SHALL NOT BE LIABLE FOR ANY DIRECT OR INDIRECT +DAMAGES, INCLUDING BUT NOT LIMITED TO LOST PROFITS, LOST DATA, OR ANY OTHER +INCIDENTAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF OR IN ANY WAY CONNECTED +WITH THE SPEEDO SOFTWARE OR THE BITSTREAM CHARTER OUTLINE FONT. + +*/ +/* $XFree86: xc/lib/font/Speedo/speedo.h,v 3.5 2001/01/17 19:43:18 dawes Exp $ */ + +#ifndef _SPEEDO_H_ +#define _SPEEDO_H_ + +#include <X11/Xmd.h> + +/***************************** S P E E D O . H ******************************* + ****************************************************************************/ + +/***** USER OPTIONS OVERRIDE DEFAULTS ******/ +#include "useropt.h" + +/***** CONFIGURATION DEFINITIONS *****/ + +#ifndef INCL_CLIPPING +#define INCL_CLIPPING 0 /* 0 indicates CLIPPING code is not compiled in*/ +#endif + +#ifndef INCL_SQUEEZING +#define INCL_SQUEEZING 0 /* 0 indicates SQUEEZE code is not compiled in*/ +#endif + +#ifndef INCL_EXT +#define INCL_EXT 1 /* 1 to include extended font support */ +#endif /* 0 to omit extended font support */ + +#ifndef INCL_RULES +#define INCL_RULES 1 /* 1 to include intelligent scaling support */ +#endif /* 0 to omit intelligent scaling support */ + +#ifndef INCL_BLACK +#define INCL_BLACK 1 /* 1 to include blackwriter output support */ +#endif /* 0 to omit output mode 0 support */ + +#ifndef INCL_SCREEN +#define INCL_SCREEN 0 /* 1 to include screen writeroutput support */ +#endif /* 0 to omit support */ + +#ifndef INCL_OUTLINE +#define INCL_OUTLINE 0 /* 1 to include outline output support */ +#endif /* 0 to omit output mode 2 support */ + +#ifndef INCL_2D +#define INCL_2D 0 /* 1 to include 2d blackwriter output support */ +#endif /* 0 to omit output mode 3 support */ + +#ifndef INCL_USEROUT +#define INCL_USEROUT 0 /* 1 to include user defined output module support */ +#endif /* 0 to omit user defined output module support */ + +#ifndef INCL_LCD +#define INCL_LCD 1 /* 1 to include load char data support*/ +#endif /* 0 to omit load char data support */ +#ifndef INCL_ISW +#define INCL_ISW 0 /* 1 to include imported width support */ +#endif /* 0 to omit imported width support */ + +#ifndef INCL_METRICS +#define INCL_METRICS 1 /* 1 to include metrics support */ +#endif /* 0 to omit metrics support */ + +#ifndef INCL_KEYS +#define INCL_KEYS 0 /* 1 to include multi key support */ +#endif /* 0 to omit multi key support */ + +#ifndef INCL_MULTIDEV +#define INCL_MULTIDEV 0 /* 1 to include multiple output device support */ +#endif /* 0 to omit multi device support */ + +#ifndef SHORT_LISTS +#define SHORT_LISTS 1 /* 1 to allocate small intercept lists */ +#endif + +#ifndef INCL_PLAID_OUT +#define INCL_PLAID_OUT 0 /* 1 to include plaid data monitoring */ +#endif /* 0 to omit plaid data monitoring */ + +#ifndef FONTFAR /* if Intel mixed memory model implementation */ +#define FONTFAR /* pointer type modifier for font buffer */ +#endif + +#ifndef STACKFAR /* if Intel mixed memory model implementation */ +#define STACKFAR /* pointer type modifier for font buffer */ +#endif + +#ifndef GLOBALFAR +#define GLOBALFAR +#endif + +#define MODE_BLACK 0 +#define MODE_SCREEN MODE_BLACK + INCL_BLACK +#define MODE_OUTLINE MODE_SCREEN + INCL_SCREEN +#define MODE_2D MODE_OUTLINE + INCL_OUTLINE + +#ifdef DYNAMIC_ALLOC +#if DYNAMIC_ALLOC +#define STATIC_ALLOC 0 +#endif +#endif + +#ifdef REENTRANT_ALLOC +#if REENTRANT_ALLOC +#define STATIC_ALLOC 0 +#endif +#endif + +#ifndef STATIC_ALLOC +#define STATIC_ALLOC 1 +#endif + +#ifndef DYNAMIC_ALLOC +#define DYNAMIC_ALLOC 0 +#endif + +#ifndef REENTRANT_ALLOC +#define REENTRANT_ALLOC 0 +#endif + +/***** TYPE DEFINITIONS *****/ + +#ifndef STDEF +#ifndef SPD_BMAP + +typedef INT8 fix7; + +typedef double real; + +typedef CARD8 ufix8; +#ifndef VFONT +typedef CARD8 boolean; +#endif +#endif + +typedef INT16 fix15; + +typedef CARD16 ufix16; + +typedef INT32 fix31; + +typedef CARD32 ufix32; +#endif + +/***** GENERAL CONSTANTS *****/ + +#ifndef FALSE +#define FALSE 0 +#define TRUE 1 +#endif + +#ifndef NULL +#include <stddef.h> +#endif + +#define FUNCTION + +#define BIT0 0x01 +#define BIT1 0x02 +#define BIT2 0x04 +#define BIT3 0x08 +#define BIT4 0x10 +#define BIT5 0x20 +#define BIT6 0x40 +#define BIT7 0x80 + +#if INCL_EXT /* Extended fonts supported? */ + +#define MAX_CONSTR 750 /* Max constraints (incl 4 dummies) */ +#define MAX_CTRL_ZONES 256 /* Max number of controlled orus */ +#define MAX_INT_ZONES 256 /* Max number of interpolation zones */ + +#else /* Compact fonts only supported */ + +#define MAX_CONSTR 512 /* Max constraints (incl 4 dummies) */ +#define MAX_CTRL_ZONES 64 /* Max number of controlled orus */ +#define MAX_INT_ZONES 64 /* Max number of interpolation zones */ + +#endif + +#define SCALE_SHIFT 12 /* Binary point positiion for scale values */ +#define SCALE_RND 2048 /* Rounding bit for scaling transformation */ +#define ONE_SCALE 4096 /* Unity scale value */ + +#ifdef INCL_SCREEN /* constants used by Screenwriter module */ +#define LEFT_INT 1 /* left intercept */ +#define END_INT 2 /* last intercept */ +#define FRACTION 0xFC /* fractional portion of intercept type list */ +#endif + +#if INCL_SQUEEZING || INCL_CLIPPING /* constants used by SQUEEZEing code */ +#define EM_TOP 764 +#define EM_BOT -236 +#endif + +/***** STRUCTURE DEFINITIONS *****/ +#if REENTRANT_ALLOC +#define PROTO_DECL1 struct speedo_global_data GLOBALFAR *sp_global_ptr +#define PROTO_DECL2 PROTO_DECL1 , +#else +#define PROTO_DECL1 void +#define PROTO_DECL2 +#endif + +typedef +struct buff_tag + { + ufix8 FONTFAR *org; /* Pointer to start of buffer */ + ufix32 no_bytes; /* Size of buffer in bytes */ + } +buff_t; /* Buffer descriptor */ + +typedef struct constr_tag + { + ufix8 FONTFAR *org; /* Pointer to first byte in constr data */ + ufix16 font_id; /* Font id for calculated data */ + fix15 xppo; /* X pixels per oru for calculated data */ + fix15 yppo; /* Y pixels per oru for calculated data */ + boolean font_id_valid; /* TRUE if font id valid */ + boolean data_valid; /* TRUE if calculated data valid */ + boolean active; /* TRUE if constraints enabled */ + } +constr_t; /* Constraint data state */ + +typedef struct kern_tag + { + ufix8 FONTFAR *tkorg; /* First byte of track kerning data */ + ufix8 FONTFAR *pkorg; /* First byte of pair kerning data */ + fix15 no_tracks; /* Number of kerning tracks */ + fix15 no_pairs; /* Number of kerning pairs */ + } +kern_t; /* Kerning control block */ + +typedef struct specs_tag + { + buff_t STACKFAR *pfont; /* Pointer to font data */ + fix31 xxmult; /* Coeff of X orus to compute X pix */ + fix31 xymult; /* Coeff of Y orus to compute X pix */ + fix31 xoffset; /* Constant to compute X pix */ + fix31 yxmult; /* Coeff of X orus to compute Y pix */ + fix31 yymult; /* Coeff of Y orus to compute Y pix */ + fix31 yoffset; /* Constant to compute Y pix */ + ufix32 flags; /* Mode flags: */ + /* Bit 0 - 2: Output module selector: */ + /* Bit 3: Send curves to output module*/ + /* Bit 4: Use linear scaling if set */ + /* Bit 5: Inhibit constraint table */ + /* Bit 6: Import set width if set */ + /* Bit 7: not used */ + /* Bit 8: Squeeze left if set */ + /* Bit 9: Squeeze right if set */ + /* Bit 10: Squeeze top if set */ + /* Bit 11: Squeeze bottom if set */ + /* Bit 12: Clip left if set */ + /* Bit 13: Clip right if set */ + /* Bit 14: Clip top if set */ + /* Bit 15: Clip bottom if set */ + /* Bits 16-31 not used */ + void *out_info; /* information for output module */ + } +specs_t; /* Specs structure for fw_set_specs */ + +typedef struct tcb_tag + { + fix15 xxmult; /* Linear coeff of Xorus to compute Xpix */ + fix15 xymult; /* Linear coeff of Yorus to compute Xpix */ + fix31 xoffset; /* Linear constant to compute Xpix */ + fix15 yxmult; /* Linear coeff of Xorus to compute Ypix */ + fix15 yymult; /* Linear coeff of Yorus to compute Ypix */ + fix31 yoffset; /* Linear constant to compute Ypix */ + fix15 xppo; /* Pixels per oru in X dimension of char */ + fix15 yppo; /* Pixels per oru in Y dimension of char */ + fix15 xpos; /* Origin in X dimension of character */ + fix15 ypos; /* Origin in Y dimension of character */ + ufix16 xtype; /* Transformation type for X oru coords */ + ufix16 ytype; /* Transformation type for Y oru coords */ + ufix16 xmode; /* Transformation mode for X oru coords */ + ufix16 ymode; /* Transformation mode for Y oru coords */ + fix15 mirror; /* Transformation creates mirror image */ + } +tcb_t; /* Transformation control block */ + +typedef struct point_tag + { + fix15 x; /* X coord of point (shifted pixels) */ + fix15 y; /* Y coord of point (shifted pixels) */ + } +point_t; /* Point in device space */ + +typedef struct band_tag + { + fix15 band_max; + fix15 band_min; + fix15 band_array_offset; + fix15 band_floor; + fix15 band_ceiling; + } band_t; + +typedef struct bbox_tag + { + fix31 xmin; + fix31 xmax; + fix31 ymin; + fix31 ymax; + } bbox_t; + +#if SHORT_LISTS +#define MAX_INTERCEPTS 256 /* Max storage for intercepts */ +typedef ufix8 cdr_t; /* 8 bit links in intercept chains */ +#else +#define MAX_INTERCEPTS 1000 /* Max storage for intercepts */ +typedef ufix16 cdr_t; /* 16 bit links in intercept chains */ +#endif + +#if REENTRANT_ALLOC + +typedef struct intercepts_tag + { + fix15 car[MAX_INTERCEPTS]; + fix15 cdr[MAX_INTERCEPTS]; +#if INCL_SCREEN + ufix8 inttype[MAX_INTERCEPTS]; + ufix8 leftedge; + ufix16 fracpix; +#endif + } intercepts_t; + +typedef struct plaid_tag + { + fix15 orus[MAX_CTRL_ZONES]; /* Controlled coordinate table (orus) */ +#if INCL_RULES + fix15 pix[MAX_CTRL_ZONES]; /* Controlled coordinate table (sub-pixels) */ + fix15 mult[MAX_INT_ZONES]; /* Interpolation multiplier table */ + fix31 offset[MAX_INT_ZONES]; /* Interpolation offset table */ +#endif + } plaid_t; +#endif + +#if INCL_MULTIDEV +typedef struct bitmap_tag + { + void (*p_open_bitmap)(PROTO_DECL2 fix31 x_set_width, fix31 y_set_width, fix31 xorg, fix31 yorg, fix15 xsize,fix15 ysize); + void (*p_set_bits)(PROTO_DECL2 fix15 y, fix15 xbit1, fix15 xbit2); + void (*p_close_bitmap)(PROTO_DECL1); + } bitmap_t; + +typedef struct outline_tag + { + void (*p_open_outline)(PROTO_DECL2 fix31 x_set_width, fix31 y_set_width, fix31 xmin, fix31 xmax, fix31 ymin,fix31 ymax); + void (*p_start_char)(PROTO_DECL1); + void (*p_start_contour)(PROTO_DECL2 fix31 x,fix31 y,boolean outside); + void (*p_curve)(PROTO_DECL2 fix31 x1, fix31 y1, fix31 x2, fix31 y2, fix31 x3, fix31 y3); + void (*p_line)(PROTO_DECL2 fix31 x, fix31 y); + void (*p_close_contour)(PROTO_DECL1); + void (*p_close_outline)(PROTO_DECL1); + } outline_t; +#endif + +/* ---------------------------------------------------*/ +/**** MAIN GLOBAL DATA STRUCTURE, SPEEDO_GLOBALS *****/ + +typedef struct speedo_global_data + { +/* do_char.c data definitions */ +#if INCL_METRICS /* Metrics functions supported? */ + kern_t kern; /* Kerning control block */ +#endif /* endif incl_metrics */ + point_t Psw; /* End of escapement vector (1/65536 pixel units) */ + +#if INCL_LCD /* Dynamic load character data supported? */ + fix15 cb_offset; /* Offset to sub-char data in char buffer */ +#endif /* endif incl_lcd */ + +/* do_trns.c data definitions */ + point_t P0; /* Current point (sub-pixels) */ + fix15 x_orus; /* Current X argument (orus) */ + fix15 y_orus; /* Current Y argument (orus) */ + fix15 x_pix; /* Current X argument (sub-pixels) */ + fix15 y_pix; /* Current Y argument (sub-pixels) */ + ufix8 x_int; /* Current X interpolation zone */ + ufix8 y_int; /* Current Y interpolation zone */ + +#if INCL_MULTIDEV && INCL_OUTLINE + outline_t outline_device; + boolean outline_device_set; +#endif + +#if INCL_BLACK || INCL_SCREEN || INCL_2D +#if INCL_MULTIDEV + bitmap_t bitmap_device; + boolean bitmap_device_set; +#endif + band_t y_band; /* Y current band(whole pixels) */ + + struct set_width_tag + { + fix31 x; + fix31 y; + } set_width; /* Character escapement vector */ + + boolean first_pass; /* TRUE during first pass thru outline data */ + boolean extents_running; /* T if extent accumulation for each vector */ + fix15 x0_spxl; /* X coord of current point (sub pixels) */ + fix15 y0_spxl; /* Y coord of current point (sub pixels) */ + fix15 y_pxl; /* Y coord of current point (whole pixels) */ +#if REENTRANT_ALLOC + intercepts_t STACKFAR *intercepts; +#else /* else if not reentrant */ + fix15 car[MAX_INTERCEPTS]; /* Data field of intercept storage */ + cdr_t cdr[MAX_INTERCEPTS]; /* Link field of intercept storage */ +#if INCL_SCREEN + ufix8 inttype[MAX_INTERCEPTS]; + ufix8 leftedge; + ufix16 fracpix; +#endif /* endif incl_screen */ +#endif /* endif reentrant */ + fix15 bmap_xmin; /* Min X value (sub-pixel units) */ + fix15 bmap_xmax; /* Max X value (sub-pixel units) */ + fix15 bmap_ymin; /* Min Y value (sub-pixel units) */ + fix15 bmap_ymax; /* Max Y value (sub-pixel units) */ + fix15 no_y_lists; /* Number of active intercept lists */ + fix15 first_offset; /* Index of first active list cell */ + fix15 next_offset; /* Index of next free list cell */ + boolean intercept_oflo; /* TRUE if intercepts data lost */ +#endif /* endif incl_black, incl_screen, incl_2d */ + +/* bounding box now used by all output modules, including outline */ + fix15 xmin; /* Min X value in whole character */ + fix15 xmax; /* Max X value in whole character */ + fix15 ymin; /* Min Y value in whole character */ + fix15 ymax; /* Max Y value in whole character */ + +#if INCL_2D + fix15 no_x_lists; /* Number of active x intercept lists */ + band_t x_band; /* X current band(whole pixels) */ + boolean x_scan_active; /* X scan flag during scan conversion */ +#endif + +/* reset.c data definitions */ + ufix16 key32; /* Decryption keys 3,2 combined */ + ufix8 key4; /* Decryption key 4 */ + ufix8 key6; /* Decryption key 6 */ + ufix8 key7; /* Decryption key 7 */ + ufix8 key8; /* Decryption key 8 */ + +/* set_spcs.c data definitions */ + buff_t font; + buff_t GLOBALFAR *pfont; /* Pointer to font buffer structure */ + fix31 font_buff_size; /* Number of bytes loaded in font buffer */ + ufix8 FONTFAR *pchar_dir; /* Pointer to character directory */ + fix15 first_char_idx; /* Index to first character in font */ + fix15 no_chars_avail; /* Total characters in font layout */ + fix15 orus_per_em; /* Outline resolution */ + fix15 metric_resolution; /* metric resolution for setwidths, kerning pairs + (defaults to orus_per_em) */ + tcb_t tcb0; /* Top level transformation control block */ + + boolean specs_valid; /* TRUE if fw_set_specs() successful */ + + fix15 depth_adj; /* Curve splitting depth adjustment */ + boolean curves_out; /* Allow curves to output module */ + fix15 output_mode; /* Output module selector */ + fix15 thresh; /* Scan conversion threshold (sub-pixels) */ + boolean normal; /* TRUE if 0 obl and mult of 90 deg rot */ + + fix15 multshift; /* Fixed point shift for multipliers */ + fix15 pixshift; /* Fixed point shift for sub-pixels */ + fix15 poshift; /* Left shift from pixel to output format */ + fix15 mpshift; /* Fixed point shift for mult to sub-pixels */ + fix31 multrnd; /* 0.5 in multiplier units */ + fix15 pixrnd; /* 0.5 in sub-pixel units */ + fix31 mprnd; /* 0.5 sub-pixels in multiplier units */ + fix15 pixfix; /* Mask to remove fractional pixels */ + fix15 onepix; /* 1.0 pixels in sub-pixel units */ + + boolean (*init_out)(PROTO_DECL2 specs_t GLOBALFAR *specsarg); + boolean (*begin_char)(PROTO_DECL2 point_t Psw,point_t Pmin,point_t Pmax); + void (*begin_sub_char)(PROTO_DECL2 point_t Psw,point_t Pmin,point_t Pmax); + void (*begin_contour)(PROTO_DECL2 point_t P1,boolean outside); + void (*curve)(PROTO_DECL2 point_t P1, point_t P2, point_t P3, fix15 depth); + void (*line)(PROTO_DECL2 point_t P1); + void (*end_contour)(PROTO_DECL1); + void (*end_sub_char)(PROTO_DECL1); + boolean (*end_char)(PROTO_DECL1); + specs_t GLOBALFAR *pspecs; /* Pointer to specifications bundle */ + specs_t specs; /* copy specs onto stack */ + ufix8 FONTFAR *font_org; /* Pointer to start of font data */ + ufix8 FONTFAR *hdr2_org; /* Pointer to start of private header data */ + +/* set_trns.c data definitions */ + tcb_t tcb; /* Current transformation control block */ + ufix8 Y_edge_org; /* Index to first Y controlled coordinate */ + ufix8 Y_int_org; /* Index to first Y interpolation zone */ + fix31 rnd_xmin; /* rounded out value of xmin for int-char spac. fix */ + +#if REENTRANT_ALLOC + plaid_t STACKFAR *plaid; +#else /* if not reentrant */ + fix15 orus[MAX_CTRL_ZONES]; /* Controlled coordinate table (orus) */ +#if INCL_RULES + fix15 pix[MAX_CTRL_ZONES]; /* Controlled coordinate table (sub-pixels) */ + fix15 mult[MAX_INT_ZONES]; /* Interpolation multiplier table */ + fix31 offset[MAX_INT_ZONES]; /* Interpolation offset table */ +#endif /* endif incl_rules */ +#endif /* endif not reentrant */ + + fix15 no_X_orus; /* Number of X controlled coordinates */ + fix15 no_Y_orus; /* Number of Y controlled coordinates */ + ufix16 Y_constr_org; /* Origin of constraint table in font data */ + +#if INCL_RULES + constr_t constr; /* Constraint data state */ + boolean c_act[MAX_CONSTR]; /* TRUE if constraint currently active */ + fix15 c_pix[MAX_CONSTR]; /* Size of constrained zone if active */ +#endif +#if INCL_ISW + boolean import_setwidth_act; /* boolean to indicate imported setwidth */ + boolean isw_modified_constants; + ufix32 imported_width; /* value of imported setwidth */ + fix15 isw_xmax; /* maximum oru value for constants*/ +#endif +#if INCL_SQUEEZING || INCL_ISW + fix15 setwidth_orus; /* setwidth value in orus */ + /* bounding box in orus for squeezing */ + fix15 bbox_xmin_orus; /* X minimum in orus */ + fix15 bbox_xmax_orus; /* X maximum in orus */ + fix15 bbox_ymin_orus; /* Y minimum in orus */ + fix15 bbox_ymax_orus; /* Y maximum in orus */ +#endif +#ifdef INCL_SQUEEZING + boolean squeezing_compound; /* flag to indicate a compound character*/ +#endif +#ifdef INCL_CLIPPING + fix31 clip_xmax; + fix31 clip_ymax; + fix31 clip_xmin; + fix31 clip_ymin; +#endif + } SPEEDO_GLOBALS; + +/*********************************************************************************** + * + * Speedo global data structure allocation + * + ***********************************************************************************/ + +#ifdef SET_SPCS +#define EXTERN +#else +#define EXTERN extern +#endif +#if STATIC_ALLOC +EXTERN SPEEDO_GLOBALS GLOBALFAR sp_globals; +#define sp_intercepts sp_globals +#define sp_plaid sp_globals +#else +#if DYNAMIC_ALLOC +EXTERN SPEEDO_GLOBALS GLOBALFAR *sp_global_ptr; +#define sp_globals (*sp_global_ptr) +#define sp_intercepts (*sp_global_ptr) +#define sp_plaid (*sp_global_ptr) +#else +#if REENTRANT_ALLOC +#define sp_globals (*sp_global_ptr) +#define sp_intercepts (*(*sp_global_ptr).intercepts) +#define sp_plaid (*(*sp_global_ptr).plaid) +#endif +#endif +#endif +#ifdef EXTERN +#undef EXTERN +#endif + + +/***** PUBLIC FONT HEADER OFFSET CONSTANTS *****/ +#define FH_FMVER 0 /* U D4.0 CR LF NULL NULL 8 bytes */ +#define FH_FNTSZ 8 /* U Font size (bytes) 4 bytes */ +#define FH_FBFSZ 12 /* U Min font buffer size (bytes) 4 bytes */ +#define FH_CBFSZ 16 /* U Min char buffer size (bytes) 2 bytes */ +#define FH_HEDSZ 18 /* U Header size (bytes) 2 bytes */ +#define FH_FNTID 20 /* U Source Font ID 2 bytes */ +#define FH_SFVNR 22 /* U Source Font Version Number 2 bytes */ +#define FH_FNTNM 24 /* U Source Font Name 70 bytes */ +#define FH_MDATE 94 /* U Manufacturing Date 10 bytes */ +#define FH_LAYNM 104 /* U Layout Name 70 bytes */ +#define FH_CPYRT 174 /* U Copyright Notice 78 bytes */ +#define FH_NCHRL 252 /* U Number of Chars in Layout 2 bytes */ +#define FH_NCHRF 254 /* U Total Number of Chars in Font 2 bytes */ +#define FH_FCHRF 256 /* U Index of first char in Font 2 bytes */ +#define FH_NKTKS 258 /* U Number of kerning tracks in font 2 bytes */ +#define FH_NKPRS 260 /* U Number of kerning pairs in font 2 bytes */ +#define FH_FLAGS 262 /* U Font flags 1 byte: */ + /* Bit 0: Extended font */ + /* Bit 1: not used */ + /* Bit 2: not used */ + /* Bit 3: not used */ + /* Bit 4: not used */ + /* Bit 5: not used */ + /* Bit 6: not used */ + /* Bit 7: not used */ +#define FH_CLFGS 263 /* U Classification flags 1 byte: */ + /* Bit 0: Italic */ + /* Bit 1: Monospace */ + /* Bit 2: Serif */ + /* Bit 3: Display */ + /* Bit 4: not used */ + /* Bit 5: not used */ + /* Bit 6: not used */ + /* Bit 7: not used */ +#define FH_FAMCL 264 /* U Family Classification 1 byte: */ + /* 0: Don't care */ + /* 1: Serif */ + /* 2: Sans serif */ + /* 3: Monospace */ + /* 4: Script or calligraphic */ + /* 5: Decorative */ + /* 6-255: not used */ +#define FH_FRMCL 265 /* U Font form Classification 1 byte: */ + /* Bits 0-3 (width type): */ + /* 0-3: not used */ + /* 4: Condensed */ + /* 5: not used */ + /* 6: Semi-condensed */ + /* 7: not used */ + /* 8: Normal */ + /* 9: not used */ + /* 10: Semi-expanded */ + /* 11: not used */ + /* 12: Expanded */ + /* 13-15: not used */ + /* Bits 4-7 (Weight): */ + /* 0: not used */ + /* 1: Thin */ + /* 2: Ultralight */ + /* 3: Extralight */ + /* 4: Light */ + /* 5: Book */ + /* 6: Normal */ + /* 7: Medium */ + /* 8: Semibold */ + /* 9: Demibold */ + /* 10: Bold */ + /* 11: Extrabold */ + /* 12: Ultrabold */ + /* 13: Heavy */ + /* 14: Black */ + /* 15-16: not used */ +#define FH_SFNTN 266 /* U Short Font Name 32 bytes */ +#define FH_SFACN 298 /* U Short Face Name 16 bytes */ +#define FH_FNTFM 314 /* U Font form 14 bytes */ +#define FH_ITANG 328 /* U Italic angle 2 bytes (1/256th deg) */ +#define FH_ORUPM 330 /* U Number of ORUs per em 2 bytes */ +#define FH_WDWTH 332 /* U Width of Wordspace 2 bytes */ +#define FH_EMWTH 334 /* U Width of Emspace 2 bytes */ +#define FH_ENWTH 336 /* U Width of Enspace 2 bytes */ +#define FH_TNWTH 338 /* U Width of Thinspace 2 bytes */ +#define FH_FGWTH 340 /* U Width of Figspace 2 bytes */ +#define FH_FXMIN 342 /* U Font-wide min X value 2 bytes */ +#define FH_FYMIN 344 /* U Font-wide min Y value 2 bytes */ +#define FH_FXMAX 346 /* U Font-wide max X value 2 bytes */ +#define FH_FYMAX 348 /* U Font-wide max Y value 2 bytes */ +#define FH_ULPOS 350 /* U Underline position 2 bytes */ +#define FH_ULTHK 352 /* U Underline thickness 2 bytes */ +#define FH_SMCTR 354 /* U Small caps transformation 6 bytes */ +#define FH_DPSTR 360 /* U Display sups transformation 6 bytes */ +#define FH_FNSTR 366 /* U Footnote sups transformation 6 bytes */ +#define FH_ALSTR 372 /* U Alpha sups transformation 6 bytes */ +#define FH_CMITR 378 /* U Chemical infs transformation 6 bytes */ +#define FH_SNMTR 384 /* U Small nums transformation 6 bytes */ +#define FH_SDNTR 390 /* U Small denoms transformation 6 bytes */ +#define FH_MNMTR 396 /* U Medium nums transformation 6 bytes */ +#define FH_MDNTR 402 /* U Medium denoms transformation 6 bytes */ +#define FH_LNMTR 408 /* U Large nums transformation 6 bytes */ +#define FH_LDNTR 414 /* U Large denoms transformation 6 bytes */ + /* Transformation data format: */ + /* Y position 2 bytes */ + /* X scale 2 bytes (1/4096ths) */ + /* Y scale 2 bytes (1/4096ths) */ +#define SIZE_FW FH_LDNTR + 6 /* size of nominal font header */ +#define EXP_FH_METRES SIZE_FW /* offset to expansion field metric resolution (optional) */ + + + +/***** MODE FLAGS CONSTANTS *****/ +#define CURVES_OUT 0X0008 /* Output module accepts curves */ +#define BOGUS_MODE 0X0010 /* Linear scaling mode */ +#define CONSTR_OFF 0X0020 /* Inhibit constraint table */ +#define IMPORT_WIDTHS 0X0040 /* Imported width mode */ +#define SQUEEZE_LEFT 0X0100 /* Squeeze left mode */ +#define SQUEEZE_RIGHT 0X0200 /* Squeeze right mode */ +#define SQUEEZE_TOP 0X0400 /* Squeeze top mode */ +#define SQUEEZE_BOTTOM 0X0800 /* Squeeze bottom mode */ +#define CLIP_LEFT 0X1000 /* Clip left mode */ +#define CLIP_RIGHT 0X2000 /* Clip right mode */ +#define CLIP_TOP 0X4000 /* Clip top mode */ +#define CLIP_BOTTOM 0X8000 /* Clip bottom mode */ + +/*********************************************************************************** + * + * Speedo function declarations - use prototypes if available + * + ***********************************************************************************/ + +/* do_char.c functions */ +ufix16 sp_get_char_id(PROTO_DECL2 ufix16 char_index); +boolean sp_make_char(PROTO_DECL2 ufix16 char_index); +#if INCL_ISW +fix31 sp_compute_isw_scale(PROTO_DECL2); +static boolean sp_do_make_char(PROTO_DECL2 ufix16 char_index); +boolean sp_make_char_isw(PROTO_DECL2 ufix16 char_index, ufix32 imported_width); +static boolean sp_reset_xmax(PROTO_DECL2 fix31 xmax); +#endif +#if INCL_ISW || INCL_SQUEEZING +static void sp_preview_bounding_box(PROTO_DECL2 ufix8 FONTFAR *pointer,ufix8 format); +#endif + +#if INCL_METRICS /* Metrics functions supported? */ +fix31 sp_get_char_width(PROTO_DECL2 ufix16 char_index); +fix15 sp_get_track_kern(PROTO_DECL2 fix15 track,fix15 point_size); +fix31 sp_get_pair_kern(PROTO_DECL2 ufix16 char_index1,ufix16 char_index2); +boolean sp_get_char_bbox(PROTO_DECL2 ufix16 char_index, bbox_t *bbox); +#endif + +/* do_trns.c functions */ +ufix8 FONTFAR *sp_read_bbox(PROTO_DECL2 ufix8 FONTFAR *pointer,point_t STACKFAR *pPmin,point_t STACKFAR *pPmax,boolean set_flag); +void sp_proc_outl_data(PROTO_DECL2 ufix8 FONTFAR *pointer); + +/* out_blk.c functions */ +#if INCL_BLACK +boolean sp_init_black(PROTO_DECL2 specs_t GLOBALFAR *specsarg); +boolean sp_begin_char_black(PROTO_DECL2 point_t Psw,point_t Pmin,point_t Pmax); +void sp_begin_contour_black(PROTO_DECL2 point_t P1,boolean outside); +void sp_line_black(PROTO_DECL2 point_t P1); +boolean sp_end_char_black(PROTO_DECL1); +#endif + +/* out_scrn.c functions */ +#if INCL_SCREEN +boolean sp_init_screen(PROTO_DECL2 specs_t GLOBALFAR *specsarg); +boolean sp_begin_char_screen(PROTO_DECL2 point_t Psw,point_t Pmin,point_t Pmax); +void sp_begin_contour_screen(PROTO_DECL2 point_t P1,boolean outside); +void sp_curve_screen(PROTO_DECL2 point_t P1,point_t P2,point_t P3, fix15 depth); +void sp_scan_curve_screen(PROTO_DECL2 fix31 X0,fix31 Y0,fix31 X1,fix31 Y1,fix31 X2,fix31 Y2,fix31 X3,fix31 Y3); +void sp_vert_line_screen(PROTO_DECL2 fix31 x, fix15 y1, fix15 y2); +void sp_line_screen(PROTO_DECL2 point_t P1); +void sp_end_contour_screen(PROTO_DECL1); +boolean sp_end_char_screen(PROTO_DECL1); +#endif + +/* out_outl.c functions */ +#if INCL_OUTLINE +#if INCL_MULTIDEV +boolean sp_set_outline_device(PROTO_DECL2 outline_t *ofuncs, ufix16 size); +#endif + + +boolean sp_init_outline(PROTO_DECL2 specs_t GLOBALFAR *specsarg); +boolean sp_begin_char_outline(PROTO_DECL2 point_t Psw,point_t Pmin,point_t Pmax); +void sp_begin_sub_char_outline(PROTO_DECL2 point_t Psw,point_t Pmin,point_t Pmax); +void sp_begin_contour_outline(PROTO_DECL2 point_t P1,boolean outside); +void sp_curve_outline(PROTO_DECL2 point_t P1,point_t P2,point_t P3, fix15 depth); +void sp_line_outline(PROTO_DECL2 point_t P1); +void sp_end_contour_outline(PROTO_DECL1); +void sp_end_sub_char_outline(PROTO_DECL1); +boolean sp_end_char_outline(PROTO_DECL1); +#endif + +/* out_bl2d.c functions */ +#if INCL_2D +boolean sp_init_2d(PROTO_DECL2 specs_t GLOBALFAR *specsarg); +boolean sp_begin_char_2d(PROTO_DECL2 point_t Psw,point_t Pmin,point_t Pmax); +void sp_begin_contour_2d(PROTO_DECL2 point_t P1,boolean outside); +void sp_line_2d(PROTO_DECL2 point_t P1); +boolean sp_end_char_2d(PROTO_DECL1); +#endif + +/* out_util.c functions */ +#if INCL_BLACK || INCL_SCREEN || INCL_2D + +#if INCL_MULTIDEV +boolean sp_set_bitmap_device(PROTO_DECL2 bitmap_t *bfuncs, ufix16 size); +#endif + +void sp_init_char_out(PROTO_DECL2 point_t Psw, point_t Pmin, point_t Pmax); +void sp_begin_sub_char_out(PROTO_DECL2 point_t Psw, point_t Pmin, point_t Pmax); +void sp_curve_out(PROTO_DECL2 point_t P1, point_t P2, point_t P3, fix15 depth); +void sp_end_contour_out(PROTO_DECL1); +void sp_end_sub_char_out(PROTO_DECL1); +void sp_init_intercepts_out(PROTO_DECL1); +void sp_restart_intercepts_out(PROTO_DECL1); +void sp_set_first_band_out(PROTO_DECL2 point_t Pmin, point_t Pmax); +void sp_reduce_band_size_out(PROTO_DECL1); +boolean sp_next_band_out(PROTO_DECL1); +#endif + +#if INCL_USEROUT +boolean sp_init_userout(specs_t *specsarg); +#endif + + +/* reset.c functions */ +void sp_reset(PROTO_DECL1); +#if INCL_KEYS +void sp_set_key(PROTO_DECL2 ufix8 key[]); +#endif +ufix16 sp_get_cust_no(PROTO_DECL2 buff_t font_buff); + +/* set_spcs.c functions */ +boolean sp_set_specs(PROTO_DECL2 specs_t STACKFAR *specsarg); +void sp_type_tcb(PROTO_DECL2 tcb_t GLOBALFAR *ptcb); + +fix31 sp_read_long(PROTO_DECL2 ufix8 FONTFAR *pointer); +fix15 sp_read_word_u(PROTO_DECL2 ufix8 FONTFAR *pointer); + +/* set_trns.c functions */ +void sp_init_tcb(PROTO_DECL1); +void sp_scale_tcb(PROTO_DECL2 tcb_t GLOBALFAR *ptcb,fix15 x_pos,fix15 y_pos,fix15 x_scale,fix15 y_scale); +ufix8 FONTFAR *sp_plaid_tcb(PROTO_DECL2 ufix8 FONTFAR *pointer,ufix8 format); +ufix8 FONTFAR *sp_skip_interpolation_table(PROTO_DECL2 ufix8 FONTFAR *pointer, ufix8 format); +ufix8 FONTFAR *sp_skip_control_zone(PROTO_DECL2 ufix8 FONTFAR *pointer, ufix8 format); + +ufix8 FONTFAR *sp_read_oru_table(PROTO_DECL2 ufix8 FONTFAR *pointer); +#if INCL_SQUEEZING || INCL_ISW +static void sp_calculate_x_pix(PROTO_DECL2 ufix8 start_edge,ufix8 end_edge,ufix16 constr_nr,fix31 x_scale,fix31 x_offset,fix31 ppo,fix15 setwidth_pix); +#endif +#if INCL_SQUEEZING +static void sp_calculate_y_pix(PROTO_DECL2 ufix8 start_edge,ufix8 end_edge,ufix16 constr_nr,fix31 top_scale,fix31 bottom_scale,fix31 ppo,fix15 emtop_pix,fix15 embot_pix); +boolean sp_calculate_x_scale(PROTO_DECL2 fix31 *x_factor,fix31 *x_offset,fix15 no_x_ctrl_zones); +boolean sp_calculate_y_scale(PROTO_DECL2 fix31 *top_scale,fix31 *bottom_scale,fix15 first_y_zone, fix15 no_Y_ctrl_zones); +#endif + + +/* user defined functions */ + +void sp_report_error(PROTO_DECL2 fix15 n); + +#if INCL_BLACK || INCL_SCREEN || INCL_2D +void sp_open_bitmap(PROTO_DECL2 fix31 x_set_width, fix31 y_set_width, fix31 xorg, fix31 yorg, fix15 xsize,fix15 ysize); +void sp_set_bitmap_bits(PROTO_DECL2 fix15 y, fix15 xbit1, fix15 xbit2); +void sp_close_bitmap(PROTO_DECL1); +#endif + +#if INCL_OUTLINE +void sp_open_outline(PROTO_DECL2 fix31 x_set_width, fix31 y_set_width, fix31 xmin, fix31 xmax, fix31 ymin,fix31 ymax); +void sp_start_new_char(PROTO_DECL1); +void sp_start_contour(PROTO_DECL2 fix31 x,fix31 y,boolean outside); +void sp_curve_to(PROTO_DECL2 fix31 x1, fix31 y1, fix31 x2, fix31 y2, fix31 x3, fix31 y3); +void sp_line_to(PROTO_DECL2 fix31 x, fix31 y); +void sp_close_contour(PROTO_DECL1); +void sp_close_outline(PROTO_DECL1); +#endif + +#if INCL_LCD /* Dynamic load character data supported? */ +buff_t *sp_load_char_data(PROTO_DECL2 fix31 file_offset,fix15 no_bytes,fix15 cb_offset); /* Load character data from font file */ +#endif + +#if INCL_PLAID_OUT /* Plaid data monitoring included? */ +void sp_record_xint(PROTO_DECL2 fix15 int_num); /* Record xint data */ +void sp_record_yint(PROTO_DECL2 fix15 int_num); /* Record yint data */ +void sp_begin_plaid_data(PROTO_DECL1); /* Signal start of plaid data */ +void sp_begin_ctrl_zones(PROTO_DECL2 fix15, no_X_zones, fix15 no_Y_zones); /* Signal start of control zones */ +void sp_record_ctrl_zone(PROTO_DECL2 fix31 start, fix31 end, fix15 constr); /* Record control zone data */ +void sp_begin_int_zones(PROTO_DECL2 fix15 no_X_int_zones, fix15 no_Y_int_zones); /* Signal start of interpolation zones */ +void sp_record_int_zone(PROTO_DECL2 fix31 start, fix31 end); /* Record interpolation zone data */ +void sp_end_plaid_data(PROTO_DECL1); /* Signal end of plaid data */ +#endif + +#endif /* _SPEEDO_H_ */ diff --git a/nx-X11/lib/font/Speedo/spencode.c b/nx-X11/lib/font/Speedo/spencode.c new file mode 100644 index 000000000..96a13504a --- /dev/null +++ b/nx-X11/lib/font/Speedo/spencode.c @@ -0,0 +1,67 @@ +/* $Xorg: spencode.c,v 1.4 2001/02/09 02:04:00 xorgcvs Exp $ */ +/* + * Copyright 1990, 1991 Network Computing Devices; + * Portions Copyright 1987 by Digital Equipment Corporation + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the names of Network Computing Devices or Digital + * not be used in advertising or publicity pertaining to distribution of + * the software without specific, written prior permission. + * + * NETWORK COMPUTING DEVICES AND DIGITAL DISCLAIM ALL WARRANTIES WITH + * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES OR DIGITAL BE + * LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* + +Copyright 1987, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +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 OPEN GROUP 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. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + +*/ +/* $XFree86: xc/lib/font/Speedo/spencode.c,v 1.6 2001/01/17 19:43:18 dawes Exp $ */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include "spint.h" + +/* No longer needed with new encoding code */ +/* #include "bics-iso.h" + +int sp_bics_map_size = (sizeof(sp_bics_map) / (sizeof(int) * 2));*/ + +#ifdef EXTRAFONTS +#include "adobe-iso.h" + +int adobe_map_size = (sizeof(adobe_map) / (sizeof(int) * 2)); + +#endif /* EXTRAFONTS */ diff --git a/nx-X11/lib/font/Speedo/sperr.c b/nx-X11/lib/font/Speedo/sperr.c new file mode 100644 index 000000000..36ce51125 --- /dev/null +++ b/nx-X11/lib/font/Speedo/sperr.c @@ -0,0 +1,127 @@ +/* $Xorg: sperr.c,v 1.4 2001/02/09 02:04:00 xorgcvs Exp $ */ +/* + * Copyright 1990, 1991 Network Computing Devices; + * Portions Copyright 1987 by Digital Equipment Corporation + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the names of M.I.T., Network Computing Devices, + * or Digital not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. M.I.T. Network Computing Devices, or Digital + * make no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * NETWORK COMPUTING DEVICES, DIGITAL AND MIT DISCLAIM ALL WARRANTIES WITH + * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES, DIGITAL OR MIT BE + * LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +/* + +Copyright 1994, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +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 OPEN GROUP 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. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + +*/ +/* $XFree86: xc/lib/font/Speedo/sperr.c,v 1.6 2001/12/14 19:56:41 dawes Exp $ */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include "spint.h" + +#ifndef FONTMODULE +#include <stdarg.h> +#endif + +extern void ErrorF(const char* f, ...); + +void +SpeedoErr(char *str, ...) +{ + va_list v; + int a1; + + va_start(v, str); + ErrorF("Speedo: "); + a1 = va_arg(v, int); + ErrorF(str, a1); + va_end(v); +} + +/* + * Called by Speedo character generator to report an error. + * + * Since character data not available is one of those errors + * that happens many times, don't report it to user + */ +void +sp_report_error(fix15 n) +{ + switch (n) { + case 1: + SpeedoErr("Insufficient font data loaded\n"); + break; + case 3: + SpeedoErr("Transformation matrix out of range\n"); + break; + case 4: + SpeedoErr("Font format error\n"); + break; + case 5: + SpeedoErr("Requested specs not compatible with output module\n"); + break; + case 7: + SpeedoErr("Intelligent transformation requested but not supported\n"); + break; + case 8: + SpeedoErr("Unsupported output mode requested\n"); + break; + case 9: + SpeedoErr("Extended font loaded but only compact fonts supported\n"); + break; + case 10: + SpeedoErr("Font specs not set prior to use of font\n"); + break; + case 12: + break; + case 13: + SpeedoErr("Track kerning data not available()\n"); + break; + case 14: + SpeedoErr("Pair kerning data not available()\n"); + break; + default: + SpeedoErr("report_error(%d)\n", n); + break; + } +} diff --git a/nx-X11/lib/font/Speedo/spfile.c b/nx-X11/lib/font/Speedo/spfile.c new file mode 100644 index 000000000..c58c0e471 --- /dev/null +++ b/nx-X11/lib/font/Speedo/spfile.c @@ -0,0 +1,460 @@ +/* $Xorg: spfile.c,v 1.4 2001/02/09 02:04:00 xorgcvs Exp $ */ +/* + * Copyright 1990, 1991 Network Computing Devices; + * Portions Copyright 1987 by Digital Equipment Corporation + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the names of Network Computing Devices or Digital + * not be used in advertising or publicity pertaining to distribution of + * the software without specific, written prior permission. + * + * NETWORK COMPUTING DEVICES AND DIGITAL DISCLAIM ALL WARRANTIES WITH + * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES OR DIGITAL + * LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Author: Dave Lemke, Network Computing Devices Inc + */ + +/* + +Copyright 1987, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +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 OPEN GROUP 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. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + +*/ +/* $XFree86: xc/lib/font/Speedo/spfile.c,v 1.13 2001/08/13 21:46:47 dawes Exp $ */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include <X11/fonts/fntfilst.h> +#include <X11/fonts/fontenc.h> +#ifndef FONTMODULE +#include <stdio.h> +#else +#include "xf86_ansic.h" +#endif + +#include "spint.h" +#include "bics-unicode.h" + +SpeedoFontPtr sp_fp_cur = (SpeedoFontPtr) 0; + +#ifdef EXTRAFONTS +#include "ncdkeys.h" +#endif + +#include "keys.h" + +#ifdef EXTRAFONTS +static ufix8 skey[] = +{ + SKEY0, + SKEY1, + SKEY2, + SKEY3, + SKEY4, + SKEY5, + SKEY6, + SKEY7, + SKEY8 +}; /* Sample Font decryption key */ + +static ufix8 rkey[] = +{ + RKEY0, + RKEY1, + RKEY2, + RKEY3, + RKEY4, + RKEY5, + RKEY6, + RKEY7, + RKEY8 +}; /* Retail Font decryption key */ + +#endif /* EXTRAFONTS */ + +#ifdef XSAMPLEFONTS +static ufix8 xkey[] = +{ + XKEY0, + XKEY1, + XKEY2, + XKEY3, + XKEY4, + XKEY5, + XKEY6, + XKEY7, + XKEY8 +}; /* Sample Font decryption key */ +#endif + +static ufix8 mkey[] = +{ + KEY0, + KEY1, + KEY2, + KEY3, + KEY4, + KEY5, + KEY6, + KEY7, + KEY8 +}; /* Font decryption key */ + + +static fix15 +read_2b(ufix8 *ptr) +{ + fix15 tmp; + + tmp = *ptr++; + tmp = (tmp << 8) + *ptr; + return tmp; +} + +static fix31 +read_4b(ufix8 *ptr) +{ + fix31 tmp; + + tmp = *ptr++; + tmp = (tmp << 8) + *ptr++; + tmp = (tmp << 8) + *ptr++; + tmp = (tmp << 8) + *ptr; + return tmp; +} + +/* + * loads the specified char's data + */ +buff_t * +sp_load_char_data(fix31 file_offset, fix15 num, fix15 cb_offset) +{ + SpeedoMasterFontPtr master = sp_fp_cur->master; + + if (fseek(master->fp, (long) file_offset, (int) 0)) { + SpeedoErr("can't seek to char\n"); + } + if ((num + cb_offset) > master->mincharsize) { + SpeedoErr("char buf overflow\n"); + } + if (fread((master->c_buffer + cb_offset), sizeof(ufix8), num, + master->fp) != num) { + SpeedoErr("can't get char data\n"); + } + master->char_data.org = (ufix8 *) master->c_buffer + cb_offset; + master->char_data.no_bytes = num; + + return &master->char_data; +} + +struct speedo_encoding { + char *name; + int *enc; + int enc_size; +}; + +/* Takes care of caching encodings already referenced */ +static int +find_encoding(const char *fontname, const char *filename, + int **enc, int *enc_size) +{ + static struct speedo_encoding *known_encodings=0; + static int number_known_encodings=0; + static int known_encodings_size=0; + + char *encoding_name; + int iso8859_1; + FontMapPtr mapping; + int i, j, k, size; + struct speedo_encoding *temp; + int *new_enc; + char *new_name; + + iso8859_1 = 0; + + encoding_name = FontEncFromXLFD(fontname, strlen(fontname)); + if(!encoding_name) { + encoding_name="iso8859-1"; + iso8859_1=1; + } + /* We don't go through the font library if asked for Latin-1 */ + iso8859_1 = iso8859_1 || !strcmp(encoding_name, "iso8859-1"); + + for(i=0; i<number_known_encodings; i++) { + if(!strcmp(encoding_name, known_encodings[i].name)) { + *enc=known_encodings[i].enc; + *enc_size=known_encodings[i].enc_size; + return Successful; + } + } + + /* it hasn't been cached yet, need to compute it */ + + /* ensure we've got enough storage first */ + + if(known_encodings==0) { + if((known_encodings= + (struct speedo_encoding*)xalloc(2*sizeof(struct speedo_encoding))) + ==0) + return AllocError; + number_known_encodings=0; + known_encodings_size=2; + } + + if(number_known_encodings >= known_encodings_size) { + if((temp= + (struct speedo_encoding*)xrealloc(known_encodings, + 2*sizeof(struct speedo_encoding)* + known_encodings_size))==0) + return AllocError; + known_encodings=temp; + known_encodings_size*=2; + } + + mapping=0; + if(!iso8859_1) { + mapping = FontEncMapFind(encoding_name, + FONT_ENCODING_UNICODE, -1, -1, + filename); + } +#define SPEEDO_RECODE(c) \ + (mapping? \ + unicode_to_bics(FontEncRecode(c, mapping)): \ + unicode_to_bics(c)) + + if((new_name = (char*)xalloc(strlen(encoding_name)))==0) + return AllocError; + strcpy(new_name, encoding_name); + + /* For now, we limit ourselves to 256 glyphs */ + size=0; + for(i=0; i < (mapping?mapping->encoding->size:256) && i < 256; i++) + if(SPEEDO_RECODE(i)>=0) + size++; + new_enc = (int*)xalloc(2*size*sizeof(int)); + if(!new_enc) { + xfree(new_name); + return AllocError; + } + for(i=j=0; i < (mapping?mapping->encoding->size:256) && i < 256; i++) + if((k = SPEEDO_RECODE(i))>=0) { + new_enc[2*j] = i; + new_enc[2*j+1] = k; + j++; + } + known_encodings[number_known_encodings].name = new_name; + known_encodings[number_known_encodings].enc = new_enc; + known_encodings[number_known_encodings].enc_size = size; + number_known_encodings++; + + *enc = new_enc; + *enc_size = size; + return Successful; +#undef SPEEDO_RECODE +} + +int +sp_open_master(const char *fontname, const char *filename, + SpeedoMasterFontPtr *master) +{ + SpeedoMasterFontPtr spmf; + ufix8 tmp[16]; + ufix16 cust_no; + FILE *fp; + ufix32 minbufsize; + ufix16 mincharsize; + ufix8 *f_buffer; + ufix8 *c_buffer; + int ret; + ufix8 *key; + + spmf = (SpeedoMasterFontPtr) xalloc(sizeof(SpeedoMasterFontRec)); + if (!spmf) + return AllocError; + bzero(spmf, sizeof(SpeedoMasterFontRec)); + spmf->entry = NULL; + spmf->f_buffer = NULL; + spmf->c_buffer = NULL; + + /* open font */ + spmf->fname = (char *) xalloc(strlen(filename) + 1); + if (!spmf->fname) + return AllocError; + fp = fopen(filename, "r"); + if (!fp) { + ret = BadFontName; + goto cleanup; + } + strcpy(spmf->fname, filename); + spmf->fp = fp; + spmf->state |= MasterFileOpen; + + if (fread(tmp, sizeof(ufix8), 16, fp) != 16) { + ret = BadFontName; + goto cleanup; + } + minbufsize = (ufix32) read_4b(tmp + FH_FBFSZ); + f_buffer = (ufix8 *) xalloc(minbufsize); + if (!f_buffer) { + ret = AllocError; + goto cleanup; + } + spmf->f_buffer = f_buffer; + + fseek(fp, (ufix32) 0, 0); + + /* read in the font */ + if (fread(f_buffer, sizeof(ufix8), (ufix16) minbufsize, fp) != minbufsize) { + ret = BadFontName; + goto cleanup; + } + spmf->copyright = (char *) (f_buffer + FH_CPYRT); + spmf->mincharsize = mincharsize = read_2b(f_buffer + FH_CBFSZ); + + c_buffer = (ufix8 *) xalloc(mincharsize); + if (!c_buffer) { + ret = AllocError; + goto cleanup; + } + spmf->c_buffer = c_buffer; + + spmf->font.org = spmf->f_buffer; + spmf->font.no_bytes = minbufsize; + + cust_no = sp_get_cust_no(spmf->font); + + /* XXX add custom encryption stuff here */ + +#ifdef EXTRAFONTS + if (cust_no == SCUS0) { + key = skey; + } else if (cust_no == RCUS0) { + key = rkey; + } else +#endif + +#ifdef XSAMPLEFONTS + if (cust_no == XCUS0) { + key = xkey; + } else +#endif + + if (cust_no == CUS0) { + key = mkey; + } else { + SpeedoErr("Non - standard encryption for \"%s\"\n", filename); + ret = BadFontName; + goto cleanup; + } + spmf->key = key; + sp_set_key(key); + + spmf->first_char_id = read_2b(f_buffer + FH_FCHRF); + spmf->num_chars = read_2b(f_buffer + FH_NCHRL); + + + spmf->enc = 0; + spmf->enc_size = 0; + +#ifdef EXTRAFONTS + { /* choose the proper encoding */ + char *f; + + f = strrchr(filename, '/'); + if (f) { + f++; + if (strncmp(f, "bx113", 5) == 0) { + spmf->enc = adobe_map; + spmf->enc_size = adobe_map_size; + } + } + } +#endif + + if(!spmf->enc) + if((ret=find_encoding(fontname, filename, &spmf->enc, &spmf->enc_size)) + !=Successful) + goto cleanup; + + spmf->first_char_id = spmf->enc[0]; + /* size of extents array */ + spmf->max_id = spmf->enc[(spmf->enc_size - 1) * 2]; + spmf->num_chars = spmf->enc_size; + + *master = spmf; + + return Successful; + +cleanup: + *master = (SpeedoMasterFontPtr) 0; + sp_close_master_font(spmf); + return ret; +} + +void +sp_close_master_font(SpeedoMasterFontPtr spmf) +{ + if (!spmf) + return; + if (spmf->state & MasterFileOpen) + fclose(spmf->fp); + if (spmf->entry) + spmf->entry->u.scalable.extra->private = NULL; + xfree(spmf->fname); + xfree(spmf->f_buffer); + xfree(spmf->c_buffer); + xfree(spmf); +} + +void +sp_close_master_file(SpeedoMasterFontPtr spmf) +{ + (void) fclose(spmf->fp); + spmf->state &= ~MasterFileOpen; +} + + +/* + * reset the encryption key, and make sure the file is opened + */ +void +sp_reset_master(SpeedoMasterFontPtr spmf) +{ + sp_set_key(spmf->key); + if (!(spmf->state & MasterFileOpen)) { + spmf->fp = fopen(spmf->fname, "r"); + /* XXX -- what to do if we can't open the file? */ + spmf->state |= MasterFileOpen; + } + fseek(spmf->fp, 0, 0); +} diff --git a/nx-X11/lib/font/Speedo/spfont.c b/nx-X11/lib/font/Speedo/spfont.c new file mode 100644 index 000000000..c209d5a51 --- /dev/null +++ b/nx-X11/lib/font/Speedo/spfont.c @@ -0,0 +1,453 @@ +/* $Xorg: spfont.c,v 1.4 2001/02/09 02:04:00 xorgcvs Exp $ */ +/* + * Copyright 1990, 1991 Network Computing Devices; + * Portions Copyright 1987 by Digital Equipment Corporation + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the names of Network Computing Devices or Digital + * not be used in advertising or publicity pertaining to distribution of + * the software without specific, written prior permission. + * + * NETWORK COMPUTING DEVICES AND DIGITAL DISCLAIM ALL WARRANTIES WITH + * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES OR DIGITAL BE + * LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Author: Dave Lemke, Network Computing Devices Inc + */ +/* $XFree86: xc/lib/font/Speedo/spfont.c,v 3.12tsi Exp $ */ + +/* + +Copyright 1987, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +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 OPEN GROUP 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. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + +*/ + +/* + * Speedo font loading + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include <X11/fonts/FSproto.h> +#include "spint.h" +#include <X11/fonts/fontutil.h> +#ifndef FONTMODULE +#ifdef _XOPEN_SOURCE +#include <math.h> +#else +#define _XOPEN_SOURCE /* to get prototype for hypot on some systems */ +#include <math.h> +#undef _XOPEN_SOURCE +#endif +#else +#include "servermd.h" +#include "xf86_ansic.h" +#endif + +#ifndef M_PI +#define M_PI 3.14159 +#endif /* M_PI */ +#ifndef DEFAULT_BIT_ORDER + +#ifdef BITMAP_BIT_ORDER +#define DEFAULT_BIT_ORDER BITMAP_BIT_ORDER +#else +#define DEFAULT_BIT_ORDER UNKNOWN_BIT_ORDER +#endif + +#endif + +static void SpeedoCloseFont(FontPtr pfont); + +static int +sp_get_glyphs( + FontPtr pFont, + unsigned long count, + register unsigned char *chars, + FontEncoding charEncoding, + unsigned long *glyphCount, /* RETURN */ + CharInfoPtr *glyphs) /* RETURN */ +{ + SpeedoFontPtr spf; + unsigned int firstCol; + register unsigned int numCols; + unsigned int firstRow; + unsigned int numRows; + CharInfoPtr *glyphsBase; + register unsigned int c; + register CharInfoPtr pci; + unsigned int r; + CharInfoPtr encoding; + CharInfoPtr pDefault; +#ifdef notyet + int itemSize; +#endif + int err = Successful; + + spf = (SpeedoFontPtr) pFont->fontPrivate; + encoding = spf->encoding; + pDefault = spf->pDefault; + firstCol = pFont->info.firstCol; + numCols = pFont->info.lastCol - firstCol + 1; + glyphsBase = glyphs; + + + /* XXX - this should be much smarter */ + /* make sure the glyphs are there */ +#ifdef notyet + if (charEncoding == Linear8Bit || charEncoding == TwoD8Bit) + itemSize = 1; + else + itemSize = 2; + + if (!fsd->complete) + err = fs_load_glyphs(NULL, pFont, count, itemSize, chars); +#endif + + if (err != Successful) + return err; + + switch (charEncoding) { + + case Linear8Bit: + case TwoD8Bit: + if (pFont->info.firstRow > 0) + break; + if (pFont->info.allExist && pDefault) { + while (count--) { + c = (*chars++) - firstCol; + if (c < numCols) + *glyphs++ = &encoding[c]; + else + *glyphs++ = pDefault; + } + } else { + while (count--) { + c = (*chars++) - firstCol; + if (c < numCols && (pci = &encoding[c])->bits) + *glyphs++ = pci; + else if (pDefault) + *glyphs++ = pDefault; + } + } + break; + case Linear16Bit: + if (pFont->info.allExist && pDefault) { + while (count--) { + c = *chars++ << 8; + c = (c | *chars++) - firstCol; + if (c < numCols) + *glyphs++ = &encoding[c]; + else + *glyphs++ = pDefault; + } + } else { + while (count--) { + c = *chars++ << 8; + c = (c | *chars++) - firstCol; + if (c < numCols && (pci = &encoding[c])->bits) + *glyphs++ = pci; + else if (pDefault) + *glyphs++ = pDefault; + } + } + break; + + case TwoD16Bit: + firstRow = pFont->info.firstRow; + numRows = pFont->info.lastRow - firstRow + 1; + while (count--) { + r = (*chars++) - firstRow; + c = (*chars++) - firstCol; + if (r < numRows && c < numCols && + (pci = &encoding[r * numCols + c])->bits) + *glyphs++ = pci; + else if (pDefault) + *glyphs++ = pDefault; + } + break; + } + *glyphCount = glyphs - glyphsBase; + return Successful; +} + +static CharInfoRec nonExistantChar; + +static int +sp_get_metrics( + FontPtr pFont, + unsigned long count, + register unsigned char *chars, + FontEncoding charEncoding, + unsigned long *glyphCount, /* RETURN */ + xCharInfo **glyphs) /* RETURN */ +{ + int ret; + SpeedoFontPtr spf; + CharInfoPtr oldDefault; + + spf = (SpeedoFontPtr) pFont->fontPrivate; + oldDefault = spf->pDefault; + spf->pDefault = &nonExistantChar; + ret = sp_get_glyphs(pFont, count, chars, charEncoding, + glyphCount, (CharInfoPtr *) glyphs); + + spf->pDefault = oldDefault; + return ret; +} + +int +sp_open_font( + char *fontname, + char *filename, + FontEntryPtr entry, + FontScalablePtr vals, + fsBitmapFormat format, + fsBitmapFormatMask fmask, + Mask flags, + SpeedoFontPtr *spfont) +{ + SpeedoFontPtr spf; + SpeedoMasterFontPtr spmf; + int ret; + specs_t specs; + int xx8, xy8, yx8, yy8; + + /* find a master (create it if necessary) */ + spmf = (SpeedoMasterFontPtr) entry->u.scalable.extra->private; + if (!spmf) + { + ret = sp_open_master(fontname, filename, &spmf); + if (ret != Successful) + return ret; + entry->u.scalable.extra->private = (pointer) spmf; + spmf->entry = entry; + } + + spf = (SpeedoFontPtr) xalloc(sizeof(SpeedoFontRec)); + if (!spf) + return AllocError; + bzero((char *) spf, sizeof(SpeedoFontRec)); + + *spfont = spf; + + /* clobber everything -- this may be leaking, but other wise evil + * stuff is left behind -- succesive transformed fonts get mangled */ + bzero((char *)&sp_globals, sizeof(sp_globals)); + + spf->master = spmf; + spf->entry = entry; + spmf->refcount++; + sp_reset_master(spmf); + /* now we've done enough that if we bail out we must call sp_close_font */ + + spf->vals = *vals; + + /* set up specs */ + + specs.pfont = &spmf->font; + + specs.xxmult = (int)(vals->pixel_matrix[0] * (double)(1L << 16)); + specs.xymult = (int)(vals->pixel_matrix[2] * (double)(1L << 16)); + specs.yxmult = (int)(vals->pixel_matrix[1] * (double)(1L << 16)); + specs.yymult = (int)(vals->pixel_matrix[3] * (double)(1L << 16)); + + specs.xoffset = 0L << 16; /* XXX tweak? */ + specs.yoffset = 0L << 16; /* XXX tweak? */ + + specs.flags = MODE_SCREEN; + specs.out_info = NULL; + + /* When Speedo tries to generate a very small font bitmap, it + often crashes or goes into an infinite loop. + Don't know why this is so, but until we can fix it properly, + return BadFontName for anything smaller than 4 pixels. + */ +#define TINY_FACTOR (16 << 16) + xx8 = specs.xxmult >> 8; + xy8 = specs.xymult >> 8; + yx8 = specs.yxmult >> 8; + yy8 = specs.yymult >> 8; + if (xx8 * xx8 + xy8 * xy8 < TINY_FACTOR || + yx8 * yx8 + yy8 * yy8 < TINY_FACTOR) + { + sp_close_font(spf); + return BadFontName; + } + + /* clobber global state to avoid wrecking future transformed fonts */ + bzero ((char *) &sp_globals, sizeof(sp_globals)); + + if (!sp_set_specs(&specs)) + { + sp_close_font(spf); + return BadFontName; + } + + spf->specs = specs; + spf->master = spmf; + + *spfont = spf; + return Successful; +} + +static int +sp_load_font( + char *fontname, + char *filename, + FontEntryPtr entry, + FontScalablePtr vals, + fsBitmapFormat format, + fsBitmapFormatMask fmask, + FontPtr pfont, + Mask flags) +{ + SpeedoFontPtr spf; + SpeedoMasterFontPtr spmf; + int esize; + int ret; + long sWidth; + + ret = sp_open_font(fontname, filename, entry, vals, format, fmask, + flags, &spf); + + if (ret != Successful) + return ret; + + spmf = spf->master; + sp_reset_master(spmf); + esize = sizeof(CharInfoRec) * (spmf->max_id - spmf->first_char_id + 1); + + spf->encoding = (CharInfoPtr) xalloc(esize); + if (!spf->encoding) { + sp_close_font(spf); + return AllocError; + } + bzero((char *) spf->encoding, esize); + + sp_fp_cur = spf; + + sp_make_header(spf, &pfont->info); + + sp_compute_bounds(spf, &pfont->info, SaveMetrics, &sWidth); + + sp_compute_props(spf, fontname, &pfont->info, sWidth); + + pfont->fontPrivate = (pointer) spf; + +/* XXX */ + flags |= FontLoadBitmaps; + + if (flags & FontLoadBitmaps) { + sp_fp_cur = spf; + ret = sp_build_all_bitmaps(pfont, format, fmask); + } + if (ret != Successful) + return ret; + + /* compute remaining accelerators */ + FontComputeInfoAccelerators(&pfont->info); + + pfont->format = format; + + pfont->get_metrics = sp_get_metrics; + pfont->get_glyphs = sp_get_glyphs; + pfont->unload_font = SpeedoCloseFont; + pfont->unload_glyphs = NULL; + pfont->refcnt = 0; + + /* have to hold on to master for min/max id */ + sp_close_master_file(spmf); + + return ret; +} + +int +SpeedoFontLoad( + FontPtr *ppfont, + char *fontname, + char *filename, + FontEntryPtr entry, + FontScalablePtr vals, + fsBitmapFormat format, + fsBitmapFormatMask fmask, + Mask flags) +{ + FontPtr pfont; + int ret; + + /* Reject ridiculously small sizes that will blow up the math */ + if (hypot(vals->pixel_matrix[0], vals->pixel_matrix[1]) < 1.0 || + hypot(vals->pixel_matrix[2], vals->pixel_matrix[3]) < 1.0) + return BadFontName; + + if (!(pfont = CreateFontRec())) + return AllocError; + + ret = sp_load_font(fontname, filename, entry, vals, format, fmask, + pfont, flags); + + if (ret == Successful) + *ppfont = pfont; + else + DestroyFontRec (pfont); + + return ret; +} + +void +sp_close_font(SpeedoFontPtr spf) +{ + SpeedoMasterFontPtr spmf; + + spmf = spf->master; + --spmf->refcount; + if (spmf->refcount == 0) + sp_close_master_font (spmf); + xfree(spf->encoding); + xfree(spf->bitmaps); + xfree(spf); +} + +static void +SpeedoCloseFont(FontPtr pfont) +{ + SpeedoFontPtr spf; + + spf = (SpeedoFontPtr) pfont->fontPrivate; + sp_close_font(spf); + xfree(pfont->info.isStringProp); + xfree(pfont->info.props); + DestroyFontRec(pfont); + +} diff --git a/nx-X11/lib/font/Speedo/spfuncs.c b/nx-X11/lib/font/Speedo/spfuncs.c new file mode 100644 index 000000000..da4d5c55e --- /dev/null +++ b/nx-X11/lib/font/Speedo/spfuncs.c @@ -0,0 +1,167 @@ +/* $Xorg: spfuncs.c,v 1.4 2001/02/09 02:04:00 xorgcvs Exp $ */ +/* + * Copyright 1990, 1991 Network Computing Devices; + * Portions Copyright 1987 by Digital Equipment Corporation + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the names of Network Computing Devices or Digital + * not be used in advertising or publicity pertaining to distribution of + * the software without specific, written prior permission. + * + * NETWORK COMPUTING DEVICES AND DIGITAL DISCLAIM ALL WARRANTIES WITH + * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES OR DIGITAL BE + * LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Author: Dave Lemke, Network Computing Devices, Inc + */ + +/* + +Copyright 1987, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +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 OPEN GROUP 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. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + +*/ +/* $XFree86: xc/lib/font/Speedo/spfuncs.c,v 1.7 2001/08/27 19:49:51 dawes Exp $ */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#ifndef FONTMODULE +#include <X11/Xos.h> +#endif +#include <X11/fonts/fntfilst.h> +#include <X11/fonts/fontutil.h> +#include "spint.h" + +/* ARGSUSED */ +static int +SpeedoOpenScalable ( + FontPathElementPtr fpe, + FontPtr *pFont, + int flags, + FontEntryPtr entry, + char *fileName, + FontScalablePtr vals, + fsBitmapFormat format, + fsBitmapFormatMask fmask, + FontPtr non_cachable_font) /* We don't do licensing */ +{ + char fullName[MAXFONTNAMELEN]; + + strcpy (fullName, entry->name.name); + return SpeedoFontLoad (pFont, fullName, fileName, entry, vals, + format, fmask, flags); +} + +/* + * XXX + * + * this does a lot more then i'd like, but it has to get the bitmaps + * in order to get accurate metrics (which it *must* have). + * + * a possible optimization is to avoid allocating the glyph memory + * and to simply save the values without doing the work. + */ +static int +get_font_info( + FontInfoPtr pinfo, + char *fontname, + char *filename, + FontEntryPtr entry, + FontScalablePtr vals, + SpeedoFontPtr *spfont) +{ + SpeedoFontPtr spf; + int err; + long sWidth; + + err = sp_open_font(fontname, filename, entry, vals, + (fsBitmapFormat) 0, (fsBitmapFormatMask) 0, (unsigned long) 0, + &spf); + + if (err != Successful) + return err; + + sp_fp_cur = spf; + sp_reset_master(spf->master); + + sp_make_header(spf, pinfo); + + sp_compute_bounds(spf, pinfo, (unsigned long) 0, &sWidth); + + sp_compute_props(spf, fontname, pinfo, sWidth); + + /* compute remaining accelerators */ + FontComputeInfoAccelerators (pinfo); + + *spfont = spf; + + return Successful; +} + +/* ARGSUSED */ +static int +SpeedoGetInfoScaleable( + FontPathElementPtr fpe, + FontInfoPtr pFontInfo, + FontEntryPtr entry, + FontNamePtr fontName, + char *fileName, + FontScalablePtr vals) +{ + SpeedoFontPtr spf = NULL; + char fullName[MAXFONTNAMELEN]; + int err; + + strcpy(fullName, entry->name.name); + FontParseXLFDName(fullName, vals, FONT_XLFD_REPLACE_VALUE); + + err = get_font_info(pFontInfo, fullName, fileName, entry, vals, &spf); + + if (spf) + sp_close_font(spf); + + return err; +} + +static FontRendererRec renderer = { + ".spd", 4, NULL, SpeedoOpenScalable, + NULL, SpeedoGetInfoScaleable, 0 + , CAP_MATRIX | CAP_CHARSUBSETTING +}; + +void +SpeedoRegisterFontFileFunctions() +{ + sp_make_standard_props(); + sp_reset(); + FontFileRegisterRenderer(&renderer); +} diff --git a/nx-X11/lib/font/Speedo/spglyph.c b/nx-X11/lib/font/Speedo/spglyph.c new file mode 100644 index 000000000..3577f5567 --- /dev/null +++ b/nx-X11/lib/font/Speedo/spglyph.c @@ -0,0 +1,399 @@ +/* $Xorg: spglyph.c,v 1.4 2001/02/09 02:04:00 xorgcvs Exp $ */ +/* + * Copyright 1990, 1991 Network Computing Devices; + * Portions Copyright 1987 by Digital Equipment Corporation + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the names of Network Computing Devices or Digital + * not be used in advertising or publicity pertaining to distribution of + * the software without specific, written prior permission. + * + * NETWORK COMPUTING DEVICES AND DIGITAL DISCLAIM ALL WARRANTIES WITH + * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES OR DIGITAL BE + * LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Author: Dave Lemke, Network Computing Devices Inc + */ + +/* + +Copyright 1987, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +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 OPEN GROUP 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. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + +*/ +/* $XFree86: xc/lib/font/Speedo/spglyph.c,v 1.6 2001/01/17 19:43:20 dawes Exp $ */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include <X11/X.h> /* for bit order #defines */ +#include "spint.h" +#include <X11/fonts/fontutil.h> + +#undef CLIP_BBOX_NOISE + +static CurrentFontValuesRec current_font_values; +static CurrentFontValuesPtr cfv = ¤t_font_values; +static int bit_order, + byte_order, + scan; + +unsigned long +sp_compute_data_size( + FontPtr pfont, + int mappad, + int scanlinepad, + unsigned long start, + unsigned long end) +{ + unsigned long ch; + unsigned long size = 0; + int bpr; + SpeedoFontPtr spf = (SpeedoFontPtr) pfont->fontPrivate; + FontInfoPtr pinfo = &pfont->info; + int firstChar; + + firstChar = spf->master->first_char_id; + + /* allocate the space */ + switch (mappad) { + int charsize; + CharInfoPtr ci; + xCharInfo *cim; + + case BitmapFormatImageRectMin: + cfv->bpr = 0; + for (ch = start; ch <= end; ch++) { + ci = &spf->encoding[ch - firstChar]; + if (!ci) + ci = spf->pDefault; + cim = &ci->metrics; + charsize = GLYPH_SIZE(ci, scanlinepad); + charsize *= cim->ascent + cim->descent; + size += charsize; + } + break; + case BitmapFormatImageRectMaxWidth: + bpr = GLWIDTHBYTESPADDED(FONT_MAX_WIDTH(pinfo), scanlinepad); + cfv->bpr = bpr; + for (ch = start; ch <= end; ch++) { + ci = &spf->encoding[ch - firstChar]; + if (!ci) + ci = spf->pDefault; + cim = &ci->metrics; + charsize = bpr * (cim->ascent + cim->descent); + size += charsize; + } + break; + case BitmapFormatImageRectMax: + bpr = GLWIDTHBYTESPADDED(FONT_MAX_WIDTH(pinfo), scanlinepad); + cfv->bpr = bpr; + size = (end - start + 1) * bpr * FONT_MAX_HEIGHT(pinfo); + break; + default: + assert(0); + } + + return size; +} + +static void +finish_line(SpeedoFontPtr spf) +{ + int bpr = cfv->bpr; + CharInfoPtr ci = &spf->encoding[cfv->char_id - spf->master->first_char_id]; + + if (bpr == 0) { + bpr = GLYPH_SIZE(ci, cfv->scanpad); + } + if (bpr) { /* char may not have any metrics... */ + cfv->bp = (char *)cfv->bp + bpr; + } + assert(cfv->bp - sp_fp_cur->bitmaps <= sp_fp_cur->bitmap_size); +} + + +void +sp_set_bitmap_bits(fix15 y, fix15 xbit1, fix15 xbit2) +{ + int nmiddle; + CARD8 startmask, + endmask; + CARD8 *dst; + + if (xbit1 > cfv->bit_width) { + +#ifdef CLIP_BBOX_NOISE + SpeedoErr("Run wider than bitmap width -- truncated\n"); +#endif + + xbit1 = cfv->bit_width; + } + if (xbit2 > cfv->bit_width) { + +#ifdef CLIP_BBOX_NOISE + SpeedoErr("Run wider than bitmap width -- truncated\n"); +#endif + + xbit2 = cfv->bit_width; + } + + if (xbit2 < xbit1) { + xbit2 = xbit1; + } + + while (cfv->cur_y != y) { + finish_line(sp_fp_cur); + cfv->cur_y++; + } + + cfv->last_y = y; + if (y >= cfv->bit_height) { + +#ifdef CLIP_BBOX_NOISE + SpeedoErr("Y larger than bitmap height -- truncated\n"); +#endif + + cfv->trunc = 1; + return; + } + if (xbit1 < 0) /* XXX this is more than a little bit rude... */ + xbit1 = 0; + + nmiddle = (xbit1 >> 3); + dst = (CARD8 *)cfv->bp + nmiddle; + xbit2 -= (xbit1 & ~7); + nmiddle = (xbit2 >> 3); + xbit1 &= 7; + xbit2 &= 7; + if (bit_order == MSBFirst) { + startmask = ((CARD8) ~0) >> xbit1; + endmask = ~(((CARD8) ~0) >> xbit2); + } else { + startmask = ((CARD8) ~0) << xbit1; + endmask = ~(((CARD8) ~0) << xbit2); + } + if (nmiddle == 0) + *dst |= endmask & startmask; + else { + *dst++ |= startmask; + while (--nmiddle) + *dst++ = (CARD8)~0; + *dst |= endmask; + } +} + +/* ARGSUSED */ +void +sp_open_bitmap(fix31 x_set_width, fix31 y_set_width, fix31 xorg, fix31 yorg, + fix15 xsize, fix15 ysize) +{ + CharInfoPtr ci = &sp_fp_cur->encoding[cfv->char_id - sp_fp_cur->master->first_char_id]; + +/*- + * this is set to provide better quality bitmaps. since the Speedo + * sp_get_bbox() function returns an approximate (but guarenteed to contain) + * set of metrics, some of the bitmaps can be place poorly inside and + * look bad. + * + * with this set, the actual bitmap values are used instead of the bboxes. + * it makes things look better, but causes two possible problems: + * + * 1 - the reported min & max bounds may not correspond to the extents + * reported + * 2 - if the extents are reported before the character is generated, + * a client could see them change. this currently never happens, + * but will when a desired enhancement (don't reneder till needed) + * is made. + */ + +#define BBOX_FIXUP 1 + +#ifdef BBOX_FIXUP + int off_horz; + int off_vert; + + if (xorg < 0) + off_horz = (fix15) ((xorg - 32768L) / 65536); + else + off_horz = (fix15) ((xorg + 32768L) / 65536); + if (yorg < 0) + off_vert = (fix15) ((yorg - 32768L) / 65536); + else + off_vert = (fix15) ((yorg + 32768L) / 65536); + if (xsize != 0 || ysize != 0 || ci->metrics.characterWidth) + { + ci->metrics.leftSideBearing = off_horz; + ci->metrics.descent = -off_vert; + ci->metrics.rightSideBearing = xsize + off_horz; + ci->metrics.ascent = ysize + off_vert; + } + else + { + /* If setting the proper size would cause the character to appear to + be non-existent, fudge things by giving it a pixel to occupy. */ + xsize = ysize = 1; + ci->metrics.leftSideBearing = ci->metrics.descent = 0; + ci->metrics.rightSideBearing = ci->metrics.ascent = 1; + } + + cfv->bit_width = xsize; + cfv->bit_height = ysize; +#else + cfv->bit_width = ci->metrics.rightSideBearing - + ci->metrics.leftSideBearing; + cfv->bit_height = ci->metrics.ascent + ci->metrics.descent; +#endif + + assert(cfv->bp - sp_fp_cur->bitmaps <= sp_fp_cur->bitmap_size); + ci->bits = (char *) cfv->bp; + + cfv->cur_y = 0; +} + +void +sp_close_bitmap() +{ + CharInfoPtr ci = &sp_fp_cur->encoding[cfv->char_id - sp_fp_cur->master->first_char_id]; + int bpr = cfv->bpr; + + if (bpr == 0) + bpr = GLYPH_SIZE(ci, cfv->scanpad); + if (!cfv->trunc) + finish_line(sp_fp_cur); + cfv->trunc = 0; + cfv->last_y++; + while (cfv->last_y < cfv->bit_height) { + finish_line(sp_fp_cur); + cfv->last_y++; + } + if (byte_order != bit_order) { + switch (scan) { + case 1: + break; + case 2: + TwoByteSwap(cfv->bp, bpr * cfv->bit_height); + break; + case 4: + FourByteSwap(cfv->bp, bpr * cfv->bit_height); + break; + } + } +} + +int +sp_build_all_bitmaps( + FontPtr pfont, + fsBitmapFormat format, + fsBitmapFormatMask fmask) +{ + int ret, + glyph = 1, + image = BitmapFormatImageRectMin; + unsigned long glyph_size; + SpeedoFontPtr spf = (SpeedoFontPtr) pfont->fontPrivate; + SpeedoMasterFontPtr spmf = spf->master; + pointer bitmaps; + int start, + end, + i; + + scan = 1; + ret = CheckFSFormat(format, fmask, + &bit_order, &byte_order, &scan, &glyph, &image); + + pfont->bit = bit_order; + pfont->byte = byte_order; + pfont->glyph = glyph; + pfont->scan = scan; + if (ret != Successful) + return BadFontFormat; + + start = spmf->first_char_id; + end = spmf->max_id; + glyph_size = sp_compute_data_size(pfont, image, glyph, start, end); + + /* XXX -- MONDO KLUDGE -- add some slop */ + /* + * not sure why this is wanted, but it keeps the packer from going off the + * end and toasting us down the line + */ + glyph_size += 20; + +#ifdef DEBUG + spf->bitmap_size = glyph_size; +#endif + + bitmaps = (pointer) xalloc(glyph_size); + if (!bitmaps) + return AllocError; + bzero((char *) bitmaps, glyph_size); + + /* set up some state */ + sp_fp_cur = spf; + spf->bitmaps = bitmaps; + cfv->format = format; + cfv->scanpad = glyph; + cfv->bp = bitmaps; + + for (i = 0; i < spmf->num_chars; i++) { + int j; + cfv->char_index = spmf->enc[i * 2 + 1]; + cfv->char_id = spmf->enc[i * 2]; +#ifdef DEBUG +fprintf(stderr, "build_all_sp_bitmaps:i = %d, Char ID = %d\n", i, cfv->char_id); +#endif + if (!cfv->char_id) + continue; + + /* + * See if this character is in the list of ranges specified in the + * XLFD name + */ + for (j = 0; j < spf->vals.nranges; j++) + if (cfv->char_id >= mincharno(spf->vals.ranges[j]) && + cfv->char_id <= maxcharno(spf->vals.ranges[j])) + break; + + /* If not, don't realize it. */ + if (spf->vals.nranges && j == spf->vals.nranges) + continue; + + if (!sp_make_char(cfv->char_index)) { + +#ifdef DEBUG /* can be very common with some encodings */ + SpeedoErr("Can't make char %d\n", cfv->char_index); +#endif + } + } + + return Successful; +} diff --git a/nx-X11/lib/font/Speedo/spinfo.c b/nx-X11/lib/font/Speedo/spinfo.c new file mode 100644 index 000000000..d7a1edd98 --- /dev/null +++ b/nx-X11/lib/font/Speedo/spinfo.c @@ -0,0 +1,462 @@ +/* $Xorg: spinfo.c,v 1.4 2001/02/09 02:04:00 xorgcvs Exp $ */ +/* + * Copyright 1990, 1991 Network Computing Devices; + * Portions Copyright 1987 by Digital Equipment Corporation + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the names of Network Computing Devices or Digital + * not be used in advertising or publicity pertaining to distribution of + * the software without specific, written prior permission. + * + * NETWORK COMPUTING DEVICES AND DIGITAL DISCLAIM ALL WARRANTIES WITH + * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES OR DIGITAL BE + * LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Author: Dave Lemke, Network Computing Devices, Inc + */ + +/* + +Copyright 1987, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +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 OPEN GROUP 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. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + +*/ +/* $XFree86: xc/lib/font/Speedo/spinfo.c,v 1.12 2001/12/14 19:56:42 dawes Exp $ */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include <X11/fonts/fntfilst.h> +#include <X11/fonts/fontutil.h> +#include "spint.h" +#ifndef FONTMODULE +#include <math.h> +#else +#include "xf86_ansic.h" +#endif + +/* percentage of pointsize used to specify ascent & descent */ +#define STRETCH_FACTOR 120 + +enum scaleType { + atom, truncate_atom, pixel_size, point_size, resolution_x, + resolution_y, average_width +}; + +typedef struct _fontProp { + char *name; + long atom; + enum scaleType type; +} fontProp; + +static fontProp fontNamePropTable[] = { + { "FOUNDRY", 0, atom }, + { "FAMILY_NAME", 0, atom }, + { "WEIGHT_NAME", 0, atom }, + { "SLANT", 0, atom }, + { "SETWIDTH_NAME", 0, atom }, + { "ADD_STYLE_NAME", 0, atom }, + { "PIXEL_SIZE", 0, pixel_size }, + { "POINT_SIZE", 0, point_size }, + { "RESOLUTION_X", 0, resolution_x }, + { "RESOLUTION_Y", 0, resolution_y }, + { "SPACING", 0, atom }, + { "AVERAGE_WIDTH", 0, average_width }, + { "CHARSET_REGISTRY", 0, atom }, + { "CHARSET_ENCODING", 0, truncate_atom } +}; + +/* Warning: following array is closely related to the sequence of + defines after it. */ + +static fontProp extraProps[] = { + { "FONT", 0, }, + { "COPYRIGHT", 0, }, + { "RAW_PIXEL_SIZE", 0, }, + { "RAW_POINT_SIZE", 0, }, + { "RAW_ASCENT", 0, }, + { "RAW_DESCENT", 0, }, + { "RAW_AVERAGE_WIDTH", 0, }, + { "FONT_TYPE", 0, }, + { "RASTERIZER_NAME", 0, } +}; + +/* this is a bit kludgy */ +#define FONTPROP 0 +#define COPYRIGHTPROP 1 +#define RAWPIXELPROP 2 +#define RAWPOINTPROP 3 +#define RAWASCENTPROP 4 +#define RAWDESCENTPROP 5 +#define RAWWIDTHPROP 6 +#define FONT_TYPEPROP 7 +#define RASTERIZER_NAMEPROP 8 + +#define NNAMEPROPS (sizeof(fontNamePropTable) / sizeof(fontProp)) +#define NEXTRAPROPS (sizeof(extraProps) / sizeof(fontProp)) + +#define NPROPS (NNAMEPROPS + NEXTRAPROPS) + +void +sp_make_standard_props() +{ + int i; + fontProp *t; + + i = sizeof(fontNamePropTable) / sizeof(fontProp); + for (t = fontNamePropTable; i; i--, t++) + t->atom = MakeAtom(t->name, (unsigned) strlen(t->name), TRUE); + i = sizeof(extraProps) / sizeof(fontProp); + for (t = extraProps; i; i--, t++) + t->atom = MakeAtom(t->name, (unsigned) strlen(t->name), TRUE); +} + +void +sp_make_header( + SpeedoFontPtr spf, + FontInfoPtr pinfo) +{ + int pixel_size; + SpeedoMasterFontPtr spmf = spf->master; + + pinfo->firstCol = spmf->first_char_id & 0xff; + pinfo->firstRow = spmf->first_char_id >> 8; + pinfo->lastCol = spmf->max_id & 0xff; + pinfo->lastRow = spmf->max_id >> 8; + + /* XXX -- hackery here */ + pinfo->defaultCh = 0; +/* computed by FontComputeInfoAccelerators: + * noOverlap + * constantMetrics + * terminalFont + * constantWidth + * inkInside + */ + pinfo->inkMetrics = 0; + pinfo->allExist = 0; + pinfo->drawDirection = LeftToRight; + pinfo->cachable = 1; + if (spf->specs.xxmult != spf->specs.yymult) + pinfo->anamorphic = TRUE; + else + pinfo->anamorphic = FALSE; +/* computed by sp_compute_bounds: + * maxOverlap + * maxbounds + * minbounds + * ink_maxbounds + * ink_minbounds + */ + pixel_size = spf->vals.pixel_matrix[3] * STRETCH_FACTOR / 100; + pinfo->fontAscent = pixel_size * 764 / 1000; /* 764 == EM_TOP */ + pinfo->fontDescent = pixel_size - pinfo->fontAscent; +} + +static void +adjust_min_max( + xCharInfo *minc, + xCharInfo *maxc, + xCharInfo *tmp) +{ +#define MINMAX(field,ci) \ + if (minc->field > (ci)->field) \ + minc->field = (ci)->field; \ + if (maxc->field < (ci)->field) \ + maxc->field = (ci)->field; + + MINMAX(ascent, tmp); + MINMAX(descent, tmp); + MINMAX(leftSideBearing, tmp); + MINMAX(rightSideBearing, tmp); + MINMAX(characterWidth, tmp); + + if ((INT16)minc->attributes > (INT16)tmp->attributes) + minc->attributes = tmp->attributes; + if ((INT16)maxc->attributes < (INT16)tmp->attributes) + maxc->attributes = tmp->attributes; + +#undef MINMAX +} + + +void +sp_compute_bounds( + SpeedoFontPtr spf, + FontInfoPtr pinfo, + unsigned long flags, + long *sWidth) +{ + int i, + id, + index, + maxOverlap, + overlap, + total_width = 0; + xCharInfo minchar, + maxchar, + tmpchar; + bbox_t bbox; + fix31 width; + double pix_width; + SpeedoMasterFontPtr spmf = spf->master; + int firstChar; + int num_chars = 0; + + firstChar = spmf->first_char_id; + minchar.ascent = minchar.descent = + minchar.leftSideBearing = minchar.rightSideBearing = + minchar.characterWidth = minchar.attributes = 32767; + maxchar.ascent = maxchar.descent = + maxchar.leftSideBearing = maxchar.rightSideBearing = + maxchar.characterWidth = maxchar.attributes = -32767; + maxOverlap = -32767; + *sWidth = 0; + for (i = 0; i < spmf->num_chars; i++) { + int j; + int char_id; + + index = spmf->enc[i * 2 + 1]; + char_id = spmf->enc[i * 2]; + /* + * See if this character is in the list of ranges specified in the + * XLFD name + */ + for (j = 0; j < spf->vals.nranges; j++) + if (char_id >= mincharno(spf->vals.ranges[j]) && + char_id <= maxcharno(spf->vals.ranges[j])) + break; + if (spf->vals.nranges && j == spf->vals.nranges) + continue; + num_chars++; + + if (!(flags & ComputeBoundsOnly)) { + + width = sp_get_char_width(index); + + /* convert to pixel coords */ + pix_width = (int)width * (spf->specs.xxmult / 65536L) + + ((int) width * (spf->specs.xxmult % 65536L)) + / 65536L; + pix_width /= 65536L; + + (void) sp_get_char_bbox(index, &bbox); + bbox.ymax = (bbox.ymax + 32768L) >> 16; + bbox.ymin = (bbox.ymin + 32768L) >> 16; + bbox.xmin = (bbox.xmin + 32768L) >> 16; + bbox.xmax = (bbox.xmax + 32768L) >> 16; + tmpchar.ascent = bbox.ymax; + tmpchar.descent = -bbox.ymin; + tmpchar.characterWidth = (int)(pix_width + /* round */ + (pix_width > 0 ? 0.5 : -0.5)); + tmpchar.rightSideBearing = bbox.xmax; + tmpchar.leftSideBearing = bbox.xmin; + + if (!tmpchar.characterWidth && + tmpchar.ascent == -tmpchar.descent && + tmpchar.rightSideBearing == tmpchar.leftSideBearing) + { + /* Character appears non-existent, probably as a result + of the transformation. Let's give it one pixel in + the universe so it's not mistaken for non-existent. */ + tmpchar.leftSideBearing = tmpchar.descent = 0; + tmpchar.rightSideBearing = tmpchar.ascent = 1; + } + + tmpchar.attributes = (int)((double)(int)width / 65.536 + .5); + } + else + tmpchar = spf->encoding[char_id - firstChar].metrics; + + adjust_min_max(&minchar, &maxchar, &tmpchar); + overlap = tmpchar.rightSideBearing - tmpchar.characterWidth; + if (maxOverlap < overlap) + maxOverlap = overlap; + + total_width += ((int)(INT16)tmpchar.attributes); + *sWidth += abs((int)(INT16)tmpchar.attributes); + + if (flags & SaveMetrics) { + id = spmf->enc[i * 2] - firstChar; + assert(id <= spmf->max_id - firstChar); + spf->encoding[id].metrics = tmpchar; + } + } + + + if (num_chars > 0) + { + *sWidth = (int)(((double)*sWidth * 10.0 + (double)num_chars / 2.0) / + num_chars); + if (total_width < 0) + { + /* Predominant direction is R->L */ + *sWidth = -*sWidth; + } + spf->vals.width = (int)((double)*sWidth * spf->vals.pixel_matrix[0] / + 1000.0 + + (spf->vals.pixel_matrix[0] > 0 ? .5 : -.5)); + } + else + { + spf->vals.width = 0; + } + pinfo->maxbounds = maxchar; + pinfo->minbounds = minchar; + pinfo->ink_maxbounds = maxchar; + pinfo->ink_minbounds = minchar; + pinfo->maxOverlap = maxOverlap; +} + +void +sp_compute_props( + SpeedoFontPtr spf, + char *fontname, + FontInfoPtr pinfo, + long sWidth) +{ + FontPropPtr pp; + int i, + nprops; + fontProp *fpt; + char *is_str; + char *ptr1 = NULL, + *ptr2; + char *ptr3; + char tmpname[1024]; + FontScalableRec tmpvals; + + nprops = pinfo->nprops = NPROPS; + pinfo->isStringProp = (char *) xalloc(sizeof(char) * nprops); + pinfo->props = (FontPropPtr) xalloc(sizeof(FontPropRec) * nprops); + if (!pinfo->isStringProp || !pinfo->props) { + xfree(pinfo->isStringProp); + pinfo->isStringProp = (char *) 0; + xfree(pinfo->props); + pinfo->props = (FontPropPtr) 0; + pinfo->nprops = 0; + return; + } + bzero(pinfo->isStringProp, (sizeof(char) * nprops)); + + ptr2 = fontname; + for (i = NNAMEPROPS, pp = pinfo->props, fpt = fontNamePropTable, + is_str = pinfo->isStringProp; + i; + i--, pp++, fpt++, is_str++) { + + if (*ptr2) + { + ptr1 = ptr2 + 1; + if (!(ptr2 = strchr(ptr1, '-'))) ptr2 = strchr(ptr1, '\0'); + } + + pp->name = fpt->atom; + switch (fpt->type) { + case atom: + *is_str = TRUE; + pp->value = MakeAtom(ptr1, ptr2 - ptr1, TRUE); + break; + case truncate_atom: + *is_str = TRUE; + for (ptr3 = ptr1; *ptr3; ptr3++) + if (*ptr3 == '[') + break; + pp->value = MakeAtom(ptr1, ptr3 - ptr1, TRUE); + break; + case pixel_size: + pp->value = (int)(spf->vals.pixel_matrix[3] + + (spf->vals.pixel_matrix[3] > 0 ? .5 : -.5)); + break; + case point_size: + pp->value = (int)(spf->vals.point_matrix[3] * 10.0 + + (spf->vals.point_matrix[3] > 0 ? .5 : -.5)); + break; + case resolution_x: + pp->value = spf->vals.x; + break; + case resolution_y: + pp->value = spf->vals.y; + break; + case average_width: + pp->value = spf->vals.width; + break; + } + } + + for (i = 0, fpt = extraProps; i < NEXTRAPROPS; i++, is_str++, pp++, fpt++) { + pp->name = fpt->atom; + switch (i) { + case FONTPROP: + *is_str = TRUE; + strcpy(tmpname, fontname); + FontParseXLFDName(tmpname, &tmpvals, FONT_XLFD_REPLACE_ZERO); + FontParseXLFDName(tmpname, &spf->vals, FONT_XLFD_REPLACE_VALUE); + pp->value = MakeAtom(tmpname, strlen(tmpname), TRUE); + break; + case COPYRIGHTPROP: + *is_str = TRUE; + pp->value = MakeAtom(spf->master->copyright, + strlen(spf->master->copyright), TRUE); + break; + case FONT_TYPEPROP: + *is_str = TRUE; + pp->value = MakeAtom("Speedo", strlen("Speedo"), TRUE); + break; + case RASTERIZER_NAMEPROP: + *is_str = TRUE; + pp->value = MakeAtom("X Consortium Speedo Rasterizer", + strlen("X Consortium Speedo Rasterizer"), + TRUE); + break; + case RAWPIXELPROP: + *is_str = FALSE; + pp->value = 1000; + break; + case RAWPOINTPROP: + *is_str = FALSE; + pp->value = (long)(72270.0 / (double)spf->vals.y + .5); + break; + case RAWASCENTPROP: + *is_str = FALSE; + pp->value = STRETCH_FACTOR * 764 / 100; + break; + case RAWDESCENTPROP: + *is_str = FALSE; + pp->value = STRETCH_FACTOR * 236 / 100; + break; + case RAWWIDTHPROP: + *is_str = FALSE; + pp->value = sWidth; + break; + } + } +} diff --git a/nx-X11/lib/font/Speedo/spint.h b/nx-X11/lib/font/Speedo/spint.h new file mode 100644 index 000000000..118ea8f42 --- /dev/null +++ b/nx-X11/lib/font/Speedo/spint.h @@ -0,0 +1,180 @@ +/* $Xorg: spint.h,v 1.4 2001/02/09 02:04:00 xorgcvs Exp $ */ +/* + * Copyright 1990, 1991 Network Computing Devices; + * Portions Copyright 1987 by Digital Equipment Corporation + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the names of Network Computing Devices or Digital + * not be used in advertising or publicity pertaining to distribution of + * the software without specific, written prior permission. + * + * NETWORK COMPUTING DEVICES AND DIGITAL DISCLAIM ALL WARRANTIES WITH + * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES OR DIGITAL BE + * LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* + +Copyright 1987, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +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 OPEN GROUP 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. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + +*/ +/* $XFree86: xc/lib/font/Speedo/spint.h,v 1.9 2001/01/17 19:43:20 dawes Exp $ */ + +#ifndef _SPINT_H_ +#define _SPINT_H_ + +#include <X11/fonts/fntfilst.h> +#ifndef XFree86LOADER +#include <stdio.h> +#else +#include <xf86_ansic.h> +#endif +#include <X11/Xfuncproto.h> +#include "speedo.h" + +#define SaveMetrics 0x1 +#define ComputeBoundsOnly 0x2 + +#define GLWIDTHBYTESPADDED(bits,nbytes) \ + ((nbytes) == 1 ? (((bits)+7)>>3) /* pad to 1 byte */ \ + :(nbytes) == 2 ? ((((bits)+15)>>3)&~1) /* pad to 2 bytes */ \ + :(nbytes) == 4 ? ((((bits)+31)>>3)&~3) /* pad to 4 bytes */ \ + :(nbytes) == 8 ? ((((bits)+63)>>3)&~7) /* pad to 8 bytes */ \ + : 0) + +#define GLYPH_SIZE(ch, nbytes) \ + GLWIDTHBYTESPADDED((ch)->metrics.rightSideBearing - \ + (ch)->metrics.leftSideBearing, (nbytes)) + +#define mincharno(p) ((p).min_char_low + ((p).min_char_high << 8)) +#define maxcharno(p) ((p).max_char_low + ((p).max_char_high << 8)) + +#define MasterFileOpen 0x1 + +typedef struct _sp_master { + FontEntryPtr entry; /* back pointer */ + FILE *fp; + char *fname; + ufix8 *f_buffer; + ufix8 *c_buffer; + char *copyright; + ufix8 *key; + buff_t font; + buff_t char_data; + ufix16 mincharsize; + int first_char_id; + int num_chars; + int max_id; + int state; /* open, closed */ + int refcount; /* number of instances */ + int *enc; + int enc_size; +} SpeedoMasterFontRec, *SpeedoMasterFontPtr; + +typedef struct _cur_font_stats { + fsBitmapFormat format; + /* current glyph info */ + ufix16 char_index; + ufix16 char_id; + + fix15 bit_width, + bit_height; + fix15 cur_y; + int bpr; + + /* + * since Speedo returns extents that are not identical to what it feeds to + * the bitmap builder, and we want to be able to use the extents for + * preformance reasons, some of the bitmaps require padding out. the next + * two flags keep track of this. + */ + fix15 last_y; + int trunc; + + pointer bp; + int scanpad; +} CurrentFontValuesRec, *CurrentFontValuesPtr; + + +typedef struct _sp_font { + struct _sp_master *master; + specs_t specs; + + FontEntryPtr entry; + + FontScalableRec vals; + + /* char & metric data */ + CharInfoPtr encoding; + CharInfoPtr pDefault; + pointer bitmaps; + +#ifdef DEBUG + unsigned long bitmap_size; +#endif + +} SpeedoFontRec, *SpeedoFontPtr; + +extern SpeedoFontPtr sp_fp_cur; + +extern int sp_open_font(char *, char *, FontEntryPtr, FontScalablePtr, + fsBitmapFormat, fsBitmapFormatMask, Mask, + SpeedoFontPtr *); +extern int sp_open_master(const char *, const char *, SpeedoMasterFontPtr *); +extern void sp_close_font(SpeedoFontPtr); +extern void sp_close_master_font(SpeedoMasterFontPtr); +extern void sp_close_master_file(SpeedoMasterFontPtr); +extern void sp_reset_master(SpeedoMasterFontPtr); +extern void SpeedoErr(char *fmt, ...); + +extern void sp_make_standard_props(void); +extern void sp_make_header(SpeedoFontPtr, FontInfoPtr); +extern void sp_compute_bounds(SpeedoFontPtr, FontInfoPtr, unsigned long, long *); +extern void sp_compute_props(SpeedoFontPtr, char *, FontInfoPtr, long); +extern int sp_build_all_bitmaps(FontPtr, fsBitmapFormat, fsBitmapFormatMask); +extern unsigned long sp_compute_data_size(FontPtr, int, int, unsigned long, + unsigned long); + +extern int SpeedoFontLoad(FontPtr *, char *, char *, FontEntryPtr, + FontScalablePtr, fsBitmapFormat, fsBitmapFormatMask, + Mask); + +extern int sp_bics_map[]; +extern int sp_bics_map_size; + +#ifdef EXTRAFONTS +extern int adobe_map[]; +extern int adobe_map_size; + +#endif + +#endif /* _SPINT_H_ */ diff --git a/nx-X11/lib/font/Speedo/sptobdf.c b/nx-X11/lib/font/Speedo/sptobdf.c new file mode 100644 index 000000000..ca3caa515 --- /dev/null +++ b/nx-X11/lib/font/Speedo/sptobdf.c @@ -0,0 +1,678 @@ +/* $Xorg: sptobdf.c,v 1.4 2001/02/09 02:04:00 xorgcvs Exp $ */ +/* + * Copyright 1990, 1991 Network Computing Devices; + * Portions Copyright 1987 by Digital Equipment Corporation + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the names of Network Computing Devices and + * Digital not be used in advertising or publicity pertaining to + * distribution of the software without specific, written prior permission. + * Network Computing Devices and Digital make no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * NETWORK COMPUTING DEVICES AND DIGITAL DISCLAIM ALL WARRANTIES WITH + * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES OR DIGITAL BE + * LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Dave Lemke + */ + +/* + +Copyright 1987, 1994, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +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 OPEN GROUP 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. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + +*/ + +/* + * Speedo outline to BFD format converter + */ + +#include <stdio.h> +#include "speedo.h" + +#ifdef EXTRAFONTS +#include "ncdkeys.h" +#else +#include "keys.h" +#endif + +#include "iso8859.h" + +#define MAX_BITS 1024 + +#define BBOX_CLIP + +static char line_of_bits[MAX_BITS + 1]; + +static FILE *fp; +static ufix16 char_index, + char_id; +static buff_t font; +static buff_t char_data; +static ufix8 *f_buffer, + *c_buffer; +static ufix16 mincharsize; +static fix15 cur_y; +static fix15 bit_width, + bit_height; + +static ufix8 key[] = +{ + KEY0, + KEY1, + KEY2, + KEY3, + KEY4, + KEY5, + KEY6, + KEY7, + KEY8 +}; /* Font decryption key */ + + +static char *progname; +static char *fontname = NULL; +static char *fontfile = NULL; + +static int point_size = 120; +static int x_res = 72; +static int y_res = 72; +static int quality = 0; +static int iso_encoding = 1; + +static int num_props = 7; +static int stretch = 120; + +static specs_t specs; + +static void dump_header(); + +static void +usage() +{ + fprintf(stderr, "Usage: %s [-xres x resolution] [-yres y resolution]\n\t[-ptsize pointsize] [-fn fontname] [-q quality (0-1)] fontfile\n", progname); + fprintf(stderr, "Where:\n"); + fprintf(stderr, "-xres specifies the X resolution (72)\n"); + fprintf(stderr, "-yres specifies the Y resolution (72)\n"); + fprintf(stderr, "-pts specifies the pointsize in decipoints (120)\n"); + fprintf(stderr, "-fn specifies the font name (full Bitstream name)\n"); + fprintf(stderr, "-q specifies the font quality [0-1] (0)\n"); + fprintf(stderr, "\n"); + exit(0); +} + +static fix15 +read_2b(ptr) + ufix8 *ptr; +{ + fix15 tmp; + + tmp = *ptr++; + tmp = (tmp << 8) + *ptr; + return tmp; +} + +static fix31 +read_4b(ptr) + ufix8 *ptr; +{ + fix31 tmp; + + tmp = *ptr++; + tmp = (tmp << 8) + *ptr++; + tmp = (tmp << 8) + *ptr++; + tmp = (tmp << 8) + *ptr; + return tmp; +} + +static void +process_args(ac, av) + int ac; + char **av; +{ + int i; + + for (i = 1; i < ac; i++) { + if (!strncmp(av[i], "-xr", 3)) { + if (av[i + 1]) { + x_res = atoi(av[++i]); + } else + usage(); + } else if (!strncmp(av[i], "-yr", 3)) { + if (av[i + 1]) { + y_res = atoi(av[++i]); + } else + usage(); + } else if (!strncmp(av[i], "-pt", 3)) { + if (av[i + 1]) { + point_size = atoi(av[++i]); + } else + usage(); + } else if (!strncmp(av[i], "-fn", 3)) { + if (av[i + 1]) { + fontname = av[++i]; + } else + usage(); + } else if (!strncmp(av[i], "-q", 2)) { + if (av[i + 1]) { + quality = atoi(av[++i]); + } else + usage(); + } else if (!strncmp(av[i], "-st", 3)) { + if (av[i + 1]) { + stretch = atoi(av[++i]); + } else + usage(); + } else if (!strncmp(av[i], "-noni", 5)) { + iso_encoding = 0; + } else if (*av[i] == '-') { + usage(); + } else + fontfile = av[i]; + } + if (!fontfile) + usage(); +} + +void +main(argc, argv) + int argc; + char **argv; +{ + ufix32 i; + ufix8 tmp[16]; + ufix32 minbufsize; + ufix16 cust_no; + int first_char_index, + num_chars; + + progname = argv[0]; + process_args(argc, argv); + fp = fopen(fontfile, "r"); + if (!fp) { + fprintf(stderr, "No such font file, \"%s\"\n", fontfile); + exit(-1); + } + if (fread(tmp, sizeof(ufix8), 16, fp) != 16) { + fprintf(stderr, "error reading \"%s\"\n", fontfile); + exit(-1); + } + minbufsize = (ufix32) read_4b(tmp + FH_FBFSZ); + f_buffer = (ufix8 *) malloc(minbufsize); + if (!f_buffer) { + fprintf(stderr, "can't get %x bytes of memory\n", minbufsize); + exit(-1); + } + fseek(fp, (ufix32) 0, 0); + + if (fread(f_buffer, sizeof(ufix8), (ufix16) minbufsize, fp) != minbufsize) { + fprintf(stderr, "error reading file \"%s\"\n", fontfile); + exit(-1); + } + mincharsize = read_2b(f_buffer + FH_CBFSZ); + + c_buffer = (ufix8 *) malloc(mincharsize); + if (!c_buffer) { + fprintf(stderr, "can't get %x bytes for char buffer\n", mincharsize); + exit(-1); + } + /* init */ + sp_reset(); + + font.org = f_buffer; + font.no_bytes = minbufsize; + + if ((cust_no = sp_get_cust_no(font)) != CUS0) { + fprintf(stderr, "Non-standard encryption for \"%s\"\n", fontfile); + exit(-1); + } + sp_set_key(key); + + first_char_index = read_2b(f_buffer + FH_FCHRF); + num_chars = read_2b(f_buffer + FH_NCHRL); + + /* set up specs */ + /* Note that point size is in decipoints */ + specs.pfont = &font; + /* XXX beware of overflow */ + specs.xxmult = point_size * x_res / 720 * (1 << 16); + specs.xymult = 0L << 16; + specs.xoffset = 0L << 16; + specs.yxmult = 0L << 16; + specs.yymult = point_size * y_res / 720 * (1 << 16); + specs.yoffset = 0L << 16; + switch (quality) { + case 0: + specs.flags = 0; + break; + case 1: + specs.flags = MODE_SCREEN; + break; + case 2: + specs.flags = MODE_2D; + break; + default: + fprintf(stderr, "bogus quality value %d\n", quality); + break; + } + specs.out_info = NULL; + + if (!fontname) { + fontname = (char *) (f_buffer + FH_FNTNM); + } + if (iso_encoding) + num_chars = num_iso_chars; + dump_header(num_chars); + + if (!sp_set_specs(&specs)) { + fprintf(stderr, "can't set specs\n"); + } else { + if (iso_encoding) { + for (i = 0; i < num_iso_chars * 2; i += 2) { + char_index = iso_map[i + 1]; + char_id = iso_map[i]; + if (!sp_make_char(char_index)) { + fprintf(stderr, "can't make char %x\n", char_index); + } + } + } else { + for (i = 0; i < num_chars; i++) { + char_index = i + first_char_index; + char_id = sp_get_char_id(char_index); + if (char_id) { + if (!sp_make_char(char_index)) { + fprintf(stderr, "can't make char %x\n", char_index); + } + } + } + } + } + + (void) fclose(fp); + + printf("ENDFONT\n"); + exit(0); +} + +static void +dump_header(num_chars) + ufix32 num_chars; +{ + fix15 xmin, + ymin, + xmax, + ymax; + fix15 ascent, + descent; + fix15 pixel_size; + + xmin = read_2b(f_buffer + FH_FXMIN); + ymin = read_2b(f_buffer + FH_FYMIN); + xmax = read_2b(f_buffer + FH_FXMAX); + ymax = read_2b(f_buffer + FH_FYMAX); + pixel_size = point_size * x_res / 720; + + printf("STARTFONT 2.1\n"); + printf("COMMENT\n"); + printf("COMMENT Generated from Bitstream Speedo outlines via sptobdf\n"); + printf("COMMENT\n"); + printf("FONT %s\n", fontname); + printf("SIZE %d %d %d\n", pixel_size, x_res, y_res); + printf("FONTBOUNDINGBOX %d %d %d %d\n", xmin, ymin, xmax, ymax); + printf("STARTPROPERTIES %d\n", num_props); + + printf("RESOLUTION_X %d\n", x_res); + printf("RESOLUTION_Y %d\n", y_res); + printf("POINT_SIZE %d\n", point_size); + printf("PIXEL_SIZE %d\n", pixel_size); + printf("COPYRIGHT \"%s\"\n", f_buffer + FH_CPYRT); + + /* do some stretching here so that its isn't too tight */ + pixel_size = pixel_size * stretch / 100; + ascent = pixel_size * 764 / 1000; /* 764 == EM_TOP */ + descent = pixel_size - ascent; + printf("FONT_ASCENT %d\n", ascent); + printf("FONT_DESCENT %d\n", descent); + + printf("ENDPROPERTIES\n"); + printf("CHARS %d\n", num_chars); +} + +buff_t * +sp_load_char_data(file_offset, num, cb_offset) + fix31 file_offset; + fix15 num; + fix15 cb_offset; +{ + if (fseek(fp, (long) file_offset, (int) 0)) { + fprintf(stderr, "can't seek to char\n"); + (void) fclose(fp); + exit(-1); + } + if ((num + cb_offset) > mincharsize) { + fprintf(stderr, "char buf overflow\n"); + (void) fclose(fp); + exit(-2); + } + if (fread((c_buffer + cb_offset), sizeof(ufix8), num, fp) != num) { + fprintf(stderr, "can't get char data\n"); + exit(-1); + } + char_data.org = (ufix8 *) c_buffer + cb_offset; + char_data.no_bytes = num; + + return &char_data; +} + +/* + * Called by Speedo character generator to report an error. + * + * Since character data not available is one of those errors + * that happens many times, don't report it to user + */ +void +sp_report_error(n) + fix15 n; +{ + switch (n) { + case 1: + fprintf(stderr, "Insufficient font data loaded\n"); + break; + case 3: + fprintf(stderr, "Transformation matrix out of range\n"); + break; + case 4: + fprintf(stderr, "Font format error\n"); + break; + case 5: + fprintf(stderr, "Requested specs not compatible with output module\n"); + break; + case 7: + fprintf(stderr, "Intelligent transformation requested but not supported\n"); + break; + case 8: + fprintf(stderr, "Unsupported output mode requested\n"); + break; + case 9: + fprintf(stderr, "Extended font loaded but only compact fonts supported\n"); + break; + case 10: + fprintf(stderr, "Font specs not set prior to use of font\n"); + break; + case 12: + break; + case 13: + fprintf(stderr, "Track kerning data not available()\n"); + break; + case 14: + fprintf(stderr, "Pair kerning data not available()\n"); + break; + default: + fprintf(stderr, "report_error(%d)\n", n); + break; + } +} + +void +sp_open_bitmap(x_set_width, y_set_width, xorg, yorg, xsize, ysize) + fix31 x_set_width; + fix31 y_set_width; + fix31 xorg; + fix31 yorg; + fix15 xsize; + fix15 ysize; +{ + fix15 i; + fix15 off_horz; + fix15 off_vert; + fix31 width, + pix_width; + bbox_t bb; + + bit_width = xsize; + + bit_height = ysize; + off_horz = (fix15) ((xorg + 32768L) >> 16); + off_vert = (fix15) ((yorg + 32768L) >> 16); + + if (bit_width > MAX_BITS) { + +#ifdef DEBUG + fprintf(stderr, "char wider than max bits -- truncated\n"); +#endif + + bit_width = MAX_BITS; + } + width = sp_get_char_width(char_index); + pix_width = width * (specs.xxmult / 65536L) + + ((ufix32) width * ((ufix32) specs.xxmult & 0xffff)) / 65536L; + pix_width /= 65536L; + + width = (pix_width * 7200L) / (point_size * y_res); + + (void) sp_get_char_bbox(char_index, &bb); + bb.xmin >>= 16; + bb.ymin >>= 16; + bb.xmax >>= 16; + bb.ymax >>= 16; + +#ifdef DEBUG + if ((bb.xmax - bb.xmin) != bit_width) + fprintf(stderr, "bbox & width mismatch 0x%x (%d) (%d vs %d)\n", + char_index, char_id, (bb.xmax - bb.xmin), bit_width); + if ((bb.ymax - bb.ymin) != bit_height) + fprintf(stderr, "bbox & height mismatch 0x%x (%d) (%d vs %d)\n", + char_index, char_id, (bb.ymax - bb.ymin), bit_height); + if (bb.xmin != off_horz) + fprintf(stderr, "x min mismatch 0x%x (%d) (%d vs %d)\n", + char_index, char_id, bb.xmin, off_horz); + if (bb.ymin != off_vert) + fprintf(stderr, "y min mismatch 0x%x (%d) (%d vs %d)\n", + char_index, char_id, bb.ymin, off_vert); +#endif + +#ifdef BBOX_CLIP + bit_width = bb.xmax - bb.xmin; + bit_height = bb.ymax - bb.ymin; + off_horz = bb.xmin; + off_vert = bb.ymin; +#endif + + /* XXX kludge to handle space */ + if (bb.xmin == 0 && bb.ymin == 0 && bb.xmax == 0 && bb.ymax == 0 && + width) { + bit_width = 1; + bit_height = 1; + } + printf("STARTCHAR %d\n", char_id); + printf("ENCODING %d\n", char_id); + printf("SWIDTH %d 0\n", width); + printf("DWIDTH %d 0\n", pix_width); + printf("BBX %d %d %d %d\n", bit_width, bit_height, off_horz, off_vert); + printf("BITMAP\n"); + + for (i = 0; i < bit_width; i++) { + line_of_bits[i] = '.'; + } + line_of_bits[bit_width] = '\0'; + cur_y = 0; +} + +static void +dump_line(line) + ufix8 *line; +{ + int bit; + unsigned byte; + + byte = 0; + for (bit = 0; bit < bit_width; bit++) { + if (line[bit] == 'X') + byte |= (1 << (7 - (bit & 7))); + if ((bit & 7) == 7) { + printf("%02X", byte); + byte = 0; + } + } + if ((bit & 7) != 0) + printf("%02X", byte); + printf("\n"); +} + +#ifdef BBOX_CLIP +static fix15 last_y; +static int trunc = 0; + +#endif + +void +sp_set_bitmap_bits(y, xbit1, xbit2) + fix15 y; + fix15 xbit1; + fix15 xbit2; +{ + fix15 i; + + if (xbit1 > MAX_BITS) { + +#ifdef DEBUG + fprintf(stderr, "run wider than max bits -- truncated\n"); +#endif + + xbit1 = MAX_BITS; + } + if (xbit2 > MAX_BITS) { + +#ifdef DEBUG + fprintf(stderr, "run wider than max bits -- truncated\n"); +#endif + + xbit2 = MAX_BITS; + } + while (cur_y != y) { + dump_line(line_of_bits); + for (i = 0; i < bit_width; i++) { + line_of_bits[i] = '.'; + } + cur_y++; + } + +#ifdef BBOX_CLIP + last_y = y; + if (y >= bit_height) { + +#ifdef DEBUG + fprintf(stderr, + "y value is larger than height 0x%x (%d) -- truncated\n", + char_index, char_id); +#endif + + trunc = 1; + return; + } +#endif /* BBOX_CLIP */ + + for (i = xbit1; i < xbit2; i++) { + line_of_bits[i] = 'X'; + } +} + +void +sp_close_bitmap() +{ + +#ifdef BBOX_CLIP + int i; + + if (!trunc) + dump_line(line_of_bits); + trunc = 0; + + + last_y++; + while (last_y < bit_height) { + +#ifdef DEBUG + fprintf(stderr, "padding out height for 0x%x (%d)\n", + char_index, char_id); +#endif + + for (i = 0; i < bit_width; i++) { + line_of_bits[i] = '.'; + } + dump_line(line_of_bits); + last_y++; + } + +#else + dump_line(line_of_bits); +#endif + + printf("ENDCHAR\n"); +} + +/* outline stubs */ +void +sp_open_outline() +{ +} + +void +sp_start_new_char() +{ +} + +void +sp_start_contour() +{ +} + +void +sp_curve_to() +{ +} + +void +sp_line_to() +{ +} + +void +sp_close_contour() +{ +} + +void +sp_close_outline() +{ +} diff --git a/nx-X11/lib/font/Speedo/useropt.h b/nx-X11/lib/font/Speedo/useropt.h new file mode 100644 index 000000000..e879aae96 --- /dev/null +++ b/nx-X11/lib/font/Speedo/useropt.h @@ -0,0 +1,41 @@ +/* $Xorg: useropt.h,v 1.4 2001/02/09 02:04:00 xorgcvs Exp $ */ +/* + +Copyright 1993, 1994, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +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 OPEN GROUP 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. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + +*/ + +#define INCL_LCD 1 +#define STATIC_ALLOC 1 + +#define INCL_BLACK 1 +#define INCL_SCREEN 1 +#define INCL_2D 1 +#define SHORT_LISTS 0 + +#define INCL_RULES 1 +#define INCL_METRICS 1 + +#define INCL_KEYS 1 |