public HSLFSlideShow() throws IOException 
{
		this(HSLFSlideShow.class.getResourceAsStream("/org/apache/poi/hslf/data/empty.ppt"));
}

Constructs a new, empty, Powerpoint document.

 public HSLFSlideShow(String fileName) throws IOException 
{
		this(new FileInputStream(fileName));
}

Constructs a Powerpoint document from fileName. Parses the document and places all the important stuff into data structures.

Parameters:

fileName - The name of the file to read.

Throws:

IOException - if there is a problem while parsing the document.

 public HSLFSlideShow(InputStream inputStream) throws IOException 
{
		//do Ole stuff
		this(new POIFSFileSystem(inputStream));
		istream = inputStream;
}

Constructs a Powerpoint document from an input stream. Parses the document and places all the important stuff into data structures.

Parameters:

inputStream - the source of the data

Throws:

IOException - if there is a problem while parsing the document.

 public HSLFSlideShow(POIFSFileSystem filesystem) throws IOException 
{
		this(filesystem.getRoot(), filesystem);
}

Constructs a Powerpoint document from a POIFS Filesystem. Parses the document and places all the important stuff into data structures.

Parameters:

filesystem - the POIFS FileSystem to read from

Throws:

IOException - if there is a problem while parsing the document.

 public HSLFSlideShow(DirectoryNode dir,
    POIFSFileSystem filesystem) throws IOException 
{
		super(dir, filesystem);
		// First up, grab the "Current User" stream
		// We need this before we can detect Encrypted Documents
		readCurrentUserStream();
		// Next up, grab the data that makes up the 
		//  PowerPoint stream
		readPowerPointStream();
		// Check to see if we have an encrypted document,
		//  bailing out if we do
		boolean encrypted = EncryptedSlideShow.checkIfEncrypted(this);
		if(encrypted) {
			throw new EncryptedPowerPointFileException("Encrypted PowerPoint files are not supported");
		}
		// Now, build records based on the PowerPoint stream
		buildRecords();
		// Look for Property Streams:
		readProperties();
		// Look for any other streams
		readOtherStreams();
		// Look for Picture Streams:
		readPictures();
}

Constructs a Powerpoint document from a specific point in a POIFS Filesystem. Parses the document and places all the important stuff into data structures.

Parameters:

dir - the POIFS directory to read from

filesystem - the POIFS FileSystem to read from

Throws:

IOException - if there is a problem while parsing the document.

 public  void addPicture(PictureData img) 
{
		// Copy over the existing pictures, into an array one bigger
		PictureData[] lst;
		if(_pictures == null) {
			lst = new PictureData[1];
		} else {
			lst = new PictureData[(_pictures.length+1)];
			System.arraycopy(_pictures,0,lst,0,_pictures.length);
		}
		// Add in the new image
		lst[lst.length - 1] = img;
		_pictures = lst;
}

Add a new picture to this presentation.

 public synchronized int appendRootLevelRecord(Record newRecord) 
{
		int addedAt = -1;
		Record[] r = new Record[_records.length+1];
		boolean added = false;
		for(int i=(_records.length-1); i >=0; i--) {
			if(added) {
				// Just copy over
				r[i] = _records[i];
			} else {
				r[(i+1)] = _records[i];
				if(_records[i] instanceof PersistPtrHolder) {
					r[i] = newRecord;
					added = true;
					addedAt = i;
				}
			}
		}
		_records = r;
		return addedAt;
}

Adds a new root level record, at the end, but before the last PersistPtrIncrementalBlock.

 public  void close() throws IOException 
{
		if(istream != null) {
			istream.close();
		}
		filesystem = null;
}

Shuts things down. Closes underlying streams etc

 public CurrentUserAtom getCurrentUserAtom() 
{
 return currentUser;
}

Fetch the Current User Atom of the document

 public ObjectData[] getEmbeddedObjects() 
{
        if (_objects == null) {
            List objects = new ArrayList();
            for (int i = 0; i <  _records.length; i++) {
                if (_records[i] instanceof ExOleObjStg) {
                    objects.add(new ObjectData((ExOleObjStg) _records[i]));
                }
            }
            _objects = (ObjectData[]) objects.toArray(new ObjectData[objects.size()]);
        }
        return _objects;
}

Gets embedded object data from the slide show.

 protected POIFSFileSystem getPOIFSFileSystem() 
{
               	 
		return filesystem;
}

Returns the underlying POIFSFileSystem for the document that is open.

 public PictureData[] getPictures() 
{
		return _pictures;
}

Return array of pictures contained in this presentation

 public Record[] getRecords() 
{
 return _records;
}

Returns an array of all the records found in the slideshow

 public byte[] getUnderlyingBytes() 
{
 return _docstream;
}

Returns an array of the bytes of the file. Only correct after a call to open or write - at all other times might be wrong!

 public  void write(OutputStream out) throws IOException 
{
        // Write out, but only the common streams
        write(out,false);
}

Writes out the slideshow file the is represented by an instance of this class. It will write out the common OLE2 streams. If you require all streams to be written out, pass in preserveNodes

 public  void write(OutputStream out,
    boolean preserveNodes) throws IOException 
{
        // Get a new Filesystem to write into
        POIFSFileSystem outFS = new POIFSFileSystem();
        // The list of entries we've written out
        List writtenEntries = new ArrayList(1);
        // Write out the Property Streams
        writeProperties(outFS, writtenEntries);
        // For position dependent records, hold where they were and now are
        // As we go along, update, and hand over, to any Position Dependent
        //  records we happen across
        Hashtable oldToNewPositions = new Hashtable();
        // First pass - figure out where all the position dependent
        //   records are going to end up, in the new scheme
        // (Annoyingly, some powerpoing files have PersistPtrHolders
        //  that reference slides after the PersistPtrHolder)
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        for(int i=0; i< _records.length; i++) {
            if(_records[i] instanceof PositionDependentRecord) {
                PositionDependentRecord pdr = (PositionDependentRecord)_records[i];
                int oldPos = pdr.getLastOnDiskOffset();
                int newPos = baos.size();
                pdr.setLastOnDiskOffset(newPos);
                oldToNewPositions.put(new Integer(oldPos),new Integer(newPos));
                //System.out.println(oldPos + " - > " + newPos);
            }
            // Dummy write out, so the position winds on properly
            _records[i].writeOut(baos);
        }
        // No go back through, actually writing ourselves out
        baos.reset();
        for(int i=0; i< _records.length; i++) {
            // For now, we're only handling PositionDependentRecord's that
            //  happen at the top level.
            // In future, we'll need the handle them everywhere, but that's
            //  a bit trickier
            if(_records[i] instanceof PositionDependentRecord) {
                // We've already figured out their new location, and
                //  told them that
                // Tell them of the positions of the other records though
                PositionDependentRecord pdr = (PositionDependentRecord)_records[i];
                pdr.updateOtherRecordReferences(oldToNewPositions);
            }
            // Whatever happens, write out that record tree
            _records[i].writeOut(baos);
        }
        // Update our cached copy of the bytes that make up the PPT stream
        _docstream = baos.toByteArray();
        // Write the PPT stream into the POIFS layer
        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        outFS.createDocument(bais,"PowerPoint Document");
        writtenEntries.add("PowerPoint Document");
        // Update and write out the Current User atom
        int oldLastUserEditAtomPos = (int)currentUser.getCurrentEditOffset();
        Integer newLastUserEditAtomPos = (Integer)oldToNewPositions.get(new Integer(oldLastUserEditAtomPos));
        if(newLastUserEditAtomPos == null) {
            throw new HSLFException("Couldn't find the new location of the UserEditAtom that used to be at " + oldLastUserEditAtomPos);
        }
        currentUser.setCurrentEditOffset(newLastUserEditAtomPos.intValue());
        currentUser.writeToFS(outFS);
        writtenEntries.add("Current User");
        // Write any pictures, into another stream
        if (_pictures != null) {
            ByteArrayOutputStream pict = new ByteArrayOutputStream();
            for (int i = 0; i <  _pictures.length; i++ ) {
                _pictures[i].write(pict);
            }
            outFS.createDocument(
                new ByteArrayInputStream(pict.toByteArray()), "Pictures"
            );
            writtenEntries.add("Pictures");
        }
        // If requested, write out any other streams we spot
        if(preserveNodes) {
        	copyNodes(filesystem, outFS, writtenEntries);
        }
        // Send the POIFSFileSystem object out to the underlying stream
        outFS.writeFilesystem(out);
}

Writes out the slideshow file the is represented by an instance of this class. If you require all streams to be written out (eg Marcos, embeded documents), then set preserveNodes to true