MPS803.java

package libsidplay.components.printer.mps803;

import libsidplay.components.iec.IECBus;
import libsidplay.components.iec.SerialIECDevice;
import libsidplay.components.printer.CommodorePrinter;
import libsidplay.components.printer.IPaper;
import libsidplay.components.printer.PrinterConnection;
import libsidplay.components.printer.PrinterModel;
import libsidplay.components.printer.RasterPrinter;
import libsidplay.components.printer.UserportPrinterEnvironment;
import libsidplay.components.printer.epson.EpsonFX80;
import libsidplay.components.printer.paper.ConsolePaper;

import java.util.Objects;

/** IEC and Centronics user-port adapter shared by the printer command interpreters. */
public abstract class MPS803 extends SerialIECDevice implements UserportPrinterEnvironment {

    public static final int MAX_WIDTH = 480;

    private final byte[] charset;
    private final int defaultSecondary;

    private PrinterModel model = PrinterModel.MPS803;
    private PrinterConnection connection = PrinterConnection.BOTH;
    private RasterPrinter engine;
    private IPaper paper = new ConsolePaper();
    private boolean poweredOn, strobe = true;
    private byte value;

    public MPS803(IECBus bus, int primary, int secondary, byte[] charset) {
        super(bus);
        this.prnr = primary;
        this.defaultSecondary = secondary;
        this.charset = Objects.requireNonNull(charset);
        engine = new CommodorePrinter(charset, model);
        engine.setPaper(paper);
        reset();
    }

    @Override
    public synchronized void reset() {
        super.reset();
        selectSecondary(defaultSecondary);
        engine.reset();
        strobe = true;
        value = 0;
    }

    @Override
    public synchronized void clock() {
        super.clock();
    }

    public synchronized void setModel(PrinterModel model) {
        Objects.requireNonNull(model);
        if (this.model != model) {
            engine.flush();
            this.model = model;
            engine = model == PrinterModel.EPSON_FX80 ? new EpsonFX80(charset) : new CommodorePrinter(charset, model);
            selectSecondary(defaultSecondary);
            engine.reset();
            engine.setPaper(paper);
        }
    }

    public synchronized PrinterModel getModel() {
        return model;
    }

    public synchronized int getWidth() {
        return model.getWidth();
    }

    public synchronized void setConnection(PrinterConnection connection) {
        Objects.requireNonNull(connection);
        if (this.connection != connection) {
            engine.flush();
            this.connection = connection;
            setDeviceEnable(false);
            setDeviceEnable(poweredOn && connection.hasIEC());
            reset();
        }
    }

    public synchronized PrinterConnection getConnection() {
        return connection;
    }

    @Override
    public synchronized void printerUserportWriteData(byte data) {
        value = data;
    }

    @Override
    public synchronized void printerUserportWriteStrobe(boolean level) {
        if (poweredOn && connection.hasUserport() && strobe && !level) {
            putc(value);
            // MOS6526.setFlag accepts an asserted interrupt input, rather than a pin voltage.
            setBusy(true);
            setBusy(false);
        }
        strobe = level;
    }

    public synchronized void turnPrinterOnOff(boolean on) {
        if (poweredOn != on) {
            if (on) {
                paper.open();
                strobe = true;
            } else {
                engine.flush();
                paper.close();
            }
            poweredOn = on;
        }
        setDeviceEnable(on && connection.hasIEC());
    }

    public synchronized void setPaper(IPaper paper) {
        engine.flush();
        this.paper = Objects.requireNonNull(paper);
        engine.setPaper(paper);
    }

    public synchronized void putc(byte data) {
        engine.put(data);
    }

    public synchronized void flush() {
        engine.flush();
    }

    public abstract void setBusy(boolean asserted);

    private void selectSecondary(int secondary) {
        if (engine instanceof CommodorePrinter) {
            ((CommodorePrinter) engine).setSecondary(secondary);
        }
    }

    @Override
    public synchronized void open(int device, byte secondary) {
        selectSecondary(secondary);
    }

    @Override
    public synchronized void close(int device, byte secondary) {
        if (poweredOn && connection.hasIEC()) {
            engine.flush();
        }
    }

    @Override
    public synchronized void listenTalk(int device, byte secondary) {
        selectSecondary(secondary);
    }

    @Override
    public void unlisten(int device, byte secondary) {
    }

    @Override
    public void untalk(int device, byte secondary) {
    }

    @Override
    public byte read(int device, byte secondary) {
        return 0;
    }

    @Override
    public synchronized void write(int device, byte secondary, byte data) {
        if (poweredOn && connection.hasIEC()) {
            selectSecondary(secondary);
            putc(data);
        }
    }

    @Override
    public byte getStatus() {
        return 0;
    }
}