/// <summary> /// Processes two cases of object copying: /// <list type="number"> /// <item><description>copying to the other document /// </description></item> /// <item><description>cloning inside of the current document /// </description></item> /// </list> /// </summary> /// <remarks> /// Processes two cases of object copying: /// <list type="number"> /// <item><description>copying to the other document /// </description></item> /// <item><description>cloning inside of the current document /// </description></item> /// </list> /// <para /> /// This two cases are distinguished by the state of /// <c>document</c> /// parameter: /// the second case is processed if /// <c>document</c> /// is /// <see langword="null"/>. /// </remarks> /// <param name="documentTo">if not null: document to copy object to; otherwise indicates that object is to be cloned. /// </param> /// <param name="allowDuplicating"> /// indicates if to allow copy objects which already have been copied. /// If object is associated with any indirect reference and allowDuplicating is false then already existing reference will be returned instead of copying object. /// If allowDuplicating is true then object will be copied and new indirect reference will be assigned. /// </param> /// <returns>copied object.</returns> internal virtual PdfObject ProcessCopying(PdfDocument documentTo, bool allowDuplicating) { if (documentTo != null) { //copyTo case PdfWriter writer = documentTo.GetWriter(); if (writer == null) { throw new PdfException(PdfException.CannotCopyToDocumentOpenedInReadingMode); } return(writer.CopyObject(this, documentTo, allowDuplicating)); } else { //clone case PdfObject obj = this; if (obj.IsIndirectReference()) { PdfObject refTo = ((PdfIndirectReference)obj).GetRefersTo(); obj = refTo != null ? refTo : obj; } if (obj.IsIndirect() && !allowDuplicating) { return(obj); } return(obj.Clone()); } }
/// <exception cref="System.Exception"/> private void TestFile(String filename, int page, String objectid) { PdfDocument pdfDocument = new PdfDocument(new PdfReader(sourceFolder + filename)); try { PdfResources resources = pdfDocument.GetPage(page).GetResources(); PdfDictionary xobjets = resources.GetResource(PdfName.XObject); PdfObject obj = xobjets.Get(new PdfName(objectid)); if (obj == null) { throw new ArgumentNullException("Reference " + objectid + " not found - Available keys are " + xobjets.KeySet ()); } PdfImageXObject img = new PdfImageXObject((PdfStream)(obj.IsIndirectReference() ? ((PdfIndirectReference)obj ).GetRefersTo() : obj)); byte[] result = img.GetImageBytes(true); NUnit.Framework.Assert.IsNotNull(result); int zeroCount = 0; foreach (byte b in result) { if (b == 0) { zeroCount++; } } NUnit.Framework.Assert.IsTrue(zeroCount > 0); } finally { pdfDocument.Close(); } }
internal static bool EqualContent(PdfObject obj1, PdfObject obj2) { PdfObject direct1 = obj1 != null && obj1.IsIndirectReference() ? ((PdfIndirectReference)obj1).GetRefersTo( true) : obj1; PdfObject direct2 = obj2 != null && obj2.IsIndirectReference() ? ((PdfIndirectReference)obj2).GetRefersTo( true) : obj2; return(direct1 != null && direct1.Equals(direct2)); }
protected internal virtual int GetCopyObjectKey(PdfObject obj) { PdfIndirectReference reference; if (obj.IsIndirectReference()) { reference = (PdfIndirectReference)obj; } else { reference = obj.GetIndirectReference(); } int result = reference.GetHashCode(); result = 31 * result + reference.GetDocument().GetHashCode(); return(result); }
public virtual ICollection <KeyValuePair <PdfName, PdfObject> > DirectEntrySet() { IDictionary <PdfName, PdfObject> directMap = new SortedDictionary <PdfName, PdfObject>(); foreach (KeyValuePair <PdfName, PdfObject> entry in map) { PdfObject value = entry.Value; if (value.IsIndirectReference()) { directMap[entry.Key] = ((PdfIndirectReference)value).GetRefersTo(); } else { directMap[entry.Key] = value; } } return(directMap); }
private void FlushObjectRecursively(PdfObject obj, PageFlushingHelper.DeepFlushingContext context) { if (obj == null) { return; } bool avoidReleaseForIndirectObjInstance = false; if (obj.IsIndirectReference()) { PdfIndirectReference indRef = (PdfIndirectReference)obj; if (indRef.refersTo == null || indRef.CheckState(PdfObject.FLUSHED)) { return; } obj = indRef.GetRefersTo(); } else { if (obj.IsFlushed()) { return; } else { if (release && obj.IsIndirect()) { // We should avoid the case when object is going to be released but is stored in containing object // not as indirect reference. This can happen when containing object is somehow modified. // Generally containing objects should not contain released read-only object instance. System.Diagnostics.Debug.Assert(obj.IsReleaseForbidden() || obj.GetIndirectReference() == null); avoidReleaseForIndirectObjInstance = true; } } } if (pdfDoc.IsDocumentFont(obj.GetIndirectReference()) || layersRefs.Contains(obj.GetIndirectReference())) { return; } if (obj.IsDictionary() || obj.IsStream()) { if (!currNestedObjParents.Add(obj)) { return; } FlushDictRecursively((PdfDictionary)obj, context); currNestedObjParents.Remove(obj); } else { if (obj.IsArray()) { if (!currNestedObjParents.Add(obj)) { return; } PdfArray array = (PdfArray)obj; for (int i = 0; i < array.Size(); ++i) { FlushObjectRecursively(array.Get(i, false), context); } currNestedObjParents.Remove(obj); } } if (!avoidReleaseForIndirectObjInstance) { FlushOrRelease(obj); } }
private void SerObject(PdfObject obj, ByteBuffer bb, int level, IDictionary <PdfIndirectReference, byte[]> serializedCache) { if (level <= 0) { return; } if (obj == null) { bb.Append("$Lnull"); return; } PdfIndirectReference reference = null; ByteBuffer savedBb = null; if (obj.IsIndirectReference()) { reference = (PdfIndirectReference)obj; byte[] cached = serializedCache.Get(reference); if (cached != null) { bb.Append(cached); return; } else { savedBb = bb; bb = new ByteBuffer(); obj = reference.GetRefersTo(); } } if (obj.IsStream()) { SerDic((PdfDictionary)obj, bb, level - 1, serializedCache); bb.Append("$B"); if (level > 0) { bb.Append(md5.Digest(((PdfStream)obj).GetBytes(false))); } } else { if (obj.IsDictionary()) { SerDic((PdfDictionary)obj, bb, level - 1, serializedCache); } else { if (obj.IsArray()) { SerArray((PdfArray)obj, bb, level - 1, serializedCache); } else { if (obj.IsString()) { bb.Append("$S").Append(obj.ToString()); } else { // TODO specify length for strings, streams, may be names? if (obj.IsName()) { bb.Append("$N").Append(obj.ToString()); } else { bb.Append("$L").Append(obj.ToString()); } } } } } // PdfNull case is also here if (savedBb != null) { serializedCache.Put(reference, bb.ToByteArray()); savedBb.Append(bb.GetInternalBuffer()); } }
// TODO 2: object is not checked if it was already serialized on start, double work could be done // TODO 3: indirect objects often stored multiple times as parts of the other objects private void SerObject(PdfObject obj, int level, ByteBufferOutputStream bb) { if (level <= 0) { return; } if (obj == null) { bb.Append("$Lnull"); return; } PdfIndirectReference reference = null; ByteBufferOutputStream savedBb = null; int indRefKey = -1; if (obj.IsIndirectReference()) { reference = (PdfIndirectReference)obj; indRefKey = CalculateIndRefKey(reference); byte[] cached = objToSerializedContent.Get(indRefKey); if (cached != null) { bb.Append(cached); return; } else { savedBb = bb; bb = new ByteBufferOutputStream(); obj = reference.GetRefersTo(); } } if (obj.IsStream()) { bb.Append("$B"); SerDic((PdfDictionary)obj, level - 1, bb); if (level > 0) { md5.Reset(); bb.Append(md5.Digest(((PdfStream)obj).GetBytes(false))); } } 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()); } } } } } // PdfNull case is also here if (savedBb != null) { objToSerializedContent[indRefKey] = bb.GetBuffer(); savedBb.Append(bb); } }
private void SerObject(PdfObject obj, int level, ByteBufferOutputStream bb, IntHashtable serialized) { if (level <= 0) { return; } if (obj == null) { bb.Append("$Lnull"); return; } PdfIndirectReference reference = null; ByteBufferOutputStream savedBb = null; if (obj.IsIndirectReference()) { reference = (PdfIndirectReference)obj; int key = GetCopyObjectKey(obj); if (serialized.ContainsKey(key)) { bb.Append((int)serialized.Get(key)); return; } else { savedBb = bb; bb = new ByteBufferOutputStream(); } } if (obj.IsStream()) { bb.Append("$B"); SerDic((PdfDictionary)obj, level - 1, bb, serialized); if (level > 0) { md5.Reset(); bb.Append(md5.Digest(((PdfStream)obj).GetBytes(false))); } } 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) { int key = GetCopyObjectKey(reference); if (!serialized.ContainsKey(key)) { serialized.Put(key, CalculateHash(bb.GetBuffer())); } savedBb.Append(bb); } }