home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Columbia Kermit
/
kermit.zip
/
archives
/
msvp98b1.lzh
/
MSGP98.ASM
next >
Wrap
Assembly Source File
|
1991-12-04
|
97KB
|
4,790 lines
;+ This is MSGP98.ASM
;
; Tektronix 4014 emulator for NEC-PC9801
; Author: Hirofumi Fujii (KEK On-line group)
;
; Last edited 17-Apr-1991
; 17-Apr-1991 Joe (and Rikitake) pointed out that tek_gtxt: should be
; 'tek_gtxt proc near'.
; 09-Mar-1991 Joe pointed out that CAN is reserved word for MASM 5.
; CAN -> CL_CAN
; SUB -> CL_SUB
; 01-Sep-1990 Start TEK4105 coding
; 09-Aug-1990 Add protection for coordinates in TEK40_DEV_COOD.
; 24-Jul-1990 for MS-Kermit v3.02
; 10-Jul-1990 ESC[1;30m gives white line for gnuplot v2.0
; 25-Jun-1990 Support for ESC [ XX ; YY ; .. ; ZZ m
; 30-May-1989 Fixed bug in background color.
; Reset command resets color to default (color in command mode).
; 21-Apr-1989 Cooked logging is added
; 13-Feb-1989 Fill 0FFh of all RAM of the GGDC when tek4014_save is called.
GGDC_STS_PORT equ 0A0h
GGDC_CMD_PORT equ 0A2h
GGDC_PRM_PORT equ 0A0h
GGDC_BLUE_PLANE equ 04000h
GGDC_RED_PLANE equ 08000h
GGDC_GREEN_PLANE equ 0C000h
GGDC_GIN_PLANE equ 04000h
GGDC_GCUR_PLANE equ 04000h
CPU_BLUE_PLANE equ 0A800h
CPU_RED_PLANE equ 0B000h
CPU_GREEN_PLANE equ 0B800h
CPU_EXTRA_PLANE equ 0E000h
TEK_X_MAX equ 4095
TEK_Y_MAX equ 3071
TEK_DX equ 56
TEK_DY equ 112
TEK41_NO_ACT equ 0
TEK41_XY_TYPE equ 1
TEK41_INT_TYPE equ 2
TEK41_STR_TYPE equ 3
TEK41_IAR_TYPE equ 4
TEK41_ARGBUF_SIZE equ 512
TEK41_FABUF_SIZE equ 1024
BS equ 008h
HT equ 009h
VT equ 00Bh
CL_CAN equ 018h
CL_SUB equ 01Ah
FS equ 01Ch
GS equ 01Dh
RS equ 01Eh
US equ 01Fh
HIY equ 020h
EXT equ 060h
LOY equ 060h
HIX equ 020h
LOX equ 040h
X_OFS equ 64
Y_OFS equ 8
SIXEL_IN_REPEAT equ 1
SIXEL_IN_PALETTE equ 2
SIXEL_YMAX equ 378 ; 24 x 16 - 6
SIXEL_XMAX equ 639
include mssdef.h
include msxp98.h
public tek4014,tek4014_ini,tek4014_reset
public tek4014_save, tek4014_restore, tek4014_modlin
public tek4014_color
public tekstat
public gdisp_on, gdisp_off, set_gcolor
public sixel, sixel_in, sixel_clear
public sixel_rollup, sixel_rolldown
public set_gpalette
data segment
extrn vt100_flags:byte, vt100_lflag:byte, vt100_gflag:byte
extrn vtgrph_flg:byte
extrn display_mode:byte
extrn gnrm_color:byte, gbck_color:byte ; in MSYP98.ASM
extrn def_color:byte, scn_color:byte
extrn vt100_cursr:word ; in MSXP98.ASM
gdisp_mode db 0 ; digital(0)/analogue(1) display
gplane_nums db 3 ; number of graphic planes (3 or 4)
gplane_actv dw 15 ; active plane mask
gplane_segm dw 0A800h ; CPU segment address of G-VRAM
dw 0B000h
dw 0B800h
dw 0E000h
;
pc98_mouse_type db 1
pc98_mouse_init db 0
pc98_mouse_char db 0,'1','2','3'
;
tek_dialog_area db 0
tek_dialog_vsbl db 0
;
; Color mode
; <int1> 0: no change <int2> 0: no change <int3> 0:nochange
; 1: RGB [0-100] 1: opake 1:color
; 2: CMY [0-100] 2: sub 2:monochrome
; 3: HLS 3: add
; 4: RGB [0-255]
;
tek_cmode_1 db 3
tek_cmode_2 db 1
tek_cmode_3 db 1
db 0 ; for alignment
;
; Window and Viewport (Ordering is important.)
;
tek_wnx1 dw 0
tek_wnx2 dw 4095
tek_wny1 dw 0
tek_wny2 dw 3071
;
tek_vpx1 dw 0
tek_vpx2 dw 4095
tek_vpy1 dw 0
tek_vpy2 dw 3071
;
; Transformation Matrix from Window to Viewport.
; 16-bit fixed decimal point number.
;
tek_w2v_mat dw 8 dup (?)
;
; Window/Viewport for GIN (Viewport must be first)
;
gin_vpx1 dw 0
gin_vpx2 dw 479
gin_vpy1 dw 0
gin_vpy2 dw 359
;
gin_wnx1 dw 0
gin_wnx2 dw 4095
gin_wny1 dw 0
gin_wny2 dw 3071
;
; Viewport to Window transformation matrix
;
gin_v2w_mat dw 8 dup (?)
;
;
; Character vectors
;
tek_gtxt_ang dw 0
tek_gtxt_w dw 39
tek_gtxt_h dw 52
tek_gtxt_s dw 13
tek_gtxt_dr db 2, 0 ; graph text dir for GDC
tek_gtxt_ux dw 52
tek_gtxt_uy dw 0
tek_gtxt_vx dw 0
tek_gtxt_vy dw 52
;
sixel_replace db 0, 1
sixel_state db 0
sixel_char db 0
sixel_on db 0
sixel_off db 0
sixel_x dw 0
sixel_y dw 0
repeat_count dw 0
sixel_pal_dest dw 0
sixel_palette dw 0, 0, 0, 0, 0
sixel_nbuf dw 0
sixel_byte dw 0
sixel_segm dw 0
;
vt_buf db 8 dup (?)
vt_dialog_clr db 7,ESCAPE,"[2J",ESCAPE,"[H"
;
tek_zero dw 0 ; Zero for clearing mode line
tek_cur_x dw 0 ; TEK current position x
tek_cur_y dw 0 ; TEK current position y
tek_req_x dw 0 ; TEK requested position x
tek_req_y dw 0 ; TEK requested position y
;
tek_lncol dw 1 ; TEK line color
tek_txcol dw 1 ; TEK text color
tek_facol dw 1 ; TEK fill area color
;
loc_x dw 0 ; locator position in DC
loc_y dw 0
loc_mov dw 0
;
tek_npnt dw 0
;
line_type dw 0
;
; NOTE:
; Bit 0 must be 1 if you want to start ON bit.
line_type_table dw 0FFFFh
dw 01111h
dw 02727h
dw 00F0Fh
dw 000FFh
dw 03E49h
dw 018FFh
dw 03333h
;
marker_type dw 0
;
tek41_cmd dw 0
tek41_func dw 0
tek41_nget dw 0
tek41_narg dw 0
tek41_nreq db 0 ; next requested data type
tek41_nact db 0 ; next action
tek41_argt db 8 dup (0)
tek41_ival dw 0
;
tek_P_prv db 0,0
tek_P_num dw 0
tek_P_pnt dw 0
tek_P_buf dw 32 dup (0)
;
tek_vseq db 0
tek_cur_HIY db 0
tek_cur_EXT db 0
tek_cur_LOY db 0
tek_cur_HIX db 0
tek_cur_LOX db 0
;
tek_mod db 0 ; 0=Alpha,1=Vector,2=Plot,3=Increment
tek_esc db 0 ; 1=TEK in esc-seq, 2= in CSI-seq
tek_byp db 0 ; 1=Bypass mode
tek_cur db 0 ; 0=Alpha cursor off, 1=on
tek_pen db 0 ; 0=Pen Up, 1=Pen down
tek_hgt db 0 ; 0=Normal, 1=HighLight
;
tek_inpanel db 0
tek_panel_bnd db 0
tek_famod db 0
tek_fapat db 0
;
tek_col0 db 0,1,2,3,4,5,6,7 ; default color index table
;
; Default Tek mode color table (R,G,B) [0-255]
;
tek_col_def db 000h,000h,000h ; 0:black
db 0ffh,0ffh,0ffh ; 1:white
db 0ffh,000h,000h ; 2:red
db 000h,0ffh,000h ; 3:green
db 000h,000h,0ffh ; 4:blue
db 000h,0ffh,0ffh ; 5:cyan
db 0ffh,000h,0ffh ; 6:magenta
db 0ffh,0ffh,000h ; 7:yellow
db 0ffh,0afh,000h ; 8:orange
db 0afh,0ffh,000h ; 9:yellow-green
db 000h,0ffh,0afh ; 10:green-cyan
db 000h,0afh,0ffh ; 11:blue-cyan
db 0afh,000h,0ffh ; 12:blue-magenta
db 0ffh,000h,0afh ; 13:red-magenta
db 07fh,07fh,07fh ; 14:dark-gray
db 0afh,0afh,0afh ; 15:light-gray
;
; Tek mode color table (R,G,B) [0-255]
;
tek_col db 000h,000h,000h ; 0:black
db 0ffh,0ffh,0ffh ; 1:white
db 0ffh,000h,000h ; 2:red
db 000h,0ffh,000h ; 3:green
db 000h,000h,0ffh ; 4:blue
db 000h,0ffh,0ffh ; 5:cyan
db 0ffh,000h,0ffh ; 6:magenta
db 0ffh,0ffh,000h ; 7:yellow
db 0ffh,0afh,000h ; 8:orange
db 0afh,0ffh,000h ; 9:yellow-green
db 000h,0ffh,0afh ; 10:green-cyan
db 000h,0afh,0ffh ; 11:blue-cyan
db 0afh,000h,0ffh ; 12:blue-magenta
db 0ffh,000h,0afh ; 13:red-magenta
db 07fh,07fh,07fh ; 14:dark-gray
db 0afh,0afh,0afh ; 15:light-gray
;
; Sixel mode color table (R,G,B) [0-255]
; Note that only plane #3 is used for sixel.
;
sixel_col0 db 000h,000h,000h ; 0:black
db 000h,000h,000h ; 1
db 000h,000h,000h ; 2
db 000h,000h,000h ; 3
db 0ffh,0ffh,0ffh ; 4
db 0ffh,0ffh,0ffh ; 5
db 0ffh,0ffh,0ffh ; 6
db 0ffh,0ffh,0ffh ; 7
db 000h,000h,000h ; 8
db 000h,000h,000h ; 9
db 000h,000h,000h ; 10
db 000h,000h,000h ; 11
db 0ffh,0ffh,0ffh ; 12
db 0ffh,0ffh,0ffh ; 13
db 0ffh,0ffh,0ffh ; 14
db 0ffh,0ffh,0ffh ; 15
;
sixel_col db 000h,000h,000h ; 0:black
db 000h,000h,000h ; 1
db 000h,000h,000h ; 2
db 000h,000h,000h ; 3
db 0ffh,0ffh,0ffh ; 4
db 0ffh,0ffh,0ffh ; 5
db 0ffh,0ffh,0ffh ; 6
db 0ffh,0ffh,0ffh ; 7
db 000h,000h,000h ; 8
db 000h,000h,000h ; 9
db 000h,000h,000h ; 10
db 000h,000h,000h ; 11
db 0ffh,0ffh,0ffh ; 12
db 0ffh,0ffh,0ffh ; 13
db 0ffh,0ffh,0ffh ; 14
db 0ffh,0ffh,0ffh ; 15
;
tek41_col db 0,7,2,4,1,5,3,6
db 7,7,2,4,1,5,3,6
;
disp_bank db 0
actv_bank db 0
;
tek41_larg dw 0
tek41_argbuf db TEK41_ARGBUF_SIZE dup (?)
dw 0 ; for guard
tek41_lstr dw 0 ; string length
tek41_nchr dw 0 ; number of char gotten
tek41_liar dw 0 ; INT array size
tek41_niar dw 0 ; number of INT gotten
tek41_faadr dw 0
tek41_numbnd dw 0
tek41_nfa dw 0
tek41_lfa dw 0
tek41_fabuf db TEK41_FABUF_SIZE dup (?)
;
scan_n dw 0 ; number of lines
scan_x dw 0
scan_y dw 0
scan_ofs dw 0 ; offset address in the graphic plane
scan_xstr dw 0
scan_xlen dw 0
scan_xmin dw 0
scan_xmax dw 0
scan_ymin dw 0
scan_ymax dw 0
;
scan_buf db 80 dup (?)
scan_fil db 0, 0
;
pc98_x1 dw 0
pc98_y1 dw 0
pc98_x2 dw 0
pc98_y2 dw 0
;
HLS_n1 dw 0
HLS_n2 dw 0
;
ggdc_buff db 80 dup (?)
loc_x_buff db 32 dup (?)
loc_y_buff db 32 dup (?)
alp_cur_buff db 48 dup (?)
;
alp_cur_font db 000h,000h,000h,000h,000h,07eh,07eh,000h
;
GDC_plane_address db 040h, 080h, 0C0h, 000h
col_indx_tab_N db 0, 2, 4, 6, 1, 3, 5, 7 ; color index for Normal
col_indx_tab_H db 7, 2, 4, 6, 1, 3, 5, 7 ; color index for HighLight
;
ext_gin db 023h,000h,0FFh,000h
ent_gin db 021h,000h ; complement
db 078h,008h
db 0FFh,0FFh,0FFh,0FFh,0FFh,0FFh,0FFh,0FFh
db 0FFh,000h
gin_ans db 006h,020h,020h,020h,020h,020h,00Dh,004h
;
ggdc_solid db 078h,008h
db 0FFh,0FFh,0FFh,0FFh,0FFh,0FFh,0FFh,0FFh
db 0FFh,000h
ggdc_on db 00Dh,000h,0FFh,000h
ggdc_off db 00Ch,000h,0FFh,000h
;
ggdc_set db 04Bh,001h,000h ; CSFORM
db 070h,004h,000h,000h,000h,019h ; SCROLL
db 023h,000h ; WRITE MODE SET
db 0FFh ; terminator
;
bit_on db 080h, 040h, 020h, 010h, 008h, 004h, 002h, 001h
bit_off db 07Fh, 0BFh, 0DFh, 0EFh, 0F7h, 0FBh, 0FDh, 0FEh
;------------------------------------------------------------------------------
; 8 x 8 marker font
;
; offset
;
mark_dx dw -4
mark_dy dw 4
;
gmark88 db 000h,000h,000h,008h,000h,000h,000h,000h ; dot
db 000h,000h,008h,01ch,008h,000h,000h,000h ; small plus
db 008h,008h,008h,07fh,008h,008h,008h,000h ; large plus
db 041h,022h,014h,07fh,014h,022h,041h,000h ; star
db 01ch,022h,041h,041h,041h,022h,01ch,000h ; circle
db 041h,022h,014h,008h,014h,022h,041h,000h ; cross
db 07fh,041h,041h,041h,041h,041h,07fh,000h ; square
db 008h,014h,022h,041h,022h,014h,008h,000h ;
db 07fh,041h,049h,05dh,049h,041h,07fh,000h ; square-dot
db 008h,014h,02ah,05dh,02ah,014h,008h,000h ;
db 07fh,063h,055h,049h,055h,063h,07fh,000h ; square-cross
;------------------------------------------------------------------------------
; text font table (8 x 8)
;
gfont88 db 000h,000h,000h,000h,000h,000h,000h,000h ; space
db 008h,008h,008h,008h,000h,000h,008h,000h ; !
db 022h,022h,022h,000h,000h,000h,000h,000h ; "
db 024h,024h,07eh,024h,07eh,024h,024h,000h ; #
db 008h,07eh,009h,03eh,048h,03fh,008h,000h ; $
db 043h,021h,010h,008h,004h,042h,061h,000h ; %
db 006h,009h,009h,006h,049h,031h,04eh,000h ; &
db 018h,010h,008h,000h,000h,000h,000h,000h ; '
db 010h,008h,004h,004h,004h,008h,010h,000h ; (
db 004h,008h,010h,010h,010h,008h,004h,000h ; )
db 000h,022h,014h,07fh,014h,022h,000h,000h ; *
db 000h,008h,008h,07fh,008h,008h,000h,000h ; +
db 000h,000h,000h,000h,00ch,008h,004h,000h ; ,
db 000h,000h,000h,03eh,000h,000h,000h,000h ; -
db 000h,000h,000h,000h,000h,00ch,00ch,000h ; .
db 040h,020h,010h,008h,004h,002h,001h,000h ; /
db 03ch,062h,052h,05ah,046h,046h,03ch,000h ; 0
db 008h,00ch,008h,008h,008h,008h,01ch,000h ; 1
db 01ch,022h,020h,018h,004h,002h,03eh,000h ; 2
db 03eh,020h,010h,018h,020h,022h,01ch,000h ; 3
db 010h,018h,014h,012h,03fh,010h,010h,000h ; 4
db 03eh,002h,01eh,022h,020h,022h,01ch,000h ; 5
db 018h,004h,002h,01eh,022h,022h,01ch,000h ; 6
db 03eh,020h,010h,008h,004h,004h,004h,000h ; 7
db 03ch,042h,042h,03ch,042h,042h,03ch,000h ; 8
db 01ch,022h,022h,03ch,020h,010h,008h,000h ; 9
db 000h,00ch,00ch,000h,00ch,00ch,000h,000h ; :
db 000h,00ch,00ch,000h,00ch,008h,004h,000h ; ;
db 020h,010h,008h,004h,008h,010h,020h,000h ; <
db 000h,000h,07eh,000h,07eh,000h,000h,000h ; =
db 002h,004h,008h,010h,008h,004h,002h,000h ; >
db 03ch,042h,030h,008h,008h,000h,008h,000h ; ?
db 03ch,042h,071h,049h,039h,002h,03ch,000h ; @
db 01ch,022h,022h,03eh,022h,022h,022h,000h ; A
db 01fh,022h,022h,01eh,022h,022h,01fh,000h ; B
db 01ch,022h,002h,002h,002h,022h,01ch,000h ; C
db 01fh,022h,022h,022h,022h,022h,01fh,000h ; D
db 03eh,002h,002h,01eh,002h,002h,03eh,000h ; E
db 03eh,002h,002h,01eh,002h,002h,002h,000h ; F
db 01ch,022h,002h,002h,072h,022h,01ch,000h ; G
db 022h,022h,022h,03eh,022h,022h,022h,000h ; H
db 01ch,008h,008h,008h,008h,008h,01ch,000h ; I
db 070h,020h,020h,020h,022h,022h,01ch,000h ; J
db 042h,022h,012h,00eh,012h,022h,042h,000h ; K
db 002h,002h,002h,002h,002h,002h,03eh,000h ; L
db 041h,063h,055h,049h,041h,041h,041h,000h ; M
db 042h,046h,04ah,052h,062h,042h,042h,000h ; N
db 01ch,022h,022h,022h,022h,022h,01ch,000h ; O
db 01eh,022h,022h,01eh,002h,002h,002h,000h ; P
db 03ch,042h,042h,042h,052h,022h,05ch,000h ; Q
db 01eh,022h,022h,01eh,012h,022h,042h,000h ; R
db 01ch,022h,002h,01ch,020h,022h,01ch,000h ; S
db 03eh,008h,008h,008h,008h,008h,008h,000h ; T
db 022h,022h,022h,022h,022h,022h,01ch,000h ; U
db 041h,041h,022h,022h,014h,014h,008h,000h ; V
db 041h,041h,041h,041h,049h,055h,022h,000h ; W
db 041h,022h,014h,008h,014h,022h,041h,000h ; X
db 041h,022h,014h,008h,008h,008h,008h,000h ; Y
db 03eh,020h,010h,008h,004h,002h,03eh,000h ; Z
db 038h,008h,008h,008h,008h,008h,038h,000h ; [
db 001h,002h,004h,008h,010h,020h,040h,000h ; backslash
db 00eh,008h,008h,008h,008h,008h,00eh,000h ; ]
db 008h,014h,022h,000h,000h,000h,000h,000h ; ^
db 000h,000h,000h,000h,000h,000h,07fh,000h ; _
db 018h,008h,000h,000h,000h,000h,000h,000h ; left quote
db 000h,000h,01ch,020h,03ch,022h,07ch,000h ; a
db 002h,002h,01ah,026h,022h,022h,01eh,000h ; b
db 000h,000h,01ch,022h,002h,002h,03ch,000h ; c
db 020h,020h,02ch,032h,022h,022h,03ch,000h ; d
db 000h,000h,01ch,022h,01eh,002h,03ch,000h ; e
db 038h,044h,004h,01eh,004h,004h,004h,000h ; f
db 000h,000h,01ch,022h,022h,03ch,022h,01ch ; g
db 002h,002h,01ah,026h,022h,022h,022h,000h ; h
db 008h,000h,008h,008h,008h,008h,010h,000h ; i
db 020h,000h,020h,020h,020h,020h,022h,01ch ; j
db 002h,002h,022h,012h,01ah,026h,042h,000h ; k
db 008h,008h,008h,008h,008h,008h,010h,000h ; l
db 000h,000h,037h,049h,049h,049h,041h,000h ; m
db 000h,000h,03ah,046h,042h,042h,042h,000h ; n
db 000h,000h,01ch,022h,022h,022h,01ch,000h ; o
db 000h,000h,01eh,022h,022h,01eh,002h,002h ; p
db 000h,000h,01ch,022h,022h,03ch,020h,060h ; q
db 000h,000h,03ah,046h,002h,002h,002h,000h ; r
db 000h,000h,03ch,002h,01ch,020h,01eh,000h ; s
db 008h,008h,03eh,008h,008h,008h,030h,000h ; t
db 000h,000h,022h,022h,022h,022h,05ch,000h ; u
db 000h,000h,022h,022h,022h,014h,008h,000h ; v
db 000h,000h,041h,041h,049h,049h,036h,000h ; w
db 000h,000h,022h,014h,008h,014h,022h,000h ; x
db 000h,000h,022h,022h,022h,03ch,022h,01ch ; y
db 000h,000h,03eh,010h,008h,004h,03eh,000h ; z
db 030h,008h,010h,00eh,010h,008h,030h,000h ; {
db 008h,008h,008h,000h,008h,008h,008h,000h ; |
db 006h,008h,004h,038h,004h,008h,006h,000h ; }
db 000h,040h,03ch,002h,000h,000h,000h,000h ; ~
db 012h,049h,024h,012h,049h,024h,012h,049h ; del
;---------------------------------------------------------------------------
func41 dw 'LE'
dw tek41_exec_LE
db 0,0,0,0,0,0
;
dw 'LP'
dw tek41_exec_LP
db 2,TEK41_XY_TYPE,TEK41_INT_TYPE,0,0,0
;
dw 'LV'
dw tek41_exec_LV
db 1,TEK41_INT_TYPE,0,0,0,0
;
dw 'LZ'
dw tek41_exec_LZ
db 0,0,0,0,0,0
;
dw 'KA'
dw tek41_exec_KA
db 1,TEK41_INT_TYPE,0,0,0,0
;
dw 'LG' ; draw
dw tek41_exec_LG
db 1,TEK41_XY_TYPE,0,0,0,0
;
dw 'LF' ; move
dw tek41_exec_LF
db 1,TEK41_XY_TYPE,0,0,0,0
;
dw 'LH' ; marker
dw tek41_exec_LH
db 1,TEK41_XY_TYPE,0,0,0,0
;
dw 'LT' ; graphic text
dw tek41_exec_LT
db 1,TEK41_STR_TYPE,0,0,0,0
;
dw 'MC' ; set graphtext size
dw tek41_exec_MC
db 3,TEK41_INT_TYPE,TEK41_INT_TYPE,TEK41_INT_TYPE,0,0
;
dw 'ML' ; set line color index
dw tek41_exec_ML
db 1,TEK41_INT_TYPE,0,0,0,0
;
dw 'MM' ; set marker type
dw tek41_exec_MM
db 1,TEK41_INT_TYPE,0,0,0,0
;
dw 'MP' ; set fill pattern
dw tek41_exec_MP
db 1,TEK41_INT_TYPE,0,0,0,0
;
dw 'MR' ; set graphtext rotation
dw tek41_exec_MR
db 2,TEK41_INT_TYPE,TEK41_INT_TYPE,0,0,0
;
dw 'MT' ; set text color index
dw tek41_exec_MT
db 1,TEK41_INT_TYPE,0,0,0,0
;
dw 'MV' ; set line style
dw tek41_exec_MV
db 1,TEK41_INT_TYPE,0,0,0,0
;
dw 'NM' ; set prompt mode
dw tek41_exec_none
db 1,TEK41_INT_TYPE,0,0,0,0
;
dw 'RW' ; set window
dw tek41_exec_RW
db 2,TEK41_XY_TYPE,TEK41_XY_TYPE,0,0,0
;
dw 'TG' ; set surface color map
dw tek41_exec_TG
db 2,TEK41_INT_TYPE,TEK41_IAR_TYPE,0,0,0
;
dw 'TM' ; set color mode
dw tek41_exec_TM
db 3,TEK41_INT_TYPE,TEK41_INT_TYPE,TEK41_INT_TYPE,0,0
;
dw '%!' ; set command
dw tek41_exec_SETCOM
db 1,TEK41_INT_TYPE,0,0,0,0
;
dw 0
dw tek41_exec_unknown
db 0,0,0,0,0,0
;----------------------------------------------
tek_stat_msg db CR,LF," Tek status: "
tek_pmode_msg db " "
db " color mode: "
tek_cmode_msg db "3 1 1 "
db " mouse: "
tek_mouse_msg db " "
db CR,LF," Tek Last Unknown command: "
tek_unkwn_msg dw ' '
db " Tek Last Ignored command: "
tek_ignor_msg dw ' '
tek_test1_msg db ' '
tek_test2_msg db ' '
tek_test3_msg db ' '
tek_test4_msg db ' '
db '$'
;----------------------------------------------
data ends
code segment
extrn vt100_modlin:near
extrn outcapt:near
extrn set_cur_color:near
extrn set_cursor:near ; in MSZP98
extrn text_scrn:near ; in MSZP98
extrn pc98_bell:near
assume cs:code,ds:data,es:nothing
TEK41_W2V PROC NEAR
;
; Input (ax,bx) -- coordinate in window
; [si] -- transformation matrix
; Output (ax,bx) -- coordinate in viewport
;
; format of the transformation matrix
; xv = (xw - wx0)*mx + vx0
; yv = (yw - wy0)*my + vy0
;
; [si ] mx_l
; [si+ 2] mx_h
; [si+ 4] wx0
; [si+ 6] vx0
; [si+ 8] my_l
; [si+10] my_h
; [si+12] wy0
; [si+14] vy0
;
push cx
push dx
push si
push di
;
mov di,bx ; save y
;
sub ax,[si+ 4]
push ax ; save (x-wx0)
xor cx,cx
cmp ax,0
jge tek41_w2v_1
mov cl,1
neg ax
tek41_w2v_1:
mul WORD PTR [si] ; low word
mov bx,dx
pop ax
mul WORD PTR [si+ 2] ; high word
add bx,ax
jcxz tek41_w2v_2
neg bx
tek41_w2v_2:
add bx,[si+ 6]
;
mov ax,di ; get y
mov di,bx ; save result x
sub ax,[si+12]
push ax ; save (y-wy0)
xor cx,cx
cmp ax,0
jge tek41_w2v_3
mov cl,1
neg ax
tek41_w2v_3:
mul WORD PTR [si+ 8] ; low word
mov bx,dx
pop ax
mul WORD PTR [si+10] ; high word
add bx,ax
jcxz tek41_w2v_4
neg bx
tek41_w2v_4:
add bx,[si+14]
mov ax,di
;
pop di
pop si
pop dx
pop cx
;
ret
TEK41_W2V ENDP
;-----------------------------------------------------------------------
; TEK4010/4014 terminal emulator
;-----------------------------------------------------------------------
TEK40_DEV_COOD PROC NEAR
;
; Transform TEK4014 coordinates to PC9801 device coordinates
; Inputs:
; AX: TEK4014 X coordinate ( to be replaced by device x )
; BX: TEK4014 Y coordinate ( to be replaced by device y )
; Outputs:
; AX: Device X coordinate
; BX: Device Y coordinate
;
push si
mov si,offset tek_w2v_mat
call tek41_w2v
pop si
;
push cx
cmp bx,399
jle tek40_dev_cood_1
mov bx,399
tek40_dev_cood_1:
mov cx,399
sub cx,bx
xchg bx,cx
cmp ax,639
jle tek40_dev_cood_2
mov ax,639
tek40_dev_cood_2:
pop cx
ret
;
TEK40_DEV_COOD ENDP
;
code ends
code2 segment
assume cs:code2
tekstat proc far
push ax
mov si,offset tek_cmode_msg
mov al,tek_cmode_1
add al,'0'
mov [si],al
mov al,tek_cmode_2
add al,'0'
mov [si+2],al
mov al,tek_cmode_3
add al,'0'
mov [si+4],al
;
mov si,offset tek_mouse_msg
test vtgrph_flg,MOUSE_BIT
jz tekstat_m01
mov al,'o'
mov [si],al
mov al,'n'
mov [si+1],al
mov al,' '
mov [si+2],al
jmp tekstat_m02
tekstat_m01:
mov al,'o'
mov [si],al
mov al,'f'
mov [si+1],al
mov [si+2],al
tekstat_m02:
mov al,' '
mov [si+3],al
mov al,pc98_mouse_type
add al,'0'
mov [si+4],al
;
mov si,offset tek_pmode_msg
mov al,tek_mod
add al,'0'
mov [si],al
mov al,tek_esc
add al,'0'
mov [si+1],al
mov si,offset tek_stat_msg
pop ax
ret
tekstat endp
;----------------------------------------------------------------------------
set_tek41_mat proc far
;
; set the transformation matrix.
; parameter consistency must be checked before call.
; Input [si] window xmin,xmax,ymin,ymax; viewport xmin,xmax,ymin,ymax
; Output [di] transformation matrix
;
push ax
push bx
push dx
;
mov ax,[si+10] ; viewport xmax
sub ax,[si+ 8] ; viewport (xmax-xmin)
inc ax
xor dx,dx
mov bx,[si+ 2] ; window xmax
sub bx,[si ] ; window (xmax-xmin)
inc bx
div bx
mov [di+ 2],ax
xor ax,ax
div bx
mov [di ],ax
;
mov ax,[si+14] ; viewport ymax
sub ax,[si+12] ; viewport (ymax-ymin)
inc ax
xor dx,dx
mov bx,[si+ 6] ; window ymax
sub bx,[si+ 4] ; window (ymax-ymin)
inc bx
div bx
mov [di+10],ax
xor ax,ax
div bx
mov [di+ 8],ax
;
mov ax,[si ] ; get window xmin
mov [di+ 4],ax
mov ax,[si+ 4] ; get window ymin
mov [di+12],ax
mov ax,[si+ 8] ; get viewport xmin
mov [di+ 6],ax
mov ax,[si+12] ; get viewport ymin
mov [di+14],ax
;
pop dx
pop bx
pop ax
ret
set_tek41_mat endp
code2 ends
code segment
assume cs:code
;
TEK40_GIN PROC NEAR
;
; Request locator
;
; If we are using mouse, set the position
;
mov pc98_mouse_type,0
test vtgrph_flg,MOUSE_BIT ; mouse on ?
jz tek40_gin_00 ; no.
tek40_gin_m01:
mov ax,0 ; init mouse
mov bx,0
int 33h
cmp ax,-1 ; mouse available ?
jne tek40_gin_00
cmp bx,2 ; MS-mouse ?
jne tek40_gin_m02 ; ne=no.
mov pc98_mouse_type,2
jmp tek40_gin_m03
tek40_gin_m02:
mov pc98_mouse_type,1
tek40_gin_m03:
mov cx,loc_x
mov dx,loc_y
mov ax,4 ; locate mouse
int 33h
tek40_gin_00:
mov si,offset ent_gin ; write mode is complement
call send_to_GGDC
mov loc_mov,3
;
; Draw X axis
;
tek40_gin_01:
test loc_mov,1
jz tek40_gin_02
mov di,offset loc_x_buff
mov ax,gin_vpx1
mov bx,loc_y
mov cx,GGDC_GIN_PLANE ; locator graphic plane
call gcsrw
mov ax,gin_vpx2
sub ax,gin_vpx1
mov bx,0
call gline
mov byte ptr [di],0FFh
mov si,offset loc_x_buff
call send_to_GGDC
;
; Draw Y axis
;
tek40_gin_02:
test loc_mov,2
jz tek40_gin_10
mov di,offset loc_y_buff
mov ax,loc_x
mov bx,399
sub bx,gin_vpy2
mov cx,GGDC_GIN_PLANE
call gcsrw
mov ax,0
mov bx,gin_vpy2
sub bx,gin_vpy1
call gline
mov byte ptr [di],0FFh
mov si,offset loc_y_buff
call send_to_GGDC
;
tek40_gin_10:
cmp pc98_mouse_type,0 ; using mouse ?
jne tek40_gin_m10 ; ne=yes.
jmp tek40_gin_11
tek40_gin_m10:
mov ax,3
int 33h
cmp pc98_mouse_type,1 ; NEC type ?
jne tek40_gin_m12 ; ne=no.
and ax,01h
and bx,02h
or bx,ax ; MS-mouse method
tek40_gin_m12:
and bx,03h
cmp bx,0
jne tek40_gin_m14
cmp cx,loc_x
jne tek40_gin_m14
cmp dx,loc_y
jne tek40_gin_m14
mov ah,01h ; sense keyboard buffer
int BIOS
cmp bh,0
je tek40_gin_m10
mov ah,00h ; read keyboard buffer
int BIOS
jmp tek40_gin_ex
tek40_gin_m14:
mov loc_x,cx
mov loc_y,dx
cmp bx,0
je tek40_gin_m16
mov ax,bx
mov bx,offset pc98_mouse_char
add bx,ax
mov al,[bx]
jmp tek40_gin_ex
;
tek40_gin_m16:
mov si,offset loc_x_buff
call send_to_GGDC
mov si,offset loc_y_buff
call send_to_GGDC
mov loc_mov,3
jmp tek40_gin_01
;
; If we are using mouse, read mouse.
; Otherwise, scan Keyboard
;
tek40_gin_11:
mov dx,1
mov ah,1 ; sense keyborad buffer
int 18h ; BIOS call
cmp bh,0
je tek40_gin_11
;
mov ah,2 ; sense shift keys
int 18h
test al,1 ; SHIFT key pressed ?
jz tek40_gin_12
mov dx,4
tek40_gin_12:
test al,16 ; CTRL key pressed ?
jz tek40_gin_13
mov dx,8
tek40_gin_13:
;
mov ah,0 ; read keyboard buffer
int 18h
;
mov loc_mov,0
;
cmp ax,03A00h ; UP
je tek40_gin_up
cmp ax,03D00h
je tek40_gin_down
cmp ax,03B00h
je tek40_gin_left
cmp ax,03C00h
je tek40_gin_right
;
; Alpha-Numeric key.
;
jmp tek40_gin_ex
;
tek40_gin_up:
sub loc_y,dx
cmp loc_y,9-Y_OFS
jge tek40_gin_y
mov loc_y,9-Y_OFS
jmp tek40_gin_y
tek40_gin_down:
add loc_y,dx
cmp loc_y,399-Y_OFS
jle tek40_gin_y
mov loc_y,399-Y_OFS
tek40_gin_y:
; erase X axis
mov si,offset loc_x_buff
or loc_mov,1
jmp tek40_gin_xy
;
tek40_gin_left:
sub loc_x,dx
cmp loc_x,X_OFS
jge tek40_gin_x
mov loc_x,X_OFS
jmp tek40_gin_x
tek40_gin_right:
add loc_x,dx
cmp loc_x,511+X_OFS
jle tek40_gin_x
mov loc_x,511+X_OFS
tek40_gin_x:
mov si,offset loc_y_buff
or loc_mov,2
tek40_gin_xy:
call send_to_GGDC
jmp tek40_gin_01
;
tek40_gin_ex:
;
; set-up answerback
;
mov si,offset gin_ans
mov [si+1],al ; Keyboard character
;
mov si,offset gin_v2w_mat
mov ax,loc_x
mov bx,399
sub bx,loc_y
call tek41_w2v
shr ax,1
shr ax,1 ; convert to 10-bit address
shr bx,1
shr bx,1 ; convert to 10-bit address
;
mov si,offset gin_ans
push bx ; save Y
;
mov bx,ax
mov cx,5 ; set shift count
shr ax,cl ; get HiX
and ax,01Fh ; mask higher bits
or al,020h ; convert to character
mov [si+2],al ; set HiX
and bx,01Fh ; get LoX
or bl,020h ; convert to character
mov [si+3],bl ; set LoX
;
pop bx ; restore Y
;
mov ax,bx
mov cx,5 ; set shift count
shr ax,cl ; get HiY
and ax,01Fh ; mask higher bits
or al,020h ; convert to character
mov [si+4],al ; set HiY
and bx,01Fh ; get LoY
or bl,020h ; convert to character
mov [si+5],bl ; set LoY
;
; Erase cross hair cursor
;
mov si,offset loc_x_buff
call send_to_GGDC
mov si,offset loc_y_buff
call send_to_GGDC
;
; Reset write mode
;
mov si,offset ext_gin
call send_to_GGDC
;
mov tek_byp,1 ; set bypass mode
mov si,offset gin_ans
xor cx,cx
mov cl,[si]
inc si
ret
TEK40_GIN ENDP
TEK40_CURON PROC NEAR
push ax
push bx
push cx
push si
push di
;
mov si,offset alp_cur_font
mov di,offset alp_cur_buff
mov byte ptr [di],078h ; TEXTW
mov byte ptr [di+1],8 ; number of parameters
add di,2
cld
mov cx,8
push es
push ds
pop es
rep movsb
pop es
mov ax,tek_cur_x
mov bx,tek_cur_y
call tek40_dev_cood
mov cx,GGDC_GCUR_PLANE ; cursor graphic plane
call gcsrw
mov byte ptr [di],21h ; write in COMPLEMENT mode
mov byte ptr [di+1],0
add di,2
mov byte ptr [di],04Ch ; VEXTW
mov byte ptr [di+1],3 ; number of parameters
mov byte ptr [di+2],012h ; normal text dir=2
mov byte ptr [di+3],07h
mov byte ptr [di+4],0
mov byte ptr [di+5],068h ; TEXTE
mov byte ptr [di+6],0
mov byte ptr [di+7],0FFh ; terminator
mov si,offset alp_cur_buff
call send_to_GGDC
mov tek_cur,1
;
pop di
pop si
pop cx
pop bx
pop ax
ret
TEK40_CURON ENDP
TEK40_CUROFF PROC NEAR
cmp tek_cur,0
je tek40_curoff_ex
push si
mov si,offset alp_cur_buff
call send_to_GGDC
pop si
mov tek_cur,0
tek40_curoff_ex:
ret
TEK40_CUROFF ENDP
TEK4014_INI PROC NEAR
call tek4014_reset
mov si,offset ggdc_off
call send_to_GGDC
ret
TEK4014_INI ENDP
TEK4014_COLOR PROC NEAR
;
; Set color index table
; [si] foreground color
; [si+1] background color
;
push ax
push di
;
push si
mov al,[si+1] ; background color
xor ah,ah
mov si,offset gnrm_color
add si,ax
add si,ax
add si,ax
mov di,offset tek_col ; index 0 is background color
mov al,[si]
mov [di],al
mov al,[si+1]
mov [di+1],al
mov al,[si+2]
mov [di+2],al
;
push cx
mov cx,4
mov di,offset sixel_col
tek4014_color_sxb:
mov al,[si]
mov [di],al ; R
mov [di+24],al ; R
mov al,[si+1]
mov [di+1],al ; G
mov [di+25],al ; G
mov al,[si+2]
mov [di+2],al ; B
mov [di+26],al ; B
add di,3
loop tek4014_color_sxb
pop cx
;
pop si
;
push si
mov al,[si] ; foreground color
xor ah,ah
mov si,offset gnrm_color
add si,ax
add si,ax
add si,ax
mov di,offset tek_col
add di,3 ; index 1 is foreground color
mov al,[si]
mov [di],al
mov al,[si+1]
mov [di+1],al
mov al,[si+2]
mov [di+2],al
;
push cx
mov cx,4
mov di,offset sixel_col
add di,12 ; start from index 4
tek4014_color_sxf:
mov al,[si]
mov [di],al ; R
mov [di+24],al ; R
mov al,[si+1]
mov [di+1],al ; G
mov [di+25],al ; G
mov al,[si+2]
mov [di+2],al ; B
mov [di+26],al ; B
add di,3
loop tek4014_color_sxf
pop cx
;
pop si
;@@ mov [di+7],al
;@@ mov al,[si+1]
;@@ mov [di],al
;@@ mov di,offset sixel_col
;@@ mov al,[si]
;@@ mov [di+4],al
;@@ mov [di+5],al
;@@ mov [di+6],al
;@@ mov [di+7],al
;@@ mov al,[si+1]
;@@ mov [di],al
;@@ mov [di+1],al
;@@ mov [di+2],al
;@@ mov [di+3],al
pop di
pop ax
ret
TEK4014_COLOR ENDP
tek40_color proc near
;
; set color
; input ax
;
push ax ; save register
cmp ax,0 ; normal intensity [0] ?
jne tek40_color_1 ; ne=no
mov tek_hgt,0 ; set normal intensity
jmp tek40_color_ex
tek40_color_1:
cmp ax,1 ; high intensity [1] ?
jne tek40_color_2 ; ne=no
mov tek_hgt,1 ; set high intensity
jmp tek40_color_ex
tek40_color_2:
cmp ax,30 ; forground color [30-37] ?
jl tek40_color_bk
cmp ax,37
jg tek40_color_bk
sub ax,30 ; OK, convert to color index
push bx
mov bx,offset col_indx_tab_N
add bx,ax
cmp tek_hgt,0 ; HighLight ?
je tek40_color_fg1 ; e=no
add bx,8
tek40_color_fg1:
mov al,[bx]
pop bx
mov tek_lncol,ax
mov tek_txcol,ax
mov tek_facol,ax
jmp tek40_color_ex
tek40_color_bk:
cmp ax,40 ; background color [40-47] ?
jl tek40_color_ex
cmp ax,47 ; bug fixed [30-May-1989]. Was 37.
jg tek40_color_ex
sub ax,40
push si
mov si,offset col_indx_tab_N
add si,ax
mov al,[si]
mov si,offset scn_color
mov [si+1],al
call tek4014_color
mov si,offset tek_col
call set_gpalette
pop si
tek40_color_ex:
pop ax ; restore ax
ret
tek40_color endp
TEK4014_RESET PROC NEAR
;
; Hardware initialization
;
tek4014_reset_lp01:
in al,GGDC_STS_PORT
xor al,024h
test al,024h ; VSYNC & GDC Empty ?
jne tek4014_reset_lp01
;
mov al,disp_bank
out 0A4h,al ; set display bank
mov al,actv_bank
out 0A6h,al ; set active bank
mov al,02h ; color mode
out 068h,al ; set mode F/F
mov al,08h ; 400 line mode
out 068h,al ; set mode F/F
mov si,offset ggdc_set ; CSFORM & SCROLL
call send_to_GGDC
;
cmp display_mode,0
je tek4014_reset_02
mov gdisp_mode,1
mov gplane_nums,4
jmp tek4014_reset_03
tek4014_reset_02:
mov gdisp_mode,0
mov gplane_nums,3
tek4014_reset_03:
mov al,gdisp_mode ; display mode
out 6ah,al
;
call gcls
;
; Software reset
;
; Set color mode
;
mov tek_cmode_1,3
mov tek_cmode_2,1
mov tek_cmode_3,1
;
push si
mov si,offset def_color
call set_cur_color
call tek4014_color
pop si
;
; Set Windows
;
mov tek_wnx1,0
mov tek_wnx2,TEK_X_MAX
mov tek_wny1,0
mov tek_wny2,TEK_Y_MAX
;
mov gin_wnx1,0
mov gin_wnx2,TEK_X_MAX
mov gin_wny1,0
mov gin_wny2,TEK_Y_MAX
;
; Set Viewports
;
mov tek_vpx1,X_OFS
mov tek_vpx2,(X_OFS+479)
mov tek_vpy1,Y_OFS
mov tek_vpy2,(Y_OFS+359)
;
mov gin_vpx1,X_OFS
mov gin_vpx2,(X_OFS+479)
mov gin_vpy1,Y_OFS
mov gin_vpy2,(Y_OFS+359)
;
; Set Transformation Matricies
;
push si
push di
mov si,offset tek_wnx1
mov di,offset tek_w2v_mat
call set_tek41_mat
mov si,offset gin_vpx1 ; viewport to window for GIN
mov di,offset gin_v2w_mat
call set_tek41_mat
pop di
pop si
;
; Set text parameters
;
mov tek_gtxt_ang,0
mov tek_gtxt_w,39
mov tek_gtxt_h,52
mov tek_gtxt_s,13
mov tek_gtxt_dr,2
mov tek_gtxt_ux,52 ; w+s
mov tek_gtxt_uy,0
mov tek_gtxt_vx,0
mov tek_gtxt_vy,52 ; h
;
; Set current position
;
mov tek_cur_x,0
mov tek_cur_y,TEK_Y_MAX
mov ax,TEK_DY
sub tek_cur_y,ax
mov line_type,0
mov marker_type,0
mov tek_byp,0
mov tek_lncol,1 ; line color is white
mov tek_txcol,1 ; text color is white
mov tek_facol,1 ; fill area color is white
mov tek_hgt,0 ; Normal Intensity
mov tek_esc,0
mov tek_inpanel,0
mov tek41_cmd,0
;
; Set locator position at the center of the screen
;
push bx
mov ax,(TEK_X_MAX+1)
shr ax,1
mov bx,(TEK_Y_MAX+1)
shr bx,1
call tek40_dev_cood
mov loc_x,ax
mov loc_y,bx
pop bx
;
; Set color index table
;
push cx
push di
push si
push es
;
push ds
pop es
mov si,offset tek_col_def ; source
mov di,offset tek_col ; destination
mov cx,48 ; 16 colors x 3
cld
rep movsb
mov si,offset tek_col
call set_gpalette
;
; Set dialog area
;
mov tek_dialog_area,0
mov tek_dialog_vsbl,0
;
pop es
pop si
pop di
pop cx
;
call tek40_curon
;
ret
TEK4014_RESET ENDP
TEK4014_SAVE PROC NEAR
;
;@@ mov si,offset tek_col0
call set_gpalette
;
mov si,offset ggdc_solid
call send_to_GGDC
mov si,offset ggdc_off
call send_to_GGDC
;
; Clear mode line
;
push dx
mov dx,offset tek_zero
call vt100_modlin
pop dx
;
push ax
mov ax,vt100_cursr
xor al,al ; restore cursor attributes
call set_cursor
mov ax,1
call text_scrn ; text screen ON
pop ax
;
ret
TEK4014_SAVE ENDP
TEK4014_RESTORE PROC NEAR
;@@ push ax
;@@ mov ax,1 ; disable text cursor
;@@ call set_cursor
;@@ pop ax
;
push ax
mov al,display_mode
cmp al,gdisp_mode
je tek4014_restore_1
mov gdisp_mode,0
mov gplane_nums,3
cmp al,0
je tek4014_restore_2
mov gdisp_mode,1
mov gplane_nums,4
tek4014_restore_2:
mov al,gdisp_mode
out 6ah,al
tek4014_restore_1:
pop ax
;
call gdisp_on
;
mov si,offset tek_col
call set_gpalette
ret
TEK4014_RESTORE ENDP
TEK4014_MODLIN PROC NEAR
call vt100_modlin
ret
TEK4014_MODLIN ENDP
; Tek4014/Tek4105 emulator by H.Fujii (KEK)
;
; Carry Set if parameters need to be passed to VT100.
; In this case, CX contains number of characters and [SI] contains the
; string.
;
TEK4014 PROC NEAR
cmp vt100_lflag,(LOGCOOK_BIT+LOGENAB_BIT)
jne tek4014_01 ; ne = no.
call outcapt ; log it
tek4014_01:
call tek40_curoff
cmp tek_byp,0 ; bypass mode ?
je tek40_00 ; e = No.
mov bl,al ; Bypass mode
and bl,07Fh ; Mask 8th bit
cmp bl,020h ; control character ?
jge tek40_ex ; ge = No.
mov tek_byp,0 ; Off the bypass mode
tek40_00:
cmp tek_esc,0 ; in ESC sequence ?
je tek40_01 ; e = No.
jmp tek40_esc
tek40_01:
cmp tek_mod,0 ; Alpha mode ?
jne tek40_02
jmp tek40_alp
tek40_02:
cmp tek_mod,1 ; Vector mode ?
jne tek40_03
jmp tek40_vct
tek40_03:
cmp tek_mod,2 ; Point plot mode ?
jne tek40_04
jmp tek40_vct
tek40_04:
cmp tek_mod,3
jne tek40_05
jmp tek40_inc
tek40_05:
call pc98_bell ; Program error !!!
tek40_ex:
cmp tek_esc,0 ; in ESC seq ?
jne tek40_ex1 ; ne=yes.
cmp tek_dialog_area,0 ; Disable dialog ?
jne tek40_ex1 ; ne=no, dialog is VT screen
cmp tek_mod,0 ; in alpha mode ?
jne tek40_ex1 ; ne=no
call tek40_curon
tek40_ex1:
mov ah,0
mov cx,0
clc ; normal return
ret
;-----------------------------------------------------------------------
; ESC sequence
;-----------------------------------------------------------------------
tek40_esc:
cmp tek_esc,1 ; just entered ?
je tek40_esc1 ; e=yes.
cmp tek_esc,2 ; in CSI mode ?
jne tek40_esc_n2 ; ne=no.
jmp tek40_esc2
tek40_esc_n2:
cmp tek_esc,3 ; in 20C ?
jne tek40_esc_n3
jmp tek40_esc3
tek40_esc_n3:
jmp tek40_esc4
;
tek40_esc1:
cmp al,020h ; C0 character ?
jb tek40_esc_C0 ; b=yes.
jmp tek40_esc_GL
;
tek40_esc_C0:
tek40_esc_0C:
cmp al,FF ; FF ?
jne tek40_esc_n0C ; ne=no.
test vtgrph_flg,GCLRWAIT_BIT
jz tek40_esc_0C_2
push ax
push bx
call pc98_bell
tek40_esc_0C_1:
mov ax,0100h
int BIOS
cmp bh,0
je tek40_esc_0C_1
mov ax,0
int BIOS
pop bx
pop ax
tek40_esc_0C_2:
call gcls ; ESC FF clears screen
mov tek_esc,0 ; ESC seq done
mov tek_mod,0 ; enter alpha mode
mov tek_cur_x,0
mov tek_cur_y,TEK_Y_MAX
sub tek_cur_y,TEK_DY
jmp tek40_ex
tek40_esc_n0C:
;
cmp al,CL_SUB ; SUB (1A) ?
jne tek40_esc_n1A ; ne=no.
call tek40_gin
mov tek_esc,0
mov tek_mod,0
mov ah,0
clc
ret ; EIXT with gin answerback
tek40_esc_n1A:
mov tek_esc,0 ; any other C0 characters are
jmp tek40_C0 ; treated as a single C0 character
;
tek40_esc_GL:
cmp al,'['
je tek40_esc_5B
ja tek40_esc_5C
mov tek_esc,3 ; in TEK4105 command mode
xor ah,ah
mov tek41_cmd,ax
jmp tek40_ex
tek40_esc_5B:
mov tek_esc,2 ; in CSI mode
mov bx,offset tek_P_buf
mov tek_P_pnt,bx
mov word ptr [bx],0
mov tek_P_num,0
mov tek_P_prv,0
jmp tek40_ex
tek40_esc_5C:
jmp tek40_esc_ex
;
; ANSI CSI sequence
;
tek40_esc2:
cmp al,'0'
jl tek40_esc2_01
cmp al,'9'
jg tek40_esc2_01
xor ah,ah
sub al,'0'
mov bx,tek_P_pnt
mov cx,[bx]
shl cx,1
shl cx,1
add cx,[bx]
shl cx,1
add ax,cx
mov [bx],ax
jmp tek40_ex
tek40_esc2_01:
cmp al,'?'
jne tek40_esc2_02
mov tek_P_prv,al
jmp tek40_ex
tek40_esc2_02:
cmp al,';'
jne tek40_esc2_03
add tek_P_pnt,2
mov bx,tek_P_pnt
mov word ptr [bx],0
inc tek_P_num
jmp tek40_ex
tek40_esc2_03:
cmp al,'h'
jne tek40_esc2_04
jmp tek40_esc_ex
tek40_esc2_04:
cmp al,'l'
jne tek40_esc2_05
jmp tek40_vtchg
tek40_esc2_05:
cmp al,'m'
jne tek40_esc2_06
push ax
push cx
push si
mov si,offset tek_P_buf
mov cx,tek_P_num ; number of parameters
inc cx
tek40_esc2_05a:
mov ax,[si] ; get color code
call tek40_color
add si,2
loop tek40_esc2_05a ; loop over all parameters
pop si
pop cx
pop ax
jmp tek40_esc_ex
tek40_esc2_06:
jmp tek40_esc_ex
;
tek40_esc3:
;
; 20C mode
;
cmp al,020h ; C0 character ?
jae tek40_esc3_01 ; ae = no.
jmp tek40_C0
tek40_esc3_01:
mov bx,tek41_cmd
mov bh,al
xchg bh,bl
mov tek41_cmd,bx ; stored it.
mov tek_esc,4 ; enter Tek41 command mode
mov tek41_narg,0
mov tek41_nget,0
mov tek41_larg,0
;
; analyze command and set number of arguments and argument types
;
mov ax,bx
mov bx,offset func41
tek41_ana_03:
mov cx,[bx]
cmp ax,cx
je tek41_ana_01
cmp cx,0
jne tek41_ana_05
add bx,2
mov cx,[bx]
mov tek41_func,cx
xchg ah,al ; change to character order
mov tek_unkwn_msg,ax
xchg ah,al
jmp tek40_ex
tek41_ana_05:
add bx,10
jmp tek41_ana_03
tek41_ana_01:
add bx,2
mov cx,[bx]
mov tek41_func,cx
add bx,2
mov cl,[bx]
inc bx
xor ch,ch
mov tek41_narg,cx
cmp cx,0
je tek41_ana_02
push si
mov si,offset tek41_argt
tek41_ana_04:
mov al,[bx]
mov [si],al
inc bx
inc si
loop tek41_ana_04
pop si
tek41_ana_02:
jmp tek41_next
;
tek40_esc4:
cmp al,20h ; C0 character ?
jae tek40_esc4_02 ; ae=no.
cmp al,ESCAPE ; one of ESC,FS,GS,RS,US ?
jl tek40_esc4_01 ; l=no.
mov tek_esc,0 ; terminate the command
jmp tek40_C0 ; and treat as C0
tek40_esc4_01:
jmp tek40_ex ; ignore any other C0 character.
tek40_esc4_02:
cmp tek41_nreq,TEK41_XY_TYPE
jne tek40_esc4_03
jmp tek41_xy
tek40_esc4_03:
cmp tek41_nreq,TEK41_INT_TYPE
jne tek40_esc4_04
jmp tek41_int
tek40_esc4_04:
cmp tek41_nreq,TEK41_STR_TYPE
jne tek40_esc4_05
jmp tek41_str
tek40_esc4_05:
cmp tek41_nreq,TEK41_IAR_TYPE
jne tek40_esc4_06
jmp tek41_int
tek40_esc4_06:
jmp tek40_ex ; Unknown command, ignore.
;
tek40_esc_ex:
mov tek_esc,0
jmp tek40_ex
; receive and convert Tek41 type xy-coordinate
; note that xy-coordinate system is the same as Tek401x.
;
tek41_xy:
jmp tek40_vct ; goto Tek40 type vector format analyzer
tek41_xy1:
mov cx,tek41_larg ; check the room for storage
add cx,4
cmp cx,TEK41_ARGBUF_SIZE
jae tek41_xy2 ; ae = room is full
mov bx,offset tek41_argbuf
add bx,tek41_larg
mov ax,tek_req_x
mov [bx],ax ; store it in buffer
mov ax,tek_req_y
mov [bx+2],ax
add tek41_larg,4 ; update buffer length
tek41_xy2:
inc tek41_nget ; icrement number of argument we get
jmp tek41_next
;
; receive and convert Tek41 type integer
; 7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0
; +-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+
; |P|1| value | ... |P|0|1|S| value | where S=1 if int >= 0
; +-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+
;
tek41_int:
mov ah,al ; copy to AH
mov bx,tek41_ival ; get previous value
test al,040h ; Hi byte ?
jz tek41_int1 ; z=no
mov cx,6 ; shift count
shl bx,cl ; shift-left previous value by 6 bits
and ah,03Fh
or bl,ah
mov tek41_ival,bx ; store it
jmp tek40_ex ; and continue
tek41_int1:
mov cx,4
shl bx,cl
and ah,00Fh
or bl,ah
test al,010h ; check sign bit
jnz tek41_int2 ; nz=positive
neg bx ; negative integer
tek41_int2:
mov ax,bx
mov tek41_ival,ax ; store it
mov cx,tek41_larg ; check the room for storage
add cx,2
cmp cx,TEK41_ARGBUF_SIZE
jae tek41_int3 ; ae = room is full
mov bx,offset tek41_argbuf
add bx,tek41_larg
mov [bx],ax ; store it in buffer
add tek41_larg,2 ; update buffer length
tek41_int3:
cmp tek41_nact,TEK41_INT_TYPE ; processing single INT ?
jne tek41_int4 ; ne=no.
inc tek41_nget ; increment number of arg. we get
jmp tek41_next ; setup for next argument
tek41_int4:
cmp tek41_nact,TEK41_STR_TYPE ; processing string ?
jne tek41_int5 ; ne=no.
mov tek41_lstr,ax ; set character length
mov tek41_nchr,0 ; clear the filled size
mov tek41_nreq,TEK41_STR_TYPE ; next data is character
jmp tek40_ex ; and continue
tek41_int5:
cmp tek41_nact,TEK41_IAR_TYPE ; processing INT array ?
jne tek41_int8
cmp tek41_nreq,TEK41_INT_TYPE ; beginning of array ?
jne tek41_int6
mov tek41_liar,ax ; set array length
mov tek41_niar,0 ; clear the filled size
mov tek41_ival,0 ; clear the buffer
mov tek41_nreq,TEK41_IAR_TYPE ; next data is INT array elem.
jmp tek40_ex ; and continue
tek41_int6:
inc tek41_niar
mov cx,tek41_niar
cmp cx,tek41_liar
jge tek41_int7
mov tek41_ival,0 ; clear the buffer
jmp tek40_ex
tek41_int7:
inc tek41_nget
jmp tek41_next
tek41_int8:
jmp tek40_ex ; PROGRAM ERROR !!!
;
tek41_str:
mov cx,tek41_larg ; check the room
inc cx
cmp cx,TEK41_ARGBUF_SIZE
jae tek41_str1 ; ae = room is full
mov bx,offset tek41_argbuf
add bx,tek41_larg
mov [bx],al
inc tek41_larg ; update buffer length
tek41_str1:
inc tek41_nchr
mov cx,tek41_nchr
cmp cx,tek41_lstr
jge tek41_str2
jmp tek40_ex
tek41_str2:
inc tek41_nget
jmp tek41_next
;
; setup next argument for Tek41xx
;
tek41_next:
mov cx,tek41_nget ; number of arg. we have
cmp cx,tek41_narg ; enough ?
jl tek41_next1 ; l=no, not.
mov tek41_nreq,TEK41_NO_ACT ; yes, we have enough, no more.
jmp tek41_exec ; execute the command.
tek41_next1:
mov bx,offset tek41_argt
add bx,cx
mov al,[bx] ; argument type
mov tek41_nact,al ; set next action
cmp al,TEK41_XY_TYPE
jne tek41_next2
mov tek41_nreq,TEK41_XY_TYPE ; next data type is XY-type
mov tek_vseq,0 ; initialize vector format seq.
jmp tek40_ex
tek41_next2:
cmp al,TEK41_INT_TYPE
jne tek41_next3
mov tek41_nreq,TEK41_INT_TYPE ; next data type is INT
mov tek41_ival,0
jmp tek40_ex
tek41_next3:
cmp al,TEK41_STR_TYPE
jne tek41_next4
mov tek41_nreq,TEK41_INT_TYPE ; next data type is INT
mov tek41_ival,0
mov tek41_lstr,0
mov tek41_nchr,0
jmp tek40_ex
tek41_next4:
cmp al,TEK41_IAR_TYPE
jne tek41_next5
mov tek41_nreq,TEK41_INT_TYPE ; next data type is INT
mov tek41_ival,0
mov tek41_liar,0
mov tek41_niar,0
jmp tek40_ex
tek41_next5:
jmp tek40_ex ; PROGRAM ERROR !!!
;
; execute the Tek41 command
;
tek41_exec:
mov bx,tek41_func
jmp bx
;
tek41_exec_MC:
mov bx,offset tek41_argbuf
mov ax,[bx] ; text width
mov tek_gtxt_w,ax
mov ax,[bx+2] ; text height
mov tek_gtxt_h,ax
mov ax,[bx+4] ; text spacing
mov tek_gtxt_s,ax
call set_gtxt_vect
jmp tek41_exec_done
;
tek41_exec_ML:
mov ax,tek41_ival
;@@ call tek41_getcol ; convert to tek41 color index
mov tek_lncol,ax
jmp tek41_exec_done
;
tek41_exec_MT:
mov ax,tek41_ival
;@@ call tek41_getcol ; convert to tek41 color index
mov tek_txcol,ax
jmp tek41_exec_done
;
tek41_exec_MM:
mov ax,tek41_ival
mov marker_type,ax
jmp tek41_exec_done
;
tek41_exec_MP:
mov ax,tek41_ival
cmp ax,0
jg tek41_exec_MP2
je tek41_exec_MP1
neg ax
;@@ call tek41_getcol ; convert to tek41 color index
tek41_exec_MP1:
mov tek_facol,ax
mov tek_famod,0
tek41_exec_MP2:
jmp tek41_exec_done
;
tek41_exec_MV:
mov ax,tek41_ival
and ax,07h
mov line_type,ax
jmp tek41_exec_done
;
tek41_exec_MR:
mov bx,offset tek41_argbuf
mov ax,[bx] ; rotation angle
mov cx,[bx+2]
cmp cx,0
je tek41_exec_MR_1
jg tek41_exec_MR_2
neg cx
sar ax,cl
jmp tek41_exec_MR_1
tek41_exec_MR_2:
sal ax,cl
tek41_exec_MR_1:
cmp ax,0
jge tek41_exec_MR_3
add ax,360
jmp tek41_exec_MR_1
tek41_exec_MR_3:
cmp ax,360
jl tek41_exec_MR_4
sub ax,360
jmp tek41_exec_MR_3
tek41_exec_MR_4:
mov tek_gtxt_ang,ax
call set_gtxt_vect
jmp tek41_exec_done
;
tek41_exec_KA:
mov ax,tek41_ival
mov tek_dialog_area,al
jmp tek41_exec_done
;
tek41_exec_LV:
mov ax,tek41_ival
mov tek_dialog_vsbl,al
call text_scrn
jmp tek41_exec_done
;
tek41_exec_LZ:
mov si,offset vt_dialog_clr
xor cx,cx
xor ax,ax
mov cl,[si]
inc si
stc
ret
;
tek41_exec_SETCOM:
cmp tek41_ival,0
je tek41_exec_nSETCOM
mov ah,1 ; change the mode to VT
mov al,0
xor cx,cx
mov tek41_cmd,0
mov tek_esc,0
ret
tek41_exec_nSETCOM:
tek41_exec_unknown:
mov tek41_cmd,0 ; unknown command
jmp tek40_ex
;
tek41_exec_none:
mov ax,tek41_cmd
xchg ah,al
mov tek_ignor_msg,ax
jmp tek41_exec_done
;
tek41_exec_LG:
cmp tek_inpanel,0
je tek41_exec_LG1
jmp tek40_vct_fa
tek41_exec_LG1:
mov ax,line_type
call tek_ltyp
mov ax,tek_cur_x
mov bx,tek_cur_y
call tek40_dev_cood
mov pc98_x1,ax
mov pc98_y1,bx
mov ax,tek_req_x
mov bx,tek_req_y
call tek40_dev_cood
call tek_draw
jmp tek41_exec_LF1
tek41_exec_LH:
cmp tek_inpanel,0
je tek41_exec_LH1
jmp tek40_vct_fa
tek41_exec_LH1:
mov ax,tek_req_x
mov bx,tek_req_y
call tek40_dev_cood
call tek_mark
jmp tek41_exec_LF1
tek41_exec_LF:
cmp tek_inpanel,0
je tek41_exec_LF1
jmp tek40_vct_fa
tek41_exec_LF1:
mov ax,tek_req_x
mov tek_cur_x,ax
mov ax,tek_req_y
mov tek_cur_y,ax
jmp tek41_exec_done
;
tek41_exec_LT:
cmp tek_inpanel,0
je tek41_exec_LT1
jmp tek40_ex
tek41_exec_LT1:
mov cx,tek41_nchr ; get number of characters
mov si,offset tek41_argbuf
add si,2 ; 1st 2-bytes contains num of char
call tek_gtxt ; draw graphic text
jmp tek41_exec_done
;
; Begin Panel Boundary
;
tek41_exec_LP:
mov si,offset tek41_fabuf
cmp tek_inpanel,0 ; already in panel mode ?
jne tek41_exec_LP_c1 ; ne=Yes. Close the previous polygon
jmp tek41_exec_LP_1
tek41_exec_LP_c1:
mov ax,tek41_lfa
add si,ax
mov bx,tek41_faadr ; get the address of the 1st point
mov ax,[bx+2] ; get 1st X
mov [si],ax ; add it to the last point
mov ax,[bx+4] ; get 1st Y
mov [si+2],ax ; add it to the last point
add tek41_lfa,4 ; update buffer length
;
cmp tek_panel_bnd,0 ; draw boundary ?
je tek41_exec_LP_c2 ; e=no.
mov ax,[si] ; get the 1st X
mov bx,[si+2] ; get the 1st Y
xchg ax,pc98_x2
xchg bx,pc98_y2
mov pc98_x1,ax
mov pc98_y1,bx
mov ax,pc98_x2
mov bx,pc98_y2
push si ; save buffer address
call tek_draw
pop si
tek41_exec_LP_c2:
add si,4 ; update buffer address
jmp tek41_exec_LP_2
tek41_exec_LP_1:
mov scan_xmin,639
mov scan_xmax,0
mov scan_ymin,399
mov scan_ymax,0
mov tek41_lfa,0
tek41_exec_LP_2:
mov tek41_faadr,si
mov ax,1 ; 1st point
mov [si],ax
mov ax,tek_req_x
mov bx,tek_req_y
mov tek_cur_x,ax
mov tek_cur_y,bx
call tek40_dev_cood
mov [si+2],ax
mov [si+4],bx
mov pc98_x2,ax
mov pc98_y2,bx
cmp ax,scan_xmin
jge tek41_exec_LP_3
mov scan_xmin,ax
tek41_exec_LP_3:
cmp ax,scan_xmax
jle tek41_exec_LP_4
mov scan_xmax,ax
tek41_exec_LP_4:
cmp bx,scan_ymin
jge tek41_exec_LP_5
mov scan_ymin,bx
tek41_exec_LP_5:
cmp bx,scan_ymax
jle tek41_exec_LP_6
mov scan_ymax,bx
tek41_exec_LP_6:
add tek41_lfa,6
mov tek_inpanel,1
mov ax,tek41_ival
mov tek_panel_bnd,al ; set panel boundary mode
test al,1
jz tek41_exec_LP_ex
mov ax,line_type
call tek_ltyp
tek41_exec_LP_ex:
jmp tek41_exec_done
;
tek41_exec_LE:
mov tek_inpanel,0
;
mov si,offset tek41_fabuf
mov ax,tek41_lfa
add si,ax
mov bx,tek41_faadr
mov ax,[bx+2] ; get 1st X
mov [si],ax ; add it to the last point
mov ax,[bx+4] ; get 1st Y
mov [si+2],ax ; add it to the last point
xor ax,ax ; terminator
mov [si+4],ax ; set terminator
add tek41_lfa,6 ; update buffer length
;
cmp tek_panel_bnd,0
je tek41_exec_LE6
mov ax,[si]
mov bx,[si+2]
xchg ax,pc98_x2
xchg bx,pc98_y2
mov pc98_x1,ax
mov pc98_y1,bx
mov ax,pc98_x2
mov bx,pc98_y2
call tek_draw
;
tek41_exec_LE6:
mov si,offset tek41_fabuf
call tek_fill
tek41_exec_LE_ex:
jmp tek41_exec_done
;
tek41_exec_RW:
push ax
push bx
;
; Check the variables
;
mov si,offset tek41_argbuf
mov ax,[si] ; x1
mov bx,[si+4] ; x2
cmp ax,bx
jl tek41_exec_RW1
jmp tek41_exec_RW_ERR
tek41_exec_RW1:
mov ax,[si+2] ; y1
mov bx,[si+6] ; y2
cmp ax,bx
jl tek41_exec_RW2
jmp tek41_exec_RW_ERR
tek41_exec_RW2:
;
; Check OK. Do it.
;
mov ax,[si]
mov tek_wnx1,ax
mov ax,[si+2]
mov tek_wny1,ax
mov ax,[si+4]
mov tek_wnx2,ax
mov ax,[si+6]
mov tek_wny2,ax
;
push si
push di
mov si,offset tek_wnx1
mov di,offset tek_w2v_mat
call set_tek41_mat ; set the transformation matrix
pop di
pop si
jmp tek41_exec_RW_ex
;
tek41_exec_RW_ERR:
tek41_exec_RW_ex:
pop bx
pop ax
jmp tek41_exec_done
;
tek41_exec_TM:
push bx
mov bx,offset tek41_argbuf
mov ax,[bx]
cmp ax,0
je tek41_exec_TM1
mov tek_cmode_1,al
tek41_exec_TM1:
add bx,2
mov ax,[bx]
cmp ax,0
je tek41_exec_TM2
mov tek_cmode_2,al
tek41_exec_TM2:
add bx,2
mov ax,[bx]
cmp ax,0
je tek41_exec_TM3
mov tek_cmode_3,al
tek41_exec_TM3:
pop bx
jmp tek41_exec_done
;
tek41_exec_TG:
push si
mov si,offset tek41_argbuf
mov ax,[si] ; ignore surface number
tek41_exec_TG1:
mov ax,[si+2] ; array size
cmp ax,4 ; must be multiple of 4
jge tek41_exec_TG2
jmp tek41_exec_TG_ex
tek41_exec_TG2:
shr ax,1
shr ax,1 ; number of colors
mov cx,ax
add si,4
tek41_exec_TG_L1:
cmp cx,0
jg tek41_exec_TG_L2
jmp tek41_exec_TG_do
tek41_exec_TG_L2:
mov ax,[si] ; get index
cmp ax,0
jge tek41_exec_TG3
jmp tek41_exec_TG_nx
tek41_exec_TG3:
cmp ax,15
jle tek41_exec_TG4
jmp tek41_exec_TG_nx
tek41_exec_TG4:
cmp tek_cmode_1,1 ; RGB [0-100] mode ?
jne tek41_exec_TG5
jmp tek41_exec_TG_RGB1
tek41_exec_TG5:
cmp tek_cmode_1,2 ; CMY [0-100] mode ?
jne tek41_exec_TG6
jmp tek41_exec_TG_CMY
tek41_exec_TG6:
cmp tek_cmode_1,3 ; HLS mode ?
jne tek41_exec_TG7
jmp tek41_exec_TG_HLS
tek41_exec_TG7:
cmp tek_cmode_1,4 ; RGB [0-255] mode ?
jne tek41_exec_TG8
jmp tek41_exec_TG_RGB2
tek41_exec_TG8:
jmp tek41_exec_TG_ex ; other cases are not supported yet.
tek41_exec_TG_HLS:
push si
add si,2
call HLS_to_RGB
pop si
jmp tek41_exec_TG_RGB1
tek41_exec_TG_CMY:
push bx
mov ax,100
mov bx,[si+2]
sub ax,bx
mov [si+2],ax
mov ax,100
mov bx,[si+4]
sub ax,bx
mov [si+4],ax
mov ax,100
mov bx,[si+6]
sub ax,bx
mov [si+6],ax
pop bx
tek41_exec_TG_RGB1:
push si
add si,2
call RGB100_to_255
pop si
tek41_exec_TG_RGB2:
push bx
mov bx,offset tek_col
mov ax,[si] ; get index
add bx,ax
add bx,ax
add bx,ax
mov ax,[si+2]
mov [bx],al
mov ax,[si+4]
mov [bx+1],al
mov ax,[si+6]
mov [bx+2],al
pop bx
tek41_exec_TG_nx:
dec cx
add si,8 ; 4 integers are processed.
jmp tek41_exec_TG_L1
tek41_exec_TG_do:
mov si,offset tek_col
call set_gpalette
tek41_exec_TG_ex:
pop si
;
tek41_exec_done:
mov tek41_cmd,0
mov tek_esc,0
jmp tek40_ex
;
tek40_vtchg:
cmp tek_P_prv,'?'
jne tek40_vtchg_ex
cmp tek_P_buf,38
jne tek40_vtchg_ex
mov ah,1
mov al,0
mov cx,0
clc
ret
tek40_vtchg_ex:
jmp tek40_esc_ex
; Alpha mode: If printable character, then put the character at
; current position.
;---------
tek40_alp:
;---------
and al,07Fh
cmp al,' ' ; C0 character ?
jae tek40_alp_01 ; ae=no.
jmp tek40_C0
tek40_alp_01:
cmp tek_dialog_area,0 ; dialog on graphic screen ?
je tek40_alp_02 ; e = yes.
mov si,offset vt_buf
mov [si],al
mov cx,1
stc ; set carry to pass the char. to VT
ret
tek40_alp_02:
sub al,' '
xor ah,ah
shl ax,1
shl ax,1
shl ax,1
mov si,offset gfont88
add si,ax
mov di,offset ggdc_buff
mov byte ptr [di],078h ; TEXTW
mov byte ptr [di+1],8 ; number of parameters
add di,2
cld
mov cx,8
push es
push ds
pop es
rep movsb
pop es
; add di,8
mov ax,tek_cur_x
mov bx,tek_cur_y
call tek40_dev_cood
push di
;@@ mov cx,GGDC_GREEN_PLANE ; cursor graphic plane
xor cx,cx
call gcsrw
mov byte ptr [di],20h
mov byte ptr [di+1],0
add di,2
mov byte ptr [di],04Ch ; VEXTW
mov byte ptr [di+1],3 ; number of parameters
mov byte ptr [di+2],012h ; normal text dir=2
mov byte ptr [di+3],07h
mov byte ptr [di+4],0
mov byte ptr [di+5],068h ; TEXTE
mov byte ptr [di+6],0
mov byte ptr [di+7],0FFh ; terminator
mov si,offset ggdc_buff
;@@ call send_to_GGDC
mov ax,tek_txcol ; set text color
pop di
call GGDC_color
mov ax,TEK_DX
add tek_cur_x,ax
jmp tek40_ex
;--------
tek40_C0:
;--------
cmp al,ESCAPE ; need to handle in this module?
jl tek40_C01 ; l=no. May go to vt
jmp tek40_C02
tek40_C01:
cmp tek_dialog_area,0 ; dialog on graphics ?
je tek40_C01_1 ; e=yes.
mov tek_esc,0
mov tek_mod,0
mov si,offset vt_buf
mov [si],al
mov cx,1
stc ; set carry to pass AL to VT
ret
tek40_C01_1:
mov tek_esc,0
mov tek_mod,0
cmp al,BELL
jne tek40_n07
call pc98_bell
jmp tek40_ex
tek40_n07:
cmp al,BS
jne tek40_n08
sub tek_cur_x,TEK_DX
cmp tek_cur_x,0
jge tek40_08_01
mov tek_cur_x,0
tek40_08_01:
mov tek_esc,0
jmp tek40_ex
tek40_n08:
;
cmp al,HT
jne tek40_n09
add tek_cur_x,TEK_DX
cmp tek_cur_x,TEK_X_MAX
jle tek40_09_01
mov tek_cur_x,TEK_X_MAX
tek40_09_01:
mov tek_esc,0
jmp tek40_ex
tek40_n09:
;
cmp al,LF
jne tek40_n0A
sub tek_cur_y,TEK_DY
cmp tek_cur_y,0
jge tek40_0A_01
mov tek_cur_y,TEK_Y_MAX
sub tek_cur_y,TEK_DY
tek40_0A_01:
mov tek_esc,0 ; ESC seq done
jmp tek40_ex
tek40_n0A:
;
cmp al,VT
jne tek40_n0B
jmp tek40_ex
tek40_n0B:
cmp al,CR
jne tek40_n0D
mov tek_cur_x,0
mov tek_mod,0 ; enter alpha mode
mov tek_esc,0 ; ESC seq done
jmp tek40_ex
tek40_n0D:
;
cmp al,CL_CAN
jne tek40_n18
mov tek_mod,0
mov tek_esc,0
;
; Leave tektronix mode if tek4010 enabled
;
test vt100_flags,AUTOTEK_BIT
jz tek40_18_01
mov ah,1 ; pass no character
mov al,0
mov cx,0
clc
ret
tek40_18_01:
jmp tek40_ex
tek40_n18:
;
; ESC, FS, GS, RS, US must be analyzed in TeK module
;
tek40_C02:
cmp al,ESCAPE
jne tek40_n1B
mov tek_esc,1 ; initiate ESC sequence
jmp tek40_ex
tek40_n1B:
;
cmp al,FS
jne tek40_n1C
mov tek_mod,2 ; enter point plot mode
mov tek_vseq,0 ; reset xy order sequence
mov di,offset ggdc_buff
mov byte ptr [di],078h ; TEXTW command
mov byte ptr [di+1],2 ; number of parameters
mov word ptr [di+2],0FFFFh ; set line type to solid
mov byte ptr [di+4],0FFh ; terminator
mov si,offset ggdc_buff
call send_to_GGDC
mov tek_esc,0 ; ESC seq done
jmp tek40_ex
tek40_n1C:
;
cmp al,GS
jne tek40_n1D
mov tek_mod,1 ; enter graph mode
mov tek_npnt,0 ; reset number of points
mov tek_vseq,0
mov ax,line_type
call tek_ltyp
mov tek_esc,0 ; ESC seq done
jmp tek40_ex
tek40_n1D:
;
cmp al,RS
jne tek40_n1E
mov tek_mod,3 ; enter incremental plot mode
mov tek_pen,0 ; reset pen state
mov di,offset ggdc_buff
mov byte ptr [di],078h ; TEXTW command
mov byte ptr [di+1],2 ; number of parameters
mov word ptr [di+2],0FFFFh ; set line type to solid
mov byte ptr [di+4],0FFh ; terminator
mov si,offset ggdc_buff
call send_to_GGDC
mov tek_esc,0 ; ESC seq done
jmp tek40_ex
tek40_n1E:
;
cmp al,US
jne tek40_n1F
mov tek_mod,0 ; enter alpha mode
mov line_type,0
mov tek_esc,0 ; ESC seq done
jmp tek40_ex
tek40_n1F:
mov tek_esc,0 ; Unknonw C0 character
jmp tek40_ex
;---------
tek40_vct:
;---------
and al,07Fh ; Mask 8th bit
cmp al,' ' ; Control character ?
jae tek40_vct_01 ; ae = No.
cmp al,ESCAPE
jae tek40_vct_C0
cmp al,CR
jne tek40_vct_n0D
cmp tek_dialog_area,0 ; disable dialog ?
je tek40_vct_C0 ; e=yes.
tek40_vct_n0D:
jmp tek40_ex ; any other C0 characters are ignored.
tek40_vct_C0:
jmp tek40_C0 ; Yes. control character.
tek40_vct_01:
mov ah,al
and ah,060h
and al,01Fh
;
cmp tek_vseq,0
jne tek40_vct_02
tek40_vct_HIY:
cmp ah,HIY ; HIY data ?
jne tek40_vct_EXT
mov tek_cur_HIY,al ; Yes. Fill HIY
mov tek_vseq,1 ; Next is EXT
jmp tek40_vct_end
tek40_vct_02:
cmp tek_vseq,1 ; EXT order?
jne tek40_vct_03
tek40_vct_EXT:
cmp ah,EXT ; EXT data ?
jne tek40_vct_LOY
mov tek_cur_LOY,al ; Yes. Temporary store to LOY
mov tek_vseq,2 ; Next is LOY
jmp tek40_vct_end
tek40_vct_03:
cmp tek_vseq,2 ; LOY order ?
jne tek40_vct_04
tek40_vct_LOY:
cmp ah,LOY ; LOY data ?
jne tek40_vct_HIX
mov ah,tek_cur_LOY ; Yes. LOY/EXT appears twice.
mov tek_cur_EXT,ah ; Previous is EXT and current is LOY
mov tek_cur_LOY,al
mov tek_vseq,3 ; Next is HIX
jmp tek40_vct_end
tek40_vct_04:
cmp tek_vseq,3 ; HIX order ?
jne tek40_vct_05
tek40_vct_HIX:
cmp ah,HIX ; HIX data ?
jne tek40_vct_LOX ; No. Test LOX data
mov tek_cur_HIX,al ; Yes. Set HIX
mov tek_vseq,4 ; Next is LOX
jmp tek40_vct_end
tek40_vct_05:
cmp tek_vseq,4 ; LOX order ?
jne tek40_vct_ERR
tek40_vct_LOX:
cmp ah,LOX ; LOX data ?
jne tek40_vct_ERR ; No. This is error
mov tek_cur_LOX,al ; Yes. Set LOX
mov tek_vseq,0 ; GS seq done
jmp tek40_get_xy
tek40_vct_ERR:
call pc98_bell
mov tek_vseq,0
mov tek_npnt,0
cmp tek_esc,4 ; in Tek41 command ?
jne tek40_vct_ERR1 ; ne = no.
mov tek_req_x,0
mov tek_req_y,0
jmp tek41_xy1
tek40_vct_ERR1:
jmp tek40_vct_end
;
; Convert TEK xy representation to the binary (x,y)
;
tek40_get_xy:
mov al,tek_cur_HIY ; get HIY
xor ah,ah ; clear higher byte
mov cl,5 ; number of shifts
shl ax,cl ; HIY done
or al,tek_cur_LOY ; add LOY
shl ax,1
shl ax,1
mov bl,tek_cur_EXT ; get EXT
shr bl,1
shr bl,1
and bl,3 ; Lower 2 bits have meaning
or al,bl ; all done.
mov tek_req_y,ax ; set requested y
;
mov al,tek_cur_HIX ; get HIX
xor ah,ah ; clear higher byte
mov cl,5 ; number of shifts
shl ax,cl ; HIX is set
or al,tek_cur_LOX ; add LOX
shl ax,1
shl ax,1
mov bl,tek_cur_EXT ; get EXT
and bl,3 ; Only lower 2 bits have meaning
or al,bl ; all done.
mov tek_req_x,ax ; set requested x
;
cmp tek_esc,4 ; in TeK41 command ?
jne tek40_get_xy1 ; ne = no.
jmp tek41_xy1
tek40_get_xy1:
cmp tek_inpanel,0 ; in Panel mode ?
je tek40_get_xy2 ; e = no.
jmp tek40_vct_fa
tek40_get_xy2:
;
cmp tek_mod,1
je tek40_vec_ln
jmp tek40_vct_pt
tek40_vec_ln:
cmp tek_npnt,0
jne tek40_vct_ln01
mov tek_npnt,1
jmp tek40_vct_do1
;
tek40_vct_ln01:
;
; Not the first point. Draw line.
;
mov ax,tek_cur_x
mov bx,tek_cur_y
call tek40_dev_cood
mov pc98_x1,ax
mov pc98_y1,bx
mov ax,tek_req_x
mov bx,tek_req_y
call tek40_dev_cood
mov pc98_x2,ax
mov pc98_y2,bx
call tek_draw
jmp tek40_vct_do1
;
; Point plot mode
;
tek40_vct_pt:
mov ax,tek_req_x
mov bx,tek_req_y
call tek40_dev_cood
call tek_mark
;
tek40_vct_do:
mov di,si
;@@ call send_to_GGDC
call GGDC_color
tek40_vct_do1:
mov ax,tek_req_x
mov tek_cur_x,ax
mov ax,tek_req_y
mov tek_cur_y,ax
jmp tek40_vct_end
;
tek40_vct_fa:
mov ax,tek_req_x
mov bx,tek_req_y
call tek40_dev_cood
mov cx,tek41_lfa
add cx,10 ; requested length
cmp cx,TEK41_FABUF_SIZE ; have enough room ?
jbe tek40_vct_fa1 ; be=yes
jmp tek40_vct_fa2
tek40_vct_fa1:
push si
mov si,offset tek41_fabuf
add si,tek41_lfa
mov [si],ax
mov [si+2],bx
add tek41_lfa,4
mov si,tek41_faadr
mov cx,[si]
inc cx
mov [si],cx ; increment number of points
pop si
cmp ax,scan_xmin
jge tek40_vct_fa1_1
mov scan_xmin,ax
tek40_vct_fa1_1:
cmp ax,scan_xmax
jle tek40_vct_fa1_2
mov scan_xmax,ax
tek40_vct_fa1_2:
cmp bx,scan_ymin
jge tek40_vct_fa1_3
mov scan_ymin,bx
tek40_vct_fa1_3:
cmp bx,scan_ymax
jle tek40_vct_fa1_4
mov scan_ymax,bx
tek40_vct_fa1_4:
tek40_vct_fa2:
cmp tek_panel_bnd,0
je tek40_vct_end
xchg ax,pc98_x2
xchg bx,pc98_y2
mov pc98_x1,ax
mov pc98_y1,bx
mov ax,pc98_x2
mov bx,pc98_y2
call tek_draw
tek40_vct_end:
jmp tek40_ex
;
; Incremental Plot
;
tek40_inc:
and al,07Fh ; mask 8th bit
cmp al,'A' ; move to right?
jne tek40_inc_NA ; ne = no
inc tek_cur_x
jmp tek40_inc_do
tek40_inc_NA:
cmp al,'B' ; move to left?
jne tek40_inc_NB ; ne = no.
dec tek_cur_x
jmp tek40_inc_do
tek40_inc_NB:
cmp al,'D' ; move to up?
jne tek40_inc_ND ; ne = no.
inc tek_cur_y
jmp tek40_inc_do
tek40_inc_ND:
cmp al,'H' ; move to down?
jne tek40_inc_NH ; ne = no.
dec tek_cur_y
jmp tek40_inc_do
tek40_inc_NH:
cmp al,'E' ; move to right up
jne tek40_inc_NE
inc tek_cur_x
inc tek_cur_y
jmp tek40_inc_do
tek40_inc_NE:
cmp al,'J'
jne tek40_inc_NJ
dec tek_cur_x
dec tek_cur_y
jmp tek40_inc_do
tek40_inc_NJ:
cmp al,'F'
jne tek40_inc_NF
dec tek_cur_x
inc tek_cur_y
jmp tek40_inc_do
tek40_inc_NF:
cmp al,'I'
jne tek40_inc_NI
inc tek_cur_x
dec tek_cur_y
jmp tek40_inc_do
tek40_inc_NI:
cmp al,' '
jne tek40_inc_NS
mov tek_pen,0
jmp tek40_ex
tek40_inc_NS:
cmp al,'P'
jne tek40_inc_NP
mov tek_pen,1
jmp tek40_ex
tek40_inc_NP:
mov tek_mod,0 ; Enter alpha mode
jmp tek40_00
tek40_inc_do:
cmp tek_pen,0
jne tek40_inc_do1
jmp tek40_ex
tek40_inc_do1:
mov di,offset ggdc_buff
mov ax,tek_cur_x
mov bx,tek_cur_y
call tek40_dev_cood
;@@ mov cx,GGDC_GREEN_PLANE
xor cx,cx
call gcsrw
mov byte ptr [di],20h
mov byte ptr [di+1],0
add di,2
;
mov byte ptr [di],4ch ; VECTW command
mov byte ptr [di+1],9 ; number of parameters
;
mov byte ptr [di+2],0 ; dir
mov word ptr [di+3],0 ; abs(d_x)
mov word ptr [di+5],0 ; 2*abs(d_y)-abs(d_x)
mov word ptr [di+7],0 ; 2*abs(d_y)-2*abs(d_x)
mov word ptr [di+9],0 ; 2*abs(d_y)
;
mov byte ptr [di+11],6ch ; VECTE command
mov byte ptr [di+12],0 ; with no parameters
add di,13 ; update address
;
mov byte ptr [di],0FFh ; set terminator
mov si,offset ggdc_buff
mov ax,tek_lncol ; set line color
;
mov di,si
;@@ call send_to_GGDC
call GGDC_color
jmp tek40_ex
;
TEK4014 ENDP
;
tek_ltyp proc near
;
; Set line type in AX
;
shl ax,1
mov si,offset line_type_table
add si,ax
mov ax,[si]
mov di,offset ggdc_buff
mov byte ptr [di],078h ; TEXTW command
mov byte ptr [di+1],2 ; number of parameters
mov word ptr [di+2],ax ; line type
mov byte ptr [di+4],0FFh ; terminator
mov si,offset ggdc_buff
call send_to_GGDC
ret
tek_ltyp endp
;
tek_draw proc near
;
; Draw line between from (pc98_x1,pc98_y1) to (ax,bx)
;
push ax
push bx
mov di,offset ggdc_buff
mov ax,pc98_x1
mov bx,pc98_y1
xor cx,cx
call gcsrw
mov byte ptr [di],20h
mov byte ptr [di+1],0
add di,2
pop bx
pop ax
sub ax,pc98_x1
sub bx,pc98_y1
call gline
mov byte ptr [di],0FFh
mov si,offset ggdc_buff
mov ax,tek_lncol
mov di,si
call GGDC_color
ret
tek_draw endp
;
tek_mark proc near
;
; Put marker at (ax,bx) given in device coordinate
;
cmp marker_type,0 ; marker type 0 ?
je tek_mark_0 ; e=yes
jmp tek_mark_n0
tek_mark_0:
xor cx,cx
call gcsrw
mov byte ptr [di],20h
mov byte ptr [di+1],0
add di,2
;
mov byte ptr [di],4ch ; VECTW command
mov byte ptr [di+1],9 ; number of parameters
;
mov byte ptr [di+2],0 ; dir
mov word ptr [di+3],0 ; abs(d_x)
mov word ptr [di+5],0 ; 2*abs(d_y)-abs(d_x)
mov word ptr [di+7],0 ; 2*abs(d_y)-2*abs(d_x)
mov word ptr [di+9],0 ; 2*abs(d_y)
;
mov byte ptr [di+11],6ch ; VECTE command
mov byte ptr [di+12],0 ; with no parameters
add di,13 ; update address
;
mov byte ptr [di],0FFh ; set terminator
mov si,offset ggdc_buff
mov ax,tek_lncol ; set line color
mov di,si
jmp tek_mark_do
tek_mark_n0:
push ax
push bx
mov ax,marker_type
xor ah,ah
shl ax,1
shl ax,1
shl ax,1
mov si,offset gmark88
add si,ax
mov di,offset ggdc_buff
mov byte ptr [di],078h ; TEXTW
mov byte ptr [di+1],8 ; number of parameters
add di,2
cld
mov cx,8
push es
push ds
pop es
rep movsb
pop es
;@@ add di,8
mov byte ptr [di],0ffh ; set terminator
mov si,offset ggdc_buff
call send_to_GGDC
pop bx
pop ax ; remember x position
add ax,mark_dx
add bx,mark_dy
mov di,offset ggdc_buff
xor cx,cx
call gcsrw
mov byte ptr [di],20h
mov byte ptr [di+1],0
add di,2
mov byte ptr [di],04Ch ; VECTW
mov byte ptr [di+1],3 ; number of parameters
mov byte ptr [di+2],012h ; normal text dir=2
mov byte ptr [di+3],07h
mov byte ptr [di+4],0
mov byte ptr [di+5],068h ; TEXTE
mov byte ptr [di+6],0
mov byte ptr [di+7],0FFh ; terminator
mov di,offset ggdc_buff
mov si,di
mov ax,tek_lncol ; set marker color
tek_mark_do:
call GGDC_color
ret
tek_mark endp
;
tek_gtxt proc near
;
; Write Graphic Text
; cx number of characters
; [si] strings
;
tek_gtxt1:
cmp cx,0
jg tek_gtxt2
jmp tek_gtxt_ex
tek_gtxt2:
push cx
push si
;
mov al,[si]
and al,07Fh
cmp al,' '
jae tek_gtxt3
mov al,' '
tek_gtxt3:
sub al,' '
xor ah,ah
shl ax,1
shl ax,1
shl ax,1
mov si,offset gfont88
add si,ax
mov di,offset ggdc_buff
mov byte ptr [di],078h ; TEXTW
mov byte ptr [di+1],8 ; number of parameters
add di,2
cld
mov cx,8
push es
push ds
pop es
rep movsb
pop es
; add di,8
mov byte ptr [di],0FFh ; set terminator
mov si,offset ggdc_buff
call send_to_GGDC
;
mov ax,tek_cur_x
mov bx,tek_cur_y
call tek40_dev_cood
mov di,offset ggdc_buff
;@@ mov cx,GGDC_GREEN_PLANE ; cursor graphic plane
xor cx,cx
call gcsrw
mov byte ptr [di],20h
mov byte ptr [di+1],0
add di,2
mov byte ptr [di],04Ch ; VEXTW
mov byte ptr [di+1],3 ; number of parameters
mov al,010h ; normal text
or al,tek_gtxt_dr ; set text dir
mov byte ptr [di+2],al
mov byte ptr [di+3],07h
mov byte ptr [di+4],0
mov byte ptr [di+5],068h ; TEXTE
mov byte ptr [di+6],0
mov byte ptr [di+7],0FFh ; terminator
mov si,offset ggdc_buff
mov di,si
;@@ call send_to_GGDC
mov ax,tek_lncol ; set text color
call GGDC_color
mov ax,tek_gtxt_ux
add tek_cur_x,ax
mov ax,tek_gtxt_uy
add tek_cur_y,ax
;
pop si
pop cx
inc si
dec cx
jmp tek_gtxt1
tek_gtxt_ex:
ret
tek_gtxt endp
;
; Routines for Fill Area
;
scan_clr proc near
;
; Purpose: Clear the scan buffer, scan_buf.
; Input: none
; Output: none
;
push ax
push cx
push di
push es
;
cld
mov cx,40 ; size of the scan buffer in words
mov di,offset scan_buf
push ds
pop es ; es = ds
xor ax,ax ; data
rep stosw ; string clear
;
pop es
pop di
pop cx
pop ax
ret
scan_clr endp
;
scan_cross proc near
;
; Purpose: calculate the cross point of the line and scan_y
; Input: san_y, [si], scan_xmin, scan_xmax, bit_on
; Output: scan_buf
; WorkArea: pc98_x1, pc98_y1, pc98_x2, pc98_y2
;
push ax
push bx
push dx
;
mov ax,[si+2] ; y1
mov bx,[si+6] ; y2
cmp bx,ax ; y2 > y1 ?
jg scan_cross_1 ; g=yes
mov pc98_y1,bx
mov pc98_y2,ax
mov ax,[si+4]
mov bx,[si]
jmp scan_cross_2
scan_cross_1:
mov pc98_y1,ax
mov pc98_y2,bx
mov ax,[si]
mov bx,[si+4]
scan_cross_2:
mov pc98_x1,ax
mov pc98_x2,bx
mov ax,scan_y
cmp ax,pc98_y1 ; scan_y >= y1
jge scan_cross_3 ; ge=yes
jmp scan_cross_ex
scan_cross_3:
cmp ax,pc98_y2 ; scan_y < y2
jl scan_cross_4 ; l=yes
jmp scan_cross_ex
scan_cross_4:
sub ax,pc98_y1 ; ax = scan_y - y1
mov bx,pc98_x2
sub bx,pc98_x1 ; bx = x2 - x1
imul bx ; dx:ax =(scan_y - y1)*(x2-x1)
mov bx,pc98_y2
sub bx,pc98_y1 ; bx = y2 - y1
idiv bx ; dx:ax =(scan_y-y1)*(x2-x1)/(y2-y1)
add ax,pc98_x1
cmp ax,scan_xmin ; scan_x < xmin ?
jge scan_cross_5 ; ge = no
mov ax,scan_xmin
scan_cross_5:
cmp ax,scan_xmax ; scan_x > xmax ?
jle scan_cross_6 ; le = no
mov ax,scan_xmax
scan_cross_6:
push ax
and ax,07h
mov bx,offset bit_on
add bx,ax
mov dl,[bx]
pop ax
mov bx,offset scan_buf
shr ax,1
shr ax,1
shr ax,1
add bx,ax
xor [bx],dl
scan_cross_ex:
pop dx
pop bx
pop ax
ret
scan_cross endp
;
scan_fill proc near
;
; fill the scan line
;
push ax
push bx
push cx
push dx
push si
;
mov si,offset scan_buf
add si,scan_xstr
mov dx,0ff00h ; dh:fill, dl:no-fill
mov cx,scan_xlen
scan_fill_1:
mov al,[si]
cmp al,0
jne scan_fill_2
mov [si],dl
jmp scan_fill_5
scan_fill_2:
push cx
mov cx,8
mov bx,offset bit_on
scan_fill_3:
mov ah,[bx]
and ah,al
cmp ah,0
je scan_fill_4
xchg dh,dl
scan_fill_4:
mov ah,[bx]
and ah,dl
or [si],ah
inc bx
loop scan_fill_3
pop cx
scan_fill_5:
inc si
loop scan_fill_1
pop si
pop dx
pop cx
pop bx
pop ax
ret
scan_fill endp
;
scan_put proc near
;
; Put the scan line to the graphic screen
;
push es
cld
mov dx,1
xor ch,ch
mov cl,gplane_nums
mov bx,offset gplane_segm
scan_put1:
push bx
push cx
mov ax,[bx]
mov es,ax
mov di,scan_ofs
mov si,offset scan_buf
add si,scan_xstr
mov cx,scan_xlen
test tek_facol,dx
jz scan_put3
scan_put2:
lodsb
or es:[di],al
inc di
loop scan_put2
jmp scan_put4
scan_put3:
lodsb
xor al,0ffh
and es:[di],al
inc di
loop scan_put3
scan_put4:
pop cx
pop bx
add bx,2
shl dx,1
loop scan_put1
scan_put_ex:
pop es
ret
scan_put endp
;
tek_fill proc near
;
; Fill area
;
mov ax,scan_ymin
mov scan_y,ax
shl ax,1
shl ax,1
add ax,scan_y ; ax=scan_y*5
mov cx,4
shl ax,cl ; ax=scan_y*80
mov scan_ofs,ax
mov ax,scan_xmin
mov cx,3
shr ax,cl
mov scan_xstr,ax ; start byte address in x
add scan_ofs,ax
mov ax,scan_xmax
mov cx,3
shr ax,cl
sub ax,scan_xstr
inc ax
mov scan_xlen,ax
;
cmp gdisp_mode,0
je tek_fill_1
jmp tek_fill_GC1
tek_fill_1:
mov ax,scan_y
cmp ax,scan_ymax
jle tek_fill_2
jmp tek_fill_ex
tek_fill_2:
call scan_clr ; clear the scan buffer
mov si,offset tek41_fabuf ; position of the line
;
tek_fill_3:
mov cx,[si] ; get number of points
jcxz tek_fill_5
add si,2
tek_fill_4:
call scan_cross
add si,4
loop tek_fill_4
add si,4
jmp tek_fill_3
tek_fill_5:
call scan_fill
call scan_put
inc scan_y
add scan_ofs,80
jmp tek_fill_1
;
tek_fill_GC1:
cld
mov al,0C0h ; GRCG on, RMW mode, all planes are active
out 7Ch,al
mov cx,4
mov dx,1
tek_fill_GC2:
test tek_facol,dx
jz tek_fill_GC3
mov al,0FFh
jmp tek_fill_GC4
tek_fill_GC3:
mov al,0
tek_fill_GC4:
out 7Eh,al ; write tile reg.
shl dx,1
loop tek_fill_GC2
;
push es
tek_fill_GC5:
mov ax,scan_y
cmp ax,scan_ymax
jg tek_fill_GC7
call scan_clr ; clear the scan buffer
mov si,offset tek41_fabuf ; position of the line
tek_fill_GC8:
mov cx,[si] ; number of lines
jcxz tek_fill_GC9
add si,2
tek_fill_GC6:
call scan_cross
add si,4
loop tek_fill_GC6
add si,4
jmp tek_fill_GC8
tek_fill_GC9:
call scan_fill
mov di,scan_ofs
mov ax,gplane_segm
mov es,ax
mov si,offset scan_buf
add si,scan_xstr
mov cx,scan_xlen
rep movsb
inc scan_y
add scan_ofs,80
jmp tek_fill_GC5
tek_fill_GC7:
mov al,040h ; GRCG off
out 7Ch,al
pop es
;
tek_fill_ex:
ret
tek_fill endp
;
tek41_getcol proc near
;
; convert tek41 color index to normal index
;
push bx
and ax,0fh
mov bx,offset tek41_col
add bx,ax
mov ax,[bx]
pop bx
ret
tek41_getcol endp
;
set_gcolor proc near
;
; set graphic color
;
push ax
push si
mov al,vt100_gflag
and al,07Fh ; mask text screen ctrl bit
cmp al,0
jne set_gcolor_n0
mov si,offset gnrm_color
jmp set_gcolor_do
set_gcolor_n0:
cmp al,1
jne set_gcolor_n1
mov si,offset gbck_color
jmp set_gcolor_do
set_gcolor_n1:
cmp al,2
jne set_gcolor_n2
mov si,offset sixel_col
jmp set_gcolor_do
set_gcolor_n2:
cmp al,3
jne set_gcolor_n3
mov si,offset sixel_col
jmp set_gcolor_do
set_gcolor_n3:
cmp al,4
jne set_gcolor_n4
mov si,offset tek_col
jmp set_gcolor_do
set_gcolor_n4:
cmp al,5
jne set_gcolor_n5
mov si,offset tek_col
jmp set_gcolor_do
set_gcolor_n5:
jmp set_gcolor_ex
set_gcolor_do:
call set_gpalette
call gdisp_on
mov al,1
test vt100_gflag,80h
jz set_gcolor_do1
mov al,tek_dialog_vsbl
set_gcolor_do1:
call text_scrn
set_gcolor_ex:
pop si
pop ax
ret
set_gcolor endp
;
sixel_clear proc near
call gcls
ret
sixel_clear endp
sixel_in proc near
call gcls
mov si,offset sixel_col
call set_gpalette
call gdisp_on
mov sixel_x,0
mov sixel_y,0
mov sixel_state,0
mov repeat_count,0
mov sixel_nbuf,0
mov sixel_palette,4
ret
sixel_in endp
;
sixel proc near
cmp al,018h ; CAN ?
je sixel_0 ; e = yes
cmp al,01bh ; ESC ?
je sixel_0 ; e = yes
cmp al,01fh
ja sixel_0
jmp sixel_ex ; ignore other 0/0 - 0/15 characters
sixel_0:
cmp sixel_state,0
jne sixel_num
jmp sixel_1
;
; sixel number (decimal characters)
sixel_num:
cmp al,'0'
jae sixel_num1
jmp sixel_num_ex
sixel_num1:
cmp al,'9'
jbe sixel_num2
jmp sixel_num_ex
sixel_num2:
xor ah,ah
sub al,'0'
push ax
mov ax,sixel_nbuf
add sixel_nbuf,ax
mov cx,3
shl ax,cl
add sixel_nbuf,ax ; sixel_nbuf *= 10
pop ax
add sixel_nbuf,ax
jmp sixel_ex
;
sixel_num_ex:
cmp sixel_state,SIXEL_IN_REPEAT
jne sixel_num_ex1
jmp sixel_num_exr
sixel_num_ex1:
cmp sixel_state,SIXEL_IN_PALETTE
jne sixel_num_ex2
jmp sixel_num_exp
sixel_num_ex2:
jmp sixel_num_exx
sixel_num_exr:
push ax
mov ax,sixel_nbuf
mov repeat_count,ax
pop ax
jmp sixel_num_exx
sixel_num_exp:
push ax
push di
mov di,offset sixel_palette
mov ax,sixel_pal_dest
add di,ax
add di,ax
mov ax,sixel_nbuf
mov [di],ax
pop di
pop ax
cmp al,';'
je sixel_num_exp_1
jmp sixel_num_exp_x
sixel_num_exp_1:
add sixel_pal_dest,1
mov sixel_nbuf,0
jmp sixel_ex
sixel_num_exp_x:
cmp sixel_pal_dest,4
je sixel_num_exp_s
mov sixel_pal_dest,0
jmp sixel_num_exx
sixel_num_exp_s:
push si
mov si,offset sixel_palette
cmp WORD PTR [si+2],1
jne sixel_num_exp_s1
add si,4
call HLS_to_RGB
jmp sixel_num_exp_s2
sixel_num_exp_s1:
add si,4
sixel_num_exp_s2:
call RGB100_to_255
push ax
push bx
mov bx,offset sixel_col
mov ax,sixel_palette
add bx,ax
add bx,ax
add bx,ax
mov ax,[si] ; R value
mov [bx],al
mov ax,[si+2] ; G value
mov [bx+1],al
mov ax,[si+4] ; B value
mov [bx+2],al
mov si,offset sixel_col
call set_gpalette
pop bx
pop ax
pop si
sixel_num_exx:
mov sixel_nbuf,0
;
sixel_1:
cmp al,07Eh
ja sixel_2
cmp al,03Fh
jb sixel_2 ; b=no. special char.
mov sixel_state,0
xor ah,ah
sub al,03Fh
call sixel_put
mov sixel_state,0 ; clear the sixel state
mov sixel_nbuf,0
mov repeat_count,0 ; clear the repeat counter
jmp sixel_ex
sixel_2:
cmp al,'!' ; repeat count prefix ?
jne sixel_2_1 ; ne = no.
mov sixel_state,SIXEL_IN_REPEAT ; yes, set repeat count flag
mov repeat_count,0 ; and clear the counter
mov sixel_nbuf,0
jmp sixel_ex
sixel_2_1:
cmp al,'#' ; palette ?
jne sixel_3 ; ne = no.
mov sixel_state,SIXEL_IN_PALETTE
mov sixel_pal_dest,0
mov sixel_nbuf,0
jmp sixel_ex
sixel_3:
cmp al,'$' ; Graphic CR ?
jne sixel_4 ; ne = no.
mov sixel_x,0 ; yes, go to left margin
mov sixel_state,0 ; clear the sixel state
mov repeat_count,0 ; and clear the counter
jmp sixel_ex
sixel_4:
cmp al,'-' ; Graphic NL ?
jne sixel_5 ; ne = no.
mov sixel_x,0 ; yes, go to left margin
xor cx,cx ; and move Y by repeat count
sixel_4_1:
add sixel_y,6
inc cx
cmp cx,repeat_count
jl sixel_4_1
mov sixel_state,0
mov repeat_count,0
jmp sixel_ex
sixel_5:
cmp al,020h ; character ?
jb sixel_ex ; b=no. it's control char.
cmp al,07Fh ; DEL/C1/GR ?
jae sixel_ex ; e=yes. ignore it.
mov sixel_state,0
mov repeat_count,0
sixel_ex:
ret
sixel endp
;
; Light on the bits in BH if the plane index is on,
; Light off the bits in BL if the plane index is off.
;
sixel_plane_on proc near
push ax
push bx
mov bl,bh
xor bl,0ffh
mov ax,sixel_segm
add ax,CPU_BLUE_PLANE
mov es,ax
test sixel_palette,1
jz sixel_plane_on1
or es:[si],bh
jmp sixel_plane_on2
sixel_plane_on1:
and es:[si],bl
sixel_plane_on2:
mov ax,sixel_segm
add ax,CPU_RED_PLANE
mov es,ax
test sixel_palette,2
jz sixel_plane_on3
or es:[si],bh
jmp sixel_plane_on4
sixel_plane_on3:
and es:[si],bl
sixel_plane_on4:
mov ax,sixel_segm
add ax,CPU_GREEN_PLANE
mov es,ax
test sixel_palette,4
jz sixel_plane_on5
or es:[si],bh
jmp sixel_plane_on6
sixel_plane_on5:
and es:[si],bl
sixel_plane_on6:
mov ax,sixel_segm
add ax,CPU_EXTRA_PLANE
mov es,ax
test sixel_palette,8
jz sixel_plane_on7
or es:[si],bh
jmp sixel_plane_on8
sixel_plane_on7:
and es:[si],bl
sixel_plane_on8:
pop bx
pop ax
ret
sixel_plane_on endp
;
; put sixel character in AL to the graphic screen
;
sixel_put proc near
push si
push es
mov sixel_char,al ; save the sixel character
cmp sixel_y,SIXEL_YMAX
jle sixel_put_1
mov ax,sixel_y
sub ax,SIXEL_YMAX
mov cx,ax
;@@ call sixel_mono_scroll
call sixel_col_scroll
mov sixel_y,SIXEL_YMAX
sixel_put_1:
cmp sixel_x,SIXEL_XMAX
jle sixel_put_2
jmp sixel_put_6
sixel_put_2:
mov ax,sixel_y
mov sixel_segm,ax
shl ax,1
shl ax,1
add sixel_segm,ax ; sixel_segm = sixel_y*5 + segm_0
mov ax,sixel_x
shr ax,1
shr ax,1
shr ax,1
mov sixel_byte,ax ; sixel_byte = sixel_x / 8
mov ax,sixel_x
and ax,07h ; ax = sixel_x % 8
cmp ax,0 ; byte boundary ?
jne sixel_put_2_1 ; ne = no, not.
cmp repeat_count,8 ; repeat_count >= 8 ?
jl sixel_put_2_1 ; l = no, not.
jmp sixel_put_byte1
sixel_put_2_1:
mov bx,offset bit_on
add bx,ax
mov cl,[bx]
mov sixel_on,cl ; bit mask to ON the graphic bit
mov bx,offset bit_off
add bx,ax
mov cl,[bx]
mov sixel_off,cl ; bit mask to OFF the graphic bit
mov cx,6 ; repeat count
cld
mov si,sixel_byte
mov al,sixel_char
mov dl,1
sixel_put_3:
test al,dl
jz sixel_put_4
mov bh,sixel_on
call sixel_plane_on
jmp sixel_put_5
sixel_put_4:
cmp sixel_replace,1 ; replace mode?
jne sixel_put_5 ; ne=no.
mov bh,sixel_off
and es:[si],bh
sixel_put_5:
shl dl,1
add si,80
loop sixel_put_3
sixel_put_6:
add sixel_x,1
dec repeat_count
jmp sixel_put_7
;
sixel_put_byte1:
mov ax,sixel_segm
mov es,ax
mov cx,6 ; repeat count
cld
mov si,sixel_byte
mov al,sixel_char
mov dl,1
sixel_put_byte3:
test al,dl
jz sixel_put_byte4
mov bh,0ffh
call sixel_plane_on
jmp sixel_put_byte5
sixel_put_byte4:
cmp sixel_replace,1 ; replace mode?
jne sixel_put_byte5 ; ne=no.
mov bh,0
mov es:[si],bh
sixel_put_byte5:
shl dl,1
add si,80
loop sixel_put_byte3
sixel_put_byte6:
add sixel_x,8
sub repeat_count,8
;
sixel_put_7:
cmp repeat_count,0
jle sixel_put_8
jmp sixel_put_1
sixel_put_8:
mov repeat_count,0
pop es
pop si
ret
sixel_put endp
;
sixel_mono_scroll proc near
;
; scroll up CX lines
;
push bx
push si
push di
push es
push ds
;
cld
;
mov si,0 ; offset of the top of the buffer
mov di,0 ; for both dest. and source.
mov ax,cx
add ax,cx
shl ax,1
add ax,cx ; ax = n * 5, number of para.
mov bx,ax ; save it for later use
mov ax,(CPU_BLUE_PLANE+1) ; top of the buffer
mov es,ax ; dest. segm.
add ax,bx
mov ds,ax ; source segm.
mov cx,32760 ; number of words of the buffer
rep movsw ; move words
mov si,0 ; clear offsets
mov di,0 ; for both dest. and source
mov ax,CPU_GREEN_PLANE
mov ds,ax ; source segm.
sub ax,bx
mov es,ax ; dest. segm.
mov cx,16000 ; scroll with status line
mov ax,bx ; ax = n * 5
shl ax,1
shl ax,1
shl ax,1 ; ax = n * 40
sub cx,ax
rep movsw
;
pop ds
pop es
pop di
pop si
pop bx
ret
sixel_mono_scroll endp
sixel_col_scroll proc near
;
; scroll-up cx lines in color mode
;
push ax
push bx
push cx
push si
push di
push es
push ds
;
mov ax,cx
shl ax,1
shl ax,1 ; ax = n * 4
add ax,cx ; ax = n * 5
shl ax,1
shl ax,1
shl ax,1
shl ax,1 ; ax = n * 80
mov bx,ax
cld
mov cx,32000
sub cx,bx ; number of bytes
shr cx,1 ; number of words
mov di,0
mov si,bx
mov ax,CPU_BLUE_PLANE
mov es,ax
mov ds,ax
rep movsw
;
mov cx,32000
sub cx,bx
shr cx,1
mov di,0
mov si,bx
mov ax,CPU_RED_PLANE
mov es,ax
mov ds,ax
rep movsw
;
mov cx,32000
sub cx,bx
shr cx,1
mov di,0
mov si,bx
mov ax,CPU_GREEN_PLANE
mov es,ax
mov ds,ax
rep movsw
;
mov cx,32000
sub cx,bx
shr cx,1
mov di,0
mov si,bx
mov ax,CPU_EXTRA_PLANE
mov es,ax
mov ds,ax
rep movsw
;
pop ds
pop es
pop di
pop si
pop cx
pop bx
pop ax
ret
sixel_col_scroll endp
sixel_rollup proc near
push bx
push si
push di
push es
push ds
;
mov ax,cx
shl ax,1
shl ax,1
add ax,cx ; ax = n * 5
mov bx,ax ; bx = ax = n * 5
shl ax,1
shl ax,1
shl ax,1 ; ax = n * 40
;
; copy top n-lines to the save buffer
;
cld
mov si,0
mov di,0
push ax
mov ax,(CPU_BLUE_PLANE+1) ; top segment
mov ds,ax
mov ax,(CPU_GREEN_PLANE+2000) ; save-buffer segment
mov es,ax
pop ax ; ax = n * 40
mov cx,ax
rep movsw
;
; roll-up n-lines
;
mov si,0
mov di,0
push ax
mov ax,(CPU_BLUE_PLANE+1)
mov es,ax ; destination
add ax,bx
mov ds,ax ; source
mov cx,32760
rep movsw
;
mov si,0
mov di,0
mov ax,CPU_GREEN_PLANE
mov es,ax
add ax,bx
mov ds,ax
mov cx,15360
pop ax
sub cx,ax
rep movsw
;
; Copy saved n-lines to the bottom
;
mov si,0
mov di,0
push ax
mov ax,(CPU_GREEN_PLANE+1920)
sub ax,bx
mov es,ax ; destination
mov ax,(CPU_GREEN_PLANE+2000)
mov ds,ax ; source
pop ax
mov cx,ax
rep movsw
;
pop ds
pop es
pop di
pop si
pop bx
ret
sixel_rollup endp
sixel_rolldown proc near
push bx
push si
push di
push es
push ds
;
mov ax,cx
shl ax,1
shl ax,1
add ax,cx ; ax = n * 5
mov bx,ax ; bx = n * 5, save it for later use
shl ax,1
shl ax,1
shl ax,1 ; ax = n * 40
;
; Copy bottom n-lines to the save buffer
;
cld
mov si,0
mov di,0
push ax
mov ax,(CPU_GREEN_PLANE+1920) ; 1920 = (24x16)lines x 5 segm.
sub ax,bx
mov ds,ax ; source segm.
mov ax,(CPU_GREEN_PLANE+2000) ; save segm.
mov es,ax ; destination
pop ax ; ax = n * 40
mov cx,ax
rep movsw ; store n-lines to save segm.
;
; Rolldown n-lines
;
std
mov si,30718 ; bottom offset address (word boundary)
mov di,30718
push ax
mov ax,CPU_GREEN_PLANE
mov es,ax ; destination
sub ax,bx
mov ds,ax ; source
mov cx,15360 ; cx = 24 x 16 x 40 words
rep movsw ; reverse move in Green segm.
;
mov si,0FFEEh ; bottom offset address (word boundary)
mov di,0FFEEh
mov ax,(CPU_BLUE_PLANE+1)
mov es,ax
sub ax,bx
mov ds,ax
mov cx,32760 ; number of words in the buffer
pop ax ; ax = n * 40
sub cx,ax
rep movsw
;
cld
mov si,0
mov di,0
push ax
mov ax,(CPU_GREEN_PLANE+2000)
mov ds,ax
mov ax,(CPU_BLUE_PLANE+1)
mov es,ax
pop ax ; ax = n * 40
mov cx,ax
rep movsw
;
pop ds
pop es
pop di
pop si
pop bx
ret
sixel_rolldown endp
;------------------------------------------------------------------------------
;------------------------------------------------------------------------------
send_to_GGDC proc near
;
; send commands and parameters
; to graphic GDC
; inputs DS:[SI] address of the list
;
push ax
push cx
push si
cld
send_to_GGDC_loop1:
lodsb
cmp al,0ffh
je send_to_GGDC_exit
push ax
send_to_GGDC_loop2:
in al,GGDC_STS_PORT
test al,2
jne send_to_GGDC_loop2
pop ax
out GGDC_CMD_PORT,al
lodsb
mov cl,al
mov ch,0
cmp cx,0
je send_to_GGDC_loop1
send_to_GGDC_loop3:
lodsb
push ax
send_to_GGDC_loop4:
in al,GGDC_STS_PORT
test al,2
jne send_to_GGDC_loop4
pop ax
out GGDC_PRM_PORT,al
loop send_to_GGDC_loop3
jmp send_to_GGDC_loop1
send_to_GGDC_exit:
pop si
pop cx
pop ax
ret
send_to_GGDC endp
;------------------------------------------------------------------------------
GGDC_color proc near
;
; send DS:[SI] to graphic GDC with
; color index.
;
; inputs
; ax: color index
; si: buffer address (used by send_to_GGDC)
; di: CSR pointer
;
push bx
push cx
push dx
push di
;
mov bx,[di+3]
push bx
mov bx,[di+5]
push bx
;
xor ch,ch
mov cl,gplane_nums
mov bx,offset GDC_plane_address
mov dx,1
GGDC_color_1:
and byte ptr [di+3],3Fh ; mask plane address
push ax
mov al,[bx]
or byte ptr [di+3],al ; add plane address
pop ax
inc bx
test dx,gplane_actv
jz GGDC_color_4 ; skip if non-active plane
test dx,ax ; test color bit
jz GGDC_color_2
mov byte ptr [di+5],23h ; write mode = SET
jmp GGDC_color_3
GGDC_color_2:
mov byte ptr [di+5],22h ; write mode = CLEAR
GGDC_color_3:
call send_to_GGDC
GGDC_color_4:
shl dx,1
loop GGDC_color_1
;
pop bx
mov [di+5],bx
pop bx
mov [di+3],bx
;
pop di
pop dx
pop cx
pop bx
ret
GGDC_color endp
;-----------------------------------------------------------------------
; Get digitized color index in AL from (r,g,b)
; si: (r,g,b) table
;
get_dig_color proc near
push cx
mov ch,ah ; save AH
mov ah,[si] ; get red
mov cl,6
shr ah,cl
and ah,02h
mov al,ah
mov ah,[si+1] ; get green
mov cl,5
shr ah,cl
and ah,04h
or al,ah
mov ah,[si+2] ; get blue
mov cl,7
shr ah,cl
and ah,01h
or al,ah
mov ah,ch ; restore AH
pop cx
ret
get_dig_color endp
HLS_value proc near
;
; input HLS_n1 n1 [0-100]
; HLS_n2 n2 [0-100]
; AX : hue
; output AX : value
;
push bx
push dx
;
HLS_value_1:
cmp ax,360
jle HLS_value_2
sub ax,360
jmp HLS_value_1
HLS_value_2:
cmp ax,0
jge HLS_value_3
add ax,360
jmp HLS_value_2
HLS_value_3:
cmp ax,60
jl HLS_value_4
cmp ax,180
jl HLS_value_5
cmp ax,240
jl HLS_value_6
mov ax,HLS_n1
jmp HLS_value_ex
HLS_value_5:
mov ax,HLS_n2
jmp HLS_value_ex
HLS_value_6:
mov bx,ax
mov ax,240
sub ax,bx
HLS_value_4:
mov bx,ax
mov ax,HLS_n2
sub ax,HLS_n1
imul bx
mov bx,60
idiv bx
add ax,HLS_n1
HLS_value_ex:
pop dx
pop bx
ret
HLS_value endp
HLS_to_RGB proc near
;
; input [si] Hue [0-360]
; [si+2] Lightness [0-100]
; [si+4] Satulation [0-100]
;
; output [si] Red [0-100]
; [si+2] Green [0-100]
; [si+4] Blue [0-100]
;
push ax
push bx
push dx
;
mov ax,[si+4] ; get s
cmp ax,0 ; if( s==0 ) then monochrome
jne HLS_to_RGB_1 ; ne=no
jmp HLS_to_RGB_nomo
HLS_to_RGB_1:
mov bx,[si+2] ; get l
mul bx ; dx:ax=l*s (dx should be 0)
mov bx,100
div bx ; ax=(l*s)/100
cmp WORD PTR [si+2],50 ; if( l>50 ) then case_2
jg HLS_to_RGB_2
mov bx,[si+2] ; bx=l
jmp HLS_to_RGB_3
HLS_to_RGB_2:
mov bx,[si+4] ; bx=s
sub bx,ax ; bx=s-l*s/100
mov ax,[si+2] ; ax=l
HLS_to_RGB_3:
add ax,bx ; ax=ax+bx
mov HLS_n2,ax
mov bx,[si+2] ; bx=l
shl bx,1 ; bx=2*l
sub bx,ax ; bx=2*l-ax
mov HLS_n1,bx
mov ax,[si] ; ax=hue
push ax
call HLS_value
mov [si],ax
pop ax
push ax
mov bx,120
sub ax,bx ; ax=hue-120
call HLS_value
mov [si+2],ax
pop ax
mov bx,120
add ax,bx ; ax=hue+120
call HLS_value
mov [si+4],ax
jmp HLS_to_RGB_ex
HLS_to_RGB_nomo:
mov ax,[si+2]
mov [si],ax
mov [si+4],ax
HLS_to_RGB_ex:
pop dx
pop bx
pop ax
ret
HLS_to_RGB endp
;
RGB100_to_255 proc near
;
; Rescale RGB [0-100] to RGB [0-255]
;
; Input [si], [si+2], [si+4]
; Output [si], [si+2], [si+4]
;
push ax
push bx
push dx
mov bx,655
mov ax,[si] ; get R
mul bx
mov al,ah
xor ah,ah
mov [si],ax
mov ax,[si+2] ; G
mul bx
mov al,ah
xor ah,ah
mov [si+2],ax
mov ax,[si+4] ; B
mul bx
mov al,ah
xor ah,ah
mov [si+4],ax
pop dx
pop bx
pop ax
ret
RGB100_to_255 endp
;
;-----------------------------------------------------------------------
; Set graphic color palette
; si: points the color index table (8 colors)
;
set_gpalette proc near
push ax
push bx
push cx
;
cmp gdisp_mode,0 ; digital display ?
jne set_gpalette_A ; ne=no.
jmp set_gpalette_D
;--------------
set_gpalette_A:
;--------------
push si
mov cx,16
mov bx,0
set_gpalette_A1:
push cx
mov al,bl
out 0A8h,al ; set color index
lodsb
mov cx,4
shr al,cl
and al,0Fh
out 0ACh,al ; set red
lodsb
mov cx,4
shr al,cl
and al,0Fh
out 0AAh,al ; set green
lodsb
mov cx,4
shr al,cl
and al,0Fh
out 0AEh,al ; set blue
pop cx
inc bx
loop set_gpalette_A1
;
pop si
jmp set_gpalette_ex
;
;--------------
set_gpalette_D:
;--------------
push si
add si,9 ; index #3
call get_dig_color
mov ah,al
mov cl,4
shl ah,cl
pop si
push si
add si,21 ; index #7
call get_dig_color
or al,ah
out 0A8h,al ; set palette #3 and #7
pop si
;
push si
add si,3 ; index #1
call get_dig_color
mov ah,al
mov cl,4
shl ah,cl
pop si
push si
add si,15 ; index #5
call get_dig_color
or al,ah
out 0AAh,al ; set palette #1 and #5
pop si
;
push si
add si,6 ; index #2
call get_dig_color
mov ah,al
mov cl,4
shl ah,cl
pop si
push si
add si,18 ; index #6
call get_dig_color
or al,ah
out 0ACh,al ; set palette #2 and #6
pop si
;
push si
call get_dig_color
mov ah,al
mov cl,4
shl ah,cl
pop si
push si
add si,12
call get_dig_color
or al,ah
out 0AEh,al ; set palette #0 and #4
pop si
;
set_gpalette_ex:
pop cx
pop bx
pop ax
ret
set_gpalette endp
set_gtxt_vect proc near
push ax
push bx
push cx
mov bx,tek_gtxt_w
add bx,tek_gtxt_s
mov cx,tek_gtxt_h
mov ax,tek_gtxt_ang
cmp ax,45
jge set_gtxt_vect_n1
jmp set_gtxt_vect_1
set_gtxt_vect_n1:
cmp ax,135
jge set_gtxt_vect_n2
jmp set_gtxt_vect_2
set_gtxt_vect_n2:
cmp ax,225
jge set_gtxt_vect_n3
jmp set_gtxt_vect_3
set_gtxt_vect_n3:
cmp ax,315
jge set_gtxt_vect_1
jmp set_gtxt_vect_4
set_gtxt_vect_1:
mov tek_gtxt_dr,2
mov tek_gtxt_ux,bx
mov tek_gtxt_uy,0
mov tek_gtxt_vx,0
mov tek_gtxt_vy,cx
jmp set_gtxt_vect_5
set_gtxt_vect_2:
neg cx
mov tek_gtxt_dr,4
mov tek_gtxt_ux,0
mov tek_gtxt_uy,bx
mov tek_gtxt_vx,cx
mov tek_gtxt_vy,0
jmp set_gtxt_vect_5
set_gtxt_vect_3:
neg bx
neg cx
mov tek_gtxt_dr,6
mov tek_gtxt_ux,bx
mov tek_gtxt_uy,0
mov tek_gtxt_vx,0
mov tek_gtxt_vy,cx
jmp set_gtxt_vect_5
set_gtxt_vect_4:
neg bx
mov tek_gtxt_dr,0
mov tek_gtxt_ux,0
mov tek_gtxt_uy,bx
mov tek_gtxt_vx,cx
mov tek_gtxt_vy,0
set_gtxt_vect_5:
pop cx
pop bx
pop ax
ret
set_gtxt_vect endp
;------------------------------------------------------------------------------
gcsrw proc near
;
; fill CSRW parameters in the buffer [di]
; Inputs
; ax: x position
; bx: y position
; cx: plane offset / 256
; di: buffer address ( to be broken )
; Outputs
; di: next buffer address
;
push ax
push bx
push cx
mov byte ptr [di],49h ; fill CSRW command
mov byte ptr [di+1],3 ; number of parameters
push ax ; save x value
push cx ; save plane number
mov cl,4 ; shift counts
shr ax,cl ; ax = x / 16
mov cx,bx ; save y value
shl bx,1 ; bx = y * 2
shl bx,1 ; bx = bx * 2 = y * 4
add bx,cx ; bx = bx + y = y * 5
mov cl,3 ; shift counts
shl bx,cl ; bx = bx * 8 = y * 40
add ax,bx ; ax = x / 16 + y * 40
mov byte ptr [di+2],al ; set EAD_L
mov al,ah ; discard EAD_L
xor ah,ah ; clear higher byte
pop bx ; recall plane offset
mov bl,bh ; mov to lower byte
xor bh,bh ; clear higher byte
add ax,bx ; add plane offset
mov byte ptr [di+3],al ; set EAD_M
mov al,ah ; discard EAD_M
xor ah,ah ; clear higher byte
pop bx ; recall x
and bx,000fh ; lower 4 bits of x (dAD)
mov cl,4 ; shift counts
shl bx,cl ; shift 4 bits
add ax,bx ; add to EAD_H
mov byte ptr [di+4],al ; set dAD+EAD_H
add di,5 ; set next pointer
pop cx
pop bx
pop ax
ret
gcsrw endp
;------------------------------------------------------------------------------
gline proc near
;
; Draw line from current position to the displacement (AX,BX)
; Inputs:
; ax: delta_x
; bx: delta_y
; di: buffer address
; Outputs:
; di: next buffer address
;
push ax
push bx
push cx
mov byte ptr [di],4ch ; VECTW command
mov byte ptr [di+1],9 ; number of parameters
;
; determine direction (cx)
;
mov cx,8 ; Line function with dir=0
cmp ax,0 ; if delta_x = 0 then
je gln0 ; goto gln0
jl gln1 ; else if delta_x < 0 goto gln1
jmp gln2 ; else goto gln2
gln0:
cmp bx,0 ;
jge gln2 ; if delta_y >= 0 goto gln2
gln1:
neg ax ; delta_x = -delta_x
neg bx ; delta_y = -delta_y
add cx,4 ; dir >= 4
gln2:
cmp bx,0 ;
jg gln3 ; if delta_y > 0 goto gln3
neg bx ; delta_y = -delta_y
xchg ax,bx ;
add cx,2 ; dir >= 2 or 6
gln3:
cmp ax,bx ;
jl gln4 ; if delta_x < delta_y goto gln4
inc cx ; dir = 1, 3, 5, or 7
jmp gln5
gln4:
xchg ax,bx
gln5:
;
; end of direction determination.
; ax: abs(d_x)
; bx: abs(d_y)
; cx: line_code + dir
;
mov byte ptr [di+2],cl ; P1 ready
mov word ptr [di+3],ax ; abs(d_x)
mov cx,bx ; cx = abs(d_y)
add cx,bx ; cx = 2*abs(d_y)
push cx ; save 2*abs(d_y) for later use
sub cx,ax ; cx = 2*abs(d_y)-abs(d_x)
mov word ptr [di+5],cx ; send it
sub cx,ax ; cx = 2*abs(d_y)-2*abs(d_x)
mov word ptr [di+7],cx ; send it
pop cx ; recall 2*abs(d_y)
mov word ptr [di+9],cx ; send it
;
mov byte ptr [di+11],6ch ; VECTE command
mov byte ptr [di+12],0 ; with no parameters
add di,13 ; update address
pop cx
pop bx
pop ax
ret
gline endp
;-----------------------------------
gdisp_on proc near
push ax
push si
mov al,gdisp_mode
out 6ah,al
mov si,offset ggdc_on
call send_to_GGDC
pop si
pop ax
ret
gdisp_on endp
;-----------------------------------
gdisp_off proc near
push si
mov si,offset ggdc_off
call send_to_GGDC
pop si
ret
gdisp_off endp
;-----------------------------------
gcls proc near
push ax
push bx
push cx
push di
push si
push es
;
mov si,offset ggdc_off ; off the graphic GDC
call send_to_GGDC
;
cld ; normal direction
xor ch,ch
mov cl,gplane_nums
mov bx,offset gplane_segm ; GDC segment address
gcls_1:
mov ax,[bx] ; get segment
mov es,ax ; and set it to ES
xor ax,ax ; store 0
mov di,ax ; offset address is 0
push cx ; save counter
mov cx,16000 ; number of words of G-VRAM
rep stosw ; store it
pop cx ; remember number of planes
add bx,2 ; next segment address
loop gcls_1
;
mov si,offset ggdc_on ; on the graphic GDC
call send_to_GGDC
;
pop es
pop si
pop di
pop cx
pop bx
pop ax
ret
gcls endp
code ends
end
