protected PdfFormField(PdfWriter writer) 
{
        super(writer, null);
        form = true;
        annotation = false;
}

Creates new PdfFormField

 public PdfFormField(PdfWriter writer,
    float llx,
    float lly,
    float urx,
    float ury,
    PdfAction action) 
{
    
        super(writer, llx, lly, urx, ury, action);
        put(PdfName.TYPE, PdfName.ANNOT);
        put(PdfName.SUBTYPE, PdfName.WIDGET);
        annotation = true;
}

Constructs a new PdfAnnotation of subtype link (Action).

 public  void addKid(PdfFormField field) 
{
        field.parent = this;
        if (kids == null)
            kids = new ArrayList();
        kids.add(field);
}

 protected static PdfFormField createButton(PdfWriter writer,
    int flags) 
{
        PdfFormField field = new PdfFormField(writer);
        field.setButton(flags);
        return field;
}

 public static PdfFormField createCheckBox(PdfWriter writer) 
{
        return createButton(writer, 0);
}

 protected static PdfFormField createChoice(PdfWriter writer,
    int flags,
    PdfArray options,
    int topIndex) 
{
        PdfFormField field = new PdfFormField(writer);
        field.put(PdfName.FT, PdfName.CH);
        field.put(PdfName.FF, new PdfNumber(flags));
        field.put(PdfName.OPT, options);
        if (topIndex  > 0)
            field.put(PdfName.TI, new PdfNumber(topIndex));
        return field;
}

 public static PdfFormField createCombo(PdfWriter writer,
    boolean edit,
    String[] options,
    int topIndex) 
{
        return createChoice(writer, FF_COMBO + (edit ? FF_EDIT : 0), processOptions(options), topIndex);
}

 public static PdfFormField createCombo(PdfWriter writer,
    boolean edit,
    String[][] options,
    int topIndex) 
{
        return createChoice(writer, FF_COMBO + (edit ? FF_EDIT : 0), processOptions(options), topIndex);
}

 public static PdfFormField createEmpty(PdfWriter writer) 
{
        PdfFormField field = new PdfFormField(writer);
        return field;
}

 public static PdfFormField createList(PdfWriter writer,
    String[] options,
    int topIndex) 
{
        return createChoice(writer, 0, processOptions(options), topIndex);
}

 public static PdfFormField createList(PdfWriter writer,
    String[][] options,
    int topIndex) 
{
        return createChoice(writer, 0, processOptions(options), topIndex);
}

 public static PdfFormField createPushButton(PdfWriter writer) 
{
        return createButton(writer, FF_PUSHBUTTON);
}

 public static PdfFormField createRadioButton(PdfWriter writer,
    boolean noToggleToOff) 
{
        return createButton(writer, FF_RADIO + (noToggleToOff ? FF_NO_TOGGLE_TO_OFF : 0));
}

 public static PdfFormField createSignature(PdfWriter writer) 
{
        PdfFormField field = new PdfFormField(writer);
        field.put(PdfName.FT, PdfName.SIG);
        return field;
}

 public static PdfFormField createTextField(PdfWriter writer,
    boolean multiline,
    boolean password,
    int maxLen) 
{
        PdfFormField field = new PdfFormField(writer);
        field.put(PdfName.FT, PdfName.TX);
        int flags = (multiline ? FF_MULTILINE : 0);
        flags += (password ? FF_PASSWORD : 0);
        field.put(PdfName.FF, new PdfNumber(flags));
        if (maxLen  > 0)
            field.put(PdfName.MAXLEN, new PdfNumber(maxLen));
        return field;
}

 public ArrayList getKids() 
{
        return kids;
}

 public PdfFormField getParent() 
{
        return parent;
}

Getter for property parent.

 static  void mergeResources(PdfDictionary result,
    PdfDictionary source) 
{
        mergeResources(result, source, null);
}

 static  void mergeResources(PdfDictionary result,
    PdfDictionary source,
    PdfStamperImp writer) 
{
        PdfDictionary dic = null;
        PdfDictionary res = null;
        PdfName target = null;
        for (int k = 0; k <  mergeTarget.length; ++k) {
            target = mergeTarget[k];
            PdfDictionary pdfDict = (PdfDictionary)PdfReader.getPdfObject(source.get(target));
            if ((dic = pdfDict) != null) {
                if ((res = (PdfDictionary)PdfReader.getPdfObject(result.get(target), result)) == null) {
                    res = new PdfDictionary();
                }
                res.mergeDifferent(dic);
                result.put(target, res);
                if (writer != null)
                    writer.markUsed(res);
            }
        }
}

 protected static PdfArray processOptions(String[] options) 
{
        PdfArray array = new PdfArray();
        for (int k = 0; k <  options.length; ++k) {
            array.add(new PdfString(options[k], PdfObject.TEXT_UNICODE));
        }
        return array;
}

 protected static PdfArray processOptions(String[][] options) 
{
        PdfArray array = new PdfArray();
        for (int k = 0; k <  options.length; ++k) {
            String subOption[] = options[k];
            PdfArray ar2 = new PdfArray(new PdfString(subOption[0], PdfObject.TEXT_UNICODE));
            ar2.add(new PdfString(subOption[1], PdfObject.TEXT_UNICODE));
            array.add(ar2);
        }
        return array;
}

 public  void setButton(int flags) 
{
        put(PdfName.FT, PdfName.BTN);
        if (flags != 0)
            put(PdfName.FF, new PdfNumber(flags));
}

 public  void setDefaultValueAsName(String s) 
{
        put(PdfName.DV, new PdfName(s));
}

 public  void setDefaultValueAsString(String s) 
{
        put(PdfName.DV, new PdfString(s, PdfObject.TEXT_UNICODE));
}

 public int setFieldFlags(int flags) 
{
        PdfNumber obj = (PdfNumber)get(PdfName.FF);
        int old;
        if (obj == null)
            old = 0;
        else
            old = obj.intValue();
        int v = old | flags;
        put(PdfName.FF, new PdfNumber(v));
        return old;
}

 public  void setFieldName(String s) 
{
        if (s != null)
            put(PdfName.T, new PdfString(s, PdfObject.TEXT_UNICODE));
}

 public  void setMappingName(String s) 
{
        put(PdfName.TM, new PdfString(s, PdfObject.TEXT_UNICODE));
}

 public  void setQuadding(int v) 
{
        put(PdfName.Q, new PdfNumber(v));
}

 public  void setUsed() 
{
        used = true;
        if (parent != null)
            put(PdfName.PARENT, parent.getIndirectReference());
        if (kids != null) {
            PdfArray array = new PdfArray();
            for (int k = 0; k <  kids.size(); ++k)
                array.add(((PdfFormField)kids.get(k)).getIndirectReference());
            put(PdfName.KIDS, array);
        }
        if (templates == null)
            return;
        PdfDictionary dic = new PdfDictionary();
        for (Iterator it = templates.keySet().iterator(); it.hasNext();) {
            PdfTemplate template = (PdfTemplate)it.next();
            mergeResources(dic, (PdfDictionary)template.getResources());
        }
        put(PdfName.DR, dic);
}

 public  void setUserName(String s) 
{
        put(PdfName.TU, new PdfString(s, PdfObject.TEXT_UNICODE));
}

 public  void setValue(PdfSignature sig) 
{
        put(PdfName.V, sig);
}

 public  void setValueAsName(String s) 
{
        put(PdfName.V, new PdfName(s));
}

 public  void setValueAsString(String s) 
{
        put(PdfName.V, new PdfString(s, PdfObject.TEXT_UNICODE));
}

 public  void setWidget(Rectangle rect,
    PdfName highlight) 
{
        put(PdfName.TYPE, PdfName.ANNOT);
        put(PdfName.SUBTYPE, PdfName.WIDGET);
        put(PdfName.RECT, new PdfRectangle(rect));
        annotation = true;
        if (highlight != null && !highlight.equals(HIGHLIGHT_INVERT))
            put(PdfName.H, highlight);
}

 public static PdfAnnotation shallowDuplicate(PdfAnnotation annot) 
{
        PdfAnnotation dup;
        if (annot.isForm()) {
            dup = new PdfFormField(annot.writer);
            PdfFormField dupField = (PdfFormField)dup;
            PdfFormField srcField = (PdfFormField)annot;
            dupField.parent = srcField.parent;
            dupField.kids = srcField.kids;
        }
        else
            dup = new PdfAnnotation(annot.writer, null);
        dup.merge(annot);
        dup.form = annot.form;
        dup.annotation = annot.annotation;
        dup.templates = annot.templates;
        return dup;
}