private static bool OrderBranchContainsSetElements(PdfObject arrayObj, PdfArray array, int currentIndex, ICollection
<PdfIndirectReference> ocgs, PdfArray toOcgs, PdfDocument toDocument) {
if (arrayObj.IsDictionary()) {
if (ocgs.Contains(arrayObj.GetIndirectReference())) {
return true;
}
else {
if (currentIndex < (array.Size() - 1) && array.Get(currentIndex + 1).IsArray()) {
PdfArray nextArray = array.GetAsArray(currentIndex + 1);
if (!nextArray.Get(0).IsString()) {
bool result = iText.Kernel.Pdf.OcgPropertiesCopier.OrderBranchContainsSetElements(nextArray, array, currentIndex
+ 1, ocgs, toOcgs, toDocument);
if (result && toOcgs != null && !ocgs.Contains(arrayObj.GetIndirectReference())) {
// Add the OCG to the OCGs array to register the OCG in document, since it is not used
// directly in the document, but is used as a parent for the order group. If it is not added
// to the OCGs array, then the OCG will be deleted at the 3rd stage of the /Order entry coping.
toOcgs.Add(arrayObj.CopyTo(toDocument, false));
}
return result;
}
}
}
}
else {
if (arrayObj.IsArray()) {
PdfArray arrayItem = (PdfArray)arrayObj;
for (int i = 0; i < arrayItem.Size(); i++) {
PdfObject obj = arrayItem.Get(i);
if (iText.Kernel.Pdf.OcgPropertiesCopier.OrderBranchContainsSetElements(obj, arrayItem, i, ocgs, toOcgs, toDocument
)) {
return true;
}
}
if (!arrayItem.IsEmpty() && !arrayItem.Get(0).IsString()) {
if (currentIndex > 0 && array.Get(currentIndex - 1).IsDictionary()) {
PdfDictionary previousDict = (PdfDictionary)array.Get(currentIndex - 1);
return ocgs.Contains(previousDict.GetIndirectReference());
}
}
}
}
return false;
}
private PdfArray GetDestArray(PdfObject obj)
{
if (obj == null)
{
return(null);
}
if (obj.IsArray())
{
return((PdfArray)obj);
}
else
{
if (obj.IsDictionary())
{
PdfArray arr = ((PdfDictionary)obj).GetAsArray(PdfName.D);
return(arr);
}
}
return(null);
}
public virtual SerializedObjectContent SerializeObject(PdfObject obj)
{
if (!obj.IsStream() && !obj.IsDictionary())
{
return(null);
}
PdfIndirectReference indRef = obj.GetIndirectReference();
System.Diagnostics.Debug.Assert(indRef != null);
IDictionary <PdfIndirectReference, byte[]> serializedCache = indRef.GetDocument().serializedObjectsCache;
byte[] content = serializedCache.Get(indRef);
if (content == null)
{
ByteBuffer bb = new ByteBuffer();
int level = 100;
SerObject(obj, bb, level, serializedCache);
content = bb.ToByteArray();
}
return(new SerializedObjectContent(content));
}
private static void GetUsedNonFlushedOCGsFromOcDict(PdfObject toObj, PdfObject fromObj, ICollection<PdfIndirectReference
> fromUsedOcgs, PdfDictionary toOcProperties) {
if (toObj != null && toObj.IsDictionary() && !toObj.IsFlushed()) {
PdfDictionary toCurrDict = (PdfDictionary)toObj;
PdfDictionary fromCurrDict = (PdfDictionary)fromObj;
PdfName typeName = toCurrDict.GetAsName(PdfName.Type);
if (PdfName.OCG.Equals(typeName) && !iText.Kernel.Pdf.OcgPropertiesCopier.OcgAlreadyInOCGs(toCurrDict.GetIndirectReference
(), toOcProperties)) {
fromUsedOcgs.Add(fromCurrDict.GetIndirectReference());
}
else {
if (PdfName.OCMD.Equals(typeName)) {
PdfArray toOcgs = null;
PdfArray fromOcgs = null;
if (toCurrDict.GetAsDictionary(PdfName.OCGs) != null) {
toOcgs = new PdfArray();
toOcgs.Add(toCurrDict.GetAsDictionary(PdfName.OCGs));
fromOcgs = new PdfArray();
fromOcgs.Add(fromCurrDict.GetAsDictionary(PdfName.OCGs));
}
else {
if (toCurrDict.GetAsArray(PdfName.OCGs) != null) {
toOcgs = toCurrDict.GetAsArray(PdfName.OCGs);
fromOcgs = fromCurrDict.GetAsArray(PdfName.OCGs);
}
}
if (toOcgs != null && !toOcgs.IsFlushed()) {
for (int i = 0; i < toOcgs.Size(); i++) {
iText.Kernel.Pdf.OcgPropertiesCopier.GetUsedNonFlushedOCGsFromOcDict(toOcgs.Get(i), fromOcgs.Get(i), fromUsedOcgs
, toOcProperties);
}
}
}
}
}
}
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());
}
}
private static bool CheckTypeOfPdfDictionary(PdfObject dictionary, PdfName expectedType)
{
return(dictionary.IsDictionary() && expectedType.Equals(((PdfDictionary)dictionary).GetAsName(PdfName.Type
)));
}
// 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);
}
}
