Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1

Summary: Imported nx-X11-3.1.0-1.tar.gz
Keywords:

Imported nx-X11-3.1.0-1.tar.gz
into Git repository

1 files changed, 650 insertions, 0 deletions

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);
+}
+