private void CreateNumTree()
{
if (numTree != null)
{
return;
}
numTree = new Dictionary <int, PdfIndirectReference>();
foreach (int i in parentTree.Keys)
{
PdfObject obj = parentTree[i];
if (obj.IsArray())
{
PdfArray ar = (PdfArray)obj;
numTree[i] = writer.AddToBody(ar).IndirectReference;
}
else if (obj is PdfIndirectReference)
{
numTree[i] = (PdfIndirectReference)obj;
}
}
}
private void Init(PdfDictionary parent, PdfName structureType)
{
PdfObject kido = parent.Get(PdfName.K);
PdfArray kids = null;
if (kido != null && !kido.IsArray())
{
throw new ArgumentException(MessageLocalization.GetComposedMessage("the.parent.has.already.another.function"));
}
if (kido == null)
{
kids = new PdfArray();
parent.Put(PdfName.K, kids);
}
else
{
kids = (PdfArray)kido;
}
kids.Add(this);
Put(PdfName.S, structureType);
reference = top.Writer.PdfIndirectReference;
}
private void Init(PdfDictionary parent, PdfName structureType)
{
PdfObject kido = parent.Get(PdfName.K);
PdfArray kids = null;
if (kido != null && !kido.IsArray())
{
throw new ArgumentException("The parent has already another function.");
}
if (kido == null)
{
kids = new PdfArray();
parent.Put(PdfName.K, kids);
}
else
{
kids = (PdfArray)kido;
}
kids.Add(this);
Put(PdfName.S, structureType);
reference = top.Writer.PdfIndirectReference;
}
/**
* A constructor from a <CODE>PdfReader</CODE>. It basically does everything
* from finding the XFA stream to the XML parsing.
* @param reader the reader
* @throws java.io.IOException on error
* @throws javax.xml.parsers.ParserConfigurationException on error
* @throws org.xml.sax.SAXException on error
*/
public XfaForm(PdfReader reader)
{
this.reader = reader;
PdfObject xfa = GetXfaObject(reader);
if (xfa == null)
{
xfaPresent = false;
return;
}
xfaPresent = true;
MemoryStream bout = new MemoryStream();
if (xfa.IsArray())
{
PdfArray ar = (PdfArray)xfa;
for (int k = 1; k < ar.Size; k += 2)
{
PdfObject ob = ar.GetDirectObject(k);
if (ob is PRStream)
{
byte[] b = PdfReader.GetStreamBytes((PRStream)ob);
bout.Write(b, 0, b.Length);
}
}
}
else if (xfa is PRStream)
{
byte[] b = PdfReader.GetStreamBytes((PRStream)xfa);
bout.Write(b, 0, b.Length);
}
bout.Seek(0, SeekOrigin.Begin);
XmlTextReader xtr = new XmlTextReader(bout);
domDocument = new XmlDocument();
domDocument.PreserveWhitespace = true;
domDocument.Load(xtr);
ExtractNodes();
}
/**
* Sets the XFA key from a byte array. The old XFA is erased.
* @param form the data
* @param reader the reader
* @param writer the writer
* @throws java.io.IOException on error
*/
public static void SetXfa(XfaForm form, PdfReader reader, PdfWriter writer) {
PdfDictionary af = (PdfDictionary)PdfReader.GetPdfObjectRelease(reader.Catalog.Get(PdfName.ACROFORM));
if (af == null) {
return;
}
PdfObject xfa = GetXfaObject(reader);
if (xfa.IsArray()) {
PdfArray ar = (PdfArray)xfa;
int t = -1;
int d = -1;
for (int k = 0; k < ar.Size; k += 2) {
PdfString s = ar.GetAsString(k);
if ("template".Equals(s.ToString())) {
t = k + 1;
}
if ("datasets".Equals(s.ToString())) {
d = k + 1;
}
}
if (t > -1 && d > -1) {
reader.KillXref(ar.GetAsIndirectObject(t));
reader.KillXref(ar.GetAsIndirectObject(d));
PdfStream tStream = new PdfStream(SerializeDoc(form.templateNode));
tStream.FlateCompress(writer.CompressionLevel);
ar[t] = writer.AddToBody(tStream).IndirectReference;
PdfStream dStream = new PdfStream(SerializeDoc(form.datasetsNode));
dStream.FlateCompress(writer.CompressionLevel);
ar[d] = writer.AddToBody(dStream).IndirectReference;
af.Put(PdfName.XFA, new PdfArray(ar));
return;
}
}
reader.KillXref(af.Get(PdfName.XFA));
PdfStream str = new PdfStream(SerializeDoc(form.domDocument));
str.FlateCompress(writer.CompressionLevel);
PdfIndirectReference refe = writer.AddToBody(str).IndirectReference;
af.Put(PdfName.XFA, refe);
}
internal void BuildTree()
{
CreateNumTree();
PdfDictionary dicTree = PdfNumberTree.WriteTree(numTree, writer);
if (dicTree != null)
{
Put(PdfName.PARENTTREE, writer.AddToBody(dicTree).IndirectReference);
}
if (classMap != null && classes.Count > 0)
{
foreach (KeyValuePair <PdfName, PdfObject> entry in classes)
{
PdfObject value = entry.Value;
if (value.IsDictionary())
{
classMap.Put(entry.Key, writer.AddToBody(value).IndirectReference);
}
else if (value.IsArray())
{
PdfArray newArray = new PdfArray();
PdfArray array = (PdfArray)value;
for (int i = 0; i < array.Size; ++i)
{
if (array[i].IsDictionary())
{
newArray.Add(writer.AddToBody(array.GetAsDict(i)).IndirectReference);
}
}
classMap.Put(entry.Key, newArray);
}
}
Put(PdfName.CLASSMAP, writer.AddToBody(classMap).IndirectReference);
}
NodeProcess(this, reference);
}
private static PdfArray GetNameArray(PdfObject obj) {
if (obj == null)
return null;
obj = GetPdfObjectRelease(obj);
if (obj == null)
return null;
if (obj.IsArray())
return (PdfArray)obj;
else if (obj.IsDictionary()) {
PdfObject arr2 = GetPdfObjectRelease(((PdfDictionary)obj).Get(PdfName.D));
if (arr2 != null && arr2.IsArray())
return (PdfArray)arr2;
}
return null;
}
/**
* @see com.lowagie.text.pdf.PdfDictionary#toPdf(com.lowagie.text.pdf.PdfWriter, java.io.OutputStream)
*/
public override void ToPdf(PdfWriter writer, Stream os)
{
if (inputStream != null && compressed)
{
Put(PdfName.FILTER, PdfName.FLATEDECODE);
}
PdfEncryption crypto = null;
if (writer != null)
{
crypto = writer.Encryption;
}
if (crypto != null)
{
PdfObject filter = Get(PdfName.FILTER);
if (filter != null)
{
if (PdfName.CRYPT.Equals(filter))
{
crypto = null;
}
else if (filter.IsArray())
{
PdfArray a = (PdfArray)filter;
if (!a.IsEmpty() && PdfName.CRYPT.Equals(a[0]))
{
crypto = null;
}
}
}
}
if (crypto != null && crypto.IsEmbeddedFilesOnly())
{
PdfArray filter = new PdfArray();
PdfArray decodeparms = new PdfArray();
PdfDictionary crypt = new PdfDictionary();
crypt.Put(PdfName.NAME, PdfName.STDCF);
filter.Add(PdfName.CRYPT);
decodeparms.Add(crypt);
if (compressed)
{
filter.Add(PdfName.FLATEDECODE);
decodeparms.Add(new PdfNull());
}
Put(PdfName.FILTER, filter);
Put(PdfName.DECODEPARMS, decodeparms);
}
PdfObject nn = Get(PdfName.LENGTH);
if (crypto != null && nn != null && nn.IsNumber())
{
int sz = ((PdfNumber)nn).IntValue;
Put(PdfName.LENGTH, new PdfNumber(crypto.CalculateStreamSize(sz)));
SuperToPdf(writer, os);
Put(PdfName.LENGTH, nn);
}
else
{
SuperToPdf(writer, os);
}
os.Write(STARTSTREAM, 0, STARTSTREAM.Length);
if (inputStream != null)
{
rawLength = 0;
ZDeflaterOutputStream def = null;
OutputStreamCounter osc = new OutputStreamCounter(os);
OutputStreamEncryption ose = null;
Stream fout = osc;
if (crypto != null)
{
fout = ose = crypto.GetEncryptionStream(fout);
}
if (compressed)
{
fout = def = new ZDeflaterOutputStream(fout, compressionLevel);
}
byte[] buf = new byte[4192];
while (true)
{
int n = inputStream.Read(buf, 0, buf.Length);
if (n <= 0)
{
break;
}
fout.Write(buf, 0, n);
rawLength += n;
}
if (def != null)
{
def.Finish();
}
if (ose != null)
{
ose.Finish();
}
inputStreamLength = (int)osc.Counter;
}
else
{
if (crypto == null)
{
if (streamBytes != null)
{
streamBytes.WriteTo(os);
}
else
{
os.Write(bytes, 0, bytes.Length);
}
}
else
{
byte[] b;
if (streamBytes != null)
{
b = crypto.EncryptByteArray(streamBytes.ToArray());
}
else
{
b = crypto.EncryptByteArray(bytes);
}
os.Write(b, 0, b.Length);
}
}
os.Write(ENDSTREAM, 0, ENDSTREAM.Length);
}
private void UpdateAnnotationReferences(PdfObject obj) {
if (obj.IsArray()) {
PdfArray array = (PdfArray)obj;
for (int i = 0; i < array.Size; i++) {
PdfObject o = array.GetPdfObject(i);
if (o != null && o.Type == 0) {
PdfIndirectObject entry;
bool contains = unmergedIndirectRefsMap.TryGetValue(new RefKey((PdfIndirectReference) o), out entry);
if (contains) {
if (entry.objecti.IsDictionary()) {
PdfNumber annotId = ((PdfDictionary) entry.objecti).GetAsNumber(PdfCopy.annotId);
if (annotId != null) {
PdfIndirectObject merged;
if (mergedMap.TryGetValue(annotId.IntValue, out merged)) {
array.Set(i, merged.IndirectReference);
}
}
}
}
} else {
UpdateAnnotationReferences(o);
}
}
} else if (obj.IsDictionary() || obj.IsStream()) {
PdfDictionary dictionary = (PdfDictionary)obj;
List<PdfName> keys = new List<PdfName>(dictionary.Keys);
foreach (PdfName key in keys) {
PdfObject o = dictionary.Get(key);
if (o != null && o.Type == 0) {
PdfIndirectObject entry;
bool contains = unmergedIndirectRefsMap.TryGetValue(new RefKey((PdfIndirectReference) o), out entry);
if (contains) {
if (entry.objecti.IsDictionary()) {
PdfNumber annotId = ((PdfDictionary) entry.objecti).GetAsNumber(PdfCopy.annotId);
if (annotId != null) {
PdfIndirectObject merged;
if (mergedMap.TryGetValue(annotId.IntValue, out merged)) {
dictionary.Put(key, merged.IndirectReference);
}
}
}
}
} else {
UpdateAnnotationReferences(o);
}
}
}
}
private ReturnType FindAndCopyMarks(PdfArray pages, int arrayNumber, int newArrayNumber)
{
if (pages.GetAsNumber(0).IntValue > arrayNumber)
{
return(ReturnType.BELOW);
}
if (pages.GetAsNumber(pages.Size - 2).IntValue < arrayNumber)
{
return(ReturnType.ABOVE);
}
int cur = pages.Size / 4;
int begin = 0;
int curNumber;
while (true)
{
curNumber = pages.GetAsNumber((begin + cur) * 2).IntValue;
if (curNumber == arrayNumber)
{
PdfObject obj = pages.GetDirectObject((begin + cur) * 2 + 1);
while (obj.IsIndirect())
{
obj = PdfReader.GetPdfObjectRelease(obj);
}
//invalid Nums
if (!obj.IsArray())
{
return(ReturnType.NOTFOUND);
}
PdfObject firstNotNullKid = null;
foreach (PdfObject numObj in (PdfArray)obj)
{
if (numObj.IsNull())
{
continue;
}
PdfObject res = writer.CopyObject(numObj, true, false);
if (firstNotNullKid == null)
{
firstNotNullKid = res;
}
structureTreeRoot.SetPageMark(newArrayNumber, (PdfIndirectReference)res);
}
//Add kid to structureTreeRoot from structTreeRoot
PdfObject structKids = structTreeRoot.Get(PdfName.K);
if (structKids == null || (!structKids.IsArray() && !structKids.IsIndirect()))
{
// incorrect syntax of tags
AddKid(structureTreeRoot, firstNotNullKid);
}
else
{
if (structKids.IsIndirect())
{
AddKid(structKids);
}
else //structKids.isArray()
{
foreach (PdfObject kid in (PdfArray)structKids)
{
AddKid(kid);
}
}
}
return(ReturnType.FOUND);
}
if (curNumber < arrayNumber)
{
begin += cur;
cur /= 2;
if (cur == 0)
{
cur = 1;
}
if (cur + begin == pages.Size)
{
return(ReturnType.NOTFOUND);
}
continue;
}
if (cur + begin == 0)
{
return(ReturnType.BELOW);
}
if (cur == 0)
{
return(ReturnType.NOTFOUND);
}
cur /= 2;
}
}
/**
* Compresses the stream.
* @param compressionLevel the compression level (0 = best speed, 9 = best compression, -1 is default)
* @since 2.1.3
*/
virtual public void FlateCompress(int compressionLevel)
{
if (!Document.Compress)
{
return;
}
// check if the flateCompress-method has already been used
if (compressed)
{
return;
}
this.compressionLevel = compressionLevel;
if (inputStream != null)
{
compressed = true;
return;
}
// check if a filter already exists
PdfObject filter = PdfReader.GetPdfObject(Get(PdfName.FILTER));
if (filter != null)
{
if (filter.IsName())
{
if (PdfName.FLATEDECODE.Equals(filter))
{
return;
}
}
else if (filter.IsArray())
{
if (((PdfArray)filter).Contains(PdfName.FLATEDECODE))
{
return;
}
}
else
{
throw new PdfException(MessageLocalization.GetComposedMessage("stream.could.not.be.compressed.filter.is.not.a.name.or.array"));
}
}
// compress
MemoryStream stream = new MemoryStream();
ZDeflaterOutputStream zip = new ZDeflaterOutputStream(stream, compressionLevel);
if (streamBytes != null)
{
streamBytes.WriteTo(zip);
}
else
{
zip.Write(bytes, 0, bytes.Length);
}
//zip.Close();
zip.Finish();
// update the object
streamBytes = stream;
bytes = null;
Put(PdfName.LENGTH, new PdfNumber(streamBytes.Length));
if (filter == null)
{
Put(PdfName.FILTER, PdfName.FLATEDECODE);
}
else
{
PdfArray filters = new PdfArray(filter);
filters.Add(0, PdfName.FLATEDECODE);
Put(PdfName.FILTER, filters);
}
compressed = true;
}
internal void AddClass(PdfObject obj)
{
obj = GetDirectObject(obj);
if (obj.IsDictionary())
{
PdfObject curClass = ((PdfDictionary)obj).Get(PdfName.C);
if (curClass == null)
{
return;
}
if (curClass.IsArray())
{
PdfArray array = (PdfArray)curClass;
for (int i = 0; i < array.Size; ++i)
{
AddClass(array[i]);
}
}
else if (curClass.IsName())
{
AddClass(curClass);
}
}
else if (obj.IsName())
{
PdfName name = (PdfName)obj;
if (sourceClassMap == null)
{
obj = GetDirectObject(structTreeRoot.Get(PdfName.CLASSMAP));
if (obj == null || !obj.IsDictionary())
{
return;
}
sourceClassMap = (PdfDictionary)obj;
}
obj = GetDirectObject(sourceClassMap.Get(name));
if (obj == null)
{
return;
}
PdfObject put = structureTreeRoot.GetMappedClass(name);
if (put != null)
{
if (!CompareObjects(put, obj))
{
throw new BadPdfFormatException(MessageLocalization.GetComposedMessage("conflict.in.classmap", name));
}
}
else
{
if (obj.IsDictionary())
{
structureTreeRoot.MapClass(name, GetDirectDict((PdfDictionary)obj));
}
else if (obj.IsArray())
{
structureTreeRoot.MapClass(name, GetDirectArray((PdfArray)obj));
}
}
}
}
internal void AddClass(PdfObject obj) {
obj = GetDirectObject(obj);
if (obj.IsDictionary()) {
PdfObject curClass = ((PdfDictionary)obj).Get(PdfName.C);
if (curClass == null)
return;
if (curClass.IsArray()) {
PdfArray array = (PdfArray)curClass;
for (int i = 0; i < array.Size; ++i) {
AddClass(array[i]);
}
} else if (curClass.IsName())
AddClass(curClass);
} else if (obj.IsName()) {
PdfName name = (PdfName)obj;
if (sourceClassMap == null) {
obj = GetDirectObject(structTreeRoot.Get(PdfName.CLASSMAP));
if (obj == null || !obj.IsDictionary()) {
return;
}
sourceClassMap = (PdfDictionary)obj;
}
obj = GetDirectObject(sourceClassMap.Get(name));
if (obj == null) {
return;
}
PdfObject put = structureTreeRoot.GetMappedClass(name);
if (put != null) {
if (!CompareObjects(put,obj)) {
throw new BadPdfFormatException(MessageLocalization.GetComposedMessage("conflict.in.classmap",name));
}
} else {
if (obj.IsDictionary())
structureTreeRoot.MapClass(name, GetDirectDict((PdfDictionary)obj));
else if (obj.IsArray()) {
structureTreeRoot.MapClass(name, GetDirectArray((PdfArray)obj));
}
}
}
}
public void AddAnnotation(PdfAnnotation annot)
{
List <PdfAnnotation> allAnnots = new List <PdfAnnotation>();
if (annot.IsForm())
{
PdfFormField field = (PdfFormField)annot;
if (field.Parent != null)
{
return;
}
ExpandFields(field, allAnnots);
if (cstp.fieldTemplates == null)
{
cstp.fieldTemplates = new Dictionary <PdfTemplate, object>();
}
}
else
{
allAnnots.Add(annot);
}
for (int k = 0; k < allAnnots.Count; ++k)
{
annot = allAnnots[k];
if (annot.IsForm())
{
if (!annot.IsUsed())
{
Dictionary <PdfTemplate, object> templates = annot.Templates;
if (templates != null)
{
foreach (PdfTemplate tpl in templates.Keys)
{
cstp.fieldTemplates[tpl] = null;
}
}
}
PdfFormField field = (PdfFormField)annot;
if (field.Parent == null)
{
AddDocumentField(field.IndirectReference);
}
}
if (annot.IsAnnotation())
{
PdfObject pdfobj = PdfReader.GetPdfObject(pageN.Get(PdfName.ANNOTS), pageN);
PdfArray annots = null;
if (pdfobj == null || !pdfobj.IsArray())
{
annots = new PdfArray();
pageN.Put(PdfName.ANNOTS, annots);
}
else
{
annots = (PdfArray)pdfobj;
}
annots.Add(annot.IndirectReference);
if (!annot.IsUsed())
{
PdfRectangle rect = (PdfRectangle)annot.Get(PdfName.RECT);
if (rect != null && (rect.Left != 0 || rect.Right != 0 || rect.Top != 0 || rect.Bottom != 0))
{
int rotation = reader.GetPageRotation(pageN);
Rectangle pageSize = reader.GetPageSizeWithRotation(pageN);
switch (rotation)
{
case 90:
annot.Put(PdfName.RECT, new PdfRectangle(
pageSize.Top - rect.Bottom,
rect.Left,
pageSize.Top - rect.Top,
rect.Right));
break;
case 180:
annot.Put(PdfName.RECT, new PdfRectangle(
pageSize.Right - rect.Left,
pageSize.Top - rect.Bottom,
pageSize.Right - rect.Right,
pageSize.Top - rect.Top));
break;
case 270:
annot.Put(PdfName.RECT, new PdfRectangle(
rect.Bottom,
pageSize.Right - rect.Left,
rect.Top,
pageSize.Right - rect.Right));
break;
}
}
}
}
if (!annot.IsUsed())
{
annot.SetUsed();
cstp.AddToBody(annot, annot.IndirectReference);
}
}
}
private ReturnType FindAndCopyMarks(PdfArray pages, int arrayNumber, int newArrayNumber)
{
if (pages.GetAsNumber(0).IntValue > arrayNumber)
{
return(ReturnType.BELOW);
}
if (pages.GetAsNumber(pages.Size - 2).IntValue < arrayNumber)
{
return(ReturnType.ABOVE);
}
int cur = pages.Size / 4;
int begin = 0;
int curNumber;
while (true)
{
curNumber = pages.GetAsNumber((begin + cur) * 2).IntValue;
if (curNumber == arrayNumber)
{
PdfObject obj = pages[(begin + cur) * 2 + 1];
PdfObject obj1 = obj;
while (obj.IsIndirect())
{
obj = PdfReader.GetPdfObjectRelease(obj);
}
//invalid Nums
if (obj.IsArray())
{
PdfObject firstNotNullKid = null;
foreach (PdfObject numObj in (PdfArray)obj)
{
if (numObj.IsNull())
{
if (nullReference == null)
{
nullReference = writer.AddToBody(new PdfNull()).IndirectReference;
}
structureTreeRoot.SetPageMark(newArrayNumber, nullReference);
}
else
{
PdfObject res = writer.CopyObject(numObj, true, false);
if (firstNotNullKid == null)
{
firstNotNullKid = res;
}
structureTreeRoot.SetPageMark(newArrayNumber, (PdfIndirectReference)res);
}
}
AttachStructTreeRootKids(firstNotNullKid);
}
else if (obj.IsDictionary())
{
PdfDictionary k = GetKDict((PdfDictionary)obj);
if (k == null)
{
return(ReturnType.NOTFOUND);
}
PdfObject res = writer.CopyObject(obj1, true, false);
structureTreeRoot.SetAnnotationMark(newArrayNumber, (PdfIndirectReference)res);
}
else
{
return(ReturnType.NOTFOUND);
}
return(ReturnType.FOUND);
}
if (curNumber < arrayNumber)
{
begin += cur;
cur /= 2;
if (cur == 0)
{
cur = 1;
}
if (cur + begin == pages.Size)
{
return(ReturnType.NOTFOUND);
}
continue;
}
if (cur + begin == 0)
{
return(ReturnType.BELOW);
}
if (cur == 0)
{
return(ReturnType.NOTFOUND);
}
cur /= 2;
}
}
private PdfObject SimplifyColorspace(PdfObject obj)
{
if (obj == null || !obj.IsArray())
return obj;
PdfObject first = (PdfObject)(((PdfArray)obj).ArrayList[0]);
if (PdfName.CALGRAY.Equals(first))
return PdfName.DEVICEGRAY;
else if (PdfName.CALRGB.Equals(first))
return PdfName.DEVICERGB;
else
return obj;
}
/// <summary>
/// methods
/// </summary>
/// <summary>
/// Compresses the stream.
/// @since 2.1.3
/// </summary>
/// <param name="compressionLevel">the compression level (0 = best speed, 9 = best compression, -1 is default)</param>
public void FlateCompress(int compressionLevel)
{
if (!Document.Compress)
{
return;
}
// check if the flateCompress-method has allready been
if (Compressed)
{
return;
}
CompressionLevel = compressionLevel;
if (InputStream != null)
{
Compressed = true;
return;
}
// check if a filter allready exists
PdfObject filter = PdfReader.GetPdfObject(Get(PdfName.Filter));
if (filter != null)
{
if (filter.IsName())
{
if (PdfName.Flatedecode.Equals(filter))
{
return;
}
}
else if (filter.IsArray())
{
if (((PdfArray)filter).Contains(PdfName.Flatedecode))
{
return;
}
}
else
{
throw new PdfException("Stream could not be compressed: filter is not a name or array.");
}
}
// compress
MemoryStream stream = new MemoryStream();
ZDeflaterOutputStream zip = new ZDeflaterOutputStream(stream, compressionLevel);
if (StreamBytes != null)
{
StreamBytes.WriteTo(zip);
}
else
{
zip.Write(Bytes, 0, Bytes.Length);
}
//zip.Close();
zip.Finish();
// update the object
StreamBytes = stream;
Bytes = null;
Put(PdfName.LENGTH, new PdfNumber(StreamBytes.Length));
if (filter == null)
{
Put(PdfName.Filter, PdfName.Flatedecode);
}
else
{
PdfArray filters = new PdfArray(filter);
filters.Add(PdfName.Flatedecode);
Put(PdfName.Filter, filters);
}
Compressed = true;
}
private PdfObject Propagate(PdfObject obj) {
if (obj == null) {
return new PdfNull();
} else if (obj.IsArray()) {
PdfArray a = (PdfArray)obj;
for (int i = 0; i < a.Size; i++) {
a.Set(i, Propagate(a.GetPdfObject(i)));
}
return a;
} else if (obj.IsDictionary() || obj.IsStream()) {
PdfDictionary d = (PdfDictionary)obj;
List<PdfName> keys = new List<PdfName>(d.Keys);
foreach (PdfName key in keys) {
d.Put(key, Propagate(d.Get(key)));
}
return d;
} else if (obj.IsIndirect()) {
obj = PdfReader.GetPdfObject(obj);
return AddToBody(Propagate(obj)).IndirectReference;
} else
return obj;
}
public void AlterContents()
{
if (_over == null && _under == null)
{
return;
}
PdfArray ar = null;
PdfObject content = PdfReader.GetPdfObject(_pageN.Get(PdfName.Contents), _pageN);
if (content == null)
{
ar = new PdfArray();
_pageN.Put(PdfName.Contents, ar);
}
else if (content.IsArray())
{
ar = (PdfArray)content;
}
else if (content.IsStream())
{
ar = new PdfArray();
ar.Add(_pageN.Get(PdfName.Contents));
_pageN.Put(PdfName.Contents, ar);
}
else
{
ar = new PdfArray();
_pageN.Put(PdfName.Contents, ar);
}
ByteBuffer outP = new ByteBuffer();
if (_under != null)
{
outP.Append(PdfContents.Savestate);
applyRotation(_pageN, outP);
outP.Append(_under.InternalBuffer);
outP.Append(PdfContents.Restorestate);
}
if (_over != null)
{
outP.Append(PdfContents.Savestate);
}
PdfStream stream = new PdfStream(outP.ToByteArray());
stream.FlateCompress(_cstp.CompressionLevel);
PdfIndirectReference ref1 = _cstp.AddToBody(stream).IndirectReference;
ar.AddFirst(ref1);
outP.Reset();
if (_over != null)
{
outP.Append(' ');
outP.Append(PdfContents.Restorestate);
outP.Append(PdfContents.Savestate);
applyRotation(_pageN, outP);
outP.Append(_over.InternalBuffer);
outP.Append(PdfContents.Restorestate);
stream = new PdfStream(outP.ToByteArray());
stream.FlateCompress(_cstp.CompressionLevel);
ar.Add(_cstp.AddToBody(stream).IndirectReference);
}
_pageN.Put(PdfName.Resources, _pageResources.Resources);
}
public void AddAnnotation(PdfAnnotation annot)
{
ArrayList allAnnots = new ArrayList();
if (annot.IsForm())
{
PdfFormField field = (PdfFormField)annot;
if (field.Parent != null)
{
return;
}
expandFields(field, allAnnots);
if (_cstp.FieldTemplates == null)
{
_cstp.FieldTemplates = new Hashtable();
}
}
else
{
allAnnots.Add(annot);
}
for (int k = 0; k < allAnnots.Count; ++k)
{
annot = (PdfAnnotation)allAnnots[k];
if (annot.IsForm())
{
if (!annot.IsUsed())
{
Hashtable templates = annot.Templates;
if (templates != null)
{
foreach (object tpl in templates.Keys)
{
_cstp.FieldTemplates[tpl] = null;
}
}
}
PdfFormField field = (PdfFormField)annot;
if (field.Parent == null)
{
addDocumentField(field.IndirectReference);
}
}
if (annot.IsAnnotation())
{
PdfObject pdfobj = PdfReader.GetPdfObject(_pageN.Get(PdfName.Annots), _pageN);
PdfArray annots = null;
if (pdfobj == null || !pdfobj.IsArray())
{
annots = new PdfArray();
_pageN.Put(PdfName.Annots, annots);
}
else
{
annots = (PdfArray)pdfobj;
}
annots.Add(annot.IndirectReference);
if (!annot.IsUsed())
{
PdfRectangle rect = (PdfRectangle)annot.Get(PdfName.Rect);
if (rect != null && (rect.Left.ApproxNotEqual(0) || rect.Right.ApproxNotEqual(0) || rect.Top.ApproxNotEqual(0) || rect.Bottom.ApproxNotEqual(0)))
{
int rotation = _reader.GetPageRotation(_pageN);
Rectangle pageSize = _reader.GetPageSizeWithRotation(_pageN);
switch (rotation)
{
case 90:
annot.Put(PdfName.Rect, new PdfRectangle(
pageSize.Top - rect.Bottom,
rect.Left,
pageSize.Top - rect.Top,
rect.Right));
break;
case 180:
annot.Put(PdfName.Rect, new PdfRectangle(
pageSize.Right - rect.Left,
pageSize.Top - rect.Bottom,
pageSize.Right - rect.Right,
pageSize.Top - rect.Top));
break;
case 270:
annot.Put(PdfName.Rect, new PdfRectangle(
rect.Bottom,
pageSize.Right - rect.Left,
rect.Top,
pageSize.Right - rect.Right));
break;
}
}
}
}
if (!annot.IsUsed())
{
annot.SetUsed();
_cstp.AddToBody(annot, annot.IndirectReference);
}
}
}
public override PdfIndirectObject AddToBody(PdfObject objecta, PdfIndirectReference refa)
{
if (tagged && indirectObjects != null && (objecta.IsArray() || objecta.IsDictionary())) {
RefKey key = new RefKey(refa);
PdfIndirectObject obj;
if (!indirectObjects.TryGetValue(key, out obj)) {
obj = new PdfIndirectObject(refa, objecta, this);
indirectObjects[key] = obj;
}
return obj;
} else {
if (tagged && objecta.IsStream())
streams.Add(new RefKey(refa));
return base.AddToBody(objecta, refa);
}
}
public override void ToPdf(PdfWriter writer, Stream os)
{
if (InputStream != null && Compressed)
{
Put(PdfName.Filter, PdfName.Flatedecode);
}
PdfEncryption crypto = null;
if (writer != null)
{
crypto = writer.Encryption;
}
if (crypto != null)
{
PdfObject filter = Get(PdfName.Filter);
if (filter != null)
{
if (PdfName.Crypt.Equals(filter))
{
crypto = null;
}
else if (filter.IsArray())
{
PdfArray a = ((PdfArray)filter);
if (a.Size > 0 && PdfName.Crypt.Equals(a[0]))
{
crypto = null;
}
}
}
}
PdfObject nn = Get(PdfName.LENGTH);
if (crypto != null && nn != null && nn.IsNumber())
{
int sz = ((PdfNumber)nn).IntValue;
Put(PdfName.LENGTH, new PdfNumber(crypto.CalculateStreamSize(sz)));
SuperToPdf(writer, os);
Put(PdfName.LENGTH, nn);
}
else
{
SuperToPdf(writer, os);
}
os.Write(Startstream, 0, Startstream.Length);
if (InputStream != null)
{
rawLength = 0;
ZDeflaterOutputStream def = null;
OutputStreamCounter osc = new OutputStreamCounter(os);
OutputStreamEncryption ose = null;
Stream fout = osc;
if (crypto != null && !crypto.IsEmbeddedFilesOnly())
{
fout = ose = crypto.GetEncryptionStream(fout);
}
if (Compressed)
{
fout = def = new ZDeflaterOutputStream(fout, CompressionLevel);
}
byte[] buf = new byte[4192];
while (true)
{
int n = InputStream.Read(buf, 0, buf.Length);
if (n <= 0)
{
break;
}
fout.Write(buf, 0, n);
rawLength += n;
}
if (def != null)
{
def.Finish();
}
if (ose != null)
{
ose.Finish();
}
InputStreamLength = osc.Counter;
}
else
{
if (crypto != null && !crypto.IsEmbeddedFilesOnly())
{
byte[] b;
if (StreamBytes != null)
{
b = crypto.EncryptByteArray(StreamBytes.ToArray());
}
else
{
b = crypto.EncryptByteArray(Bytes);
}
os.Write(b, 0, b.Length);
}
else
{
if (StreamBytes != null)
{
StreamBytes.WriteTo(os);
}
else
{
os.Write(Bytes, 0, Bytes.Length);
}
}
}
os.Write(Endstream, 0, Endstream.Length);
}
public void AlterContents()
{
if (over == null && under == null)
{
return;
}
PdfArray ar = null;
PdfObject content = PdfReader.GetPdfObject(pageN.Get(PdfName.CONTENTS), pageN);
if (content == null)
{
ar = new PdfArray();
pageN.Put(PdfName.CONTENTS, ar);
}
else if (content.IsArray())
{
ar = (PdfArray)content;
}
else if (content.IsStream())
{
ar = new PdfArray();
ar.Add(pageN.Get(PdfName.CONTENTS));
pageN.Put(PdfName.CONTENTS, ar);
}
else
{
ar = new PdfArray();
pageN.Put(PdfName.CONTENTS, ar);
}
ByteBuffer out_p = new ByteBuffer();
if (under != null)
{
out_p.Append(PdfContents.SAVESTATE);
ApplyRotation(pageN, out_p);
out_p.Append(under.InternalBuffer);
out_p.Append(PdfContents.RESTORESTATE);
}
if (over != null)
{
out_p.Append(PdfContents.SAVESTATE);
}
PdfStream stream = new PdfStream(out_p.ToByteArray());
stream.FlateCompress(cstp.CompressionLevel);
PdfIndirectReference ref1 = cstp.AddToBody(stream).IndirectReference;
ar.AddFirst(ref1);
out_p.Reset();
if (over != null)
{
out_p.Append(' ');
out_p.Append(PdfContents.RESTORESTATE);
out_p.Append(PdfContents.SAVESTATE);
ApplyRotation(pageN, out_p);
out_p.Append(over.InternalBuffer);
out_p.Append(PdfContents.RESTORESTATE);
stream = new PdfStream(out_p.ToByteArray());
stream.FlateCompress(cstp.CompressionLevel);
ar.Add(cstp.AddToBody(stream).IndirectReference);
}
pageN.Put(PdfName.RESOURCES, pageResources.Resources);
}
private void SerObject(PdfObject obj, int level, ByteBuffer bb, Dictionary <RefKey, int> serialized)
{
if (level <= 0)
{
return;
}
if (obj == null)
{
bb.Append("$Lnull");
return;
}
PdfIndirectReference refe = null;
ByteBuffer savedBb = null;
if (obj.IsIndirect())
{
refe = (PdfIndirectReference)obj;
RefKey key = new RefKey(refe);
if (serialized.ContainsKey(key))
{
bb.Append(serialized[key]);
return;
}
else
{
savedBb = bb;
bb = new ByteBuffer();
}
}
obj = PdfReader.GetPdfObject(obj);
if (obj.IsStream())
{
bb.Append("$B");
SerDic((PdfDictionary)obj, level - 1, bb, serialized);
if (level > 0)
{
bb.Append(DigestAlgorithms.Digest("MD5", PdfReader.GetStreamBytesRaw((PRStream)obj)));
}
}
else if (obj.IsDictionary())
{
SerDic((PdfDictionary)obj, level - 1, bb, serialized);
}
else if (obj.IsArray())
{
SerArray((PdfArray)obj, level - 1, bb, serialized);
}
else if (obj.IsString())
{
bb.Append("$S").Append(obj.ToString());
}
else if (obj.IsName())
{
bb.Append("$N").Append(obj.ToString());
}
else
{
bb.Append("$L").Append(obj.ToString());
}
if (savedBb != null)
{
RefKey key = new RefKey(refe);
if (!serialized.ContainsKey(key))
{
serialized[key] = CalculateHash(bb.Buffer);
}
savedBb.Append(bb);
}
}
private void SerObject(PdfObject obj, int level, ByteBuffer bb) {
if (level <= 0)
return;
if (obj == null) {
bb.Append("$Lnull");
return;
}
if (obj.IsIndirect()) {
if (serialized.Contains(obj))
return;
else
serialized.Add(obj);
}
obj = PdfReader.GetPdfObject(obj);
if (obj.IsStream()) {
bb.Append("$B");
SerDic((PdfDictionary)obj, level - 1, bb);
if (level > 0) {
bb.Append(DigestAlgorithms.Digest("MD5", PdfReader.GetStreamBytesRaw((PRStream)obj)));
}
}
else if (obj.IsDictionary()) {
SerDic((PdfDictionary)obj, level - 1, bb);
}
else if (obj.IsArray()) {
SerArray((PdfArray)obj, level - 1, bb);
}
else if (obj.IsString()) {
bb.Append("$S").Append(obj.ToString());
}
else if (obj.IsName()) {
bb.Append("$N").Append(obj.ToString());
}
else
bb.Append("$L").Append(obj.ToString());
}
// methods
/**
* Compresses the stream.
*
* @throws PdfException if a filter is allready defined
*/
public void FlateCompress()
{
if (!Document.Compress)
{
return;
}
// check if the flateCompress-method has allready been
if (compressed)
{
return;
}
if (inputStream != null)
{
compressed = true;
return;
}
// check if a filter allready exists
PdfObject filter = Get(PdfName.FILTER);
if (filter != null)
{
if (filter.IsName() && ((PdfName)filter).CompareTo(PdfName.FLATEDECODE) == 0)
{
return;
}
else if (filter.IsArray() && ((PdfArray)filter).Contains(PdfName.FLATEDECODE))
{
return;
}
else
{
throw new PdfException("Stream could not be compressed: filter is not a name or array.");
}
}
// compress
MemoryStream stream = new MemoryStream();
ZDeflaterOutputStream zip = new ZDeflaterOutputStream(stream);
if (streamBytes != null)
{
streamBytes.WriteTo(zip);
}
else
{
zip.Write(bytes, 0, bytes.Length);
}
//zip.Close();
zip.Finish();
// update the object
streamBytes = stream;
bytes = null;
Put(PdfName.LENGTH, new PdfNumber(streamBytes.Length));
if (filter == null)
{
Put(PdfName.FILTER, PdfName.FLATEDECODE);
}
else
{
PdfArray filters = new PdfArray(filter);
filters.Add(PdfName.FLATEDECODE);
Put(PdfName.FILTER, filters);
}
compressed = true;
}
public static bool CompareObjects(PdfObject value1, PdfObject value2)
{
value2 = GetDirectObject(value2);
if (value2 == null)
{
return(false);
}
if (value1.Type != value2.Type)
{
return(false);
}
if (value1.IsBoolean())
{
if (value1 == value2)
{
return(true);
}
if (value2 is PdfBoolean)
{
return(((PdfBoolean)value1).BooleanValue == ((PdfBoolean)value2).BooleanValue);
}
return(false);
}
else if (value1.IsName())
{
return(value1.Equals(value2));
}
else if (value1.IsNumber())
{
if (value1 == value2)
{
return(true);
}
if (value2 is PdfNumber)
{
return(((PdfNumber)value1).DoubleValue == ((PdfNumber)value2).DoubleValue);
}
return(false);
}
else if (value1.IsNull())
{
if (value1 == value2)
{
return(true);
}
if (value2 is PdfNull)
{
return(true);
}
return(false);
}
else if (value1.IsString())
{
if (value1 == value2)
{
return(true);
}
if (value2 is PdfString)
{
return((value2 == null && value1.ToString() == null) ||
value1.ToString() == value2.ToString());
}
return(false);
}
if (value1.IsArray())
{
PdfArray array1 = (PdfArray)value1;
PdfArray array2 = (PdfArray)value2;
if (array1.Size != array2.Size)
{
return(false);
}
for (int i = 0; i < array1.Size; ++i)
{
if (!CompareObjects(array1[i], array2[i]))
{
return(false);
}
}
return(true);
}
if (value1.IsDictionary())
{
PdfDictionary first = (PdfDictionary)value1;
PdfDictionary second = (PdfDictionary)value2;
if (first.Size != second.Size)
{
return(false);
}
foreach (PdfName name in first.hashMap.Keys)
{
if (!CompareObjects(first.Get(name), second.Get(name)))
{
return(false);
}
}
return(true);
}
return(false);
}
private void SerObject(PdfObject obj, int level, ByteBuffer bb, Dictionary<RefKey, int> serialized)
{
if (level <= 0)
return;
if (obj == null) {
bb.Append("$Lnull");
return;
}
PdfIndirectReference refe = null;
ByteBuffer savedBb = null;
if (obj.IsIndirect()) {
refe = (PdfIndirectReference)obj;
RefKey key = new RefKey(refe);
if (serialized.ContainsKey(key)) {
bb.Append(serialized[key]);
return;
}
else {
savedBb = bb;
bb = new ByteBuffer();
}
}
obj = PdfReader.GetPdfObject(obj);
if (obj.IsStream()) {
bb.Append("$B");
SerDic((PdfDictionary)obj, level - 1, bb, serialized);
if (level > 0) {
bb.Append(DigestAlgorithms.Digest("MD5", PdfReader.GetStreamBytesRaw((PRStream)obj)));
}
}
else if (obj.IsDictionary()) {
SerDic((PdfDictionary)obj, level - 1, bb,serialized);
}
else if (obj.IsArray()) {
SerArray((PdfArray)obj, level - 1, bb,serialized);
}
else if (obj.IsString()) {
bb.Append("$S").Append(obj.ToString());
}
else if (obj.IsName()) {
bb.Append("$N").Append(obj.ToString());
}
else
bb.Append("$L").Append(obj.ToString());
if (savedBb != null) {
RefKey key = new RefKey(refe);
if (!serialized.ContainsKey(key))
serialized[key] = CalculateHash(bb.Buffer);
savedBb.Append(bb);
}
}
public static bool CompareObjects(PdfObject value1, PdfObject value2) {
value2 = GetDirectObject(value2);
if (value2 == null)
return false;
if (value1.Type != value2.Type)
return false;
if (value1.IsBoolean()){
if (value1 == value2)
return true;
if (value2 is PdfBoolean) {
return ((PdfBoolean)value1).BooleanValue == ((PdfBoolean)value2).BooleanValue;
}
return false;
} else if (value1.IsName()) {
return value1.Equals(value2);
} else if (value1.IsNumber()){
if (value1 == value2)
return true;
if (value2 is PdfNumber) {
return ((PdfNumber)value1).DoubleValue == ((PdfNumber)value2).DoubleValue;
}
return false;
} else if (value1.IsNull()){
if (value1 == value2)
return true;
if (value2 is PdfNull)
return true;
return false;
} else if (value1.IsString()){
if (value1 == value2)
return true;
if (value2 is PdfString) {
return ((value2 == null && value1.ToString() == null)
|| value1.ToString() == value2.ToString());
}
return false;
}
if (value1.IsArray()) {
PdfArray array1 = (PdfArray)value1;
PdfArray array2 = (PdfArray)value2;
if (array1.Size != array2.Size)
return false;
for (int i = 0; i < array1.Size; ++i)
if (!CompareObjects(array1[i],array2[i]))
return false;
return true;
}
if (value1.IsDictionary()) {
PdfDictionary first = (PdfDictionary)value1;
PdfDictionary second = (PdfDictionary)value2;
if (first.Size != second.Size)
return false;
foreach (PdfName name in first.hashMap.Keys) {
if (!CompareObjects(first.Get(name),second.Get(name)))
return false;
}
return true;
}
return false;
}
private static void MapGotoBookmark(Dictionary<String, Object> map, PdfObject dest, IntHashtable pages)
{
if (dest.IsString())
map["Named"] = dest.ToString();
else if (dest.IsName())
map["Named"] = PdfName.DecodeName(dest.ToString());
else if (dest.IsArray())
map["Page"] = MakeBookmarkParam((PdfArray)dest, pages); //changed by ujihara 2004-06-13
map["Action"] = "GoTo";
}
private void UpdateAnnotationReferences(PdfObject obj) {
if (obj.IsArray()) {
PdfArray array = (PdfArray)obj;
for (int i = 0; i < array.Size; i++) {
PdfObject o = array[i];
if (o is PdfIndirectReference) {
foreach (PdfIndirectObject entry in unmergedSet) {
if (entry.IndirectReference.ToString().Equals(o.ToString())) {
if (entry.objecti.IsDictionary()) {
PdfNumber annotId = ((PdfDictionary)entry.objecti).GetAsNumber(PdfCopy.annotId);
if (annotId != null) {
PdfIndirectObject merged = null;
if (mergedMap.TryGetValue(annotId.IntValue, out merged)) {
array[i] = merged.IndirectReference;
}
}
}
}
}
} else {
UpdateAnnotationReferences(o);
}
}
} else if (obj.IsDictionary() || obj.IsStream()) {
PdfDictionary dictionary = (PdfDictionary)obj;
PdfDictionary newDictionary = new PdfDictionary();
foreach (PdfName key in dictionary.Keys) {
PdfObject o = dictionary.Get(key);
if (o is PdfIndirectReference) {
foreach (PdfIndirectObject entry in unmergedSet) {
if (entry.IndirectReference.ToString().Equals(o.ToString())) {
if (entry.objecti.IsDictionary()) {
PdfNumber annotId = ((PdfDictionary)entry.objecti).GetAsNumber(PdfCopy.annotId);
if (annotId != null) {
PdfIndirectObject merged;
if (mergedMap.TryGetValue(annotId.IntValue, out merged)) {
newDictionary.Put(key, merged.IndirectReference);
}
}
}
}
}
} else {
UpdateAnnotationReferences(o);
}
}
foreach (PdfName key in newDictionary.Keys) {
dictionary.Put(key, newDictionary.Get(key));
}
}
}
virtual public String[] GetFieldValues(String name)
{
PdfDictionary field = GetField(name);
if (field == null)
{
return new String[] { }
}
;
PdfObject v = GetPdfObject(field.Get(PdfName.V));
if (v == null)
{
return new String[] { }
}
;
if (v.IsName())
{
return new String[] { PdfName.DecodeName(((PdfName)v).ToString()) }
}
;
else if (v.IsString())
{
PdfString vs = (PdfString)v;
if (encoding == null || vs.Encoding != null)
{
return new String[] { vs.ToUnicodeString() }
}
;
byte[] b = vs.GetBytes();
if (b.Length >= 2 && b[0] == (byte)254 && b[1] == (byte)255)
{
return new String[] { vs.ToUnicodeString() }
}
;
try
{
if (encoding.Equals(PdfName.SHIFT_JIS))
{
return new String[] { Encoding.GetEncoding(932).GetString(b) }
}
;
else if (encoding.Equals(PdfName.UHC))
{
return new String[] { Encoding.GetEncoding(949).GetString(b) }
}
;
else if (encoding.Equals(PdfName.GBK))
{
return new String[] { Encoding.GetEncoding(936).GetString(b) }
}
;
else if (encoding.Equals(PdfName.BIGFIVE))
{
return new String[] { Encoding.GetEncoding(950).GetString(b) }
}
;
else if (encoding.Equals(PdfName.UTF_8))
{
return new String[] { Encoding.UTF8.GetString(b) }
}
;
}
catch
{
}
return(new String[] { vs.ToUnicodeString() });
}
else if (v.IsArray())
{
PdfArray vsArray = (PdfArray)v;
System.Collections.Generic.List <String> vals = new System.Collections.Generic.List <String>();
for (Int32 vsIdx = 0; vsIdx < vsArray.Size; vsIdx++)
{
if (vsArray[vsIdx] == null)
{
vals.Add("");
}
else if (vsArray[vsIdx].IsString())
{
PdfString vs = (PdfString)vsArray[vsIdx];
if (encoding == null || vs.Encoding != null)
{
vals.Add(vs.ToUnicodeString());
}
else
{
byte[] b1 = vs.GetBytes();
if (b1.Length >= 2 && b1[0] == (byte)254 && b1[1] == (byte)255)
{
vals.Add(vs.ToUnicodeString());
}
else
{
try
{
if (encoding.Equals(PdfName.SHIFT_JIS))
{
vals.Add(Encoding.GetEncoding(932).GetString(b1));
}
else if (encoding.Equals(PdfName.UHC))
{
vals.Add(Encoding.GetEncoding(949).GetString(b1));
}
else if (encoding.Equals(PdfName.GBK))
{
vals.Add(Encoding.GetEncoding(936).GetString(b1));
}
else if (encoding.Equals(PdfName.BIGFIVE))
{
vals.Add(Encoding.GetEncoding(950).GetString(b1));
}
else if (encoding.Equals(PdfName.UTF_8))
{
vals.Add(Encoding.UTF8.GetString(b1));
}
}
catch
{
}
}
}
}
else if (vsArray[vsIdx].IsName())
{
vals.Add(PdfName.DecodeName(((PdfName)vsArray[vsIdx]).ToString()));
}
}
return(vals.ToArray());
}
return(new String[] { });
}
private PdfObject Propagate(PdfObject obj) {
if (obj == null) {
return new PdfNull();
}
if (obj.IsArray()) {
PdfArray a = (PdfArray)obj;
for (int i = 0; i < a.Size; i++) {
a[i] = Propagate(a[i]);
}
return a;
}
if (obj.IsDictionary() || obj.IsStream()) {
PdfDictionary d = (PdfDictionary)obj;
PdfDictionary newD = new PdfDictionary();
foreach (PdfName key in d.Keys) {
newD.Put(key, Propagate(d.Get(key)));
}
return newD;
}
if (obj.IsIndirect()) {
obj = PdfReader.GetPdfObject(obj);
return AddToBody(Propagate(obj)).IndirectReference;
}
return obj;
}
private void UpdateReferences(PdfObject obj) {
if (obj.IsDictionary() || obj.IsStream()) {
PdfDictionary dictionary = (PdfDictionary)obj;
PdfDictionary newDictionary = new PdfDictionary();
foreach (PdfName key in dictionary.Keys) {
PdfObject o = dictionary.Get(key);
if (o.IsIndirect()) {
PdfReader reader = ((PRIndirectReference)o).Reader;
Dictionary<RefKey,IndirectReferences> indirects = indirectMap[reader];
IndirectReferences indRef = null;
if (indirects.TryGetValue(new RefKey((PRIndirectReference)o), out indRef)) {
newDictionary.Put(key, indRef.Ref);
}
} else {
UpdateReferences(o);
}
}
foreach (PdfName key in newDictionary.Keys) {
dictionary.Put(key, newDictionary.Get(key));
}
} else if (obj.IsArray()) {
PdfArray array = (PdfArray)obj;
for (int i = 0; i < array.Size; i++) {
PdfObject o = array[i];
if (o.IsIndirect()) {
PdfReader reader = ((PRIndirectReference)o).Reader;
Dictionary<RefKey,IndirectReferences> indirects = indirectMap[reader];
IndirectReferences indRef = null;
if (indirects.TryGetValue(new RefKey((PRIndirectReference)o), out indRef)) {
array[i] = indRef.Ref;
}
} else {
UpdateReferences(o);
}
}
}
}
private void SerObject(PdfObject obj, int level, ByteBuffer bb)
{
if (level <= 0)
return;
if (obj == null) {
bb.Append("$Lnull");
return;
}
obj = PdfReader.GetPdfObject(obj);
if (obj.IsStream()) {
bb.Append("$B");
SerDic((PdfDictionary)obj, level - 1, bb);
if (level > 0) {
bb.Append(PdfEncryption.DigestComputeHash("MD5", PdfReader.GetStreamBytesRaw((PRStream)obj)));
}
}
else if (obj.IsDictionary()) {
SerDic((PdfDictionary)obj, level - 1, bb);
}
else if (obj.IsArray()) {
SerArray((PdfArray)obj, level - 1, bb);
}
else if (obj.IsString()) {
bb.Append("$S").Append(obj.ToString());
}
else if (obj.IsName()) {
bb.Append("$N").Append(obj.ToString());
}
else
bb.Append("$L").Append(obj.ToString());
}
public new PdfIndirectObject AddToBody(PdfObject objecta, PdfIndirectReference refa, bool formBranching) {
if (formBranching) {
UpdateReferences(objecta);
}
PdfIndirectObject indObj;
if ((tagged || mergeFields) && indirectObjects != null && (objecta.IsArray() || objecta.IsDictionary() || objecta.IsStream())) {
RefKey key = new RefKey(refa);
PdfIndirectObject obj;
if (!indirectObjects.TryGetValue(key, out obj)) {
obj = new PdfIndirectObject(refa, objecta, this);
indirectObjects[key] = obj;
}
indObj = obj;
} else {
indObj = base.AddToBody(objecta, refa);
}
if (mergeFields && objecta.IsDictionary()) {
PdfNumber annotId = ((PdfDictionary)objecta).GetAsNumber(PdfCopy.annotId);
if (annotId != null) {
if (formBranching) {
mergedMap[annotId.IntValue] = indObj;
mergedSet.Add(indObj);
} else {
unmergedMap[annotId.IntValue] = indObj;
unmergedSet.Add(indObj);
}
}
}
return indObj;
}
public override void ToPdf(PdfWriter writer, Stream os)
{
if (inputStream != null && compressed)
{
Put(PdfName.FILTER, PdfName.FLATEDECODE);
}
PdfEncryption crypto = null;
if (writer != null)
{
crypto = writer.Encryption;
}
if (crypto != null)
{
PdfObject filter = Get(PdfName.FILTER);
if (filter != null)
{
if (PdfName.CRYPT.Equals(filter))
{
crypto = null;
}
else if (filter.IsArray())
{
PdfArray a = ((PdfArray)filter);
if (a.Size > 0 && PdfName.CRYPT.Equals(a[0]))
{
crypto = null;
}
}
}
}
PdfObject nn = Get(PdfName.LENGTH);
if (crypto != null && nn != null && nn.IsNumber())
{
int sz = ((PdfNumber)nn).IntValue;
Put(PdfName.LENGTH, new PdfNumber(crypto.CalculateStreamSize(sz)));
SuperToPdf(writer, os);
Put(PdfName.LENGTH, nn);
}
else
{
SuperToPdf(writer, os);
}
PdfWriter.CheckPdfIsoConformance(writer, PdfIsoKeys.PDFISOKEY_STREAM, this);
os.Write(STARTSTREAM, 0, STARTSTREAM.Length);
if (inputStream != null)
{
rawLength = 0;
ZDeflaterOutputStream def = null;
OutputStreamCounter osc = new OutputStreamCounter(os);
OutputStreamEncryption ose = null;
Stream fout = osc;
if (crypto != null && !crypto.IsEmbeddedFilesOnly())
{
fout = ose = crypto.GetEncryptionStream(fout);
}
if (compressed)
{
fout = def = new ZDeflaterOutputStream(fout, compressionLevel);
}
byte[] buf = new byte[4192];
while (true)
{
int n = inputStream.Read(buf, 0, buf.Length);
if (n <= 0)
{
break;
}
fout.Write(buf, 0, n);
rawLength += n;
}
if (def != null)
{
def.Finish();
}
if (ose != null)
{
ose.Finish();
}
inputStreamLength = (int)osc.Counter;
}
else
{
if (crypto != null && !crypto.IsEmbeddedFilesOnly())
{
byte[] b;
if (streamBytes != null)
{
b = crypto.EncryptByteArray(streamBytes.ToArray());
}
else
{
b = crypto.EncryptByteArray(bytes);
}
os.Write(b, 0, b.Length);
}
else
{
if (streamBytes != null)
{
streamBytes.WriteTo(os);
}
else
{
os.Write(bytes, 0, bytes.Length);
}
}
}
os.Write(ENDSTREAM, 0, ENDSTREAM.Length);
}
private static ArrayList BookmarkDepth(PdfReader reader, PdfDictionary outline, IntHashtable pages)
{
ArrayList list = new ArrayList();
while (outline != null)
{
Hashtable map = new Hashtable();
PdfString title = (PdfString)PdfReader.GetPdfObjectRelease(outline.Get(PdfName.TITLE));
map["Title"] = title.ToUnicodeString();
PdfArray color = (PdfArray)PdfReader.GetPdfObjectRelease(outline.Get(PdfName.C));
if (color != null && color.ArrayList.Count == 3)
{
ByteBuffer outp = new ByteBuffer();
ArrayList arr = color.ArrayList;
outp.Append(((PdfNumber)arr[0]).FloatValue).Append(' ');
outp.Append(((PdfNumber)arr[1]).FloatValue).Append(' ');
outp.Append(((PdfNumber)arr[2]).FloatValue);
map["Color"] = PdfEncodings.ConvertToString(outp.ToByteArray(), null);
}
PdfNumber style = (PdfNumber)PdfReader.GetPdfObjectRelease(outline.Get(PdfName.F));
if (style != null)
{
int f = style.IntValue;
String s = "";
if ((f & 1) != 0)
{
s += "italic ";
}
if ((f & 2) != 0)
{
s += "bold ";
}
s = s.Trim();
if (s.Length != 0)
{
map["Style"] = s;
}
}
PdfNumber count = (PdfNumber)PdfReader.GetPdfObjectRelease(outline.Get(PdfName.COUNT));
if (count != null && count.IntValue < 0)
{
map["Open"] = "false";
}
try {
PdfObject dest = PdfReader.GetPdfObjectRelease(outline.Get(PdfName.DEST));
if (dest != null)
{
MapGotoBookmark(map, dest, pages); //changed by ujihara 2004-06-13
}
else
{
PdfDictionary action = (PdfDictionary)PdfReader.GetPdfObjectRelease(outline.Get(PdfName.A));
if (action != null)
{
if (PdfName.GOTO.Equals(PdfReader.GetPdfObjectRelease(action.Get(PdfName.S))))
{
dest = PdfReader.GetPdfObjectRelease(action.Get(PdfName.D));
if (dest != null)
{
MapGotoBookmark(map, dest, pages);
}
}
else if (PdfName.URI.Equals(PdfReader.GetPdfObjectRelease(action.Get(PdfName.S))))
{
map["Action"] = "URI";
map["URI"] = ((PdfString)PdfReader.GetPdfObjectRelease(action.Get(PdfName.URI))).ToUnicodeString();
}
else if (PdfName.GOTOR.Equals(PdfReader.GetPdfObjectRelease(action.Get(PdfName.S))))
{
dest = PdfReader.GetPdfObjectRelease(action.Get(PdfName.D));
if (dest != null)
{
if (dest.IsString())
{
map["Named"] = dest.ToString();
}
else if (dest.IsName())
{
map["NamedN"] = PdfName.DecodeName(dest.ToString());
}
else if (dest.IsArray())
{
ArrayList arr = ((PdfArray)dest).ArrayList;
StringBuilder s = new StringBuilder();
s.Append(arr[0].ToString());
s.Append(' ').Append(arr[1].ToString());
for (int k = 2; k < arr.Count; ++k)
{
s.Append(' ').Append(arr[k].ToString());
}
map["Page"] = s.ToString();
}
}
map["Action"] = "GoToR";
PdfObject file = PdfReader.GetPdfObjectRelease(action.Get(PdfName.F));
if (file != null)
{
if (file.IsString())
{
map["File"] = ((PdfString)file).ToUnicodeString();
}
else if (file.IsDictionary())
{
file = PdfReader.GetPdfObject(((PdfDictionary)file).Get(PdfName.F));
if (file.IsString())
{
map["File"] = ((PdfString)file).ToUnicodeString();
}
}
}
PdfObject newWindow = PdfReader.GetPdfObjectRelease(action.Get(PdfName.NEWWINDOW));
if (newWindow != null)
{
map["NewWindow"] = newWindow.ToString();
}
}
else if (PdfName.LAUNCH.Equals(PdfReader.GetPdfObjectRelease(action.Get(PdfName.S))))
{
map["Action"] = "Launch";
PdfObject file = PdfReader.GetPdfObjectRelease(action.Get(PdfName.F));
if (file == null)
{
file = PdfReader.GetPdfObjectRelease(action.Get(PdfName.WIN));
}
if (file != null)
{
if (file.IsString())
{
map["File"] = ((PdfString)file).ToUnicodeString();
}
else if (file.IsDictionary())
{
file = PdfReader.GetPdfObjectRelease(((PdfDictionary)file).Get(PdfName.F));
if (file.IsString())
{
map["File"] = ((PdfString)file).ToUnicodeString();
}
}
}
}
}
}
}
catch {
//empty on purpose
}
PdfDictionary first = (PdfDictionary)PdfReader.GetPdfObjectRelease(outline.Get(PdfName.FIRST));
if (first != null)
{
map["Kids"] = BookmarkDepth(reader, first, pages);
}
list.Add(map);
outline = (PdfDictionary)PdfReader.GetPdfObjectRelease(outline.Get(PdfName.NEXT));
}
return(list);
}
private PdfArray VerifyArraySize(PdfObject obj, int size, String message) {
if (obj == null || !obj.IsArray()) Assert.Fail(message + " is not array");
if (((PdfArray) obj).Size != size)
Assert.Fail(message + " has wrong size");
return (PdfArray) obj;
}
/**
* A constructor from a <CODE>PdfReader</CODE>. It basically does everything
* from finding the XFA stream to the XML parsing.
* @param reader the reader
* @throws java.io.IOException on error
* @throws javax.xml.parsers.ParserConfigurationException on error
* @throws org.xml.sax.SAXException on error
*/
public XfaForm(PdfReader reader)
{
this.reader = reader;
PdfDictionary af = (PdfDictionary)PdfReader.GetPdfObjectRelease(reader.Catalog.Get(PdfName.ACROFORM));
if (af == null)
{
xfaPresent = false;
return;
}
PdfObject xfa = PdfReader.GetPdfObjectRelease(af.Get(PdfName.XFA));
if (xfa == null)
{
xfaPresent = false;
return;
}
xfaPresent = true;
MemoryStream bout = new MemoryStream();
if (xfa.IsArray())
{
ArrayList ar = ((PdfArray)xfa).ArrayList;
for (int k = 1; k < ar.Count; k += 2)
{
PdfObject ob = PdfReader.GetPdfObject((PdfObject)ar[k]);
if (ob != null && ob is PRStream)
{
byte[] b = PdfReader.GetStreamBytes((PRStream)ob);
bout.Write(b, 0, b.Length);
}
}
}
else if (xfa is PRStream)
{
byte[] b = PdfReader.GetStreamBytes((PRStream)xfa);
bout.Write(b, 0, b.Length);
}
bout.Seek(0, SeekOrigin.Begin);
XmlTextReader xtr = new XmlTextReader(bout);
domDocument = new XmlDocument();
domDocument.Load(xtr);
XmlNode n = domDocument.FirstChild;
while (n.NodeType != XmlNodeType.Element)
{
n = n.NextSibling;
}
n = n.FirstChild;
while (n != null)
{
if (n.NodeType == XmlNodeType.Element)
{
String s = n.LocalName;
if (s.Equals("template"))
{
templateNode = n;
templateSom = new Xml2SomTemplate(n);
}
else if (s.Equals("datasets"))
{
datasetsNode = n;
datasetsSom = new Xml2SomDatasets(n.FirstChild);
}
}
n = n.NextSibling;
}
}
