OptionalContent.cs

// ===========================================================================
//	©2013-2021 WebSupergoo. All rights reserved.
//
//	This source code is for use exclusively with the ABCpdf product under
//	the terms of the license for that product. Details can be found at
//
//		http://www.websupergoo.com/
//
//	This copyright notice must not be deleted and must be reproduced alongside
//	any sections of code extracted from this module.
// ===========================================================================

using System;
using System.Drawing;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
using System.Runtime;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Xml;
using System.Net;
using WebSupergoo.ABCpdf12;
using WebSupergoo.ABCpdf12.Objects;
using WebSupergoo.ABCpdf12.Operations;
using WebSupergoo.ABCpdf12.Atoms;


namespace OptionalContent {

	/// <summary>
	/// This class represents the Optional Content Properties Dictionary in a PDF document.
	/// This is the top level container of all Optional Content Groups (OCGs)
	/// in a document. OCGs are referenced at the top level in a global dictionary and their
	/// visibility states are held in a global configuration dictionary. These OCGs may then
	/// be referenced by one or more pages in the document. 
	/// Here we refer to OCGs simply as Groups.
	/// </summary>
	class Properties {
		/// <summary>
		/// Create a Properties object for the Doc.
		/// </summary>
		/// <param name="doc">The Doc on which to operate.</param>
		/// <param name="create">Whether to create a new properties entry if one is not already present.</param>
		/// <returns>The Properties object. This may be null if layers were not present in the document and the create parameter is false.</returns>
		public static Properties FromDoc(Doc doc, bool create) {
			Catalog catalog = doc.ObjectSoup.Catalog;
			Atom atom = catalog.Resolve(Atom.GetItem(catalog.Atom, "OCProperties"));
			if ((atom == null) && (create)) {
				int id = doc.AddObject("<< /OCGs [] /D << /BaseState /ON >> >>");
				IndirectObject io = doc.ObjectSoup[id];
				Atom.SetItem(catalog.Atom, "OCProperties", new RefAtom(io));
				atom = io.Atom;
			}
			if (atom == null)
				return null;
			return new Properties(catalog, atom);
		}

		private Catalog _catalog;
		private Atom _atom;

		private Properties(Catalog catalog, Atom atom) {
			_catalog = catalog;
			_atom = atom;
		}

		/// <summary>
		/// The Catalog from the Doc.
		/// </summary>
		public Catalog Catalog { get { return _catalog; } }

		/// <summary>
		/// Get the Groups for the Doc.
		/// </summary>
		/// <returns>A list of the Groups.</returns>
		public List<Group> GetGroups() {
			List<Group> list = new List<Group>();
			ArrayAtom array = EntryOCGs;
			if (array != null) {
				foreach (Atom item in array) {
					IndirectObject io = _catalog.ResolveObj(item);
					Group group = Group.FromIndirectObject(this, io);
					if (group != null)
						list.Add(group);
				}
			}
			return list;
		}

		/// <summary>
		/// Get the Optional Content Groups (OCGs) for the Page.
		/// </summary>
		/// <param name="page">The page from which OCGs should be found.</param>
		/// <returns>A list of the OCGs.</returns>
		public List<Group> GetGroups(Page page) {
			List<Group> list = new List<Group>();
			ISet<Atom> props = page.GetResourcesByType("Properties", true, true, true, true, null);
			foreach (Atom item in props) {
				IndirectObject io = page.ResolveObj(item);
				Group ocg = Group.FromIndirectObject(this, io);
				if (ocg != null) {
					list.Add(ocg);
					continue;
				}
				MembershipGroup mg = MembershipGroup.FromIndirectObject(this, io);
				if (mg != null) {
					foreach (var ocg2 in mg.PolicyGroups)
						list.Add(ocg2);
					continue;
				}
			}
			return list;
		}


		/// <summary>
		/// Sort Groups for presentation in a UI. Remove any Groups which should not appear in UI. 
		/// Construct a list of indents for those Groups that should be presented nested.
		/// </summary>
		/// <param name="groups">The OCGs to order.</param>
		/// <param name="indents">A list of indents to indicate nestedness.</param>
		public void SortGroupsForPresentation(List<Group> groups, List<int> indents) {
			Dictionary<int, Group> lookup = new Dictionary<int, Group>();
			foreach (Group group in groups)
				lookup[group.IndirectObject.ID] = group;
			groups.Clear();
			indents.Clear();
			Configuration config = GetDefault();
			ArrayAtom order = config != null ? config.EntryOrder : null;
			if (order == null)
				return;
			SortGroupsForPresentation(order, lookup, groups, indents, 0);
		}

		private void SortGroupsForPresentation(ArrayAtom order, Dictionary<int, Group> lookup, List<Group> groups, List<int> indents, int depth) {
			if (depth > 100)
				throw new Exception("OCG order nesting depth unfeasibly large.");
			foreach (Atom atom in order) {
				Atom resAtom = _catalog.Resolve(atom);
				if (resAtom is ArrayAtom) { // OCG group
					SortGroupsForPresentation((ArrayAtom)resAtom, lookup, groups, indents, depth + 1);
				}
				else if (resAtom is DictAtom) { // OCG
					RefAtom refAtom = _catalog.ResolveRef(atom);
					if (refAtom != null) {
						Group group = null;
						lookup.TryGetValue(refAtom.ID, out group);
						if (group != null) {
							groups.Add(group);
							indents.Add(depth);
						}
					}
				}
			}
		}

		/// <summary>
		/// Add a Group to the Doc.
		/// </summary>
		/// <param name="name">The name for the Group</param>
		/// <param name="parent">The parent for the Group to indicate nested visibility. This may be null if nested visibility is not required.</param>
		/// <returns>The newly added Group.</returns>
		public Group AddGroup(string name, Group parent) {
			Group ocg = Group.NewGroup(this);
			ocg.EntryName = new StringAtom(name);
			if (true) { // we need to list the ocg in the global database
				ArrayAtom array = EntryOCGs;
				if (array == null) {
					array = new ArrayAtom();
					EntryOCGs = array;
				}
				array.Add(new RefAtom(ocg.IndirectObject));
			}
			if (true) { // we also need to list it in the visible entries
				Configuration config = GetDefault();
				ArrayAtom array = config.EntryOrder;
				if (array == null) {
					array = new ArrayAtom();
					config.EntryOrder = array;
				}
				if (parent != null) {
					Tuple<ArrayAtom, int> entry = FindArrayEntry(parent.IndirectObject, array, 0);
					if (entry == null)
						throw new ArgumentException("Parent OCG not present in configuration dictionary.");
					array = entry.Item1;
					int index = entry.Item2;
					ArrayAtom next = index < array.Count - 1 ? _catalog.Resolve(array[index + 1]) as ArrayAtom : null;
					if (next == null) {
						next = new ArrayAtom();
						array.Insert(index + 1, next);
					}
					array = next;
				}
				array.Add(new RefAtom(ocg.IndirectObject));
			}
			return ocg;
		}

		/// <summary>
		/// Add a Membership Group to the Doc.
		/// </summary>
		/// <returns>The newly added Membership Group.</returns>
		public MembershipGroup AddMembershipGroup() {
			return MembershipGroup.New(this);
		}

		/// <summary>
		/// Get the default Configuration to indicate which layers are visible or invisible.
		/// </summary>
		/// <returns>The Configuration.</returns>
		public Configuration GetDefault() {
			Atom defaultConfig = EntryD;
			return defaultConfig != null ? Configuration.FromAtom(this, defaultConfig) : null;
		}

		/// <summary>
		/// Get the alternate Configurations that may be used to indicate which layers are visible or invisible.
		/// Alternate configurations are indended for use under different circumstances - they represent alternate
		/// views of the pages.
		/// </summary>
		/// <returns>A list of Configurations.</returns>
		public List<Configuration> GetConfigs() {
			List<Configuration> list = new List<Configuration>();
			ArrayAtom configs = EntryConfigs;
			if (configs != null) {
				foreach (Atom item in configs) {
					Configuration occd = Configuration.FromAtom(this, item);
					list.Add(occd);
				}
			}
			return list;
		}

		/// <summary>
		/// The Optional Content Properties Dictionary OCG entry.
		/// </summary>
		public ArrayAtom EntryOCGs {
			get { return _catalog.Resolve(Atom.GetItem(_atom, "OCGs")) as ArrayAtom; }
			set { Atom.SetItem(_atom, "OCGs", value); }
		}

		/// <summary>
		/// The Optional Content Properties Dictionary D entry.
		/// </summary>
		public DictAtom EntryD {
			get { return _catalog.Resolve(Atom.GetItem(_atom, "D")) as DictAtom; }
			set { Atom.SetItem(_atom, "D", value); }
		}

		/// <summary>
		/// The Optional Content Properties Dictionary Configs entry.
		/// </summary>
		public ArrayAtom EntryConfigs {
			get { return _catalog.Resolve(Atom.GetItem(_atom, "Configs")) as ArrayAtom; }
			set { Atom.SetItem(_atom, "Configs", value); }
		}

		private static Tuple<ArrayAtom, int> FindArrayEntry(IndirectObject io, ArrayAtom array, int depth) {
			if (depth > 100)
				return null;
			int n = array.Count;
			for (int i = 0; i < n; i++) {
				Atom atom = array[i];
				ArrayAtom subArray = io.Resolve(atom) as ArrayAtom;
				if (subArray != null) {
					Tuple<ArrayAtom, int> result = FindArrayEntry(io, subArray, depth + 1);
					if (result != null)
						return result;
				}
				else {
					RefAtom refAtom = io.ResolveRef(atom);
					if ((refAtom != null) && (refAtom.ID == io.ID))
						return new Tuple<ArrayAtom, int>(array, i);
				}
			}
			return null;
		}

		public static RefAtom MakeResourceIndirect(Page page, IndirectObject container, string resourceType, string resourceName, Atom resourceAtom, ref Atom cache) {
			RefAtom refAtom = container.ResolveRef(resourceAtom);
			if (refAtom == null) {
				if (cache == null)
					cache = GetResourceDict(page, container, resourceType, true);
				IndirectObject prop = new IndirectObject();
				prop.Atom = resourceAtom;
				container.Doc.ObjectSoup.Add(prop);
				refAtom = (RefAtom)Atom.SetItem(cache, resourceName, new RefAtom(prop));
			}
			return refAtom;
		}

		public static DictAtom GetResourceDict(Page page, IndirectObject container, string resourceType, bool create) {
			DictAtom dict = null;
			Atom resAtom = null;
			if (container is FormXObject) {
				resAtom = container.Resolve(Atom.GetItem(container.Atom, "Resources"));
				if (resAtom == null)
					resAtom = Atom.SetItem(container.Atom, "Resources", new DictAtom());
			}
			else {
				resAtom = container.Resolve(Atom.GetItem(page.Atom, "Resources"));
				Debug.Assert(resAtom  != null, "Page does not contain Resources.");
			}
			dict = container.Resolve(Atom.GetItem(resAtom, resourceType)) as DictAtom;
			if ((dict == null) && (create))
				dict = (DictAtom)Atom.SetItem(resAtom, resourceType, new DictAtom());
			return dict;
		}
	}

	/// <summary>
	/// This class represents an Optional Content Group (OCG) in a PDF document.
	/// An OCG is a layer-like object that may be visible or invisible. Items on the page
	/// may belong to one or more than one OCG. Only if all OCGs that they belong to are visible
	/// are the items visible. OCGs are held at the Doc level in a global dictionary
	/// and then referenced at a Page level.
	/// </summary>
	class Group {
		/// <summary>
		/// Create a new Group for the document.
		/// </summary>
		/// <param name="oc">The Properties object for the Doc.</param>
		/// <returns>The new Group.</returns>
		public static Group NewGroup(Properties oc) {
			IndirectObject io = IndirectObject.FromString("<< /Type /OCG /Name () >>");
			oc.Catalog.Doc.ObjectSoup.Add(io);
			return FromIndirectObject(oc, io);
		}

		/// <summary>
		/// Create a list of Groups from a list of atoms that reference Optional Content Groups (OCGs) already existing in the Doc.
		/// Only those atoms that reference OCGs will be included in the list. Other atoms will be ignored.
		/// </summary>
		/// <param name="oc">The Properties object for the Doc.</param>
		/// <param name="atoms">The list of atoms.</param>
		/// <returns>A list of Groups.</returns>
		public static List<Group> FromAtoms(Properties oc, IEnumerable<Atom> atoms) {
			List<Group> list = new List<Group>();
			foreach (Atom atom in atoms) {
				IndirectObject io = oc.Catalog.ResolveObj(atom);
				Group ocg = Group.FromIndirectObject(oc, io);
				if (ocg != null)
					list.Add(ocg);
			}
			return list;
		}

		/// <summary>
		/// Create a Group from an IndirectObject that already exists in the Doc.
		/// If the IndirectObject is not an Optional Content Group then null will be returned.
		/// </summary>
		/// <param name="oc">The Properties object for the Doc.</param>
		/// <param name="io">The IndirectObject.</param>
		/// <returns>The Group.</returns>
		public static Group FromIndirectObject(Properties oc, IndirectObject io) {
			if (io == null)
				return null;
			Group ocg = new Group(oc, io);
			return ocg.AllOk() ? ocg : null;
		}

		private Properties _oc;
		private IndirectObject _io;

		private Group(Properties oc, IndirectObject io) {
			_oc = oc;
			_io = io;
		}

		private bool AllOk() {
			// check type
			NameAtom type = _io.Resolve(Atom.GetItem(_io.Atom, "Type")) as NameAtom;
			if ((type == null) || (type.Text != "OCG"))
				return false; // malformed entry - corrupt PDF
			// The optional intent can be either a name or an array of names.
			// To keep things simple we always use the array form.
			Atom intent = _io.Resolve(Atom.GetItem(_io.Atom, "Intent"));
			if (intent is NameAtom) {
				ArrayAtom array = new ArrayAtom();
				array.Add(intent);
				Atom.SetItem(_io.Atom, "Intent", array);
				intent = array;
			}
			return true;
		}

		/// <summary>
		/// The IndirectObject representing the Group.
		/// </summary>
		public IndirectObject IndirectObject {
			get { return _io; }
		}

		/// <summary>
		/// Indicates whether the Group is visible or not.
		/// </summary>
		public bool Visible {
			get { return _oc.GetDefault().GetVisibility(true, this); }
			set { _oc.GetDefault().SetVisibility(value, this); }
		}

		/// <summary>
		/// Adds the Group to a page.
		/// </summary>
		/// <param name="page"></param>
		/// <returns></returns>
		public string AddToPage(Page page) {
			return page.AddResource(_io, "Properties", "OC" + _io.ID.ToString());
		}

		/// <summary>
		/// The Optional Content Group Dictionary Name entry.
		/// </summary>
		public StringAtom EntryName {
			get { return _io.Resolve(Atom.GetItem(_io.Atom, "Name")) as StringAtom; }
			set { Atom.SetItem(_io.Atom, "Name", value); }
		}

		/// <summary>
		/// The Optional Content Group Dictionary Intent entry.
		/// </summary>
		public ArrayAtom EntryIntent {
			get { return _io.Resolve(Atom.GetItem(_io.Atom, "Intent")) as ArrayAtom; }
			set { Atom.SetItem(_io.Atom, "Intent", value); }
		}

		/// <summary>
		/// The Optional Content Group Dictionary Usage entry.
		/// </summary>
		public DictAtom EntryUsage {
			get { return _io.Resolve(Atom.GetItem(_io.Atom, "Usage")) as DictAtom; }
			set { Atom.SetItem(_io.Atom, "Usage", value); }
		}
	}

	/// <summary>
	/// This class represents an Optional Content Membership Dictionary (OCMD) in a PDF document.
	/// This is a bit of a mouthful and doesn't actually express what it is, which is a
	/// kind of metagroup. It expresses visibility dependent on the visibility of a 
	/// set of groups rather than directly being switched on and off by itself. OCMDs are not
	/// referenced at the document level - only at a page level. However of course the OCMD references
	/// OCGs which are themselves referenced at a document level.
	/// Membership Groups may express visibility either using a Policy or using a Visibility Expression.
	/// Policies are simpler to implement but limited in scope. Visibility Expressions are more complex
	/// but also more powerful.
	/// OCGs always have to be IndirectObjects since they are referenced from more than one place.
	/// OCMGs do not have to be IndirectObject - they can be simple Atoms - since they are only referenced from
	/// the Resources of the Page. However to make things simple we convert them to IndiretObjects when we
	/// find them.
	/// </summary>
	class MembershipGroup {
		/// <summary>
		/// An enumeration representing the possibilities for a Policy based Membership Group.
		/// </summary>
		public enum PolicyEnum { AllOn, AnyOn, AllOff, AnyOff };

		/// <summary>
		/// An enumeration representing the possibilities for a Logic based Membership Group.
		/// </summary>
		public enum LogicEnum { And, Or, Not };

		/// <summary>
		/// Create a new Membership Group.
		/// </summary>
		/// <param name="oc">The Properties object for the Doc</param>
		/// <returns>The Membership Group</returns>
		public static MembershipGroup New(Properties oc) {
			IndirectObject io = IndirectObject.FromString("<< /Type /OCMD >>");
			oc.Catalog.Doc.ObjectSoup.Add(io);
			return FromIndirectObject(oc, io);
		}

		/// <summary>
		/// Create a list of Membership Groups from a list of atoms that reference Optional Content Membership Groups (OCMGs) already existing in the Doc.
		/// Only those atoms that reference OCMGs will be included in the list. Other atoms will be ignored.
		/// </summary>
		/// <param name="oc">The Properties object for the Doc.</param>
		/// <param name="atoms">The list of atoms.</param>
		/// <returns>A list of Membership Groups.</returns>
		public static List<MembershipGroup> FromAtoms(Properties oc, IEnumerable<Atom> atoms) {
			// Here we assume that all atoms passed in are references to an OCMG IndirectObject.
			// In our code this is always the case. However if you modify the code to take Atoms
			// read from another PDF then you need to tak account of the fact that OCMGs (unlike
			// OCGs) need not be IndirectObjects - they can be plain DictAtoms. If this is the case
			// you will need to use Properties.MakeResourceIndirect to convert these Atoms into
			// IndirectObjects.
			List<MembershipGroup> list = new List<MembershipGroup>();
			foreach (Atom atom in atoms) {
				IndirectObject io = oc.Catalog.ResolveObj(atom);
				MembershipGroup ocmg = MembershipGroup.FromIndirectObject(oc, io);
				if (ocmg != null)
					list.Add(ocmg);
			}
			return list;
		}

		/// <summary>
		/// Create a new Membership Group from an IndirectObject that already exists in the Doc.
		/// If the IndirectObject is not a Membership Group then null will be returned.
		/// </summary>
		/// <param name="oc">The Properties object for the Doc</param>
		/// <param name="io">The IndirectObject.</param>
		/// <returns>The Group.</returns>
		public static MembershipGroup FromIndirectObject(Properties oc, IndirectObject io) {
			if (io == null)
				return null;
			MembershipGroup ocm = new MembershipGroup(oc, io);
			return ocm.AllOk() ? ocm : null;
		}

		private Properties _oc;
		private IndirectObject _io;

		private MembershipGroup(Properties oc, IndirectObject io) {
			_oc = oc;
			_io = io;
		}

		private bool AllOk() {
			// check type
			NameAtom type = _io.Resolve(Atom.GetItem(_io.Atom, "Type")) as NameAtom;
			if ((type == null) || (type.Text != "OCMD"))
				return false; // malformed entry - corrupt PDF
			// The optional OCGs can be either a dict or an array of dicts.
			// To keep things simple we always use the array form.
			Atom ocgs = _io.Resolve(Atom.GetItem(_io.Atom, "OCGs"));
			if (ocgs is DictAtom) {
				ArrayAtom array = new ArrayAtom();
				array.Add(ocgs);
				Atom.SetItem(_io.Atom, "OCGs", array);
				ocgs = array;
			}
			return true;
		}

		/// <summary>
		/// The IndirectObject representing the Membership Group.
		/// </summary>
		public IndirectObject IndirectObject {
			get { return _io; }
		}

		/// <summary>
		/// Indicates whether the Membership Group is visible or not.
		/// </summary>
		public bool Visible {
			get { return EntryVE != null ? EvaluateVisibility(EntryVE, 0) : EvaluateVisibility(Policy, PolicyGroups); } 
		}

		private bool EvaluateVisibility(Atom ve, int depth) {
			if (depth > 100)
				return true;
			ve = _oc.Catalog.Resolve(ve);
			if (ve is ArrayAtom) {
				ArrayAtom array = (ArrayAtom)ve;
				int n = array.Count;
				string op = n > 0 ? Atom.GetName(_oc.Catalog.Resolve(Atom.GetItem(array, 0))) : "";
				if (op == LogicEnum.And.ToString()) {
					for(int i = 1; i < n; i++) {
						IndirectObject io = _oc.Catalog.ResolveObj(array[i]);
						if (io != null) {
							if (!EvaluateVisibility(io))
								return false;
						}
						else {
							if (!EvaluateVisibility(array[i], depth + 1))
								return false;
						}
					}
					return true;
				}
				else if (op == LogicEnum.Or.ToString()) {
					for(int i = 1; i < n; i++) {
						IndirectObject io = _oc.Catalog.ResolveObj(array[i]);
						if (io != null) {
							if (EvaluateVisibility(io))
								return true;
						}
						else {
							if (EvaluateVisibility(array[i], depth + 1))
								return true;
						}
					}
					return false;
				}
				else if ((op == LogicEnum.Not.ToString()) && (n > 1)) {
					IndirectObject io = _oc.Catalog.ResolveObj(array[1]);
					if (io != null)
						return !EvaluateVisibility(io);
					else
						return !EvaluateVisibility(array[1], depth + 1);
				} 
			}
			return true;
		}

		private bool EvaluateVisibility(PolicyEnum? policy, IEnumerable<Group> groups) {
			bool visible = true;
			if (policy == null)
				policy = PolicyEnum.AnyOn;
			if (groups == null)
				groups = new Group[0];
			if (policy == PolicyEnum.AnyOn) {
				visible = false;
				foreach (Group group in groups) {
					if (group.Visible) {
						visible = true;
						break;
					}
				}
			}
			else if (policy == PolicyEnum.AnyOff) {
				visible = false;
				foreach (Group group in groups) {
					if (!group.Visible) {
						visible = true;
						break;
					}
				}
			}
			else if (policy == PolicyEnum.AllOn) {
				visible = true;
				foreach (Group group in groups) {
					if (!group.Visible) {
						visible = false;
						break;
					}
				}
			}
			else if (policy == PolicyEnum.AllOff) {
				visible = true;
				foreach (Group group in groups) {
					if (group.Visible) {
						visible = false;
						break;
					}
				}
			}
			return visible;
		}

		private bool EvaluateVisibility(IndirectObject io) {
			Group group = Group.FromIndirectObject(_oc, io);
			return group != null ? group.Visible : true;
		}

		/// <summary>
		/// The Policy for the Membership Group. Null indicates that there is no Policy.
		/// </summary>
		public PolicyEnum? Policy {
			get { NameAtom a = EntryP; return a != null ? (PolicyEnum?)Enum.Parse(typeof(PolicyEnum), a.Text) : null; }
			set { EntryP = value.HasValue ? new NameAtom(value.ToString()) : null; }
		}

		/// <summary>
		/// The Groups on which the Policy will operate.
		/// </summary>
		public IEnumerable<Group> PolicyGroups {
			get {
				ArrayAtom array = EntryOCGs;
				return array != null ? Group.FromAtoms(_oc, EntryOCGs) : new List<Group>();
			}
			set {
				ArrayAtom array = new ArrayAtom();
				foreach (Group item in value)
					array.Add(new RefAtom(item.IndirectObject));
				EntryOCGs = array;
			}
		}

		/// <summary>
		/// Create a Visibility Expression showing how the visibility of a set of Groups should be combined.
		/// </summary>
		/// <param name="op">The logic operator used to combine the visibility.</param>
		/// <param name="groups">The set of Groups on which to operate. Visible Groups are true and invisible ones are false.</param>
		/// <returns>An ArrayAtom containing the Visibility Expression.</returns>
		public ArrayAtom MakeVisibilityExpression(LogicEnum op, IEnumerable<Group> groups) {
			ArrayAtom array = new ArrayAtom();
			array.Add(new NameAtom(op.ToString()));
			foreach (var group in groups)
				array.Add(new RefAtom(group.IndirectObject));
			return array;
		}

		/// <summary>
		/// Create a Visibility Expression showing how the visibility of a set of Visibility Expressions should be combined.
		/// </summary>
		/// <param name="op">The logic operator used to combine the visibility.</param>
		/// <param name="atoms">The set of groups on which to operate.</param>
		/// <returns>An ArrayAtom containing the Visibility Expression.</returns>
		public ArrayAtom MakeVisibilityExpression(LogicEnum op, IEnumerable<ArrayAtom> atoms) {
			ArrayAtom array = new ArrayAtom();
			array.Add(new NameAtom(op.ToString()));
			foreach (var atom in atoms)
				array.Add(atom);
			return array;
		}

		/// <summary>
		/// All the Groups on which the Membership Group depends.
		/// </summary>
		public IEnumerable<Atom> GetGroupReferences() {
			List<Atom> list = new List<Atom>();
			GetGroupReferences(EntryVE, list, 0);
			GetGroupReferences(EntryOCGs, list, 0);
			return list;
		}

		private IEnumerable<Atom> GetGroupReferences(ArrayAtom array, List<Atom> list, int depth) {
			if ((array == null) || (depth > 100))
				return list;
			foreach (Atom atom in array) {
				Atom item = _oc.Catalog.Resolve(atom);
				if (item is ArrayAtom)
					GetGroupReferences((ArrayAtom)item, list, depth + 1);
				else {
					RefAtom refAtom =_oc.Catalog.ResolveRef(atom);
					if (refAtom != null)
						list.Add(refAtom);
				}
			}
			return list;
		}

		/// <summary>
		/// Add the Membership Group to a Page.
		/// </summary>
		/// <param name="page">The Page to which this should be added.</param>
		/// <returns>The resource name used for this Membership Group.</returns>
		public string AddToPage(Page page) {
			return page.AddResource(_io, "Properties", "OC" + _io.ID.ToString());
		}

		/// <summary>
		/// The Optional Content Membership Dictionary OCGs entry.
		/// </summary>
		public ArrayAtom EntryOCGs { 
			get { return _io.Resolve(Atom.GetItem(_io.Atom, "OCGs")) as ArrayAtom; }
			set { Atom.SetItem(_io.Atom, "OCGs", value); }
		}

		/// <summary>
		/// The Optional Content Membership Dictionary P entry.
		/// </summary>
		public NameAtom EntryP {
			get { return _io.Resolve(Atom.GetItem(_io.Atom, "P")) as NameAtom; }
			set { Atom.SetItem(_io.Atom, "P", value); }
		}

		/// <summary>
		/// The Optional Content Membership Dictionary VE entry.
		/// </summary>
		public ArrayAtom EntryVE {
			get { return _io.Resolve(Atom.GetItem(_io.Atom, "VE")) as ArrayAtom; }
			set { Atom.SetItem(_io.Atom, "VE", value); }
		}
	}

	/// <summary>
	/// This class represents an Optional Content Configuration Dictionary (OCCD) in a PDF document.
	/// An OCCD expresses the visibility of the Groups in the document and also how they should be
	/// presented in a User Interface (UI).
	/// </summary>
	class Configuration {
		/// <summary>
		/// Create a Configuration from an Optional Content Configuration Dictionary (OCCD) Atom already existing in the Doc.
		/// If the Atom is not an OCCD then null will be returned.
		/// </summary>
		/// <param name="oc">The Properties object for the Doc.</param>
		/// <param name="atom">The Atom.</param>
		/// <returns>The Configuration.</returns>
		public static Configuration FromAtom(Properties oc, Atom atom) {
			if ((atom == null) || (oc == null))
				return null;
			return new Configuration(oc, atom);
		}

		private Properties _oc;
		private Atom _atom;

		private Configuration(Properties oc, Atom atom) {
			_oc = oc;
			_atom = atom;
		}

		/// <summary>
		/// The Atom representing the Membership Group.
		/// </summary>
		public Atom Atom {
			get { return _atom; }
		}

		private enum Visibility { On, Off, Unchanged };

		/// <summary>
		/// Evaluate the visibility of the Group.
		/// </summary>
		/// <param name="isDefault">Whether this is the default configuration.</param>
		/// <param name="layer">The Group for which visibility should be evaluated.</param>
		/// <returns>Whether visible.</returns>
		public bool GetVisibility(bool isDefault, Group layer) {
			Visibility visibility =  Visibility.On;
			NameAtom baseState = isDefault ? null : EntryBaseState;
			if (baseState != null) {
				switch (baseState.Text) {
					case "OFF": visibility = Visibility.Off; break;
					case "Unchanged": visibility = Visibility.Unchanged; break;
				}
			}
			if (visibility != Visibility.On) {
				ArrayAtom array = EntryON;
				if (array != null) {
					foreach (Atom item in array) {
						IndirectObject io = _oc.Catalog.ResolveObj(item);
						if ((io != null) && (io.ID == layer.IndirectObject.ID)) {
							visibility = Visibility.On;
							break;
						}
					}
				}
			}
			else if (visibility != Visibility.Off) {
				ArrayAtom array = EntryOFF;
				if (array != null) {
					foreach (Atom item in array) {
						IndirectObject io = _oc.Catalog.ResolveObj(item);
						if ((io != null) && (io.ID == layer.IndirectObject.ID)) {
							visibility = Visibility.Off;
							break;
						}
					}
				}
			}
			return visibility != Visibility.Off;
		}

		/// <summary>
		/// Set the visibility of a Group.
		/// </summary>
		/// <param name="visible">Whether the Group should be visible.</param>
		/// <param name="layer">The Group for which visibility should be evaluated.</param>
		public void SetVisibility(bool visible, Group layer) {
			RemoveEntries(EntryOFF, layer.IndirectObject.ID);
			RemoveEntries(EntryON, layer.IndirectObject.ID);
			if (visible) {
				if (EntryON == null)
					EntryON = new ArrayAtom();
				EntryON.Add(new RefAtom(layer.IndirectObject));
			}
			else {
				if (EntryOFF == null)
					EntryOFF = new ArrayAtom();
				EntryOFF.Add(new RefAtom(layer.IndirectObject));
			}
			//layer.IndirectObject.Atom = layer.IndirectObject.Atom.Clone();
		}

		private void RemoveEntries(ArrayAtom array, int id) {
			int n = array != null ? array.Count : 0;
			for (int i = 0; i < n; i++) {
				IndirectObject item = _oc.Catalog.ResolveObj(array[i]);
				if ((item != null) && (item.ID == id)) {
					array.RemoveAt(i);
					i--;
					n--;
				}
			}
		}

		/// <summary>
		/// The Optional Content Configuration Dictionary Name entry.
		/// </summary>		
		public StringAtom EntryName {
			get { return _oc.Catalog.Resolve(Atom.GetItem(_atom, "Name")) as StringAtom; }
			set { Atom.SetItem(_atom, "Name", value); }
		}

		/// <summary>
		/// The Optional Content Configuration Dictionary Creator entry.
		/// </summary>		
		public StringAtom EntryCreator {
			get { return _oc.Catalog.Resolve(Atom.GetItem(_atom, "Creator")) as StringAtom; }
			set { Atom.SetItem(_atom, "Creator", value); }
		}

		/// <summary>
		/// The Optional Content Configuration Dictionary BaseState entry.
		/// </summary>		
		public NameAtom EntryBaseState {
			get { return _oc.Catalog.Resolve(Atom.GetItem(_atom, "BaseState")) as NameAtom; }
			set { Atom.SetItem(_atom, "BaseState", value); }
		}

		/// <summary>
		/// The Optional Content Configuration Dictionary ON entry.
		/// </summary>		
		public ArrayAtom EntryON {
			get { return _oc.Catalog.Resolve(Atom.GetItem(_atom, "ON")) as ArrayAtom; }
			set { Atom.SetItem(_atom, "ON", value); }
		}

		/// <summary>
		/// The Optional Content Configuration Dictionary OFF entry.
		/// </summary>		
		public ArrayAtom EntryOFF {
			get { return _oc.Catalog.Resolve(Atom.GetItem(_atom, "OFF")) as ArrayAtom; }
			set { Atom.SetItem(_atom, "OFF", value); }
		}

		/// <summary>
		/// The Optional Content Configuration Dictionary Order entry.
		/// </summary>		
		public ArrayAtom EntryOrder {
			get { return _oc.Catalog.Resolve(Atom.GetItem(_atom, "Order")) as ArrayAtom; }
			set { Atom.SetItem(_atom, "Order", value); }
		}	
	}

	/// <summary>
	/// Class for evaluating which parts of a page are visible and which parts are members
	/// of which Optional Content Groups or Membership dictionaries. Includes facilities
	/// for redacting elements that are invisible.
	/// </summary>
	class Reader {
		/// <summary>
		/// Create a Reader for a particular Page.
		/// </summary>
		/// <param name="oc">The Properties object for the Doc.</param>
		/// <param name="page">The page to operate on.</param>
		/// <returns></returns>
		public static Reader FromPage(Properties oc, Page page) {
			Reader content = new Reader(oc, page);
			return content.AllOk() ? content : null;
		}

		[DebuggerDisplay("\\{ Offset = {Offset} Length = {Length} Command = {Command} \\}")]
		private class Op : IComparable {
			public Op(int offset, int length, string command, string textWidth) {
				Offset = offset;
				Length = length;
				Command = command;
				TextWidth = textWidth;
			}
			public int CompareTo(Object obj) {
				return this.Offset - ((Op)obj).Offset;
			}
			public int Offset;
			public int Length;
			public string Command;
			public string TextWidth;
		}

		private Properties _oc;
		private Page _page;
		private Dictionary<int, List<Op>> _ops;
		private Dictionary<int, Dictionary<int, Atom[]>> _states; // first int is stream ID, second is position in stream
		private Dictionary<int, IDictionary<string, Atom>> _rezMap;
		private Dictionary<int, List<int>> _lookups; // fast lookup list

		private Reader() {
			Debug.Assert(false);
		}

		private Reader(Properties oc, Page page) {
			_oc = oc;
			_page = page;
			_ops = null;
			_states = null;
			_rezMap = null;
			_lookups = null;
		}

		private bool AllOk() {
			_page.DeInline(true);
			_page.Flatten(true, false);
			// Theoretically a FormXObject could have different visibilty
			// at different times it is drawn. So you should really call 
			// _page.StampFormXObjects(true) to separate them all out. However
			// this might have quite an impact on size and it seems unlikely
			// so we don't currently do this.
			ScanPage(_page.GetText(Page.TextType.SvgPlus2, true));
			return true;
		}

		private void ScanPage(string svg) {
			_ops = new Dictionary<int, List<Op>>();
			_states = new Dictionary<int, Dictionary<int, Atom[]>>();
			_rezMap = new Dictionary<int, IDictionary<string, Atom>>();
			_lookups = new Dictionary<int, List<int>>();
			Stack<Atom> names = new Stack<Atom>();
			Stack<int> depths = new Stack<int>();
			depths.Push(0);

			using (StringReader reader = new StringReader(svg)) {
				for (string item; (item = reader.ReadLine()) != null; ) {
					if (item.StartsWith("<", StringComparison.InvariantCultureIgnoreCase)) {
						// get object ID
						string pdf_Op = GetAttribute(item, "pdf_Op");
						string op = WebUtility.HtmlDecode(pdf_Op);
						if (op == null)
							continue;
						int streamID = Int32.Parse(GetAttribute(item, "pdf_StreamID"));
						int streamOffset = Int32.Parse(GetAttribute(item, "pdf_StreamOffset"));
						int streamLength = Int32.Parse(GetAttribute(item, "pdf_StreamLength"));
						string textWidth = GetAttribute(item, "pdf_w1000");
						List<Op> ops = GetOpsFromStreamID(streamID);
						// FormXObjects may be drawn multiple times on page. Don't need to keep
						// track of all the times this happens. Once is enough.
						if ((ops.Count == 0) || (ops[ops.Count - 1].Offset < streamOffset))
							ops.Add(new Op(streamOffset, streamLength, op, textWidth));
						bool isBDC = (op.EndsWith("BDC"));
						bool isBMC = (op.EndsWith("BMC"));
						bool isEMC = (op.EndsWith("EMC"));
						if (isBDC || isBMC || isEMC) {
							if (isBDC) {
								ArrayAtom array = (ArrayAtom)Atom.FromString("[" + op + "]");
								NameAtom type = array.Count > 0 ? (NameAtom)array[0] : null; // this must be a NameAtom
								NameAtom name = array.Count > 1 ? array[1] as NameAtom : null; // this may be NameAtom or DictAtom but if OC, NameAtom only
								if ((type != null) && (name != null) && (type.Text == "OC")) { // optional content
									depths.Push(0);
									IDictionary<string, Atom> map = GetResourceMapFromStreamID(streamID);
									names.Push(map[name.Text]);
									Dictionary<int, Atom[]> state = GetStateFromStreamID(streamID);
									state.Add(streamOffset, names.Count > 0 ? names.ToArray() : new Atom[0]);
								}
								else { // some other kind of marked content
									depths.Push(depths.Pop() + 1);
								}
							}
							else if (isBMC) { // some other kind of marked content
								depths.Push(depths.Pop() + 1);
							}
							else if (isEMC) {
								if (depths.Peek() == 0) {
									names.Pop(); // exception here indicates too many EMC without corresponding BDC
									Dictionary<int, Atom[]> state = GetStateFromStreamID(streamID);
									state.Add(streamOffset, names.Count > 0 ? names.ToArray() : new Atom[0]);
									depths.Pop();
								}
								else {
									depths.Push(depths.Pop() - 1);
								}
							}
						}
					}
				}
			}
		}

		/// <summary>
		/// Get all the Layers referenced on the current page.
		/// </summary>
		/// <returns>A list of Layers.</returns>
		public List<Layer> GetLayers() {
			HashSet<Atom> set = new HashSet<Atom>();
			foreach (KeyValuePair<int, Dictionary<int, Atom[]>> state1 in _states) {
				foreach (KeyValuePair<int, Atom[]> state2 in state1.Value) {
					foreach (Atom atom in state2.Value) {
						set.Add(atom);
					}
				}
			}
			List<Layer> list = new List<Layer>();
			foreach (Atom atom in set) {
				IndirectObject io = _oc.Catalog.ResolveObj(atom);
				Group group = Group.FromIndirectObject(_oc, io);
				if (group != null) {
					list.Add(new Layer(group, null));
					continue;
				}
				MembershipGroup membershipGroup = MembershipGroup.FromIndirectObject(_oc, io);
				if (membershipGroup != null) {
					list.Add(new Layer(membershipGroup, null));
					continue;
				}
			}
			return list;
		}

		/// <summary>
		/// Get the Groups active at a particular point in a particular content stream.
		/// You can use this to establish the visibility of a PDF operator at a particular
		/// point in a stream.
		/// </summary>
		/// <param name="streamID">The ID of the StreamObject.</param>
		/// <param name="position">The offset in the stream.</param>
		/// <returns>A list of Layers</returns>
		public List<Layer> GetLayersFromStreamAndPosition(int streamID, int position) {
			List<Layer> list = new List<Layer>();
			Atom[] atoms = GetStateFromStreamAndPosition(streamID, position);
			foreach (Group group in Group.FromAtoms(_oc, atoms))
				list.Add(new Layer(group, null));
			foreach (MembershipGroup group in MembershipGroup.FromAtoms(_oc, atoms))
				list.Add(new Layer(group, null));
			return list;
		}

		/// <summary>
		/// Delete all content associated with the specified Group. After this the Reader will
		/// no longer be valid and will need to be recreated if further operations are required.
		/// </summary>
		/// <param name="reader">The reader. This will be set to null on exit to ensure that an invalid reader is not used.</param>
		/// <param name="layer">The Layer whos content should be deleted.</param>
		static public void Redact(ref Reader reader, Layer layer) {
			HashSet<Atom> kept = reader.Redact(layer);
			reader.RemoveResources(kept);
			reader = null; // invalid
		}

		private HashSet<Atom> Redact(Layer layer) {
			HashSet<Atom> kept = new HashSet<Atom>();
			foreach (KeyValuePair<int, Dictionary<int, Atom[]>> pair in _states) {
				List<Op> ops = _ops[pair.Key];
				Dictionary<int, Atom[]> state = GetStateFromStreamID(pair.Key);
				List<int> lookup = GetLookupFromStreamID(pair.Key);
				int n = lookup.Count, pos = 0;
				bool keeping = true;
				for (int i = 0; i < n; i++) {
					bool match = false;
					Atom[] ocs = state[lookup[i]]; // OCMG or OCMD
					foreach (Atom atom in ocs) {
						IndirectObject io = _page.ResolveObj(atom);
						if (io.ID == layer.IndirectObject.ID) {
							match = true;
							break;
						}
					}
					if (!match)// keep track of the ones left
						foreach (Atom atom in ocs)
							kept.Add(_oc.Catalog.Resolve(atom));
					if (match && keeping) {
						pos = lookup[i];
						keeping = false;
					}
					else if (!match && !keeping) {
						Redact(ops, pos, lookup[i]);
						keeping = true;
					}
				}
				if ((!keeping) && (ops.Count > 0)) // flush
					Redact(ops, pos, ops[ops.Count - 1].Offset + 1);
				StringBuilder sb = new StringBuilder();
				foreach (Op op in ops)
					sb.AppendLine(op.Command);
				StreamObject so = (StreamObject)_page.Doc.ObjectSoup[pair.Key];
				so.ClearData();
				so.SetText(sb.ToString());
				so.CompressFlate();
			}
			_states = null; // invalid
			_lookups = null; // invalid
			return kept;
		}

		private void RemoveResources(HashSet<Atom> kept) {
			foreach (KeyValuePair<int, IDictionary<string, Atom>> pair1 in _rezMap) {
				foreach (KeyValuePair<string, Atom> pair2 in pair1.Value) {
					Atom atom = _oc.Catalog.Resolve(pair2.Value);
					if (!kept.Contains(atom)) {
						IndirectObject resObj = _oc.Catalog.Doc.ObjectSoup[pair1.Key];
						DictAtom dict = Properties.GetResourceDict(_page, resObj, "Properties", false);
						Atom.RemoveItem(dict, pair2.Key);
					}
				}
			}
		}

		private void Redact(List<Op> ops, int pos1, int pos2) {
			HashSet<string> cmdMakePath = new HashSet<string>(new string[] { "m", "l", "c", "v", "y", "h", "re" });
			HashSet<string> cmdPaintPath = new HashSet<string>(new string[] { "S", "s", "F", "f", "f*", "B", "B*", "b", "b*" });
			HashSet<string> cmdClipPath = new HashSet<string>(new string[] { "W" }); // ignore "n"
			HashSet<string> cmdShow = new HashSet<string>(new string[] { "Do", "sh" });
			int depth = 0;
			Stack<int> depths = new Stack<int>();
			List<int> paints = new List<int>();
			// there should always be an exact match for the binary search
			int start = ops.BinarySearch(new Op(pos1, 0, null, null));
			int n = ops.Count;
			for (int i = start; i < n; i++) {
				Op op = ops[i];
				Debug.Assert((i != start) || (op.Command.EndsWith("BDC")));
				if (op.Offset > pos2)
					break;
				Debug.Assert(!((i == n - 1) || (ops[i + 1].Offset > pos2)) || (op.Command == "EMC"));
				string cmd = op.Command.TrimEnd();
				int p = cmd.Length - 1;
				while (p >= 0) {
					if ((char.IsWhiteSpace(cmd[p])) || (cmd[p] == ')') || (cmd[p] == ']') || (cmd[p] == '>')) {
						cmd = cmd.Substring(p + 1);
						break;
					}
					p--;
				}
				// here we remove any displayed content
				if (cmdShow.Contains(cmd))
					op.Command = "";
				// here we remove any path painting but keep clipping
				else if (cmdMakePath.Contains(cmd)) {
					paints.Add(i);
				}
				else if (cmdPaintPath.Contains(cmd)) {
					op.Command = "n"; // needed because of bugs in Acrobat
					foreach (int j in paints)
						ops[j].Command = "";
					paints.Clear();
				}
				else if (cmdClipPath.Contains(cmd)) {
					paints.Clear();
				}
				// here we remove the BDC / EMC entries
				else if (cmd == "BMC") {
					depth++;
				}
				else if (cmd == "BDC") {
					if (op.Command.StartsWith("/OC")) {
						op.Command = "";
						depths.Push(depth);
					}
					depth++;
				}
				else if (cmd == "EMC") {
					depth--;
					if (depths.Peek() == depth) {
						op.Command = "";
						depths.Pop();
					}
				}
				// here we remove the text showing commands but in a way that preserves
				// the offset of the text position albeit with invisible text
				else if ((cmd == "TJ") || (cmd == "Tj"))
					op.Command = "[" + op.TextWidth + "] TJ";
				else if (cmd == "\'")
					op.Command = "T* [" + op.TextWidth + "] TJ";
				else if (cmd == "\"") {
					int p1 = 0, p2 = 0;
					while (p1 < op.Command.Length - 1) {
						if (!char.IsWhiteSpace(op.Command[p1]))
							break;
						p1++;
					}
					while (p1 < op.Command.Length - 1) {
						if (char.IsWhiteSpace(op.Command[p1]))
							break;
						p1++;
					}
					p2 = p1;
					while (p2 < op.Command.Length - 1) {
						if (!char.IsWhiteSpace(op.Command[p2]))
							break;
						p2++;
					}
					while (p2 < op.Command.Length - 1) {
						if (char.IsWhiteSpace(op.Command[p2]))
							break;
						p2++;
					}
					string tw = p1 > 0 ? op.Command.Substring(0, p1) : "0";
					string tc = p2 > p1 ? op.Command.Substring(p1, p2 - p1) : "0";
					op.Command = tw + " Tw " + tc + " Tc T* [" + op.TextWidth + "] TJ";
				}
			}
		}

		private Atom[] GetStateFromStreamAndPosition(int streamID, int position) {
			Dictionary<int, Atom[]> state = GetStateFromStreamID(streamID);
			List<int> lookup = GetLookupFromStreamID(streamID);
			int pos = lookup.BinarySearch(position);
			if (pos >= 0) { // exact match
				return state[lookup[pos]];
			}
			else { // exact key not found
				pos = ~pos; // Bitwise complement of the first index in the list larger than the target.
				// But we want the one before that - so move back one. For that reason we shouldn't need to pin the top
				if (pos == 0) // no state
					return new Atom[0];
				pos = pos >= 0 ? pos - 1 : pos;
				return state[lookup[pos]];
			}
		}

		private static string GetAttribute(string item, string name) {
			int p1 = item.IndexOf(name);
			if (p1 < 0) return null;
			p1 = item.IndexOf('=', p1) + 1;
			if (p1 < 0) return null;
			p1 = item.IndexOf('\"', p1) + 1;
			if (p1 < 0) return null;
			int p2 = item.IndexOf('\"', p1);
			if (p2 < 0) return null;
			string attr = item.Substring(p1, p2 - p1);
			return attr;
		}

		private List<Op> GetOpsFromStreamID(int streamID) {
			List<Op> op = null;
			_ops.TryGetValue(streamID, out op);
			if (op == null) {
				op = new List<Op>();
				_ops[streamID] = op;
			}
			return op;
		}

		private Dictionary<int, Atom[]> GetStateFromStreamID(int streamID) {
			Dictionary<int, Atom[]> state = null;
			_states.TryGetValue(streamID, out state);
			if (state == null) {
				state = new Dictionary<int, Atom[]>();
				_states[streamID] = state;
			}
			return state;
		}

		private IDictionary<string, Atom> GetResourceMapFromStreamID(int streamID) {
			IDictionary<string, Atom> map = null;
			_rezMap.TryGetValue(streamID, out map);
			if (map == null) {
				IndirectObject io = _page.Doc.ObjectSoup[streamID];
				int id = io is FormXObject ? streamID : _page.ID;
				map = _page.GetResourceMap(id, "Properties");
				Atom cache = null; // Convert OCMD Atoms to IndirectObjects where necessary
				List<string> keys = new List<string>(map.Keys);
				foreach (string key in keys) {
					Atom atom = map[key];
					if (_oc.Catalog.ResolveRef(atom) == null) {
						RefAtom refAtom = Properties.MakeResourceIndirect(_page, io, "Properties", key, atom, ref cache);
						map[key] = refAtom;
					}
				}
				_rezMap[streamID] = map;
			}
			return map;
		}

		private List<int> GetLookupFromStreamID(int streamID) {
			List<int> lookup = null;
			_lookups.TryGetValue(streamID, out lookup);
			if (lookup == null) {
				Dictionary<int, Atom[]> state = GetStateFromStreamID(streamID);
				lookup = new List<int>(state.Keys);
				lookup.Sort();
				_lookups[streamID] = lookup;
			}
			return lookup;
		}
	}

	/// <summary>
	/// Class to represent a Layer on the page. A Layer represents a reference to a visibility
	/// object from within a Page. The visibilty object may be either a Group or
	/// on a Membership Group.
	/// </summary>
	class Layer {
		private Layer() { ResourceName = ""; }

		/// <summary>
		/// Create a Layer object from a Group.
		/// </summary>
		/// <param name="group">The Group.</param>
		/// <param name="name">The resource name for the Group.</param>
		public Layer(Group group, string name) { Group = group; ResourceName = name; }

		/// <summary>
		/// Create a Layer object from a Membership Group.
		/// </summary>
		/// <param name="group">The Membership Group.</param>
		/// <param name="name">The resource name for the Membership Group.</param>
		public Layer(MembershipGroup group, string name) { MembershipGroup = group; ResourceName = name; }

		/// <summary>
		/// The Group. Either this or the MembershipGroup property will be null. Only one can be populated.
		/// </summary>
		public Group Group { get; set; }

		/// <summary>
		/// The Membership Group. Either this or the Group property will be null. Only one can be populated.
		/// </summary>
		public MembershipGroup MembershipGroup { get; set; }

		/// <summary>
		/// The resource name used for this object.
		/// </summary>
		public string ResourceName { get; set; }

		/// <summary>
		/// The IndirectObject for this Layer.
		/// </summary>
		public IndirectObject IndirectObject { get { return Group != null ? Group.IndirectObject : (MembershipGroup != null ? MembershipGroup.IndirectObject : null); } }

		/// <summary>
		/// Indicates whether the Group is visible or not.
		/// </summary>
		public bool Visible { get { return Group != null ? Group.Visible : (MembershipGroup != null ? MembershipGroup.Visible : true); } }
	}
	
	/// <summary>
	/// Class for creating layers on a Page.
	/// </summary>
	class Writer {
		private Properties _oc;
		private Page _page;
		private int _depth = 0;

		private Writer() {
			Debug.Assert(false);
		}

		/// <summary>
		/// Create a new Writer for the Page.
		/// </summary>
		/// <param name="oc">The Properties object for the Doc.</param>
		/// <param name="page">The Page on which to operate.</param>
		public Writer(Properties oc, Page page) {
			_oc = oc;
			_page = page;
		}

		~Writer() {
			Debug.Assert(_depth == 0, "Unbalanced StartLayer and EndLayer calls.");
		}

		/// <summary>
		/// The depth of nested calls to StartLayer and EndLayer.
		/// </summary>
		public int Depth { get { return _depth; } }

		/// <summary>
		/// Add a reference to a Group for the current Page.
		/// </summary>
		/// <param name="group">The Group for which a reference should be added.</param>
		/// <returns>The Layer.</returns>
		public Layer AddGroup(Group group) {
			string resource = group.AddToPage(_page);
			return new Layer(group, resource);
		}

		/// <summary>
		/// Add a reference to a Membership Group for the current Page.
		/// </summary>
		/// <param name="group">The Membership Group for which a reference should be added.</param>
		/// <returns>The Layer.</returns>
		public Layer AddGroup(MembershipGroup group) {
			string resource = group.AddToPage(_page);
			return new Layer(group, resource);
		}

		/// <summary>
		/// Start writing content for a particular layer. Calls to StartLayer may be nested
		/// but each call to StartLayer must be balanced by a corresponding call to EndLayer.
		/// </summary>
		/// <param name="layer">The Layer to start.</param>
		public void StartLayer(Layer layer) {
			_page.AddLayer(MakeLayerStart(_page, layer.ResourceName));
			_depth++;
		}

		/// <summary>
		/// End writing content for a particular layer. Calls to StartLayer may be nested
		/// but each call to StartLayer must be balanced by a corresponding call to EndLayer.
		/// </summary>
		public void EndLayer() {
			_page.AddLayer(MakeLayerEnd(_page));
			_depth--;
		}

		private static StreamObject MakeLayerStart(Page page, string name) {
			byte[] data = ASCIIEncoding.UTF7.GetBytes("/OC /" + name + " BDC\r\n");
			return new StreamObject(page.Doc.ObjectSoup, data);
		}

		private static StreamObject MakeLayerEnd(Page page) {
			byte[] data = ASCIIEncoding.UTF7.GetBytes("EMC\r\n");
			return new StreamObject(page.Doc.ObjectSoup, data);
		}
	}
}