PAGE  60,132
        TITLE   EPSON MX-GRAFTRAX PrtSc, V 2.3a
; GRAF.COM  3/12/83
; INTERRUPT REPLACEMENT FOR PRINT SCREEN FUNCTION ON IBMPC(tm)
;  =====> N O T I C E <=======
;       THIS PROGRAM IS SUPPLIED FOR YOUR PERSONAL AND NON-COMMERCIAL
;       USE ONLY. NO COMMERCIAL USE PERMITTED. USERS OF THIS PROGRAM
;       ARE GRANTED LIMITED RIGHTS TO REPRODUCE AND DISTRIBUTE THIS
;       PROGRAM. IT MAY NOT BE SOLD. PROVIDING THIS PROGRAM FOR
;       CONSIDERATION ANY SORT, INCLUDING COPYING OR DISTRIBUTION FEES,
;       IS SPECIFICALLY PROHIBITED.  THE AUTHOR CANNOT ASSUME RESPONSIBILITY
;       FOR DAMAGES, REAL OR IMAGINED, RESULTING FROM THE USE OF THIS PROGRAM.
;  =====> ENDNOTICE <=========
;
;       PLEASE SEND PROBLEM REPORTS AND SUGGESTIONS TO:
;               MARTY SMITH
;               310 CINNAMON OAK LANE
;               HOUSTON, TEXAS  77079
;               SOURCE ST2259, COMPUSERVE 72155,1214
;               (713) 661-1241 Office, (713) 464-6737, Home.
;
;  THIS PROGRAM ORIGINALLY DESIGNED FOR EPSON-MX(tm) SERIES PRINTERS
;  WITH GRAFTRAX80(tm) AND GRAFTRAX+(tm) BIT-PLOT GRAPHIC CAPABILITES.
;  ======> Now modified with conditional compilation and macros for
;  ======> c.itoh(tm) model 8510a and other printers with bit-plot
;  ======> capabilities. See the macro definitions and equates following
;  ======> these messages.
;
;       CHANGE HISTORY:
;       9/18/82 - Buffer in routine for a line of bit-plot bytes to allow for
;  checking for blank lines replaced by pre-scan routine, saving space.
;       1/24/83 - Modifications for conditional assembly with other printers
;  and C.ITOH 8510a.
;       1/24/83 - Improved error checking for out-of-paper and I/O errors
;  involving printer.
;       1/24/83 - Bug in error check corrected, occuring when routine does
;  error exit and is then called again, resulting in bit-plot data sent in
;  regular mode.
;       3/12/83 - Allow calling as a subroutine. i.e. no shift key depressed.
;  Defaults to small print mode. Can be poked for LARGE.
;
;       THE IBM MACRO ASSEMBLER(tm) AND LINK(tm) WILL PRODUCE
;       GRAF.EXE, WHICH MUST BE CONVERTED TO A .COM PROGRAM BY
;       THE COMMAND FROM DOS -EXE2BIN-.
;               do this:
;       X>EXE2BIN GRAF.EXE GRAF.COM
;
;       Features:
;  Accepts ESC key exit, prescans to test for blank line
;  left shift prtsc = small graphics, right shift prtsc = big
;  Runs as a .COM type program under dos
;     resident until power down or reset.
;   1 = screen sent horiz. 320 bits in 480 mode
;   2 = screen sent vert. 400 bits double printed in 480 mode
; **************  1 mode **********************
;       DL = masking character
;       DH = count of 25 (physical lines)
;       CX = counter for each line (80)
;       DS = used to index screen at 'b8000'
;   These regs must be preserved during routine
;         (increment each line by adding '14' hex to ds for para
;               boundary of 320 bytes '140')
; **************  2 mode *********************
;       DH = count of 40 (physical lines)
;       CX = counter for each line (100)
;       SI = index to screen via ds
;   These regs must be preserved during routine
;       all output to printer is done from routine -send2-, which uses
;       bios routine int 17h, and provides safe error exit.
;
;  GRAF.COM is designed with the idea that the user's main program is the
;  primary function and GRAF.COM should not cause problems of its own.
;  The author has tried his best to send control back to the main program in
;  the case of errors involving the printer, and to make the program as easy
;  to use as possible.
;
; =======================================================
; =             USER MODIFICATION SECTION.              =
; =     If your printer can treat a byte of data to     =
; =     control the wires on the dot-matrix head you    =
; =     can probably get this working with your printer =
; =     If you have Epson Graftrax or a C.Itoh 8510a,   =
; =     just set the two equates indicated to -true-    =
; =     and compile. Otherwise get out your manual      =
; =     and put the code indicated in the -other-       =
; =     section and set -other- to -true-.              =
; =     **>     The title message starts at label       =
; =     **>     -buffer-. If you set for another        =
; =     **>     printer you should change the           =
; =     **>     greeting to indicate which printer      =
; =     ===> ONLY SET *ONE* CONDITION TO -TRUE- or you  =
; =     will have a real mess!          marty smith     =
; =======================================================

TRUE    EQU     1       ; DON'T CHANGE THESE!
FALSE   EQU     0

; ===============>  A L L  U S E R S  <===================
; ====> SET ONE AND ONLY ONE OF THE FOLLOWING THREE <=====

EPSON   EQU     FALSE
CITOH   EQU     TRUE
OTHER   EQU     FALSE

; Each bit of a byte is mapped to the wire head of the printer.
; If the Epson MX is sent 80h (bit 7), the TOP wire makes a dot.
; If the C.ITOH is sent   01h (bit 0), the TOP wire makes a dot.
; ===============>  A L L  U S E R S  <===================
; =====> SET ONE AND ONLY ONE OF THE FOLLOWING TWO <======

BIT7    EQU     FALSE
BIT0    EQU     TRUE
        ; BIT7 is TRUE for EPSON
        ; BIT0 is TRUE for CITOH

; *****************************
; *  START of -OTHER- SECTION *
; *****************************
;
; ALL routines must set either BIT7 or BIT0.
;   above. If your printer can't see bit 7 or 0 as the top wire, you
;   will probably have quite a time getting this routine to work.
;
; OLINE Resets line spacing so that the print head
; will make a continuous line DOWN the page. (8/72 inch)
; This is the sequence to set the EPSON for this. (ESC A 8)
; SEND2 sends the byte in AL to the printer for ALL routines.
; It uses the INT 17h routine in order to avoid DOS's extra line
; feeds and CR's. Set for LPT1: Change SEND2 to redirect. DX=0=LPT1,1=LPT2
OLINE   MACRO
        MOV     AL,27
        CALL    SEND2
        MOV     AL,65
        CALL    SEND2
        MOV     AL,8
        CALL    SEND2
        ENDM

; ORLINE restores the printer to normal line spacing
; Example is for EPSON (ESC 2)
ORLINE  MACRO
        MOV     AL,27
        CALL    SEND2
        MOV     AL,'2'
        CALL    SEND2
        ENDM

; ORESET reinitializes the printer to default settings, spacings,
; current line becomes Top of Form.
; Is used by LARGE print to allow a series to be printed
; on separate pages. It can be modified by getting rid of label
; TOF: up to but not including   JMP DONE, which is the exit from
; the whole routine. Example is for EPSON. (ESC @)
ORESET  MACRO
        MOV     AL,27
        CALL    SEND2
        MOV     AL,'@'
        CALL    SEND2
        ENDM

; BP1 initiates bit-plot graphics. It tells the printer
; that the next xxx bytes are to be considered bit-plots and not
; regular characters. The small print routine sends 320 bit plot bytes
; to the printer. On the EPSON this is:
; ESC K 64 1   hex 1b 4b 40 1  > 1*256+64=320
; --> the first part indents the page with ordinary spaces
; --> to find spaces take TOTAL_DOTS_PER_LINE - 320. Then / BITS_PER_CHARACTER
; --> Divide this by two and you have the spaces to indent
BP1     MACRO
        MOV     CX,13   ; EPSON ( we've got 320 dots and 480 to work with
INLOP:  MOV     AL,20H  ; 480-320=160 / 6 dots per char. = 26.67 extra
        CALL    SEND2   ; so indent the picture 13 spaces to center
        LOOP    INLOP
        MOV     AL,27
        CALL    SEND2
        MOV     AL,75
        CALL    SEND2
        MOV     AL,64
        CALL    SEND2
        MOV     AL,1
        CALL    SEND2
        ENDM

; BP2.
; The LARGE print sends 400 bit plot bytes to the printer. On the EPSON:
; ESC K 144 1  hex 1b 4b 90 1  > 1*256+144=400
; FIND YOUR INDENT FOR 400 BITS
BP2     MACRO
        MOV     CX,6    ; EPSON ( we've got 400 dots and 480 to work with
INLOP2: MOV     AL,20H  ; 480-400=80 / 6 dots per char. = 13.33 extra
        CALL    SEND2   ; so indent the picture 6 spaces to center
        LOOP    INLOP2
        MOV     AL,27
        CALL    SEND2
        MOV     AL,75
        CALL    SEND2
        MOV     AL,144
        CALL    SEND2
        MOV     AL,1
        CALL    SEND2
        ENDM

; ****************************
; *   END OF -OTHER- SECTION *
; ****************************

;  ***************> START OF ACTUAL CODE <*****************

CSEG    SEGMENT 'CODE'
        ASSUME CS:CSEG
        ORG     100H            ; set up for .COM conversion
INIT    PROC    FAR             ; we're an interrupt routine
        JMP     INITIAL         ; so we have to set up first
BUFFER  DB      '         GRAFTRAX.COM v1.2',10,13
        DB      'EPSON MX-80 GRAFTRAX(tm) Screen Printer.',13,10
        DB      '   Left Sh. PrtSc. = LARGE GRAPHICS',13,10
        DB      '  Right Sh. PrtSc. = small graphics',13,10
        DB      ' Text screen uses regular ROM routine.',13,10
        DB      '   ESCape will exit GRAPHICS print.',13,10,'$'
GOWAIT  DW      0
WHERESI DW      0
PTFLAG  DB      0
ONEOR2  DB      0
DSTOR   DW      0
FUDGE   DD      0
INITIAL:
        MOV     AX,0    ; GET ADDR OF
        MOV     DS,AX   ; PRINT SCREEN ROUTINE
        MOV     SI,14H  ; IN ROM
        MOV     AX,[SI] ; from interrupt table in ram
        MOV     DX,AX   ; in case they change the ROM's!
        INC     SI
        INC     SI
        MOV     AX,[SI]
        MOV     DS,AX
        MOV     AL,0F1H ; MOVE IT TO
        MOV     AH,25H
        INT     21H     ; INT F1H described in Tech. Manual as unused vector
        MOV     AX,CS   ; RESET INT 5
        MOV     DS,AX   ; TO POINT TO
        MOV     AX,OFFSET START ; THIS ROUTINE
        MOV     DX,AX
        MOV     AL,5
        MOV     AH,25H  ; DOS routine to reset int. vector
        INT     21H
        MOV     AX,CS
        MOV     DS,AX
        MOV     AX,OFFSET BUFFER
        MOV     DX,AX
        MOV     AH,9
        INT     21H     ; PRINT GREETING
        MOV     AX,OFFSET LAST  ; last address here
        MOV     DX,AX
        INC     DX
        INT     27H     ; TERMINATE BUT STAY RESIDENT
INIT    ENDP
; --->  ACTUAL INTERRUPT ROUTINE STARTS HERE  <---
START   PROC    FAR     ; Start of main routine--Shift Prt.Sc hit.
        ASSUME CS:CSEG
        STI             ; This follows ROM routine real close
        PUSH    DS
        PUSH    AX      ;SAVE REGS
        PUSH    BX
        PUSH    CX
        PUSH    DX
        PUSH    DI
        PUSH    SI
        PUSH    BP
        MOV     BP,SP   ; Save in case of error for reset
        MOV     AX,50H  ; Check here first to see if
        MOV     DS,AX   ; routine is already in progress
        MOV     SI,0    ; otherwise it will be a mess.
        MOV     AL,01H
        CMP     [SI],AL
        JNZ     NXTS    ; if not we're go for routine
        JMP     EXIT    ; otherwise go back home.
NXTS:   MOV     [SI],AL ; if we're go don't let us start again until done.
        MOV     AH,15   ; Get the current video state.
        INT     10H     ; from the ROM routine,
        CMP     AL,4    ; AL=4-6 are all graphics so we're OK
        JZ      GRAPHIC
        CMP     AL,5
        JZ      GRAPHIC
        CMP     AL,6
        JZ      GRAPHIC
        MOV     AL,0    ; else reset and go to ROM routine.
        MOV     [SI],AL
        INT     0F1H    ; this is where we stored the ROM routine entry.
        JMP     EXIT    ; Do the ROM routine but come back here to leave.
GRAPHIC:
        MOV     AX,40H  ; Get the keyboard shift flag
        MOV     DS,AX   ; segment
        MOV     SI,17H  ; and address
        MOV     AX,[SI] ; pick it up
        AND     AX,3    ; get rid of other stuff
        CMP     AX,0    ; Mod. to create default small
        JNZ     GR1     ; for case where routine is called as
        MOV     AX,1    ; a subroutine.
GR1:    MOV     CS:ONEOR2,AL    ; store for later
        PUSH    AX      ; also here
        MOV     AL,0    ; make sure this starts out as NO print.
        MOV     CS:PTFLAG,AL
        MOV     DL,00H  ; These bits indicate whether R or L Shift is down
        MOV     DH,19H  ; 25 lines of graphic dots at 8 dots per line
        MOV     AX,0B800H ; stored in DX
        MOV     DS,AX   ;SET UP FOR SCREEN PEEK
; Printer setup section to change line spacing to 8/72" for continuous dots
        IF      EPSON
        MOV     AL,27   ; ESC
        CALL    SEND2   ; goes out through INT 17h to avoid DOS processing
        MOV     AL,65   ; A
        CALL    SEND2
        MOV     AL,8    ; 8
        CALL    SEND2
        ENDIF
        IF      CITOH   ; ESC T 16
        MOV     AL,27   ; ESC
        CALL    SEND2   ; goes out through INT 17h to avoid DOS processing
        MOV     AL,'T'  ; T
        CALL    SEND2
        MOV     AL,'1'  ; 1
        CALL    SEND2
        MOV     AL,'6'  ; 6
        CALL    SEND2
        MOV     AL,27
        CALL    SEND2
        MOV     AL,62   ; Set printer to unidirectional for dot alignment
        CALL    SEND2
        ENDIF
        IF      OTHER
        OLINE
        ENDIF
        POP     AX      ; get back which routine
        CMP     AL,2    ; Left Shift Prt Sc means LARGE graphic print
        JZ      MAIN2   ; so hop over there if so.
; START OF small GRAPHICS PRINT ROUTINE.
; This routine scans across the screen from left to right,
; building an EPSON bit plot byte out of IBM screen dots.
; EPSON wire head               IBM screen color dots
; TOP    o  128  80h bit 7      | 00 | 01 | 10 | 11 | = 4 dots, one byte
;        o   64  40h  "  6
; one    o   32  20h  "  5      ibm dots go one raster line then the next
; bit    o   16  10h  "  4      EVEN line, ie 0, 2, 4 etc.
; plot   o    8  08h  "  3
; byte   o    4  04h  "  2      then you go back and do 1, 3, 5 etc.
;        o    2  02h  "  1
; BOTTOM o    1  01h  "  0      At loc. 0000h are 4 dots, 0,0|0,1|0,2|0,3
;                               At loc. 2000h are 4 dots, 1,0|1,1|1,2|1,3
;
MAIN:   MOV     CX,80   ; 80 x 4 = 320 dots.
MLOOP:  MOV     DL,0C0H ; 11000000b
        CALL    TST4    ; see if this comes back <> 0
        MOV     AL,AH   ; we are testing bit patterns for one screen byte
        CALL    SEND    ; don't send to printer unless something to send
        MOV     DL,30H  ; 00110000b
        CALL    TST4    ; each byte is 4 dots
        MOV     AL,AH   ; so we test for each dot in a byte
        CALL    SEND    ; send sets PTFLAG if there is a dot on the line
        MOV     DL,0CH  ; 00001100b
        CALL    TST4    ; then resets to start of line and starts printing
        MOV     AL,AH   ; AL is the bit plot byte being built
        CALL    SEND
        MOV     DL,03H  ; 00000011b
        CALL    TST4    ; TST4 scans down 8 screen dot lines each time called
        MOV     AL,AH
        CALL    SEND
        LOOP    MLOOP   ; 80 bytes make 320 dots
        CALL    LFCR    ; this is a good old regular line feed/carriage return
        CALL    BREAK?  ; see if someone hit ESC key. If so take early exit
        OR      AL,AL
        DEC     DH      ; DL is line counter
        CMP     DH,0    ; when it goes 0 we're through
        JZ      DONE    ; reset everything and do an IRET
        MOV     AX,DS   ; otherwise bump the SEGMENT reg so that location
        ADD     AX,14H  ; 0 is the start of the next line
        MOV     DS,AX   ; X'140' = 320
        JMP     MAIN    ; and do this 80 times (80x4=320)
DONE:   MOV     AX,0
; This is the common exit for both routines, Printer is restored.
DONE1:  PUSH    AX      ; save AX cause it has error exit flag
; EPSON command to reset printer to 6 lines/in. = ESC 2 (1b 32)
        IF      EPSON
        MOV     AL,27   ; RESET PRINTER, RESTORE REGS
        CALL    SEND2
        MOV     AL,32H
        CALL    SEND2
        ENDIF
; FOR CITOH MAKE SURE BIDIRECTIONAL PRINTING IS RESTORED
        IF      CITOH
        MOV     AL,27
        CALL    SEND2
        MOV     AL,'A'
        CALL    SEND2
        MOV     AL,27
        CALL    SEND2
        MOV     AL,60
        CALL    SEND2
        ENDIF
        IF      OTHER
        ORLINE
        ENDIF
EDONE:  MOV     AX,50H  ; Set end of PrtSc indication
        MOV     DS,AX   ; OK to come back and do again
        MOV     SI,0
        POP     AX
        MOV     [SI],AL
EXIT:   POP     BP
        POP     SI      ; restore regs and return to caller
        POP     DI
        POP     DX
        POP     CX
        POP     BX
        POP     AX
        POP     DS
        IRET            ; were an interrupt routine so we IRET
; START OF LARGE PRINT ROUTINE
; +-------------+
; | ^ ^         |  This time we scan from 199,0 to 0,0
; | ^ ^         |  and go across
; | ^ ^         |  o  o    x  x    o  x    x  x   These are representations
; | | |         |  o  o    o  o    x  o    x  x   of one color dot.
; +-------------+    0       1       2       3     Palettes
MAIN2:  MOV     DH,80   ; we have 80 colunms x 25 lines here
        MOV     CS:WHERESI,3EF0H ; SI is our index
        MOV     SI,CS:WHERESI
MAIN2A: MOV     CX,64H  ; 100
MLOOP2: MOV     AL,[SI] ; idea is to get a byte starting at screen BOTTOM
        IF      BIT0
        CALL    REVERSE ; Bits have to be reversed on wire 0 type
        ENDIF
        CALL    SEND    ; send it since these resemble bit plot bytes
        CALL    FLIPFLOP ; then reverse(sort of) this byte and send it
        CALL    SEND    ; again.
        MOV     CS:GOWAIT,SI ; store SI for next EVEN raster line
        SUB     SI,2000H ; subtract 2000h for the next ODD raster line
        MOV     AL,[SI] ; and do the same here
        IF      BIT0
        CALL    REVERSE
        ENDIF
        CALL    SEND
        CALL    FLIPFLOP
        CALL    SEND
        MOV     SI,CS:GOWAIT ; get back the EVEN line
        SUB     SI,80   ; advance UP the screen one line (say 199,0 to 197,0)
        LOOP    MLOOP2  ; and do this 100 times
        CALL    LFCR    ; finished with one line we send normal line-end
        CALL    BREAK?  ; check for an ESC if we want to abort
        OR      AL,AL   ; clear flags
        DEC     DH      ; DH is our line counter,
        CMP     DH,0    ; when it goes 0 we're done.
        JZ      TOF     ; so we'll try to reset Top of Form and exit
        INC     CS:WHERESI      ; else go to the next byte location
        MOV     SI,CS:WHERESI   ; store
        JMP     MAIN2A          ; and do again
TOF:    MOV     CX,19   ; tof restores page to 11 inches from where it started
TOFL:   MOV     AL,13   ; send a bunch of cr's and lf's
        CALL    SEND2   ; put BREAK? in here somehow
        MOV     AL,10
        CALL    SEND2
        CALL    BREAK?  ; check for early exit
        LOOP    TOFL    ; on and on.
; This restores the EPSON to 6 lines per inch
; ESC @ = Restore all settings to default
        IF      EPSON
        MOV     AL,27   ; esc
        CALL    SEND2
        MOV     AL,64   ; @
        CALL    SEND2
        ENDIF
;       IF      CITOH   ; No equivalent to Epson ESC @
;       MOV     AL,27   ; for CITOH
;       CALL    SEND2   ; so just reset line feed pitch
;       MOV     AL,'A'  ; this is done by DONE anyway
;       CALL    SEND2   ; so leave open if someone wants to patch
;       ENDIF
        IF      OTHER
        ORESET
        ENDIF
        JMP     DONE    ; clean up and back to caller.
START   ENDP
SEND2   PROC    NEAR    ; BIOS routine to print the character in AL
        PUSH    AX
        MOV     AH,00H  ; 0=print, 1=initialize port, 2=read status to AH
        PUSH    DX
        MOV     DX,0    ; DX specifies printer 0 (LPT1:)
        INT     17H     ; BIOS used instead of DOS because DOS sends
        POP     DX      ; CR/LF's in the middle of the bit-plots
        TEST    AH,29h  ; check for timeout or errors or out-of-paper
        POP     AX
        JNZ     ERRET
        RET
ERRET:  MOV     AX,00FFH ; Flag for printer foulup
        MOV     SP,BP
        PUSH    AX
        JMP     EDONE   ; special abort
SEND2   ENDP
; EPSON bit plots operate at 480 or 960 dots across the page
; called by ESC K 'low byte';'high byte'
;  i.e.  300 dots would be 256+44 or 012CH
;  This is sent to the EPSON as --> 1b 4b 2c 01
;               or in decimal   --> 27 75 44 1
INDENT  PROC    NEAR
        PUSH    CX      ; 13 SPACES IN TO CENTER
        IF      EPSON
        MOV     CX,13   ; PICTURE ( we've got 320 dots and 480 to work with
INLOP:  MOV     AL,20H  ; 480-320=160 / 6 dots per char. = 26.67 extra
        CALL    SEND2   ; so indent the picture 13 spaces to center
        LOOP    INLOP
; ESC K 64 1  = 256+64=320 bit plot type bytes on the way
        MOV     AL,27   ; SEQUENCE TO SET UP 320
        CALL    SEND2   ; BIT PLOTS IN 480 MODE
        MOV     AL,75   ; OF MX-80
        CALL    SEND2   ; This is the set-up for the small print
        MOV     AL,64
        CALL    SEND2
        MOV     AL,1
        CALL    SEND2
        ENDIF
        IF      CITOH
        MOV     AL,27   ; ESC N = Pica pitch
        CALL    SEND2
        MOV     AL,'N'
        CALL    SEND2
        MOV     CX,20   ; PICTURE ( we've got 320 dots and 640 to work with
INLOP:  MOV     AL,20H  ; 640-320=320 / 8 dots per char. = 40 extra
        CALL    SEND2   ; so indent the picture 13 spaces to center
        LOOP    INLOP
; ESC S 0320 = 320 bit plot type bytes on the way
        MOV     AL,27   ; SEQUENCE TO SET UP 320
        CALL    SEND2   ; BIT PLOTS IN 640 MODE
        MOV     AL,'S'  ; OF CITOH
        CALL    SEND2   ; This is the set-up for the small print
        MOV     AL,'0'  ; Would love to try to use all 640 bits here
        CALL    SEND2   ; but have no way of testing routine.
        MOV     AL,'3'
        CALL    SEND2
        MOV     AL,'2'
        CALL    SEND2
        MOV     AL,'0'
        CALL    SEND2
        ENDIF
        IF      OTHER
        BP1
        ENDIF
        POP     CX
        RET
INDENT  ENDP
; This is indent for LARGE print
; This time we have 400 bit plots to send (200 lines x 2)
; 480-400=80 / 6 = 13.3 extra
INDENT2 PROC    NEAR
        PUSH    CX
        IF      EPSON
        MOV     CX,6    ; so indent 6 character type spaces
INLOP2: MOV     AL,20H
        CALL    SEND2
        LOOP    INLOP2
; ESC 27 K 144 1 = 256+144=400 bit-plots
        MOV     AL,27
        CALL    SEND2
        MOV     AL,75
        CALL    SEND2
        MOV     AL,144
        CALL    SEND2
        MOV     AL,1
        CALL    SEND2
        ENDIF
; 640-400=240 / 8 = 30 EXTRA characters
        IF      CITOH
        MOV     AL,27   ; ESC N = Pica pitch
        CALL    SEND2
        MOV     AL,'N'
        CALL    SEND2
        MOV     CX,15   ; PICTURE ( we've got 400 dots and 640 to work with
INLOP2: MOV     AL,20H  ; 640-400 / 8 dots per char. = 30 extra
        CALL    SEND2   ; so indent the picture 15 spaces to center
        LOOP    INLOP2
; ESC S 0400 = 400 bit plot type bytes on the way
        MOV     AL,27   ; SEQUENCE TO SET UP 400
        CALL    SEND2   ; BIT PLOTS IN 640 MODE
        MOV     AL,'S'  ; OF CITOH
        CALL    SEND2
        MOV     AL,'0'
        CALL    SEND2
        MOV     AL,'4'
        CALL    SEND2
        MOV     AL,'0'
        CALL    SEND2
        MOV     AL,'0'
        CALL    SEND2
        ENDIF
        IF      OTHER
        BP2
        ENDIF
        POP     CX
        RET
INDENT2 ENDP
TST4    PROC    NEAR    ;  This routine builds ONE bit plot byte
        MOV     AX,80   ;  by testing a dot with the mask sent
        SUB     AX,CX   ;  from MLOOP.
        MOV     SI,AX   ;  First it does the ODD row then the EVEN
        MOV     AH,0    ;  since alternate lines are offset 2000h
        MOV     AL,[SI] ;  from each other in memory.
        AND     AL,DL   ;  DL has the mask
        CMP     AL,0    ;  SI the location
        JZ      NO7     ;  AL the memory byte
        CALL    SET7    ;  AH is the byte being built
NO7:    ADD     SI,80   ; +80 gets us from say 0,0 to 2,0
        MOV     AL,[SI] ; get the memory byte ( 4 dots )
        AND     AL,DL   ; get rid of dots we aren't testing now
        CMP     AL,0    ; see if its COLOR 0
        JZ      NO5     ; if yes, go on
        CALL    SET5    ; otherwise set that bit
NO5:    ADD     SI,80   ; continue 7 5 3 1
        MOV     AL,[SI]
        AND     AL,DL
        CMP     AL,0
        JZ      NO3
        CALL    SET3
NO3:    ADD     SI,80
        MOV     AL,[SI]
        AND     AL,DL
        CMP     AL,0
        JZ      NO1
        CALL    SET1
NO1:    PUSH    AX
        MOV     AX,80
        SUB     AX,CX   ; CX counts our screen position
        ADD     AX,2000H ; add 2000h for the EVEN rows
        MOV     SI,AX   ; with seg set to B800h we can use SI like an
        POP     AX      ; array pointer ( AH has our byte so don't lose )
        MOV     AL,[SI] ; and continue with the same idea for 6 4 2 0
        AND     AL,DL
        CMP     AL,0
        JZ      NO6
        CALL    SET6
NO6:    ADD     SI,80
        MOV     AL,[SI]
        AND     AL,DL
        CMP     AL,0
        JZ      NO4
        CALL    SET4
NO4:    ADD     SI,80
        MOV     AL,[SI]
        AND     AL,DL
        CMP     AL,0
        JZ      NO2
        CALL    SET2
NO2:    ADD     SI,80
        MOV     AL,[SI]
        AND     AL,DL
        CMP     AL,0
        JZ      NO0
        CALL    SET0
NO0:    RET
; where's my Z80 now
; reverse this table if your bit plots use bit 0 for the top wire
        IF      BIT7
SET7:   OR      AH,80H  ; top wire - bit 7
        RET
SET6:   OR      AH,40H  ; bit 6
        RET
SET5:   OR      AH,20H  ; bit 5
        RET
SET4:   OR      AH,10H  ; bit 4
        RET
SET3:   OR      AH,08H  ; bit 3
        RET
SET2:   OR      AH,04H  ; bit 2
        RET
SET1:   OR      AH,02H  ; bit 1
        RET
SET0:   OR      AH,01H  ; bit 0
        RET
        ENDIF
        IF      BIT0
SET7:   OR      AH,01H  ; top wire - bit 0
        RET
SET6:   OR      AH,02H  ; bit 1
        RET
SET5:   OR      AH,04H  ; bit 2
        RET
SET4:   OR      AH,08H  ; bit 3
        RET
SET3:   OR      AH,10H  ; bit 4
        RET
SET2:   OR      AH,20H  ; bit 5
        RET
SET1:   OR      AH,40H  ; bit 6
        RET
SET0:   OR      AH,80H  ; bit 7
        RET
        ENDIF
TST4    ENDP
; This routine pre-scans a line to see if in fact there are any bit
; plots to send. The main routine will keep sending bytes here
; If a whole line of 0's are sent we avoid going through the
; set-up for bit-plot (i.e. slower movement) graphics when a CR/LF
; would take care of everything.
; If there IS something to send, PTFLAG is set, the current line
; position is set to 0, bit-plot is init., and bits are really sent to printer.
SEND    PROC    NEAR
        PUSH    AX      ; save the character
        PUSH    DS      ; DS saved cause it points to lines
        MOV     AX,CS   ; set seg for here
        MOV     DS,AX   ; This was some of my first stuff with the 8088
        POP     AX      ; and I see some needless complexity here now
        MOV     CS:DSTOR,AX     ; but it works and if I mess with it
        CMP     CS:PTFLAG,0FFH  ; its back to DEBUG.
        JNZ     NOSEND  ; if PTFLAG isn't FFh we are still scanning
        POP     AX      ; else get the char. in AL and print it
        CALL    SEND2   ; this is the real out to printer routine
        JMP     SHORT NOSET ; restore DS and return
NOSEND: POP     AX      ; This is the SCAN routine
        CMP     AL,0    ; get the char. > test for 0 > if so reset and go back
        JZ      NOSET
        MOV     AL,0FFH ; if <> 0
        MOV     CS:PTFLAG,AL ; set PTFLAG to go
        POP     AX      ;DISCARD RETURN
        CMP     CS:ONEOR2,1 ; check which (small or LARGE)
        JNZ     TWO     ; indent 6 or 13 depending on which routine
        CALL    INDENT  ; indent also sets up bit-plot mode
        CALL    NOSET   ; NOSET will restore DS to right pos.
        JMP     MAIN    ; and do the line for real.
TWO:    CALL    INDENT2 ; init. for LARGE
        MOV     SI,CS:WHERESI   ; SI set back to start of line
        CALL    NOSET   ; get right DS
        JMP     MAIN2A  ; back to beginning
NOSET:  PUSH    AX      ; routine to restore DS
        MOV     AX,CS:DSTOR
        MOV     DS,AX
        POP     AX
        RET
SEND    ENDP
LFCR    PROC    NEAR    ; send a regular CR/LF combo
        MOV     AL,13
        CALL    SEND2
        MOV     AL,10
        CALL    SEND2
        MOV     AX,0
        MOV     CS:PTFLAG,AL ; reset PTFLAG for next line
        MOV     AX,CS:DSTOR  ; restore DS
        MOV     DS,AX
        RET             ; onward
LFCR    ENDP
BREAK?  PROC    NEAR    ; Test for early exit
        PUSH    AX      ; don't lose any regs. here
        PUSH    DX
        MOV     AH,06H  ; call direct keyboard io (constat)
        MOV     DL,0FFH ; if we got a char. go check it.
        INT     21H
        JNZ     GOBACK? ; if zero flag clear we have a character
BCONT:  POP     DX      ; no char. return
        POP     AX
        RET
GOBACK?:
        CMP     AL,1BH  ; ESC
        JZ      BACK    ; so go back, else return
        JMP     SHORT BCONT     ; no ESC exit
BACK:   POP     DX      ; ESC exit This doesn't check for Ctrl-Break
        POP     AX      ; so if it is hit we save it for the caller to handle
        POP     AX      ;DISCARD RETURN
        JMP     DONE    ; and go back to orig. caller
BREAK?  ENDP
FLIPFLOP        PROC NEAR       ; This creates different combinations
        PUSH    CX      ; of a box of four bit-plot dots for one color dot.
        PUSH    BX      ; Don't lose any variables or loop counters
        PUSH    AX
        MOV     CL,2    ; AL has present bit-plot finished byte
        MOV     BX,0
        AND     AL,3    ; 00000011b
        CALL    FLIP
        ROR     BL,CL   ; 11000000b
        POP     AX      ; basically rotate bits around for
        PUSH    AX      ; o x
        CALL    R2      ; x o   color 1
        AND     AL,3    ; and
        CALL    FLIP    ; o x
        ROR     BL,CL   ; o x   color 2
        POP     AX      ; instead of
        PUSH    AX      ; x o
        CALL    R4      ; x o   color 1
        AND     AL,3    ; and
        CALL    FLIP    ; o x
        ROR     BL,CL   ; o x   color 2
        POP     AX      ; which aren't to convincing as
        CALL    R6      ; two different colors
        AND     AL,3
        CALL    FLIP
        ROR     BL,CL
        MOV     AL,BL
        POP     BX
        POP     CX
        RET
R6:     ROR     AL,CL
R4:     ROR     AL,CL
R2:     ROR     AL,CL
        RET
FLIP:   CMP     AL,3    ; make sure there are two dots for color 1 and 2
        JNZ     FLIP2
        OR      BL,3
FLIP2:  CMP     AL,2
        JNZ     FLIP3
        OR      BL,1
FLIP3:  CMP     AL,1
        JNZ     FLIP4
        OR      BL,1
FLIP4:  RET
FLIPFLOP        ENDP
REVERSE PROC    NEAR    ; take AL and make bit 0 bit 7 , 1 - 6, etc
        PUSH    DX      ; Save our counters and masks
        PUSH    CX
        MOV     DL,01H  ; 00000001B
        MOV     DH,80H  ; 10000000B
        MOV     AH,00H  ; start out blank
        MOV     CX,8    ; set counter for 8 times through
REV1:   TEST    AL,DL   ; see if bit is set
        JZ      REV2    ; if not skip next step
        OR      AH,DH   ; else set bit in AH
REV2:   SHL     DL,1    ; shift left test bit
        SHR     DH,1    ; shift right mask bit (pad other bits with 0)
        LOOP    REV1    ; do this 8 times
        MOV     AL,AH   ; and we have a reversed character.
        POP     CX      ; get back these
        POP     DX
        RET             ; and back to caller
REVERSE ENDP
LAST    DW      0
CSEG    ENDS
        END     INIT