/* Copyright (C) 2001-2023 Artifex Software, Inc.

   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.

   Refer to licensing information at http://www.artifex.com or contact

   Artifex Software, Inc.,  39 Mesa Street, Suite 108A, San Francisco,

   CA 94129, USA, for further information.

*/

/* Type 42 character display operator */

#include "ghost.h"

#include "oper.h"

#include "gsmatrix.h"

#include "gspaint.h"    /* for gs_fill, gs_stroke */

#include "gspath.h"

#include "gxfixed.h"

#include "gxfont.h"

#include "gxfont42.h"

#include "gxgstate.h"

#include "gxpath.h"

#include "gxtext.h"

#include "gzstate.h"    /* only for ->path */

#include "dstack.h"   /* only for systemdict */

#include "estack.h"

#include "ichar.h"

#include "icharout.h"

#include "ifont.h"    /* for font_param */

#include "igstate.h"

#include "iname.h"

#include "store.h"

#include "string_.h"

#include "zchar42.h"

#include "idict.h"

/* Get a Type 42 character metrics and set the cache device. */

int

zchar42_set_cache(i_ctx_t *i_ctx_p, gs_font_base *pbfont, ref *cnref,

            uint glyph_index, op_proc_t cont, op_proc_t *exec_cont)

{   double sbw[4];

    double w[2];

    int present;

    gs_font_type42 *pfont42 = (gs_font_type42 *)pbfont;

    int code = zchar_get_metrics(pbfont, cnref, sbw);

    gs_rect bbox;

    int vertical = gs_rootfont(igs)->WMode;

    float sbw_bbox[8];

    float sbw_bbox_h[8];

    ref *fdict = (ref *)pbfont->client_data;

    ref *rpath = NULL;

    bool embedded = true;

    if (code < 0)

        return code;

    present = code;

    if (dict_find_string(fdict, "Path", &rpath) > 0) {

        embedded = false;

    }

    if (vertical) { /* for vertically-oriented metrics */

        /* Always call get_metrics because we'll need glyph bbox below in any case

           as a workaround for Dynalab fonts. We can't recognize Dynalab here. */

        code = pfont42->data.get_metrics(pfont42, glyph_index,

                    gs_type42_metrics_options_WMODE0_AND_BBOX, sbw_bbox_h);

        if (code < 0)

            return code;

        code = pfont42->data.get_metrics(pfont42, glyph_index,

                gs_type42_metrics_options_WMODE1_AND_BBOX, sbw_bbox);

        /* Here code=0 means success, code<0 means no vertical metrics. */

        /* We only want to create fake vertical metrics for TTF fonts

           being used to emulate a vertical writing CIDFont. If we have

           a CIDType 2 font, without vertical metrics, we're supposed to

           treat it as a horizontal writing font, regardless of the wmode

           setting

         */

        if (code < 0 && !embedded) {

            /* No vertical metrics in the font,

               hewristically compose vertical metrics from bounding boxes. */

            sbw_bbox[0] = 0;

            sbw_bbox[1] = pbfont->FontBBox.q.y - 1;

            sbw_bbox[2] = 0;

            sbw_bbox[3] = -1;

        }

        else {

            vertical = false;

        }

    }

    if (vertical) {

        if (present != metricsSideBearingAndWidth) {

            /* metricsNone or metricsWidthOnly. */

            /* No top side bearing (in Metrics2) in Postscript font. */

            /* Note that Postscript wants the 'V' vector in sbw[0:1],

               and True Type supplies Top Side Bearing in sbw_bbox[0:1],

               and Left Side Bearing in sbw_bbox_h[0:1].

               So we need to compute V from FontBBox as we do for FontType 9

               (see FontBBox_as_Metrics2) and add TSB to it. */

#     if 0 /* old code taken from empirics, keepping it for a while to compare results. */

            sbw[0] = (sbw_bbox[6] + sbw_bbox[4]) / 2;

            sbw[1] = (pbfont->FontBBox.q.y + pbfont->FontBBox.p.y - sbw_bbox[3]) / 2;

#     else

            sbw[0] = sbw_bbox_h[2] / 2;

            sbw[1] = sbw_bbox[1] - sbw_bbox[3];

#     endif

        }

        if (present == metricsNone) {

            /* No adwance width (in Metrcis2) in Postscript font. */

            sbw[2] = 0;

            sbw[3] = sbw_bbox[3];

        }

    } else {

        /* Always call get_metrics because we'll need glyph bbox below in any case

           as a workaround for Dynalab fonts. We can't recognize Dynalab here. */

        code = pfont42->data.get_metrics(pfont42, glyph_index,

                    gs_type42_metrics_options_WMODE0_AND_BBOX, sbw_bbox);

        if (code < 0)

            return code;

        if (present != metricsSideBearingAndWidth) {

            /* metricsNone or metricsWidthOnly. */

            /* No left side bearing (in Metrics) in Postscript font. */

            sbw[0] = sbw_bbox[0];

            sbw[1] = sbw_bbox[1];

        }

        if (present == metricsNone) {

            /* No advance width (in Metrics) in Postscript font. */

            sbw[2] = sbw_bbox[2];

            sbw[3] = sbw_bbox[3];

        }

    }

    w[0] = sbw[2];

    w[1] = sbw[3];

    if (!vertical) {

        sbw_bbox[6] = (sbw_bbox[6] - sbw_bbox[4]) + sbw_bbox[0];

        sbw_bbox[4] = sbw_bbox[0];

    }

    /* Note: The glyph bbox usn't useful for Dynalab fonts,

       which stretch subglyphs. Uniting with FontBBox helps.

       In same time, FontBBox with no glyph bbox

       doesn't work for 34_all.PS page 4. */

    /* Previously we used to expand the bbox to the maximum/minimum

     * of the glyph and font bounding boxes combined, as noted above.

     * However this causes incorrect output (bug #703697) for vertical

     * writing fonts with pdfwrite. Since we no longer use this code

     * for rendering, and pdfwrite doesn't use the metrics for clipping,

     * but does for positioning, we've removed this code.

     */

    bbox.p.x = sbw_bbox[4];

    bbox.p.y = sbw_bbox[5];

    bbox.q.x = sbw_bbox[6];

    bbox.q.y = sbw_bbox[7];

    return zchar_set_cache(i_ctx_p, pbfont, cnref,

                           NULL,

                           w, &bbox,

                           cont, exec_cont,

                           vertical ? sbw : NULL);

}

/* <font> <code|name> <name> <glyph_index> .type42execchar - */

static int type42_fill(i_ctx_t *);

static int type42_stroke(i_ctx_t *);

static int

ztype42execchar(i_ctx_t *i_ctx_p)

{

    os_ptr op = osp;

    gs_font *pfont;

    int code;

    gs_font_base *pbfont;

    gs_font_type42 *pfont42;

    gs_text_enum_t *penum = op_show_find(i_ctx_p);

    op_proc_t cont, exec_cont = 0;

    ref *cnref;

    uint glyph_index;

    check_op(4);

    check_type(*(op - 1), t_name);

    if (!r_has_type((op - 2), t_name)) {

        check_type(*(op - 2), t_integer);

    }

    code = font_param(op - 3, &pfont);

    if (code < 0)

        return code;

    pbfont = (gs_font_base *) pfont;

    cont = (pbfont->PaintType == 0 ? type42_fill : type42_stroke);

    pfont42 = (gs_font_type42 *) pfont;

    if (penum == 0 ||

        (pfont->FontType != ft_TrueType &&

         pfont->FontType != ft_CID_TrueType)

        )

        return_error(gs_error_undefined);

    /*

     * Any reasonable implementation would execute something like

     *  1 setmiterlimit 0 setlinejoin 0 setlinecap

     * here, but apparently the Adobe implementations aren't reasonable.

     *

     * If this is a stroked font, set the stroke width.

     */

    if (pfont->PaintType)

        gs_setlinewidth(igs, pfont->StrokeWidth);

    check_estack(3);   /* for continuations */

    /*

     * Execute the definition of the character.

     */

    if (r_is_proc(op))

        return zchar_exec_char_proc(i_ctx_p);

    /*

     * The definition must be a Type 42 glyph index.

     * Note that we do not require read access: this is deliberate.

     */

    check_type(*op, t_integer);

    check_ostack(3);   /* for lsb values */

    /* Establish a current point. */

    code = gs_moveto(igs, 0.0, 0.0);

    if (code < 0)

        return code;

    cnref = op - 1;

    glyph_index = (uint)op->value.intval;

    if (pfont42->data.gsub_size) {

        glyph_index = pfont42->data.substitute_glyph_index_vertical(pfont42, glyph_index,

                gs_rootfont(igs)->WMode, penum->returned.current_glyph);

        make_int(op, glyph_index);

    }

    code = zchar42_set_cache(i_ctx_p, pbfont, cnref, glyph_index, cont, &exec_cont);

    if (code >= 0 && exec_cont != 0)

        code = (*exec_cont)(i_ctx_p);

    return code;

}

/* Continue after a CDevProc callout. */

static int type42_finish(i_ctx_t *i_ctx_p,

                          int (*cont)(gs_gstate *));

static int

type42_fill(i_ctx_t *i_ctx_p)

{

    int code;

    gs_fixed_point fa = i_ctx_p->pgs->fill_adjust;

    i_ctx_p->pgs->fill_adjust.x = i_ctx_p->pgs->fill_adjust.y = -1;

    code = type42_finish(i_ctx_p, gs_fill);

    i_ctx_p->pgs->fill_adjust = fa; /* Not sure whether we need to restore it,

                                       but this isn't harmful. */

    return code;

}

static int

type42_stroke(i_ctx_t *i_ctx_p)

{

    return type42_finish(i_ctx_p, gs_stroke);

}

/* <font> <code|name> <name> <glyph_index> %type42_{fill|stroke} - */

static int

type42_finish(i_ctx_t *i_ctx_p, int (*cont) (gs_gstate *))

{

    os_ptr op = osp;

    gs_font *pfont;

    gs_font_type42 *pfont42;

    int code;

    gs_text_enum_t *penum = op_show_find(i_ctx_p);

    os_ptr opc = op;

    uint glyph_index;

    check_type(*opc, t_integer);

    code = font_param(opc - 3, &pfont);

    if (code < 0)

        return code;

    if (penum == 0 || (pfont->FontType != ft_TrueType &&

                       pfont->FontType != ft_CID_TrueType)

        )

        return_error(gs_error_undefined);

    pfont42 = (gs_font_type42 *)pfont;

    if (!i_ctx_p->RenderTTNotdef) {

        if (r_has_type(opc - 1, t_name)) {

            ref gref;

            name_string_ref(imemory, opc - 1, &gref);

            if ((gref.tas.rsize == 7 && strncmp((const char *)gref.value.const_bytes, ".notdef", 7) == 0) ||

                (gref.tas.rsize > 9 && strncmp((const char *)gref.value.const_bytes, ".notdef~GS", 10) == 0)) {

                pop(4);

                return (*cont)(igs);

            }

        }

    }

    glyph_index = (uint)opc->value.intval;

    if (pfont42->data.gsub_size)

        glyph_index = pfont42->data.substitute_glyph_index_vertical(pfont42, glyph_index,

                    gs_rootfont(igs)->WMode, penum->returned.current_glyph);

    /*

     * We have to disregard penum->pis and penum->path, and render to

     * the current gstate and path.  This is a design bug that we will

     * have to address someday!

     */

    code = gs_type42_append(glyph_index, igs,

                            igs->path, penum, pfont,

                            (penum->text.operation & TEXT_DO_ANY_CHARPATH) != 0);

    if (code < 0)

        return code;

    pop(4);

    return (*cont)(igs);

}

/* ------ Initialization procedure ------ */

const op_def zchar42_op_defs[] =

{

    {"4.type42execchar", ztype42execchar},

    op_def_end(0)

};