/* Copyright (C) 2019-2025 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.

*/

/* Annotation handling for the PDF interpreter */

#include "pdf_int.h"

#include "pdf_stack.h"

#include "pdf_annot.h"

#include "pdf_file.h"

#include "pdf_dict.h"

#include "pdf_array.h"

#include "pdf_loop_detect.h"

#include "pdf_colour.h"

#include "pdf_trans.h"

#include "pdf_font_types.h"

#include "pdf_gstate.h"

#include "pdf_misc.h"

#include "pdf_optcontent.h"

#include "pdf_annot.h"

#include "pdf_colour.h"

#include "pdf_deref.h"

#include "pdf_image.h"

#include "pdf_mark.h"

#include "pdf_font.h"

#include "pdf_text.h"

#include "gspath2.h"

#include "gxfarith.h"

#include "gxdevsop.h"               /* For special ops */

#include "gsstrtok.h"               /* For gs_strtok */

#include "gscoord.h"        /* for gs_concat() and others */

#include "gsline.h"         /* For gs_setlinejoin() and friends */

#include "gsutil.h"        /* For gs_next_ids() */

#include "gspaint.h"        /* For gs_fill() and friends */

/* Detect if there is a BOM at beginning of string */

#define IS_UTF8(str) (!strcmp((char *)(str), "\xef\xbb\xbf"))

#define IS_UTF16(str) (!strcmp((char *)(str), "\xfe\xff"))

typedef int (*annot_func)(pdf_context *ctx, pdf_dict *annot, pdf_obj *NormAP, bool *render_done);

typedef struct {

    const char *subtype;

    annot_func func;

    bool simpleAP; /* Just Render AP if it exists? (false means more complicated) */

} annot_dispatch_t;

typedef int (*annot_LE_func)(pdf_context *ctx, pdf_dict *annot);

typedef struct {

    const char *name;

    annot_LE_func func;

} annot_LE_dispatch_t;

typedef int (*annot_preserve_func)(pdf_context *ctx, pdf_dict *annot, pdf_name *subtype);

typedef struct {

    const char *subtype;

    annot_preserve_func func;

} annot_preserve_dispatch_t;

static int pdfi_annot_start_transparency(pdf_context *ctx, pdf_dict *annot)

{

    int code;

    if (!ctx->page.has_transparency)

        return 0;

    /* TODO: ps code does something with /BM which is apparently the Blend Mode,

     * but I am not sure that the value is actually used properly.  Look into it.

     * (see pdf_draw.ps/startannottransparency)

     */

    code = gs_clippath(ctx->pgs);

    if (code < 0)

        return code;

    code = pdfi_trans_begin_simple_group(ctx, NULL, false, false, false);

    (void)gs_newpath(ctx->pgs);

    return code;

}

static int pdfi_annot_end_transparency(pdf_context *ctx, pdf_dict *annot)

{

    if (!ctx->page.has_transparency)

        return 0;

    return pdfi_trans_end_simple_group(ctx);

}

/* Get width from BS, if it exists

 * Default to 1.0 if not

 */

static int pdfi_annot_get_BS_width(pdf_context *ctx, pdf_dict *annot, double *width)

{

    int code;

    pdf_dict *BS = NULL;

    *width = 1.0;

    code = pdfi_dict_knownget_type(ctx, annot, "BS", PDF_DICT, (pdf_obj **)&BS);

    if (code <= 0)

        goto exit;

    code = pdfi_dict_knownget_number(ctx, BS, "W", width);

 exit:

    pdfi_countdown(BS);

    return code;

}

/* Set both stroke opacity and fill opacity to either CA or ca

 * For annotations, the one value seems to control both.

 */

static int pdfi_annot_opacity(pdf_context *ctx, pdf_dict *annot)

{

    int code = 0;

    double CA;

    /* CA -- opacity */

    code = pdfi_dict_knownget_number(ctx, annot, "CA", &CA);

    if (code > 0) {

        code = gs_setstrokeconstantalpha(ctx->pgs, CA);

        if (code < 0) goto exit;

        code = gs_setfillconstantalpha(ctx->pgs, CA);

        goto exit;

    }

    /* If CA not found, we also check for 'ca' even though it's not in the spec */

    code = pdfi_dict_knownget_number(ctx, annot, "ca", &CA);

    if (code > 0) {

        code = gs_setstrokeconstantalpha(ctx->pgs, CA);

        if (code < 0) goto exit;

        code = gs_setfillconstantalpha(ctx->pgs, CA);

    }

 exit:

    return code;

}

/* Apply RD to provided rect */

static int pdfi_annot_applyRD(pdf_context *ctx, pdf_dict *annot, gs_rect *rect)

{

    int code;

    pdf_array *RD = NULL;

    gs_rect rd;

    code = pdfi_dict_knownget_type(ctx, annot, "RD", PDF_ARRAY, (pdf_obj **)&RD);

    if (code <= 0) goto exit;

    code = pdfi_array_to_gs_rect(ctx, RD, &rd);

    if (code < 0) goto exit;

    rect->p.x += rd.p.x;

    rect->p.y += rd.p.y;

    rect->q.x -= rd.q.x;

    rect->q.y -= rd.q.y;

 exit:

    pdfi_countdown(RD);

    return code;

}

static int pdfi_annot_Rect(pdf_context *ctx, pdf_dict *annot, gs_rect *rect)

{

    int code;

    pdf_array *Rect = NULL;

    code = pdfi_dict_knownget_type(ctx, annot, "Rect", PDF_ARRAY, (pdf_obj **)&Rect);

    if (code < 0) goto exit;

    code = pdfi_array_to_gs_rect(ctx, Rect, rect);

    if (code < 0) goto exit;

    pdfi_normalize_rect(ctx, rect);

 exit:

    pdfi_countdown(Rect);

    return code;

}

static int pdfi_annot_position_AP(pdf_context *ctx, pdf_dict *annot, pdf_stream *AP)

{

    int code = 0;

    gs_rect rect;

    pdf_array *BBox = NULL;

    gs_rect bbox;

    pdf_array *Matrix = NULL;

    gs_matrix matrix;

    double xscale, yscale;

    pdf_dict *Annot_dict;

    code = pdfi_dict_from_obj(ctx, (pdf_obj *)AP, &Annot_dict);

    if (code < 0)

        return code;

    /* TODO: graphicsbeginpage, textbeginpage

     * These should match what was done at the beginning of the page,

     * but current implementation has things kind of mixed around.

     * Need to figure out exactly what to do.  I'd like it to be one

     * function in both places.

     * see pdfi_page_render()

     */

    /* graphicsbeginpage() */

    /* textbeginpage() */

    /* code = gs_initgraphics(ctx->pgs); */

    ctx->text.BlockDepth = 0;

    /* TODO: FIXME */

    code = pdfi_annot_Rect(ctx, annot, &rect);

    if (code < 0) goto exit;

    code = pdfi_dict_knownget_type(ctx, Annot_dict, "BBox", PDF_ARRAY, (pdf_obj **)&BBox);

    if (code < 0) goto exit;

    code = pdfi_array_to_gs_rect(ctx, BBox, &bbox);

    if (code < 0) goto exit;

    if (bbox.q.x - bbox.p.x == 0.0 || bbox.q.y - bbox.p.y == 0.0) {

        /* If the Bounding Box has 0 width or height, then the scaling calculation below will

         * end up with a division by zero, causing the CTM to go infinite.

         * We handle the broken BBox elsewhere, so for now just discard it, preventing

         * us breaking the CTM.

         */

        pdfi_countdown(BBox);

        BBox = NULL;

    }

    code = pdfi_dict_knownget_type(ctx, Annot_dict, "Matrix", PDF_ARRAY, (pdf_obj **)&Matrix);

    if (code < 0) goto exit;

    code = pdfi_array_to_gs_matrix(ctx, Matrix, &matrix);

    if (code < 0) goto exit;

    xscale = yscale = 1.0;

    code = gs_translate(ctx->pgs, rect.p.x, rect.p.y);

    if (code < 0) goto exit;

    if (BBox != NULL) {

        pdfi_bbox_transform(ctx, &bbox, &matrix);

        /* Calculate scale factor */

        xscale = (rect.q.x - rect.p.x) / (bbox.q.x - bbox.p.x);

        yscale = (rect.q.y - rect.p.y) / (bbox.q.y - bbox.p.y);

        if (xscale * yscale <= 0) {

            code = pdfi_set_warning_stop(ctx, gs_note_error(gs_error_rangecheck), NULL, W_PDF_ZEROSCALE_ANNOT, "pdfi_annot_position_AP", "ANNOT: Ignoring annotation with scale factor of 0\n");

            goto exit;

        }

        /* Scale it */

        code = gs_scale(ctx->pgs, xscale, yscale);

        if (code < 0) goto exit;

        /* Compensate for non-zero origin of BBox */

        code = gs_translate(ctx->pgs, -bbox.p.x, -bbox.p.y);

        if (code < 0) goto exit;

    }

 exit:

    pdfi_countdown(BBox);

    pdfi_countdown(Matrix);

    return code;

}

/* See pdf_draw.ps/drawwidget (draws the AP for any type of thingy) */

static int pdfi_annot_draw_AP(pdf_context *ctx, pdf_dict *annot, pdf_obj *NormAP)

{

    int code = 0;

    if (NormAP == NULL)

        return 0;

    if (pdfi_type_of(NormAP) == PDF_NULL)

        return 0;

    if (pdfi_type_of(NormAP) != PDF_STREAM)

        return pdfi_set_error_stop(ctx, gs_note_error(gs_error_typecheck), NULL, E_PDF_BAD_ANNOTATION, "pdfi_annot_draw_AP", "");

    code = pdfi_op_q(ctx);

    if (code < 0)

        return code;

    code = pdfi_annot_position_AP(ctx, annot, (pdf_stream *)NormAP);

    if (code < 0)

        goto exit;

    /* Render the annotation */

    code = pdfi_do_image_or_form(ctx, NULL, ctx->page.CurrentPageDict, NormAP);

exit:

    (void)pdfi_op_Q(ctx);

    return code;

}

static int pdfi_annot_setcolor_key(pdf_context *ctx, pdf_dict *annot, const char *key,

                                   bool usedefault, bool *drawit)

{

    int code = 0;

    pdf_array *C = NULL;

    *drawit = true;

    code = pdfi_dict_knownget_type(ctx, annot, key, PDF_ARRAY, (pdf_obj **)&C);

    if (code < 0) goto exit;

    if (code == 0) {

        if (usedefault)

            code = pdfi_gs_setgray(ctx, 0);

        else

            *drawit = false;

    } else {

        if (pdfi_array_size(C) == 0) {

            code = 0;

            *drawit = false;

        } else {

            code = pdfi_setcolor_from_array(ctx, C);

        }

    }

 exit:

    if (code < 0)

        *drawit = false;

    pdfi_countdown(C);

    return code;

}

static int pdfi_annot_setinteriorcolor(pdf_context *ctx, pdf_dict *annot, bool usedefault, bool *drawit)

{

    return pdfi_annot_setcolor_key(ctx, annot, "IC", usedefault, drawit);

}

static int pdfi_annot_setcolor(pdf_context *ctx, pdf_dict *annot, bool usedefault, bool *drawit)

{

    return pdfi_annot_setcolor_key(ctx, annot, "C", usedefault, drawit);

}

/* Stroke border using current path */

static int pdfi_annot_strokeborderpath(pdf_context *ctx, pdf_dict *annot, double width, pdf_array *dash)

{

    int code = 0;

    if (width <= 0)

        return 0;

    code = pdfi_setdash_impl(ctx, dash, 0);

    if (code < 0) goto exit;

    code = gs_setlinewidth(ctx->pgs, width);

    if (code < 0) goto exit;

    code = gs_stroke(ctx->pgs);

 exit:

    return code;

}

/* Fill border path */

static int pdfi_annot_fillborderpath(pdf_context *ctx, pdf_dict *annot)

{

    int code;

    bool drawit;

    code = pdfi_gsave(ctx);

    if (code < 0) return code;

    code = pdfi_annot_opacity(ctx, annot);

    if (code < 0) goto exit;

    code = pdfi_annot_setinteriorcolor(ctx, annot, false, &drawit);

    if (code < 0) goto exit;

    if (drawit)

        code = gs_fill(ctx->pgs);

 exit:

    (void)pdfi_grestore(ctx);

    return code;

}

/* Draw a path from a rectangle */

static int pdfi_annot_rect_path(pdf_context *ctx, gs_rect *rect)

{

    int code;

    code = gs_moveto(ctx->pgs, rect->p.x, rect->p.y);

    if (code < 0) goto exit;

    code = gs_lineto(ctx->pgs, rect->q.x, rect->p.y);

    if (code < 0) goto exit;

    code = gs_lineto(ctx->pgs, rect->q.x, rect->q.y);

    if (code < 0) goto exit;

    code = gs_lineto(ctx->pgs, rect->p.x, rect->q.y);

    if (code < 0) goto exit;

    code = gs_closepath(ctx->pgs);

 exit:

    return code;

}

/* Make a rectangle path from Rect (see /re, /normal_re in pdf_ops.ps)

 * See also /Square

 * Not sure if I have to worry about the /inside_text_re here

 */

static int pdfi_annot_RectRD_path(pdf_context *ctx, pdf_dict *annot)

{

    gs_rect rect;

    int code;

    code = pdfi_annot_Rect(ctx, annot, &rect);

    if (code < 0) goto exit;

    code = pdfi_annot_applyRD(ctx, annot, &rect);

    if (code < 0) goto exit;

    code = pdfi_annot_rect_path(ctx, &rect);

 exit:

    return code;

}

/* Adjust rectangle by specified width */

static void pdfi_annot_rect_adjust(pdf_context *ctx, gs_rect *rect, double width)

{

    rect->p.x += width;

    rect->p.y += width;

    rect->q.x -= width;

    rect->q.y -= width;

}

/* Fill Rect with current color */

static int pdfi_annot_fillRect(pdf_context *ctx, pdf_dict *annot)

{

    int code;

    gs_rect rect;

    code = pdfi_gsave(ctx);

    if (code < 0) return code;

    code = pdfi_annot_Rect(ctx, annot, &rect);

    if (code < 0) goto exit;

    code = gs_rectclip(ctx->pgs, &rect, 1);

    if (code < 0) goto exit;

    code = pdfi_annot_applyRD(ctx, annot, &rect);

    if (code < 0) goto exit;

    code = gs_rectfill(ctx->pgs, &rect, 1);

    if (code < 0) goto exit;

 exit:

    (void)pdfi_grestore(ctx);

    return code;

}

/* Stroke border, drawing path from rect */

static int pdfi_annot_strokeborder(pdf_context *ctx, pdf_dict *annot, double width, pdf_array *dash)

{

    int code = 0;

    gs_rect rect;

    if (width <= 0)

        return 0;

    code = pdfi_gsave(ctx);

    code = pdfi_setdash_impl(ctx, dash, 0);

    if (code < 0) goto exit;

    code = gs_setlinewidth(ctx->pgs, width);

    if (code < 0) goto exit;

    code = pdfi_annot_Rect(ctx, annot, &rect);

    if (code < 0) goto exit;

    code = pdfi_annot_applyRD(ctx, annot, &rect);

    if (code < 0) goto exit;

    /* Stroke the rectangle */

    /* Adjust rectangle by the width */

    pdfi_annot_rect_adjust(ctx, &rect, width/2);

    code = gs_rectstroke(ctx->pgs, &rect, 1, NULL);

 exit:

    (void)pdfi_grestore(ctx);

    return code;

}

/* Draw border from a Border array

 * Note: Border can be null

 */

static int pdfi_annot_draw_Border(pdf_context *ctx, pdf_dict *annot, pdf_array *Border, bool usepath)

{

    pdf_array *dash = NULL;

    int code = 0;

    uint64_t size = 0;

    double width = 0;

    if (Border)

        size = pdfi_array_size(Border);

    if (Border &&  size < 3) {

        code = pdfi_set_warning_stop(ctx, gs_note_error(gs_error_rangecheck), NULL, W_PDF_ANNOT_ERROR, "pdfi_annot_draw_Border", "WARNING: Annotation Border array invalid");

        goto exit;

    }

    if (!Border) {

        code = pdfi_array_alloc(ctx, 0, &dash);

        if (code < 0) goto exit;

        pdfi_countup(dash);

        width = 1;

    } else {

        if (size > 3) {

            code = pdfi_array_get_type(ctx, Border, 3, PDF_ARRAY, (pdf_obj **)&dash);

            if (code < 0) {

                if ((code = pdfi_set_warning_stop(ctx, code, NULL, W_PDF_ANNOT_ERROR,

                                 "pdfi_annot_draw_Border", "WARNING: Annotation Border Dash array invalid")) < 0) {

                    goto exit;

                }

                code = pdfi_array_alloc(ctx, 0, &dash);

                if (code < 0) goto exit;

                pdfi_countup(dash);

            }

        } else {

            code = pdfi_array_alloc(ctx, 0, &dash);

            if (code < 0) goto exit;

            pdfi_countup(dash);

        }

        code = pdfi_array_get_number(ctx, Border, 2, &width);

        if (code < 0) goto exit;

    }

    /* At this point we have a dash array (which could be length 0) and a width */

    if (usepath)

        code = pdfi_annot_strokeborderpath(ctx, annot, width, dash);

    else

        code = pdfi_annot_strokeborder(ctx, annot, width, dash);

 exit:

    pdfi_countdown(dash);

    return code;

}

/* Draw border from a BS dict */

static int pdfi_annot_draw_BS(pdf_context *ctx, pdf_dict *annot, pdf_dict *BS, bool usepath)

{

    double W;

    int code = 0;

    pdf_name *S = NULL;

    pdf_array *dash = NULL;

    /* Get the width */

    code = pdfi_dict_knownget_number(ctx, BS, "W", &W);

    if (code < 0) goto exit;

    if (code == 0)

        W = 1; /* Default */

    /* TODO: Some junk about scaling to UserUnit */

    /* ... */

    /* Lookup border style */

    code = pdfi_dict_knownget_type(ctx, BS, "S", PDF_NAME, (pdf_obj **)&S);

    if (code < 0) goto exit;

    if (code > 0 && pdfi_name_is(S, "D")) {

        /* Handle Dash array */

        code = pdfi_dict_knownget_type(ctx, BS, "D", PDF_ARRAY, (pdf_obj **)&dash);

        if (code < 0) goto exit;

        /* If there is no Dash array, then create one containing a 3 (the default) */

        if (code == 0) {

            code = pdfi_array_alloc(ctx, 1, &dash);

            if (code < 0) goto exit;

            pdfi_countup(dash);

            code = pdfi_array_put_int(ctx, dash, 0, 3);

            if (code < 0) goto exit;

        }

    } else {

        /* Empty array */

        code = pdfi_array_alloc(ctx, 0, &dash);

        if (code < 0) goto exit;

        pdfi_countup(dash);

    }

    /* At this point we have a dash array (which could be length 0) and a width */

    if (usepath)

        code = pdfi_annot_strokeborderpath(ctx, annot, W, dash);

    else

        code = pdfi_annot_strokeborder(ctx, annot, W, dash);

 exit:

    pdfi_countdown(S);

    pdfi_countdown(dash);

    return code;

}

/* Draw the border

 * This spec seems to be scattered around.  There might be:

 *  /Border -- an array of 3-4 elements, where the optional 4th element is a "dash array"

 *   (default value: [0 0 1])

 *  /BS -- a Border Style dictionary

 *  Spec says /Border would be ignored in favor of /BS

 *

 * usepath -- indicates whether to stroke existing path, or use Rect to draw a path first

 */

static int pdfi_annot_draw_border(pdf_context *ctx, pdf_dict *annot, bool usepath)

{

    int code, code1;

    pdf_dict *BS = NULL;

    pdf_array *Border = NULL;

    code = pdfi_dict_knownget_type(ctx, annot, "BS", PDF_DICT, (pdf_obj **)&BS);

    if (code < 0) goto exit;

    code = pdfi_dict_knownget_type(ctx, annot, "Border", PDF_ARRAY, (pdf_obj **)&Border);

    if (code < 0) goto exit;

    code = pdfi_gsave(ctx);

    if (code < 0) goto exit;

    if (BS) {

        code = pdfi_annot_draw_BS(ctx, annot, BS, usepath);

    } else {

        /* Note: Border can be null */

        code = pdfi_annot_draw_Border(ctx, annot, Border, usepath);

    }

    code1 = pdfi_grestore(ctx);

    if (code == 0) code = code1;

 exit:

    pdfi_countdown(BS);

    pdfi_countdown(Border);

    return code;

}

/*********** BEGIN Font/Text ***************/

/* Set font */

static int

pdfi_annot_set_font(pdf_context *ctx, const char *font, double size)

{

    int code = 0;

    if (font != NULL) {

        code = pdfi_font_set_internal_string(ctx, font, size);

        if (code < 0) goto exit;

    }

 exit:

    return code;

}

/* Get value from a field, or its Parents (recursive)

 * If no Parent, will also check ctx->AcroForm

 * Returns <0 on error, 0 if not found, >0 if found

 */

static int pdfi_form_get_inheritable(pdf_context *ctx, pdf_dict *field, const char *Key,

                                     pdf_obj_type type, pdf_obj **o)

{

    int code = 0;

    pdf_dict *Parent = NULL;

    bool known = false;

    /* Check this field */

    code = pdfi_dict_knownget_type(ctx, field, Key, type, o);

    if (code != 0) goto exit1;

    code = pdfi_loop_detector_mark(ctx);

    if (code < 0)

        goto exit;

    /* Check for Parent. Do not store the dereferenced Parent back to the dictionary

     * as this can cause circular references.

     */

    code = pdfi_dict_known(ctx, field, "Parent", &known);

    if (code >= 0 && known == true)

    {

        code = pdfi_dict_get_no_store_R(ctx, field, "Parent", (pdf_obj **)&Parent);

        if (code < 0)

            goto exit;

        if (pdfi_type_of(Parent) != PDF_DICT) {

            if (pdfi_type_of(Parent) == PDF_INDIRECT) {

                pdf_indirect_ref *o = (pdf_indirect_ref *)Parent;

                code = pdfi_dereference(ctx, o->ref_object_num, o->ref_generation_num, (pdf_obj **)&Parent);

                pdfi_countdown(o);

                goto exit;

            } else {

                code = gs_note_error(gs_error_typecheck);

                goto exit;

            }

        }

        code = pdfi_form_get_inheritable(ctx, Parent, Key, type, o);

        if (code <= 0) {

            if (ctx->AcroForm)

                code = pdfi_dict_knownget_type(ctx, ctx->AcroForm, Key, type, o);

        }

    } else {

        /* No Parent, so check AcroForm, if any */

        if (ctx->AcroForm)

            code = pdfi_dict_knownget_type(ctx, ctx->AcroForm, Key, type, o);

    }

exit:

    (void)pdfi_loop_detector_cleartomark(ctx);

exit1:

    pdfi_countdown(Parent);

    return code;

}

/* Get int value from a field, or its Parents (recursive)

 * Returns <0 on error, 0 if not found, >0 if found

 */

static int pdfi_form_get_inheritable_int(pdf_context *ctx, pdf_dict *field, const char *Key,

                                         int64_t *val)

{

    int code = 0;

    pdf_num *num = NULL;

    *val = 0;

    code = pdfi_form_get_inheritable(ctx, field, Key, PDF_INT, (pdf_obj **)&num);

    if (code < 0) goto exit;

    if (code > 0)

        *val = num->value.i;

 exit:

    pdfi_countdown(num);

    return code;

}

/* Scan DA to see if font size is 0, if so make a new DA with font size scaled by gs_rect */

static int pdfi_form_modDA(pdf_context *ctx, pdf_string *DA, pdf_string **mod_DA, gs_rect *rect)

{

    char *token, *prev_token;

    char *parse_str = NULL;

    bool did_mod = false;

    int code = 0;

    double size;

    char size_str[20];

    char *last;

    pdf_string *newDA = NULL;

    /* Make a copy of the string because we are going to destructively parse it */

    parse_str = (char *)gs_alloc_bytes(ctx->memory, DA->length+1, "pdfi_annot_display_text(strbuf)");

    if (parse_str == NULL) {

        code = gs_note_error(gs_error_VMerror);

        goto exit;

    }

    memcpy(parse_str, DA->data, DA->length);

    parse_str[DA->length] = 0; /* Null terminate */

    /* find the 'Tf' token, if any */

    token = gs_strtok(parse_str, " ", &last);

    prev_token = NULL;

    while (token != NULL) {

        if (!strcmp(token, "Tf"))

            break;

        prev_token = token;

        token = gs_strtok(NULL, " ", &last);

    }

    /* See if we found it */

    if (!token)

        goto exit;

    /* See if there was a prev_token and it was "0" */

    if (!(prev_token && !strcmp(prev_token, "0")))

        goto exit;

    /* Case with '<font> 0 Tf', need to calculate correct size */

    size = (rect->q.y - rect->p.y) * .75; /* empirical from gs code make_tx_da */

    snprintf(size_str, sizeof(size_str), "%g ", size);

    /* Create a new DA and reassemble the old DA into it */

    code = pdfi_object_alloc(ctx, PDF_STRING, DA->length+strlen(size_str)+1, (pdf_obj **)&newDA);

    if (code < 0)

        goto exit;

    pdfi_countup(newDA);

    strncpy((char *)newDA->data, (char *)DA->data, prev_token-parse_str);

    strncpy((char *)newDA->data + (prev_token-parse_str), size_str, strlen(size_str)+1);

    strncpy((char *)newDA->data + strlen((char *)newDA->data), (char *)DA->data + (token - parse_str),

            DA->length-(token-parse_str));

    newDA->length = strlen((char *)newDA->data);

    did_mod = true;

 exit:

    /* If didn't need to mod it, just copy the original and get a ref */

    if (did_mod) {

        *mod_DA = newDA;

    } else {

        *mod_DA = DA;

        pdfi_countup(DA);

    }

    if (parse_str)

        gs_free_object(ctx->memory, parse_str, "pdfi_form_modDA(parse_str)");

    return code;

}

/* Process the /DA string by either running it through the interpreter

 *  or providing a bunch of defaults

 *

 * According to the spec, if there is a "<fontname> <size> Tf" in the /DA,

 * and the <size> = 0, we autosize it using the annotation's rect.  (see PDF1.7, pages 678-679)

 *

 * rect -- the annotation's rect, for auto-sizing the font

 * is_form -- is this a form, so check inheritable?

 */

static int pdfi_annot_process_DA(pdf_context *ctx, pdf_dict *page_dict, pdf_dict *annot, gs_rect *rect,

                                 bool is_form)

{

    int code = 0;

    pdf_string *DA = NULL;

    pdf_string *mod_DA = NULL;

    pdf_dict *resource_dict = annot;  /* dict to use for resources, alias no need to refcnt */

    pdf_dict *DR = NULL;

    bool known;

    /* TODO -- see gs code make_tx_da, need to handle case where we need to set a UTF-16 font */

    if (!page_dict)

        page_dict = ctx->page.CurrentPageDict;

    if (is_form) {

        code = pdfi_dict_known(ctx, annot, "DR", &known);

        if (code < 0) goto exit;

        /* If there is no "DR" and no Parent in the annotation, have it use the AcroForm instead

         * This is a hack.  May need to use fancier inheritance approach.

         */

        if (!known) {

            code = pdfi_dict_known(ctx, annot, "Parent", &known);

            if (code < 0) goto exit;

            if (!known && ctx->AcroForm != NULL)

                resource_dict = ctx->AcroForm;

        }

        code = pdfi_form_get_inheritable(ctx, annot, "DA", PDF_STRING, (pdf_obj **)&DA);

    } else {

        code = pdfi_dict_knownget_type(ctx, annot, "DA", PDF_STRING, (pdf_obj **)&DA);

    }

    if (code < 0) goto exit;

    if (code > 0) {

        if (is_form) {

            code = pdfi_form_modDA(ctx, DA, &mod_DA, rect);

            if (code < 0) goto exit;

        } else {

            mod_DA = DA;

            pdfi_countup(mod_DA);

        }

        code = pdfi_interpret_inner_content_string(ctx, mod_DA, resource_dict,

                                                   page_dict, false, "DA");

        if (code < 0) goto exit;

        /* If no font got set, set one */

        if (pdfi_get_current_pdf_font(ctx) == NULL) {

            code = pdfi_annot_set_font(ctx, "Helvetica", 12.0);

            if (code < 0) goto exit;

        }

    } else {

        code = pdfi_gs_setgray(ctx, 0);

        if (code < 0) goto exit;

        code = pdfi_annot_set_font(ctx, "Helvetica", 12.0);

        if (code < 0) goto exit;

    }

 exit:

    pdfi_countdown(DR);

    pdfi_countdown(DA);

    pdfi_countdown(mod_DA);

    return code;

}

/* Put a string into buffer as a hexstring and return ptr to end of it

 * Skip over any BOM that is present.

 */

static char *pdfi_get_hexstring(pdf_context *ctx, char *outbuf, byte *inbuf, int len)

{

    int i;

    char *ptr;

    i = 0;

    /* skip over BOM if it's there */

    if (IS_UTF16(inbuf)) {

        i += 2; /* UTF-16 */

    } else if (IS_UTF16(inbuf)) {

        i += 3; /* UTF-8 */

    }

    ptr = outbuf;

    *ptr++ = '<';

    for ( ; i<len; i++) {

        snprintf(ptr, 3, "%02X", *(inbuf+i));

        ptr += 2;

    }

    *ptr++ = '>';

    *ptr = 0;

    return ptr;

}

/* Display text at current position (inside BT/ET) */

static int

pdfi_annot_display_nexttext(pdf_context *ctx, pdf_dict *annot, pdf_string *text)

{

    char *strbuf = NULL;

    size_t buflen = 50 + text->length*2; /* 50 to account for formatting, plus the text itself */

    int code = 0;

    char *ptr;

    strbuf = (char *)gs_alloc_bytes(ctx->memory, buflen, "pdfi_annot_display_text(strbuf)");

    if (strbuf == NULL)

        return_error(gs_error_VMerror);

    ptr = pdfi_get_hexstring(ctx, strbuf, text->data, text->length);

    strncpy(ptr, " Tj", buflen-strlen(strbuf));

    code = pdfi_interpret_inner_content_c_string(ctx, strbuf, annot,

                                               ctx->page.CurrentPageDict, false, "Annot text Tj");

    if (code < 0) goto exit;

 exit:

    if (strbuf)

        gs_free_object(ctx->memory, strbuf, "pdfi_annot_display_text(strbuf)");

    return code;

}

/* Display text with positioning (inside BT/ET) */

static int

pdfi_annot_display_text(pdf_context *ctx, pdf_dict *annot, double x, double y, pdf_string *text)

{

    char *strbuf = NULL;

    size_t buflen = 50 + text->length*2; /* 50 to account for formatting, plus the text itself */

    int code = 0;

    char *ptr;

    strbuf = (char *)gs_alloc_bytes(ctx->memory, buflen, "pdfi_annot_display_text(strbuf)");

    if (strbuf == NULL)

        return_error(gs_error_VMerror);

    snprintf(strbuf, buflen, "%g %g Td ", x, y);

    ptr = strbuf + strlen(strbuf);

    ptr = pdfi_get_hexstring(ctx, ptr, text->data, text->length);

    strncpy(ptr, " Tj", buflen-strlen(strbuf));

    code = pdfi_interpret_inner_content_c_string(ctx, strbuf, annot,

                                               ctx->page.CurrentPageDict, false, "Annot text Tj");

    if (code < 0) goto exit;

 exit:

    if (strbuf)

        gs_free_object(ctx->memory, strbuf, "pdfi_annot_display_text(strbuf)");

    return code;

}

/* Get Text height for current font (assumes font is already set, inside BT/ET)

 * TODO: See /Tform implementation that uses FontBBox and ScaleMatrix instead

 * Maybe use this technique as a backup if those entries aren't available?

 */

static int

pdfi_annot_get_text_height(pdf_context *ctx, double *height)

{

    int code;

    pdf_string *temp_string = NULL;

    gs_rect bbox;

    gs_point awidth;

    if (ctx->pgs->PDFfontsize == 0) {

        *height = 0;

        return 0;

    }

    code = pdfi_obj_charstr_to_string(ctx, "Hy", &temp_string);

    if (code < 0)

        goto exit;

    /* Find the bbox of the string "Hy" */

    code = pdfi_string_bbox(ctx, temp_string, &bbox, &awidth, false);

    if (code < 0)

        goto exit;

    *height = bbox.q.y - bbox.p.y;

 exit:

    pdfi_countdown(temp_string);

    return code;

}

/* Display a simple text string (outside BT/ET) */

static int

pdfi_annot_display_simple_text(pdf_context *ctx, pdf_dict *annot, double x, double y, pdf_string *text)

{

    int code = 0;

    int code1 = 0;

    code = pdfi_BT(ctx);

    if (code < 0)

        return code;

    code = pdfi_annot_display_text(ctx, annot, x, y, text);

    code1 = pdfi_ET(ctx);

    if (code == 0) code = code1;

    return code;

}

/* Display a centered text string (outside BT/ET) */

static int

pdfi_annot_display_centered_text(pdf_context *ctx, pdf_dict *annot, gs_rect *rect, pdf_string *text)

{

    int code = 0;

    int code1 = 0;

    gs_rect bbox;

    gs_point awidth;

    double x, y;

    code = pdfi_BT(ctx);

    if (code < 0)

        return code;

    /* Get width of the string */

    code = pdfi_string_bbox(ctx, text, &bbox, &awidth, false);

    if (code < 0) goto exit;