insert header and footer with POI HWPF?

[juan sebastian sanchez]

hi! I need your help!

how do you insert header and footer with POI HWPF? how can I replace a word in a World's document with POI wihtout a corruption file?

Thanks to somebody wich answer!

[Ulf Dittmer]

I don't think HWPF supports adding headers or footers directly, but if you base your document on an existing one (as demonstrated in http://faq.javaranch.com/java/CreateWordDocument) you may be able to use any header/footer that happens to exist in that document already.

Replacing text inside of a DOC document is discussed in this topic.

[juan sebastian sanchez]

Ulf Dittmer wrote:I don't think HWPF supports adding headers or footers directly, but if you base your document on an existing one (as demonstrated in http://faq.javaranch.com/java/CreateWordDocument) you may be able to use any header/footer that happens to exist in that document already.

Replacing text inside of a DOC document is discussed in this topic.

hi

when I replace words of different length the result file is corrupt

do you know why this happend?

thank for your help

[Ulf Dittmer]

How are you doing the replacing? Post the relevant code here.

[juan sebastian sanchez]

Hi the code that I am used are this two classes:
1- http://test.javaranch.com/ulf/InsertText.java
2- http://test.javaranch.com/ulf/ParagraphText.java
I am replacing the method piece.usesUnicode() for piece.isUnicode()
I am using POI 3.2 and also test with POI 3.5 beta 6
I have another class for replace words, is this:

 package com.prueba.seb;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

import org.apache.poi.hpsf.CustomProperties;
import org.apache.poi.hpsf.DocumentSummaryInformation;
import org.apache.poi.hwpf.HWPFDocument;
import org.apache.poi.hwpf.usermodel.CharacterRun;
import org.apache.poi.hwpf.usermodel.Paragraph;
import org.apache.poi.hwpf.usermodel.Range;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;

public class CreateWordDoc {
public static void main(String[] args) throws Exception {


HashMap<String, String> replacements = new HashMap<String, String>();
replacements.put("HOLAMAMA", "2012-03");
replacements.put("CLAVEPA", "102003");
Paragraph paragraph = null;
CharacterRun charRun = null;
Set<String> keySet = null;
Iterator<String> keySetIterator = null;
int numCharRuns = 0;
String text = null;
Range docRange = null;
String key = null;
String value = null;
keySet = replacements.keySet();
// POI apparently can't create a document from scratch,
// so we need an existing empty dummy document
POIFSFileSystem fs = new POIFSFileSystem(new FileInputStream(
"c:\\plantilla1.doc"));
HWPFDocument doc = new HWPFDocument(fs);
Range r1 = doc.getRange();


for (int i = 0; i < r1.numParagraphs(); i++) {
paragraph = r1.getParagraph(i);
text = paragraph.text();
numCharRuns = paragraph.numCharacterRuns();
for (int j = 0; j < numCharRuns; j++) {
charRun = paragraph.getCharacterRun(j);
text = charRun.text().trim();
System.out.println("Character Run text: " + text);
keySetIterator = keySet.iterator();
while (keySetIterator.hasNext()) {
key = keySetIterator.next();
if (text.contains(key)) {
value = replacements.get(key);
charRun.replaceText(key.trim(), value.trim());
charRun.insertBefore(value.trim());
docRange = doc.getRange();
paragraph = docRange.getParagraph(i);
charRun = paragraph.getCharacterRun(j);
text = charRun.text().trim();
}
}
}
}



// add a custom document property (needs POI 3.5; POI 3.2 doesn't save
// custom properties)
DocumentSummaryInformation dsi = doc.getDocumentSummaryInformation();
CustomProperties cp = dsi.getCustomProperties();
if (cp == null)
cp = new CustomProperties();
cp.put("myProperty", "foo bar baz");
dsi.setCustomProperties(cp);
doc.write(new FileOutputStream("d:\\Otro.doc"));
}


} 

but with both forms I have problems because the file get corrupted when the length of the old word and new word are differents betweenword

[Ulf Dittmer]

Post the code that uses those two classes for replacing text.

[juan sebastian sanchez]

package com.prueba.seb;


import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

import org.apache.poi.hwpf.HWPFDocument;
import org.apache.poi.hwpf.model.TextPiece;
import org.apache.poi.hwpf.usermodel.Paragraph;
import org.apache.poi.hwpf.usermodel.Range;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;

import wordtest.ParagraphText;

/**
 * An instance of this class can be used to replace 'placeholders' with
 * text within a Word document. Any and all occurrences found within paragraphs
 * of text contained either within the body of the document or the cells of a
 * table will be replaced.
 * 
 * Currently, the replacement takes no regard of any formatting applied to the
 * original text. Instead, it will simply replace the 'placeholder' with text
 * formatted in accordance with the 'Normal' style.
 * 
 * @author AA
 * 
 * @version 1.00 8th December 2008.
 */
public class InsertText {
    
    private File inputFile = null;
    private HWPFDocument document = null;
    private HashMap<String, String> replacementText = null;
    private Set<String> keys = null;
        
    /**
     * Create a new instance of the InsertText class using the following parameters;
     * 
     * @param filename An instance of the String class encapsulating the path
     *        path to and name of the MS Word file that is to be processed. No
     *        checks are made to ensure that the file is accessible or even
     *        of the correct data type.
     * @param replacementText An instance of the HashMap class that contains
     *        one or more key value pairs. Each pair consists of two Strings
     *        the first encapsulates the placeholder and the second the
     *        text that should replace it.
     * 
     * @throws NullPointerException if a null value is passed to either parameter.
     * @throws IllegalArgumentException if the vallue passed to either parameter is empty.
     */
    public InsertText(String filename, HashMap<String, String> replacementText) throws NullPointerException, IllegalArgumentException {
        
        // Not strictly necessary as a similar exception will be thrown on
        // instantiation of the File object later. Still like to test the parameters though.
        if(filename == null) {
            throw new NullPointerException("Null value passed to the filename parameter of the InsertText class constructor.");
        }
        if(replacementText == null) {
            throw new NullPointerException("Null value passed to the replacementText parameter of the InsertText class constructor.");
        }
        if(filename.isEmpty()) {
            throw new IllegalArgumentException("An empty String was passed to the filename parameter of the InsertText class constructor.");
        }
        if(replacementText.isEmpty()) {
            throw new IllegalArgumentException("An empty HashMap was passed to the replacementText parameter of the InsertText class constructor.");
        }
        // Copy parameters to local variables. Get the set of keys backing the HashMap and open the file.
        this.replacementText = replacementText;
        this.keys = replacementText.keySet();
        this.inputFile = new File(filename);
    }
    
    /**
     * Called to replace any named 'placeholders' with their accompanying text.
     */
    public void processFile() {
        Range range = null;
        BufferedInputStream buffInputStream = null;
        BufferedOutputStream buffOutputStream = null;
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        ParagraphText[] paraText = null;

        try {
            // Open the input file.
            fileInputStream = new FileInputStream(this.inputFile);
            buffInputStream = new BufferedInputStream(fileInputStream);
            this.document = new HWPFDocument(new POIFSFileSystem(buffInputStream));
            
            // Get an instance of the Range class and load all of the Paragrpahs
            // the document contains into a local array of type ParagraphText.
            range = this.document.getRange();
            paraText = this.loadParagraphs(range);

            // Step through the paragraph text.
            for(int i = 0; i < paraText.length; i++) {
                
                // Step through the Set of keys that backs the HashMap of
                // key/value pairs. For each key, test to see whether it exists
				// in the paragraph of text and if so replace it with the specified text value.
                for(String key : this.keys) {
                    if(paraText[i].getUpdatedText().contains(key)) {
                        paraText[i].updateText(
                            this.replacePlaceholders(key, this.replacementText.get(key), paraText[i].getUpdatedText()));
                    }
                }
                
                // After the paragraph has been tested against all of the keys
                // for placeholders, check to see if any replacements were nade.
                // If there were any replacements made then call the replaceText()
                // method for the specific paragraph. Here the paragraph's
                // number is recovered by calling the getParagraphNumber()
                // method - this could easilly be replaced in the current
                // situation with the number i which is the index of the enclosing
                // for loop. If the updates were made in another loop however, the
                // availability of the paragraph number could be useful.
                //
                // Note that two further calls are made to get the raw text - the
                // text that was originallg recovered from the paragraph - and the
                // updated text - the text with any placeholders replaced. It
                // proved necessary to copy the text recovered from the paragraph
                // becuase a call to the text() method of the Paragraph object
                // only returned part of the text for the final paragraph.
                if(paraText[i].isUpdated()) {
                    range.getParagraph(paraText[i].getParagraphNumber()).replaceText(
                            paraText[i].getRawText(), paraText[i].getUpdatedText(), 0);
                }
            }
            // Save the document away.
            fileOutputStream = new FileOutputStream(new File("C:\\Copy.doc"));
            buffOutputStream = new BufferedOutputStream(fileOutputStream);
            this.document.write(buffOutputStream);
        }
        catch(IOException ioEx) {
            System.out.println("Caught an: " + ioEx.getClass().getName());
            System.out.println("Message: " + ioEx.getMessage());
            System.out.println("StackTrace follows:");
            ioEx.printStackTrace(System.out);
        }
        finally {
            if(buffInputStream != null) {
                try {
                    buffInputStream.close();
                }
                catch(IOException ioEx) {
                    // I G N O R E //
                }
            }
            
            if(buffOutputStream != null) {
                try {
                    buffOutputStream.flush();
                    buffOutputStream.close();
                }
                catch(IOException ioEx) {
                    // I G N O R E //
                }
            }
        }
    }
    
    /**
     * Called to replace all occurrences of a placeholder.
     * 
     * @param key An instance of the String class that encapsulates the text of the placeholder.
     * @param value An instance of the String class that encapsulates the
     *        text that will be used to replace the placeholder.
     * @param text An instance of the String class that contains the contents
     *        of a paragraph read from a Word document.
     * 
     * @return An instance of the String class containing an updated version
     *         of the text originally recovered from the Word document; one
     *         where all occurrences of the placeholder have been replaced.
     */
    private String replacePlaceholders(String key, String value, String text) {
        int index = 0;
        // This is far from the most efficient way to parse the String as it
        // always starts from the beginning even after one or more substitutions
        // have been made. For now though it does work but will have obvious
        // limitations if the chunks of text are very large.
        while((index = text.indexOf(key)) >= 0) {
            text = text.substring(0, index) + value + text.substring(index + key.length());
        }
        return(text);
    }
    
    /**
     * Reads the contents of the document as a series of Paragraph objects. The
     * text is extracted from each and encapsulated into a instances of the ParagraphText calss.
     * 
     * It proved to be problematic to call the text() method on an instance
     * of the Paragraph class - sometimes, such a call would fail to return
     * all of the text the actual paragraph contained. So, it was necessary to
     * read all of the text into local variables so that it could be more
     * effectivley and successfully processed and this method was copied -
     * along with it's companion getTextFromPieces() from Nick Burch's WordExtractor class.
     * 
     * @param range An instance of the org.apache.poi.hwpf.usermodel.Range class
     *        that encapsulates information about the Word document - it's
     *        sections, paragraphs, tables, pictures, etc.
     * 
     * @return An array of type ParagraphText. Each element will contain an
     *         instance of the ParagraphText class that encasulates information
     *         about a paragraph of text - the text itself, the number of the
     *         paragraph, whether the text has been modified since it was read, etc.
     */
    private ParagraphText[] loadParagraphs(Range range) {
        ParagraphText[] paraText = new ParagraphText[range.numParagraphs()];
        Paragraph paragraph = null;
        String readText = null;
        try{
        
            for(int i = 0; i < range.numParagraphs(); i++) {
                paragraph = range.getParagraph(i);
                readText = paragraph.text();
                if(readText.endsWith("\n")) {
                    readText = readText + "\n";
                }
                paraText[i] = new ParagraphText(i, readText);
            }
        }
        catch(Exception ex) {
            paraText[0] = this.getTextFromPieces();
        }
        return(paraText);
    }

    /**
     * Again, with thanks to Nick Burch, this method will reconstruct the 
     * document's text from a series of TextPieces.
     * 
     * @return An instance of the ParagraphText class that encapsulates all
     *         of the text recovered from the document and treats it as one
     *         very large - potentially - paragraph.
     */
    private ParagraphText getTextFromPieces() {
        TextPiece piece = null;
        StringBuffer buffer = new StringBuffer();
        String text = null;
        String encoding = "Cp1252";
        
       	Iterator textPieces = this.document.getTextTable().getTextPieces().iterator();
       	while (textPieces.hasNext()) {
            piece = (TextPiece)textPieces.next();
            if (piece.isUnicode()) {
                encoding = "UTF-16LE";
            }
            try {
                text = new String(piece.getRawBytes(), encoding);
       		buffer.append(text);
            } catch(UnsupportedEncodingException e) {
                throw new InternalError("Standard Encoding " + encoding + " not found, JVM broken");
            }
       	}
       	text = buffer.toString();
       	// Fix line endings (Note - won't get all of them
       	text = text.replaceAll("\r\r\r", "\r\n\r\n\r\n");
       	text = text.replaceAll("\r\r", "\r\n\r\n");
       	if(text.endsWith("\r")) {
       		text += "\n";
       	}
      	return(new ParagraphText(0, text));
      }
    
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        try {
            HashMap<String, String> replacementText = new HashMap<String, String>();
            replacementText.put("$PH1", "MODIFIED REPLACEMENT 1");
            replacementText.put("$PH2", "MODIFIED REPLACEMENT 2");
            new InsertText("c:\\plantilla1.doc", replacementText).processFile();
        }
        catch(Exception eEx) {
            System.out.println("Caught an: " + eEx.getClass().getName());
            System.out.println("Message: " + eEx.getMessage());
            System.out.println("StackTrace follows:");
            eEx.printStackTrace(System.out);
        }
    }
}
    

 package wordtest;

/**
 * An instance of this class encapsulates information about a paragraph
 * recovered from a Word cocument.
 * 
 * @author AA
 * 
 * @version 1.00 8th December 2008.
 */
public class ParagraphText {
    
    private String rawText = null;
    private String updatedText = null;
    private boolean updated = false;
    private int paragraphNumber = 0;

    /**
     * Create an instance of the ParagraphText class using the following
     * parameters;
     * 
     * @param paragraphNumber A primitive int whose value indicates the
     *        number of the paragraph.
     * @param text An instance of the String class encapsulating the text
     *        recovered from the document.
     */
    public ParagraphText(int paragraphNumber, String text) {
        // Note that two 'copies' of the document's text are made. This is
        // so that one can be modofed whilst the other is unaltered for
        // later use in the replaceText() method. This approach was adopted
        // because a call to the text() method on the final paragraph of the
        // document produced inconsistent results and it is essentil to know the
        // paragraphs original contents in order to update it successfully.
        this.rawText = text;
        this.updatedText = new String(text);
        this.paragraphNumber = paragraphNumber;
        this.updated = false;
    }
    
    /**
     * Get the original - unaltered - contents of the paragraph.
     * 
     * @return A String object that encapsulates the text as it was orginally
     *         recovered from the paragraph.
     */
    public String getRawText() {
        return(this.rawText);
    }
    
    /**
     * Get the contents for the paragraph following any modifications.
     * 
     * @return A String object encapsulating the modified version of the
     *         paragraphs text - that is the version where any and all
     *         'placeholders' have been replaced.
     */
    public String getUpdatedText() {
        return(this.updatedText);
    }
    
    /**
     * Get the number of the paragraph.
     * 
     * @return A primtive int whose value indicates the position of the
     *         paragraph within the entire series of paragraphs read from the
     *         document.
     */
    public int getParagraphNumber() {
        return(this.paragraphNumber);
    }
    
    /**
     * Update or modify the paragraphs contents.
     * 
     * @param text A String object that encapsulates the text the paragraph
     *        should contain following modification.
     */
    public void updateText(String text) {
        this.updatedText = text;
        this.setUpdated(true);
    }
    
    /**
     * Indicates whether the paragraphs text has been updated.
     * 
     * @return A boolean value indicating whether the text has been updated 
     *         - true - or not - false.
     */
    public boolean isUpdated() {
        return(this.updated);
    }

    /**
     * Retruns a String that represents the succrent state of the object.
     * 
     * @return A String that encapsulates information about the objets state.
     *         In this case, the contents of it's member variables.
     * 
     * @Override
     */
    public String toString() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("ParagraphText: ");
        buffer.append("Paragraph Number: ");
        buffer.append(this.paragraphNumber);
        buffer.append(" Raw Text: ");
        buffer.append(this.rawText);
        buffer.append(" Updated Text: ");
        buffer.append(this.updatedText);
        buffer.append(" Updated: ");
        buffer.append(this.updated);
        return(buffer.toString().trim());
    }
    
    /**
     * A utility method used to set the state of the updated flag.
     */
    private void setUpdated(boolean updated) {
        this.updated = updated;
    }
}
   

[Ulf Dittmer]

Interesting. A DOC file so changed is opened fine by both OpenOffice and Mellel (an OS X word processor), but not by Word itself. Might be something to ask on the POI mailing list about.

[jetti madhu]

Hi,
is there any one know how to get the images from .doc file using POI ?

[asif aftab]

http://stackoverflow.com/questions/26250065/adding-footer-to-ms-word-using-poi-api/26250188#26250188
Please check above link. In this post footer is added perfectly.