Example usage for com.lowagie.text.pdf PdfCopy addPage

List of usage examples for com.lowagie.text.pdf PdfCopy addPage

Introduction

In this page you can find the example usage for com.lowagie.text.pdf PdfCopy addPage.

Prototype

public void addPage(PdfImportedPage iPage) throws IOException, BadPdfFormatException 

Source Link

Document

Add an imported page to our output

Usage

From source file:edu.psu.citeseerx.web.ViewPDFPageController.java

License:Apache License

public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException {

    String errorTitle = "Document Not Found";

    String doi = request.getParameter("doi");
    String rep = request.getParameter("rep");
    String page = request.getParameter("page");

    Map<String, Object> model = new HashMap<String, Object>();
    if (doi == null || rep == null) {
        model.put("pagetitle", errorTitle);
        return new ModelAndView("viewDocError", model);
    }/*  w w w .  j  av  a 2s .  c o m*/

    int iPage;
    try {
        iPage = Integer.parseInt(page);
    } catch (NumberFormatException e) {
        e.printStackTrace();
        model.put("pagetitle", errorTitle);
        return new ModelAndView("viewDocError", model);
    }

    try {
        PdfReader reader = csxdao.getPdfReader(doi, rep);
        Document document = new Document(reader.getPageSizeWithRotation(iPage));
        ByteArrayOutputStream baos = new ByteArrayOutputStream(OUTPUT_BYTE_ARRAY_INITIAL_SIZE);
        PdfCopy copy = new PdfCopy(document, baos);
        document.open();
        PdfImportedPage docPage = copy.getImportedPage(reader, iPage);
        copy.addPage(docPage);
        document.close();

        response.setContentType("application/pdf");
        response.setContentLength(baos.size());
        ServletOutputStream out = response.getOutputStream();
        baos.writeTo(out);
        out.flush();
    } catch (IOException e) {
        e.printStackTrace();
        model.put("pagetitle", errorTitle);
        return new ModelAndView("viewDocError", model);
    } catch (DocumentException e) {
        e.printStackTrace();
        model.put("pagetitle", errorTitle);
        return new ModelAndView("viewDocError", model);
    }
    return null;
}

From source file:Faculty.Scans_Upload_Processor.java

protected void service(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setContentType("text/html;charset=UTF-8");
    PrintWriter out = response.getWriter();
    try {//from  w w  w.java2  s.  co m
        HttpSession session = request.getSession();
        MyDB m = new MyDB();

        int total_sheets = (Integer) session.getAttribute("total_sheets");
        int p_id = (Integer) session.getAttribute("p_id");
        String path = (String) getServletContext().getInitParameter("Directory") + "//";

        if (!(new File(path)).exists()) {
            (new File(path)).mkdir(); // creates the directory if it does not exist        
        }

        path = path + (Integer) p_id + "//";

        System.out.println();
        ArrayList err = new ArrayList();
        ArrayList rollList = new ArrayList();
        ArrayList DocIds = new ArrayList();

        if (!(new File(path)).exists()) {
            (new File(path)).mkdir(); // creates the directory if it does not exist        
        }

        boolean isMultipart = ServletFileUpload.isMultipartContent(request);

        if (isMultipart) {

            // Create a factory for disk-based file items
            FileItemFactory factory = new DiskFileItemFactory();

            // Create a new file upload handler
            ServletFileUpload upload = new ServletFileUpload(factory);

            // Parse the request
            List /* FileItem */ items = upload.parseRequest(request);

            // Process the uploaded form items
            Iterator iter = items.iterator();

            while (iter.hasNext()) {
                FileItem item = (FileItem) iter.next();
                if (item.isFormField()) {
                } else {
                    try {

                        String str = item.getName();

                        String ext = FilenameUtils.getExtension(str);

                        if (ext.equals("txt") || ext.equals("text")) {
                            if ((new File(path + str)).exists()) {
                                (new File(path + str)).delete(); // deletes the file if it does already exist       
                            }

                            File savedFile = new File(path + str);

                            item.write(savedFile);

                            BufferedReader br = new BufferedReader(new FileReader(path + str));
                            String line;
                            while ((line = br.readLine()) != null) {
                                rollList.add(Integer.parseInt(line.trim()));
                            }
                            br.close();

                            DocIds = m.getDocIds(p_id, rollList);
                            Iterator it = DocIds.iterator();

                            while (it.hasNext()) {
                                int temp = (Integer) it.next();
                                if ((new File(path + temp + "//")).exists()) {
                                    try {
                                        delete(new File(path + temp + "//")); // deletes the directory if it does already exist       
                                    } catch (IOException e) {
                                        e.printStackTrace();
                                        System.exit(0);
                                    }

                                }

                            }
                            m.CreateDocIds(p_id, rollList);

                            DocIds = m.getDocIds(p_id, rollList);
                            it = DocIds.iterator();
                            while (it.hasNext()) {
                                int temp = (Integer) it.next();
                                if (!(new File(path + temp + "//")).exists()) {
                                    (new File(path + temp + "//")).mkdir(); // creates the directory if it does not exist        
                                }

                            }
                        }

                        else {
                            // To Store Split Files

                            if ((new File(path + "-1" + "//")).exists()) {
                                try {
                                    delete(new File(path + "-1" + "//")); // deletes the directory if it does already exist       
                                } catch (IOException e) {
                                    e.printStackTrace();
                                    System.exit(0);
                                }

                            }

                            if (!(new File(path + "-1" + "//")).exists()) {
                                (new File(path + "-1" + "//")).mkdir(); // creates the directory if it does not exist        
                            }

                            //Splitting PDF
                            int n = 0; // no.of pages
                            try {
                                File savedFile = new File(path + "-1" + "//" + str);
                                item.write(savedFile);

                                String inFile = path + "-1" + "//" + str;
                                System.out.println("Reading " + inFile);
                                PdfReader reader = new PdfReader(inFile);
                                n = reader.getNumberOfPages();

                                // Reply User if PDF has invalid number of scans
                                if (n != total_sheets * DocIds.size()) {
                                    m.deleteDocIds(p_id, rollList);
                                    Iterator it = DocIds.iterator();

                                    while (it.hasNext()) {
                                        int temp = (Integer) it.next();
                                        if ((new File(path + temp + "//")).exists()) {
                                            try {
                                                delete(new File(path + temp + "//")); // deletes the directory if it does already exist       
                                            } catch (IOException e) {
                                                e.printStackTrace();
                                                System.exit(0);
                                            }

                                        }

                                    }
                                    err.add("PDF has missing scans!! It must have "
                                            + total_sheets * DocIds.size() + " pages");

                                    break;
                                }
                                //                                    postData();

                                System.out.println("Number of pages : " + n);
                                int i = 0;
                                while (i < n) {
                                    String outFile = (i + 1) + ".pdf";
                                    System.out.println("Writing " + outFile);
                                    Document document = new Document(reader.getPageSizeWithRotation(1));
                                    PdfCopy writer = new PdfCopy(document,
                                            new FileOutputStream(path + "-1" + "//" + outFile));
                                    document.open();
                                    PdfImportedPage page = writer.getImportedPage(reader, ++i);
                                    writer.addPage(page);
                                    document.close();
                                    writer.close();
                                }

                            } catch (Exception e) {
                                e.printStackTrace();
                            }

                            // Placing files in Corresponding directories
                            //System.out.println(DocIds);
                            for (int i = 1; i <= n; i++) {
                                int temp2 = (i - 1) / total_sheets;
                                int d_id = (Integer) DocIds.get(temp2);
                                String itemName = "";

                                if ((i % total_sheets) == 0) {
                                    itemName = ((Integer) total_sheets).toString();
                                } else {
                                    itemName = ((Integer) (i % total_sheets)).toString();
                                }

                                File source = new File(path + "-1" + "//" + i + ".pdf");
                                File desc = new File(
                                        path + "-1//" + p_id + "_" + d_id + "_" + itemName + ".pdf");

                                try {
                                    FileUtils.copyFile(source, desc);
                                    uploadFile(path + "-1//" + p_id + "_" + d_id + "_" + itemName + ".pdf",
                                            (String) getServletContext().getInitParameter("UploadPhP"));
                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                            }

                            try {
                                delete(new File(path + "-1" + "//")); // deletes the directory if it does already exist  
                                delete(new File(path)); // deletes all docs in this paper id
                            } catch (IOException e) {
                                e.printStackTrace();
                                System.exit(0);
                            }

                            err.add("Scans  sucessfully saved !");
                        }

                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }

            request.setAttribute("err", err);

            RequestDispatcher rd = request.getRequestDispatcher("Paper_Spec_Fetcher");
            rd.forward(request, response);
        } else {
            // Normal request. request.getParameter will suffice.
        }

    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        out.close();
    }

}

From source file:is.idega.idegaweb.egov.printing.business.DocumentServiceBean.java

License:Open Source License

/**
 * Creates a pdf letter from a template which is chosen from the message type. Returns a primaryKey to a file in database
 *//*from w w w .  j ava  2s  .  co m*/
public Integer createPDF(IWUserContext iwuc, Collection msgs, String type, String fileName,
        boolean flagPrinted) {
    OutputStream outerOs = null;
    InputStream outerIs = null;
    try {
        MemoryFileBuffer outerBuf = new MemoryFileBuffer();
        outerOs = new MemoryOutputStream(outerBuf);
        outerIs = new MemoryInputStream(outerBuf);

        //
        // step 1: creation of a document-object
        Document document = new Document();
        // step 2: we create a writer that listens to the document
        PdfCopy writer = new PdfCopy(document, outerOs);
        // step 3: we open the document
        document.open();

        ICFile bulkFile = getICFileHome().create();
        bulkFile.store();

        PrintingService pserv = getPrintingService();

        CommuneMessageBusiness msgBuiz = getMessageService();
        int lettersProcessed = 0;
        for (Iterator iter = msgs.iterator(); iter.hasNext();) {
            PrintMessage msg = (PrintMessage) iter.next();
            MemoryFileBuffer buffer = new MemoryFileBuffer();
            OutputStream mos = new MemoryOutputStream(buffer);
            InputStream mis = new MemoryInputStream(buffer);

            PrintingContext pcx = getPrintingContext(iwuc, msg);
            if (pcx != null) {
                pcx.setDocumentStream(mos);
                pserv.printDocument(pcx);

                PdfReader reader = new PdfReader(buffer.buffer());
                PdfImportedPage page;
                int n = reader.getNumberOfPages();
                for (int i = 0; i < n;) {
                    ++i;
                    page = writer.getImportedPage(reader, i);
                    writer.addPage(page);
                }
                lettersProcessed++;
                storeStreamToICFile(iwuc, msgBuiz, msg, mis, fileName, buffer.length(), flagPrinted);
                msg.setMessageBulkData(bulkFile);
                msg.store();
            }
        }
        document.close();
        bulkFile = createFile(bulkFile, fileName, outerIs, outerBuf.length());

        PrintDocuments pdocs = getPrintDocumentsHome().create();
        pdocs.setDocument(bulkFile);
        pdocs.setNumberOfSubDocuments(lettersProcessed);
        pdocs.setCreator(iwuc.getCurrentUser());
        pdocs.setType(type);
        pdocs.store();

        return (Integer) bulkFile.getPrimaryKey();
    } catch (Exception e) {
        e.printStackTrace();
        throw new ContentCreationException(e);
    } finally {
        try {
            outerOs.close();
            outerIs.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

From source file:it.pdfsam.console.tools.pdf.PdfAlternateMix.java

License:Open Source License

/**
  * Execute the mix command. On error an exception is thrown.
  * @throws AlternateMixException//  ww  w  .j ava2s .co m
  */
public void execute() throws AlternateMixException {
    try {
        workingIndeterminate();
        out_message = "";
        Document pdf_document = null;
        PdfCopy pdf_writer = null;
        File tmp_o_file = TmpFileNameGenerator.generateTmpFile(o_file.getParent());
        PdfReader pdf_reader1;
        PdfReader pdf_reader2;

        pdf_reader1 = new PdfReader(new RandomAccessFileOrArray(input_file1.getAbsolutePath()), null);
        pdf_reader1.consolidateNamedDestinations();
        limits1[1] = pdf_reader1.getNumberOfPages();

        pdf_reader2 = new PdfReader(new RandomAccessFileOrArray(input_file2.getAbsolutePath()), null);
        pdf_reader2.consolidateNamedDestinations();
        limits2[1] = pdf_reader2.getNumberOfPages();

        pdf_document = new Document(pdf_reader1.getPageSizeWithRotation(1));
        pdf_writer = new PdfCopy(pdf_document, new FileOutputStream(tmp_o_file));
        if (compressed_boolean) {
            pdf_writer.setFullCompression();
        }
        out_message += LogFormatter.formatMessage("Temporary file created-\n");
        MainConsole.setDocumentCreator(pdf_document);
        pdf_document.open();

        PdfImportedPage page;
        //importo
        boolean finished1 = false;
        boolean finished2 = false;
        int current1 = (reverseFirst) ? limits1[1] : limits1[0];
        int current2 = (reverseSecond) ? limits2[1] : limits2[0];
        while (!finished1 || !finished2) {
            if (!finished1) {
                if (current1 >= limits1[0] && current1 <= limits1[1]) {
                    page = pdf_writer.getImportedPage(pdf_reader1, current1);
                    pdf_writer.addPage(page);
                    current1 = (reverseFirst) ? (current1 - 1) : (current1 + 1);
                } else {
                    out_message += LogFormatter.formatMessage("First file processed-\n");
                    finished1 = true;
                }
            }
            if (!finished2) {
                if (current2 >= limits2[0] && current2 <= limits2[1] && !finished2) {
                    page = pdf_writer.getImportedPage(pdf_reader2, current2);
                    pdf_writer.addPage(page);
                    current2 = (reverseSecond) ? (current2 - 1) : (current2 + 1);
                } else {
                    out_message += LogFormatter.formatMessage("Second file processed-\n");
                    finished2 = true;
                }
            }

        }

        pdf_reader1.close();
        pdf_writer.freeReader(pdf_reader1);
        pdf_reader2.close();
        pdf_writer.freeReader(pdf_reader2);

        pdf_document.close();
        // step 6: temporary buffer moved to output file
        renameTemporaryFile(tmp_o_file, o_file, overwrite_boolean);
        out_message += LogFormatter.formatMessage("Alternate mix completed-\n");

    } catch (Exception e) {
        throw new AlternateMixException(e);
    } finally {
        workCompleted();
    }
}

From source file:it.pdfsam.console.tools.pdf.PdfSplit.java

License:Open Source License

/**
* Execute the split of a pdf document when split type is S_ODD or S_EVEN
* @param pdf_reader pdfreader of the original pdf document
* @throws Exception//from  ww w  . ja v a  2s  .  c o  m
*/
private void doSplitOddEven(PdfReader pdf_reader) throws Exception {
    int current_page;
    Document current_document = new Document(pdf_reader.getPageSizeWithRotation(1));
    boolean time_to_close = false;
    PdfCopy pdf_writer = null;
    PdfImportedPage imported_page;
    File tmp_o_file = null;
    File o_file = null;
    for (current_page = 1; current_page <= n; current_page++) {
        //check if i've to read one more page or to open a new doc
        if ((current_page != 1) && ((split_type.equals(CmdParser.S_ODD) && ((current_page % 2) != 0))
                || (split_type.equals(CmdParser.S_EVEN) && ((current_page % 2) == 0)))) {
            time_to_close = true;
        } else {
            time_to_close = false;
        }
        if (!time_to_close) {
            tmp_o_file = TmpFileNameGenerator.generateTmpFile(o_dir);
            o_file = new File(o_dir, prefixParser.generateFileName(file_number_formatter.format(current_page)));
            // step 1: creation of a document-object
            current_document = new Document(pdf_reader.getPageSizeWithRotation(current_page));
            // step 2: we create a writer that listens to the document
            pdf_writer = new PdfCopy(current_document, new FileOutputStream(tmp_o_file));
            if (compressed_boolean) {
                pdf_writer.setFullCompression();
            }
            MainConsole.setDocumentCreator(current_document);
            // step 3: we open the document
            current_document.open();
        }
        imported_page = pdf_writer.getImportedPage(pdf_reader, current_page);
        pdf_writer.addPage(imported_page);
        //if it's time to close the document
        if ((time_to_close) || (current_page == n)
                || ((current_page == 1) && (split_type.equals(CmdParser.S_ODD)))) {
            current_document.close();
            renameTemporaryFile(tmp_o_file, o_file, overwrite_boolean);
        }
        percentageChanged(java.lang.Math.round((current_page * 100) / n));
    }
    out_message += LogFormatter.formatMessage("Split " + split_type + " done.\n");
}

From source file:it.pdfsam.console.tools.pdf.PdfSplit.java

License:Open Source License

/**
* Execute the split of a pdf document when split type is S_BURST
* @param pdf_reader pdfreader of the original pdf document
* @throws Exception//from  w ww  .  ja v  a  2  s.c  o m
*/
private void doSplitBurst(PdfReader pdf_reader) throws Exception {
    int current_page;
    Document current_document;
    for (current_page = 1; current_page <= n; current_page++) {
        File tmp_o_file = TmpFileNameGenerator.generateTmpFile(o_dir);
        File o_file = new File(o_dir,
                prefixParser.generateFileName(file_number_formatter.format(current_page)));
        // step 1: creation of a document-object
        current_document = new Document(pdf_reader.getPageSizeWithRotation(current_page));
        // step 2: we create a writer that listens to the document
        PdfCopy pdf_writer = new PdfCopy(current_document, new FileOutputStream(tmp_o_file));
        if (compressed_boolean) {
            pdf_writer.setFullCompression();
        }
        // step 3: we open the document
        MainConsole.setDocumentCreator(current_document);
        current_document.open();
        PdfImportedPage imported_page = pdf_writer.getImportedPage(pdf_reader, current_page);
        pdf_writer.addPage(imported_page);
        current_document.close();
        renameTemporaryFile(tmp_o_file, o_file, overwrite_boolean);
        percentageChanged(java.lang.Math.round((current_page * 100) / n));
    }
    out_message += LogFormatter.formatMessage("Burst done.\n");
}

From source file:it.pdfsam.console.tools.pdf.PdfSplit.java

License:Open Source License

/**
 * Execute the split of a pdf document when split type is S_SPLIT
 * /*www  .  ja v  a  2 s.c  om*/
 * @param pdf_reader
 *                pdfreader of the original pdf document
 * @param out_files_name
 *                output file name
 * @throws Exception
 */
private void doSplitSplit(PdfReader pdf_reader) throws Exception {
    String[] limits = snumber_page.split("-");
    Arrays.sort(limits, new StrNumComparator());
    // limits list validation end clean
    LinkedList limits_list = validateSplitLimits(limits, n);
    if (limits_list == null) {
        throw new SplitException("PageNumberError: Cannot find page limits, please check input value.");
    }
    if (limits_list.isEmpty()) {
        throw new SplitException("PageNumberError: Cannot find page limits, please check input value.");
    }
    // HERE I'M SURE I'VE A LIMIT LIST WITH VALUES, I CAN START
    // BOOKMARKS
    Iterator itr = limits_list.iterator();
    int current_page;
    int relative_current_page = 0;
    int end_page = n;
    int start_page = 1;
    Document current_document = new Document(pdf_reader.getPageSizeWithRotation(1));
    PdfCopy pdf_writer = null;
    PdfImportedPage imported_page;
    File tmp_o_file = null;
    File o_file = null;
    if (itr.hasNext()) {
        end_page = Integer.parseInt((String) itr.next());
    }
    for (current_page = 1; current_page <= n; current_page++) {
        relative_current_page++;
        //check if i've to read one more page or to open a new doc
        if (relative_current_page == 1) {
            tmp_o_file = TmpFileNameGenerator.generateTmpFile(o_dir);
            o_file = new File(o_dir, prefixParser.generateFileName(file_number_formatter.format(current_page)));
            start_page = current_page;
            // step 1: creation of a document-object
            current_document = new Document(pdf_reader.getPageSizeWithRotation(current_page));
            // step 2: we create a writer that listens to the document
            pdf_writer = new PdfCopy(current_document, new FileOutputStream(tmp_o_file));
            if (compressed_boolean) {
                pdf_writer.setFullCompression();
            }
            MainConsole.setDocumentCreator(current_document);
            // step 3: we open the document
            current_document.open();
        }
        imported_page = pdf_writer.getImportedPage(pdf_reader, current_page);
        pdf_writer.addPage(imported_page);
        // if it's time to close the document
        if (current_page == end_page) {
            out_message += LogFormatter.formatMessage(
                    "Temporary document " + tmp_o_file.getName() + " done, now adding bookmarks...\n");
            //manage bookmarks
            ArrayList master = new ArrayList();
            List this_book = SimpleBookmark.getBookmark(pdf_reader);
            if (this_book != null) {
                //ArrayList this_book = new ArrayList(bookmarks);
                SimpleBookmark.eliminatePages(this_book, new int[] { end_page + 1, n });
                if (start_page > 1) {
                    SimpleBookmark.eliminatePages(this_book, new int[] { 1, start_page - 1 });
                    SimpleBookmark.shiftPageNumbers(this_book, -(start_page - 1), null);
                }
                master.addAll(this_book);
                pdf_writer.setOutlines(master);
            }
            relative_current_page = 0;
            current_document.close();
            renameTemporaryFile(tmp_o_file, o_file, overwrite_boolean);
            end_page = (itr.hasNext()) ? Integer.parseInt((String) itr.next()) : n;
        }
        percentageChanged((current_page * 100) / n);
    }
    out_message += LogFormatter.formatMessage("Split " + split_type + " done.\n");
}

From source file:jPDFmelange.MelangeJFrame.java

License:Open Source License

/** 
 *  Main save method./*from  w w  w .j  a  va 2s .  co m*/
 *  <p> 
 *  Saves all elements of the main list represented with its {@link MelangeJFrame#listContentMain content} 
 *  to the specified file.
 *  
 *   @param fileName name of file to save.
 *   @throws IOException on File IO error.
 *   @throws DocumentException on itext PDF error. 
 */
private void saveFile(String fileName) throws IOException, DocumentException {
    File file = new File(fileName);
    File tmpfile = File.createTempFile("Mixer", null, file.getParentFile());
    String bakFileName = fileName.substring(0, fileName.lastIndexOf('.')).concat(".bak");
    File bakfile = new File(bakFileName);

    //
    // prevent writing to a PDF that is blocked by the renderer.
    //
    jPanePreview.closePdfFile();

    // itext usage
    System.out.println("Writing new content to <" + tmpfile.getName() + ">");
    PdfReader reader = null;
    PdfDictionary dict = null;
    Document pdfDoc = new Document();
    PdfCopy writer = new PdfCopy(pdfDoc, new FileOutputStream(tmpfile));
    pdfDoc.open();
    PageNode node = null;
    for (int i = 0; i < listContentMain.size(); i++) {
        node = (PageNode) listContentMain.get(i);
        if (node.password == null)
            reader = new PdfReader(node.filename);
        else
            reader = new PdfReader(node.filename, node.password.getBytes());
        dict = reader.getPageN(node.pagenumber);
        dict.put(PdfName.ROTATE, new PdfNumber(node.rotation));
        writer.addPage(writer.getImportedPage(reader, node.pagenumber));
        reader.close(); // close input file
        System.out
                .println("Page " + node.pagenumber + "  File:" + node.filename + "  Rotation:" + node.rotation);
    }

    //
    // save page mode and layout preferences
    //
    if (jCheckBoxEnablePDFViewerPrefs.isSelected()) {

        String key = jPanelViewPrefs.getKeyPageMode();
        writer.setViewerPreferences(PageMode.get(key));

        key = jPanelViewPrefs.getKeyPageLayout();
        writer.setViewerPreferences(PageLayout.get(key));

        if (jPanelViewPrefs.jCheckBoxHideToolbar.isSelected())
            writer.addViewerPreference(PdfName.HIDETOOLBAR, PdfBoolean.PDFTRUE);
        if (jPanelViewPrefs.jCheckBoxHideMenubar.isSelected())
            writer.addViewerPreference(PdfName.HIDEMENUBAR, PdfBoolean.PDFTRUE);
        if (jPanelViewPrefs.jCheckBoxHideWindowUI.isSelected())
            writer.addViewerPreference(PdfName.HIDEWINDOWUI, PdfBoolean.PDFTRUE);
        if (jPanelViewPrefs.jCheckBoxFitWindow.isSelected())
            writer.addViewerPreference(PdfName.FITWINDOW, PdfBoolean.PDFTRUE);
        if (jPanelViewPrefs.jCheckBoxCenterWindow.isSelected())
            writer.addViewerPreference(PdfName.CENTERWINDOW, PdfBoolean.PDFTRUE);
        if (jPanelViewPrefs.jCheckBoxDisplayDocTitle.isSelected())
            writer.addViewerPreference(PdfName.DISPLAYDOCTITLE, PdfBoolean.PDFTRUE);
    }

    pdfDoc.close(); // close Helper Class
    writer.close(); // close output file

    // save old file to a XXX.bak file
    if (bakfile.exists())
        bakfile.delete();
    if (file.renameTo(bakfile.getCanonicalFile())) {
        System.out.println("Orginal File is saved in <" + bakfile.getName() + ">");
    }

    // move new content to original file name
    file = new File(fileName);
    if (tmpfile.renameTo(file))
        System.out.println("<" + tmpfile.getName() + "> is copied to <" + file.getName() + "> ");
    else {
        JOptionPane.showMessageDialog(MelangeJFrame.this,
                messages.getString("canNotWriteFile") + file.getName() + messages.getString("trySaveAs"),
                messages.getString("warning"), JOptionPane.WARNING_MESSAGE);
        System.out.println(
                messages.getString("canNotWriteFile") + file.getName() + messages.getString("trySaveAs"));
    }

}

From source file:lucee.runtime.tag.Document.java

License:Open Source License

private void render(OutputStream os, boolean doBookmarks, boolean doHtmlBookmarks)
        throws IOException, PageException, DocumentException {
    byte[] pdf = null;
    // merge multiple docs to 1
    if (documents.size() > 1) {
        PDFDocument[] pdfDocs = new PDFDocument[documents.size()];
        PdfReader[] pdfReaders = new PdfReader[pdfDocs.length];
        Iterator<PDFDocument> it = documents.iterator();
        int index = 0;
        // generate pdf with pd4ml
        while (it.hasNext()) {
            pdfDocs[index] = it.next();//from  ww w  .j  a  va  2  s  .  c o  m
            pdfReaders[index] = new PdfReader(
                    pdfDocs[index].render(getDimension(), unitFactor, pageContext, doHtmlBookmarks));
            index++;
        }

        // collect together
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        com.lowagie.text.Document document = new com.lowagie.text.Document(
                pdfReaders[0].getPageSizeWithRotation(1));
        PdfCopy copy = new PdfCopy(document, baos);
        document.open();
        String name;
        ArrayList bookmarks = doBookmarks ? new ArrayList() : null;
        try {
            int size, totalPage = 0;
            Map parent;
            for (int doc = 0; doc < pdfReaders.length; doc++) {
                size = pdfReaders[doc].getNumberOfPages();

                PdfImportedPage ip;

                // bookmarks
                if (doBookmarks) {
                    name = pdfDocs[doc].getName();
                    if (!StringUtil.isEmpty(name)) {
                        bookmarks.add(parent = PDFUtil.generateGoToBookMark(name, totalPage + 1));
                    } else
                        parent = null;

                    if (doHtmlBookmarks) {
                        java.util.List pageBM = SimpleBookmark.getBookmark(pdfReaders[doc]);
                        if (pageBM != null) {
                            if (totalPage > 0)
                                SimpleBookmark.shiftPageNumbers(pageBM, totalPage, null);
                            if (parent != null)
                                PDFUtil.setChildBookmarks(parent, pageBM);
                            else
                                bookmarks.addAll(pageBM);
                        }
                    }
                }

                totalPage++;
                for (int page = 1; page <= size; page++) {
                    if (page > 1)
                        totalPage++;
                    ip = copy.getImportedPage(pdfReaders[doc], page);

                    //ip.getPdfDocument().setHeader(arg0);
                    //ip.getPdfDocument().setFooter(arg0);
                    copy.addPage(ip);
                }
            }
            if (doBookmarks && !bookmarks.isEmpty())
                copy.setOutlines(bookmarks);
        } finally {
            document.close();
        }
        pdf = baos.toByteArray();
    } else if (documents.size() == 1) {
        pdf = (documents.get(0)).render(getDimension(), unitFactor, pageContext, doHtmlBookmarks);
    } else {
        pdf = getDocument().render(getDimension(), unitFactor, pageContext, doHtmlBookmarks);
    }

    // permission/encryption
    if (PDFDocument.ENC_NONE != encryption) {
        PdfReader reader = new PdfReader(pdf);
        com.lowagie.text.Document document = new com.lowagie.text.Document(reader.getPageSize(1));
        document.addCreator("Lucee " + Info.getVersionAsString() + " " + Info.getStateAsString());
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        PdfCopy copy = new PdfCopy(document, baos);
        //PdfWriter writer = PdfWriter.getInstance(document, pdfOut);
        copy.setEncryption(PDFDocument.ENC_128BIT == encryption, userpassword, ownerpassword, permissions);
        document.open();
        int size = reader.getNumberOfPages();
        for (int page = 1; page <= size; page++) {
            copy.addPage(copy.getImportedPage(reader, page));
        }
        document.close();
        pdf = baos.toByteArray();
    }

    // write out
    if (os != null)
        IOUtil.copy(new ByteArrayInputStream(pdf), os, true, false);
    if (!StringUtil.isEmpty(name)) {
        pageContext.setVariable(name, pdf);
    }
}

From source file:lucee.runtime.text.pdf.PDFUtil.java

License:Open Source License

/**
 * @param docs//from w  w w.j a v  a2  s  . c  o  m
 * @param os
 * @param removePages if true, pages defined in PDFDocument will be removed, otherwise all other pages will be removed
 * @param version 
 * @throws PageException 
 * @throws IOException 
 * @throws DocumentException 
 */
public static void concat(PDFDocument[] docs, OutputStream os, boolean keepBookmark, boolean removePages,
        boolean stopOnError, char version) throws PageException, IOException, DocumentException {
    Document document = null;
    PdfCopy writer = null;
    PdfReader reader;
    Set pages;
    boolean isInit = false;
    PdfImportedPage page;
    try {
        int pageOffset = 0;
        ArrayList master = new ArrayList();

        for (int i = 0; i < docs.length; i++) {
            // we create a reader for a certain document
            pages = docs[i].getPages();
            try {
                reader = docs[i].getPdfReader();
            } catch (Throwable t) {
                if (!stopOnError)
                    continue;
                throw Caster.toPageException(t);
            }
            reader.consolidateNamedDestinations();

            // we retrieve the total number of pages
            int n = reader.getNumberOfPages();
            List bookmarks = keepBookmark ? SimpleBookmark.getBookmark(reader) : null;
            if (bookmarks != null) {
                removeBookmarks(bookmarks, pages, removePages);
                if (pageOffset != 0)
                    SimpleBookmark.shiftPageNumbers(bookmarks, pageOffset, null);
                master.addAll(bookmarks);
            }

            if (!isInit) {
                isInit = true;
                document = new Document(reader.getPageSizeWithRotation(1));
                writer = new PdfCopy(document, os);

                if (version != 0)
                    writer.setPdfVersion(version);

                document.open();
            }

            for (int y = 1; y <= n; y++) {
                if (pages != null && removePages == pages.contains(Integer.valueOf(y))) {
                    continue;
                }
                pageOffset++;
                page = writer.getImportedPage(reader, y);
                writer.addPage(page);
            }
            PRAcroForm form = reader.getAcroForm();
            if (form != null)
                writer.copyAcroForm(reader);
        }
        if (master.size() > 0)
            writer.setOutlines(master);

    } finally {
        IOUtil.closeEL(document);
    }
}