slideshow.java

java 读写word excel ppt

				logger.log(POILogger.ERROR, "A Notes SlideAtomSet at " + i + " said its record was at refID " + notesSets[i].getSlidePersistAtom().getRefID() + ", but that was actually a " + r);
			}
		}
		notesRecords = new org.apache.poi.hslf.record.Notes[notesRecordsL.size()];
		notesRecords = (org.apache.poi.hslf.record.Notes[])
			notesRecordsL.toArray(notesRecords);
	}
	
	// Now, do the same thing for our slides
	org.apache.poi.hslf.record.Slide[] slidesRecords;
	SlideAtomsSet[] slidesSets = new SlideAtomsSet[0];
	if(slidesSLWT == null) {
		// None
		slidesRecords = new org.apache.poi.hslf.record.Slide[0]; 
	} else {
		// Match up the records and the SlideAtomSets
		slidesSets = slidesSLWT.getSlideAtomsSets();
		slidesRecords = new org.apache.poi.hslf.record.Slide[slidesSets.length];
		for(int i=0; i<slidesSets.length; i++) {
			// Get the right core record
			Record r = getCoreRecordForSAS(slidesSets[i]);
			
			// Ensure it really is a slide record
			if(r instanceof org.apache.poi.hslf.record.Slide) {
				slidesRecords[i] = (org.apache.poi.hslf.record.Slide)r;
			} else {
				logger.log(POILogger.ERROR, "A Slide SlideAtomSet at " + i + " said its record was at refID " + slidesSets[i].getSlidePersistAtom().getRefID() + ", but that was actually a " + r);
			}
		}
	}
	
	// Finally, generate model objects for everything
	// Notes first
	_notes = new Notes[notesRecords.length];
	for(int i=0; i<_notes.length; i++) {
		_notes[i] = new Notes(notesRecords[i]);
		_notes[i].setSlideShow(this);
	}
	// Then slides
	_slides = new Slide[slidesRecords.length];
	for(int i=0; i<_slides.length; i++) {
		SlideAtomsSet sas = slidesSets[i];
		int slideIdentifier = sas.getSlidePersistAtom().getSlideIdentifier();

		// Do we have a notes for this?
		Notes notes = null;
        //Slide.SlideAtom.notesId references the corresponding notes slide. 0 if slide has no notes.
        int noteId = slidesRecords[i].getSlideAtom().getNotesID();
        if (noteId != 0){
            Integer notesPos = (Integer)slideIdToNotes.get(new Integer(noteId));
            if (notesPos != null) notes = _notes[notesPos.intValue()];
            else logger.log(POILogger.ERROR, "Notes not found for noteId=" + noteId);
        }

		// Now, build our slide
		_slides[i] = new Slide(slidesRecords[i], notes, sas, slideIdentifier, (i+1));
		_slides[i].setSlideShow(this);
	}
  }

  /**
   * Writes out the slideshow file the is represented by an instance of
   *  this class
   * @param out The OutputStream to write to.
   *  @throws IOException If there is an unexpected IOException from the passed
   *            in OutputStream
   */
   public void write(OutputStream out) throws IOException {
	_hslfSlideShow.write(out);
   }


   /* ===============================================================
    *                       Accessor Code
    * ===============================================================
    */
   

	/**
	 * Returns an array of the most recent version of all the interesting
	 *  records
	 */
	public Record[] getMostRecentCoreRecords() { return _mostRecentCoreRecords; }

	/**
	 * Returns an array of all the normal Slides found in the slideshow
	 */
	public Slide[] getSlides() { return _slides; }

	/**
	 * Returns an array of all the normal Notes found in the slideshow
	 */
	public Notes[] getNotes() { return _notes; }

	/**
     * Returns an array of all the normal Slide Masters found in the slideshow
	 */
    public SlideMaster[] getSlidesMasters() { return _masters; }

    /**
     * Returns an array of all the normal Title Masters found in the slideshow
     */
    public TitleMaster[] getTitleMasters() { return _titleMasters; }
	/**
	 * Returns the data of all the pictures attached to the SlideShow
	 */
	public PictureData[] getPictureData() {
		return _hslfSlideShow.getPictures();
	}
	
	/**
	 * Return the current page size
	 */
	public Dimension getPageSize(){
		DocumentAtom docatom = _documentRecord.getDocumentAtom();
		int pgx = (int)docatom.getSlideSizeX()*Shape.POINT_DPI/Shape.MASTER_DPI;
		int pgy = (int)docatom.getSlideSizeY()*Shape.POINT_DPI/Shape.MASTER_DPI;
		return new Dimension(pgx, pgy);
	}
	
	/**
	 * Change the current page size
	 * 
	 * @param pgsize page size (in points)
	 */
	public void setPageSize(Dimension pgsize){
		DocumentAtom docatom = _documentRecord.getDocumentAtom();
		docatom.setSlideSizeX(pgsize.width*Shape.MASTER_DPI/Shape.POINT_DPI);
		docatom.setSlideSizeY(pgsize.height*Shape.MASTER_DPI/Shape.POINT_DPI);
	}
	
	/**
	 * Helper method for usermodel: Get the font collection
	 */
	protected FontCollection getFontCollection() { return _fonts; }
	/**
	 * Helper method for usermodel and model: Get the document record
	 */
	public Document getDocumentRecord() { return _documentRecord; }

	
	/* ===============================================================
	 *                       Re-ordering Code
	 * ===============================================================
	 */
	   
	
	/**
	 * Re-orders a slide, to a new position.
	 * @param oldSlideNumer The old slide number (1 based)
	 * @param newSlideNumber The new slide number (1 based)
	 */
	public void reorderSlide(int oldSlideNumer, int newSlideNumber) {
		// Ensure these numbers are valid
		if(oldSlideNumer < 1 || newSlideNumber < 1) {
			throw new IllegalArgumentException("Old and new slide numbers must be greater than 0");
		}
		if(oldSlideNumer > _slides.length || newSlideNumber > _slides.length) {
			throw new IllegalArgumentException("Old and new slide numbers must not exceed the number of slides (" + _slides.length + ")");
		}
		
		// Shift the SlideAtomsSet
		SlideListWithText slwt = _documentRecord.getSlideSlideListWithText(); 
		slwt.repositionSlideAtomsSet( 
				slwt.getSlideAtomsSets()[(oldSlideNumer-1)],
				(newSlideNumber-1)
		);
		
		// Re-order the slides
		ArrayUtil.arrayMoveWithin(_slides, (oldSlideNumer-1), (newSlideNumber-1), 1);
		
		// Tell the appropriate slides their new numbers
		for(int i=0; i<_slides.length; i++) {
			_slides[i].setSlideNumber( (i+1) );
		}
	}

	/* ===============================================================
	 *                       Addition Code
	 * ===============================================================
	 */
	   

	/**
	 * Create a blank <code>Slide</code>.
	 *
	 * @return  the created <code>Slide</code>
	 * @throws IOException
	 */
  	public Slide createSlide() throws IOException {
  		SlideListWithText slist = null;

  		// We need to add the records to the SLWT that deals
  		//  with Slides.
  		// Add it, if it doesn't exist
  		slist = _documentRecord.getSlideSlideListWithText();
  		if(slist == null) {
  			// Need to add a new one
  			slist = new SlideListWithText();
  			_documentRecord.addSlideListWithText(slist);
  		}

  		// Grab the SlidePersistAtom with the highest Slide Number.
  		// (Will stay as null if no SlidePersistAtom exists yet in
  		//  the slide, or only master slide's ones do)
  		SlidePersistAtom prev = null;
		SlideAtomsSet[] sas = slist.getSlideAtomsSets();
  		for(int j=0; j<sas.length; j++) {
  			SlidePersistAtom spa = sas[j].getSlidePersistAtom();
  			if(spa.getSlideIdentifier() < 0) {
  				// This is for a master slide
  				// Odd, since we only deal with the Slide SLWT
  			} else {
				// Must be for a real slide
  				if(prev == null) { prev = spa; }
  				if(prev.getSlideIdentifier() < spa.getSlideIdentifier()) {
  					prev = spa;
  				}
  			}
  		}
  		
  		// Set up a new  SlidePersistAtom for this slide 
  		SlidePersistAtom sp = new SlidePersistAtom();

  		// Reference is the 1-based index of the slide container in 
  		//  the PersistPtr root.
  		// It always starts with 3 (1 is Document, 2 is MainMaster, 3 is 
  		//  the first slide), but quicksaves etc can leave gaps
  		_highestSheetId++;
  		sp.setRefID(_highestSheetId);
  		// First slideId is always 256
  		sp.setSlideIdentifier(prev == null ? 256 : (prev.getSlideIdentifier() + 1));
  		
  		// Add this new SlidePersistAtom to the SlideListWithText
  		slist.addSlidePersistAtom(sp);
  		
  		
  		// Create a new Slide
  		Slide slide = new Slide(sp.getSlideIdentifier(), sp.getRefID(), _slides.length+1);
  		// Add in to the list of Slides
  		Slide[] s = new Slide[_slides.length+1];
  		System.arraycopy(_slides, 0, s, 0, _slides.length);
  		s[_slides.length] = slide;
  		_slides = s;
  		logger.log(POILogger.INFO, "Added slide " + _slides.length + " with ref " + sp.getRefID() + " and identifier " + sp.getSlideIdentifier());
  		
  		// Add the core records for this new Slide to the record tree
  		org.apache.poi.hslf.record.Slide slideRecord = slide.getSlideRecord();
  		slideRecord.setSheetId(sp.getRefID());
  		int slideRecordPos = _hslfSlideShow.appendRootLevelRecord(slideRecord);
  		_records = _hslfSlideShow.getRecords();

  		// Add the new Slide into the PersistPtr stuff
  		int offset = 0;
  		int slideOffset = 0;
  		PersistPtrHolder ptr = null;
  		UserEditAtom usr = null;
  		for (int i = 0; i < _records.length; i++) {
  			Record record = _records[i];
  			ByteArrayOutputStream out = new ByteArrayOutputStream();
  			record.writeOut(out);
  			
  			// Grab interesting records as they come past
  			if(_records[i].getRecordType() == RecordTypes.PersistPtrIncrementalBlock.typeID){
  				ptr = (PersistPtrHolder)_records[i];
  			}
  			if(_records[i].getRecordType() == RecordTypes.UserEditAtom.typeID) {
  				usr = (UserEditAtom)_records[i];
  			}
  			
  			if(i == slideRecordPos) {
  				slideOffset = offset;
  			}
  			offset += out.size();
  		}
  		
		// Add the new slide into the last PersistPtr
  		// (Also need to tell it where it is)
		slideRecord.setLastOnDiskOffset(slideOffset);
		ptr.addSlideLookup(sp.getRefID(), slideOffset);
		logger.log(POILogger.INFO, "New slide ended up at " + slideOffset);

		// Last view is now of the slide
  		usr.setLastViewType((short)UserEditAtom.LAST_VIEW_SLIDE_VIEW);
  		
  		// All done and added
  		slide.setSlideShow(this);
  		return slide;
	}


    /**
     * Adds a picture to this presentation and returns the associated index.
     *
     * @param data      picture data
     * @param format    the format of the picture.  One of constans defined in the <code>Picture</code> class.
     * @return          the index to this picture (1 based).
     */
    public int addPicture(byte[] data, int format) throws IOException {
        byte[] uid = PictureData.getChecksum(data);

        EscherContainerRecord bstore;
        int offset = 0;

        EscherContainerRecord dggContainer = _documentRecord.getPPDrawingGroup().getDggContainer();
        bstore = (EscherContainerRecord)Shape.getEscherChild(dggContainer, EscherContainerRecord.BSTORE_CONTAINER);
        if (bstore == null){
            bstore = new EscherContainerRecord();
            bstore.setRecordId( EscherContainerRecord.BSTORE_CONTAINER);

            List child = dggContainer.getChildRecords();
            for ( int i = 0; i < child.size(); i++ ) {
                EscherRecord rec = (EscherRecord)child.get(i);
                if (rec.getRecordId() == EscherOptRecord.RECORD_ID){
                    child.add(i, bstore);
                    i++;
                }
            }
            dggContainer.setChildRecords(child);
        } else {
            List lst = bstore.getChildRecords();
            for ( int i = 0; i < lst.size(); i++ ) {
                EscherBSERecord bse = (EscherBSERecord) lst.get(i);
                if (Arrays.equals(bse.getUid(), uid)){
                    return i + 1;
                }
                offset += bse.getSize();
             }
        }

        PictureData pict = PictureData.create(format);
        pict.setData(data);
        pict.setOffset(offset);

        EscherBSERecord bse = new EscherBSERecord();
        bse.setRecordId(EscherBSERecord.RECORD_ID);
        bse.setOptions( (short) ( 0x0002 | ( format << 4 ) ) );
        bse.setSize(pict.getRawData().length + 8);
        bse.setUid(uid);

        bse.setBlipTypeMacOS((byte)format);
        bse.setBlipTypeWin32((byte)format);

        if (format == Picture.EMF) bse.setBlipTypeMacOS((byte)Picture.PICT);
        else if (format == Picture.WMF) bse.setBlipTypeMacOS((byte)Picture.PICT);
        else if (format == Picture.PICT) bse.setBlipTypeWin32((byte)Picture.WMF);

        bse.setRef(1);
        bse.setOffset(offset);

        bstore.addChildRecord(bse);
        int count = bstore.getChildRecords().size();
        bstore.setOptions((short)( (count << 4) | 0xF ));

        _hslfSlideShow.addPicture(pict);

        return count;
    }

    /**
     * Adds a picture to this presentation and returns the associated index.
     *
     * @param pict       the file containing the image to add
     * @param format    the format of the picture.  One of constans defined in the <code>Picture</code> class.
     * @return          the index to this picture (1 based).
     */
    public int addPicture(File pict, int format) throws IOException {
        int length = (int)pict.length();
        byte[] data = new byte[length];
        try {
            FileInputStream is = new FileInputStream(pict);
            is.read(data);
            is.close();
        } catch (IOException e){
            throw new HSLFException(e);
        }
        return addPicture(data, format);
    }
}