com.openbravo.pos.util.JRPrinterAWT411.java Source code

Java tutorial

Introduction

Here is the source code for com.openbravo.pos.util.JRPrinterAWT411.java

Source

/*
 * JasperReports - Free Java Reporting Library.
 * Copyright (C) 2001 - 2009 Jaspersoft Corporation. All rights reserved.
 * http://www.jaspersoft.com
 *
 * Unless you have purchased a commercial license agreement from Jaspersoft,
 * the following license terms apply:
 *
 * This program is part of JasperReports.
 *
 * JasperReports is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * JasperReports is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with JasperReports. If not, see <http://www.gnu.org/licenses/>.
 */

//    Portions:
//    Openbravo POS is a point of sales application designed for touch screens.
//    Copyright (C) 2007-2009 Openbravo, S.L.
//    http://www.openbravo.com/product/pos
//    author adrian romero
//    This class is a copy of net.sf.jasperreports.view.JRViewer
//    The modifications are:
//    The loadJasperPrint() method 
//    And the redesign of the design properties of the toolbar
//    Nothing else.

/*    Update for support library jasperreports 4.1.1
 *    @author Andrey Svininykh <svininykh@gmail.com>
 *    http://code.google.com/p/openbravoposru/
 */

package com.openbravo.pos.util;

import java.awt.Graphics;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.awt.print.Book;
import java.awt.print.PageFormat;
import java.awt.print.Paper;
import java.awt.print.Printable;
import java.awt.print.PrinterException;
import java.awt.print.PrinterJob;

import javax.print.PrintService;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JRExporterParameter;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.export.JRGraphics2DExporter;
import net.sf.jasperreports.engine.export.JRGraphics2DExporterParameter;
import net.sf.jasperreports.engine.util.JRGraphEnvInitializer;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * @author Teodor Danciu (teodord@users.sourceforge.net)
 * @version $Id: JRPrinterAWT.java 3940 2010-08-20 10:35:15Z teodord $
 */
public class JRPrinterAWT411 implements Printable {
    private static final Log log = LogFactory.getLog(JRPrinterAWT411.class);

    /**
     *
     */
    private JasperPrint jasperPrint = null;
    private int pageOffset = 0;

    /**
     *
     */
    protected JRPrinterAWT411(JasperPrint jrPrint) throws JRException {
        JRGraphEnvInitializer.initializeGraphEnv();

        jasperPrint = jrPrint;
    }

    /**
     *
     */
    public static boolean printPages(JasperPrint jrPrint, int firstPageIndex, int lastPageIndex,
            PrintService service) throws JRException {
        JRPrinterAWT411 printer = new JRPrinterAWT411(jrPrint);
        return printer.printPages(firstPageIndex, lastPageIndex, service);
    }

    /**
     *
     */
    public static Image printPageToImage(JasperPrint jrPrint, int pageIndex, float zoom) throws JRException {
        JRPrinterAWT411 printer = new JRPrinterAWT411(jrPrint);
        return printer.printPageToImage(pageIndex, zoom);
    }

    /**
     *
     */
    private boolean printPages(int firstPageIndex, int lastPageIndex, PrintService service) throws JRException {
        boolean isOK = true;

        if (firstPageIndex < 0 || firstPageIndex > lastPageIndex
                || lastPageIndex >= jasperPrint.getPages().size()) {
            throw new JRException("Invalid page index range : " + firstPageIndex + " - " + lastPageIndex + " of "
                    + jasperPrint.getPages().size());
        }

        pageOffset = firstPageIndex;

        PrinterJob printJob = PrinterJob.getPrinterJob();

        // fix for bug ID 6255588 from Sun bug database
        initPrinterJobFields(printJob);

        PageFormat pageFormat = printJob.defaultPage();
        Paper paper = pageFormat.getPaper();

        printJob.setJobName("JasperReports - " + jasperPrint.getName());

        switch (jasperPrint.getOrientationValue()) {
        case LANDSCAPE: {
            pageFormat.setOrientation(PageFormat.LANDSCAPE);
            paper.setSize(jasperPrint.getPageHeight(), jasperPrint.getPageWidth());
            paper.setImageableArea(0, 0, jasperPrint.getPageHeight(), jasperPrint.getPageWidth());
            break;
        }
        case PORTRAIT:
        default: {
            pageFormat.setOrientation(PageFormat.PORTRAIT);
            paper.setSize(jasperPrint.getPageWidth(), jasperPrint.getPageHeight());
            paper.setImageableArea(0, 0, jasperPrint.getPageWidth(), jasperPrint.getPageHeight());
        }
        }

        pageFormat.setPaper(paper);

        Book book = new Book();
        book.append(this, pageFormat, lastPageIndex - firstPageIndex + 1);
        printJob.setPageable(book);
        try {
            if (service == null) {
                if (printJob.printDialog()) {
                    printJob.print();
                } else {
                    isOK = false;
                }
            } else {
                printJob.setPrintService(service);
                printJob.print();
            }
        } catch (Exception ex) {
            throw new JRException("Error printing report.", ex);
        }

        return isOK;
    }

    /**
     *
     */
    public int print(Graphics graphics, PageFormat pageFormat, int pageIndex) throws PrinterException {
        if (Thread.currentThread().isInterrupted()) {
            throw new PrinterException("Current thread interrupted.");
        }

        pageIndex += pageOffset;

        if (pageIndex < 0 || pageIndex >= jasperPrint.getPages().size()) {
            return Printable.NO_SUCH_PAGE;
        }

        try {
            JRGraphics2DExporter exporter = new JRGraphics2DExporter();
            exporter.setParameter(JRExporterParameter.JASPER_PRINT, this.jasperPrint);
            exporter.setParameter(JRGraphics2DExporterParameter.GRAPHICS_2D, graphics);
            exporter.setParameter(JRExporterParameter.PAGE_INDEX, Integer.valueOf(pageIndex));
            exporter.exportReport();
        } catch (JRException e) {
            if (log.isDebugEnabled()) {
                log.debug("Print failed.", e);
            }

            throw new PrinterException(e.getMessage()); //NOPMD
        }

        return Printable.PAGE_EXISTS;
    }

    /**
     *
     */
    private Image printPageToImage(int pageIndex, float zoom) throws JRException {
        Image pageImage = new BufferedImage((int) (jasperPrint.getPageWidth() * zoom) + 1,
                (int) (jasperPrint.getPageHeight() * zoom) + 1, BufferedImage.TYPE_INT_RGB);

        JRGraphics2DExporter exporter = new JRGraphics2DExporter();
        exporter.setParameter(JRExporterParameter.JASPER_PRINT, this.jasperPrint);
        exporter.setParameter(JRGraphics2DExporterParameter.GRAPHICS_2D, pageImage.getGraphics());
        exporter.setParameter(JRExporterParameter.PAGE_INDEX, Integer.valueOf(pageIndex));
        exporter.setParameter(JRGraphics2DExporterParameter.ZOOM_RATIO, new Float(zoom));
        exporter.exportReport();

        return pageImage;
    }

    /**
     * Fix for bug ID 6255588 from Sun bug database
     * @param job print job that the fix applies to
     */
    public static void initPrinterJobFields(PrinterJob job) {
        try {
            job.setPrintService(job.getPrintService());
        } catch (PrinterException e) {
        }
    }

    public static long getImageSize(JasperPrint jasperPrint, float zoom) {
        int width = (int) (jasperPrint.getPageWidth() * zoom) + 1;
        int height = (int) (jasperPrint.getPageHeight() * zoom) + 1;
        return width * height;
    }
}