org.eclipse.osbp.fork.jpos/src/jpos/FiscalPrinter.java - osbp/org.eclipse.osbp.fork.jpos - Git at Google

 //------------------------------------------------------------------------------
 //
 // This software is provided "AS IS".  The JavaPOS working group (including
 // each of the Corporate members, contributors and individuals)  MAKES NO
 // REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE SOFTWARE,
 // EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
 // WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 // NON-INFRINGEMENT. The JavaPOS working group shall not be liable for
 // any damages suffered as a result of using, modifying or distributing this
 // software or its derivatives.Permission to use, copy, modify, and distribute
 // the software and its documentation for any purpose is hereby granted.
 //
 // FiscalPrinter.java - A JavaPOS 1.14.0 device control
 //
 //------------------------------------------------------------------------------

 package jpos;

 import jpos.events.*;
 import jpos.services.*;
 import java.util.Vector;
 import jpos.loader.*;

 public class FiscalPrinter
   extends BaseJposControl
   implements FiscalPrinterControl114, JposConst
 {
   //--------------------------------------------------------------------------
   // Variables
   //--------------------------------------------------------------------------

   protected FiscalPrinterService13 service13;
   protected FiscalPrinterService14 service14;
   protected FiscalPrinterService15 service15;
   protected FiscalPrinterService16 service16;
   protected FiscalPrinterService17 service17;
   protected FiscalPrinterService18 service18;
   protected FiscalPrinterService19 service19;
   protected FiscalPrinterService110 service110;
   protected FiscalPrinterService111 service111;
   protected FiscalPrinterService112 service112;
   protected FiscalPrinterService113 service113;
   protected FiscalPrinterService114 service114;
   protected Vector directIOListeners;
   protected Vector errorListeners;
   protected Vector outputCompleteListeners;
   protected Vector statusUpdateListeners;


   //--------------------------------------------------------------------------
   // Constructor
   //--------------------------------------------------------------------------

   public FiscalPrinter()
   {
     // Initialize base class instance data
     deviceControlDescription = "JavaPOS FiscalPrinter Device Control";
     deviceControlVersion = deviceVersion114;

     // Initialize instance data. Initializations are commented out for
     // efficiency if the Java default is correct.
     //service13 = null;
     //service14 = null;
     //service15 = null;
     //service16 = null;
     //service17 = null;
     //service18 = null;
     //service19 = null;
     //service110 = null;
     //service111 = null;
     //service112 = null;
     //service113 = null;
     //service114 = null;
     directIOListeners = new Vector();
     errorListeners = new Vector();
     outputCompleteListeners = new Vector();
     statusUpdateListeners = new Vector();
   }


   //--------------------------------------------------------------------------
   // Capabilities
   //--------------------------------------------------------------------------

   public boolean getCapAdditionalLines()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapAdditionalLines();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapAmountAdjustment()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapAmountAdjustment();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapAmountNotPaid()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapAmountNotPaid();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapCheckTotal()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapCheckTotal();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapCoverSensor()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapCoverSensor();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapDoubleWidth()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapDoubleWidth();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapDuplicateReceipt()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapDuplicateReceipt();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapFixedOutput()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapFixedOutput();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapHasVatTable()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapHasVatTable();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapIndependentHeader()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapIndependentHeader();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapItemList()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapItemList();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapJrnEmptySensor()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapJrnEmptySensor();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapJrnNearEndSensor()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapJrnNearEndSensor();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapJrnPresent()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapJrnPresent();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapNonFiscalMode()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapNonFiscalMode();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapOrderAdjustmentFirst()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapOrderAdjustmentFirst();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapPercentAdjustment()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapPercentAdjustment();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapPositiveAdjustment()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapPositiveAdjustment();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapPowerLossReport()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapPowerLossReport();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getCapPowerReporting()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapPowerReporting();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapPredefinedPaymentLines()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapPredefinedPaymentLines();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapReceiptNotPaid()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapReceiptNotPaid();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapRecEmptySensor()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapRecEmptySensor();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapRecNearEndSensor()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapRecNearEndSensor();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapRecPresent()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapRecPresent();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapRemainingFiscalMemory()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapRemainingFiscalMemory();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapReservedWord()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapReservedWord();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapSetHeader()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapSetHeader();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapSetPOSID()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapSetPOSID();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapSetStoreFiscalID()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapSetStoreFiscalID();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapSetTrailer()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapSetTrailer();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapSetVatTable()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapSetVatTable();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapSlpEmptySensor()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapSlpEmptySensor();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapSlpFiscalDocument()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapSlpFiscalDocument();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapSlpFullSlip()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapSlpFullSlip();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapSlpNearEndSensor()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapSlpNearEndSensor();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapSlpPresent()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapSlpPresent();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapSlpValidation()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapSlpValidation();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapSubAmountAdjustment()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapSubAmountAdjustment();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapSubPercentAdjustment()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapSubPercentAdjustment();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapSubtotal()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapSubtotal();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapTrainingMode()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapTrainingMode();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapValidateJournal()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapValidateJournal();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapXReport()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCapXReport();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapAdditionalHeader()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getCapAdditionalHeader();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapAdditionalTrailer()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getCapAdditionalTrailer();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapChangeDue()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getCapChangeDue();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapEmptyReceiptIsVoidable()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getCapEmptyReceiptIsVoidable();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapFiscalReceiptStation()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getCapFiscalReceiptStation();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapFiscalReceiptType()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getCapFiscalReceiptType();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapMultiContractor()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getCapMultiContractor();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapOnlyVoidLastItem()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getCapOnlyVoidLastItem();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapPackageAdjustment()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getCapPackageAdjustment();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapPostPreLine()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getCapPostPreLine();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapSetCurrency()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getCapSetCurrency();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapTotalizerType()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getCapTotalizerType();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapStatisticsReporting()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.8.0
     if(serviceVersion < deviceVersion18)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.8.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service18.getCapStatisticsReporting();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapUpdateStatistics()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.8.0
     if(serviceVersion < deviceVersion18)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.8.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service18.getCapUpdateStatistics();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapCompareFirmwareVersion()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.9.0
     if(serviceVersion < deviceVersion19)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.9.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service19.getCapCompareFirmwareVersion();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapUpdateFirmware()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.9.0
     if(serviceVersion < deviceVersion19)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.9.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service19.getCapUpdateFirmware();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCapPositiveSubtotalAdjustment()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.11.0
     if(serviceVersion < deviceVersion111)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.11.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service111.getCapPositiveSubtotalAdjustment();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }


   //--------------------------------------------------------------------------
   // Properties
   //--------------------------------------------------------------------------

   public int getAmountDecimalPlace()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getAmountDecimalPlace();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getAsyncMode()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getAsyncMode();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setAsyncMode(boolean asyncMode)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.setAsyncMode(asyncMode);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCheckTotal()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCheckTotal();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setCheckTotal(boolean checkTotal)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.setCheckTotal(checkTotal);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getCountryCode()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCountryCode();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getCoverOpen()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getCoverOpen();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getDayOpened()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getDayOpened();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getDescriptionLength()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getDescriptionLength();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getDuplicateReceipt()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getDuplicateReceipt();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setDuplicateReceipt(boolean duplicateReceipt)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.setDuplicateReceipt(duplicateReceipt);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getErrorLevel()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getErrorLevel();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getErrorOutID()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getErrorOutID();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getErrorState()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getErrorState();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getErrorStation()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getErrorStation();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public String getErrorString()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getErrorString();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getFlagWhenIdle()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getFlagWhenIdle();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setFlagWhenIdle(boolean flagWhenIdle)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.setFlagWhenIdle(flagWhenIdle);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getJrnEmpty()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getJrnEmpty();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getJrnNearEnd()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getJrnNearEnd();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getMessageLength()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getMessageLength();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getNumHeaderLines()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getNumHeaderLines();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getNumTrailerLines()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getNumTrailerLines();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getNumVatRates()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getNumVatRates();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getOutputID()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getOutputID();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getPowerNotify()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getPowerNotify();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setPowerNotify(int powerNotify)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.setPowerNotify(powerNotify);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getPowerState()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getPowerState();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public String getPredefinedPaymentLines()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getPredefinedPaymentLines();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getPrinterState()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getPrinterState();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getQuantityDecimalPlaces()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getQuantityDecimalPlaces();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getQuantityLength()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getQuantityLength();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getRecEmpty()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getRecEmpty();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getRecNearEnd()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getRecNearEnd();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getRemainingFiscalMemory()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getRemainingFiscalMemory();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public String getReservedWord()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getReservedWord();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getSlpEmpty()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getSlpEmpty();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getSlpNearEnd()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getSlpNearEnd();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getSlipSelection()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getSlipSelection();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setSlipSelection(int slipSelection)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.setSlipSelection(slipSelection);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public boolean getTrainingModeActive()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       return service13.getTrainingModeActive();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getActualCurrency()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getActualCurrency();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public String getAdditionalHeader()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getAdditionalHeader();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setAdditionalHeader(String additionalHeader)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       service16.setAdditionalHeader(additionalHeader);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public String getAdditionalTrailer()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getAdditionalTrailer();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setAdditionalTrailer(String additionalTrailer)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       service16.setAdditionalTrailer(additionalTrailer);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public String getChangeDue()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getChangeDue();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setChangeDue(String changeDue)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       service16.setChangeDue(changeDue);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getContractorId()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getContractorId();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setContractorId(int contractorId)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       service16.setContractorId(contractorId);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getDateType()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getDateType();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setDateType(int dateType)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       service16.setDateType(dateType);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getFiscalReceiptStation()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getFiscalReceiptStation();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setFiscalReceiptStation(int fiscalReceiptStation)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       service16.setFiscalReceiptStation(fiscalReceiptStation);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getFiscalReceiptType()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getFiscalReceiptType();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setFiscalReceiptType(int fiscalReceiptType)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       service16.setFiscalReceiptType(fiscalReceiptType);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getMessageType()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getMessageType();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setMessageType(int messageType)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       service16.setMessageType(messageType);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public String getPostLine()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getPostLine();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setPostLine(String postLine)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       service16.setPostLine(postLine);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public String getPreLine()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getPreLine();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setPreLine(String preLine)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       service16.setPreLine(preLine);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getTotalizerType()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service16.getTotalizerType();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setTotalizerType(int totalizerType)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       service16.setTotalizerType(totalizerType);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public int getAmountDecimalPlaces()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.7.0
     if(serviceVersion < deviceVersion17)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.7.0 compliant.");
     }

     // Perform the operation
     try
     {
       return service17.getAmountDecimalPlaces();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }


   //--------------------------------------------------------------------------
   // Methods
   //--------------------------------------------------------------------------

   public void beginFiscalDocument(int documentAmount)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.beginFiscalDocument(documentAmount);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void beginFiscalReceipt(boolean printHeader)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.beginFiscalReceipt(printHeader);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void beginFixedOutput(int station, int documentType)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.beginFixedOutput(station, documentType);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void beginInsertion(int timeout)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.beginInsertion(timeout);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void beginItemList(int vatID)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.beginItemList(vatID);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void beginNonFiscal()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.beginNonFiscal();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void beginRemoval(int timeout)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.beginRemoval(timeout);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void beginTraining()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.beginTraining();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void clearError()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.clearError();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void clearOutput()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.clearOutput();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void endFiscalDocument()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.endFiscalDocument();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void endFiscalReceipt(boolean printHeader)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.endFiscalReceipt(printHeader);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void endFixedOutput()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.endFixedOutput();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void endInsertion()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.endInsertion();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void endItemList()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.endItemList();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void endNonFiscal()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.endNonFiscal();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void endRemoval()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.endRemoval();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void endTraining()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.endTraining();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void getData(int dataItem, int[] optArgs, String[] data)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.getData(dataItem, optArgs, data);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void getDate(String[] Date)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.getDate(Date);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void getTotalizer(int vatID, int optArgs, String[] data)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.getTotalizer(vatID, optArgs, data);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void getVatEntry(int vatID, int optArgs, int[] vatRate)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.getVatEntry(vatID, optArgs, vatRate);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printDuplicateReceipt()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.printDuplicateReceipt();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printFiscalDocumentLine(String documentLine)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.printFiscalDocumentLine(documentLine);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printFixedOutput(int documentType, int lineNumber, String data)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.printFixedOutput(documentType, lineNumber, data);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printNormal(int station, String data)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.printNormal(station, data);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printPeriodicTotalsReport(String date1, String date2)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.printPeriodicTotalsReport(date1, date2);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printPowerLossReport()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.printPowerLossReport();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecItem(String description, long price, int quantity, int vatInfo, long unitPrice, String unitName)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.printRecItem(description, price, quantity, vatInfo, unitPrice, unitName);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecItemAdjustment(int adjustmentType, String description, long amount, int vatInfo)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.printRecItemAdjustment(adjustmentType, description, amount, vatInfo);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecMessage(String message)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.printRecMessage(message);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecNotPaid(String description, long amount)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.printRecNotPaid(description, amount);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecRefund(String description, long amount, int vatInfo)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.printRecRefund(description, amount, vatInfo);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecSubtotal(long amount)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.printRecSubtotal(amount);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecSubtotalAdjustment(int adjustmentType, String description, long amount)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.printRecSubtotalAdjustment(adjustmentType, description, amount);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecTotal(long total, long payment, String description)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.printRecTotal(total, payment, description);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecVoid(String description)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.printRecVoid(description);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecVoidItem(String description, long amount, int quantity, int adjustmentType, long adjustment, int vatInfo)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.printRecVoidItem(description, amount, quantity, adjustmentType, adjustment, vatInfo);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printReport(int reportType, String startNum, String endNum)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.printReport(reportType, startNum, endNum);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printXReport()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.printXReport();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printZReport()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.printZReport();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void resetPrinter()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.resetPrinter();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setDate(String date)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.setDate(date);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setHeaderLine(int lineNumber, String text, boolean doubleWidth)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.setHeaderLine(lineNumber, text, doubleWidth);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setPOSID(String POSID, String cashierID)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.setPOSID(POSID, cashierID);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setStoreFiscalID(String ID)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.setStoreFiscalID(ID);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setTrailerLine(int lineNumber, String text, boolean doubleWidth)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.setTrailerLine(lineNumber, text, doubleWidth);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setVatTable()
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.setVatTable();
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setVatValue(int vatID, String vatValue)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.setVatValue(vatID, vatValue);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void verifyItem(String itemName, int vatID)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Perform the operation
     try
     {
       service13.verifyItem(itemName, vatID);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void setCurrency(int newCurrency)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       service16.setCurrency(newCurrency);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecCash(long amount)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       service16.printRecCash(amount);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecItemFuel(String description, long price, int quantity, int vatInfo, long unitPrice, String unitName, long specialTax, String specialTaxName)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       service16.printRecItemFuel(description, price, quantity, vatInfo, unitPrice, unitName, specialTax, specialTaxName);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecItemFuelVoid(String description, long price, int vatInfo, long specialTax)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       service16.printRecItemFuelVoid(description, price, vatInfo, specialTax);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecPackageAdjustment(int adjustmentType, String description, String vatAdjustment)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       service16.printRecPackageAdjustment(adjustmentType, description, vatAdjustment);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecPackageAdjustVoid(int adjustmentType, String vatAdjustment)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       service16.printRecPackageAdjustVoid(adjustmentType, vatAdjustment);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecRefundVoid(String description, long amount, int vatInfo)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       service16.printRecRefundVoid(description, amount, vatInfo);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecSubtotalAdjustVoid(int adjustmentType, long amount)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       service16.printRecSubtotalAdjustVoid(adjustmentType, amount);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecTaxID(String taxID)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.6.0
     if(serviceVersion < deviceVersion16)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.6.0 compliant.");
     }

     // Perform the operation
     try
     {
       service16.printRecTaxID(taxID);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void resetStatistics(String statisticsBuffer)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.8.0
     if(serviceVersion < deviceVersion18)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.8.0 compliant.");
     }

     // Perform the operation
     try
     {
       service18.resetStatistics(statisticsBuffer);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void retrieveStatistics(String[] statisticsBuffer)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.8.0
     if(serviceVersion < deviceVersion18)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.8.0 compliant.");
     }

     // Perform the operation
     try
     {
       service18.retrieveStatistics(statisticsBuffer);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void updateStatistics(String statisticsBuffer)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.8.0
     if(serviceVersion < deviceVersion18)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.8.0 compliant.");
     }

     // Perform the operation
     try
     {
       service18.updateStatistics(statisticsBuffer);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void compareFirmwareVersion(String firmwareFileName, int[] result)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.9.0
     if(serviceVersion < deviceVersion19)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.9.0 compliant.");
     }

     // Perform the operation
     try
     {
       service19.compareFirmwareVersion(firmwareFileName, result);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void updateFirmware(String firmwareFileName)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.9.0
     if(serviceVersion < deviceVersion19)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.9.0 compliant.");
     }

     // Perform the operation
     try
     {
       service19.updateFirmware(firmwareFileName);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecItemVoid(String description, long price, int quantity, int vatInfo, long unitPrice, String unitName)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.11.0
     if(serviceVersion < deviceVersion111)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.11.0 compliant.");
     }

     // Perform the operation
     try
     {
       service111.printRecItemVoid(description, price, quantity, vatInfo, unitPrice, unitName);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecItemAdjustmentVoid(int adjustmentType, String description, long amount, int vatInfo)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.11.0
     if(serviceVersion < deviceVersion111)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.11.0 compliant.");
     }

     // Perform the operation
     try
     {
       service111.printRecItemAdjustmentVoid(adjustmentType, description, amount, vatInfo);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecItemRefund(String description, long amount, int quantity, int vatInfo, long unitAmount, String unitName)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.12.0
     if(serviceVersion < deviceVersion112)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.12.0 compliant.");
     }

     // Perform the operation
     try
     {
       service112.printRecItemRefund(description, amount, quantity, vatInfo, unitAmount, unitName);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }

   public void printRecItemRefundVoid(String description, long amount, int quantity, int vatInfo, long unitAmount, String unitName)
     throws JposException
   {
     // Make sure control is opened
     if(!bOpen)
     {
       throw new JposException(JPOS_E_CLOSED, "Control not opened");
     }

     // Make sure service supports at least version 1.12.0
     if(serviceVersion < deviceVersion112)
     {
       throw new JposException(JPOS_E_NOSERVICE,
                               "Device Service is not 1.12.0 compliant.");
     }

     // Perform the operation
     try
     {
       service112.printRecItemRefundVoid(description, amount, quantity, vatInfo, unitAmount, unitName);
     }
     catch(JposException je)
     {
       throw je;
     }
     catch(Exception e)
     {
       throw new JposException(JPOS_E_FAILURE,
                               "Unhandled exception from Device Service", e);
     }
   }


   //--------------------------------------------------------------------------
   // Framework Methods
   //--------------------------------------------------------------------------

   // Create an EventCallbacks interface implementation object for this Control
   protected EventCallbacks createEventCallbacks()
   {
     return new FiscalPrinterCallbacks();
   }

   // Store the reference to the Device Service
   protected void setDeviceService(BaseService service, int nServiceVersion)
     throws JposException
   {
     // Special case: service == null to free references
     if(service == null)
     {

       service13 = null;
       service14 = null;
       service15 = null;
       service16 = null;
       service17 = null;
       service18 = null;
       service19 = null;
       service110 = null;
       service111 = null;
       service112 = null;
       service113 = null;
       service114 = null;
     }
     else
     {
       // Make sure that the service actually conforms to the interfaces it
       // claims to.
       if(serviceVersion >= deviceVersion13)
       {
         try
         {
           service13 = (FiscalPrinterService13)service;
         }
         catch(Exception e)
         {
           throw new JposException(JPOS_E_NOSERVICE,
                                   "Service does not fully implement FiscalPrinterService13 interface",
                                   e);
         }
       }

       if(serviceVersion >= deviceVersion14)
       {
         try
         {
           service14 = (FiscalPrinterService14)service;
         }
         catch(Exception e)
         {
           throw new JposException(JPOS_E_NOSERVICE,
                                   "Service does not fully implement FiscalPrinterService14 interface",
                                   e);
         }
       }

       if(serviceVersion >= deviceVersion15)
       {
         try
         {
           service15 = (FiscalPrinterService15)service;
         }
         catch(Exception e)
         {
           throw new JposException(JPOS_E_NOSERVICE,
                                   "Service does not fully implement FiscalPrinterService15 interface",
                                   e);
         }
       }

       if(serviceVersion >= deviceVersion16)
       {
         try
         {
           service16 = (FiscalPrinterService16)service;
         }
         catch(Exception e)
         {
           throw new JposException(JPOS_E_NOSERVICE,
                                   "Service does not fully implement FiscalPrinterService16 interface",
                                   e);
         }
       }

       if(serviceVersion >= deviceVersion17)
       {
         try
         {
           service17 = (FiscalPrinterService17)service;
         }
         catch(Exception e)
         {
           throw new JposException(JPOS_E_NOSERVICE,
                                   "Service does not fully implement FiscalPrinterService17 interface",
                                   e);
         }
       }

       if(serviceVersion >= deviceVersion18)
       {
         try
         {
           service18 = (FiscalPrinterService18)service;
         }
         catch(Exception e)
         {
           throw new JposException(JPOS_E_NOSERVICE,
                                   "Service does not fully implement FiscalPrinterService18 interface",
                                   e);
         }
       }

       if(serviceVersion >= deviceVersion19)
       {
         try
         {
           service19 = (FiscalPrinterService19)service;
         }
         catch(Exception e)
         {
           throw new JposException(JPOS_E_NOSERVICE,
                                   "Service does not fully implement FiscalPrinterService19 interface",
                                   e);
         }
       }

       if(serviceVersion >= deviceVersion110)
       {
         try
         {
           service110 = (FiscalPrinterService110)service;
         }
         catch(Exception e)
         {
           throw new JposException(JPOS_E_NOSERVICE,
                                   "Service does not fully implement FiscalPrinterService110 interface",
                                   e);
         }
       }

       if(serviceVersion >= deviceVersion111)
       {
         try
         {
           service111 = (FiscalPrinterService111)service;
         }
         catch(Exception e)
         {
           throw new JposException(JPOS_E_NOSERVICE,
                                   "Service does not fully implement FiscalPrinterService111 interface",
                                   e);
         }
       }

       if(serviceVersion >= deviceVersion112)
       {
         try
         {
           service112 = (FiscalPrinterService112)service;
         }
         catch(Exception e)
         {
           throw new JposException(JPOS_E_NOSERVICE,
                                   "Service does not fully implement FiscalPrinterService112 interface",
                                   e);
         }
       }

       if(serviceVersion >= deviceVersion113)
       {
         try
         {
           service113 = (FiscalPrinterService113)service;
         }
         catch(Exception e)
         {
           throw new JposException(JPOS_E_NOSERVICE,
                                   "Service does not fully implement FiscalPrinterService113 interface",
                                   e);
         }
       }

       if(serviceVersion >= deviceVersion114)
       {
         try
         {
           service114 = (FiscalPrinterService114)service;
         }
         catch(Exception e)
         {
           throw new JposException(JPOS_E_NOSERVICE,
                                   "Service does not fully implement FiscalPrinterService114 interface",
                                   e);
         }
       }

     }
   }


   //--------------------------------------------------------------------------
   // Event Listener Methods
   //--------------------------------------------------------------------------

   public void addDirectIOListener(DirectIOListener l)
   {
     synchronized(directIOListeners)
     {
       directIOListeners.addElement(l);
     }
   }

   public void removeDirectIOListener(DirectIOListener l)
   {
     synchronized(directIOListeners)
     {
       directIOListeners.removeElement(l);
     }
   }

   public void addErrorListener(ErrorListener l)
   {
     synchronized(errorListeners)
     {
       errorListeners.addElement(l);
     }
   }

   public void removeErrorListener(ErrorListener l)
   {
     synchronized(errorListeners)
     {
       errorListeners.removeElement(l);
     }
   }

   public void addOutputCompleteListener(OutputCompleteListener l)
   {
     synchronized(outputCompleteListeners)
     {
       outputCompleteListeners.addElement(l);
     }
   }

   public void removeOutputCompleteListener(OutputCompleteListener l)
   {
     synchronized(outputCompleteListeners)
     {
       outputCompleteListeners.removeElement(l);
     }
   }

   public void addStatusUpdateListener(StatusUpdateListener l)
   {
     synchronized(statusUpdateListeners)
     {
       statusUpdateListeners.addElement(l);
     }
   }

   public void removeStatusUpdateListener(StatusUpdateListener l)
   {
     synchronized(statusUpdateListeners)
     {
       statusUpdateListeners.removeElement(l);
     }
   }


   //--------------------------------------------------------------------------
   // EventCallbacks inner class
   //--------------------------------------------------------------------------

   protected class FiscalPrinterCallbacks
     implements EventCallbacks
   {
     public BaseControl getEventSource()
     {
       return (BaseControl)FiscalPrinter.this;
     }

     public void fireDataEvent(DataEvent e)
     {
     }

     public void fireDirectIOEvent(DirectIOEvent e)
     {
       synchronized(FiscalPrinter.this.directIOListeners)
       {
         // deliver the event to all registered listeners
         for(int x = 0; x < directIOListeners.size(); x++)
         {
           ((DirectIOListener)directIOListeners.elementAt(x)).directIOOccurred(e);
         }
       }
     }

     public void fireErrorEvent(ErrorEvent e)
     {
       synchronized(FiscalPrinter.this.errorListeners)
       {
         // deliver the event to all registered listeners
         for(int x = 0; x < errorListeners.size(); x++)
         {
           ((ErrorListener)errorListeners.elementAt(x)).errorOccurred(e);
         }
       }
     }

     public void fireOutputCompleteEvent(OutputCompleteEvent e)
     {
       synchronized(FiscalPrinter.this.outputCompleteListeners)
       {
         // deliver the event to all registered listeners
         for(int x = 0; x < outputCompleteListeners.size(); x++)
         {
           ((OutputCompleteListener)outputCompleteListeners.elementAt(x)).outputCompleteOccurred(e);
         }
       }
     }

     public void fireStatusUpdateEvent(StatusUpdateEvent e)
     {
       synchronized(FiscalPrinter.this.statusUpdateListeners)
       {
         // deliver the event to all registered listeners
         for(int x = 0; x < statusUpdateListeners.size(); x++)
         {
           ((StatusUpdateListener)statusUpdateListeners.elementAt(x)).statusUpdateOccurred(e);
         }
       }
     }
   }
 }