src.com.ibm.as400.access.SCS5256Writer Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jt400 Show documentation
Show all versions of jt400 Show documentation
The Open Source version of the IBM Toolbox for Java
///////////////////////////////////////////////////////////////////////////////
//
// JTOpen (IBM Toolbox for Java - OSS version)
//
// Filename: SCS5256Writer.java
//
// The source code contained herein is licensed under the IBM Public License
// Version 1.0, which has been approved by the Open Source Initiative.
// Copyright (C) 1997-2000 International Business Machines Corporation and
// others. All rights reserved.
//
///////////////////////////////////////////////////////////////////////////////
package com.ibm.as400.access;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
/**
* The SCS5256Writer class writes an SCS 5256 data stream to an output stream,
* translating characters into bytes of the specified CCSID.
* SCS5256Writer is the simplest SCS generator. It supports
* text, carriage return, line feed, new line, form feed, Absolute Horiz/Vert
* positioning, Relative Horiz/Vert positioning, and Set Vertical Format.
*
* @see OutputStreamWriter
* @version 1.1
**/
public class SCS5256Writer extends OutputStreamWriter
{
private static final String copyright = "Copyright (C) 1997-2000 International Business Machines Corporation and others.";
private static final byte [] CR = {0x0D};
private static final byte [] LF = {0x25};
private static final byte [] NL = {0x15};
private static final byte [] FF = {0x0C};
private static final byte [] SGEA = {0x2B, (byte)0xC8, 0x01};
private static final byte [] SHF = {0x2B, (byte)0xC1, 0x02, 0x00};
private static final byte [] SVF = {0x2B, (byte)0xC2, 0x02, 0x00};
private static final byte [] AHPP = {0x34, (byte)0xC0, 0x00};
private static final byte [] AVPP = {0x34, (byte)0xC4, 0x00};
private static final byte [] RHPP = {0x34, (byte)0xC8, 0x00};
private static final byte [] RVPP = {0x34, (byte)0x4C, 0x00};
private OutputStream outPut;
private Converter cvt;
private byte [] buffer = new byte [300];
private int dataLength = 0;
/* horizontalFormat retains the current # of characters per line.
* (-1) indicates not set.
*/
private int horizontalFormat_ = -1;
/* verticalFormat retains the current # of lines per page.
* (-1) indicates not set.
*/
private int verticalFormat_ = -1;
/* PageStarted is a flag to indicate data has been written to the
* page. Some print commands can only appear at the start of a
* page.
*/
boolean pageStarted_ = false;
/**
* Constructs a SCS5256Writer. The default encoding will be used.
*
* @param out An OutputStream.
*
* @deprecated Replaced by SCS5256Writer(OutputStream, int, AS400).
Any SCS5256Writer object that is created without
specifying an AS400 system object on its constructor may
not behave as expected in certain environments.
**/
public SCS5256Writer(OutputStream out)
{
super(out);
outPut = out;
// cvt = Converter.getConverter();
cvt = new Converter();
}
/**
* Constructs a SCS5256Writer.
*
* @param out An OutputStream.
* @param ccsid The name of the target CCSID to be used.
*
* @exception UnsupportedEncodingException If ccsid is invalid.
* @deprecated Replaced by SCS5256Writer(OutputStream, int, AS400).
Any SCS5256Writer object that is created without
specifying an AS400 system object on its constructor may
not behave as expected in certain environments.
**/
public SCS5256Writer(OutputStream out,
int ccsid)
throws UnsupportedEncodingException
{
super(out);
outPut = out;
// cvt = Converter.getConverter(ccsid);
cvt = new Converter(ccsid);
}
/**
* Constructs a SCS5256Writer.
*
* @param out An OutputStream.
* @param ccsid The name of the target CCSID to be used.
* @param system The system.
*
* @exception UnsupportedEncodingException If ccsid is invalid.
**/
public SCS5256Writer(OutputStream out,
int ccsid,
AS400 system)
throws UnsupportedEncodingException
{
super(out);
outPut = out;
cvt = new Converter(ccsid, system);
}
/**
* Constructs a SCS5256Writer.
*
* @param out An OutputStream.
* @param encoding The name of the target encoding to be used.
*
* @exception UnsupportedEncodingException If encoding is invalid.
* @deprecated Replaced by SCS5256Writer(OutputStream, int, AS400).
Any SCS5256Writer object that is created without
specifying an AS400 system object on its constructor may
not behave as expected in certain environments.
**/
public SCS5256Writer(OutputStream out,
String encoding)
throws UnsupportedEncodingException
{
super(out);
outPut = out;
// cvt = Converter.getConverter(encoding); //@A1C
cvt = new Converter(encoding); // @A4A
}
/** Moves the print position to the column specified. Moving
* beyond the right end of the page will cause an error on the
* printer.
*
* @param column The new horizontal print position. Valid values are
* 0 to the maximum print position as set in the SetHorizontalFormat
* method. A value of 0 causes a no-op. The number of columns on
* a line is dependent on the current character width (CPI) and the
* width of the page.
*
* @exception IOException If an error occurs while communicating
* with the system.
**/
public void absoluteHorizontalPosition(int column)
throws IOException
{
byte [] cmd = AHPP;
if ((column < 0) || (column > 255)) {
String arg = "Column (" + String.valueOf(column) + ")";
throw new ExtendedIllegalArgumentException(arg, 2);
}
if (pageStarted_ == false) initPage();
cmd[cmd.length-1] = (byte)column;
addToBuffer(cmd);
}
/** Moves the print position to the line number specified. Moving
* above the current line causes a form feed and move to the specified
* line on the next page.
*
* @param line The new vertical print position. Valid values are
* 0 to the current forms length as specified by the SetVerticalFormat
* method. A value of 0 causes a no-op. If the value is less than
* the current line, the forms are moved to the specified line of the
* next logical page.
*
* @exception IOException If an error occurs while communicating
* with the system.
**/
public void absoluteVerticalPosition(int line)
throws IOException
{
byte [] cmd = AVPP;
if ((line < 0) || (line > 255)) {
String arg = "Line (" + String.valueOf(line) + ")";
throw new ExtendedIllegalArgumentException(arg, 2);
}
if (pageStarted_ == false) initPage();
cmd[cmd.length-1] = (byte)line;
addToBuffer(cmd);
}
/* Adds printer controls to the buffer.
* Bytes are not translated.
*
* @param data The bytes to add to the buffer.
*
* @exception IOException If an error occurs while communicating
* with the system.
*/
void addToBuffer(byte [] data)
throws IOException
{
if (outPut == null) {
throw new IOException("Stream closed");
}
int len = data.length;
if ((dataLength + len) > buffer.length) flush();
for (int i = 0; i < len; i++ ) {
buffer[dataLength] = data[i];
dataLength ++;
} /* endfor */
}
/** Adds a carriage return control to the stream.
*
* @exception IOException If an error occurs while communicating
* with the system.
**/
public void carriageReturn()
throws IOException
{
addToBuffer(CR);
}
/** Closes the stream.
*
* @exception IOException If an error occurs while communicating
* with the system.
**/
public void close()
throws IOException
{
flush();
outPut.close();
outPut = null; // Null private data to show
cvt = null;
}
/** Ends current page. The application MUST use this method
* to end the current page after the page data has been written.
*
* @exception IOException If an error occurs while communicating
* with the system.
*
**/
public void endPage()
throws IOException
{
addToBuffer(FF);
pageStarted_ = false;
}
/** Flushes the stream.
*
* @exception IOException If an error occurs while communicating
* with the system.
**/
public void flush()
throws IOException
{
if (dataLength > 0) {
if (outPut == null) {
throw new IOException("Stream closed");
}
outPut.write(buffer, 0, dataLength);
dataLength = 0;
}
}
// Get the CCSID used for this writer.
int getCcsid()
{
if (cvt == null) {
return 0;
} else {
return cvt.getCcsid();
}
}
/** Returns the name of the encoding being used by this stream.
* It may return null if the stream has been closed.
**/
public String getEncoding()
{
if (cvt == null) {
return(null);
} else {
return cvt.getEncoding();
}
}
/* Sends out controls to initialize the start of a page.
*
* @exception IOException If an error occurs while communicating
* with the system.
*
*/
void initPage()
throws IOException
{
pageStarted_ = true;
sendSGEA();
if (horizontalFormat_ != (-1)) {
setHorizontalFormat(horizontalFormat_);
}
if (verticalFormat_ != (-1)) {
setVerticalFormat(verticalFormat_);
}
}
/** Adds a line feed control to the stream.
*
* @exception IOException If an error occurs while communicating
* with the system.
**/
public void lineFeed()
throws IOException
{
addToBuffer(LF);
}
/** Adds a new line control to the stream.
*
* @exception IOException If an error occurs while communicating
* with the system.
**/
public void newLine()
throws IOException
{
addToBuffer(NL);
}
/** Moves the print position the number of characters specified. Moving
* beyond the right end of the page will cause an error on the
* printer.
*
* @param chars The number of character widths to move. Valid values are
* 0 to the maximum print position minus the current column. The maximum
* print position is the current CPI * 13.2 inches. A value of 0 causes a
* no-op.
*
* @exception IOException If an error occurs while communicating
* with the system.
**/
public void relativeHorizontalPosition(int chars)
throws IOException
{
byte [] cmd = RHPP;
// Just check chars for min and max value. User must keep track of
// max value for page size
if ((chars < 0) || (chars > 255)) {
String arg = "chars (" + String.valueOf(chars) + ")";
throw new ExtendedIllegalArgumentException(arg, 2);
}
if (pageStarted_ == false) initPage();
cmd[cmd.length-1] = (byte)chars;
addToBuffer(cmd);
}
/** Moves the print position the number of lines specified.
*
* @param lines The number of lines to move down the page. Valid values are
* 0 to the last logical line on the page. A value of 0 causes a
* no-op.
*
* @exception IOException If an error occurs while communicating
* with the system.
**/
public void relativeVerticalPosition(int lines)
throws IOException
{
byte [] cmd = RVPP;
// Just check chars for min and max value. User must keep track of
// max value for page size
if ((lines < 0) || (lines > 255)) {
String arg = "lines (" + String.valueOf(lines) + ")";
throw new ExtendedIllegalArgumentException(arg, 2);
}
if (pageStarted_ == false) initPage();
cmd[cmd.length-1] = (byte)lines;
addToBuffer(cmd);
}
/* Sends Set Graphic Error Action (SGEA) command. One multibyte
* command must be sent for the data stream sniffer to determine
* this is a SCS data stream.
*
*/
private void sendSGEA()
throws IOException
{
addToBuffer(SGEA);
}
/** Sets the Horizontal Format. This specifies the maximum number of
* characters on the line.
*
* @param NumOfChars The maximum number of characters. Valid values are
* 0 to 255. A value of 0 causes horizontal format to be set to the
* printer default.
*
* @exception IOException If an error occurs while communicating
* with the system.
**/
public void setHorizontalFormat(int NumOfChars)
throws IOException
{
byte [] cmd = {0,0,0,0};
if ((NumOfChars < 0) || (NumOfChars > 255)) {
String arg = "NumOfChars (" + String.valueOf(NumOfChars) + ")";
throw new ExtendedIllegalArgumentException(arg, 2);
}
horizontalFormat_ = NumOfChars;
for(int i=0; i< (cmd.length-1); i++)
{
cmd[i] = SHF[i];
}
cmd[cmd.length-1] = (byte)NumOfChars;
addToBuffer(cmd);
}
/** Sets the Vertical Format. This specifies the maximum number of
* lines on the page. Note that when the printer executes this command
* the current line number on the printer is set to 1. Also, the
* combination of LPI and Vertical Format should not exceed 159 cm
* (63.75 inches). Changing the Line Density changes where the maximum
* line is on the physical page.
*
* @param NumOfLines The maximum number of lines. Valid values are
* 0 to 255. A value of 0 causes vertical format to be set to the
* printer default.
*
* @exception IOException If an error occurs while communicating
* with the system.
**/
public void setVerticalFormat(int NumOfLines)
throws IOException
{
byte [] cmd = {0,0,0,0};
if ((NumOfLines < 0) || (NumOfLines > 255)) {
String arg = "NumOfLines (" + String.valueOf(NumOfLines) + ")";
throw new ExtendedIllegalArgumentException(arg, 2);
}
verticalFormat_ = NumOfLines;
for(int i=0; i< (cmd.length-1); i++)
{
cmd[i] = SVF[i];
}
cmd[cmd.length-1] = (byte)NumOfLines;
addToBuffer(cmd);
}
/** Writes a portion of an array of characters.
*
* @param databuffer The buffer of characters.
* @param offset The offset from which to start writing characters.
* @param length The number of characters to write.
*
* @exception IOException If an error occurs while communicating
* with the system.
**/
public void write(char databuffer[],
int offset,
int length)
throws IOException
{
// Convert input to a string.
String aStr = new String(databuffer, offset, length);
write(aStr);
}
/** Writes a single character.
*
* @param c The character to write.
*
* @exception IOException If an error occurs while communicating
* with the system.
**/
public void write(int c)
throws IOException
{
// Convert input to a string.
String aStr = String.valueOf(c);
write(aStr);
}
/** Writes a string.
*
* @param str The string to write.
*
* @exception IOException If an error occurs while communicating
* with the system.
**/
public void write(String str)
throws IOException
{
if (outPut == null) {
throw new IOException("Stream closed");
}
if (pageStarted_ == false) initPage();
// Convert input to a byte array of proper encoding.
byte [] convertedBytes = cvt.stringToByteArray(str);
// If input too large for room in buffer, flush buffer
if ((dataLength + convertedBytes.length) > buffer.length) {
flush();
// If input data is larger than buffer, write data
if (convertedBytes.length > buffer.length) {
outPut.write(convertedBytes, 0, convertedBytes.length);
return;
}
}
// Copy input to buffer
System.arraycopy(convertedBytes, 0, buffer, dataLength,
convertedBytes.length);
dataLength += convertedBytes.length;
}
/** Writes a portion of a string.
*
* @param str The string to write.
* @param offset The offset from which to start writing characters.
* @param length The number of characters to write.
*
* @exception IOException If an error occurs while communicating
* with the system.
**/
public void write(String str,
int offset,
int length)
throws IOException
{
String aStr = str.substring(offset, offset + length);
write(aStr);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy