Merge the gs853merge branch down into the trunk. This ports ghostpcl and

ghostxps to build against a branch of ghostscript close it its current
mainline (around r7000) between Ghostscript 8.54 and 8.55.

This mostly consists of removing the memory pointers from many calls as
well as a few other api changes, as well as some makefile updates, which
were skewed between the branches.

Nevertheless this is a big merge and there are likely to be a few
mistakes. The previous trunk is tagged as /tags/ghostpcl-pre855merge
for comparision.

Both pcl6 and pspcl6 build and run with the Artifex font scaler (the
native gs one). pcl6 compiles but does not link with ufst. pspcl6 does
not compile with ufst, but that's not too different from what was
happening in the branch. Fixing this will of course come next.

git-svn-id: http://svn.ghostscript.com/ghostpcl/trunk/ghostpcl@2566 06663e23-700e-0410-b217-a244a6096597

1 files changed, 268 insertions, 0 deletions

diff --git a/tools/gslite/gslt_font_api_test.c b/tools/gslite/gslt_font_api_test.c
new file mode 100644
index 000000000..7425f64dc
--- /dev/null
+++ b/tools/gslite/gslt_font_api_test.c
@@ -0,0 +1,268 @@
+/* Copyright (C) 2006 artofcode LLC.
+   All Rights Reserved.
+
+   This software is provided AS-IS with no warranty, either express or
+   implied.
+
+   This software is distributed under license and may not be copied, modified
+   or distributed except as expressly authorized under the terms of that
+   license.  Refer to licensing information at http://www.artifex.com/
+   or contact Artifex Software, Inc.,  7 Mt. Lassen Drive - Suite A-134,
+   San Rafael, CA  94903, U.S.A., +1(415)492-9861, for further information.
+*/
+
+/* $Id: gslt_font_api_test.c 2461 2006-07-14 18:54:03Z giles $ */
+/* gslt OpenType font library example client */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <gserror.h>
+
+#include "gslt.h"
+#include "gslt_font_api.h"
+
+/* these are not strictly needed */
+extern void gs_erasepage(gs_state *pgs);
+extern void gs_moveto(gs_state *pgs, double, double);
+extern void gs_output_page(gs_state *pgs, int, int);
+extern char gs_debug[];
+
+/*
+ * Read a file from disk into memory.
+ */
+
+int readfile(char *filename, char **datap, int *lengthp)
+{
+    FILE *fp;
+    int t, n;
+    char *p;
+
+    fp = fopen(filename, "rb");
+    if (!fp)
+        return gs_throw(-1, "cannot open font file");
+
+    t = fseek(fp, 0, 2);
+    if (t < 0)
+    {
+        fclose(fp);
+        return gs_throw(-1, "cannot seek in font file");
+    }
+
+    n = ftell(fp);
+    if (n < 0)
+    {
+        fclose(fp);
+        return gs_throw(-1, "cannot tell in font file");
+    }
+
+    t = fseek(fp, 0, 0);
+    if (t < 0)
+    {
+        fclose(fp);
+        return gs_throw(-1, "cannot seek in font file");
+    }
+
+    p = malloc(n);
+    if (!p)
+    {
+        fclose(fp);
+        return gs_throw(-1, "out of memory");
+    }
+
+    t = fread(p, 1, n, fp);
+    if (t != n)
+    {
+        free(p);
+        fclose(fp);
+        return gs_throw(-1, "cannot read font file data");
+    }
+
+    t = fclose(fp);
+    if (t < 0)
+    {
+        gs_throw(-1, "cannot close font file");
+        /* ... continue anyway */
+    }
+
+    *lengthp = n;
+    *datap = p;
+
+    return 0;
+}
+
+/*
+ * Test program.
+ */
+
+static int mymoveto(void *ctx, float x, float y)
+{
+    x *= 1000; y *= 1000;
+    printf("%g %g moveto\n", x, y);
+    return 0;
+}
+
+static int mylineto(void *ctx, float x, float y)
+{
+    x *= 1000; y *= 1000;
+    printf("%g %g lineto\n", x, y);
+    return 0;
+}
+
+static int mycurveto(void *ctx, float x0, float y0, float x1, float y1, float x2, float y2)
+{
+    x0 *= 1000; y0 *= 1000;
+    x1 *= 1000; y1 *= 1000;
+    x2 *= 1000; y2 *= 1000;
+    printf("%g %g  %g %g  %g %g curveto\n", x0, y0, x1, y1, x2, y2);
+    return 0;
+}
+
+static int myclosepath(void *ctx)
+{
+    printf("closepath\n");
+    return 0;
+}
+
+int
+main(int argc, const char *argv[])
+{
+    gs_memory_t *mem;
+    gx_device *dev;
+    gs_state *pgs;
+    gs_font_dir *cache;
+    gslt_font_t *font;
+    gslt_outline_walker_t walk;
+    gslt_glyph_bitmap_t slot;
+    gslt_glyph_metrics_t mtx;
+    gs_matrix ctm;
+    int code;
+    char *s;
+    char *devicename;
+    int i, n, pid, eid, best;
+    char *buf;
+    int len;
+
+    char *text;
+
+    devicename = getenv("DEVICE");
+    if (!devicename)
+        devicename = "nullpage";
+
+    mem = gslt_init_library();
+    dev = gslt_init_device(mem, devicename);
+    pgs = gslt_init_state(mem, dev);
+
+//    n = readfile("/Users/tor/Documents/msfonts/times.ttf", &buf, &len);
+    n = readfile("/usr/share/fonts/truetype/ttf-bitstream-vera/VeraIt.ttf", &buf, &len);
+    if (n < 0)
+        return gs_throw(1, "could not read font file");
+
+    gs_debug['k'] = 1; /* debug character cache machinery */
+
+    /*
+     * Set up ghostscript library
+     */
+
+    // gslt_get_device_param(mem, dev, "Name");
+    gslt_set_device_param(mem, dev, "OutputFile", "-");
+
+    // so we see what device calls are made
+    gs_erasepage(pgs);
+    gs_moveto(pgs, 5.0, 20.0);
+
+    /*
+     * Create a font cache
+     */
+
+    cache = gslt_new_font_cache(mem);
+    if (!cache)
+        return gs_throw(1, "could not create font cache");
+
+    /*
+     * Create the font and select an encoding
+     */
+
+    font = gslt_new_font(mem, cache, buf, len, 0);
+    if (!font)
+        return gs_throw(1, "could not create font");
+
+    n = gslt_count_font_encodings(font);
+    for (best = 0, i = 0; i < n; i++)
+    {
+        gslt_identify_font_encoding(font, i, &pid, &eid);
+        if (pid == 3 && eid == 0)
+            best = i;
+    }
+    gslt_select_font_encoding(font, best);
+
+    /*
+     * Test bitmap rendering.
+     */
+
+    text = "Pack my box with five dozen liquor jugs!";
+
+    ctm.xx = 48.0;
+    ctm.xy = 0.0;
+    ctm.yx = 0.0;
+    ctm.yy = 48.0;
+    ctm.tx = ctm.ty = 0.0;
+
+    for (s = text; *s; s++)
+    {
+        int gid = gslt_encode_font_char(font, *s);
+
+        code = gslt_measure_font_glyph(pgs, font, gid, &mtx);
+        if (code < 0)
+        {
+            printf("error in gslt_measure_font_glyph\n");
+            continue;
+        }
+
+        code = gslt_render_font_glyph(pgs, font, &ctm, gid, &slot);
+        if (code < 0)
+        {
+            printf("error in gslt_render_font_glyph\n");
+            continue;
+        }
+
+
+        printf("glyph %3d: v=%f,%f w=%f,%f ", gid, mtx.v[0], mtx.v[1], mtx.w[0], mtx.w[1]);
+        printf(" -> %dx%d+(%d,%d) w=%f,%f\n",
+                slot.w, slot.h,
+                slot.lsb,
+                slot.top,
+                slot.xadv,
+                slot.yadv);
+    }
+
+    /*
+     * Test outline extraction.
+     */
+
+    walk.user = NULL;
+    walk.moveto = mymoveto;
+    walk.lineto = mylineto;
+    walk.curveto = mycurveto;
+    walk.closepath = myclosepath;
+
+    code = gslt_outline_font_glyph(pgs, font, gslt_encode_font_char(font, 'e'), &walk);
+    if (code < 0)
+        printf("error in gslt_outline_font_glyph\n");
+
+    /*
+     * Clean up.
+     */
+
+    // show device and wait for keypress
+    gs_output_page(pgs, 1, 1);
+    getchar();
+
+    gslt_free_font(mem, font);
+    gslt_free_font_cache(mem, cache);
+    free(buf);
+    gslt_free_library(mem, dev, pgs);
+
+    return 0;
+}
+