Java Examples for com.itextpdf.text.pdf.PdfCopy

public static byte[] concatanatePDF(byte[] pdf1, byte[] pdf2) throws IOException, DocumentException {
    // näite järgi pdfide kokku panemine -- pole proovinud kas töötab
    ByteArrayOutputStream output = new ByteArrayOutputStream();
    PdfReader reader = new PdfReader(pdf1);
    Document document = new Document(reader.getPageSizeWithRotation(1));
    PdfCopy copy = new PdfCopy(document, output);
    document.open();
    // esimene pdf lisatakse
    PdfImportedPage pdfImportedPage;
    for (int i = 0; i < reader.getNumberOfPages(); ) {
        ++i;
        pdfImportedPage = copy.getImportedPage(reader, i);
        copy.addPage(pdfImportedPage);
    }
    // teine pdf lisatakse
    reader = new PdfReader(pdf2);
    for (int i = 0; i < reader.getNumberOfPages(); ) {
        ++i;
        pdfImportedPage = copy.getImportedPage(reader, i);
        copy.addPage(pdfImportedPage);
    }
    document.close();
    return output.toByteArray();
}

/**
	 * Makes a copy from each PDF-file in the folder and puts it in the same
	 * folder with the prefix"Mig_iText"
	 * 
	 * @param takes
	 *            in PdfReader and the filename as a string
	 * @return: void
	 * 
	 */
@SuppressWarnings("rawtypes")
static void repairWithItext(PdfReader reader, File filename) throws DocumentException, IOException {
    Map<String, String> info = reader.getInfo();
    Document document = new Document();
    String filenameStr = filename.getName();
    PdfCopy copy = new PdfCopy(document, new FileOutputStream(examinedFolder + "//" + "Mig_iText" + filenameStr));
    int pdfVersion = filetools.pdf.PdfAnalysis.getPdfVersion(filename.toString());
    //TODO: But all the output PDF is PDF 1.4
    switch(pdfVersion) {
        case 2:
            copy.setPdfVersion(PdfWriter.PDF_VERSION_1_2);
            break;
        case 3:
            copy.setPdfVersion(PdfWriter.PDF_VERSION_1_3);
            break;
        case 4:
            copy.setPdfVersion(PdfWriter.PDF_VERSION_1_4);
            break;
        case 5:
            copy.setPdfVersion(PdfWriter.PDF_VERSION_1_5);
            break;
        case 6:
            copy.setPdfVersion(PdfWriter.PDF_VERSION_1_6);
            break;
        case 7:
            copy.setPdfVersion(PdfWriter.PDF_VERSION_1_7);
            break;
    }
    // Bruno's books
    if (info.get("Title") != null)
        document.addTitle((String) info.get("Title"));
    if (info.get("Author") != null)
        document.addAuthor((String) info.get("Author"));
    if (info.get("Keywords") != null)
        document.addKeywords((String) info.get("Keywords"));
    // TODO: Is this the right Keyword?
    if (info.get("Date") != null)
        document.addKeywords((String) info.get("Date"));
    copy.createXmpMetadata();
    document.open();
    int n = reader.getNumberOfPages();
    for (int i = 0; i < n; ) {
        copy.addPage(copy.getImportedPage(reader, ++i));
    }
    copy.freeReader(reader);
    document.close();
}

public boolean split(OutputStream os, long sizeInBytes) throws IOException, DocumentException {
    if (!hasMorePages()) {
        os.close();
        return false;
    }
    overSized = false;
    Document document = new Document();
    PdfCopy copy = new PdfSmartCopy(document, os);
    document.open();
    boolean hasPage = false;
    PdfResourceCounter counter = new PdfResourceCounter(reader.getTrailer());
    long trailer = counter.getLength(null);
    Map<Integer, PdfObject> resources = counter.getResources();
    long length = 0;
    long page;
    while (hasMorePages()) {
        counter = new PdfResourceCounter(reader.getPageN(currentPage));
        page = counter.getLength(resources);
        resources = counter.getResources();
        length += page + trailer + xrefLength(resources.size());
        LOGGER.info(String.format("Page %s: Comparing %s with %s", currentPage, length, sizeInBytes));
        LOGGER.info(String.format("   page %s trailer %s xref %s", page, trailer, xrefLength(resources.size())));
        if (!hasPage || length < sizeInBytes) {
            hasPage = true;
            copy.addPage(copy.getImportedPage(reader, currentPage));
            length = copy.getOs().getCounter();
            LOGGER.info(String.format("Size after adding page: %s", length));
            if (length > sizeInBytes)
                overSized = true;
            currentPage++;
        } else {
            LOGGER.info("Page doesn't fit");
            break;
        }
    }
    document.close();
    return true;
}

/**
     * @param titleSection
     * @param pdfCopy
     * @throws IOException
     * @throws BadPdfFormatException
     */
public static void addPages(InputStream titleSection, PdfCopy pdfCopy) throws IOException, BadPdfFormatException {
    if (isDebugEnabled) {
        S_LOGGER.debug("Entering Method DocumentUtil.addPages(InputStream titleSection, PdfCopy pdfCopy)");
    }
    PdfReader reader = new PdfReader(titleSection);
    reader.consolidateNamedDestinations();
    int pages = reader.getNumberOfPages();
    for (int i = 1; i <= pages; i++) {
        PdfImportedPage importedPage = pdfCopy.getImportedPage(reader, i);
        pdfCopy.addPage(importedPage);
    }
    pdfCopy.freeReader(reader);
}

public static void merge(File output, List<File> inputFiles, ProgressDisplay progress) throws IOException, DocumentException {
    //$NON-NLS-1$
    progress.startTask(Messages.getString("PdfPermissionManager.Combine"), inputFiles.size(), true);
    FileOutputStream outputStream = null;
    PdfCopy copy = null;
    int pageCount = 0;
    try {
        Document document = new Document();
        outputStream = new FileOutputStream(output);
        copy = new PdfCopy(document, outputStream);
        document.open();
        int n = 0;
        for (File file : inputFiles) {
            if (progress.isCanceled()) {
                break;
            }
            progress.setNote(file.getName());
            FileInputStream inputStream = null;
            PdfReader reader = null;
            try {
                inputStream = new FileInputStream(file);
                reader = new PdfReader(inputStream);
                unlockReader(reader);
                for (int i = 1; i <= reader.getNumberOfPages(); i++) {
                    if (progress.isCanceled()) {
                        break;
                    }
                    document.newPage();
                    pageCount++;
                    // import the page from source pdf
                    PdfImportedPage page = copy.getImportedPage(reader, i);
                    copy.addPage(page);
                }
            } finally {
                if (reader != null) {
                    reader.close();
                }
                if (inputStream != null) {
                    inputStream.close();
                }
                progress.setProgress(++n);
            }
        }
        outputStream.flush();
        document.close();
    } finally {
        progress.endTask();
        // check if any page was written.
        if (copy != null && pageCount > 0) {
            copy.close();
        }
        if (outputStream != null) {
            outputStream.close();
        }
    }
}

private static void exportReportDataOnPDF(String pageid, ReportRequest rrequest, WabacusResponse wresponse) {
    boolean success = true;
    try {
        rrequest.setWResponse(wresponse);
        wresponse.setRRequest(rrequest);
        rrequest.init(pageid);
        if (rrequest.getLstAllReportBeans() == null || rrequest.getLstAllReportBeans().size() == 0) {
            throw new WabacusRuntimeException("导出页面" + pageid + "上的数据失败，plainexcel导出方式只能导出报表，不能导出其它应用");
        }
        Document document = new Document();
        ByteArrayOutputStream baosResult = new ByteArrayOutputStream();
        PdfCopy pdfCopy = new PdfCopy(document, baosResult);
        document.open();
        boolean ispdfprint = rrequest.isPdfPrintAction();
        for (IComponentConfigBean ccbeanTmp : rrequest.getLstComponentBeans()) {
            //依次导出配置有PDF模板的组件
            PDFExportBean pdfbeanTmp = null;
            if (ispdfprint) {
                pdfbeanTmp = ccbeanTmp.getPdfPrintBean();
            } else if (ccbeanTmp.getDataExportsBean() != null) {
                pdfbeanTmp = (PDFExportBean) ccbeanTmp.getDataExportsBean().getDataExportBean(Consts.DATAEXPORT_PDF);
            }
            if (pdfbeanTmp != null && pdfbeanTmp.getPdftemplate() != null && !pdfbeanTmp.getPdftemplate().trim().equals("")) {
                PdfAssistant.getInstance().addPdfPageToDocument(pdfCopy, PdfAssistant.getInstance().showReportDataOnPdfWithTpl(rrequest, ccbeanTmp));
            }
        }
        AbsReportType reportTypeObjTmp;
        for (ReportBean rbTmp : rrequest.getLstAllReportBeans()) {
            reportTypeObjTmp = (AbsReportType) rrequest.getComponentTypeObj(rbTmp, null, false);
            //如果当前报表是在某个有PDF模板的组件中导出，则不在这里导，而是在上面导出
            if (rrequest.isReportInPdfTemplate(rbTmp.getId()))
                continue;
            PdfAssistant.getInstance().addPdfPageToDocument(pdfCopy, reportTypeObjTmp.displayOnPdf());
        }
        document.close();
        BufferedOutputStream bos = null;
        if (rrequest.isExportToLocalFile()) {
            bos = new BufferedOutputStream(new FileOutputStream(new File(rrequest.getDataExportFilepath())));
        } else {
            if (!ispdfprint) {
                String title = WabacusAssistant.getInstance().encodeAttachFilename(rrequest.getRequest(), rrequest.getDataExportFilename());
                wresponse.getResponse().setHeader("Content-disposition", "attachment;filename=" + title + ".pdf");
            }
            wresponse.getResponse().setContentLength(baosResult.size());
            bos = new BufferedOutputStream(wresponse.getResponse().getOutputStream());
        }
        baosResult.writeTo(bos);
        bos.close();
        baosResult.close();
        if (rrequest.isExportToLocalFile() && rrequest.isDataexport_localstroagezip()) {
            tarDataFile(rrequest);
        }
    } catch (WabacusRuntimeTerminateException wrwe) {
        if (wresponse.getStatecode() == Consts.STATECODE_FAILED) {
            success = false;
        }
    } catch (Exception wre) {
        wresponse.setStatecode(Consts.STATECODE_FAILED);
        log.error("导出页面" + rrequest.getPagebean().getId() + "下的报表失败", wre);
        success = false;
    } finally {
        rrequest.destroy(success);
    }
    doPostDataExport(rrequest, wresponse);
}

@Override
public void crop(DocumentInfo pdfFile, File targetFile, PageRectsMap pageRectsMap, int viewWidth, int viewHeight, ProgressMonitor progressMonitor) throws IOException, DocumentException {
    IResourceHandler originalFile = pdfFile.getOriginalFile();
    HashMap<String, String> pdfInfo = pdfFile.getDocInfo();
    PdfReader reader1 = PDFUtils.getReader(originalFile.toFile());
    PdfReader reader2 = null;
    float normalizedPdfWidth = pdfFile.getNormalizedWidth();
    float normalizedPdfHeight = pdfFile.getNormalizedHeight();
    LoggerFactory.getLogger(PdfCropper.class).log(Level.INFO, "Finding ratio : viewSize " + viewWidth + "x" + viewHeight + ", pdf size " + normalizedPdfWidth + "x" + normalizedPdfHeight);
    double widthRatio = normalizedPdfWidth / viewWidth;
    double heightRatio = normalizedPdfHeight / viewHeight;
    if (widthRatio != heightRatio) {
        System.err.println("WARNING>>> RATION NOT SAME ?! " + widthRatio + " " + heightRatio);
    }
    Document document = null;
    PdfCopy writer = null;
    PdfStamper stamper = null;
    IResourceHandler tempFile = null;
    OutputStream tempFileOut = null;
    // open the original
    try {
        reader1.consolidateNamedDestinations();
        int originalPageCount = reader1.getNumberOfPages();
        document = new Document(reader1.getPageSizeWithRotation(1));
        tempFile = ResourceHandlerFactory.getTemporaryResource("tmp");
        writer = new PdfCopy(document, tempFileOut = tempFile.getContentOutputStream(false));
        document.open();
        PdfImportedPage page;
        int newPageCount = 0;
        for (int i = 0; i < originalPageCount; ) {
            ++i;
            ArrayList<java.awt.Rectangle> cropRects = pageRectsMap.getRects(i);
            int cropCellCount = 0;
            if (cropRects != null) {
                cropCellCount = cropRects.size();
            }
            if (cropCellCount == 0) {
                //we will assume there is one crop cell that covers the whole page
                cropCellCount = 1;
            }
            newPageCount += cropCellCount;
            for (int iCell = 0; iCell < cropCellCount; iCell++) {
                progressMonitor.setNote("Writing page " + ((i - 1) * cropCellCount + iCell) + " of " + newPageCount);
                progressMonitor.setProgress(i * 100 / originalPageCount);
                page = writer.getImportedPage(reader1, i);
                writer.addPage(page);
            }
        }
        document.close();
        document = null;
        reader2 = PDFUtils.getReader(tempFile.toFile());
        stamper = new PdfStamper(reader2, new FileOutputStream(targetFile));
        int pageCount = reader2.getNumberOfPages();
        newPageCount = 0;
        for (int iOriginalPage = 1; iOriginalPage <= originalPageCount; iOriginalPage++) {
            normalizedPdfHeight = (int) reader1.getPageSize(iOriginalPage).getHeight();
            ArrayList<java.awt.Rectangle> cropRectsInIPDFCoords = pageRectsMap.getConvertedRectsForCropping(iOriginalPage, viewWidth, viewHeight, normalizedPdfWidth, normalizedPdfHeight);
            int cropCellCount = 0;
            if (cropRectsInIPDFCoords != null) {
                cropCellCount = cropRectsInIPDFCoords.size();
            }
            if (cropCellCount == 0) {
                // we will still add one full page
                newPageCount++;
                LoggerFactory.getLogger(PdfCropper.class).log(Level.INFO, "Cropping page " + newPageCount + " ... full page size");
            } else {
                for (int i = 0; i < cropCellCount; ) {
                    ++i;
                    newPageCount++;
                    // http://stackoverflow.com/questions/4089757/how-do-i-resize-an-existing-pdf-with-coldfusion-itext
                    progressMonitor.setNote("Cropping page " + newPageCount + " of " + pageCount);
                    progressMonitor.setProgress(newPageCount * 100 / pageCount);
                    if (cropRectsInIPDFCoords != null) {
                        java.awt.Rectangle cropRect = cropRectsInIPDFCoords.get(i - 1);
                        applyCropToPage(reader2, newPageCount, cropRect);
                    }
                }
            }
        }
        // put the information, like author name etc.
        stamper.setMoreInfo(pdfInfo);
    } finally {
        if (document != null) {
            document.close();
        }
        if (stamper != null) {
            stamper.close();
        }
        if (reader1 != null) {
            reader1.close();
        }
        if (reader2 != null) {
            reader2.close();
        }
        if (writer != null) {
            writer.flush();
            writer.close();
        }
        IOUtils.closeQuietly(tempFileOut);
        if (tempFile != null) {
            tempFile.delete();
        }
    }
}

/** 
     * Do the work of joining the FOP output and a PDF together. This involves
     * several steps:
     * 
     *  1. Based on parameters specified in the PipeFOP command, determine how
     *     the pages will overlap.
     *  2. Merge bookmarks and metadata
     *  3. Output the pages  
     */
private void mergePdf(XPathContext context, byte[] origPdfData, File fileToAppend, MergeMode mergeMode, MergeAt mergeAt, OutputStream outStream) throws IOException, DocumentException, BadPdfFormatException, XPathException {
    PdfReader[] readers = new PdfReader[2];
    HashMap<String, String>[] infos = new HashMap[2];
    int[] nInPages = new int[2];
    int[] pageOffsets = new int[2];
    int nOutPages = 0;
    // Read in the PDF that FOP generated and the one we're merging
    readers[0] = new PdfReader(origPdfData);
    readers[1] = new PdfReader(new BufferedInputStream(new FileInputStream(fileToAppend)));
    // Perform processing that's identical for both
    for (int i = 0; i < 2; i++) {
        readers[i].consolidateNamedDestinations();
        infos[i] = readers[i].getInfo();
        nInPages[i] = readers[i].getNumberOfPages();
    }
    // Calculate page offsets depending on the merge mode.
    switch(mergeMode) {
        case SEQUENTIAL:
            nOutPages = nInPages[0] + nInPages[1];
            switch(mergeAt) {
                case START:
                    pageOffsets[0] = nInPages[1];
                    pageOffsets[1] = 0;
                    break;
                case END:
                    pageOffsets[0] = 0;
                    pageOffsets[1] = nInPages[0];
                    break;
            }
            break;
        case OVERLAY:
        case UNDERLAY:
            nOutPages = Math.max(nInPages[0], nInPages[1]);
            pageOffsets[0] = 0;
            if (mergeAt == MergeAt.END)
                pageOffsets[1] = Math.max(0, nInPages[0] - nInPages[1]);
            else
                pageOffsets[1] = 0;
            break;
    }
    // Construct the copying writer
    Document pdfDocument = new Document(readers[0].getPageSizeWithRotation(1));
    PdfCopy pdfWriter = new PdfCopy(pdfDocument, outStream);
    pdfDocument.open();
    // Merge the metadata
    mergeMetadata(infos, pdfWriter, context);
    // Copy bookmarks from both PDFs
    ArrayList allBookmarks = new ArrayList();
    for (int i = 0; i < 2; i++) {
        List bookmarks = SimpleBookmark.getBookmark(readers[i]);
        if (bookmarks != null) {
            if (pageOffsets[i] != 0)
                SimpleBookmark.shiftPageNumbers(bookmarks, pageOffsets[i], null);
            allBookmarks.addAll(bookmarks);
        }
    }
    PageInfo[] basePages = new PageInfo[nOutPages];
    PageInfo[] mergePages = new PageInfo[nOutPages];
    //
    for (int i = 0; i < nOutPages; i++) {
        for (int j = 0; j < 2; j++) {
            int inPageNum = i - pageOffsets[j];
            if (inPageNum < 0 || inPageNum >= nInPages[j])
                continue;
            PageInfo info = new PageInfo();
            info.reader = readers[j];
            info.pageNum = inPageNum + 1;
            if (basePages[i] == null)
                basePages[i] = info;
            else {
                info.impPage = pdfWriter.getImportedPage(info.reader, info.pageNum);
                info.image = Image.getInstance(info.impPage);
                mergePages[i] = info;
            }
        }
    }
    for (int i = 0; i < nOutPages; i++) {
        PageInfo base = basePages[i];
        base.impPage = pdfWriter.getImportedPage(base.reader, base.pageNum);
        if (mergePages[i] != null) {
            PageStamp ps = pdfWriter.createPageStamp(base.impPage);
            PdfContentByte contentBuf = null;
            if (mergeMode == MergeMode.OVERLAY)
                contentBuf = ps.getOverContent();
            else if (mergeMode == MergeMode.UNDERLAY)
                contentBuf = ps.getUnderContent();
            else
                assert false : "page offset calculations were wrong";
            // this is the trick
            Image img = Image.getInstance(mergePages[i].image);
            contentBuf.addImage(img, base.impPage.getWidth(), 0, 0, base.impPage.getHeight(), 0, 0);
            ps.alterContents();
        }
        pdfWriter.addPage(base.impPage);
    }
    // Set the combined bookmarks.
    if (!allBookmarks.isEmpty())
        pdfWriter.setOutlines(allBookmarks);
    // And we're done.
    pdfDocument.close();
}

@Override
public Set<File> export(final Origami origami, File file, ExportFormat format, ExportOptions options, Runnable progressCallback) throws IOException {
    Set<File> result = new LinkedHashSet<File>();
    if (format == ExportFormat.XML) {
        try {
            save(origami, file);
        } catch (MarshalException e) {
            throw new IOException(e);
        } catch (JAXBException e) {
            throw new IOException(e);
        }
        result.add(file);
        if (progressCallback != null)
            progressCallback.run();
    } else if (format == ExportFormat.PNG || format == ExportFormat.SVG || format == ExportFormat.PDF) {
        // a lot of code is common for those 3 formats, so we won't divide them
        Double dpi = null;
        Locale locale = null;
        Insets pageInsets = null;
        boolean withBackground = true;
        // configure from options
        if (options != null) {
            if (options instanceof PNGExportOptions) {
                PNGExportOptions options2 = (PNGExportOptions) options;
                dpi = options2.getDpi();
                locale = options2.getLocale();
                withBackground = options2.isWithBackground();
                pageInsets = options2.getPageInsets();
            } else if (options instanceof SVGExportOptions) {
                SVGExportOptions options2 = (SVGExportOptions) options;
                dpi = options2.getDpi();
                locale = options2.getLocale();
                withBackground = options2.isWithBackground();
                pageInsets = options2.getPageInsets();
            } else if (options instanceof PDFExportOptions) {
                PDFExportOptions options2 = (PDFExportOptions) options;
                dpi = options2.getDpi();
                locale = options2.getLocale();
                withBackground = options2.isWithBackground();
                pageInsets = options2.getPageInsets();
            } else {
                dpi = 72d;
                locale = ServiceLocator.get(ConfigurationManager.class).get().getDiagramLocale();
                pageInsets = new Insets(25, 25, 25, 25);
            }
        } else {
            dpi = 72d;
            locale = ServiceLocator.get(ConfigurationManager.class).get().getDiagramLocale();
            pageInsets = new Insets(25, 25, 25, 25);
        }
        final File parentFile = (file.isDirectory() ? file : file.getParentFile());
        final FileNameGenerator fileNames;
        if (!file.isDirectory()) {
            String prefix = file.getName().replaceAll("\\.[^.]*$", "");
            String suffix = file.getName().replaceAll("^.*(\\.[^.]*)$", "$1");
            fileNames = new FileNameGeneratorImpl(prefix, suffix, origami.getNumberOfPages());
        } else {
            fileNames = new FileNameGeneratorImpl("", ".png", origami.getNumberOfPages());
        }
        UnitDimension paperDim = origami.getPaper().getSize();
        paperDim = paperDim.convertTo(Unit.INCH);
        final Dimension resultDim = new Dimension((int) (paperDim.getWidth() * dpi), (int) (paperDim.getHeight() * dpi));
        // create the graphics object - either from a buffered image, or an SVG graphics
        final Graphics2D g;
        BufferedImage buffer = null;
        Document svgDocument = null;
        if (format == ExportFormat.PNG) {
            buffer = new BufferedImage(resultDim.width, resultDim.height, BufferedImage.TYPE_INT_ARGB);
            g = buffer.createGraphics();
        } else {
            DOMImplementation domImpl = GenericDOMImplementation.getDOMImplementation();
            String svgNS = "http://www.w3.org/2000/svg";
            svgDocument = domImpl.createDocument(svgNS, "svg", null);
            SVGGeneratorContext ctx = SVGGeneratorContext.createDefault(svgDocument);
            // this is important, otherwise the SVG files use a different font and that breaks the result
            ctx.setEmbeddedFontsOn(true);
            g = new SVGGraphics2D(ctx, true);
        }
        Font font = new JMultilineLabel("").getFont();
        // normalize the font size
        font = font.deriveFont((float) (font.getSize2D() * dpi / 72));
        // iterate through pages, draw them into the created graphics, and write to files
        IOException e = null;
        for (int i = 0; i <= origami.getNumberOfPages(); i++) {
            try {
                if (i > 0) {
                    // DRAW THE PAGE
                    drawPage(g, new Rectangle(0, 0, resultDim.width, resultDim.height), pageInsets, origami, i, locale, font, withBackground, progressCallback);
                } else {
                    // DRAW TITLE PAGE
                    drawTitlePage(g, new Rectangle(0, 0, resultDim.width, resultDim.height), pageInsets, origami, locale, font, withBackground, progressCallback);
                }
            } catch (InterruptedException ex) {
                g.dispose();
                return result;
            }
            if (format == ExportFormat.PNG && buffer != null) {
                try {
                    // write the image buffer to file
                    buffer.flush();
                    File pageFile = new File(parentFile, fileNames.getFileName(i));
                    ImageIO.write(buffer, "png", pageFile);
                    result.add(pageFile);
                } catch (IOException ex) {
                    e = ex;
                }
            } else if (format == ExportFormat.SVG || format == ExportFormat.PDF) {
                // write the SVG graphics to file
                File outFile = new File(parentFile, fileNames.getFileName(i));
                FileWriter writer = null;
                try {
                    writer = new FileWriter(outFile);
                    // PDF will be written with incorrect extension, but it doesn't matter since it is only
                    // temporary
                    ((SVGGraphics2D) g).stream(writer, true);
                    result.add(outFile);
                } catch (IOException ex) {
                    e = ex;
                } finally {
                    if (writer != null) {
                        try {
                            writer.flush();
                            writer.close();
                        } catch (IOException ex) {
                            e = ex;
                        }
                    }
                }
            }
        }
        g.dispose();
        if (format == ExportFormat.PDF) {
            // coversion to PDF is a little tricky
            // although the manuals say that exporting PDF directly from SVG tree is possible, I didn't get correct
            // results - always just a blank PDF page; so we've written the SVGs to disk, loading them from there
            // works
            // SVG doesn't handle pages, nor Batik does, so we must write one file per page and then merge them
            // using iText
            PDFTranscoder trans = new PDFTranscoder();
            trans.addTranscodingHint(PDFTranscoder.KEY_WIDTH, (float) resultDim.width);
            trans.addTranscodingHint(PDFTranscoder.KEY_HEIGHT, (float) resultDim.height);
            List<File> newResult = new LinkedList<File>();
            for (File f : result) {
                // transcode SVGs to PDFs - one file per page
                TranscoderInput input = new TranscoderInput(new FileReader(f));
                File outFile = new File(parentFile, f.getName() + ".pdf");
                newResult.add(outFile);
                OutputStream stream = new FileOutputStream(outFile);
                TranscoderOutput output = new TranscoderOutput(stream);
                try {
                    trans.transcode(input, output);
                    newResult.add(outFile);
                } catch (TranscoderException e1) {
                    e = new IOException(e1);
                } finally {
                    try {
                        stream.flush();
                        stream.close();
                    } catch (IOException e1) {
                        e = e1;
                    }
                    progressCallback.run();
                }
            }
            // delete the temporary SVG files
            for (File f : result) f.delete();
            result.clear();
            result.addAll(newResult);
            // initialize iText
            com.itextpdf.text.Document doc = new com.itextpdf.text.Document(new com.itextpdf.text.Rectangle(resultDim.width, resultDim.height));
            PdfCopy copy = null;
            try {
                copy = new PdfCopy(doc, new FileOutputStream(file));
            } catch (DocumentException e2) {
                e = new IOException(e2);
            }
            // merge the multiple pdf files into one
            if (copy != null) {
                doc.open();
                PdfReader reader = null;
                int n;
                for (File f : result) {
                    try {
                        reader = new PdfReader(f.toString());
                        // loop over the pages in documents
                        n = reader.getNumberOfPages();
                        for (int page = 0; page < n; ) {
                            try {
                                copy.addPage(copy.getImportedPage(reader, ++page));
                            } catch (BadPdfFormatException e1) {
                                e = new IOException(e1);
                            }
                        }
                    } catch (IOException ex) {
                        e = ex;
                    } finally {
                        if (reader != null)
                            copy.freeReader(reader);
                        progressCallback.run();
                    }
                }
                doc.close();
                for (File f : result) f.delete();
                result.clear();
                result.add(file);
            }
        }
        // this way we try to create the most files, so one error in the middle won't break the rest of files
        if (e != null)
            throw e;
    } else if (format == ExportFormat.MOV) {
        MOVExportOptions opt = (MOVExportOptions) options;
        Canvas3D canvas = new Canvas3D(SimpleUniverse.getPreferredConfiguration(), true);
        canvas.setSize(opt.getSize());
        final StepMorphingCanvasController morpher = new StepMorphingCanvasController(canvas, origami, origami.getModel().getSteps().getStep().get(0), (int) (opt.getFps() * opt.getStepDuration()));
        JPEGMovieAnimation anim = new JPEGMovieAnimation(file);
        int numFrames = (int) (origami.getModel().getSteps().getStep().size() * opt.getFps() * opt.getStepDuration());
        int i = 0;
        BufferedImage im;
        while ((im = morpher.getNextFrame()) != null) {
            anim.addFrame((float) (1f / opt.getFps()), im, 1f);
            progressCallback.run();
            if (// we don't want an infinite loop when something goes bad
            i++ > numFrames)
                break;
        }
        anim.close();
        result.add(file);
    } else {
        Logger.getLogger("application").error("Unsupported export format: " + format);
        throw new IOException("Unsupported export format: " + format);
    }
    return result;
}

private NodeRef subsetPDFDocument(NodeRef targetNodeRef, Map<String, Serializable> params, String pages, boolean delete) {
    InputStream is = null;
    File tempDir = null;
    ContentWriter writer = null;
    PdfReader pdfReader = null;
    NodeRef destinationNode = null;
    try {
        ContentReader targetReader = getReader(targetNodeRef);
        is = targetReader.getContentInputStream();
        File alfTempDir = TempFileProvider.getTempDir();
        tempDir = new File(alfTempDir.getPath() + File.separatorChar + targetNodeRef.getId());
        tempDir.mkdir();
        Boolean inplace = Boolean.valueOf(String.valueOf(params.get(PARAM_INPLACE)));
        String fileName = getFilename(params, targetNodeRef);
        File file = new File(tempDir, ffs.getFileInfo(targetNodeRef).getName());
        pdfReader = new PdfReader(is);
        Document doc = new Document(pdfReader.getPageSizeWithRotation(1));
        PdfCopy copy = new PdfCopy(doc, new FileOutputStream(file));
        doc.open();
        List<Integer> pagelist = parsePageList(pages);
        for (int pageNum = 1; pageNum <= pdfReader.getNumberOfPages(); pageNum++) {
            if (pagelist.contains(pageNum) && !delete) {
                copy.addPage(copy.getImportedPage(pdfReader, pageNum));
            } else if (!pagelist.contains(pageNum) && delete) {
                copy.addPage(copy.getImportedPage(pdfReader, pageNum));
            }
        }
        doc.close();
        destinationNode = createDestinationNode(fileName, (NodeRef) params.get(PARAM_DESTINATION_FOLDER), targetNodeRef, inplace);
        writer = cs.getWriter(destinationNode, ContentModel.PROP_CONTENT, true);
        writer.setEncoding(targetReader.getEncoding());
        writer.setMimetype(FILE_MIMETYPE);
        // Put it in the repository
        writer.putContent(file);
        // Clean up
        file.delete();
    } catch (IOException e) {
        throw new AlfrescoRuntimeException(e.getMessage(), e);
    } catch (DocumentException e) {
        throw new AlfrescoRuntimeException(e.getMessage(), e);
    } catch (Exception e) {
        throw new AlfrescoRuntimeException(e.getMessage(), e);
    } finally {
        if (pdfReader != null) {
            pdfReader.close();
        }
        if (is != null) {
            try {
                is.close();
            } catch (IOException e) {
                throw new AlfrescoRuntimeException(e.getMessage(), e);
            }
        }
        if (tempDir != null) {
            tempDir.delete();
        }
    }
    return destinationNode;
}

public boolean split(OutputStream os, long sizeInBytes) throws IOException, DocumentException {
    if (!hasMorePages()) {
        os.close();
        return false;
    }
    overSized = false;
    Document document = new Document();
    PdfCopy copy = new PdfSmartCopy(document, os);
    document.open();
    boolean hasPage = false;
    PdfResourceCounter counter = new PdfResourceCounter(reader.getTrailer());
    long trailer = counter.getLength(null);
    Map<Integer, PdfObject> resources = counter.getResources();
    long length = 0;
    long page;
    while (hasMorePages()) {
        counter = new PdfResourceCounter(reader.getPageN(currentPage));
        page = counter.getLength(resources);
        resources = counter.getResources();
        length += page + trailer + xrefLength(resources.size());
        LOGGER.info(String.format("Page %s: Comparing %s with %s", currentPage, length, sizeInBytes));
        LOGGER.info(String.format("   page %s trailer %s xref %s", page, trailer, xrefLength(resources.size())));
        if (!hasPage || length < sizeInBytes) {
            hasPage = true;
            copy.addPage(copy.getImportedPage(reader, currentPage));
            length = copy.getOs().getCounter();
            LOGGER.info(String.format("Size after adding page: %s", length));
            if (length > sizeInBytes)
                overSized = true;
            currentPage++;
        } else {
            LOGGER.info("Page doesn't fit");
            break;
        }
    }
    document.close();
    return true;
}