/// <summary>Flushes all modified objects which have not been flushed yet.</summary>
/// <remarks>Flushes all modified objects which have not been flushed yet. Used in case incremental updates.</remarks>
/// <param name="forbiddenToFlush">
/// a
/// <see cref="Java.Util.Set{E}"/>
/// of
/// <see cref="PdfIndirectReference">references</see>
/// that are forbidden to be flushed automatically.
/// </param>
protected internal virtual void FlushModifiedWaitingObjects(ICollection <PdfIndirectReference> forbiddenToFlush
)
{
PdfXrefTable xref = document.GetXref();
for (int i = 1; i < xref.Size(); i++)
{
PdfIndirectReference indirectReference = xref.Get(i);
if (null != indirectReference && !indirectReference.IsFree() && !forbiddenToFlush.Contains(indirectReference
))
{
bool isModified = indirectReference.CheckState(PdfObject.MODIFIED);
if (isModified)
{
PdfObject obj = indirectReference.GetRefersTo(false);
if (obj != null)
{
if (!obj.Equals(objectStream))
{
obj.Flush();
}
}
}
}
}
if (objectStream != null && objectStream.GetSize() > 0)
{
objectStream.Flush();
objectStream = null;
}
}
/// <summary>Flushes all objects which have not been flushed yet.</summary>
/// <param name="forbiddenToFlush">
/// a
/// <see cref="Java.Util.Set{E}"/>
/// of
/// <see cref="PdfIndirectReference">references</see>
/// that are forbidden to be flushed automatically.
/// </param>
protected internal virtual void FlushWaitingObjects(ICollection <PdfIndirectReference> forbiddenToFlush)
{
PdfXrefTable xref = document.GetXref();
bool needFlush = true;
while (needFlush)
{
needFlush = false;
for (int i = 1; i < xref.Size(); i++)
{
PdfIndirectReference indirectReference = xref.Get(i);
if (indirectReference != null && !indirectReference.IsFree() && indirectReference.CheckState(PdfObject.MUST_BE_FLUSHED
) && !forbiddenToFlush.Contains(indirectReference))
{
PdfObject obj = indirectReference.GetRefersTo(false);
if (obj != null)
{
obj.Flush();
needFlush = true;
}
}
}
}
if (objectStream != null && objectStream.GetSize() > 0)
{
objectStream.Flush();
objectStream = null;
}
}
/// <summary>Flushes the object.</summary>
/// <remarks>Flushes the object. Override this method if you want to define custom behaviour for object flushing.
/// </remarks>
/// <param name="pdfObject">object to flush.</param>
/// <param name="canBeInObjStm">indicates whether object can be placed into object stream.</param>
/// <exception cref="System.IO.IOException">on error.</exception>
protected internal virtual void FlushObject(PdfObject pdfObject, bool canBeInObjStm)
{
PdfIndirectReference indirectReference = pdfObject.GetIndirectReference();
if (IsFullCompression() && canBeInObjStm)
{
PdfObjectStream objectStream = GetObjectStream();
objectStream.AddObject(pdfObject);
}
else
{
indirectReference.SetOffset(GetCurrentPos());
WriteToBody(pdfObject);
}
((PdfIndirectReference)indirectReference.SetState(PdfObject.FLUSHED)).ClearState(PdfObject.MUST_BE_FLUSHED
);
switch (pdfObject.GetObjectType())
{
case PdfObject.BOOLEAN:
case PdfObject.NAME:
case PdfObject.NULL:
case PdfObject.NUMBER:
case PdfObject.STRING: {
((PdfPrimitiveObject)pdfObject).content = null;
break;
}
case PdfObject.ARRAY: {
PdfArray array = ((PdfArray)pdfObject);
MarkArrayContentToFlush(array);
array.ReleaseContent();
break;
}
case PdfObject.STREAM:
case PdfObject.DICTIONARY: {
PdfDictionary dictionary = ((PdfDictionary)pdfObject);
MarkDictionaryContentToFlush(dictionary);
dictionary.ReleaseContent();
break;
}
case PdfObject.INDIRECT_REFERENCE: {
MarkObjectToFlush(((PdfIndirectReference)pdfObject).GetRefersTo(false));
break;
}
}
}
/// <summary>Gets the current object stream.</summary>
/// <returns>object stream.</returns>
/// <exception cref="System.IO.IOException"/>
internal virtual PdfObjectStream GetObjectStream()
{
if (!IsFullCompression())
{
return(null);
}
if (objectStream == null)
{
objectStream = new PdfObjectStream(document);
}
else
{
if (objectStream.GetSize() == PdfObjectStream.MAX_OBJ_STREAM_SIZE)
{
objectStream.Flush();
objectStream = new PdfObjectStream(objectStream);
}
}
return(objectStream);
}
/// <summary>Flushes all modified objects which have not been flushed yet.</summary>
/// <remarks>Flushes all modified objects which have not been flushed yet. Used in case incremental updates.</remarks>
protected internal virtual void FlushModifiedWaitingObjects()
{
PdfXrefTable xref = document.GetXref();
for (int i = 1; i < xref.Size(); i++)
{
PdfIndirectReference indirectReference = xref.Get(i);
if (null != indirectReference)
{
PdfObject obj = indirectReference.GetRefersTo(false);
if (obj != null && !obj.Equals(objectStream) && obj.IsModified())
{
obj.Flush();
}
}
}
if (objectStream != null && objectStream.GetSize() > 0)
{
objectStream.Flush();
objectStream = null;
}
}
private void Write(PdfStream pdfStream)
{
try {
bool userDefinedCompression = pdfStream.GetCompressionLevel() != CompressionConstants.UNDEFINED_COMPRESSION;
if (!userDefinedCompression)
{
int defaultCompressionLevel = document != null?document.GetWriter().GetCompressionLevel() : CompressionConstants
.DEFAULT_COMPRESSION;
pdfStream.SetCompressionLevel(defaultCompressionLevel);
}
bool toCompress = pdfStream.GetCompressionLevel() != CompressionConstants.NO_COMPRESSION;
bool allowCompression = !pdfStream.ContainsKey(PdfName.Filter) && IsNotMetadataPdfStream(pdfStream);
if (pdfStream.GetInputStream() != null)
{
Stream fout = this;
DeflaterOutputStream def = null;
OutputStreamEncryption ose = null;
if (crypto != null && !crypto.IsEmbeddedFilesOnly())
{
fout = ose = crypto.GetEncryptionStream(fout);
}
if (toCompress && (allowCompression || userDefinedCompression))
{
UpdateCompressionFilter(pdfStream);
fout = def = new DeflaterOutputStream(fout, pdfStream.GetCompressionLevel(), 0x8000);
}
this.Write((PdfDictionary)pdfStream);
WriteBytes(iText.Kernel.Pdf.PdfOutputStream.stream);
long beginStreamContent = GetCurrentPos();
byte[] buf = new byte[4192];
while (true)
{
int n = pdfStream.GetInputStream().Read(buf);
if (n <= 0)
{
break;
}
fout.Write(buf, 0, n);
}
if (def != null)
{
def.Finish();
}
if (ose != null)
{
ose.Finish();
}
PdfNumber length = pdfStream.GetAsNumber(PdfName.Length);
length.SetValue((int)(GetCurrentPos() - beginStreamContent));
pdfStream.UpdateLength(length.IntValue());
WriteBytes(iText.Kernel.Pdf.PdfOutputStream.endstream);
}
else
{
//When document is opened in stamping mode the output stream can be uninitialized.
//We have to initialize it and write all data from streams input to streams output.
if (pdfStream.GetOutputStream() == null && pdfStream.GetIndirectReference().GetReader() != null)
{
// If new specific compression is set for stream,
// then compressed stream should be decoded and written with new compression settings
byte[] bytes = pdfStream.GetIndirectReference().GetReader().ReadStreamBytes(pdfStream, false);
if (userDefinedCompression)
{
bytes = DecodeFlateBytes(pdfStream, bytes);
}
pdfStream.InitOutputStream(new ByteArrayOutputStream(bytes.Length));
pdfStream.GetOutputStream().Write(bytes);
}
System.Diagnostics.Debug.Assert(pdfStream.GetOutputStream() != null, "PdfStream lost OutputStream");
ByteArrayOutputStream byteArrayStream;
try {
if (toCompress && !ContainsFlateFilter(pdfStream) && (allowCompression || userDefinedCompression))
{
// compress
UpdateCompressionFilter(pdfStream);
byteArrayStream = new ByteArrayOutputStream();
DeflaterOutputStream zip = new DeflaterOutputStream(byteArrayStream, pdfStream.GetCompressionLevel());
if (pdfStream is PdfObjectStream)
{
PdfObjectStream objectStream = (PdfObjectStream)pdfStream;
((ByteArrayOutputStream)objectStream.GetIndexStream().GetOutputStream()).WriteTo(zip);
((ByteArrayOutputStream)objectStream.GetOutputStream().GetOutputStream()).WriteTo(zip);
}
else
{
System.Diagnostics.Debug.Assert(pdfStream.GetOutputStream() != null, "Error in outputStream");
((ByteArrayOutputStream)pdfStream.GetOutputStream().GetOutputStream()).WriteTo(zip);
}
zip.Finish();
}
else
{
if (pdfStream is PdfObjectStream)
{
PdfObjectStream objectStream = (PdfObjectStream)pdfStream;
byteArrayStream = new ByteArrayOutputStream();
((ByteArrayOutputStream)objectStream.GetIndexStream().GetOutputStream()).WriteTo(byteArrayStream);
((ByteArrayOutputStream)objectStream.GetOutputStream().GetOutputStream()).WriteTo(byteArrayStream);
}
else
{
System.Diagnostics.Debug.Assert(pdfStream.GetOutputStream() != null, "Error in outputStream");
byteArrayStream = (ByteArrayOutputStream)pdfStream.GetOutputStream().GetOutputStream();
}
}
if (CheckEncryption(pdfStream))
{
ByteArrayOutputStream encodedStream = new ByteArrayOutputStream();
OutputStreamEncryption ose = crypto.GetEncryptionStream(encodedStream);
byteArrayStream.WriteTo(ose);
ose.Finish();
byteArrayStream = encodedStream;
}
}
catch (System.IO.IOException ioe) {
throw new PdfException(PdfException.IoException, ioe);
}
pdfStream.Put(PdfName.Length, new PdfNumber(byteArrayStream.Length));
pdfStream.UpdateLength((int)byteArrayStream.Length);
this.Write((PdfDictionary)pdfStream);
WriteBytes(iText.Kernel.Pdf.PdfOutputStream.stream);
byteArrayStream.WriteTo(this);
byteArrayStream.Dispose();
WriteBytes(iText.Kernel.Pdf.PdfOutputStream.endstream);
}
}
catch (System.IO.IOException e) {
throw new PdfException(PdfException.CannotWriteToPdfStream, e, pdfStream);
}
}