EpsonFX80.java
package libsidplay.components.printer.epson;
import libsidplay.components.printer.PrinterModel;
import libsidplay.components.printer.RasterPrinter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* FX-80 ESC/P interpreter. The raster uses 240 horizontal and 216 vertical
* dots/inch, preserving all four graphics densities and 1/216 inch feeds.
* Text uses the bundled Commodore bitmap font, mapped to ASCII.
*/
public final class EpsonFX80 extends RasterPrinter {
private static final int[] GRAPHICS_DPI = {60, 120, 120, 240, 80, 72, 90};
private final byte[] charset;
private final int[] parameters = new int[3];
private final int[] graphicsModes = new int[4];
private final List<Integer> horizontalTabs = new ArrayList<>();
private final List<Integer> verticalTabs = new ArrayList<>();
private final int[][] downloaded = new int[256][];
private boolean escape, elite, condensed, emphasized, doubleStrike, italic, underline;
private boolean doubleWidth, singleLineWidth, userDefined, ninePin;
private int script, command, parameterCount, parametersNeeded, tabCommand, lastTab;
private int lineSpacing, pageLength, pagePosition, bottomMargin, leftMargin, rightMargin;
private int graphicsRemaining, graphicsByte, downloadCharacter, downloadIndex, downloadRemaining;
private double graphicsPosition, graphicsStep;
public EpsonFX80(byte[] charset) {
super(PrinterModel.EPSON_FX80.getWidth());
this.charset = charset;
reset();
}
@Override
public void reset() {
super.reset();
initialize();
pagePosition = 0;
Arrays.fill(downloaded, null);
}
private void initialize() {
escape = elite = condensed = emphasized = doubleStrike = italic = underline = false;
doubleWidth = singleLineWidth = userDefined = ninePin = false;
script = command = parameterCount = parametersNeeded = tabCommand = 0;
graphicsRemaining = downloadRemaining = 0;
lineSpacing = 36;
pageLength = 11 * 216;
bottomMargin = leftMargin = 0;
rightMargin = width;
x = 0;
horizontalTabs.clear();
for (int column = 8; column < 80; column += 8) {
horizontalTabs.add(column * 24);
}
verticalTabs.clear();
graphicsModes[0] = 0;
graphicsModes[1] = 1;
graphicsModes[2] = 2;
graphicsModes[3] = 3;
}
@Override
public void put(byte data) {
int c = data & 0xff;
// Binary payloads take precedence over every text/control code.
if (graphicsRemaining != 0) {
printGraphics(c);
return;
}
if (downloadRemaining != 0) {
if (downloadIndex == 0) {
downloaded[downloadCharacter] = new int[12];
}
downloaded[downloadCharacter][downloadIndex++] = c;
if (downloadIndex == 12) {
downloadIndex = 0;
downloadCharacter++;
}
downloadRemaining--;
return;
}
if (parametersNeeded != 0) {
parameters[parameterCount++] = c;
if (parameterCount == parametersNeeded) {
parametersNeeded = 0;
applyParameters();
}
return;
}
if (tabCommand != 0) {
List<Integer> tabs = tabCommand == 'D' ? horizontalTabs : verticalTabs;
if (c == 0 || c <= lastTab) {
tabCommand = 0;
} else {
if (tabs.size() < (tabCommand == 'D' ? 32 : 16)) {
tabs.add(c * (tabCommand == 'D' ? characterWidth() : lineSpacing));
}
lastTab = c;
}
return;
}
if (escape) {
escape = false;
escapeCommand(c);
return;
}
switch (c) {
case 8:
x = Math.max(leftMargin, x - characterWidth());
break;
case 9:
for (int tab : horizontalTabs) {
if (tab > x && tab < rightMargin) {
x = tab;
break;
}
}
break;
case 10:
advance(lineSpacing);
singleLineWidth = false;
break;
case 11:
verticalTab();
break;
case 12:
formFeed();
break;
case 13:
x = leftMargin;
singleLineWidth = false;
break;
case 14:
singleLineWidth = true;
break;
case 15:
condensed = true;
break;
case 18:
condensed = false;
break;
case 20:
singleLineWidth = false;
break;
case 24:
super.reset();
x = leftMargin;
break;
case 27:
escape = true;
break;
default:
if (c >= 32 && c != 127) {
printCharacter(c);
}
break;
}
}
private void escapeCommand(int c) {
switch (c) {
case '@':
initialize();
return;
case '0':
lineSpacing = 27;
return;
case '1':
lineSpacing = 21;
return;
case '2':
lineSpacing = 36;
return;
case '4':
case '5':
italic = c == '4';
return;
case 'E':
case 'F':
emphasized = c == 'E';
return;
case 'G':
case 'H':
doubleStrike = c == 'G';
return;
case 'M':
case 'P':
elite = c == 'M';
return;
case 'O':
bottomMargin = 0;
return;
case 'T':
script = 0;
return;
case 14:
singleLineWidth = true;
return;
case 15:
condensed = true;
return;
case 'B':
case 'D':
tabCommand = c;
lastTab = 0;
(c == 'D' ? horizontalTabs : verticalTabs).clear();
return;
case '*':
case '^':
case '&':
case ':':
expect(c, 3);
return;
case 'K':
case 'L':
case 'Y':
case 'Z':
case '$':
case '\\':
case '?':
expect(c, 2);
return;
case '!':
case '-':
case '3':
case 'A':
case 'J':
case 'C':
case 'N':
case 'Q':
case 'l':
case 'S':
case 'W':
case '%':
case 'R':
case 'U':
case 's':
case 'p':
case 'x':
case 'i':
expect(c, 1);
return;
default:
// Unsupported one-byte commands have no printed representation.
return;
}
}
private void expect(int command, int count) {
this.command = command;
parameterCount = 0;
parametersNeeded = count;
}
private void applyParameters() {
int n = parameters[0];
switch (command) {
case '!':
elite = (n & 1) != 0;
condensed = (n & 4) != 0;
emphasized = (n & 8) != 0;
doubleStrike = (n & 16) != 0;
doubleWidth = (n & 32) != 0;
italic = (n & 64) != 0;
underline = (n & 128) != 0;
break;
case '-':
underline = enabled(n);
break;
case 'W':
doubleWidth = enabled(n);
break;
case '%':
userDefined = enabled(n);
break;
case 'S':
script = (n & 1) == 0 ? -1 : 1;
break;
case '3':
lineSpacing = n;
break;
case 'A':
lineSpacing = n * 3;
break;
case 'J':
advance(n);
break;
case 'C':
if (n == 0) {
expect('c', 1);
} else {
pageLength = Math.max(1, n * lineSpacing);
pagePosition = 0;
}
break;
case 'c':
if (n != 0) {
pageLength = n * 216;
pagePosition = 0;
}
break;
case 'N':
bottomMargin = Math.min(n * lineSpacing, pageLength - 1);
break;
case 'l':
int left = n * characterWidth();
if (left < rightMargin) {
leftMargin = left;
x = Math.max(x, leftMargin);
}
break;
case 'Q':
int right = n * characterWidth();
if (right > leftMargin && right <= width) {
rightMargin = right;
}
break;
case '$':
x = Math.min(rightMargin, leftMargin + (n | parameters[1] << 8) * 4);
break;
case '\\':
int offset = (short) (n | parameters[1] << 8);
x = Math.max(leftMargin, Math.min(rightMargin, x + offset * 2));
break;
case '?':
int index = graphicsIndex(n);
if (index >= 0 && parameters[1] < GRAPHICS_DPI.length) {
graphicsModes[index] = parameters[1];
}
break;
case '*':
startGraphics(n, parameters[1] | parameters[2] << 8, false);
break;
case '^':
startGraphics(n & 1, parameters[1] | parameters[2] << 8, true);
break;
case 'K':
case 'L':
case 'Y':
case 'Z':
startGraphics(graphicsModes[graphicsIndex(command)], n | parameters[1] << 8, false);
break;
case '&':
if (parameters[2] >= parameters[1]) {
downloadCharacter = parameters[1];
downloadIndex = 0;
downloadRemaining = (parameters[2] - parameters[1] + 1) * 12;
}
break;
default:
// Direction, speed and ROM character-set selection do not move paper.
break;
}
}
private boolean enabled(int n) {
return n == 1 || n == '1';
}
private int graphicsIndex(int command) {
switch (command) {
case 'K':
return 0;
case 'L':
return 1;
case 'Y':
return 2;
case 'Z':
return 3;
default:
return -1;
}
}
private void startGraphics(int mode, int columns, boolean ninePin) {
this.ninePin = ninePin;
graphicsRemaining = columns * (ninePin ? 2 : 1);
graphicsByte = 0;
graphicsPosition = x;
// Consume even unsupported density payloads without interpreting them as text.
graphicsStep = mode < GRAPHICS_DPI.length ? 240.0 / GRAPHICS_DPI[mode] : 0;
}
private void printGraphics(int c) {
int firstRow = ninePin && (graphicsByte & 1) != 0 ? 8 : 0;
int pins = firstRow == 8 ? 1 : 8;
if (graphicsStep != 0) {
for (int pin = 0; pin < pins; pin++) {
if ((c & 0x80 >> pin) != 0) {
for (int dx = 0; dx < Math.max(1, (int) Math.round(graphicsStep)); dx++) {
int column = (int) Math.round(graphicsPosition) + dx;
if (column < rightMargin) {
for (int dy = 0; dy < 3; dy++) {
plot(column, (firstRow + pin) * 3 + dy);
}
}
}
}
}
}
graphicsByte++;
graphicsRemaining--;
if (!ninePin || (graphicsByte & 1) == 0) {
graphicsPosition += graphicsStep;
x = Math.min(rightMargin, (int) Math.round(graphicsPosition));
}
pending = true;
}
private int characterWidth() {
int cell = condensed ? (elite ? 12 : 14) : (elite ? 20 : 24);
return cell * (doubleWidth || singleLineWidth ? 2 : 1);
}
private void printCharacter(int c) {
int cell = characterWidth();
if (x + cell > rightMargin) {
advance(lineSpacing);
x = leftMargin;
singleLineWidth = false;
cell = characterWidth();
}
int[] custom = userDefined ? downloaded[c] : null;
int columns = custom == null ? 6 : 12;
int height = custom == null ? 7 : 8;
int ascii = c & 0x7f;
int glyph = ascii >= 'a' && ascii <= 'z' ? 256 + ascii - 32 : ascii;
for (int row = 0; row < height; row++) {
for (int dx = 0; dx < cell; dx++) {
int column = dx * columns / cell;
boolean pixel = custom == null
? (charset[glyph * 7 + row] & 0x80 >> column) != 0
: column < 11 && (custom[column + 1] & 0x80 >> row) != 0;
if (pixel) {
int skew = italic ? (height - 1 - row) / 2 : 0;
int top = script == 0 ? row * 3 : row * 2 + (script > 0 ? 12 : 0);
for (int dy = 0; dy < (script == 0 ? 3 : 2); dy++) {
textDot(x + dx + skew, top + dy);
}
}
}
}
if (underline) {
for (int dx = 0; dx < cell; dx++) {
plot(x + dx, 24);
}
}
x += cell;
pending = true;
}
private void textDot(int column, int row) {
if (column < rightMargin) {
plot(column, row);
if (emphasized && column + 1 < rightMargin) {
plot(column + 1, row);
}
if (doubleStrike) {
plot(column, row + 1);
}
}
}
private void advance(int dots) {
feed(dots);
pagePosition = (pagePosition + dots) % pageLength;
if (bottomMargin != 0 && pagePosition >= pageLength - bottomMargin) {
feed(pageLength - pagePosition);
pagePosition = 0;
}
}
private void verticalTab() {
for (int tab : verticalTabs) {
if (tab > pagePosition && tab < pageLength) {
advance(tab - pagePosition);
x = leftMargin;
singleLineWidth = false;
return;
}
}
if (verticalTabs.isEmpty()) {
advance(lineSpacing);
} else {
formFeed();
}
}
private void formFeed() {
feed(pageLength - pagePosition);
pagePosition = 0;
x = leftMargin;
singleLineWidth = false;
}
@Override
public void flush() {
if (pending) {
advance(Math.max(lineSpacing, getBufferedHeight()));
}
x = leftMargin;
}
}