Subversion Repositories planix.SVN

/* Copyright (C) 1989, 1995, 1996, 1997, 1998, 1999 Aladdin Enterprises.  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 the license contained in the file LICENSE in this distribution.

  For more information about licensing, please refer to

  http://www.ghostscript.com/licensing/. For information on

  commercial licensing, go to http://www.artifex.com/licensing/ or

  contact Artifex Software, Inc., 101 Lucas Valley Road #110,

  San Rafael, CA  94903, U.S.A., +1(415)492-9861.

*/

/* $Id: gxchar.c,v 1.47 2005/07/21 09:53:42 igor Exp $ */

/* Default implementation of text writing */

#include "gx.h"

#include "memory_.h"

#include "string_.h"

#include "gserrors.h"

#include "gsstruct.h"

#include "gxfixed.h"		/* ditto */

#include "gxarith.h"

#include "gxmatrix.h"

#include "gzstate.h"

#include "gxcoord.h"

#include "gxdevice.h"

#include "gxdevmem.h"

#include "gxchar.h"

#include "gxfont.h"

#include "gxfont0.h"

#include "gxfcache.h"

#include "gspath.h"

#include "gzpath.h"

#include "gxfcid.h"

/* Define whether or not to cache characters rotated by angles other than */

/* multiples of 90 degrees. */

private const bool CACHE_ROTATED_CHARS = true;

/* Define the maximum size of a full temporary bitmap when rasterizing, */

/* in bits (not bytes). */

private const uint MAX_TEMP_BITMAP_BITS = 80000;

/* Define whether the show operation uses the character outline data, */

/* as opposed to just needing the width (or nothing). */

#define SHOW_USES_OUTLINE(penum)\

  !SHOW_IS(penum, TEXT_DO_NONE | TEXT_DO_CHARWIDTH)

/* Structure descriptors */

public_st_gs_show_enum();

extern_st(st_gs_text_enum);

extern_st(st_gs_state);		/* only for testing */

private 

ENUM_PTRS_BEGIN(show_enum_enum_ptrs)

     return ENUM_USING(st_gs_text_enum, vptr, size, index - 5);

ENUM_PTR(0, gs_show_enum, pgs);

ENUM_PTR(1, gs_show_enum, show_gstate);

ENUM_PTR3(2, gs_show_enum, dev_cache, dev_cache2, dev_null);

ENUM_PTRS_END

private RELOC_PTRS_WITH(show_enum_reloc_ptrs, gs_show_enum *eptr)

{

    RELOC_USING(st_gs_text_enum, vptr, size);		/* superclass */

    RELOC_VAR(eptr->pgs);

    RELOC_VAR(eptr->show_gstate);

    RELOC_PTR3(gs_show_enum, dev_cache, dev_cache2, dev_null);

}

RELOC_PTRS_END

/* Forward declarations */

private int continue_kshow(gs_show_enum *);

private int continue_show(gs_show_enum *);

private int continue_show_update(gs_show_enum *);

private void show_set_scale(const gs_show_enum *, gs_log2_scale_point *log2_scale);

private int show_cache_setup(gs_show_enum *);

private int show_state_setup(gs_show_enum *);

private int show_origin_setup(gs_state *, fixed, fixed, gs_show_enum * penum);

/* Accessors for current_char and current_glyph. */

#define CURRENT_CHAR(penum) ((penum)->returned.current_char)

#define SET_CURRENT_CHAR(penum, chr)\

  ((penum)->returned.current_char = (chr))

#define CURRENT_GLYPH(penum) ((penum)->returned.current_glyph)

#define SET_CURRENT_GLYPH(penum, glyph)\

  ((penum)->returned.current_glyph = (glyph))

/* Allocate a show enumerator. */

gs_show_enum *

gs_show_enum_alloc(gs_memory_t * mem, gs_state * pgs, client_name_t cname)

{

    gs_show_enum *penum;

    rc_alloc_struct_1(penum, gs_show_enum, &st_gs_show_enum, mem,

		      return 0, cname);

    penum->rc.free = rc_free_text_enum;

    penum->auto_release = true;	/* old API */

    /* Initialize pointers for GC */

    penum->text.operation = 0;	/* no pointers relevant */

    penum->dev = 0;

    penum->pgs = pgs;

    penum->show_gstate = 0;

    penum->dev_cache = 0;

    penum->dev_cache2 = 0;

    penum->fapi_log2_scale.x = penum->fapi_log2_scale.y = -1;

    penum->fapi_glyph_shift.x = penum->fapi_glyph_shift.y = 0;

    penum->dev_null = 0;

    penum->fstack.depth = -1;

    return penum;

}

/* ------ Driver procedure ------ */

private text_enum_proc_resync(gx_show_text_resync);

private text_enum_proc_process(gx_show_text_process);

private text_enum_proc_is_width_only(gx_show_text_is_width_only);

private text_enum_proc_current_width(gx_show_text_current_width);

private text_enum_proc_set_cache(gx_show_text_set_cache);

private text_enum_proc_retry(gx_show_text_retry);

private text_enum_proc_release(gx_show_text_release); /* not default */

private const gs_text_enum_procs_t default_text_procs = {

    gx_show_text_resync, gx_show_text_process,

    gx_show_text_is_width_only, gx_show_text_current_width,

    gx_show_text_set_cache, gx_show_text_retry,

    gx_show_text_release

};

int

gx_default_text_begin(gx_device * dev, gs_imager_state * pis,

		      const gs_text_params_t * text, gs_font * font,

		      gx_path * path, const gx_device_color * pdcolor,

		      const gx_clip_path * pcpath,

		      gs_memory_t * mem, gs_text_enum_t ** ppte)

{

    uint operation = text->operation;

    bool propagate_charpath = (operation & TEXT_DO_DRAW) != 0;

    int code;

    gs_state *pgs = (gs_state *)pis;

    gs_show_enum *penum;

    /*

     * For the moment, require pis to be a gs_state *, since all the

     * procedures for character rendering expect it.

     */

    if (gs_object_type(mem, pis) != &st_gs_state)

	return_error(gs_error_Fatal);

    penum = gs_show_enum_alloc(mem, pgs, "gx_default_text_begin");

    if (!penum)

	return_error(gs_error_VMerror);

    code = gs_text_enum_init((gs_text_enum_t *)penum, &default_text_procs,

			     dev, pis, text, font, path, pdcolor, pcpath, mem);

    if (code < 0) {

	gs_free_object(mem, penum, "gx_default_text_begin");

	return code;

    }

    penum->auto_release = false; /* new API */

    penum->level = pgs->level;

    if (operation & TEXT_DO_ANY_CHARPATH)

	penum->charpath_flag =

	    (operation & TEXT_DO_FALSE_CHARPATH ? cpm_false_charpath :

	     operation & TEXT_DO_TRUE_CHARPATH ? cpm_true_charpath :

	     operation & TEXT_DO_FALSE_CHARBOXPATH ? cpm_false_charboxpath :

	     operation & TEXT_DO_TRUE_CHARBOXPATH ? cpm_true_charboxpath :

	     operation & TEXT_DO_CHARWIDTH ? cpm_charwidth :

	     cpm_show /* can't happen */ );

    else

	penum->charpath_flag =

	    (propagate_charpath ? pgs->in_charpath : cpm_show);

    penum->cc = 0;

    penum->continue_proc = continue_show;

    /* Note: show_state_setup may reset can_cache. */

    switch (penum->charpath_flag) {

    case cpm_false_charpath: case cpm_true_charpath:

	penum->can_cache = -1; break;

    case cpm_false_charboxpath: case cpm_true_charboxpath:

	penum->can_cache = 0; break;

    case cpm_charwidth:

    default:			/* cpm_show */

	penum->can_cache = 1; break;

    }

    code = show_state_setup(penum);

    if (code < 0)

	return code;

    penum->show_gstate =

	(propagate_charpath && (pgs->in_charpath != 0) ?

	 pgs->show_gstate : pgs);

    if (!(~operation & (TEXT_DO_NONE | TEXT_RETURN_WIDTH))) {

	/* This is stringwidth. */

	gx_device_null *dev_null =

	    gs_alloc_struct(mem, gx_device_null, &st_device_null,

			    "stringwidth(dev_null)");

	if (dev_null == 0)

	    return_error(gs_error_VMerror);

	/* Do an extra gsave and suppress output */

	if ((code = gs_gsave(pgs)) < 0)

	    return code;

	penum->level = pgs->level;	/* for level check in show_update */

	/* Set up a null device that forwards xfont requests properly. */

	gs_make_null_device(dev_null, gs_currentdevice_inline(pgs), mem);

	pgs->ctm_default_set = false;

	penum->dev_null = dev_null;

	/* Retain this device, since it is referenced from the enumerator. */

	gx_device_retain((gx_device *)dev_null, true);

	gs_setdevice_no_init(pgs, (gx_device *) dev_null);

	/* Establish an arbitrary translation and current point. */

	gs_newpath(pgs);

	gx_translate_to_fixed(pgs, fixed_0, fixed_0);

	code = gx_path_add_point(pgs->path, fixed_0, fixed_0);

	if (code < 0)

	    return code;

    }

    *ppte = (gs_text_enum_t *)penum;

    return 0;

}

/* An auxiliary functions for pdfwrite to process type 3 fonts. */

int

gx_hld_stringwidth_begin(gs_imager_state * pis, gx_path **path)

{

    gs_state *pgs = (gs_state *)pis;

    extern_st(st_gs_state);

    int code;

    if (gs_object_type(pis->memory, pis) != &st_gs_state)

	return_error(gs_error_unregistered);

    code = gs_gsave(pgs);

    if (code < 0)

	return code;

    gs_newpath(pgs);

    *path = pgs->path;

    gx_translate_to_fixed(pgs, fixed_0, fixed_0);

    return gx_path_add_point(pgs->path, fixed_0, fixed_0);

}

int

gx_default_text_restore_state(gs_text_enum_t *pte)

{

    gs_show_enum *penum;

    gs_state *pgs;

    if (SHOW_IS(pte, TEXT_DO_NONE))

	return 0;

    penum = (gs_show_enum *)pte;

    pgs = penum->pgs;

    return gs_grestore(pgs);

}

/* ------ Width/cache setting ------ */

private int

    set_cache_device(gs_show_enum *penum, gs_state *pgs,

		     floatp llx, floatp lly, floatp urx, floatp ury);

/* This is the default implementation of text enumerator set_cache. */

private int

gx_show_text_set_cache(gs_text_enum_t *pte, const double *pw,

			  gs_text_cache_control_t control)

{

    gs_show_enum *const penum = (gs_show_enum *)pte;

    gs_state *pgs = penum->pgs;

    switch (control) {

    case TEXT_SET_CHAR_WIDTH:

	return set_char_width(penum, pgs, pw[0], pw[1]);

    case TEXT_SET_CACHE_DEVICE: {

	int code = set_char_width(penum, pgs, pw[0], pw[1]);	/* default is don't cache */

	if (code < 0)

	    return code;

	if (SHOW_IS_ALL_OF(penum, TEXT_DO_NONE | TEXT_INTERVENE)) /* cshow */

            return code;

	return set_cache_device(penum, pgs, pw[2], pw[3], pw[4], pw[5]);

    }

    case TEXT_SET_CACHE_DEVICE2: {

	int code;

	bool retry = (penum->width_status == sws_retry);

	if (gs_rootfont(pgs)->WMode) {

	    float vx = pw[8], vy = pw[9];

	    gs_fixed_point pvxy, dvxy;

	    gs_fixed_point rewind_pvxy;

	    int rewind_code;

	    if ((code = gs_point_transform2fixed(&pgs->ctm, -vx, -vy, &pvxy)) < 0 ||

		(code = gs_distance_transform2fixed(&pgs->ctm, vx, vy, &dvxy)) < 0

		)

		return 0;		/* don't cache */

	    if ((code = set_char_width(penum, pgs, pw[6], pw[7])) < 0)

		return code;

	    if (SHOW_IS_ALL_OF(penum, TEXT_DO_NONE | TEXT_INTERVENE))

		return code;

	    /* Adjust the origin by (vx, vy). */

	    gx_translate_to_fixed(pgs, pvxy.x, pvxy.y);

	    code = set_cache_device(penum, pgs, pw[2], pw[3], pw[4], pw[5]);

	    if (code != 1) {

	        if (retry) {

		   rewind_code = gs_point_transform2fixed(&pgs->ctm, vx, vy, &rewind_pvxy);

		   if (rewind_code < 0) {

		       /* If the control passes here, something is wrong. */

		       return_error(gs_error_unregistered);

		   }

		   /* Rewind the origin by (-vx, -vy) if the cache is failed. */

		   gx_translate_to_fixed(pgs, rewind_pvxy.x, rewind_pvxy.y);

		}

		return code;

	    }

	    /* Adjust the character origin too. */

	    (penum->cc)->offset.x += dvxy.x;

	    (penum->cc)->offset.y += dvxy.y;

	} else {

	    code = set_char_width(penum, pgs, pw[0], pw[1]);

	    if (code < 0)

		return code;

	    if (SHOW_IS_ALL_OF(penum, TEXT_DO_NONE | TEXT_INTERVENE))

		return code;

	    code = set_cache_device(penum, pgs, pw[2], pw[3], pw[4], pw[5]);

	}

	return code;

    }

    default:

	return_error(gs_error_rangecheck);

    }

}

/* Set the character width. */

/* Note that this returns 1 if the current show operation is */

/* non-displaying (stringwidth or cshow). */

int

set_char_width(gs_show_enum *penum, gs_state *pgs, floatp wx, floatp wy)

{

    int code;

    if (penum->width_status != sws_none && penum->width_status != sws_retry)

	return_error(gs_error_undefined);

    if (penum->fstack.depth > 0 && 

	penum->fstack.items[penum->fstack.depth].font->FontType == ft_CID_encrypted) {

    	/* We must not convert advance width with a CID font leaf's FontMatrix,

	   because CDevProc is attached to the CID font rather than to its leaf.

	   But show_state_setup sets CTM with the leaf's matrix.

	   Compensate it here with inverse FontMatrix of the leaf.

	   ( We would like to do without an inverse transform, but 

	     we don't like to extend general gs_state or gs_show_enum

	     for this particular reason. ) */

	const gx_font_stack_item_t *pfsi = &penum->fstack.items[penum->fstack.depth];

	gs_point p;

	code = gs_distance_transform_inverse(wx, wy,

		&gs_cid0_indexed_font(pfsi->font, pfsi->index)->FontMatrix, &p);

	if (code < 0)

	    return code;

	wx = p.x; 

	wy = p.y;

    }

    if ((code = gs_distance_transform2fixed(&pgs->ctm, wx, wy, &penum->wxy)) < 0)

	return code;

    /* Check whether we're setting the scalable width */

    /* for a cached xfont character. */

    if (penum->cc != 0) {

	penum->cc->wxy = penum->wxy;

	penum->width_status = sws_cache_width_only;

    } else {

	penum->width_status = sws_no_cache;

    }

    if (SHOW_IS_ALL_OF(penum, TEXT_DO_NONE | TEXT_INTERVENE)) /* cshow */

	gs_nulldevice(pgs);

    return !SHOW_IS_DRAWING(penum);

}

void

gx_compute_text_oversampling(const gs_show_enum * penum, const gs_font *pfont, 

                             int alpha_bits, gs_log2_scale_point *p_log2_scale)

{

    gs_log2_scale_point log2_scale;

    if (alpha_bits == 1) 

	log2_scale.x = log2_scale.y = 0;

    else if (pfont->PaintType != 0) {

	/* Don't oversample artificially stroked fonts. */

	log2_scale.x = log2_scale.y = 0;

    } else if (!penum->is_pure_color) {

	/* Don't oversample characters for rendering in non-pure color. */

	log2_scale.x = log2_scale.y = 0;

    } else {

	int excess;

	/* Get maximal scale according to cached bitmap size. */

	show_set_scale(penum, &log2_scale);

	/* Reduce the scale to fit into alpha bits. */

	excess = log2_scale.x + log2_scale.y - alpha_bits;

	while (excess > 0) {

	    if (log2_scale.y > 0) {

		log2_scale.y --; 

		excess--;

		if (excess == 0)

		    break;

	    }

	    if (log2_scale.x > 0) {

		log2_scale.x --; 

		excess--;

	    }

	}

    }

    *p_log2_scale = log2_scale;

}

/* Compute glyph raster parameters */

private int

compute_glyph_raster_params(gs_show_enum *penum, bool in_setcachedevice, int *alpha_bits, 

		    int *depth,

                    gs_fixed_point *subpix_origin, gs_log2_scale_point *log2_scale)

{

    gs_state *pgs = penum->pgs;

    gx_device *dev = gs_currentdevice_inline(pgs);

    int code;

    *alpha_bits = (*dev_proc(dev, get_alpha_bits)) (dev, go_text);

    if (in_setcachedevice) {

	/* current point should already be in penum->origin */

    } else {

	code = gx_path_current_point_inline(pgs->path, &penum->origin);

	if (code < 0) {

	    /* For cshow, having no current point is acceptable. */

	    if (!SHOW_IS(penum, TEXT_DO_NONE))

		return code;

	    penum->origin.x = penum->origin.y = 0;	/* arbitrary */

	}

    }

    if (penum->fapi_log2_scale.x != -1)

	*log2_scale = penum->fapi_log2_scale;

    else

	gx_compute_text_oversampling(penum, penum->current_font, *alpha_bits, log2_scale);

    /*	We never oversample over the device alpha_bits,

     * so that we don't need to scale down. Perhaps it may happen 

     * that we underuse alpha_bits due to a big character raster,

     * so we must compute log2_depth more accurately :

     */

    *depth = (log2_scale->x + log2_scale->y == 0 ?

        1 : min(log2_scale->x + log2_scale->y, *alpha_bits));

    if (gs_currentaligntopixels(penum->current_font->dir) == 0) {

	int scx = -1L << (_fixed_shift - log2_scale->x);

	int rdx =  1L << (_fixed_shift - 1 - log2_scale->x);

#	if 1 /* Ever align Y to pixels to provide an uniform glyph height. */

	    subpix_origin->y = 0;

#	else

	    int scy = -1L << (_fixed_shift - log2_scale->y);

	    int rdy =  1L << (_fixed_shift - 1 - log2_scale->y);

	    subpix_origin->y = ((penum->origin.y + rdy) & scy) & (fixed_1 - 1);

#	endif

	subpix_origin->x = ((penum->origin.x + rdx) & scx) & (fixed_1 - 1);

    } else

	subpix_origin->x = subpix_origin->y = 0;

    return 0;

}

/* Set up the cache device if relevant. */

/* Return 1 if we just set up a cache device. */

/* Used by setcachedevice and setcachedevice2. */

private int

set_cache_device(gs_show_enum * penum, gs_state * pgs, floatp llx, floatp lly,

		 floatp urx, floatp ury)

{

    gs_glyph glyph;

    /* See if we want to cache this character. */

    if (pgs->in_cachedevice)	/* no recursion! */

	return 0;

    if (SHOW_IS_ALL_OF(penum, TEXT_DO_NONE | TEXT_INTERVENE)) { /* cshow */

	int code;

	if_debug0('k', "[k]no cache: cshow");

	code = gs_nulldevice(pgs);

	if (code < 0)

	    return code;

	return 0;

    }

    pgs->in_cachedevice = CACHE_DEVICE_NOT_CACHING;	/* disable color/gray/image operators */

    /* We can only use the cache if we know the glyph. */

    glyph = CURRENT_GLYPH(penum);

    if (glyph == gs_no_glyph)

	return 0;

    /* We can only use the cache if ctm is unchanged */

    /* (aside from a possible translation). */

    if (penum->can_cache <= 0 || !pgs->char_tm_valid) {

	if_debug2('k', "[k]no cache: can_cache=%d, char_tm_valid=%d\n",

		  penum->can_cache, (int)pgs->char_tm_valid);

	return 0;

    } {

	const gs_font *pfont = pgs->font;

	gs_font_dir *dir = pfont->dir;

        int alpha_bits, depth;

	gs_log2_scale_point log2_scale;

	gs_fixed_point subpix_origin;

        static const fixed max_cdim[3] =

        {

#define max_cd(n)\

	    (fixed_1 << (arch_sizeof_short * 8 - n)) - (fixed_1 >> n) * 3

	    max_cd(0), max_cd(1), max_cd(2)

#undef max_cd

        };

	ushort iwidth, iheight;

	cached_char *cc;

	gs_fixed_rect clip_box;

	int code;

	/* Compute the bounding box of the transformed character. */

	/* Since we accept arbitrary transformations, the extrema */

	/* may occur in any order; however, we can save some work */

	/* by observing that opposite corners before transforming */

	/* are still opposite afterwards. */

	gs_fixed_point cll, clr, cul, cur, cdim;

	if ((code = gs_distance_transform2fixed(&pgs->ctm, llx, lly, &cll)) < 0 ||

	    (code = gs_distance_transform2fixed(&pgs->ctm, llx, ury, &clr)) < 0 ||

	    (code = gs_distance_transform2fixed(&pgs->ctm, urx, lly, &cul)) < 0 ||

	 (code = gs_distance_transform2fixed(&pgs->ctm, urx, ury, &cur)) < 0

	    )

	    return 0;		/* don't cache */

	{

	    fixed ctemp;

#define swap(a, b) ctemp = a, a = b, b = ctemp

#define make_min(a, b) if ( (a) > (b) ) swap(a, b)

	    make_min(cll.x, cur.x);

	    make_min(cll.y, cur.y);

	    make_min(clr.x, cul.x);

	    make_min(clr.y, cul.y);

#undef make_min

#undef swap

	}

	/* Now take advantage of symmetry. */

	if (clr.x < cll.x)

	    cll.x = clr.x, cur.x = cul.x;

	if (clr.y < cll.y)

	    cll.y = clr.y, cur.y = cul.y;

	/* Now cll and cur are the extrema of the box. */

	code = compute_glyph_raster_params(penum, true, &alpha_bits, &depth,

           &subpix_origin, &log2_scale);

	if (code < 0)

	    return code;

#ifdef DEBUG

        if (gs_debug_c('k')) {

	    dlprintf6("[k]cbox=[%g %g %g %g] scale=%dx%d\n",

		      fixed2float(cll.x), fixed2float(cll.y),

		      fixed2float(cur.x), fixed2float(cur.y),

		      1 << log2_scale.x, 1 << log2_scale.y);

	    dlprintf6("[p]  ctm=[%g %g %g %g %g %g]\n",

		      pgs->ctm.xx, pgs->ctm.xy, pgs->ctm.yx, pgs->ctm.yy,

		      pgs->ctm.tx, pgs->ctm.ty);

        }

#endif

	cdim.x = cur.x - cll.x;

	cdim.y = cur.y - cll.y;

	if (cdim.x > max_cdim[log2_scale.x] ||

	    cdim.y > max_cdim[log2_scale.y]

	    )

	    return 0;		/* much too big */

	iwidth = ((ushort) fixed2int_var(cdim.x) + 2) << log2_scale.x;

	iheight = ((ushort) fixed2int_var(cdim.y) + 2) << log2_scale.y;

	if_debug3('k', "[k]iwidth=%u iheight=%u dev_cache %s\n",

		  (uint) iwidth, (uint) iheight,

		  (penum->dev_cache == 0 ? "not set" : "set"));

	if (penum->dev_cache == 0) {

	    code = show_cache_setup(penum);

	    if (code < 0)

		return code;

	}

	/*

	 * If we're oversampling (i.e., the temporary bitmap is

	 * larger than the final monobit or alpha array) and the

	 * temporary bitmap is large, use incremental conversion

	 * from oversampled bitmap strips to alpha values instead of

	 * full oversampling with compression at the end.

	 */

	cc = gx_alloc_char_bits(dir, penum->dev_cache,

				(iwidth > MAX_TEMP_BITMAP_BITS / iheight &&

				 log2_scale.x + log2_scale.y > alpha_bits ?

				 penum->dev_cache2 : NULL),

				iwidth, iheight, &log2_scale, depth);

	if (cc == 0) {

	    /* too big for cache or no cache */

	    gx_path box_path;

	    if (penum->current_font->FontType != ft_user_defined && 

		penum->current_font->FontType != ft_CID_user_defined) {

		/* Most fonts don't paint outside bbox,

		   so render with no clipping. */

		return 0;

	    }

	    /* Render with a clip. */

	    /* show_proceed already did gsave. */

	    pgs->in_cachedevice = CACHE_DEVICE_NONE; /* Provide a correct grestore on error. */

	    clip_box.p.x = penum->origin.x - fixed_ceiling(-cll.x);

	    clip_box.p.y = penum->origin.y - fixed_ceiling(-cll.y);

	    clip_box.q.x = clip_box.p.x + int2fixed(iwidth);

	    clip_box.q.y = clip_box.p.y + int2fixed(iheight);

	    gx_path_init_local(&box_path, pgs->memory);

	    code = gx_path_add_rectangle(&box_path, clip_box.p.x, clip_box.p.y,

						    clip_box.q.x, clip_box.q.y);

	    if (code < 0)

		return code;

	    code = gx_cpath_clip(pgs, pgs->clip_path, &box_path, gx_rule_winding_number);

	    gx_path_free(&box_path, "set_cache_device");

	    pgs->in_cachedevice = CACHE_DEVICE_NONE_AND_CLIP;

	    return 0;		

	}

	/* The mins handle transposed coordinate systems.... */

	/* Truncate the offsets to avoid artifacts later. */

	cc->offset.x = fixed_ceiling(-cll.x);

	cc->offset.y = fixed_ceiling(-cll.y);

	if_debug4('k', "[k]width=%u, height=%u, offset=[%g %g]\n",

		  (uint) iwidth, (uint) iheight,

		  fixed2float(cc->offset.x),

		  fixed2float(cc->offset.y));

	pgs->in_cachedevice = CACHE_DEVICE_NONE; /* Provide correct grestore */

	if ((code = gs_gsave(pgs)) < 0) {

	    gx_free_cached_char(dir, cc);

	    return code;

	}

	/* Nothing can go wrong now.... */

	penum->cc = cc;

	cc->code = glyph;

	cc->wmode = gs_rootfont(pgs)->WMode;

	cc->wxy = penum->wxy;

	cc->subpix_origin = subpix_origin;

	if (penum->pair != 0)

	    cc_set_pair(cc, penum->pair);

	else

	    cc->pair = 0;

	/* Install the device */

	gx_set_device_only(pgs, (gx_device *) penum->dev_cache);

	pgs->ctm_default_set = false;

	/* Adjust the transformation in the graphics context */

	/* so that the character lines up with the cache. */

	gx_translate_to_fixed(pgs,

			      (cc->offset.x + subpix_origin.x) << log2_scale.x,

			      (cc->offset.y + subpix_origin.y) << log2_scale.y);

	if ((log2_scale.x | log2_scale.y) != 0)

	    gx_scale_char_matrix(pgs, 1 << log2_scale.x,

				 1 << log2_scale.y);

	/* Set the initial matrix for the cache device. */

	penum->dev_cache->initial_matrix = ctm_only(pgs);

	/* Set the oversampling factor. */

	penum->log2_scale.x = log2_scale.x;

	penum->log2_scale.y = log2_scale.y;

	/* Reset the clipping path to match the metrics. */

	clip_box.p.x = clip_box.p.y = 0;

	clip_box.q.x = int2fixed(iwidth);

	clip_box.q.y = int2fixed(iheight);

	if ((code = gx_clip_to_rectangle(pgs, &clip_box)) < 0)

	    return code;

	gx_set_device_color_1(pgs);	/* write 1's */

	pgs->in_cachedevice = CACHE_DEVICE_CACHING;

    }

    penum->width_status = sws_cache;

    return 1;

}

/* Return the cache device status. */

gs_in_cache_device_t

gs_incachedevice(const gs_state *pgs)

{

    return pgs->in_cachedevice;

}

/* ------ Enumerator ------ */

/*

 * Set the encode_char procedure in an enumerator.

 */

private void

show_set_encode_char(gs_show_enum * penum)

{

    penum->encode_char =

	(SHOW_IS(penum, TEXT_FROM_GLYPHS | TEXT_FROM_SINGLE_GLYPH) ?

	 gs_no_encode_char :

	 gs_show_current_font(penum)->procs.encode_char);

}

/*

 * Resync a text operation with a different set of parameters.

 * Currently this is implemented only for changing the data source.

 */

private int

gx_show_text_resync(gs_text_enum_t *pte, const gs_text_enum_t *pfrom)

{

    gs_show_enum *const penum = (gs_show_enum *)pte;

    int old_index = pte->index;

    if ((pte->text.operation ^ pfrom->text.operation) & ~TEXT_FROM_ANY)

	return_error(gs_error_rangecheck);

    pte->text = pfrom->text;

    if (pte->index == old_index) {

	show_set_encode_char(penum);

	return 0;

    } else

	return show_state_setup(penum);

}

/* Do the next step of a show (or stringwidth) operation */

private int

gx_show_text_process(gs_text_enum_t *pte)

{

    gs_show_enum *const penum = (gs_show_enum *)pte;

    return (*penum->continue_proc)(penum);

}

/* Continuation procedures */

private int show_update(gs_show_enum * penum);

private int show_move(gs_show_enum * penum);

private int show_proceed(gs_show_enum * penum);

private int show_finish(gs_show_enum * penum);

private int

continue_show_update(gs_show_enum * penum)

{

    int code = show_update(penum);

    if (code < 0)

	return code;

    code = show_move(penum);

    if (code != 0)

	return code;

    return show_proceed(penum);

}

private int

continue_show(gs_show_enum * penum)

{

    return show_proceed(penum);

}

/* For kshow, the CTM or font may have changed, so we have to reestablish */

/* the cached values in the enumerator. */

private int

continue_kshow(gs_show_enum * penum)

{   int code;

    gs_state *pgs = penum->pgs;

    if (pgs->font != penum->orig_font) 

	gs_setfont(pgs, penum->orig_font);

    code = show_state_setup(penum);

    if (code < 0)

	return code;

    return show_proceed(penum);

}

/* Update position */

private int

show_update(gs_show_enum * penum)

{

    gs_state *pgs = penum->pgs;

    cached_char *cc = penum->cc;

    int code;

    /* Update position for last character */

    switch (penum->width_status) {

	case sws_none:

        case sws_retry:	  

	    /* Adobe interpreters assume a character width of 0, */

	    /* even though the documentation says this is an error.... */

	    penum->wxy.x = penum->wxy.y = 0;

	    break;

	case sws_cache:

	    /* Finish installing the cache entry. */

	    /* If the BuildChar/BuildGlyph procedure did a save and a */

	    /* restore, it already undid the gsave in setcachedevice. */

	    /* We have to check for this by comparing levels. */

	    switch (pgs->level - penum->level) {

		default:

		    return_error(gs_error_invalidfont);		/* WRONG */

		case 2:

		    code = gs_grestore(pgs);

		    if (code < 0)

			return code;

		case 1:

		    ;

	    }

	    {   cached_fm_pair *pair;

		code = gx_lookup_fm_pair(pgs->font, &char_tm_only(pgs), 

			    &penum->log2_scale, penum->charpath_flag != cpm_show, &pair);

		if (code < 0)

		    return code;

		gx_add_cached_char(pgs->font->dir, penum->dev_cache,

			       cc, pair, &penum->log2_scale);

	    }

	    if (!SHOW_USES_OUTLINE(penum) ||

		penum->charpath_flag != cpm_show

		)

		break;

	    /* falls through */

	case sws_cache_width_only:

	    /* Copy the bits to the real output device. */

	    code = gs_grestore(pgs);

	    if (code < 0)

		return code;

	    code = gs_state_color_load(pgs);

	    if (code < 0)

		return code;

	    return gx_image_cached_char(penum, cc);

	case sws_no_cache:

	    ;

    }

    if (penum->charpath_flag != cpm_show) {

	/* Move back to the character origin, so that */

	/* show_move will get us to the right place. */

	code = gx_path_add_point(pgs->show_gstate->path,

				 penum->origin.x, penum->origin.y);

	if (code < 0)

	    return code;

    }

    return gs_grestore(pgs);

}

/* Move to next character */

private int

show_fast_move(gs_state * pgs, gs_fixed_point * pwxy)

{

    return gs_moveto_aux((gs_imager_state *)pgs, pgs->path,

			      pgs->current_point.x + fixed2float(pwxy->x), 

			      pgs->current_point.y + fixed2float(pwxy->y));

}

/* Get the current character code. */

int gx_current_char(const gs_text_enum_t * pte)

{

    const gs_show_enum *penum = (const gs_show_enum *)pte;

    gs_char chr = CURRENT_CHAR(penum) & 0xff;

    int fdepth = penum->fstack.depth;

    if (fdepth > 0) {

	/* Add in the shifted font number. */

	uint fidx = penum->fstack.items[fdepth].index;

	switch (((gs_font_type0 *) (penum->fstack.items[fdepth - 1].font))->data.FMapType) {

	case fmap_1_7:

	case fmap_9_7:

	    chr += fidx << 7;

	    break;

	case fmap_CMap:

	    chr = CURRENT_CHAR(penum);  /* the full character */

	    if (!penum->cmap_code)

		break;

	    /* falls through */

	default:

	    chr += fidx << 8;

	}

    }

    return chr;

}