public PDField(PDAcroForm theAcroForm) 
{
        acroForm = theAcroForm;
        dictionary = new COSDictionary();
        //no required fields in base field class
}

Constructor.

Parameters:

theAcroForm - The form that this field is part of.

 public PDField(PDAcroForm theAcroForm,
    COSDictionary field) 
{
        acroForm = theAcroForm;
        dictionary = field;
}

Creates a COSField from a COSDictionary, expected to be a correct object definition for a field in PDF.

Parameters:

theAcroForm - The form that this field is part of.

field - the PDF objet to represent as a field.

 public String findFieldType() 
{
        return findFieldType( getDictionary() );
}

Find the field type and optionally do a recursive upward search. Sometimes the fieldtype will be specified on the parent instead of the direct object. This will look at this object for the field type, if none is specified then it will look to the parent if there is a parent. If there is no parent and no field type has been found then this will return null.

 public PDField findKid(String[] name,
    int nameIndex) throws IOException 
{
        PDField retval = null;
        COSArray kids = (COSArray)getDictionary().getDictionaryObject( COSName.KIDS );
        if( kids != null )
        {
            for (int i = 0; retval == null && i <  kids.size(); i++)
            {
                COSDictionary kidDictionary = (COSDictionary)kids.getObject(i);
                if( name[nameIndex].equals( kidDictionary.getString( "T" ) ) )
                {
                    retval = PDFieldFactory.createField( acroForm, kidDictionary );
                    if( name.length  > nameIndex+1 )
                    {
                        retval = retval.findKid( name, nameIndex+1 );
                    }
                }
            }
        }
        return retval;
}

This will find one of the child elements. The name array are the components of the name to search down the tree of names. The nameIndex is where to start in that array. This method is called recursively until it finds the end point based on the name array.

 public PDAcroForm getAcroForm() 
{
        return acroForm;
}

This will get the acroform that this field is part of.

 public PDFormFieldAdditionalActions getActions() 
{
        COSDictionary aa = (COSDictionary)dictionary.getDictionaryObject( "AA" );
        PDFormFieldAdditionalActions retval = null;
        if( aa != null )
        {
            retval = new PDFormFieldAdditionalActions( aa );
        }
        return retval;
}

Get the additional actions for this field. This will return null if there are no additional actions for this field.

 public String getAlternateFieldName() 
{
        return this.getDictionary().getString("TU");
}

Gets the alternate name of the field.

 public COSBase getCOSObject() 
{
        return dictionary;
}

Convert this standard java object to a COS object.

 public COSDictionary getDictionary() 
{
        return dictionary;
}

This will get the dictionary associated with this field.

 public int getFieldFlags() 
{
        int retval = 0;
        COSInteger ff = (COSInteger)getDictionary().getDictionaryObject( COSName.getPDFName( "Ff" ) );
        if( ff != null )
        {
            retval = ff.intValue();
        }
        return retval;
}

This will get the flags for this field.

 public String getFieldType() 
{
        return getDictionary().getNameAsString( "FT" );
}

Get the FT entry of the field. This is a read only field and is set depending on the actual type. The field type is an inheritable attribute. This method will return only the direct value on this object. Use the findFieldType for an upward recursive search.

 public String getFullyQualifiedName() throws IOException 
{
        PDField parent = getParent();
        String parentName = null;
        if( parent != null )
        {
            parentName = parent.getFullyQualifiedName();
        }
        String finalName = getPartialName();
        if( parentName != null )
        {
            finalName = parentName + "." + finalName;
        }
        return finalName;
}

Returns the fully qualified name of the field, which is a concatenation of the names of all the parents fields.

 public List getKids() throws IOException 
{
        List retval = null;
        COSArray kids = (COSArray)getDictionary().getDictionaryObject(COSName.KIDS);
        if( kids != null )
        {
            List kidsList = new ArrayList();
            for (int i = 0; i <  kids.size(); i++)
            {
                COSDictionary kidDictionary = (COSDictionary)kids.getObject(i);
                COSDictionary parent = (COSDictionary)kidDictionary.getDictionaryObject( "Parent" );
                if( kidDictionary.getDictionaryObject( "FT" ) != null ||
                    (parent != null && parent.getDictionaryObject( "FT" ) != null ) )
                {
                    kidsList.add( PDFieldFactory.createField( acroForm, kidDictionary ));
                }
                else if( "Widget".equals( kidDictionary.getNameAsString( "Subtype" ) ) )
                {
                    kidsList.add( new PDAnnotationWidget( kidDictionary ) );
                }
                else
                {
                    //
                    kidsList.add( PDFieldFactory.createField( acroForm, kidDictionary ));
                }
            }
            retval = new COSArrayList( kidsList, kids );
        }
        return retval;
}

This will get all the kids of this field. The values in the list will either be PDWidget or PDField. Normally they will be PDWidget objects unless this is a non-terminal field and they will be child PDField objects.

 public PDField getParent() throws IOException 
{
        PDField parent = null;
        COSDictionary parentDic = (COSDictionary)getDictionary().getDictionaryObject( "Parent" );
        if( parentDic != null )
        {
            parent = PDFieldFactory.createField( getAcroForm(), parentDic );
        }
        return parent;
}

Get the parent field to this field, or null if none exists.

 public String getPartialName() 
{
        return getDictionary().getString( "T" );
}

Returns the partial name of the field.

 abstract public String getValue() throws IOException
getValue gets the fields value to as a string.

 public PDAnnotationWidget getWidget() throws IOException 
{
        PDAnnotationWidget retval = null;
        List kids = getKids();
        if( kids == null )
        {
            retval = new PDAnnotationWidget( getDictionary() );
        }
        else if( kids.size()  > 0 )
        {
            Object firstKid = kids.get( 0 );
            if( firstKid instanceof PDAnnotationWidget )
            {
                retval = (PDAnnotationWidget)firstKid;
            }
            else
            {
                retval = ((PDField)firstKid).getWidget();
            }
        }
        else
        {
            retval = null;
        }
        return retval;
}

This will get the single associated widget that is part of this field. This occurs when the Widget is embedded in the fields dictionary. Sometimes there are multiple sub widgets associated with this field, in which case you want to use getKids(). If the kids entry is specified, then the first entry in that list will be returned.

 public  void importFDF(FDFField fdfField) throws IOException 
{
        Object fieldValue = fdfField.getValue();
        int fieldFlags = getFieldFlags();
        if( fieldValue != null )
        {
            if( fieldValue instanceof String )
            {
                setValue( (String)fieldValue );
            }
            else if( fieldValue instanceof PDTextStream )
            {
                setValue( ((PDTextStream)fieldValue).getAsString() );
            }
            else
            {
                throw new IOException( "Unknown field type:" + fieldValue.getClass().getName() );
            }
        }
        Integer ff = fdfField.getFieldFlags();
        if( ff != null )
        {
            setFieldFlags( ff.intValue() );
        }
        else
        {
            //these are suppose to be ignored if the Ff is set.
            Integer setFf = fdfField.getSetFieldFlags();
            if( setFf != null )
            {
                int setFfInt = setFf.intValue();
                fieldFlags = fieldFlags | setFfInt;
                setFieldFlags( fieldFlags );
            }
            Integer clrFf = fdfField.getClearFieldFlags();
            if( clrFf != null )
            {
                //we have to clear the bits of the document fields for every bit that is
                //set in this field.
                //
                //Example:
                //docFf = 1011
                //clrFf = 1101
                //clrFfValue = 0010;
                //newValue = 1011 & 0010 which is 0010
                int clrFfValue = clrFf.intValue();
                clrFfValue ^= 0xFFFFFFFF;
                fieldFlags = fieldFlags & clrFfValue;
                setFieldFlags( fieldFlags );
            }
        }
        PDAnnotationWidget widget = getWidget();
        if( widget != null )
        {
            int annotFlags = widget.getAnnotationFlags();
            Integer f = fdfField.getWidgetFieldFlags();
            if( f != null && widget != null )
            {
                widget.setAnnotationFlags( f.intValue() );
            }
            else
            {
                //these are suppose to be ignored if the F is set.
                Integer setF = fdfField.getSetWidgetFieldFlags();
                if( setF != null )
                {
                    annotFlags = annotFlags | setF.intValue();
                    widget.setAnnotationFlags( annotFlags );
                }
                Integer clrF = fdfField.getClearWidgetFieldFlags();
                if( clrF != null )
                {
                    //we have to clear the bits of the document fields for every bit that is
                    //set in this field.
                    //
                    //Example:
                    //docF = 1011
                    //clrF = 1101
                    //clrFValue = 0010;
                    //newValue = 1011 & 0010 which is 0010
                    int clrFValue = clrF.intValue();
                    clrFValue ^= 0xFFFFFFFFL;
                    annotFlags = annotFlags & clrFValue;
                    widget.setAnnotationFlags( annotFlags );
                }
            }
        }
        List fdfKids = fdfField.getKids();
        List pdKids = getKids();
        for( int i=0; fdfKids != null && i< fdfKids.size(); i++ )
        {
            FDFField fdfChild = (FDFField)fdfKids.get( i );
            String fdfName = fdfChild.getPartialFieldName();
            for( int j=0; j< pdKids.size(); j++ )
            {
                Object pdChildObj = pdKids.get( j );
                if( pdChildObj instanceof PDField )
                {
                    PDField pdChild = (PDField)pdChildObj;
                    if( fdfName != null && fdfName.equals( pdChild.getPartialName() ) )
                    {
                        pdChild.importFDF( fdfChild );
                    }
                }
            }
        }
}

This will import a fdf field from a fdf document.

 public boolean isNoExport() 
{
        return BitFlagHelper.getFlag( getDictionary(), "Ff", FLAG_NO_EXPORT );
}

 public boolean isReadonly() 
{
        return BitFlagHelper.getFlag( getDictionary(), "Ff", FLAG_READ_ONLY );
}

 public boolean isRequired() 
{
        return BitFlagHelper.getFlag( getDictionary(), "Ff", FLAG_REQUIRED );
}

 public  void setAcroForm(PDAcroForm value) 
{
        acroForm = value;
}

This will set the form this field is on.

 public  void setActions(PDFormFieldAdditionalActions actions) 
{
        dictionary.setItem( "AA", actions );
}

Set the actions of the field.

 public  void setAlternateFieldName(String alternateFieldName) 
{
        this.getDictionary().setString("TU", alternateFieldName);
}

This will set the alternate name of the field.

 public  void setFieldFlags(int flags) 
{
        getDictionary().setInt( COSName.getPDFName( "Ff" ), flags );
}

This will set the flags for this field.

 public  void setKids(List kids) 
{
        COSArray kidsArray = COSArrayList.converterToCOSArray( kids );
        getDictionary().setItem( COSName.KIDS, kidsArray );
}

This will set the list of kids.

 public  void setNoExport(boolean noExport) 
{
        BitFlagHelper.setFlag( getDictionary(), "Ff", FLAG_NO_EXPORT, noExport );
}

sets the field to be not exported..

 public  void setParent(PDField parent) 
{
        getDictionary().setItem( "Parent", parent );
}

Set the parent of this field.

 public  void setPartialName(String name) 
{
        getDictionary().setString( "T", name );
}

This will set the partial name of the field.

 public  void setReadonly(boolean readonly) 
{
        BitFlagHelper.setFlag( getDictionary(), "Ff", FLAG_READ_ONLY, readonly );
}

sets the field to be read-only.

 public  void setRequired(boolean required) 
{
        BitFlagHelper.setFlag( getDictionary(), "Ff", FLAG_REQUIRED, required );
}

sets the field to be required.

 abstract public  void setValue(String value) throws IOException
setValue sets the fields value to a given string.

 public String toString() 
{
        return "" + getDictionary().getDictionaryObject( COSName.getPDFName( "V" ) );
}

This will return a string representation of this field.