• Java 打印程序设计实例


    3.1 打印文本

    3.1.1 应用场景

    假设我们需要打印一个窗体的某个文本编辑域(可能只有几行,也可能包含多页)的内容,并且每页最多打印 54 行,如何实现呢?

    3.1.2 解决方法

    基本思路如下:首先我们需要实现 Printable 接口,然后按照每页最多 54 行的格式计算共需要打印多少页,当打印文本的按钮被点击时,执行相应的打印动作。打印文本的具体操作可通过 Graphics2D 的 drawString 方法来实现。

    1、实现 Printable 接口

     /*Graphic 指明打印的图形环境;PageFormat 指明打印页格式(页面大小以点为计量单位,
     1 点为 1 英才的 1/72,1 英寸为 25.4 毫米。A4 纸大致为 595 × 842 点);page 指明页号 */ 
     public int print(Graphics g, PageFormat pf, int page) throws PrinterException 
     { 
        Graphics2D g2 = (Graphics2D)g; 
        g2.setPaint(Color.black); // 设置打印颜色为黑色
         if (page >= PAGES) // 当打印页号大于需要打印的总页数时,打印工作结束
             return Printable.NO_SUCH_PAGE; 
        g2.translate(pf.getImageableX(), pf.getImageableY());// 转换坐标,确定打印边界
        drawCurrentPageText(g2, pf, page); // 打印当前页文本
     return Printable.PAGE_EXISTS; // 存在打印页时,继续打印工作
     } 
         /* 打印指定页号的具体文本内容 */ 
        private void drawCurrentPageText(Graphics2D g2, PageFormat pf, int page) 
         { 
             String s = getDrawText(printStr)[page];// 获取当前页的待打印文本内容
            // 获取默认字体及相应的尺寸
     FontRenderContext context = g2.getFontRenderContext(); 
            Font f = area.getFont(); 
            String drawText; 
            float ascent = 16;      // 给定字符点阵
            int k, i = f.getSize(), lines = 0; 
            while(s.length() > 0 && lines < 54) // 每页限定在 54 行以内
            { 
                 k = s.indexOf('
    '); // 获取每一个回车符的位置
                if (k != -1)  // 存在回车符
                { 
                     lines += 1; // 计算行数
                    drawText = s.substring(0, k); // 获取每一行文本
                    g2.drawString(drawText, 0, ascent); // 具体打印每一行文本,同时走纸移位
                    if (s.substring(k + 1).length() > 0) 
                    { 
                         s = s.substring(k + 1); // 截取尚未打印的文本
                        ascent += i; 
                    } 
                } 
                else // 不存在回车符
                { 
                     lines += 1; // 计算行数
                        drawText = s; // 获取每一行文本
                    g2.drawString(drawText, 0, ascent); // 具体打印每一行文本,同时走纸移位
                    s = ""; // 文本已结束
                } 
            } 
        } 
         /* 将打印目标文本按页存放为字符串数组 */ 
         public String[] getDrawText(String s) 
        { 
            String[] drawText = new String[PAGES];// 根据页数初始化数组
            for (int i = 0; i < PAGES; i++) 
                drawText[i] = ""; // 数组元素初始化为空字符串
            
            int k, suffix = 0, lines = 0; 
            while(s.length() > 0) 
            { 
                if(lines < 54) // 不够一页时
                { 
                    k = s.indexOf('
    '); 
                    if (k != -1) // 存在回车符
                    { 
                        lines += 1; // 行数累加
                         // 计算该页的具体文本内容,存放到相应下标的数组元素
                        drawText[suffix] = drawText[suffix] + s.substring(0, k + 1); 
                        if (s.substring(k + 1).length() > 0) 
                            s = s.substring(k + 1); 
                    } 
                    else 
                    { 
                        lines += 1; // 行数累加
                         // 将文本内容存放到相应的数组元素
                        drawText[suffix] = drawText[suffix] + s; 
                        s = ""; 
                    } 
                } 
                else // 已满一页时
                { 
                    lines = 0; // 行数统计清零
                    suffix++; // 数组下标加 1 
                } 
            } 
            return drawText; 
        }

    2、计算需要打印的总页数

     public int getPagesCount(String curStr) 
         { 
            int page = 0; 
            int position, count = 0; 
            String str = curStr; 
            while(str.length() > 0) // 文本尚未计算完毕
            { 
                position = str.indexOf('
    '); // 计算回车符的位置
                count += 1; // 统计行数
                if (position != -1) 
                    str = str.substring(position + 1); // 截取尚未计算的文本
                else 
                    str = ""; // 文本已计算完毕
            } 
            if (count > 0) 
                page = count / 54 + 1; // 以总行数除以 54 获取总页数
            return page; // 返回需打印的总页数
         }

    3.1、以 jdk1.4 以前的版本实现打印动作按钮监听,并完成具体的打印操作

         private void printTextAction() 
        { 
            printStr = area.getText().trim(); // 获取需要打印的目标文本
            if (printStr != null && printStr.length() > 0) // 当打印内容不为空时
            { 
                PAGES = getPagesCount(printStr); // 获取打印总页数
                PrinterJob myPrtJob = PrinterJob.getPrinterJob(); // 获取默认打印作业
                PageFormat pageFormat = myPrtJob.defaultPage(); // 获取默认打印页面格式
                myPrtJob.setPrintable(this, pageFormat); // 设置打印工作
                if (myPrtJob.printDialog()) // 显示打印对话框
                { 
                    try 
                    { 
                        myPrtJob.print(); // 进行每一页的具体打印操作
                    } 
                    catch(PrinterException pe) 
                    { 
                        pe.printStackTrace(); 
                    } 
                } 
            } 
            else 
            { 
                 // 如果打印内容为空时,提示用户打印将取消
                JOptionPane.showConfirmDialog 
                 (null, "Sorry, Printer Job is Empty, Print Cancelled!", "Empty", 
                 JOptionPane.DEFAULT_OPTION, JOptionPane.WARNING_MESSAGE); 
            } 
        }

    3.2、以 jdk1.4 新版本提供的 API 实现打印动作按钮监听,并完成具体的打印操作

       private void printText2Action() 
        { 
            printFlag = 0; // 打印标志清零
            printStr = area.getText().trim();// 获取需要打印的目标文本
            if (printStr != null && printStr.length() > 0) // 当打印内容不为空时
            { 
                PAGES = getPagesCount(printStr); // 获取打印总页数
                 // 指定打印输出格式
                DocFlavor flavor = DocFlavor.SERVICE_FORMATTED.PRINTABLE; 
                // 定位默认的打印服务
     PrintService printService = PrintServiceLookup.lookupDefaultPrintService(); 
                // 创建打印作业
     DocPrintJob job = printService.createPrintJob(); 
                // 设置打印属性
     PrintRequestAttributeSet pras = new HashPrintRequestAttributeSet(); 
                DocAttributeSet das = new HashDocAttributeSet(); 
                // 指定打印内容
     Doc doc = new SimpleDoc(this, flavor, das); 
                 // 不显示打印对话框,直接进行打印工作
                try 
                { 
                    job.print(doc, pras); // 进行每一页的具体打印操作
                } 
                catch(PrintException pe) 
                { 
                    pe.printStackTrace(); 
                } 
            } 
            else 
            { 
                // 如果打印内容为空时,提示用户打印将取消
     JOptionPane.showConfirmDialog(null, "Sorry, Printer Job is Empty, Print Cancelled!", 
     "Empty", JOptionPane.DEFAULT_OPTION, JOptionPane.WARNING_MESSAGE); 
            } 
        }

    3.2 打印预览

    3.2.1 应用场景

    大多数商业应用都需要提供打印预览机制,它可以让我们在屏幕上看到页面,这样就不会因为不喜欢的打印结果而浪费纸张。 假设我们在打印上一节所说的文本之前,需要先进行打印预览。那么该怎么实现呢?

    界面实现图示如下:(Next 预览下一页,Preview 预览前一页,Close 则关闭预览)

    3.2.2 解决方法

    基本思路:虽然 Java2 平台的打印 API 并不提供标准的打印预览对话框,但是自己来进行设计也并不复杂。正常情况下,print 方法将页面环境绘制到一个打印机图形环境上,从而实现打印。而事实上,print 方法并不能真正产生打印页面,它只是将待打印内容绘制到图形环境上。所以,我们可以忽略掉屏幕图形环境,经过适当的缩放比例,使整个打印页容纳在一个屏幕矩形里,从而实现精确的打印预览。

    在打印预览的设计实现中,主要需要解决两个问题。第一,如何将打印内容按合适的比例绘制到屏幕;第二,如何实现前后翻页。下面我给出这两个问题的具体实现方法,完整的实现请参看附件中的 PrintPreviewDialog.java 文件。

     /* 将待打印内容按比例绘制到屏幕 */ 
     public void paintComponent(Graphics g) 
        { 
     super.paintComponent(g); 
            Graphics2D g2 = (Graphics2D)g; 
            PageFormat pf = PrinterJob.getPrinterJob().defaultPage(); // 获取页面格式
            double xoff; // 在屏幕上页面初始位置的水平偏移
            double yoff; // 在屏幕上页面初始位置的垂直偏移
            double scale; // 在屏幕上适合页面的比例
            double px = pf.getWidth(); // 页面宽度
            double py = pf.getHeight(); // 页面高度
            double sx = getWidth() - 1; 
            double sy = getHeight() - 1; 
            if (px / py < sx / sy) 
            { 
                 scale = sy / py; // 计算比例
                xoff = 0.5 * (sx - scale * px); // 水平偏移量
                yoff = 0; 
            } 
            else 
            { 
                 scale = sx / px; // 计算比例
                xoff = 0; 
                yoff = 0.5 * (sy - scale * py); // 垂直偏移量
            } 
            g2.translate((float)xoff, (float)yoff); // 转换坐标
            g2.scale((float)scale, (float)scale); 
            Rectangle2D page = new Rectangle2D.Double(0, 0, px, py); // 绘制页面矩形
            g2.setPaint(Color.white); // 设置页面背景为白色
            g2.fill(page); 
            g2.setPaint(Color.black);// 设置页面文字为黑色
            g2.draw(page); 
            try 
            { 
                 preview.print(g2, pf, currentPage); // 显示指定的预览页面
            } 
            catch(PrinterException pe) 
            { 
                 g2.draw(new Line2D.Double(0, 0, px, py)); 
                g2.draw(new Line2D.Double(0, px, 0, py)); 
            } 
     } 
     /* 预览指定的页面 */ 
     public void viewPage(int pos) 
        { 
             int newPage = currentPage + pos; 
             // 指定页面在实际的范围内
            if (0 <= newPage && newPage < preview.getPagesCount(printStr)) 
            { 
                 currentPage = newPage; // 将指定页面赋值为当前页
                repaint(); 
            } 
        }

    这样,在按下"Next"按钮时,只需要调用 canvas.viewPage(1);而在按下"Preview"按钮时,只需要调用 canvas.viewPage(-1) 即可实现预览的前后翻页。

    3.3 打印图形

    3.3.1 应用场景

    在实际应用中,我们还需要打印图形。譬如,我们有时需要将一个 Java Applet 的完整界面或一个应用程序窗体及其所包含的全部组件都打印出来,又应该如何实现呢?

    3.3.2 解决方法

    基本思路如下:在 Java 的 Component 类及其派生类中都提供了 print 和 printAll 方法,只要设置好属性就可以直接调用这两个方法,从而实现对组件及图形的打印。

     /* 打印指定的窗体及其包含的组件 */ 
     private void printFrameAction() 
     { 
     Toolkit kit = Toolkit.getDefaultToolkit(); // 获取工具箱
        Properties props = new Properties(); 
        props.put("awt.print.printer", "durango");// 设置打印属性
        props.put("awt.print.numCopies", "2"); 
        if(kit != null) 
        { 
             // 获取工具箱自带的打印对象
     PrintJob printJob = kit.getPrintJob(this, "Print Frame", props); 
            if(printJob != null) 
            { 
                 Graphics pg = printJob.getGraphics();// 获取打印对象的图形环境
                if(pg != null) 
                { 
                     try 
                     { 
                         this.printAll(pg);// 打印该窗体及其所有的组件
                    } 
                    finally 
                    { 
                         pg.dispose();// 注销图形环境
                    } 
                } 
                printJob.end();// 结束打印作业
             } 
        } 
     }

    3.4 打印文件

    3.4.1 应用场景

    在很多实际应用情况下,我们可能都需要打印用户指定的某一个文件。该文件可能是图形文件,如 GIF、JPEG 等等;也可能是文本文件,如 TXT、Java 文件等等;还可能是复杂的 PDF、DOC 文件等等。那么对于这样的打印需求,我们又应该如何实现呢?

    3.4.2 解决方法

    基本思路:在 JDK 1.4 以前的版本,要实现这样的打印功能将非常麻烦和复杂,甚至是难以想象的。但幸运的是,jdk1.4 的打印服务 API 提供了一整套的打印文件流的类和方法。利用它们,我们可以非常方便快捷地实现各式各样不同类型文件的打印功能。下面给出一个通用的处理方法。

    /* 打印指定的文件 */ 
    private void printFileAction() 
    { 
        // 构造一个文件选择器,默认为当前目录
        JFileChooser fileChooser = new JFileChooser(SystemProperties.USER_DIR); 
        int state = fileChooser.showOpenDialog(this);// 弹出文件选择对话框
        if (state == fileChooser.APPROVE_OPTION)// 如果用户选定了文件
        { 
             File file = fileChooser.getSelectedFile();// 获取选择的文件
             // 构建打印请求属性集
            PrintRequestAttributeSet pras = new HashPrintRequestAttributeSet(); 
             // 设置打印格式,因为未确定文件类型,这里选择 AUTOSENSE 
            DocFlavor flavor = DocFlavor.INPUT_STREAM.AUTOSENSE; 
             // 查找所有的可用打印服务
            PrintService printService[] = 
                PrintServiceLookup.lookupPrintServices(flavor, pras);
             // 定位默认的打印服务
            PrintService defaultService = PrintServiceLookup.lookupDefaultPrintService();
            // 显示打印对话框
            PrintService service = ServiceUI.printDialog(null, 200, 200, printService 
                , defaultService, flavor, pras); 
            if (service != null) 
            { 
                 try 
                { 
                     DocPrintJob job = service.createPrintJob();// 创建打印作业
                    FileInputStream fis = new FileInputStream(file);// 构造待打印的文件流
                    DocAttributeSet das = new HashDocAttributeSet(); 
                    Doc doc = new SimpleDoc(fis, flavor, das);// 建立打印文件格式
                    job.print(doc, pras);// 进行文件的打印
                } 
                catch(Exception e) 
                { 
                     e.printStackTrace(); 
                } 
            } 
        } 
    }

    在上面的示例中,因尚未确定文件的类型,所以将指定文件的打印格式定义为 DocFlavor.INPUT_STREAM.AUTOSENSE。事实上,如果在进行打印之前,就已确定地知道文件的格式,如为 GIF,就应定义为 DocFlavor.INPUT_STREAM.GIF ;如为 PDF,就应该定义为 DocFlavor.INPUT_STREAM.PDF;如为纯 ASCII 文件,就可以定义为 DocFlavor.INPUT_STREAM.TEXT_HTML_US_ASCII。等等。jdk1.4 的 javax.print.DocFlavor 提供了极为丰富的文件流类型,你可以根据具体的应用需求进行合适的选择。具体的 API 参考文档可见本文的参考资料 3。

    完整例程源码

    PrintTest.java 

    package com.cn.gaopeng;
    
    import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;
    import java.util.Properties;
    import java.awt.font.FontRenderContext;
    import java.awt.print.*;
    import javax.print.*;
    import javax.print.attribute.*;
    import java.io.*;
    
    public class PrintTest extends JFrame
    implements ActionListener, Printable
    {
        private JButton printTextButton = new JButton("Print Text");
        private JButton previewButton = new JButton("Print Preview");
        private JButton printText2Button = new JButton("Print Text2");
        private JButton printFileButton = new JButton("Print File");
        private JButton printFrameButton = new JButton("Print Frame");
        private JButton exitButton = new JButton("Exit");
        private JLabel tipLabel = new JLabel("");
        private JTextArea area = new JTextArea();
        private JScrollPane scroll = new JScrollPane(area);
        private JPanel buttonPanel = new JPanel();
    
        private int PAGES = 0;
        private String printStr;
    
        public PrintTest()
        {
            this.setTitle("Print Test");
            this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            this.setBounds((int)((SystemProperties.SCREEN_WIDTH - 800) / 2), (int)((SystemProperties.SCREEN_HEIGHT - 600) / 2), 800, 600);
            initLayout();
        }
    
        private void initLayout()
        {
            this.getContentPane().setLayout(new BorderLayout());
            this.getContentPane().add(scroll, BorderLayout.CENTER);
            printTextButton.setMnemonic('P');
            printTextButton.addActionListener(this);
            buttonPanel.add(printTextButton);
            previewButton.setMnemonic('v');
            previewButton.addActionListener(this);
            buttonPanel.add(previewButton);
            printText2Button.setMnemonic('e');
            printText2Button.addActionListener(this);
            buttonPanel.add(printText2Button);
            printFileButton.setMnemonic('i');
            printFileButton.addActionListener(this);
            buttonPanel.add(printFileButton);
            printFrameButton.setMnemonic('F');
            printFrameButton.addActionListener(this);
            buttonPanel.add(printFrameButton);
            exitButton.setMnemonic('x');
            exitButton.addActionListener(this);
            buttonPanel.add(exitButton);
            this.getContentPane().add(buttonPanel, BorderLayout.SOUTH);
        }
    
        public void actionPerformed(ActionEvent evt)
        {
            Object src = evt.getSource();
            if (src == printTextButton)
                printTextAction();
            else if (src == previewButton)
                previewAction();
            else if (src == printText2Button)
                printText2Action();
            else if (src == printFileButton)
                printFileAction();
            else if (src == printFrameButton)
                printFrameAction();
            else if (src == exitButton)
                exitApp();
        }
    
        public int print(Graphics g, PageFormat pf, int page) throws PrinterException
        {
            Graphics2D g2 = (Graphics2D)g;
            g2.setPaint(Color.black);
            if (page >= PAGES)
                return Printable.NO_SUCH_PAGE;
            g2.translate(pf.getImageableX(), pf.getImageableY());
            drawCurrentPageText(g2, pf, page);
            return Printable.PAGE_EXISTS;
        }
    
        private void drawCurrentPageText(Graphics2D g2, PageFormat pf, int page)
        {
            Font f = area.getFont();
            String s = getDrawText(printStr)[page];
            String drawText;
            float ascent = 16;
            int k, i = f.getSize(), lines = 0;
            while(s.length() > 0 && lines < 54)
            {
                k = s.indexOf('
    ');
                if (k != -1)
                {
                    lines += 1;
                    drawText = s.substring(0, k);
                    g2.drawString(drawText, 0, ascent);
                    if (s.substring(k + 1).length() > 0)
                    {
                        s = s.substring(k + 1);
                        ascent += i;
                    }
                }
                else
                {
                    lines += 1;
                    drawText = s;
                    g2.drawString(drawText, 0, ascent);
                    s = "";
                }
            }
        }
    
        public String[] getDrawText(String s)
        {
            String[] drawText = new String[PAGES];
            for (int i = 0; i < PAGES; i++)
                drawText[i] = "";
    
            int k, suffix = 0, lines = 0;
            while(s.length() > 0)
            {
                if(lines < 54)
                {
                    k = s.indexOf('
    ');
                    if (k != -1)
                    {
                        lines += 1;
                        drawText[suffix] = drawText[suffix] + s.substring(0, k + 1);
                        if (s.substring(k + 1).length() > 0)
                            s = s.substring(k + 1);
                    }
                    else
                    {
                        lines += 1;
                        drawText[suffix] = drawText[suffix] + s;
                        s = "";
                    }
                }
                else
                {
                    lines = 0;
                    suffix++;
                }
            }
            return drawText;
        }
    
        public int getPagesCount(String curStr)
        {
            int page = 0;
            int position, count = 0;
            String str = curStr;
            while(str.length() > 0)
            {
                position = str.indexOf('
    ');
                count += 1;
                if (position != -1)
                    str = str.substring(position + 1);
                else
                    str = "";
            }
    
            if (count > 0)
                page = count / 54 + 1;
    
            return page;
        }
    
        private void printTextAction()
        {
            printStr = area.getText().trim();
            if (printStr != null && printStr.length() > 0)
            {
                PAGES = getPagesCount(printStr);
                PrinterJob myPrtJob = PrinterJob.getPrinterJob();
                PageFormat pageFormat = myPrtJob.defaultPage();
                myPrtJob.setPrintable(this, pageFormat);
                if (myPrtJob.printDialog())
                {
                    try
                    {
                        myPrtJob.print();
                    }
                    catch(PrinterException pe)
                    {
                        pe.printStackTrace();
                    }
                }
            }
            else
            {
                JOptionPane.showConfirmDialog(null, "Sorry, Printer Job is Empty, Print Cancelled!", "Empty"
                                            , JOptionPane.DEFAULT_OPTION, JOptionPane.WARNING_MESSAGE);
            }
        }
    
        private void previewAction()
        {
            printStr = area.getText().trim();
            PAGES = getPagesCount(printStr);
            (new PrintPreviewDialog(this, "Print Preview", true, this, printStr)).setVisible(true);
        }
    
        private void printText2Action()
        {
            printStr = area.getText().trim();
            if (printStr != null && printStr.length() > 0)
            {
                PAGES = getPagesCount(printStr);
                DocFlavor flavor = DocFlavor.SERVICE_FORMATTED.PRINTABLE;
                PrintService printService = PrintServiceLookup.lookupDefaultPrintService();
                DocPrintJob job = printService.createPrintJob();
                PrintRequestAttributeSet pras = new HashPrintRequestAttributeSet();
                DocAttributeSet das = new HashDocAttributeSet();
                Doc doc = new SimpleDoc(this, flavor, das);
    
                try
                {
                    job.print(doc, pras);
                }
                catch(PrintException pe)
                {
                    pe.printStackTrace();
                }
            }
            else
            {
                JOptionPane.showConfirmDialog(null, "Sorry, Printer Job is Empty, Print Cancelled!", "Empty"
                                            , JOptionPane.DEFAULT_OPTION, JOptionPane.WARNING_MESSAGE);
            }
        }
    
        private void printFileAction()
        {
            JFileChooser fileChooser = new JFileChooser(SystemProperties.USER_DIR);
            int state = fileChooser.showOpenDialog(this);
            if (state == fileChooser.APPROVE_OPTION)
            {
                File file = fileChooser.getSelectedFile();
                PrintRequestAttributeSet pras = new HashPrintRequestAttributeSet();
                DocFlavor flavor = DocFlavor.INPUT_STREAM.AUTOSENSE;
                PrintService printService[] = PrintServiceLookup.lookupPrintServices(flavor, pras);
                PrintService defaultService = PrintServiceLookup.lookupDefaultPrintService();
                PrintService service = ServiceUI.printDialog(null, 200, 200, printService
                                                            , defaultService, flavor, pras);
                if (service != null)
                {
                    try
                    {
                        DocPrintJob job = service.createPrintJob();
                        FileInputStream fis = new FileInputStream(file);
                        DocAttributeSet das = new HashDocAttributeSet();
                        Doc doc = new SimpleDoc(fis, flavor, das);
                        job.print(doc, pras);
                    }
                    catch(Exception e)
                    {
                        e.printStackTrace();
                    }
                }
            }
        }
    
        private void printFrameAction()
        {
            Toolkit kit = Toolkit.getDefaultToolkit();
            Properties props = new Properties();
            props.put("awt.print.printer", "durango");
            props.put("awt.print.numCopies", "2");
            if(kit != null)
            {
                PrintJob printJob = kit.getPrintJob(this, "Print Frame", props);
                if(printJob != null)
                {
                    Graphics pg = printJob.getGraphics();
                    if(pg != null)
                    {
                        try
                        {
                            this.printAll(pg);
                        }
                        finally
                        {
                            pg.dispose();
                        }
                    }
                    printJob.end();
                }
            }
        }
    
        private void exitApp()
        {
            this.setVisible(false);
            this.dispose();
            System.exit(0);
        }
    
        public static void main(String[] args)
        {
            (new PrintTest()).setVisible(true);
        }
    }

    PrintPreviewDialog.java 

    package com.cn.gaopeng;
    
    import java.awt.event.*;
    import java.awt.*;
    import java.awt.print.*;
    import javax.swing.*;
    import java.awt.geom.*;
    
    public class PrintPreviewDialog extends JDialog
    implements ActionListener
    {
        private JButton nextButton = new JButton("Next");
        private JButton previousButton = new JButton("Previous");
        private JButton closeButton = new JButton("Close");
        private JPanel buttonPanel = new JPanel();
        private PreviewCanvas canvas;
    
        public PrintPreviewDialog(Frame parent, String title, boolean modal, PrintTest pt, String str)
        {
            super(parent, title, modal);
            canvas = new PreviewCanvas(pt, str);
            setLayout();
        }
    
        private void setLayout()
        {
            this.getContentPane().setLayout(new BorderLayout());
            this.getContentPane().add(canvas, BorderLayout.CENTER);
    
            nextButton.setMnemonic('N');
            nextButton.addActionListener(this);
            buttonPanel.add(nextButton);
            previousButton.setMnemonic('N');
            previousButton.addActionListener(this);
            buttonPanel.add(previousButton);
            closeButton.setMnemonic('N');
            closeButton.addActionListener(this);
            buttonPanel.add(closeButton);
            this.getContentPane().add(buttonPanel, BorderLayout.SOUTH);
            this.setBounds((int)((SystemProperties.SCREEN_WIDTH - 400) / 2), (int)((SystemProperties.SCREEN_HEIGHT - 400) / 2), 400, 400);
        }
    
        public void actionPerformed(ActionEvent evt)
        {
            Object src = evt.getSource();
            if (src == nextButton)
                nextAction();
            else if (src == previousButton)
                previousAction();
            else if (src == closeButton)
                closeAction();
        }
    
        private void closeAction()
        {
            this.setVisible(false);
            this.dispose();
        }
    
        private void nextAction()
        {
            canvas.viewPage(1);
        }
    
        private void previousAction()
        {
            canvas.viewPage(-1);
        }
    
        class PreviewCanvas extends JPanel
        {
            private String printStr;
            private int currentPage = 0;
            private PrintTest preview;
    
            public PreviewCanvas(PrintTest pt, String str)
            {
                printStr = str;
                preview = pt;
            }
    
            public void paintComponent(Graphics g)
            {
                super.paintComponent(g);
                Graphics2D g2 = (Graphics2D)g;
                PageFormat pf = PrinterJob.getPrinterJob().defaultPage();
    
                double xoff;
                double yoff;
                double scale;
                double px = pf.getWidth();
                double py = pf.getHeight();
                double sx = getWidth() - 1;
                double sy = getHeight() - 1;
                if (px / py < sx / sy)
                {
                    scale = sy / py;
                    xoff = 0.5 * (sx - scale * px);
                    yoff = 0;
                }
                else
                {
                    scale = sx / px;
                    xoff = 0;
                    yoff = 0.5 * (sy - scale * py);
                }
                g2.translate((float)xoff, (float)yoff);
                g2.scale((float)scale, (float)scale);
    
                Rectangle2D page = new Rectangle2D.Double(0, 0, px, py);
                g2.setPaint(Color.white);
                g2.fill(page);
                g2.setPaint(Color.black);
                g2.draw(page);
    
                try
                {
                    preview.print(g2, pf, currentPage);
                }
                catch(PrinterException pe)
                {
                    g2.draw(new Line2D.Double(0, 0, px, py));
                    g2.draw(new Line2D.Double(0, px, 0, py));
                }
            }
    
            public void viewPage(int pos)
            {
                int newPage = currentPage + pos;
                if (0 <= newPage && newPage < preview.getPagesCount(printStr))
                {
                    currentPage = newPage;
                    repaint();
                }
            }
        }
    }

    SystemProperties.java

    package com.cn.gaopeng;
    
    import java.awt.Dimension;
    import java.awt.Font;
    import java.awt.GraphicsEnvironment;
    import java.awt.Toolkit;
    
    public final class SystemProperties {
        public static final double SCREEN_WIDTH = Toolkit.getDefaultToolkit().getScreenSize().getWidth();
        public static final double SCREEN_HEIGHT = Toolkit.getDefaultToolkit().getScreenSize().getHeight();
        public static final String USER_DIR = System.getProperty("user.dir");
        public static final String USER_HOME = System.getProperty("user.home");
        public static final String USER_NAME = System.getProperty("user.name");
        public static final String FILE_SEPARATOR = System.getProperty("file.separator");
        public static final String LINE_SEPARATOR = System.getProperty("line.separator");
        public static final String PATH_SEPARATOR = System.getProperty("path.separator");
        public static final String JAVA_HOME = System.getProperty("java.home");
        public static final String JAVA_VENDOR = System.getProperty("java.vendor");
        public static final String JAVA_VENDOR_URL = System.getProperty("java.vendor.url");
        public static final String JAVA_VERSION = System.getProperty("java.version");
        public static final String JAVA_CLASS_PATH = System.getProperty("java.class.path");
        public static final String JAVA_CLASS_VERSION = System.getProperty("java.class.version");
        public static final String OS_NAME = System.getProperty("os.name");
        public static final String OS_ARCH = System.getProperty("os.arch");
        public static final String OS_VERSION = System.getProperty("os.version");
        public static final String[] FONT_NAME_LIST = GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames();
        public static final Font[] FONT_LIST = GraphicsEnvironment.getLocalGraphicsEnvironment().getAllFonts();
    }
    1. PrintTest.java 包含了本文所描述的所有打印功能的实现源代码。相应的打印文本功能通过 Print Text 和 PrintText2(jdk1.4 中新的实现)按钮调用;打印文件通过 Print File 按钮调用;打印图形通过 Print Frame 按钮调用;而 Print Preview 则进行打印预览。
    2. PrintPreviewDialog.java 包含打印预览源代码,你可以通过 PrintTest 窗体中的 Print Preview 按钮来调用。

    参考资料

    1. 《 Java2 核心技术 卷Ⅱ:高级特性》 机械工业出版社
    2. Java 打印服务参考文档: http://java.sun.com/j2se/1.4/docs/guide/jps/
    3. jdk1.4 API 参考文档: http://java.sun.com/j2se/1.4/docs/api/
  • 相关阅读:
    js确定取消—js确定取消判断
    css3响应式布局教程—css3响应式
    python算法介绍:希尔排序
    python教程:用简单的Python编写Web应用程序
    用Scratch制作一个Hello World程序
    scratch教程:学做控制类积木
    北邮《数据库原理与应用》应用阶段作业一带答案
    [20180614]删除bootstrap$记录无法启动2.txt
    [20180612]删除bootstrap$记录无法启动.txt
    [20180619]oradebug peek.txt
  • 原文地址:https://www.cnblogs.com/gaopeng527/p/4359975.html
Copyright © 2020-2023  润新知