// Copyright (C) 2004-2025 Artifex Software, Inc.

//

// This file is part of MuPDF.

//

// MuPDF is free software: you can redistribute it and/or modify it under the

// terms of the GNU Affero General Public License as published by the Free

// Software Foundation, either version 3 of the License, or (at your option)

// any later version.

//

// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY

// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more

// details.

//

// You should have received a copy of the GNU Affero General Public License

// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>

//

// Alternative licensing terms are available from the licensor.

// For commercial licensing, see <https://www.artifex.com/> or contact

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

// CA 94129, USA, for further information.

#include "mupdf/fitz.h"

#include "pdf-annot-imp.h"

#include <string.h>

#include <float.h>

pdf_annot *

pdf_keep_annot(fz_context *ctx, pdf_annot *annot)

{

  return fz_keep_imp(ctx, annot, &annot->refs);

}

void

pdf_drop_annot(fz_context *ctx, pdf_annot *annot)

{

  if (fz_drop_imp(ctx, annot, &annot->refs))

  {

    pdf_drop_obj(ctx, annot->obj);

    fz_free(ctx, annot);

  }

}

void

pdf_drop_annots(fz_context *ctx, pdf_annot *annot)

{

  while (annot)

  {

    pdf_annot *next = annot->next;

    pdf_drop_annot(ctx, annot);

    annot = next;

  }

}

pdf_obj *

pdf_annot_ap(fz_context *ctx, pdf_annot *annot)

{

  int flags = pdf_annot_flags(ctx, annot);

  int readonly = flags & PDF_ANNOT_IS_READ_ONLY;

  pdf_obj *ap = pdf_dict_get(ctx, annot->obj, PDF_NAME(AP));

  pdf_obj *ap_n = pdf_dict_get(ctx, ap, PDF_NAME(N));

  pdf_obj *ap_r = pdf_dict_get(ctx, ap, PDF_NAME(R));

  pdf_obj *ap_d = pdf_dict_get(ctx, ap, PDF_NAME(D));

  if (!readonly && annot->is_hot && annot->is_active && ap_d)

    ap = ap_d;

  else if (!readonly && annot->is_hot && ap_r)

    ap = ap_r;

  else

    ap = ap_n;

  /* AP/N, AP/R and AP/D may be streams, or dictionaries of streams. */

  /* If it's a stream, we have a winner! */

  if (pdf_is_indirect(ctx, ap) && pdf_obj_num_is_stream(ctx, annot->page->doc, pdf_to_num(ctx, ap)))

    return ap;

  /* If it's not a stream, it may be a dictionary containing

   * a range of possible values, that should be indexed by

   * AS. */

  return pdf_dict_get(ctx, ap, pdf_resolve_indirect_chain(ctx, pdf_dict_get(ctx, annot->obj, PDF_NAME(AS))));

}

int pdf_annot_active(fz_context *ctx, pdf_annot *annot)

{

  return annot ? annot->is_active : 0;

}

void pdf_set_annot_active(fz_context *ctx, pdf_annot *annot, int active)

{

  int old;

  if (!annot)

    return;

  old = annot->is_active;

  annot->is_active = !!active;

  if (old != annot->is_active)

    pdf_set_annot_has_changed(ctx, annot);

}

int pdf_annot_hot(fz_context *ctx, pdf_annot *annot)

{

  return annot ? annot->is_hot : 0;

}

void pdf_set_annot_hot(fz_context *ctx, pdf_annot *annot, int hot)

{

  int old;

  if (!annot)

    return;

  old = annot->is_hot;

  annot->is_hot = !!hot;

  if (old != annot->is_hot)

    pdf_set_annot_has_changed(ctx, annot);

}

int

pdf_annot_display_rotate(fz_context *ctx, pdf_annot *annot)

{

  int flags;

  int rotate;

  pdf_annot_push_local_xref(ctx, annot);

  fz_try(ctx)

  {

    flags = pdf_annot_flags(ctx, annot);

    if (flags & PDF_ANNOT_IS_NO_ROTATE)

      rotate = pdf_dict_get_inheritable_int(ctx, annot->page->obj, PDF_NAME(Rotate));

    else

      rotate = 0;

  }

  fz_always(ctx)

    pdf_annot_pop_local_xref(ctx, annot);

  fz_catch(ctx)

    fz_rethrow(ctx);

  return rotate;

}

fz_rect

pdf_annot_display_rect(fz_context *ctx, pdf_annot *annot)

{

  fz_rect rect;

  int flags;

  pdf_annot_push_local_xref(ctx, annot);

  fz_try(ctx)

  {

    rect = pdf_dict_get_rect(ctx, annot->obj, PDF_NAME(Rect));

    flags = pdf_annot_flags(ctx, annot);

    if (flags & PDF_ANNOT_IS_NO_ZOOM)

    {

      pdf_obj *ap = pdf_annot_ap(ctx, annot);

      if (ap)

      {

        fz_rect bbox = pdf_xobject_bbox(ctx, ap);

        rect = fz_make_rect(

          rect.x0,

          rect.y1 - (bbox.y1 - bbox.y0),

          rect.x0 + (bbox.x1 - bbox.x0),

          rect.y1

        );

      }

    }

    if (flags & PDF_ANNOT_IS_NO_ROTATE)

    {

      int rotate = pdf_dict_get_inheritable_int(ctx, annot->page->obj, PDF_NAME(Rotate));

      if (rotate != 0)

      {

        fz_point tp = fz_make_point(rect.x0, rect.y1);

        fz_matrix rotmat = fz_translate(-tp.x, -tp.y);

        rotmat = fz_concat(rotmat, fz_rotate(rotate));

        rotmat = fz_concat(rotmat, fz_translate(tp.x, tp.y));

        rect = fz_transform_rect(rect, rotmat);

      }

    }

  }

  fz_always(ctx)

    pdf_annot_pop_local_xref(ctx, annot);

  fz_catch(ctx)

    fz_rethrow(ctx);

  return rect;

}

fz_matrix

pdf_annot_transform(fz_context *ctx, pdf_annot *annot)

{

  fz_rect bbox, rect;

  fz_matrix matrix, rotmat;

  float w, h, sx, sy, x, y;

  int rotate;

  pdf_obj *ap = pdf_annot_ap(ctx, annot);

  rect = pdf_annot_display_rect(ctx, annot);

  rotate = pdf_annot_display_rotate(ctx, annot);

  matrix = pdf_xobject_matrix(ctx, ap);

  bbox = pdf_xobject_bbox(ctx, ap);

  bbox = fz_transform_rect(bbox, matrix);

  w = (bbox.x1 - bbox.x0);

  h = (bbox.y1 - bbox.y0);

  if (rotate == 90)

  {

    rotmat = fz_pre_rotate(fz_scale(w/h, h/w), 90);

    rotmat.e = w;

  }

  else if (rotate == 180)

  {

    rotmat = fz_rotate(180);

    rotmat.e = w;

    rotmat.f = h;

  }

  else if (rotate == 270)

  {

    rotmat = fz_pre_rotate(fz_scale(w/h, h/w), 270);

    rotmat.f = h;

  }

  else

  {

    rotmat = fz_identity;

  }

  if (bbox.x1 == bbox.x0)

    sx = 0;

  else

    sx = (rect.x1 - rect.x0) / w;

  if (bbox.y1 == bbox.y0)

    sy = 0;

  else

    sy = (rect.y1 - rect.y0) / h;

  x = rect.x0 - (bbox.x0 * sx);

  y = rect.y0 - (bbox.y0 * sy);

  return fz_concat(rotmat, fz_pre_scale(fz_translate(x, y), sx, sy));

}

/*

  Internal function for creating a new pdf annotation.

*/

static pdf_annot *

pdf_new_annot(fz_context *ctx, pdf_page *page, pdf_obj *obj)

{

  pdf_annot *annot;

  annot = fz_malloc_struct(ctx, pdf_annot);

  annot->refs = 1;

  annot->page = page; /* only borrowed, as the page owns the annot */

  annot->obj = pdf_keep_obj(ctx, obj);

  return annot;

}

void

pdf_nuke_annots(fz_context *ctx, pdf_page *page)

{

  pdf_annot *annot;

  pdf_annot *next;

  for (annot = page->annots; annot; annot = next)

  {

    next = annot->next;

    pdf_drop_obj(ctx, annot->obj);

    annot->obj = NULL;

    pdf_drop_annot(ctx, annot);

  }

  for (annot = page->widgets; annot; annot = next)

  {

    next = annot->next;

    pdf_drop_obj(ctx, annot->obj);

    annot->obj = NULL;

    pdf_drop_annot(ctx, annot);

  }

  page->annots = NULL;

  page->widgets = NULL;

  page->annot_tailp = &page->annots;

  page->widget_tailp = &page->widgets;

}

static pdf_annot *find_and_unlink_annot_from_list(fz_context *ctx, pdf_annot **prev, pdf_obj *obj)

{

  int num = pdf_to_num(ctx, obj);

  pdf_annot *node;

  node = *prev;

  while (node)

  {

    if (pdf_to_num(ctx, node->obj) == num)

    {

      *prev = node->next;

      node->next = NULL;

      return node;

    }

    else

    {

      prev = &node->next;

      node = node->next;

    }

  }

  return NULL;

}

void

pdf_sync_annots(fz_context *ctx, pdf_page *page)

{

  pdf_annot *old_annots;

  pdf_annot *old_widgets;

  pdf_annot *annot, *next;

  pdf_obj *annots;

  pdf_obj *subtype;

  int i, n;

  // Save list of annots loaded last time (if any).

  old_annots = page->annots;

  old_widgets = page->widgets;

  page->annots = NULL;

  page->widgets = NULL;

  page->annot_tailp = &page->annots;

  page->widget_tailp = &page->widgets;

  // Create new list of annots (reusing old annots when possible)

  annots = pdf_dict_get(ctx, page->obj, PDF_NAME(Annots));

  n = pdf_array_len(ctx, annots);

  for (i = 0; i < n; ++i)

  {

    pdf_obj *obj = pdf_array_get(ctx, annots, i);

    if (pdf_is_dict(ctx, obj))

    {

      subtype = pdf_dict_get(ctx, obj, PDF_NAME(Subtype));

      if (pdf_name_eq(ctx, subtype, PDF_NAME(Link)))

        continue;

      if (pdf_name_eq(ctx, subtype, PDF_NAME(Popup)))

        continue;

      if (pdf_name_eq(ctx, subtype, PDF_NAME(Widget)))

      {

        annot = find_and_unlink_annot_from_list(ctx, &old_widgets, obj);

        if (!annot)

          annot = pdf_new_annot(ctx, page, obj);

        *page->widget_tailp = annot;

        page->widget_tailp = &annot->next;

      }

      else

      {

        annot = find_and_unlink_annot_from_list(ctx, &old_annots, obj);

        if (!annot)

          annot = pdf_new_annot(ctx, page, obj);

        *page->annot_tailp = annot;

        page->annot_tailp = &annot->next;

      }

    }

  }

  // Nuke the annot structs that are no longer used on the page

  for (annot = old_annots; annot; annot = next)

  {

    next = annot->next;

    pdf_drop_obj(ctx, annot->obj);

    annot->obj = NULL;

    pdf_drop_annot(ctx, annot);

  }

  for (annot = old_widgets; annot; annot = next)

  {

    next = annot->next;

    pdf_drop_obj(ctx, annot->obj);

    annot->obj = NULL;

    pdf_drop_annot(ctx, annot);

  }

}

static int pdf_need_appearances(fz_context *ctx, pdf_document *doc)

{

  return pdf_to_bool(ctx,

    pdf_dict_getl(ctx,

      pdf_trailer(ctx, doc),

      PDF_NAME(Root),

      PDF_NAME(AcroForm),

      PDF_NAME(NeedAppearances),

      NULL

    )

  );

}

void

pdf_load_annots(fz_context *ctx, pdf_page *page)

{

  pdf_sync_annots(ctx, page);

  /* We need to run a resynth pass on the annotations on this

   * page. That means rerunning it on the complete document. */

  if (page->annots || page->widgets)

  {

    page->doc->resynth_required = 1;

    if (pdf_need_appearances(ctx, page->doc))

    {

      pdf_annot *widget;

      for (widget = page->widgets; widget; widget = widget->next)

      {

        // request local only resynthesis

        widget->needs_new_local_ap = 1;

      }

    }

  }

  /* And actually update the page so that any annotations required

   * get synthesised. */

  pdf_update_page(ctx, page);

}

pdf_annot *

pdf_first_annot(fz_context *ctx, pdf_page *page)

{

  return page ? page->annots : NULL;

}

pdf_annot *

pdf_next_annot(fz_context *ctx, pdf_annot *annot)

{

  return annot ? annot->next : NULL;

}

pdf_obj *pdf_annot_obj(fz_context *ctx, pdf_annot *annot)

{

  return annot ? annot->obj : NULL;

}

pdf_page *pdf_annot_page(fz_context *ctx, pdf_annot *annot)

{

  return annot ? annot->page : NULL;

}

fz_rect

pdf_bound_annot(fz_context *ctx, pdf_annot *annot)

{

  fz_matrix page_ctm;

  fz_rect rect;

  pdf_page_transform(ctx, annot->page, NULL, &page_ctm);

  rect = pdf_annot_display_rect(ctx, annot);

  return fz_transform_rect(rect, page_ctm);

}

void

pdf_annot_request_resynthesis(fz_context *ctx, pdf_annot *annot)

{

  if (annot == NULL)

    return;

  annot->needs_new_local_ap = 0;

  annot->needs_new_ap = 1;

  annot->page->doc->resynth_required = 1;

}

void

pdf_annot_request_synthesis(fz_context *ctx, pdf_annot *annot)

{

  if (annot == NULL)

    return;

  if (!pdf_annot_ap(ctx, annot))

    pdf_annot_request_resynthesis(ctx, annot);

}

int

pdf_annot_needs_resynthesis(fz_context *ctx, pdf_annot *annot)

{

  if (annot == NULL)

    return 0;

  if (annot->needs_new_local_ap)

    return -1;

  return annot->needs_new_ap;

}

void pdf_set_annot_resynthesised(fz_context *ctx, pdf_annot *annot)

{

  if (annot == NULL)

    return;

  if (annot->page->doc->local_xref_nesting == 0)

    annot->needs_new_local_ap = 0;

  annot->needs_new_ap = 0;

  pdf_set_annot_has_changed(ctx, annot);

}

void pdf_set_annot_has_changed(fz_context *ctx, pdf_annot *annot)

{

  if (annot == NULL)

    return;

  annot->has_new_ap = 1;

}

void

pdf_dirty_annot(fz_context *ctx, pdf_annot *annot)

{

  pdf_annot_request_resynthesis(ctx, annot);

}

const char *

pdf_string_from_annot_type(fz_context *ctx, enum pdf_annot_type type)

{

  switch (type)

  {

  case PDF_ANNOT_TEXT: return "Text";

  case PDF_ANNOT_LINK: return "Link";

  case PDF_ANNOT_FREE_TEXT: return "FreeText";

  case PDF_ANNOT_LINE: return "Line";

  case PDF_ANNOT_SQUARE: return "Square";

  case PDF_ANNOT_CIRCLE: return "Circle";

  case PDF_ANNOT_POLYGON: return "Polygon";

  case PDF_ANNOT_POLY_LINE: return "PolyLine";

  case PDF_ANNOT_HIGHLIGHT: return "Highlight";

  case PDF_ANNOT_UNDERLINE: return "Underline";

  case PDF_ANNOT_SQUIGGLY: return "Squiggly";

  case PDF_ANNOT_STRIKE_OUT: return "StrikeOut";

  case PDF_ANNOT_REDACT: return "Redact";

  case PDF_ANNOT_STAMP: return "Stamp";

  case PDF_ANNOT_CARET: return "Caret";

  case PDF_ANNOT_INK: return "Ink";

  case PDF_ANNOT_POPUP: return "Popup";

  case PDF_ANNOT_FILE_ATTACHMENT: return "FileAttachment";

  case PDF_ANNOT_SOUND: return "Sound";

  case PDF_ANNOT_MOVIE: return "Movie";

  case PDF_ANNOT_RICH_MEDIA: return "RichMedia";

  case PDF_ANNOT_WIDGET: return "Widget";

  case PDF_ANNOT_SCREEN: return "Screen";

  case PDF_ANNOT_PRINTER_MARK: return "PrinterMark";

  case PDF_ANNOT_TRAP_NET: return "TrapNet";

  case PDF_ANNOT_WATERMARK: return "Watermark";

  case PDF_ANNOT_3D: return "3D";

  case PDF_ANNOT_PROJECTION: return "Projection";

  default: return "UNKNOWN";

  }

}

enum pdf_annot_type

pdf_annot_type_from_string(fz_context *ctx, const char *subtype)

{

  if (!strcmp("Text", subtype)) return PDF_ANNOT_TEXT;

  if (!strcmp("Link", subtype)) return PDF_ANNOT_LINK;

  if (!strcmp("FreeText", subtype)) return PDF_ANNOT_FREE_TEXT;

  if (!strcmp("Line", subtype)) return PDF_ANNOT_LINE;

  if (!strcmp("Square", subtype)) return PDF_ANNOT_SQUARE;

  if (!strcmp("Circle", subtype)) return PDF_ANNOT_CIRCLE;

  if (!strcmp("Polygon", subtype)) return PDF_ANNOT_POLYGON;

  if (!strcmp("PolyLine", subtype)) return PDF_ANNOT_POLY_LINE;

  if (!strcmp("Highlight", subtype)) return PDF_ANNOT_HIGHLIGHT;

  if (!strcmp("Underline", subtype)) return PDF_ANNOT_UNDERLINE;

  if (!strcmp("Squiggly", subtype)) return PDF_ANNOT_SQUIGGLY;

  if (!strcmp("StrikeOut", subtype)) return PDF_ANNOT_STRIKE_OUT;

  if (!strcmp("Redact", subtype)) return PDF_ANNOT_REDACT;

  if (!strcmp("Stamp", subtype)) return PDF_ANNOT_STAMP;

  if (!strcmp("Caret", subtype)) return PDF_ANNOT_CARET;

  if (!strcmp("Ink", subtype)) return PDF_ANNOT_INK;

  if (!strcmp("Popup", subtype)) return PDF_ANNOT_POPUP;

  if (!strcmp("FileAttachment", subtype)) return PDF_ANNOT_FILE_ATTACHMENT;

  if (!strcmp("Sound", subtype)) return PDF_ANNOT_SOUND;

  if (!strcmp("Movie", subtype)) return PDF_ANNOT_MOVIE;

  if (!strcmp("RichMedia", subtype)) return PDF_ANNOT_RICH_MEDIA;

  if (!strcmp("Widget", subtype)) return PDF_ANNOT_WIDGET;

  if (!strcmp("Screen", subtype)) return PDF_ANNOT_SCREEN;

  if (!strcmp("PrinterMark", subtype)) return PDF_ANNOT_PRINTER_MARK;

  if (!strcmp("TrapNet", subtype)) return PDF_ANNOT_TRAP_NET;

  if (!strcmp("Watermark", subtype)) return PDF_ANNOT_WATERMARK;

  if (!strcmp("3D", subtype)) return PDF_ANNOT_3D;

  if (!strcmp("Projection", subtype)) return PDF_ANNOT_PROJECTION;

  return PDF_ANNOT_UNKNOWN;

}

static void

begin_annot_op(fz_context *ctx, pdf_annot *annot, const char *op)

{

  if (!annot->page)

    fz_throw(ctx, FZ_ERROR_ARGUMENT, "annotation not bound to any page");

  pdf_begin_operation(ctx, annot->page->doc, op);

}

static void

end_annot_op(fz_context *ctx, pdf_annot *annot)

{

  pdf_end_operation(ctx, annot->page->doc);

}

static void

abandon_annot_op(fz_context *ctx, pdf_annot *annot)

{

  pdf_abandon_operation(ctx, annot->page->doc);

}

static int is_allowed_subtype(fz_context *ctx, pdf_annot *annot, pdf_obj *property, pdf_obj **allowed)

{

  pdf_obj *subtype;

  subtype = pdf_dict_get(ctx, annot->obj, PDF_NAME(Subtype));

  while (*allowed) {

    if (pdf_name_eq(ctx, subtype, *allowed))

      return 1;

    allowed++;

  }

  return 0;

}

static int is_allowed_subtype_wrap(fz_context *ctx, pdf_annot *annot, pdf_obj *property, pdf_obj **allowed)

{

  int ret;

  pdf_annot_push_local_xref(ctx, annot);

  fz_try(ctx)

    ret = is_allowed_subtype(ctx, annot, property, allowed);

  fz_always(ctx)

    pdf_annot_pop_local_xref(ctx, annot);

  fz_catch(ctx)

    fz_rethrow(ctx);

  return ret;

}

static void check_allowed_subtypes(fz_context *ctx, pdf_annot *annot, pdf_obj *property, pdf_obj **allowed)

{

  pdf_obj *subtype;

  subtype = pdf_dict_get(ctx, annot->obj, PDF_NAME(Subtype));

  if (!is_allowed_subtype(ctx, annot, property, allowed))

    fz_throw(ctx, FZ_ERROR_ARGUMENT, "%s annotations have no %s property", pdf_to_name(ctx, subtype), pdf_to_name(ctx, property));

}

pdf_annot *

pdf_create_annot_raw(fz_context *ctx, pdf_page *page, enum pdf_annot_type type)

{

  pdf_annot *annot = NULL;

  pdf_document *doc = page->doc;

  pdf_obj *annot_obj = pdf_new_dict(ctx, doc, 0);

  pdf_obj *ind_obj = NULL;

  pdf_obj *free_arr = NULL;

  fz_var(annot);

  fz_var(ind_obj);

  fz_var(free_arr);

  fz_try(ctx)

  {

    int ind_obj_num;

    const char *type_str;

    pdf_obj *annot_arr;

    type_str = pdf_string_from_annot_type(ctx, type);

    if (type == PDF_ANNOT_UNKNOWN)

      fz_throw(ctx, FZ_ERROR_ARGUMENT, "cannot create unknown annotation");

    annot_arr = pdf_dict_get(ctx, page->obj, PDF_NAME(Annots));

    if (!pdf_is_array(ctx, annot_arr))

      annot_arr = pdf_dict_put_array(ctx, page->obj, PDF_NAME(Annots), 0);

    else if (pdf_is_indirect(ctx, annot_arr))

    {

      free_arr = annot_arr = pdf_copy_array(ctx, annot_arr);

      pdf_dict_put(ctx, page->obj, PDF_NAME(Annots), annot_arr);

    }

    pdf_dict_put(ctx, annot_obj, PDF_NAME(Type), PDF_NAME(Annot));

    pdf_dict_put_name(ctx, annot_obj, PDF_NAME(Subtype), type_str);

    /*

      Both annotation object and annotation structure are now created.

      Insert the object in the hierarchy and the structure in the

      page's array.

    */

    ind_obj_num = pdf_create_object(ctx, doc);

    pdf_update_object(ctx, doc, ind_obj_num, annot_obj);

    ind_obj = pdf_new_indirect(ctx, doc, ind_obj_num, 0);

    pdf_array_push(ctx, annot_arr, ind_obj);

    annot = pdf_new_annot(ctx, page, ind_obj);

    /*

      Linking must be done after any call that might throw because

      pdf_drop_annots below actually frees a list. Put the new annot

      at the end of the list, so that it will be drawn last.

    */

    if (type == PDF_ANNOT_WIDGET)

    {

      *page->widget_tailp = annot;

      page->widget_tailp = &annot->next;

    }

    else

    {

      *page->annot_tailp = annot;

      page->annot_tailp = &annot->next;

    }

  }

  fz_always(ctx)

  {

    pdf_drop_obj(ctx, free_arr);

    pdf_drop_obj(ctx, annot_obj);

    pdf_drop_obj(ctx, ind_obj);

  }

  fz_catch(ctx)

  {

    pdf_drop_annots(ctx, annot);

    fz_rethrow(ctx);

  }

  return pdf_keep_annot(ctx, annot);

}

fz_link *

pdf_create_link(fz_context *ctx, pdf_page *page, fz_rect bbox, const char *uri)

{

  fz_link *link = NULL;

  pdf_document *doc = page->doc;

  pdf_obj *annot_obj = pdf_new_dict(ctx, doc, 0);

  pdf_obj *ind_obj = NULL;

  pdf_obj *bs = NULL;

  pdf_obj *a = NULL;

  fz_link **linkp;

  fz_rect page_mediabox;

  fz_matrix page_ctm;

  fz_rect rect;

  pdf_obj *free_arr = NULL;

  fz_var(link);

  fz_var(ind_obj);

  fz_var(bs);

  fz_var(a);

  fz_var(free_arr);

  pdf_begin_operation(ctx, page->doc, "Create Link");

  fz_try(ctx)

  {

    int ind_obj_num;

    pdf_obj *annot_arr;

    pdf_page_transform(ctx, page, &page_mediabox, &page_ctm);

    page_ctm = fz_invert_matrix(page_ctm);

    rect = fz_transform_rect(bbox, page_ctm);

    annot_arr = pdf_dict_get(ctx, page->obj, PDF_NAME(Annots));

    if (!pdf_is_array(ctx, annot_arr))

      annot_arr = pdf_dict_put_array(ctx, page->obj, PDF_NAME(Annots), 0);

    else if (pdf_is_indirect(ctx, annot_arr))

    {

      free_arr = annot_arr = pdf_copy_array(ctx, annot_arr);

      pdf_dict_put(ctx, page->obj, PDF_NAME(Annots), annot_arr);

    }

    pdf_dict_put(ctx, annot_obj, PDF_NAME(Type), PDF_NAME(Annot));

    pdf_dict_put(ctx, annot_obj, PDF_NAME(Subtype), PDF_NAME(Link));

    pdf_dict_put_rect(ctx, annot_obj, PDF_NAME(Rect), rect);

    bs = pdf_dict_put_dict(ctx, annot_obj, PDF_NAME(BS), 4);

    pdf_dict_put(ctx, bs, PDF_NAME(S), PDF_NAME(S));

    pdf_dict_put(ctx, bs, PDF_NAME(Type), PDF_NAME(Border));

    pdf_dict_put_int(ctx, bs, PDF_NAME(W), 0);

    pdf_dict_put_drop(ctx, annot_obj, PDF_NAME(A),

      pdf_new_action_from_link(ctx, doc, uri));

    /*

      Both annotation object and annotation structure are now created.

      Insert the object in the hierarchy and the structure in the

      page's array.

    */

    ind_obj_num = pdf_create_object(ctx, doc);

    pdf_update_object(ctx, doc, ind_obj_num, annot_obj);

    ind_obj = pdf_new_indirect(ctx, doc, ind_obj_num, 0);

    pdf_array_push(ctx, annot_arr, ind_obj);

    link = (fz_link *) pdf_new_link(ctx, page, bbox, uri, annot_obj);

    linkp = &page->links;

    while (*linkp != NULL)

      linkp = &(*linkp)->next;

    *linkp = link;

    pdf_end_operation(ctx, page->doc);

  }

  fz_always(ctx)

  {

    pdf_drop_obj(ctx, free_arr);

    pdf_drop_obj(ctx, annot_obj);

    pdf_drop_obj(ctx, ind_obj);

  }

  fz_catch(ctx)

  {

    pdf_abandon_operation(ctx, page->doc);

    fz_rethrow(ctx);

  }

  return fz_keep_link(ctx, link);

}

void pdf_delete_link(fz_context *ctx, pdf_page *page, fz_link *link)

{

  fz_link **linkptr;

  pdf_obj *annots;

  int i;

  if (link == NULL || page == NULL || page != ((pdf_link *) link)->page)

    return;

  for (linkptr = &page->links; *linkptr; linkptr = &((*linkptr)->next))

  {

    if (*linkptr == link)

      break;

  }

  if (*linkptr == NULL)

    return;

  /* Link may no longer borrow page pointer, since they are separated */

  ((pdf_link *) link)->page = NULL;

  pdf_begin_operation(ctx, page->doc, "Delete Link");

  fz_try(ctx)

  {

    annots = pdf_dict_get(ctx, page->obj, PDF_NAME(Annots));

    i = pdf_array_find(ctx, annots, ((pdf_link *) link)->obj);

    if (i >= 0)

      pdf_array_delete(ctx, annots, i);

    *linkptr = link->next;

    link->next = NULL;

    fz_drop_link(ctx, link);

    pdf_end_operation(ctx, page->doc);

  }

  fz_catch(ctx)

  {

    pdf_abandon_operation(ctx, page->doc);

    fz_rethrow(ctx);

  }

}

static pdf_obj *

pdf_add_popup_annot(fz_context *ctx, pdf_annot *annot)

{

  pdf_obj *annots, *popup;

  popup = pdf_dict_get(ctx, annot->obj, PDF_NAME(Popup));

  if (popup)

    return popup;

  annots = pdf_dict_get(ctx, annot->page->obj, PDF_NAME(Annots));

  if (!annots)

    return NULL;

  popup = pdf_add_new_dict(ctx, annot->page->doc, 4);

  pdf_array_push_drop(ctx, annots, popup);

  pdf_dict_put(ctx, popup, PDF_NAME(Type), PDF_NAME(Annot));

  pdf_dict_put(ctx, popup, PDF_NAME(Subtype), PDF_NAME(Popup));

  pdf_dict_put(ctx, popup, PDF_NAME(Parent), annot->obj);

  pdf_dict_put_rect(ctx, popup, PDF_NAME(Rect), fz_make_rect(0,0,0,0));

  pdf_dict_put(ctx, annot->obj, PDF_NAME(Popup), popup);

  return popup;

}

static pdf_obj *popup_subtypes[] = {

  PDF_NAME(Text),

  PDF_NAME(FreeText),

  PDF_NAME(Line),

  PDF_NAME(Square),

  PDF_NAME(Circle),

  PDF_NAME(Polygon),

  PDF_NAME(PolyLine),

  PDF_NAME(Highlight),

  PDF_NAME(Underline),

  PDF_NAME(Squiggly),

  PDF_NAME(StrikeOut),

  PDF_NAME(Stamp),

  PDF_NAME(Caret),

  PDF_NAME(Ink),

  PDF_NAME(FileAttachment),

  PDF_NAME(Sound),

  PDF_NAME(Redact),

  NULL,

};

int

pdf_annot_has_popup(fz_context *ctx, pdf_annot *annot)

{

  return is_allowed_subtype_wrap(ctx, annot, PDF_NAME(Popup), popup_subtypes);

}

void pdf_set_annot_popup(fz_context *ctx, pdf_annot *annot, fz_rect rect)

{

  fz_matrix page_ctm, inv_page_ctm;

  pdf_obj *popup;

  begin_annot_op(ctx, annot, "Set popup");

  fz_try(ctx)

  {

    check_allowed_subtypes(ctx, annot, PDF_NAME(Popup), popup_subtypes);

    pdf_page_transform(ctx, annot->page, NULL, &page_ctm);

    inv_page_ctm = fz_invert_matrix(page_ctm);

    rect = fz_transform_rect(rect, inv_page_ctm);

    popup = pdf_add_popup_annot(ctx, annot);

    pdf_dict_put_rect(ctx, popup, PDF_NAME(Rect), rect);

    end_annot_op(ctx, annot);

  }

  fz_catch(ctx)

  {

    abandon_annot_op(ctx, annot);

    fz_rethrow(ctx);

  }

  pdf_dirty_annot(ctx, annot);

}

fz_rect pdf_annot_popup(fz_context *ctx, pdf_annot *annot)