// 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 "mupdf/pdf.h"

#include <string.h>

/*
	Notes on OCGs etc.

	PDF Documents may contain Optional Content Groups. Which of
	these is shown at any given time is dependent on which
	Optional Content Configuration Dictionary is in force at the
	time.

	A pdf_document, once loaded, contains some state saying which
	OCGs are enabled/disabled, and which 'Intent' (or 'Intents')
	a file is being used for. This information is held outside of
	the actual PDF file.

	An Intent (just 'View' or 'Design' or 'All', according to
	PDF 2.0, but theoretically more) says which OCGs to consider
	or ignore in calculating the visibility of content. The
	Intent (or Intents, for there can be an array) is set by the
	current OCCD.

	When first loaded, we turn all OCGs on, then load the default
	OCCD. This may turn some OCGs off, and sets the document Intent.

	Callers can ask how many OCCDs there are, read the names/creators
	for each, and then select any one of them. That updates which
	OCGs are selected, and resets the Intent.

	Once an OCCD has been selected, a caller can enumerate the
	'displayable configuration'. This is a list of labels/radio
	buttons/check buttons that can be used to enable/disable
	given OCGs. The caller can then enable/disable OCGs by
	asking to select (or toggle) given entries in that list.

	Thus the handling of radio button groups, and 'locked'
	elements is kept within the core of MuPDF.

	Finally, the caller can set the 'usage' for a document. This
	can be 'View', 'Print', or 'Export'.
*/

typedef struct
{
	pdf_obj *obj;
	int n;
	int state;
} pdf_ocg_entry;

typedef struct
{
	int ocg;
	const char *name;
	int depth;
	unsigned int button_flags : 2;
	unsigned int locked : 1;
} pdf_ocg_ui;

struct pdf_ocg_descriptor
{
	int current;
	int num_configs;

	int len;
	pdf_ocg_entry *ocgs;

	pdf_obj *intent;
	const char *usage;

	int num_ui_entries;
	pdf_ocg_ui *ui;
};

int
pdf_count_layer_configs(fz_context *ctx, pdf_document *doc)
{
	pdf_ocg_descriptor *desc = pdf_read_ocg(ctx, doc);
	return desc ? desc->num_configs : 0;
}

int
pdf_count_layers(fz_context *ctx, pdf_document *doc)
{
	pdf_ocg_descriptor *desc = pdf_read_ocg(ctx, doc);
	return desc ? desc->len : 0;
}

const char *
pdf_layer_name(fz_context *ctx, pdf_document *doc, int layer)
{
	pdf_ocg_descriptor *desc = pdf_read_ocg(ctx, doc);
	if (desc && layer >= 0 && layer < desc->len)
		return pdf_dict_get_text_string(ctx, desc->ocgs[layer].obj, PDF_NAME(Name));
	fz_throw(ctx, FZ_ERROR_ARGUMENT, "invalid layer index");
}

int
pdf_layer_is_enabled(fz_context *ctx, pdf_document *doc, int layer)
{
	pdf_ocg_descriptor *desc = pdf_read_ocg(ctx, doc);
	if (desc && layer >= 0 && layer < desc->len)
		return desc->ocgs[layer].state;
	fz_throw(ctx, FZ_ERROR_ARGUMENT, "invalid layer index");
}

void
pdf_enable_layer(fz_context *ctx, pdf_document *doc, int layer, int enabled)
{
	pdf_ocg_descriptor *desc = pdf_read_ocg(ctx, doc);
	if (desc && layer >= 0 && layer < desc->len)
		desc->ocgs[layer].state = enabled;
	else
		fz_throw(ctx, FZ_ERROR_ARGUMENT, "invalid layer index");
}

static int
count_entries(fz_context *ctx, pdf_obj *obj, pdf_cycle_list *cycle_up)
{
	pdf_cycle_list cycle;
	int len = pdf_array_len(ctx, obj);
	int i;
	int count = 0;

	for (i = 0; i < len; i++)
	{
		pdf_obj *o = pdf_array_get(ctx, obj, i);
		if (pdf_cycle(ctx, &cycle, cycle_up, o))
			continue;
		count += (pdf_is_array(ctx, o) ? count_entries(ctx, o, &cycle) : 1);
	}
	return count;
}

static pdf_ocg_ui *
get_ocg_ui(fz_context *ctx, pdf_ocg_descriptor *desc, int fill)
{
	if (fill == desc->num_ui_entries)
	{
		/* Number of layers changed while parsing;
		 * probably due to a repair. */
		int newsize = desc->num_ui_entries * 2;
		if (newsize == 0)
			newsize = 4; /* Arbitrary non-zero */
		desc->ui = fz_realloc_array(ctx, desc->ui, newsize, pdf_ocg_ui);
		desc->num_ui_entries = newsize;
	}
	return &desc->ui[fill];
}

static int
ocgcmp(const void *a_, const void *b_)
{
	const pdf_ocg_entry *a = a_;
	const pdf_ocg_entry *b = b_;

	return (b->n - a->n);
}

static int
find_ocg(fz_context *ctx, pdf_ocg_descriptor *desc, pdf_obj *obj)
{
	int n = pdf_to_num(ctx, obj);
	int l = 0;
	int r = desc->len-1;

	if (n <= 0)
		return -1;

	while (l <= r)
	{
		int m = (l + r) >> 1;
		int c = desc->ocgs[m].n - n;
		if (c < 0)
			r = m - 1;
		else if (c > 0)
			l = m + 1;
		else
			return m;
	}
	return -1;
}

static int
populate_ui(fz_context *ctx, pdf_ocg_descriptor *desc, int fill, pdf_obj *order, int depth, pdf_obj *rbgroups, pdf_obj *locked,
	pdf_cycle_list *cycle_up)
{
	pdf_cycle_list cycle;
	int len = pdf_array_len(ctx, order);
	int i, j;
	pdf_ocg_ui *ui;

	for (i = 0; i < len; i++)
	{
		pdf_obj *o = pdf_array_get(ctx, order, i);
		if (pdf_is_array(ctx, o))
		{
			if (pdf_cycle(ctx, &cycle, cycle_up, o))
				continue;

			fill = populate_ui(ctx, desc, fill, o, depth+1, rbgroups, locked, &cycle);
			continue;
		}
		if (pdf_is_string(ctx, o))
		{
			ui = get_ocg_ui(ctx, desc, fill++);
			ui->depth = depth;
			ui->ocg = -1;
			ui->name = pdf_to_text_string(ctx, o);
			ui->button_flags = PDF_LAYER_UI_LABEL;
			ui->locked = 1;
			continue;
		}

		j = find_ocg(ctx, desc, o);
		if (j < 0)
			continue; /* OCG not found in main list! Just ignore it */
		ui = get_ocg_ui(ctx, desc, fill++);
		ui->depth = depth;
		ui->ocg = j;
		ui->name = pdf_dict_get_text_string(ctx, o, PDF_NAME(Name));
		ui->button_flags = pdf_array_contains(ctx, o, rbgroups) ? PDF_LAYER_UI_RADIOBOX : PDF_LAYER_UI_CHECKBOX;
		ui->locked = pdf_array_contains(ctx, o, locked);
	}
	return fill;
}

static void
drop_ui(fz_context *ctx, pdf_ocg_descriptor *desc)
{
	if (!desc)
		return;

	fz_free(ctx, desc->ui);
	desc->ui = NULL;
}

static void
load_ui(fz_context *ctx, pdf_ocg_descriptor *desc, pdf_obj *ocprops, pdf_obj *occg)
{
	pdf_obj *order;
	pdf_obj *rbgroups;
	pdf_obj *locked;
	int count;

	/* Count the number of entries */
	order = pdf_dict_get(ctx, occg, PDF_NAME(Order));
	if (!order)
		order = pdf_dict_getp(ctx, ocprops, "D/Order");
	count = count_entries(ctx, order, NULL);
	rbgroups = pdf_dict_get(ctx, occg, PDF_NAME(RBGroups));
	if (!rbgroups)
		rbgroups = pdf_dict_getp(ctx, ocprops, "D/RBGroups");
	locked = pdf_dict_get(ctx, occg, PDF_NAME(Locked));

	desc->num_ui_entries = count;
	if (desc->num_ui_entries == 0)
		return;

	desc->ui = fz_malloc_struct_array(ctx, count, pdf_ocg_ui);
	fz_try(ctx)
	{
		desc->num_ui_entries = populate_ui(ctx, desc, 0, order, 0, rbgroups, locked, NULL);
	}
	fz_catch(ctx)
	{
		drop_ui(ctx, desc);
		fz_rethrow(ctx);
	}
}

void
pdf_select_layer_config(fz_context *ctx, pdf_document *doc, int config)
{
	pdf_ocg_descriptor *desc;
	int i, j, len, len2;
	pdf_obj *obj, *cobj;
	pdf_obj *name;

	desc = pdf_read_ocg(ctx, doc);

	obj = pdf_dict_get(ctx, pdf_dict_get(ctx, pdf_trailer(ctx, doc), PDF_NAME(Root)), PDF_NAME(OCProperties));
	if (!obj)
	{
		if (config == 0)
			return;
		else
			fz_throw(ctx, FZ_ERROR_ARGUMENT, "Unknown Layer config (None known!)");
	}

	cobj = pdf_array_get(ctx, pdf_dict_get(ctx, obj, PDF_NAME(Configs)), config);
	if (!cobj)
	{
		if (config != 0)
			fz_throw(ctx, FZ_ERROR_ARGUMENT, "Illegal Layer config");
		cobj = pdf_dict_get(ctx, obj, PDF_NAME(D));
		if (!cobj)
			fz_throw(ctx, FZ_ERROR_FORMAT, "No default Layer config");
	}

	pdf_drop_obj(ctx, desc->intent);
	desc->intent = pdf_keep_obj(ctx, pdf_dict_get(ctx, cobj, PDF_NAME(Intent)));

	len = desc->len;
	name = pdf_dict_get(ctx, cobj, PDF_NAME(BaseState));
	if (pdf_name_eq(ctx, name, PDF_NAME(Unchanged)))
	{
		/* Do nothing */
	}
	else if (pdf_name_eq(ctx, name, PDF_NAME(OFF)))
	{
		for (i = 0; i < len; i++)
		{
			desc->ocgs[i].state = 0;
		}
	}
	else /* Default to ON */
	{
		for (i = 0; i < len; i++)
		{
			desc->ocgs[i].state = 1;
		}
	}

	obj = pdf_dict_get(ctx, cobj, PDF_NAME(ON));
	len2 = pdf_array_len(ctx, obj);
	for (i = 0; i < len2; i++)
	{
		pdf_obj *o = pdf_array_get(ctx, obj, i);
		for (j=0; j < len; j++)
		{
			if (!pdf_objcmp_resolve(ctx, desc->ocgs[j].obj, o))
			{
				desc->ocgs[j].state = 1;
				break;
			}
		}
	}

	obj = pdf_dict_get(ctx, cobj, PDF_NAME(OFF));
	len2 = pdf_array_len(ctx, obj);
	for (i = 0; i < len2; i++)
	{
		pdf_obj *o = pdf_array_get(ctx, obj, i);
		for (j=0; j < len; j++)
		{
			if (!pdf_objcmp_resolve(ctx, desc->ocgs[j].obj, o))
			{
				desc->ocgs[j].state = 0;
				break;
			}
		}
	}

	desc->current = config;

	drop_ui(ctx, desc);
	load_ui(ctx, desc, obj, cobj);
}

void
pdf_layer_config_info(fz_context *ctx, pdf_document *doc, int config_num, pdf_layer_config *info)
{
	pdf_ocg_descriptor *desc;
	pdf_obj *ocprops;
	pdf_obj *obj;

	if (!info)
		return;

	desc = pdf_read_ocg(ctx, doc);

	info->name = NULL;
	info->creator = NULL;

	if (config_num < 0 || config_num >= desc->num_configs)
		fz_throw(ctx, FZ_ERROR_ARGUMENT, "Invalid layer config number");

	ocprops = pdf_dict_getp(ctx, pdf_trailer(ctx, doc), "Root/OCProperties");
	if (!ocprops)
		return;

	obj = pdf_dict_get(ctx, ocprops, PDF_NAME(Configs));
	if (pdf_is_array(ctx, obj))
		obj = pdf_array_get(ctx, obj, config_num);
	else if (config_num == 0)
		obj = pdf_dict_get(ctx, ocprops, PDF_NAME(D));
	else
		fz_throw(ctx, FZ_ERROR_ARGUMENT, "Invalid layer config number");

	info->creator = pdf_dict_get_string(ctx, obj, PDF_NAME(Creator), NULL);
	info->name = pdf_dict_get_string(ctx, obj, PDF_NAME(Name), NULL);
}

void
pdf_drop_ocg(fz_context *ctx, pdf_document *doc)
{
	pdf_ocg_descriptor *desc;
	int i;

	if (!doc)
		return;
	desc = doc->ocg;
	if (!desc)
		return;

	drop_ui(ctx, desc);
	pdf_drop_obj(ctx, desc->intent);
	for (i = 0; i < desc->len; i++)
		pdf_drop_obj(ctx, desc->ocgs[i].obj);
	fz_free(ctx, desc->ocgs);
	fz_free(ctx, desc);
}

static void
clear_radio_group(fz_context *ctx, pdf_document *doc, pdf_obj *ocg)
{
	pdf_obj *rbgroups = pdf_dict_getp(ctx, pdf_trailer(ctx, doc), "Root/OCProperties/RBGroups");
	int len, i;

	len = pdf_array_len(ctx, rbgroups);
	for (i = 0; i < len; i++)
	{
		pdf_obj *group = pdf_array_get(ctx, rbgroups, i);

		if (pdf_array_contains(ctx, ocg, group))
		{
			int len2 = pdf_array_len(ctx, group);
			int j;

			for (j = 0; j < len2; j++)
			{
				pdf_obj *g = pdf_array_get(ctx, group, j);
				int k;
				for (k = 0; k < doc->ocg->len; k++)
				{
					pdf_ocg_entry *s = &doc->ocg->ocgs[k];

					if (!pdf_objcmp_resolve(ctx, s->obj, g))
						s->state = 0;
				}
			}
		}
	}
}

int pdf_count_layer_config_ui(fz_context *ctx, pdf_document *doc)
{
	pdf_ocg_descriptor *desc = pdf_read_ocg(ctx, doc);
	return desc ? desc->num_ui_entries : 0;
}

void pdf_select_layer_config_ui(fz_context *ctx, pdf_document *doc, int ui)
{
	pdf_ocg_descriptor *desc = pdf_read_ocg(ctx, doc);
	pdf_ocg_ui *entry;

	if (ui < 0 || ui >= desc->num_ui_entries)
		fz_throw(ctx, FZ_ERROR_ARGUMENT, "Out of range UI entry selected");

	entry = &desc->ui[ui];
	if (entry->button_flags != PDF_LAYER_UI_RADIOBOX &&
		entry->button_flags != PDF_LAYER_UI_CHECKBOX)
		return;
	if (entry->locked)
		return;

	if (entry->button_flags == PDF_LAYER_UI_RADIOBOX)
		clear_radio_group(ctx, doc, desc->ocgs[entry->ocg].obj);

	desc->ocgs[entry->ocg].state = 1;
}

void pdf_toggle_layer_config_ui(fz_context *ctx, pdf_document *doc, int ui)
{
	pdf_ocg_descriptor *desc = pdf_read_ocg(ctx, doc);
	pdf_ocg_ui *entry;
	int selected;

	if (ui < 0 || ui >= desc->num_ui_entries)
		fz_throw(ctx, FZ_ERROR_ARGUMENT, "Out of range UI entry toggled");

	entry = &desc->ui[ui];
	if (entry->button_flags != PDF_LAYER_UI_RADIOBOX &&
		entry->button_flags != PDF_LAYER_UI_CHECKBOX)
		return;
	if (entry->locked)
		return;

	selected = desc->ocgs[entry->ocg].state;

	if (entry->button_flags == PDF_LAYER_UI_RADIOBOX)
		clear_radio_group(ctx, doc, desc->ocgs[entry->ocg].obj);

	desc->ocgs[entry->ocg].state = !selected;
}

void pdf_deselect_layer_config_ui(fz_context *ctx, pdf_document *doc, int ui)
{
	pdf_ocg_descriptor *desc = pdf_read_ocg(ctx, doc);
	pdf_ocg_ui *entry;

	if (ui < 0 || ui >= desc->num_ui_entries)
		fz_throw(ctx, FZ_ERROR_ARGUMENT, "Out of range UI entry deselected");

	entry = &desc->ui[ui];
	if (entry->button_flags != PDF_LAYER_UI_RADIOBOX &&
		entry->button_flags != PDF_LAYER_UI_CHECKBOX)
		return;
	if (entry->locked)
		return;

	desc->ocgs[entry->ocg].state = 0;
}

void
pdf_layer_config_ui_info(fz_context *ctx, pdf_document *doc, int ui, pdf_layer_config_ui *info)
{
	pdf_ocg_descriptor *desc = pdf_read_ocg(ctx, doc);
	pdf_ocg_ui *entry;

	if (!info)
		return;

	info->depth = 0;
	info->locked = 0;
	info->selected = 0;
	info->text = NULL;
	info->type = 0;

	if (ui < 0 || ui >= desc->num_ui_entries)
		fz_throw(ctx, FZ_ERROR_ARGUMENT, "Out of range UI entry selected");

	entry = &desc->ui[ui];
	info->type = entry->button_flags;
	info->depth = entry->depth;
	info->selected = desc->ocgs[entry->ocg].state;
	info->locked = entry->locked;
	info->text = entry->name;
}

static int
ocg_intents_include(fz_context *ctx, pdf_ocg_descriptor *desc, const char *name)
{
	int i, len;

	if (strcmp(name, "All") == 0)
		return 1;

	/* In the absence of a specified intent, it's 'View' */
	if (!desc->intent)
		return (strcmp(name, "View") == 0);

	if (pdf_is_name(ctx, desc->intent))
	{
		const char *intent = pdf_to_name(ctx, desc->intent);
		if (strcmp(intent, "All") == 0)
			return 1;
		return (strcmp(intent, name) == 0);
	}
	if (!pdf_is_array(ctx, desc->intent))
		return 0;

	len = pdf_array_len(ctx, desc->intent);
	for (i=0; i < len; i++)
	{
		const char *intent = pdf_array_get_name(ctx, desc->intent, i);
		if (strcmp(intent, "All") == 0)
			return 1;
		if (strcmp(intent, name) == 0)
			return 1;
	}
	return 0;
}

static int
pdf_is_ocg_hidden_imp(fz_context *ctx, pdf_document *doc, pdf_obj *rdb, const char *usage, pdf_obj *ocg, pdf_cycle_list *cycle_up)
{
	pdf_cycle_list cycle;
	pdf_ocg_descriptor *desc = pdf_read_ocg(ctx, doc);
	pdf_obj *obj, *obj2, *type;
	char event_state[16];

	/* If no usage, everything is visible */
	if (!usage)
		return 0;

	/* If no ocg descriptor or no ocgs described, everything is visible */
	if (!desc || desc->len == 0)
		return 0;

	/* If we've been handed a name, look it up in the properties. */
	if (pdf_is_name(ctx, ocg))
	{
		ocg = pdf_dict_get(ctx, pdf_dict_get(ctx, rdb, PDF_NAME(Properties)), ocg);
	}
	/* If we haven't been given an ocg at all, then we're visible */
	if (!ocg)
		return 0;

	/* Avoid infinite recursions */
	if (pdf_cycle(ctx, &cycle, cycle_up, ocg))
		return 0;

	fz_strlcpy(event_state, usage, sizeof event_state);
	fz_strlcat(event_state, "State", sizeof event_state);

	type = pdf_dict_get(ctx, ocg, PDF_NAME(Type));

	if (pdf_name_eq(ctx, type, PDF_NAME(OCG)))
	{
		/* An Optional Content Group */
		int default_value = 0;
		int len = desc->len;
		int i;
		pdf_obj *es;

		/* by default an OCG is visible, unless it's explicitly hidden */
		for (i = 0; i < len; i++)
		{
			/* Deliberately do NOT resolve here. Bug 702261. */
			if (!pdf_objcmp(ctx, desc->ocgs[i].obj, ocg))
			{
				default_value = !desc->ocgs[i].state;
				break;
			}
		}

		/* Check Intents; if our intent is not part of the set given
		 * by the current config, we should ignore it. */
		obj = pdf_dict_get(ctx, ocg, PDF_NAME(Intent));
		if (pdf_is_name(ctx, obj))
		{
			/* If it doesn't match, it's hidden */
			if (ocg_intents_include(ctx, desc, pdf_to_name(ctx, obj)) == 0)
				return 1;
		}
		else if (pdf_is_array(ctx, obj))
		{
			int match = 0;
			len = pdf_array_len(ctx, obj);
			for (i=0; i<len; i++) {
				match |= ocg_intents_include(ctx, desc, pdf_array_get_name(ctx, obj, i));
				if (match)
					break;
			}
			/* If we don't match any, it's hidden */
			if (match == 0)
				return 1;
		}
		else
		{
			/* If it doesn't match, it's hidden */
			if (ocg_intents_include(ctx, desc, "View") == 0)
				return 1;
		}

		/* FIXME: Currently we do a very simple check whereby we look
		 * at the Usage object (an Optional Content Usage Dictionary)
		 * and check to see if the corresponding 'event' key is on
		 * or off.
		 *
		 * Really we should only look at Usage dictionaries that
		 * correspond to entries in the AS list in the OCG config.
		 * Given that we don't handle Zoom or User, or Language
		 * dicts, this is not really a problem. */
		obj = pdf_dict_get(ctx, ocg, PDF_NAME(Usage));
		if (!pdf_is_dict(ctx, obj))
			return default_value;
		/* FIXME: Should look at Zoom (and return hidden if out of
		 * max/min range) */
		/* FIXME: Could provide hooks to the caller to check if
		 * User is appropriate - if not return hidden. */
		obj2 = pdf_dict_gets(ctx, obj, usage);
		es = pdf_dict_gets(ctx, obj2, event_state);
		if (pdf_name_eq(ctx, es, PDF_NAME(OFF)))
			return 1;
		return default_value;
	}
	else if (pdf_name_eq(ctx, type, PDF_NAME(OCMD)))
	{
		/* An Optional Content Membership Dictionary */
		pdf_obj *name;
		int combine, on = 0;

		obj = pdf_dict_get(ctx, ocg, PDF_NAME(VE));
		if (pdf_is_array(ctx, obj)) {
			/* FIXME: Calculate visibility from array */
			return 0;
		}
		name = pdf_dict_get(ctx, ocg, PDF_NAME(P));
		/* Set combine; Bit 0 set => AND, Bit 1 set => true means
		 * Off, otherwise true means On */
		if (pdf_name_eq(ctx, name, PDF_NAME(AllOn)))
		{
			combine = 1;
		}
		else if (pdf_name_eq(ctx, name, PDF_NAME(AnyOff)))
		{
			combine = 2;
		}
		else if (pdf_name_eq(ctx, name, PDF_NAME(AllOff)))
		{
			combine = 3;
		}
		else /* Assume it's the default (AnyOn) */
		{
			combine = 0;
		}

		obj = pdf_dict_get(ctx, ocg, PDF_NAME(OCGs));
		on = combine & 1;
		if (pdf_is_array(ctx, obj)) {
			int i, len;
			len = pdf_array_len(ctx, obj);
			for (i = 0; i < len; i++)
			{
				int hidden = pdf_is_ocg_hidden_imp(ctx, doc, rdb, usage, pdf_array_get(ctx, obj, i), &cycle);
				if ((combine & 1) == 0)
					hidden = !hidden;
				if (combine & 2)
					on &= hidden;
				else
					on |= hidden;
			}
		}
		else
		{
			on = pdf_is_ocg_hidden_imp(ctx, doc, rdb, usage, obj, &cycle);
			if ((combine & 1) == 0)
				on = !on;
		}

		return !on;
	}
	/* No idea what sort of object this is - be visible */
	return 0;
}

int
pdf_is_ocg_hidden(fz_context *ctx, pdf_document *doc, pdf_obj *rdb, const char *usage, pdf_obj *ocg)
{
	return pdf_is_ocg_hidden_imp(ctx, doc, rdb, usage, ocg, NULL);
}

pdf_ocg_descriptor *
pdf_read_ocg(fz_context *ctx, pdf_document *doc)
{
	pdf_obj *prop, *ocgs, *configs;
	int len, i, num_configs;

	if (doc->ocg)
		return doc->ocg;

	fz_try(ctx)
	{
		prop = pdf_dict_get(ctx, pdf_dict_get(ctx, pdf_trailer(ctx, doc), PDF_NAME(Root)), PDF_NAME(OCProperties));

		configs = pdf_dict_get(ctx, prop, PDF_NAME(Configs));
		num_configs = pdf_array_len(ctx, configs);
		ocgs = pdf_dict_get(ctx, prop, PDF_NAME(OCGs));
		len = pdf_array_len(ctx, ocgs);

		doc->ocg = fz_malloc_struct(ctx, pdf_ocg_descriptor);
		doc->ocg->ocgs = fz_calloc(ctx, len, sizeof(*doc->ocg->ocgs));
		doc->ocg->len = len;
		doc->ocg->num_configs = num_configs;

		for (i = 0; i < len; i++)
		{
			pdf_obj *o = pdf_array_get(ctx, ocgs, i);
			doc->ocg->ocgs[i].obj = pdf_keep_obj(ctx, o);
			doc->ocg->ocgs[i].n = pdf_to_num(ctx, o);
			doc->ocg->ocgs[i].state = 1;
		}
		qsort(doc->ocg->ocgs, len, sizeof(doc->ocg->ocgs[0]), ocgcmp);

		pdf_select_layer_config(ctx, doc, 0);
	}
	fz_catch(ctx)
	{
		pdf_drop_ocg(ctx, doc);
		doc->ocg = NULL;
		fz_rethrow_if(ctx, FZ_ERROR_TRYLATER);
		fz_rethrow_if(ctx, FZ_ERROR_SYSTEM);
		fz_report_error(ctx);
		fz_warn(ctx, "Ignoring broken Optional Content configuration");
		doc->ocg = fz_malloc_struct(ctx, pdf_ocg_descriptor);
	}

	return doc->ocg;
}

void
pdf_set_layer_config_as_default(fz_context *ctx, pdf_document *doc)
{
	pdf_obj *ocprops, *d, *order, *on, *configs, *rbgroups;
	int k;

	ocprops = pdf_dict_getp(ctx, pdf_trailer(ctx, doc), "Root/OCProperties");
	if (!ocprops)
		return;

	/* All files with OCGs are required to have a D entry */
	d = pdf_dict_get(ctx, ocprops, PDF_NAME(D));
	if (d == NULL)
		return;

	pdf_dict_put(ctx, d, PDF_NAME(BaseState), PDF_NAME(OFF));

	/* We are about to delete RBGroups and Order, from D. These are
	 * both the underlying defaults for other configs, so copy the
	 * current values out to any config that doesn't have one
	 * already. */
	order = pdf_dict_get(ctx, d, PDF_NAME(Order));
	rbgroups = pdf_dict_get(ctx, d, PDF_NAME(RBGroups));
	configs = pdf_dict_get(ctx, ocprops, PDF_NAME(Configs));
	if (configs)
	{
		int len = pdf_array_len(ctx, configs);
		for (k=0; k < len; k++)
		{
			pdf_obj *config = pdf_array_get(ctx, configs, k);

			if (order && !pdf_dict_get(ctx, config, PDF_NAME(Order)))
				pdf_dict_put(ctx, config, PDF_NAME(Order), order);
			if (rbgroups && !pdf_dict_get(ctx, config, PDF_NAME(RBGroups)))
				pdf_dict_put(ctx, config, PDF_NAME(RBGroups), rbgroups);
		}
	}

	/* Offer all the layers in the UI */
	order = pdf_new_array(ctx, doc, 4);
	on = pdf_new_array(ctx, doc, 4);
	for (k = 0; k < doc->ocg->len; k++)
	{
		pdf_ocg_entry *s = &doc->ocg->ocgs[k];

		pdf_array_push(ctx, order, s->obj);
		if (s->state)
			pdf_array_push(ctx, on, s->obj);
	}
	pdf_dict_put(ctx, d, PDF_NAME(Order), order);
	pdf_dict_put(ctx, d, PDF_NAME(ON), on);
	pdf_dict_del(ctx, d, PDF_NAME(OFF));
	pdf_dict_del(ctx, d, PDF_NAME(AS));
	pdf_dict_put(ctx, d, PDF_NAME(Intent), PDF_NAME(View));
	pdf_dict_del(ctx, d, PDF_NAME(Name));
	pdf_dict_del(ctx, d, PDF_NAME(Creator));
	pdf_dict_del(ctx, d, PDF_NAME(RBGroups));
	pdf_dict_del(ctx, d, PDF_NAME(Locked));

	pdf_dict_del(ctx, ocprops, PDF_NAME(Configs));
}
