You are hereAria User Guide / Section III: In Depth / Printing and Export

Printing and Export

By luano - Posted on 14 January 2009

Printouts can be produced in a number of different ways, directly and indirectly through applications like Excel and OpenOffice. Aria provides some easy to use classes that can be used to print pages or framesets from an application. Custom printed pages can also be to create a sort of report generation.

Direct printing

Aria's pages can be printed directly using the built-in infrastructure. However it should be noted that this may not be appropriate in all situations. A page created for on-screen, landscape rendering may not be best suited to the high resolution, portrait format of most printers. Aria applications can also include special printout pages where the layout and aspect can be given a more suitable configuration. Using the data binding schemes promoted by Aria this should involve little additional work while at the same time adding versatility to the printout infrastructure.

The printing infrastructure

Printing in Aria uses the normal Java printing API and mechanisms, but in order to hide some of the low level details Aria provides some additional infrastructure. The printing infrastructure revolves around three classes in the org.formaria.print package. These classes are:

  1. The Printing Classes

Printout

This class encapsulates the print job. Control of headers and footers is also provided.

PrintablePage

A decoration of the Page class to support printing. Scales the page as needed.

PrintableFrameSet

A decoration of a frameset to allow printing of the frameset's pages. Again scaling is performed as needed.

These classes act as decorations of the Page class so that the pages can be configured for on-screen use or for printing or they can be used for both purposes. This decoration also means that the pages can be designed as any other page with little need for special considerations.

The use of these classes are as follows:

Printing a Frameset

  1.      /**
  2.       * On a mouse click print this page
  3.       */
  4.      public void printPage()
  5.      {
  6.        // Hide the navigation buttons for the home page
  7.        if ( wasMouseClicked() ) {
  8.          Printout po = new Printout();
  9.          po.showPageFormat();
  10.          po.setJobName( "Survey Printout" );
  11.          po.setHeader( "Left Header", Printout.LEFT );
  12.          po.setHeader( "Right Header", Printout.RIGHT );
  13.          po.setFooter( "Footer", Printout.LEFT );
  14.          po.setPageNumbers( false, Printout.RIGHT, "Page " );
  15.  
  16.          int numFrames = pageManager.getNumTargets();
  17.          PrintableFrameSet pf = new PrintableFrameSet( po );
  18.          for ( int i = 0; i < numFrames; i++ )
  19.            pf.addFrame( pageManager.getTarget( i ) );
  20.          po.addFrame( pf );
  21.  
  22.          po.print();
  23.        }
  24.      }

The headers and footers are set so that their height is deducted from the printable area of the `page'. Headers and footers can be position to the LEFT , RIGHT or CENTER of the page.

Creating print forms

By default the printer is setup to print in Landscape format so as to match the aspect ratio of a typical screen. The printing framework automatically scales pages to the printer resolution so it is possible to create pages with different sizes or sizes more suited to the printer aspect ratio and resolution. Therefore custom pages could be setup for printing.

When using custom pages and adding them to the PrintOut you will need to take care of the initialization the page display framework would normally provide. This initialization includes updating layouts ( doLayout ), setting sizes, and updating bound components ( updateBoundComponentValues ) and perhaps even calling the page lifecycle methods ( pageCreated , pageActivated ).

Printing tables

As of version 2.0 Aria does not make use of the new JSE 5.0 printing support. Therefore if you wish to print tables you will need to handle sizing and pagination issues directly.

Other printout issues

While most of the time little by way of special consideration needs too be given to printing there are a few issues worth considering when preparing content.

Graphics

  1. Printing Content Issues

The resolution of printers is typically in thousands of dots per inch (dpi) whereas on-screen resolution is of the order of 72 dpi. An unscaled raster graphic that works well on screen will appear tiny on a printout and while Aria scales images it cannot (in most cases) increase the image resolution and so the printed quality of the image may suffer.

The solution to this problem is to use `lossy' raster graphics like JPEG that can interpolate the image or to use vector graphics like SVG that are ideal for scaling.

Tables

Tables frequently scroll or have varying amounts of content and this is not ideal for printing. At best a printout can accommodate vertical scrolling, but horizontal scrolling can rarely be accommodated well. When using tables pay special attention to testing with a variety of data.

Aspect

As has been noted above the resolution and aspect of the printed page normally differs from on-screen resolution. Consider using special print-only pages to accommodate your printouts. The print-only page can derive from the same class as the on-screen equivalent so any support functions and data binding can be reused.

Outputting to file

Another mechanism for printing is to use intermediate formats like HTML and Office file formats. An advantage of these formats is that the output can be of use for integration with other applications or within other documents and therefore you are not limited to the print format of your application.

Aria provides some utility classes to facilitate output to some of the more common formats. The utilities work best when some common elements of the output are grouped, thereby allowing reuse of code. The following example shows how a parts list can be generated in a number of formats. The example includes output that can be configured in several ways, exported to file or clipboard, and opened or printed:

First lets look at setting up the infrastructure. The output generation is facilitated by some exporters than do some of the most common formatting. Depending on the options chosen the appropriate exported is setup.

Setup the export infrastructure

  1.  private void createExporter( String fileName ) throws Exception
  2.  {
  3.    if ( textRb.getState())
  4.      exporter = new XExportHelper();
  5.    else if ( wordRb.getState())
  6.      exporter = new XExportHelper( ".doc" );
  7.    else if ( xmlRb.getState() )
  8.      exporter = new XmlExportHelper();
  9.    else if ( htmlRb.getState() )
  10.      exporter = new HtmlExportHelper();
  11.    else if ( excelRb.getState() )
  12.      exporter = new ExcelExportHelper( fileName );
  13.  }

The createExporter method creates the processor for each type of export format that is supported. Each export format then has specific properties that must be set::

Setup the export format details

  1.  private void exportText( Writer w )
  2.  {
  3.    try {
  4.      exporter.setOutputWriter( w );
  5.      exporter.setComponentFactory( pageHelper.componentFactory );
  6.  
  7.      String delim = delimiterEdit.getText();
  8.      exporter.setLeftDelimiter( delim );
  9.      exporter.setRightDelimiter( delim );
  10.      delim = separatorEdit.getText();
  11.  
  12.      exporter.setFieldSeparator( delim );
  13.      exporter.setFieldNameSeparator( delim );
  14.      exporter.setUseWindowsLineEnd( windowsCheck.getState());
  15.      doExport();
  16.  
  17.      exporter.close();
  18.    }
  19.    catch ( IOException ex ) {
  20.    }
  21.  }
  22.  
  23.  private void exportXml( Writer w )
  24.  {
  25.    try {
  26.      exporter.setOutputWriter( w );
  27.      exporter.setComponentFactory( pageHelper.componentFactory );
  28.  
  29.      exporter.setUseWindowsLineEnd( windowsCheck.getState());
  30.      doExport();
  31.  
  32.      exporter.close();
  33.    }
  34.    catch ( IOException ex ) {
  35.    }
  36.  }
  37.  
  38.  private void exportHtml( Writer w )
  39.  {
  40.    try {
  41.      exporter.setOutputWriter( w );
  42.      exporter.setComponentFactory( pageHelper.componentFactory );
  43.  
  44.      exporter.setUseWindowsLineEnd( windowsCheck.getState());
  45.      doExport();
  46.  
  47.      exporter.close();
  48.    }
  49.    catch ( IOException ex ) {
  50.    }
  51.  }
  52.  
  53.  private void exportExcel( String fileName )
  54.  {
  55.    try {
  56.      exporter = new ExcelExportHelper( fileName );
  57.      exporter.setComponentFactory( pageHelper.componentFactory );
  58.  
  59.      exporter.setUseWindowsLineEnd( windowsCheck.getState() );
  60.      doExport();
  61.  
  62.      exporter.close();
  63.    }
  64.    catch ( IOException ex ) {
  65.      ex.printStackTrace();
  66.    }
  67.  }

Most of this setup code is straightforward and involves setting up the export processor. The most involved is setting up the text export as a delimited file can vary by the type of delimiter and how the text values are separated. Some formats even have different left and right delimiters.

The actual export is initiated in the BeginExport method:

Start the export process

  1.    public void beginExport()
  2.    {
  3.      String targetFile = locationEdit.getText();
  4.      int type = TEXT;
  5.      try {
  6.        if ( wasMouseClicked() ) {
  7.          if ( !clipboardCheck.getState() && ( targetFile.length() == 0 ) ) {
  8.            showMessage( "Unable to Export", "You must enter a file name or click browse to choose a file!" );
  9.            return;
  10.          }
  11.  
  12.          root = DataModel.getInstance();
  13.  
  14.          Writer w = null;
  15.          createExporter( targetFile );
  16.  
  17.          // Choose the output, either the clipboard or an output stream (file)
  18.          if ( !clipboardCheck.getState() && !excelRb.getState() )
  19.            w = exporter.setupWriter( this, targetFile );
  20.          else
  21.            w = new StringWriter();
  22.  
  23.  
  24.          if ( w != null ) {
  25.            // Start the export process
  26.            if ( textRb.getState() )
  27.              exportText( w );
  28.            else if ( xmlRb.getState() ) {
  29.              exportXml( w );
  30.              type = XML;
  31.            }
  32.            else if ( htmlRb.getState() ) {
  33.              exportHtml( w );
  34.              type = HTML;
  35.            }
  36.            else if ( excelRb.getState() ) {
  37.              exportExcel( locationEdit.getText() );
  38.              type = EXCEL;
  39.            }
  40.            else if ( wordRb.getState() ) {
  41.              exportText( w );
  42.              type = WORD;
  43.            }
  44.  
  45.            if ( clipboardCheck.getState() ) {
  46.              exporter.setClipboardContents( ( ( StringWriter ) w ).getBuffer().toString() );
  47.            }
  48.          }
  49.  
  50.          if ( exportRb.getState() || exportAndOpenRb.getState()) {
  51.            showMessage( "Export complete", "Your file can be found at " + targetFile );
  52.            if ( exportAndOpenRb.getState())
  53.              doOpen( targetFile, false, type );
  54.          }
  55.          else if ( exportAndPrintRb.getState() ) {
  56.            showMessage( "Export complete", "Your file has been printed and can be found at " + targetFile );
  57.            doOpen( locationEdit.getText(), true, type );
  58.          }
  59.        }
  60.      }
  61.      catch ( Exception ex ) {
  62.        ex.printStackTrace();
  63.        showMessage( "Export failed", "Unable to export to " + targetFile );
  64.      }
  65.    }
  66.  

The export process involves setting up the output stream (or the clipboard) and calling the appropriate output method to take account of the output variations. The export process then finishes by writing the output and displaying some messages where appropriate.

If opening a file for saving the document then the following support methods helps access the file.

Open the output file

  1.    /**
  2.     * Open or print a file
  3.     * @param fileName the file name
  4.     * @param doPrint true to print
  5.     */
  6.    private void doOpen( String fileName, boolean doPrint, int fileType )
  7.    {
  8.      // This method is all over the palce and needs to be refactored!
  9.      String command = "start";
  10.      try {
  11.        File tempFile = null;
  12.        String tempFileName = null;
  13.  
  14.  
  15.        if ( doPrint ) {
  16.          switch ( fileType ) {
  17.            case TEXT:
  18.              command = "NOTEPAD /P" + "\"" + fileName + "\"";
  19.              break;
  20.  
  21.            case XML:
  22.            case HTML:
  23.            case EXCEL:
  24.            case WORD:
  25.            {
  26.              if (( tempPrintFileName == null ) || ( fileType != lastFileType )) {
  27.                tempFile = File.createTempFile( "doPrint", ".bat" );
  28.                tempPrintFileName = tempFile.getCanonicalPath();
  29.                lastFileType = fileType;
  30.                tempOpenFileName = null;
  31.              }
  32.              tempFileName = tempPrintFileName;
  33.  
  34.              if ( tempFile != null ) {
  35.                OutputStreamWriter writer = new OutputStreamWriter( project.getBufferedOutputStream( tempFileName, false ) );
  36.                writer.write( getOfficePath( fileType, doPrint ) + " %1 /mFilePrintDefault" );
  37.                writer.flush();
  38.                writer.close();
  39.              }
  40.              command = "start \"" + tempFileName + "\" \"" + fileName + "\""; ;
  41.            }
  42.            break;
  43.          }
  44.        }
  45.  
  46.        else {
  47.          if (( tempOpenFileName == null ) || ( lastFileType != fileType )) {
  48.            tempFile = File.createTempFile( "doOpen", ".bat" );
  49.            tempOpenFileName = tempFile.getCanonicalPath();
  50.            lastFileType = fileType;
  51.            tempPrintFileName = null;
  52.          }
  53.          tempFileName = tempOpenFileName;
  54.  
  55.          if ( tempFile != null ) {
  56.            OutputStreamWriter writer = new OutputStreamWriter( project.getBufferedOutputStream( tempFileName, false ) );
  57.            writer.write( "start %1 %2 %3 %4 %5 %6 %7 %8 %9" );
  58.            writer.flush();
  59.            writer.close();
  60.          }
  61.        }
  62.  
  63.        String line;
  64.        String cmdLine;
  65.        if ( doPrint )
  66.          cmdLine = command;
  67.        else
  68.          cmdLine = "start \"" + tempFileName + "\" \"" + fileName + "\"";
  69.  
  70.        File targetFile = new File( fileName );
  71.        File startDir = new File( targetFile.getParent() );
  72.        if ( BuildProperties.DEBUG )
  73.          DebugLogger.log( "Running: " + cmdLine );
  74.  
  75.        String osName = System.getProperty( "os.name" );
  76.        String[] cmd = new String[ 3 ];
  77.        if ( osName.equals( "Windows 95" ) || osName.equals( "Windows 98" ) ) {
  78.          cmd[ 0 ] = "command.com";
  79.          cmd[ 1 ] = "/C";
  80.          cmd[ 2 ] = cmdLine;
  81.        }
  82.        else {
  83.          cmd[ 0 ] = "cmd.exe";
  84.          cmd[ 1 ] = "/C";
  85.          cmd[ 2 ] = cmdLine;
  86.        }
  87.  
  88.        Process p = Runtime.getRuntime().exec( cmd );
  89.        BufferedReader input = new BufferedReader( new InputStreamReader( p.getInputStream() ) );
  90.  
  91.        while ( ( line = input.readLine() ) != null ) {
  92.          if ( BuildProperties.DEBUG )
  93.            System.out.println( line );
  94.        }
  95.        input.close();
  96.      }
  97.      catch ( IOException ex ) {
  98.        ex.printStackTrace();
  99.      }
  100.    }

An output file can be required for printing as the approach we take is to generate a temporary file and then invoke an application to print the document.

The opening of files in this way also requires that we build the command line appropriate for each application.

And when exporting to office it is necessary to find the office installation:

  1.    private String getOfficePath( int fileType, boolean doPrint )
  2.    {
  3.      try {
  4.        String applicationQuery = null;
  5.        switch ( fileType )
  6.        {
  7.          case EXCEL:
  8.            applicationQuery = REGQUERY_UTIL + "\"HKCR\\Applications\\EXCEL.EXE\\shell\\edit\\command";
  9.            break;
  10.          case HTML:
  11.            if ( doPrint )
  12.              applicationQuery = REGQUERY_UTIL + "\"HKCR\\Applications\\WINWORD.EXE\\shell\\edit\\command";
  13.            else
  14.              applicationQuery = REGQUERY_UTIL + "\"HKCR\\Applications\\iexplore.exe\\shell\\edit\\command";
  15.            break;
  16.          case TEXT:
  17.          case WORD:
  18.          default:
  19.            applicationQuery = REGQUERY_UTIL + "\"HKCR\\Applications\\WINWORD.EXE\\shell\\edit\\command";
  20.            break;
  21.        }
  22.        Process process = Runtime.getRuntime().exec( applicationQuery );
  23.        StreamReader reader = new StreamReader( process.getInputStream() );
  24.  
  25.        reader.start();
  26.        process.waitFor();
  27.        reader.join();
  28.        String result = reader.getResult();
  29.        int p = result.indexOf( REGSTR_TOKEN );
  30.  
  31.        if ( p == -1 )
  32.          return null;
  33.        result = result.substring( p + REGSTR_TOKEN.length() ).trim();
  34.        result = result.substring( 0, result.indexOf( "\"", 1 ) + 1 ).trim();
  35.        return result;
  36.      }
  37.      catch ( Exception e ) {
  38.        return null;
  39.      }
  40.    }

Ultimately, to generate the document we must ouput each part of the document

Run through each step of the document

  1.  private void doExport() throws IOException
  2.  {
  3.    exporter.startDocument();
  4.    exportPartsList();
  5.    exporter.endDocument();
  6.  }

And finally the elements within that document section must be output.

Run through each step of the document

  1.  private void exportPartsList() throws IOException
  2.  {
  3.    exporter.writeSectionTitle( "Components" );
  4.    exporter.setOutputFieldNames( false );
  5.    exporter.startTable();
  6.  
  7.    exporter.startHeader();
  8.    exporter.writeField( "type", "" );
  9.    exporter.writeField( "description", "" );
  10.    exporter.writeField( "codeNo", "" );
  11.    exporter.writeField( "quantity", "" );
  12.    exporter.endHeader();
  13.    int itemId = 0;
  14.    int numNodes = getNumNodes();
  15.    for ( int i = 0; i < numNodes; i++ ) {
  16.      DataModel targetNode = getNode( i );
  17.      if ( targetNode != null ) {
  18.        exporter.startGroup();
  19.        exporter.startRecord();
  20.        exporter.startElement( "component" );
  21.        exporter.writeField( "type", targetNode.getAttribValueAsString( BaseModel.VALUE_ATTRIBUTE ));
  22.        exporter.writeField( "description", 
  23.                           pageHelper.componentFactory.translate( 
  24.                             (String)targetNode.get( "@Description" ) ));
  25.        exporter.writeField( "codeNo", ( String ) selectedNode.get( "@Code_no" ));
  26.        exporter.writeField( "quantity", "1" );
  27.        exporter.endRecord();
  28.        int accessories = 0;
  29.        for ( int ij = 0; ij < accessoryList.length; ij++ ) {
  30.          Object accessoryCode = selectedNode.get( "@" + accessoryList[ ij ] );
  31.  
  32.          if ( accessoryCode != null ) {
  33.            exporter.startRecord();
  34.            if ( accessories == 0 )
  35.              exporter.endElement();
  36.            exporter.startElement( "accessory" );
  37.            exporter.writeField( "type", "" );
  38.            exporter.writeField( "description", 
  39.                        pageHelper.componentFactory.translate( 
  40.                        Functional.accessoryDescription[ ij ] ));
  41.            exporter.writeField( "codeNo", (String)accessoryCode );
  42.            exporter.writeField( "quantity", 
  43.                        new Integer( Functional.accessoryQuantity[ ij ] ).toString() );
  44.            accessories++;
  45.            exporter.closeElement();
  46.            exporter.endRecord();
  47.          }
  48.        }
  49.        if ( accessories == 0 )
  50.          exporter.closeElement();
  51.        else
  52.          exporter.matchElement();
  53.        exporter.endGroup();
  54.      }
  55.    }
  56.  }
  57.      }
  58.  
  59.      exporter.endTable();
  60.      exporter.setOutputFieldNames( true );
  61.      exporter.writeSectionEnd();
  62.      exporter.writeBlankLine();
  63.    }

This last output method is very much application specific, but the example above groups some items (the accessories) with a main item.

To create a print out with this mechanism requires a more work than printing directly but it offers more flexibility. Furthermore the content of an Excel sheet can be alot more powerful than a flat printout.

Printing via Excel

Aria includes a set of wrapper classes to ease the use of Excel sheets. While Excel worksheets have many potential uses they can be used for printing purposes with the sheet being created directly or with a pre-prepared sheet acting as a template. Aria also includes classes to allow you easily launch Excel to preview the `printout' prior to actual printing.

Using the code above we can get the following Excel sheet (displayed in OpenOffice 2.0):

Printing and interacting with OpenOffice

OpenOffice can be used in much the same way as Excel however OpenOffice provides some extra programming control and support that can be useful in some situations.

OpenOffice can be run in a server mode where the worksheet is generated or populated by a server. This opens up the possibility of doing some sorts of workflow.

Printing via HTML

HTML provides another option for printing. Aria includes support for printing things such as forms and tables to HTML. However because of the wide variety of formats that could be generated you should be prepared to manually code some of the HTML generation.

Again using the code above we can get the following HTML, shown in the Mozilla FireFox browser:

Navigation

SourceForge Project

SourceForge.net Logo

Recent blog posts

more