Beispiel #1
0
        private PdfFormField MergeFieldsWithTheSameName(PdfFormField existingField, PdfFormField newField)
        {
            String    fullFieldName = newField.GetFieldName().ToUnicodeString();
            PdfString fieldName     = newField.GetPdfObject().GetAsString(PdfName.T);

            newField.GetPdfObject().Remove(PdfName.T);
            newField.GetPdfObject().Remove(PdfName.P);
            existingField = formTo.GetField(fullFieldName);
            PdfArray kids = existingField.GetKids();

            if (kids != null && !kids.IsEmpty())
            {
                existingField.AddKid(newField);
                return(existingField);
            }
            existingField.GetPdfObject().Remove(PdfName.T);
            existingField.GetPdfObject().Remove(PdfName.P);
            formTo.GetFields().Remove(existingField.GetPdfObject());
            PdfFormField mergedField = PdfFormField.CreateEmptyField(documentTo);

            mergedField.Put(PdfName.FT, existingField.GetFormType()).Put(PdfName.T, fieldName);
            PdfDictionary parent = existingField.GetParent();

            if (parent != null)
            {
                mergedField.Put(PdfName.Parent, parent);
                PdfArray parentKids = parent.GetAsArray(PdfName.Kids);
                for (int i = 0; i < parentKids.Size(); i++)
                {
                    PdfObject obj = parentKids.Get(i);
                    if (obj == existingField.GetPdfObject())
                    {
                        parentKids.Set(i, mergedField.GetPdfObject());
                        break;
                    }
                }
            }
            kids = existingField.GetKids();
            if (kids != null)
            {
                mergedField.Put(PdfName.Kids, kids);
            }
            mergedField.AddKid(existingField).AddKid(newField);
            PdfObject value = existingField.GetValue();

            if (value != null)
            {
                mergedField.Put(PdfName.V, existingField.GetPdfObject().Get(PdfName.V));
            }
            return(mergedField);
        }
        private PdfFormField MergeFieldsWithTheSameName(PdfFormField existingField, PdfFormField newField)
        {
            String fieldName = newField.GetFieldName().ToUnicodeString();

            existingField.GetPdfObject().Remove(PdfName.T);
            PdfFormField mergedField = formTo.GetField(fieldName);
            PdfArray     kids        = mergedField.GetKids();

            if (kids != null && !kids.IsEmpty())
            {
                mergedField.AddKid(existingField);
                return(mergedField);
            }
            newField.GetPdfObject().Remove(PdfName.T);
            mergedField = PdfFormField.CreateEmptyField(documentTo);
            formTo.GetFields().Remove(newField.GetPdfObject());
            mergedField.Put(PdfName.FT, existingField.GetFormType()).Put(PdfName.T, new PdfString(fieldName));
            PdfDictionary parent = existingField.GetParent();

            if (parent != null)
            {
                mergedField.Put(PdfName.Parent, parent);
            }
            kids = existingField.GetKids();
            if (kids != null)
            {
                mergedField.Put(PdfName.Kids, kids);
            }
            mergedField.AddKid(existingField).AddKid(newField);
            return(mergedField);
        }
        private void CopyParentFormField(PdfPage toPage, IDictionary <String, PdfFormField> fieldsTo, PdfAnnotation
                                         annot, PdfFormField parentField)
        {
            PdfString parentName = parentField.GetFieldName();

            if (!fieldsTo.ContainsKey(parentName.ToUnicodeString()))
            {
                PdfFormField field = CreateParentFieldCopy(annot.GetPdfObject(), documentTo);
                PdfArray     kids  = field.GetKids();
                field.GetPdfObject().Remove(PdfName.Kids);
                formTo.AddField(field, toPage);
                field.GetPdfObject().Put(PdfName.Kids, kids);
            }
            else
            {
                PdfFormField field = MakeFormField(annot.GetPdfObject());
                if (field == null)
                {
                    return;
                }
                PdfString fieldName = field.GetFieldName();
                if (fieldName != null)
                {
                    PdfFormField existingField = fieldsTo.Get(fieldName.ToUnicodeString());
                    if (existingField != null)
                    {
                        PdfFormField mergedField = MergeFieldsWithTheSameName(field);
                        formTo.GetFormFields().Put(mergedField.GetFieldName().ToUnicodeString(), mergedField);
                    }
                    else
                    {
                        HashSet <String> existingFields = new HashSet <String>();
                        GetAllFieldNames(formTo.GetFields(), existingFields);
                        AddChildToExistingParent(annot.GetPdfObject(), existingFields, fieldsTo);
                    }
                }
                else
                {
                    if (!parentField.GetKids().Contains(field.GetPdfObject()))
                    {
                        HashSet <String> existingFields = new HashSet <String>();
                        GetAllFieldNames(formTo.GetFields(), existingFields);
                        AddChildToExistingParent(annot.GetPdfObject(), existingFields);
                    }
                }
            }
        }
        private void CopyExistingField(PdfPage toPage, PdfAnnotation currentAnnot)
        {
            PdfFormField field = MergeFieldsWithTheSameName(PdfFormField.MakeFormField(currentAnnot.GetPdfObject(), toPage
                                                                                       .GetDocument()));
            PdfArray kids = field.GetKids();

            if (kids != null)
            {
                field.GetPdfObject().Remove(PdfName.Kids);
                formTo.AddField(field, toPage);
                field.GetPdfObject().Put(PdfName.Kids, kids);
            }
            else
            {
                formTo.AddField(field, toPage);
            }
        }
 public virtual void Copy(PdfPage fromPage, PdfPage toPage)
 {
     if (documentFrom != fromPage.GetDocument())
     {
         documentFrom = fromPage.GetDocument();
         formFrom     = PdfAcroForm.GetAcroForm(documentFrom, false);
     }
     if (documentTo != toPage.GetDocument())
     {
         documentTo = toPage.GetDocument();
         formTo     = PdfAcroForm.GetAcroForm(documentTo, true);
     }
     if (formFrom != null)
     {
         //duplicate AcroForm dictionary
         IList <PdfName> excludedKeys = new List <PdfName>();
         excludedKeys.Add(PdfName.Fields);
         excludedKeys.Add(PdfName.DR);
         PdfDictionary dict = formFrom.GetPdfObject().CopyTo(documentTo, excludedKeys, false);
         formTo.GetPdfObject().MergeDifferent(dict);
     }
     if (formFrom != null)
     {
         IDictionary <String, PdfFormField> fieldsFrom = formFrom.GetFormFields();
         if (fieldsFrom.Count > 0)
         {
             IDictionary <String, PdfFormField> fieldsTo = formTo.GetFormFields();
             IList <PdfAnnotation> annots = toPage.GetAnnotations();
             foreach (PdfAnnotation annot in annots)
             {
                 if (annot.GetSubtype().Equals(PdfName.Widget))
                 {
                     PdfDictionary parent = annot.GetPdfObject().GetAsDictionary(PdfName.Parent);
                     if (parent != null)
                     {
                         PdfFormField parentField = GetParentField(parent, documentTo);
                         PdfString    parentName  = parentField.GetFieldName();
                         if (parentName == null)
                         {
                             continue;
                         }
                         if (!fieldsTo.ContainsKey(parentName.ToUnicodeString()))
                         {
                             PdfFormField field = CreateParentFieldCopy(annot.GetPdfObject(), documentTo);
                             PdfArray     kids  = field.GetKids();
                             field.GetPdfObject().Remove(PdfName.Kids);
                             formTo.AddField(field, toPage);
                             field.GetPdfObject().Put(PdfName.Kids, kids);
                         }
                         else
                         {
                             PdfFormField field     = PdfFormField.MakeFormField(annot.GetPdfObject(), documentTo);
                             PdfString    fieldName = field.GetFieldName();
                             if (fieldName != null)
                             {
                                 PdfFormField existingField = fieldsTo.Get(fieldName.ToUnicodeString());
                                 if (existingField != null)
                                 {
                                     PdfFormField clonedField = PdfFormField.MakeFormField(field.GetPdfObject().Clone().MakeIndirect(documentTo
                                                                                                                                     ), documentTo);
                                     toPage.GetPdfObject().GetAsArray(PdfName.Annots).Add(clonedField.GetPdfObject());
                                     toPage.RemoveAnnotation(annot);
                                     MergeFieldsWithTheSameName(clonedField);
                                 }
                                 else
                                 {
                                     HashSet <String> existingFields = new HashSet <String>();
                                     GetAllFieldNames(formTo.GetFields(), existingFields);
                                     AddChildToExistingParent(annot.GetPdfObject(), existingFields);
                                 }
                             }
                             else
                             {
                                 if (!parentField.GetKids().Contains(field.GetPdfObject()))
                                 {
                                     HashSet <String> existingFields = new HashSet <String>();
                                     GetAllFieldNames(formTo.GetFields(), existingFields);
                                     AddChildToExistingParent(annot.GetPdfObject(), existingFields);
                                 }
                             }
                         }
                     }
                     else
                     {
                         PdfString annotName       = annot.GetPdfObject().GetAsString(PdfName.T);
                         String    annotNameString = null;
                         if (annotName != null)
                         {
                             annotNameString = annotName.ToUnicodeString();
                         }
                         if (annotNameString != null && fieldsFrom.ContainsKey(annotNameString))
                         {
                             PdfFormField field = fieldsTo.Get(annotNameString);
                             if (field != null)
                             {
                                 PdfDictionary clonedAnnot = (PdfDictionary)annot.GetPdfObject().Clone().MakeIndirect(documentTo);
                                 toPage.GetPdfObject().GetAsArray(PdfName.Annots).Add(clonedAnnot);
                                 toPage.RemoveAnnotation(annot);
                                 field = MergeFieldsWithTheSameName(PdfFormField.MakeFormField(clonedAnnot, toPage.GetDocument()));
                                 logger.Warn(MessageFormatUtil.Format(iText.IO.LogMessageConstant.DOCUMENT_ALREADY_HAS_FIELD, annotNameString
                                                                      ));
                                 PdfArray kids = field.GetKids();
                                 if (kids != null)
                                 {
                                     field.GetPdfObject().Remove(PdfName.Kids);
                                     formTo.AddField(field, toPage);
                                     field.GetPdfObject().Put(PdfName.Kids, kids);
                                 }
                                 else
                                 {
                                     formTo.AddField(field, toPage);
                                 }
                             }
                             else
                             {
                                 formTo.AddField(PdfFormField.MakeFormField(annot.GetPdfObject(), documentTo), null);
                             }
                         }
                     }
                 }
             }
         }
     }
 }
        private PdfFormField MergeFieldsWithTheSameName(PdfFormField newField)
        {
            String    fullFieldName = newField.GetFieldName().ToUnicodeString();
            PdfString fieldName     = newField.GetPdfObject().GetAsString(PdfName.T);

            logger.Warn(MessageFormatUtil.Format(iText.IO.LogMessageConstant.DOCUMENT_ALREADY_HAS_FIELD, fullFieldName
                                                 ));
            PdfFormField existingField = formTo.GetField(fullFieldName);

            if (existingField.IsFlushed())
            {
                int index = 0;
                do
                {
                    index++;
                    newField.SetFieldName(fieldName.ToUnicodeString() + "_#" + index);
                    fullFieldName = newField.GetFieldName().ToUnicodeString();
                }while (formTo.GetField(fullFieldName) != null);
                return(newField);
            }
            newField.GetPdfObject().Remove(PdfName.T);
            newField.GetPdfObject().Remove(PdfName.P);
            formTo.GetFields().Remove(existingField.GetPdfObject());
            PdfArray kids = existingField.GetKids();

            if (kids != null && !kids.IsEmpty())
            {
                existingField.AddKid(newField);
                return(existingField);
            }
            existingField.GetPdfObject().Remove(PdfName.T);
            existingField.GetPdfObject().Remove(PdfName.P);
            PdfFormField mergedField = PdfFormField.CreateEmptyField(documentTo);

            mergedField.Put(PdfName.FT, existingField.GetFormType()).Put(PdfName.T, fieldName);
            PdfDictionary parent = existingField.GetParent();

            if (parent != null)
            {
                mergedField.Put(PdfName.Parent, parent);
                PdfArray parentKids = parent.GetAsArray(PdfName.Kids);
                for (int i = 0; i < parentKids.Size(); i++)
                {
                    PdfObject obj = parentKids.Get(i);
                    if (obj == existingField.GetPdfObject())
                    {
                        parentKids.Set(i, mergedField.GetPdfObject());
                        break;
                    }
                }
            }
            kids = existingField.GetKids();
            if (kids != null)
            {
                mergedField.Put(PdfName.Kids, kids);
            }
            mergedField.AddKid(existingField).AddKid(newField);
            PdfObject value = existingField.GetPdfObject().Get(PdfName.V);

            if (value != null)
            {
                mergedField.Put(PdfName.V, existingField.GetPdfObject().Get(PdfName.V));
            }
            return(mergedField);
        }
        public virtual void Copy(PdfPage fromPage, PdfPage toPage)
        {
            if (documentFrom != fromPage.GetDocument())
            {
                documentFrom = fromPage.GetDocument();
                formFrom     = PdfAcroForm.GetAcroForm(documentFrom, false);
            }
            if (documentTo != toPage.GetDocument())
            {
                documentTo = toPage.GetDocument();
                formTo     = PdfAcroForm.GetAcroForm(documentTo, true);
                if (formFrom != null)
                {
                    //duplicate AcroForm dictionary
                    IList <PdfName> excludedKeys = new List <PdfName>();
                    excludedKeys.Add(PdfName.Fields);
                    excludedKeys.Add(PdfName.DR);
                    PdfDictionary dict = formFrom.GetPdfObject().CopyTo(documentTo, excludedKeys, false);
                    formTo.GetPdfObject().MergeDifferent(dict);
                }
            }
            IList <PdfDictionary> usedParents = new List <PdfDictionary>();

            if (formFrom != null)
            {
                IDictionary <String, PdfFormField> fieldsFrom = formFrom.GetFormFields();
                if (fieldsFrom.Count > 0)
                {
                    IDictionary <String, PdfFormField> fieldsTo = formTo.GetFormFields();
                    IList <PdfAnnotation> annots = toPage.GetAnnotations();
                    foreach (PdfAnnotation annot in annots)
                    {
                        if (annot.GetSubtype().Equals(PdfName.Widget))
                        {
                            PdfDictionary parent = annot.GetPdfObject().GetAsDictionary(PdfName.Parent);
                            if (parent != null)
                            {
                                PdfString parentName = parent.GetAsString(PdfName.T);
                                if (parentName == null)
                                {
                                    continue;
                                }
                                if (!usedParents.Contains(parent))
                                {
                                    PdfFormField field = PdfFormField.MakeFormField(parent, toPage.GetDocument());
                                    field.GetKids().Clear();
                                    formTo.AddField(field, toPage);
                                    usedParents.Add(parent);
                                    field.AddKid((PdfWidgetAnnotation)annot);
                                }
                                else
                                {
                                    parent.GetAsArray(PdfName.Kids).Add(annot.GetPdfObject());
                                }
                            }
                            else
                            {
                                PdfString annotName       = annot.GetPdfObject().GetAsString(PdfName.T);
                                String    annotNameString = null;
                                if (annotName != null)
                                {
                                    annotNameString = annotName.ToUnicodeString();
                                }
                                if (annotNameString != null && fieldsFrom.ContainsKey(annotNameString))
                                {
                                    PdfFormField field = PdfFormField.MakeFormField(annot.GetPdfObject(), toPage.GetDocument());
                                    if (fieldsTo.ContainsKey(annotNameString))
                                    {
                                        field = MergeFieldsWithTheSameName(field, fieldsTo.Get(annotNameString));
                                        ILogger logger = LoggerFactory.GetLogger(typeof(PdfPageFormCopier));
                                        logger.Warn(String.Format(LogMessageConstant.DOCUMENT_ALREADY_HAS_FIELD, annotNameString));
                                    }
                                    formTo.AddField(field, null);
                                }
                            }
                        }
                    }
                }
            }
        }