public FDFDictionary() 
{
        fdf = new COSDictionary();
}

Default constructor.

 public FDFDictionary(COSDictionary fdfDictionary) 
{
        fdf = fdfDictionary;
}

Constructor.

Parameters:

fdfDictionary - The FDF documents catalog.

 public FDFDictionary(Element fdfXML) throws IOException 
{
        this();
        NodeList nodeList = fdfXML.getChildNodes();
        for( int i=0; i< nodeList.getLength(); i++ )
        {
            Node node = nodeList.item( i );
            if( node instanceof Element )
            {
                Element child = (Element)node;
                if( child.getTagName().equals( "f" ) )
                {
                    PDSimpleFileSpecification fs = new PDSimpleFileSpecification();
                    fs.setFile( child.getAttribute( "href" ) );
                    setFile(fs);
                }
                else if( child.getTagName().equals( "ids" ) )
                {
                    COSArray ids = new COSArray();
                    String original = child.getAttribute( "original" );
                    String modified = child.getAttribute( "modified" );
                    ids.add( COSString.createFromHexString( original ) );
                    ids.add( COSString.createFromHexString( modified ) );
                    setID( ids );
                }
                else if( child.getTagName().equals( "fields" ) )
                {
                    NodeList fields = child.getElementsByTagName( "field" );
                    List fieldList = new ArrayList();
                    for( int f=0; f< fields.getLength(); f++ )
                    {
                        fieldList.add( new FDFField( (Element)fields.item( f ) ) );
                    }
                    setFields( fieldList );
                }
                else if( child.getTagName().equals( "annots" ) )
                {
                    NodeList annots = child.getChildNodes();
                    List annotList = new ArrayList();
                    for( int j=0; j< annots.getLength(); j++ )
                    {
                        Node annotNode = annots.item( i );
                        if( annotNode instanceof Element )
                        {
                            Element annot = (Element)annotNode;
                            if( annot.getNodeName().equals( "text" ) )
                            {
                                annotList.add( new FDFAnnotationText( annot ) );
                            }
                            else
                            {
                                throw new IOException( "Error: Unknown annotation type '" + annot.getNodeName() );
                            }
                        }
                    }
                    setAnnotations(annotList);
                }
            }
        }
}

This will create an FDF dictionary from an XFDF XML document.

Parameters:

fdfXML - The XML document that contains the XFDF data.

Throws:

IOException - If there is an error reading from the dom.

 public List getAnnotations() throws IOException 
{
        List retval = null;
        COSArray annotArray = (COSArray)fdf.getDictionaryObject( "Annots" );
        if( annotArray != null )
        {
            List annots = new ArrayList();
            for( int i=0; i< annotArray.size(); i++ )
            {
                annots.add( FDFAnnotation.create( (COSDictionary)annotArray.getObject( i ) ) );
            }
            retval = new COSArrayList( annots, annotArray );
        }
        return retval;
}

This will get the list of FDF Annotations. This will return a list of FDFAnnotation objects or null if the entry is not set.

 public COSDictionary getCOSDictionary() 
{
        return fdf;
}

Convert this standard java object to a COS object.

 public COSBase getCOSObject() 
{
        return fdf;
}

Convert this standard java object to a COS object.

 public COSStream getDifferences() 
{
        return (COSStream)fdf.getDictionaryObject( "Differences" );
}

This will get the incremental updates since the PDF was last opened.

 public List getEmbeddedFDFs() throws IOException 
{
        List retval = null;
        COSArray embeddedArray = (COSArray)fdf.getDictionaryObject( "EmbeddedFDFs" );
        if( embeddedArray != null )
        {
            List embedded = new ArrayList();
            for( int i=0; i< embeddedArray.size(); i++ )
            {
                embedded.add( PDFileSpecification.createFS( embeddedArray.get( i ) ) );
            }
            retval = new COSArrayList( embedded, embeddedArray );
        }
        return retval;
}

This will get the list of embedded FDF entries, or null if the entry is null. This will return a list of PDFileSpecification objects.

 public String getEncoding() 
{
        String encoding = fdf.getNameAsString( "Encoding" );
        if( encoding == null )
        {
            encoding = "PDFDocEncoding";
        }
        return encoding;
}

The encoding to be used for a FDF field. The default is PDFDocEncoding and this method will never return null.

 public List getFields() 
{
        List retval = null;
        COSArray fieldArray = (COSArray)fdf.getDictionaryObject( "Fields" );
        if( fieldArray != null )
        {
            List fields = new ArrayList();
            for( int i=0; i< fieldArray.size(); i++ )
            {
                fields.add( new FDFField( (COSDictionary)fieldArray.getObject( i ) ) );
            }
            retval = new COSArrayList( fields, fieldArray );
        }
        return retval;
}

This will get the list of FDF Fields. This will return a list of FDFField objects.

 public PDFileSpecification getFile() throws IOException 
{
        return PDFileSpecification.createFS( fdf.getDictionaryObject( "F" ) );
}

The source file or target file: the PDF document file that this FDF file was exported from or is intended to be imported into.

 public COSArray getID() 
{
        return (COSArray)fdf.getDictionaryObject( "ID" );
}

This is the FDF id.

 public FDFJavaScript getJavaScript() 
{
        FDFJavaScript fs = null;
        COSDictionary dic = (COSDictionary)fdf.getDictionaryObject( "JavaScript" );
        if( dic != null )
        {
            fs = new FDFJavaScript( dic );
        }
        return fs;
}

This will get the java script entry.

 public List getPages() 
{
        List retval = null;
        COSArray pageArray = (COSArray)fdf.getDictionaryObject( "Pages" );
        if( pageArray != null )
        {
            List pages = new ArrayList();
            for( int i=0; i< pageArray.size(); i++ )
            {
                pages.add( new FDFPage( (COSDictionary)pageArray.get( i ) ) );
            }
            retval = new COSArrayList( pages, pageArray );
        }
        return retval;
}

This will get the list of FDF Pages. This will return a list of FDFPage objects.

 public String getStatus() 
{
        return fdf.getString( "Status" );
}

This will get the status string to be displayed as the result of an action.

 public String getTarget() 
{
        return fdf.getString( "Target" );
}

This will get the target frame in the browser to open this document.

 public  void setAnnotations(List annots) 
{
        fdf.setItem( "Annots", COSArrayList.converterToCOSArray( annots ) );
}

This will set the list of annotations. This should be a list of FDFAnnotation objects.

 public  void setDifferences(COSStream diff) 
{
        fdf.setItem( "Differences", diff );
}

This will set the differences stream.

 public  void setEmbeddedFDFs(List embedded) 
{
        fdf.setItem( "EmbeddedFDFs", COSArrayList.converterToCOSArray( embedded ) );
}

This will set the list of embedded FDFs. This should be a list of PDFileSpecification objects.

 public  void setEncoding(String encoding) 
{
        fdf.setName( "Encoding", encoding );
}

This will set the encoding.

 public  void setFields(List fields) 
{
        fdf.setItem( "Fields", COSArrayList.converterToCOSArray( fields ) );
}

This will set the list of fields. This should be a list of FDFField objects.

 public  void setFile(PDFileSpecification fs) 
{
        fdf.setItem( "F", fs );
}

This will set the file specification.

 public  void setID(COSArray id) 
{
        fdf.setItem( "ID", id );
}

This will set the FDF id.

 public  void setJavaScript(FDFJavaScript js) 
{
        fdf.setItem( "JavaScript", js );
}

This will set the JavaScript entry.

 public  void setPages(List pages) 
{
        fdf.setItem( "Pages", COSArrayList.converterToCOSArray( pages ) );
}

This will set the list of pages. This should be a list of FDFPage objects.

 public  void setStatus(String status) 
{
        fdf.setString( "Status", status );
}

This will set the status string.

 public  void setTarget(String target) 
{
        fdf.setString( "Target", target );
}

This will set the target frame in the browser to open this document.

 public  void writeXML(Writer output) throws IOException 
{
        PDFileSpecification fs = this.getFile();
        if( fs != null )
        {
            output.write( "< f href=\"" + fs.getFile() + "\" / >\n" );
        }
        COSArray ids = this.getID();
        if( ids != null )
        {
            COSString original = (COSString)ids.getObject( 0 );
            COSString modified = (COSString)ids.getObject( 1 );
            output.write( "< ids original=\"" + original.getHexString() + "\" " );
            output.write( "modified=\"" + modified.getHexString() + "\" / >\n");
        }
        List fields = getFields();
        if( fields != null && fields.size()  > 0 )
        {
            output.write( "< fields >\n" );
            for( int i=0; i< fields.size(); i++ )
            {
                ((FDFField)fields.get( i )).writeXML( output );
            }
            output.write( "< /fields >\n" );
        }
}

This will write this element as an XML document.