Source file: /~heha/hsn/kcemu/[Download]kcemu_050.exe/SRC/KCSCR.ASM

;**********************************************************
;*
;*  Bitmap-Interface fr KC-Emulator und alle KC-Typen
;*
;*****
;Folgende Beschr„nkungen gelten fr alle KC's und auch den User-KC's:
;24 statische Farben 0..23,
;8 animierbare Farben 24..31
;Windows-PixmapgrӇe max. 128K
;Das drfte wirklich fr alle existierenden Z80-Computer reichen!

;Registerbelegung:
; es: Adreábereich KC
; ds: restliche Daten (Windows automatisches Datensegment [HInstance])
; si: Z80-Instruktionszeiger ("program counter" PC)
;
	IDEAL
	%TITLE	"KCEMU DrawBitmap library"
	model	small, pascal
	P286
	warn pro	;Protected-Mode-Fehler anmeckern

extrn MemKCSel: Word		;KC-Selektor
extrn InUpdate: Byte:160	;Bitfeld der Update-Regionen
extrn BlinkFarben: Byte:8	;8 Blinkfarbpaare
extrn __ahincr: Proc		;Selektor-Inkrement (Offset als Konstante)
extrn hDisplay: Word		;Bitmap-Selektor
extrn DisplaySize: DWord	;Bitmap-Gr”áe (fr Blink_GC)
extrn hCharMap: Word;		;Zeichenbildtabellen-Selektor
extrn KC4Port84H: Byte		;Register fr Bankauswahl und HRG
extrn KC4Port88H: Byte		;Register fr Z9001-20-Zeilen-Modus und Border
extrn KCIRM: DWord		;Zeiger auf KC85/4-Bildspeicher
extrn Blinken: Byte		;Boolean-Schalter
extrn GC_ShortCircuit: Byte	;Boolean-Schalter
extrn Foreground: Byte		;Boolean-Schalter
extrn Test8086: Byte		;Ergebnis des CPU-Tests (Unit SYSTEM)
extrn GetAnimIdx: Word;		;Prozedur-Zeiger
extrn Regions: Word		;Kl”tzchenregion-Z„hler
extrn MainWnd: Word		;Hauptfenster
extrn hPal: Word;		;Paletten-Handle
extrn InvalidateRect: FAR	;Windows-Funktion
extrn AnimatePalette: FAR	;Windows-Funktion
extrn ChrBox: DWord		;Zeichenzelle in Bildschirm-Pixeln
extrn PixBox: Word		;8x8-Zelle in Bildschirm-Pixeln
extrn Palette: DWord:33		;die beiden Header-Words mitgez„hlt


;*** allgemein ***
public Blink_GC			;Garbage Collection fr User-KC
public GetBlinkFarbe		;Freie Blinkfarbe beschaffen, fr User-KC
public Animate			;Nach Wechsel von [Foreground] aufzurufen
public InvalWnd			;ganze Bitmap invalidieren
public Inval8x8			;Kl”tzchen inval., fr Vollgrafik-Systeme
; (das Zeichenraster [ChrBox] muá nicht zwangsl„ufig 8x8 sein [WordPro!])
public InvalChrBox		;Kl”tzchen inval., fr Textbildschirme
;*** KC85/2,3,4 ***
public GetAnimIdx3		;Umrechnung Farbbyte+Foreground->PalIndex
public IRM_Access3		;schlieát KC85/2 ein
public IRM_Update3
public IRM_Access4
public IRM_Update4
;*** KC85/1, Z1013 ***
public GetAnimIdx7
public IRM_Access1
public IRM_Update1
public IRM_Access7
public IRM_Update7
public IRM_Access9
public IRM_Update9

CODESEG
;**************************
;****************************************************
;*** Allgemeine Routinen (Invalidieren und Blinken***
;****************************************************

proc Blink_GC
;{Garbage Collection fr BlinkFarben: Durchbrowst die Pixmap
; nach Eintr„gen zwischen 24 und 31 und entfernt Fehlreferenzen
; aus BlinkFarben[]. Sind alle Farben in Beschlag, dann CY=1.
; PE: CLD! VR: BX,CX}
	push ax es si
	 mov	bx,[word LOW DisplaySize]
	 cmp	[word HIGH DisplaySize],0	;darf maximal 1 sein!
	 mov	es,[hDisplay]
	 jz	@@0
	 xor	bx,bx		;>64K: zuerst eine "volle" Runde
@@0:	 xor	si,si
	 mov	ah,0FFh		;{Alles frei...}
@@l:	 seges	lodsb		;{Byte laden}
	 sub	al,24
	 cmp	al,8
	 jnc	@@no		;{keine Blinkfarbe}
	 mov	cl,al
	 mov	al,not 1
	 rol	al,cl
	 and	ah,al		;{Bitstelle ist NICHT mehr frei}
@@no:	 dec	bx
	 jnz	@@l
	 or	si,si
	 jnz	@@w		;{in 2. Runde raus! (SI<>0)}
	 mov	bx,es
	 add	bx,offset __ahincr
	 mov	es,bx
	 mov	bx,[word LOW DisplaySize]
	 or	bx,bx		;{Neuer Z„hler fr den Rest (KC85/3: 16K}
	 jnz	@@l		;durchlaufen falls genau 64K
@@w:
	pop si es
	cmp	ah,1		;{Null? (Alle 8 Indizes in Beschlag?)}
	jc	@@e		;ja, kann nichts machen
	lea	bx,[BlinkFarben]
@@l2:	shr	ah,1		;{Bit ausschieben}
	jnc	@@used
	mov	[byte bx],0
@@used:	inc	bx
	or	ah,ah		;{Noch freie Bits? (und CY l”schen!)}
	jnz	@@l2
@@e:	pop ax
	ret
endp Blink_GC

;**************************
proc GetBlinkFarbe
;{PE: AL=(unver„ndertes) Farbattribut; PA:AL=Palettenindex; VR: AL}
;{Funktioniert fr alle KC durch Funktionszeiger fr GetAnimIdx}
	push bx cx
	 mov	bx,offset BlinkFarben-1
	 mov	cx,8
@@l1:	 inc	bx
	 cmp	[bx],al		;{Gleichen Eintrag suchen}
	 loopnz	@@l1
	 jz	@@f_e		;{Gleichen Eintrag gefunden!}
@@try:	 mov	bx,offset BlinkFarben-1
	 mov	cx,8
@@l2:	 inc	bx
	 cmp	[byte bx],0	;{Freien Eintrag suchen}
	 loopnz	@@l2
	 jz	@@f_f		;{Freien Eintrag gefunden!}
	 cmp	[GC_ShortCircuit],0
	 jnz	@@sc
	 call	Blink_GC	;{"Garbage Collection" aufrufen}
	 mov	[GC_ShortCircuit],1
	 jnc	@@try		;{Wenn neue freie Eintr„ge gefunden}
@@sc:	 stc
	 jmp	@@e		;{Fehler, nicht-blinkende Farben nehmen}
@@f_f:	 mov	[bx],al		;{Farbe allozieren}
;{Neu allozierte Farbe muá nun auch (einzeln) animiert werden!}
	 pusha
	 push	es
	  push	ds
	  pop	es
	  cmp	[Foreground],0
	  call	[GetAnimIdx]	;{liefert AL zwischen 0 und 23}
	  xor	ah,ah		;{auf AX erweitern}
	  sub	bx,offset BlinkFarben-24
	  mov	di,bx		;{Index der animierten Farbe (24..31}
	  push	[hPal]		;AnimatePalette()-Aufruf vorbereiten
	  push	di		;{Paletten-Index}
	  push	1		;{genau 1 Farbe}
	  push	ds
	  lea	si,[Palette+4]
	  shl	di,2		;{*sizeof(LongInt)}
	  add	di,si		;{Zieladresse fr Farb-Kopieren}
	  push	di		;Adresse des TPaletteEntry-Eintrags
	  shl	al,2
	  add	si,ax		;{Quelladresse}
	  cld
	  movsw
	  movsb			;{3 Farbbytes kopieren}
	  call	AnimatePalette
	 pop	es
	 popa
@@f_e:	 sub	bx,offset BlinkFarben-24	;{CLC}
	 mov	al,bl		;{aus BX=Zeiger Palettenindex machen}
@@e:	pop cx bx
	ret
endp GetBlinkFarbe

;**************************
proc Animate
	cld
	push	ds
	pop	es
	lea	bx,[BlinkFarben]	;Quelladresse
	lea	di,[Palette+4+24*4]	;laufende Zieladresse
	mov	cx,8
@@l:	mov	al,[bx]
	cmp	[Foreground],0
	call	[GetAnimIdx]
	xor	ah,ah
	shl	al,2
	lea	si,[Palette+4]
	add	si,ax
	movsw
	movsb
	inc	di			;peFlags bergehen
	inc	bx			;n„chste Blinkfarbe
	loop	@@l
	push	[hPal]
	push	24
	push	8
	push	ds
	push	offset Palette+4+24*4
	call	AnimatePalette
	ret
endp Animate

;**************************
proc InvalWnd
;{PE: -, PA: -, VR: alle auáer DS,SI,SP,BP}
	xor	ax,ax
	push	[MainWnd]
	push ax ax		;{lpRect=NIL}
	push	ax		;{fErase=FALSE}
	call	InvalidateRect
	push	ds
	pop	es
	mov	di,offset InUpdate
	mov	cx,length InUpdate/2	;SIZE wrde hier 1 liefern
	mov	ax,0FFFFh
	cld
	rep	stosw		;{FillChar: Alles in Update-Region}
	ret
endp InvalWnd

proc MakeBXAL
;erstellt fr den am 286er fehlenden Befehl BTS [InUpdate],bx
;eine Bitmaske in AL und Byte-Adresse in BX
;PE: BX=Bit-Nummer; PA: BX=Adresse, AL=Maske, Z=1: Bit=0; VR: CL
	mov	cl,bl
	and	cl,7
	mov	al,1
	shl	al,cl		;{AL=Bitmaske}
	shr	bx,3		;{BX nun max. 124}
	add	bx,offset InUpdate
	test	[bx],al
	ret
endp MakeBXAL

;**************************
proc Inval8x8
;{Invaliditiert Bildschirm-Bereich 8x8-Pixel-Schritten
; PE: DL=Zeile(Y), DH=Spalte(X) (also gerade andersherum als im PC-BIOS)
;     BX=eindeutiger Bit-Bezeichner fr InUpdate-BitArray
; VR: BX,CL,Flags}
	cmp	[Test8086],2	;{386er?}
	jc	@@286
P386
	BTS	[word InUpdate],bx
	jnc	@@w
@@e:	ret
P286
@@286:	call	MakeBXAL
	jnz	@@e
	or	[bx],al		;{Bit setzen}
@@w:	pusha
	push	es
	 mov	si,[PixBox]
	 mov	di,si
	 jmp	InvalXY
endp Inval8x8

;**************************
proc InvalChrBox
;{dieselbe Routine wie oben, jedoch in Zeichenzellen statt 8x8}
	cmp	[Test8086],2	;{386er?}
	jc	@@286
P386
	BTS	[word InUpdate],bx
	jnc	@@w
@@e:	ret
P286
@@286:	call	MakeBXAL
	jnz	@@e
	or	[bx],al		;{Bit setzen}
@@w:	pusha
	push es
	 mov	si,[word LOW ChrBox]	;X
	 mov	di,[word HIGH ChrBox]	;Y
InvalXY: dec	[Regions]
	 jnz	@@w1
	 call	InvalWnd
	 jmp	@@ex
@@w1:	 mov	ax,di
	 imul	dl		;{AX=R.top}
	 add	di,ax		;{eine Zeichenh”he dazu gibt R.bottom}
	 push	di		;{R.bottom}
	 xchg	bx,ax		;{R.top retten}
	 mov	ax,si
	 imul	dh		;{AX=R.left}
	 add	si,ax		;{eine Zeichenbreite dazu gibt R.right}
	 push	si		;{R.right}
	 push	bx		;{R.top}
	 push	ax		;{R.left}
	 mov	ax,sp		;{SS:AX=Adresse von TRect}
	 push	[MainWnd]
	 push	ss ax		;{auf dem Stack liegendes TRect}
	 push	0
	 call	InvalidateRect	;{modifiziert ES!}
	 add	sp,8		;{TRect entfernen}
@@ex:	pop es
	popa
	ret
endp InvalChrBox

;**************************************
;*** Routinen fr KC85/2, /3 und /4 ***
;**************************************

proc GetAnimIdx3
;{PE: AL=Farbbyte, Z=1: HFarbe, Z=0: VFarbe gewnscht;
; PA: AL=Index als Blinkfarbe (0..23)
; VR: AL, Flags}
	jnz	@@fg
	and	al,7
	ret
@@fg:	shr	al,3
	and	al,0Fh
	add	al,8
	ret
endp

proc GetVFarbe
;Gemeinsame Routine fr KC85/3 und 4 wegen gleichem Farbbyte-Aufbau.
;Keine Verwendung fr den KC85/4-HRG-Modus
;{PE: CL=Pixelbyte (KC85/4), <>0 (andere KCs),
;     AL=Farbattribut; PA: AL=Palettenindex fr VFarbe; VR: AL,Flags}
;{N: HFarbe ist stets AL and 7}
	cmp	al,80h		;{Blinkbit?}
	jbe	@@nb		;{wenn kein Blinkbit oder schwarz auf schwarz}
	cmp	[Blinken],0
	jz	@@nb		;{wenn global ausgeschaltet}
	cmp	al,0C0h		;{Auch schwarz auf schwarz?}
	je	@@nb
	or	cl,cl		;{Bits gesetzt? (am /3 immer)}
	je	@@nb		;{nein-auch nicht blinken lassen!}
	call	GetBlinkFarbe
	jnc	@@e
@@nb:	shr	al,3
	and	al,0Fh
	add	al,8		;{VFarbe fr KC85/2,3,4}
@@e:	ret
endp GetVFarbe

proc adr2pixcolxy
;{PE: BX=Schreibadresse,
; PA: SI=Pixeladresse, DI=Farbadresse, DX=Spalte(X), CX=Zeile(Y),
;  AL=0 (DEBUG: kein Update), 1 (Pixel-Update), 4(Farb-Update)}
	mov	di,bx
	mov	si,bx
	xor	ch,ch
	xor	dh,dh
	xor	al,al		;{Fehler-Code}
	sub	bh,0B2h
IFDEF DEBUG
	jnc	@@err
ENDIF
	add	bh,2
	jc	@@cr
	add	bh,8
	jc	@@cl
	add	bh,8
	jc	@@pr
	add	bh,20h
IFDEF DEBUG
	jnc	@@err
ENDIF
;{PE: Pixeladresse links}
@@pl:	mov	dl,bl
	and	dl,1Fh	;{H}
	add	bx,bx
	mov	cl,bh
	shr	bh,2
	or	bh,50h
	mov	di,bx
	stc
	rcr	di,1	;{Farbadresse fertig!}
	shl	bx,4
	and	bh,0FCh
	and	cl,03h
	or	cl,bh	;{V}
	mov	al,1
	ret
;{PE: Pixeladresse rechts}
@@pr:	mov	dl,bl
	and	dl,7
	or	dl,20h	;{H}
	add	bx,bx
	mov	ax,bx	;{AH enth„lt: V7 V6 V1 V0, AL: V3 V2 V5 V4}
	shr	bh,2
	shr	bx,1
	or	bh,0B0h
	mov	di,bx	;{Farbadresse fertig!}
	mov	bx,ax
	shl	bx,4
	and	bh,0CCh
	and	ax,0330h
	or	al,ah
	or	al,bh
	mov	cl,al	;{V}
	mov	al,1
	ret
;{PE: Farbadresse links}
@@cl:	mov	dl,bl
	and	dl,01Fh	;{H}
	shl	bx,5
	mov	cl,bh
	and	cl,0FCh	;{V}
	shr	bx,4
	shr	bl,1
	add	bh,bh
	or	bh,80h
	mov	si,bx	;{Pixeladresse fertig!}
	mov	al,4
	ret
;{PE: Farbadresse rechts}
@@cr:
	mov	dl,bl
	and	dl,7
	or	dl,20h	;{H}
	add	bx,bx
	mov	cl,bl	;{V4 und V5 bit-richtig!}
	shr	bl,1	;{V1 und V0 =0 setzen!}
	add	bh,bh
	or	bh,0A0h
	mov	si,bx	;{Pixeladresse fertig!}
	shl	bx,5
	and	bh,0FCh
	and	cl,30h
	or	cl,bh	;{V}
	mov	al,4
;{PE: fehlerhafte Adresse}
@@err:	ret

endp adr2pixcolxy

;**************************
proc IRM_Access3
;{PE: BX=Schreibadresse, ES=MemKCSel (ES:BX bereits geschrieben)
; PA: -, VR: Flags}
	pusha
	call	adr2pixcolxy	;{4 Parameter ausrechnen}
IFDEF DEBUG
	or	al,al
	jz	@@e
ENDIF
	push	ax		;{Zeilen retten}
	 pusha
	  mov	dh,dl
	  mov	dl,cl
	  mov	bx,dx
	  shr	bx,3
	  shr	dl,3		;{Y}
	  call	Inval8x8	;{Aktualisieren lassen}
	 popa
	 not	cl		;{Zeile strzen fr DIB}
	 mov	ax,cx
	 add	ax,ax
	 add	ax,ax		;{Spalte*4}
	 add	ax,cx		;{*5}
	 shl	ax,3		;{*40}
	 add	ax,dx		;{Zeile*40+Spalte}
	 mov	dx,[hDisplay]
	 shl	ax,3		;{Pixel-Adresse, wird CY richtig gesetzt??}
	 jnc	@@1
	 add	dx,offset __ahincr
@@1:	;{DX:AX nun Adresse in Pixmap}
	pop	cx		;{Zeilenzahl in CL}
	cld
;{Hauptschleife mit: DX:AX (temp.alias ES:DI)=Windows-DIB-Adresse,
; AL=Akku, BL=Pixelbyte, BH=VFarbe, AH=HFarbe, CH=Bitmaske, CL=Schleifenz„hler,
; ES:SI=KC-Pixel-Adresse, ES:DI=KC-Farb-Adresse}
	mov	bh,[es:di]	;{Farb-Byte}
	xchg	di,ax		;{DI nun Bitmap-Adresse}
	mov	al,bh
	call	GetVFarbe	;{CL trickreicherweise immer <>0}
	xchg	ah,al		;{VFarbe nach AH}
	and	bh,7		;{HFarbe}
@@l2:	mov	bl,[es:si]	;{Pixel-Byte}
	push es
	 mov	es,dx		;{Segment-"Umschaltung"}
	 mov	ch,80h		;{Start mit Bit 7}
@@l1:	 test	bl,ch
	 mov	al,bh		;{HFarbe?}
	 jz	@@hf
	 mov	al,ah		;{nimm VFarbe!}
@@hf:	 stosb			;{Pixel setzen, kein Segmentberlauf
	 shr	ch,1		; (auáer am Ende)}
	 jnz	@@l1
	pop es
	dec	cl
	jz	@@e		;{fertig, nicht mehr rechnen}
	dec	di		;{"Anlauf" nehmen gegen Segmentberlauf}
	sub	di,320+7	;{Pixel pro Zeile + 1 Byte - 1 Bit}
	jnc	@@3
	sub	dx,offset __ahincr
@@3:	add	si,80h		;{n„chste KC-Pixelzeile (Farbe bleibt)}
	jmp	@@l2
@@e:
	popa
	ret
endp IRM_Access3

;**************************
proc IRM_Access4
;{PE: BX=Schreibadresse, (ES:BX bereits geschrieben)
; PA: -, VR: Flags}
	pusha
	push	es
	 sub	bh,80h
IFDEF DEBUG
	 cmp	bh,28h
	 jnc	@@e		;{BH=X, BL=Y}
ENDIF
	 mov	si,bx		;{KC-Adresse retten}
	 les	di,[KCIRM]
	 mov	[es:di+bx],al	;{in den 10-K-Spiegel schreiben}
	 mov	al,[KC4Port84H]
	 and	al,5		;{Anzeige und Zugriff verschieden?}
	 jpo	@@e		;{ja (unpaarig) - raus!}
;{Test auf InUpdate und Aufruf von InvalidateRect}
	 mov	dx,bx
	 shr	bx,3		;{Unterste Bits (X) uninteressant!}
	 shr	dl,3		;{nun DL=Y, DH=X}
	 call	Inval8x8
	 mov	dx,si
	 not	dl		;{Zeile strzen fr DIB}
	 mov	bl,dh
	 xor	bh,bh		;{BX=Spalte(X)}
	 xor	dh,dh		;{DX=Zeile(Y), gestrzt}
	 mov	di,dx
	 add	di,di
	 add	di,di		;{Spalte*4}
	 add	di,dx		;{*5}
	 shl	di,3		;{*40}
	 add	di,bx		;{Zeile*40+Spalte}
	 mov	dx,[hDisplay]
	 shl	di,3		;{Pixel-Adresse, CY ist das letzte Bit}
	 jnc	@@1
	 add	dx,offset __ahincr
@@1:	;{DX:DI nun Adresse in Pixmap}
	 cld
;{Hauptschleife mit: DX:DI=Windows-DIB-Adresse,
; AL=Akku, CL=Pixelbyte, CH=HFarbe, AH=VFarbe, BH=Bitmaske,
; SI=KC-Pixel-Adresse, [KC4Pixel], [KC4Color]: Basiszeiger}
	 mov	al,[KC4Port84H]
	 and	ax,1
	 ror	ax,1		;{0 oder 8000h}
	 add	si,ax
	 mov	cl,[es:si]	;{Pixel-Byte}
	 mov	al,[es:si+4000h];{Farb-Byte}
	 mov	ch,al
	 mov	es,dx		;{hDisplay-Segment}
	 test	[KC4Port84H],8	;{HRG-Modus? (Bit invertiert!)}
	 mov	bh,80h		;{Start mit Bit 7}
	 jz	@@hrg
	 call	GetVFarbe	;{CL enth„lt Pixel-Byte}
	 mov	ah,al
	 and	ch,7		;{HFarbe}
@@l1:	 test	cl,bh
	 mov	al,ch		;{HFarbe?}
	 jz	@@hf
	 mov	al,ah		;{nimm VFarbe!}
@@hf:	 stosb			;{Pixel setzen}
	 shr	bh,1
	 jnz	@@l1
@@e:	pop	es
	popa
	ret
@@hrg:	;{im HRG-Modus liefern die Pixel-Bits den Rot- und die Farb-Bits
	; den Trkis-Anteil - beide zusammen weiá}
@@l2:	 mov	al,8		;{Vordergrundfarbe Schwarz}
	 test	cl,bh
	 jz	@@p0
	 or	al,2		;{Vordergrundfarbe Rot}
@@p0:	 test	ch,bh
	 jz	@@c0
	 or	al,5		;{Vordergrundfarbe Trkis oder Weiá}
@@c0:	 stosb
	 shr	bh,1
	 jnz	@@l2
	pop	es
	popa
	ret
endp IRM_Access4

;**************************
proc IRM_Update4
;{Routine fr die Umschaltung der KC85/4-Bildseite oder -Aufl”sung,
; dafr mehr als sonst auf Geschwindigkeit getrimmt}
;{PE: -, PA: -, VR: Flags}
	pusha
	 cld
	 push	es
	  mov	bh,[KC4Port84H]
	  ror	bh,1		;{Bit7 je nach Anzeige-Bild}
	  mov	si,[word HIGH KCIRM]
	  mov	dx,[hDisplay]
	  xor	di,di		;{fangen unten links an}
	  mov	bl,0FFh
@@ll0:	  and	bh,80h		;{entsprechende KC-Adresse}
@@ll:	;{ES:DI nun Adresse in Pixmap}
;{Hauptschleife mit: DX:DI=Windows-DIB-Adresse, SI=[KCIRM]
; AL=Akku(VFarbe), AH=Bitmaske, BL=Zeile, BH=Spalte (+80h),
; CL=Pixelbyte, CH=HFarbe, [KC4Pixel], [KC4Color]: Basiszeiger}
	  mov	es,si
	  mov	cl,[es:bx]	;{Pixel-Byte}
	  mov	ch,[es:bx+4000h];{Farb-Byte}
	  mov	es,dx
	  test	[KC4Port84H],8	;{HRG-Modus? (Bit invertiert!)}
	  mov	ah,80h		;{Start mit Bit 7}
	  jz	@@hrg
	  mov	al,ch
	  and	ch,7		;{HFarbe}
	  call	GetVFarbe
@@l1:	  test	cl,ah
	  jnz	@@vf
	  xchg	al,ch
	  stosb			;{HFarbe setzen}
	  xchg	ch,al
	  shr	ah,1		;{Doppelt zur Sprungvermeidung}
	  jnz	@@l1
	  jmp	@@w
@@vf:	  stosb			;{VFarbe setzen}
@@w1:	  shr	ah,1
	  jnz	@@l1
	  jmp	@@w
@@hrg:	;{im HRG-Modus liefern die Pixel-Bits den Rot- und die Farb-Bits
	; den Trkis-Anteil - beide zusammen weiá. Blinken gibt's nicht}
@@l2:	  mov	al,8		;{Vordergrundfarbe Schwarz}
	  test	cl,ah
	  jz	@@p0
	  or	al,2		;{Vordergrundfarbe Rot}
@@p0:	  test	ch,ah
	  jz	@@c0
	  or	al,5		;{Vordergrundfarbe Trkis oder Weiá}
@@c0:	  stosb
	  shr	ah,1
	  jnz	@@l2
@@w:	  or	di,di
	  jnz	@@ni
	  add	dx,offset __ahincr
	  mov	es,dx		;{n„chstes Segment}
@@ni:	  inc	bh		;{X - nach rechts}
	  mov	al,bh
	  and	al,7Fh
	  cmp	al,40
	  jc	@@ll
	  sub	bl,1		;{Y - nach oben}
	  jnc	@@ll0
ToInvalWnd:
	  call	InvalWnd
	 pop	es
@@e:	popa
	ret
endp

;**************************
proc IRM_Update3
;{PE: -, PA: -, VR: Flags}
;Langsame Variante, da nur bei Emulator-Start oder -Resume gerufen
	pusha
	 push   es
	  mov	cx,0A00h
	  mov	bx,0A800h
	  mov	di,offset IRM_Access3
ToUpdate: mov	es,[MemKCSel]
@@l:	  mov	al,[es:bx]
	  call	di
	  inc	bx
	  loop	@@l
	  jmp	ToInvalWnd
endp IRM_Update3

;***********************************
;*** Routinen fr Z9001 und KC87 ***
;***********************************

proc GetAnimIdx7
;{PE: AL=Farbbyte, Z=1: HFarbe, Z=0: VFarbe gewnscht;
; PA: AL=Index als Blinkfarbe (0..23)
; VR: AL, Flags}
	jz	@@bg
	shr	al,4
@@bg:	and	al,7
	ret
endp

proc CalcZ24
;{rechnen: Adr=((23-Y)*8+7)*40+X, aufgel”st: Adr=7640-Y*320+X}
	  shl	dl,3		;{Pixelzeilen}
	  mov	ax,40*256+24*8-1;{DIB-Adresse berechnen, =40*y+x}
	  sub	al,dl		;{Pixelzeile strzen, z.B. 0->191}
	  mul	ah
	  add	al,dh		;{X dazu}
	  adc	ah,0		;{AX ist Offset}
	  ret
endp CalcZ24

proc CalcZ20
;{rechnen: Adr=((19-Y)*10+8)*40+X, aufgel”st: Adr=7920-Y*400+X}
	  mov	bl,dh
	  mov	bh,0
	  mov	al,-25
	  imul	dl
	  shl	ax,4		;schneller als mul dx,-400
	  add	ax,bx
	  add	ax,7920
	  ret
endp CalcZ20

;**************************
proc IRM_Access1
;{PE: BX=Schreibadresse, (ES:BX bereits geschrieben), AL=Zeichen
; PA: -, VR: Flags}
	pusha
	 mov	ch,al		;{Zeichen retten}
	 sub	bh,0ECh
IFDEF DEBUG
	 cld
	 cmp	bh,04h
	 jnc	@@e
ENDIF
	 mov	ax,bx
	 mov	cl,40
	 div	cl		;{AH=ZeichenSpalte, AL=ZeichenZeile}
	 test	[KC4Port88H],4
	 jz	@@z24		;{normaler 24-Zeilen-Modus}
	 cmp	al,20
	 jnc	@@e
	 xchg	ax,dx
	 push	es
	  call	InvalChrBox	;{mit DH=X und DL=Y}
	  call	CalcZ20
	  jmp	@@w20
@@z24:
	 cmp	al,24		;{24. oder 25. Zeile?}
	 jnc	@@e		;{Ja-raus (kein Zugriff)}
	 xchg	ax,dx		;{DH=Spalte(X), DL=Zeile(Y)}
;{Test auf InUpdate und Aufruf von InvalidateRect}
	 push	es
	  call	InvalChrBox	;{mit DH=X und DL=Y}
	  call	CalcZ24
@@w20:	  mov	es,[hDisplay]
	  xchg	ax,di		;{ES:DI: fertig ist die DIB-Adresse!}
	  mov	cl,0
	  shr	cx,5		;{Zeichencode in Position bringen}
	  push	ds
	   mov	ds,[hCharMap]
	   mov	si,cx		;{und DS:SI zeigt auf Zeichenbildtabelle}
;{Hauptschleife mit: ES:DI=Windows-DIB-Adresse, DS:SI=Zeichenbild,
; CX=Schleifenz„hler}
	   mov	cx,8
@@l:	   movsb
	   sub	di,1+40		;{DIB ist "verkehrtherum"}
	   loop	@@l
	  pop	ds
	 pop	es
@@e:	popa
	ret
endp IRM_Access1

proc GetVFarbeZ
;{PE: CL=Zeichencode (20h verhindert Blinken), AL=Farbattribut
; PA: AL=Palettenindex fr VFarbe; VR: AL,CH,Flags}
;{N: HFarbe ist AL and 7}
	cmp	al,80h		;{Blinkbit?}
	jbe	@@nb		;{wenn kein Blinkbit oder schwarz auf schwarz}
	cmp	[Blinken],0
	jz	@@nb		;{wenn global ausgeschaltet}
	cmp	cl,20h		;{Leerzeichen?}
	je	@@nb		;{Auch nicht blinken!}
	mov	ch,al
	shr	ch,4
	xor	ch,al
	and	ch,7		;{Grauer Adler auf grauem Grund?}
	jz	@@nb
	call	GetBlinkFarbe
	jnc	@@e
@@nb:	shr	al,4
	and	al,7
@@e:	ret
endp GetVFarbeZ

proc CalcZ7
;Hilfsroutine fr IRM_Access7
;PE: AX=Monochrom-Bitmap-Adresse, SI=Z9001-Zugriffsadresse AND 3FFh
;PA: ES:DI=DIB-Adresse, SI=Zeichentabellen-Offset,
;    BH=VFarbe (0..7 oder 24..31), AH=HFarbe(0..7)
	  shl	ax,3
	  xchg	ax,di		;{DI ist Offset}
	  mov	cl,[es:si+0EC00h]	;{ASCII}
	  mov	al,[es:si+0E800h]	;{Farbe}
	  mov	es,[hDisplay]	;{ES:DI: fertig ist die DIB-Adresse!}
	  mov	ah,al
	  and	ah,7		;{8 Hintergrundfarben}
	  call	GetVFarbeZ	;{AL->Index (unter Verwendung von CL)}
	  mov	ch,0
	  shl	cx,3		;{Zeichencode in Position bringen}
	  mov	si,cx		;{und (DS:)SI zeigt auf Zeichenbildtabelle}
	  mov	bh,al
	  ret
endp CalcZ7

proc StosZ
;gemeinsame Zeichenschreibroutine
	   mov	cl,8
@@lx2:	   mov	ch,80h
	   lodsb		;{Zeichentabellen-Zugriff}
	   mov	bl,al
@@lx:	   test	bl,ch		;{Pixel gesetzt}
	   mov	al,ah
	   jz	@@x1		;{nein, HFarbe verwenden}
	   mov	al,bh
@@x1:	   stosb
	   shr	ch,1		;{N„chstes Bit}
	   jnz	@@lx
	   sub	di,8+320	;{DIB ist "verkehrtherum"}
	   loop	@@lx2		;{CH ist hier Null!}
	   ret
endp StosZ

;**************************
proc IRM_Access7
;{PE: BX=Schreibadresse, (ES:BX bereits geschrieben), AL=Zeichen oder Farbcode
; PA: -, VR: Flags
;FARBBYTE:
; Bit 7: 1=Blinken
; Bit 6..4: Vordergrundfarbe B-G-R
; Bit 3: frei
; Bit 2..0: Hintergrundfarbe B-G-R
;BILDSCHIRMRAND UND ZEILENUMSTELLUNG
; Port 136 (88h):
; Bit 5..3: Bildrandfarbe B-G-R (wird sp„ter via WM_NCPaint emuliert)
; Bit 2: 1=20-Zeilen-Modus mit 8x10-Zeichenzellen}
	pusha
IFDEF DEBUG
	 cld
	 sub	bh,0E8h
	 cmp	bh,08h
	 jnc	@@e
ENDIF
	 and	bh,3		;{auf Pixeladresse}
	 mov	si,bx		;{Adresse retten}
	 mov	ax,bx
	 mov	cl,40
	 div	cl		;{AH=ZeichenSpalte, AL=ZeichenZeile}
	 test	[KC4Port88H],4
	 jz	@@z24		;{normaler 24-Zeilen-Modus}
	 cmp	al,20
	 jnc	@@e
	 xchg	ax,dx
	 push	es
	  call	InvalChrBox	;{mit DH=X und DL=Y}
	  call	CalcZ20
	  add	ax,40		;Korrektur, um Leerzeile mit HFarbe zu fllen
	  call	CalcZ7		;Weitere Vorbereitungen
	  push	ds
	   mov	ds,[hCharMap]
;{Hauptschleife mit: ES:DI=Windows-DIB-Adresse, DS:SI=Zeichenbild, AH=HFarbe
; BH=VFarbe, BL=Bits, CH=Maske, CL=Schleifenz„hler}
	   mov	al,ah
	   mov	cx,4		;{Word-Z„hler}
	   rep	stosw		;{Obere leere Zeile fllen}
	   sub	di,8+320
	   call	StosZ
	   mov	cl,4
	   mov	al,ah
	   rep	stosw		;{Untere leere Zeile fllen}
	  jmp	@@w20
@@z24:
	 cmp	al,24		;{24. oder 25. Zeile?}
	 jnc	@@e		;{Ja-raus}
	 xchg	ax,dx		;{DH=Spalte(X), DL=Zeile(Y)}
;{Test auf InUpdate und Aufruf von InvalidateRect}
	 push	es
	  call	InvalChrBox
	  call	CalcZ24
	  call	CalcZ7
	  push	ds
	   mov	ds,[hCharMap]
;{Hauptschleife mit: ES:DI=Windows-DIB-Adresse, DS:SI=Zeichenbild, AH=HFarbe
; BH=VFarbe, BL=Bits, CH=Maske, CL=Schleifenz„hler}
	   call	StosZ
@@w20:	  pop	ds
	 pop	es
@@e:	popa
	ret
endp IRM_Access7

;**************************
proc IRM_Update1
;{PE: -, PA: -, VR: Flags}
;Langsame Variante, jedoch mit Anpassung an 20/24-Zeilen-Modus
	pusha
	 push   es
;ACHTUNG-beim IRM_Access1 erfolgt nicht das L”schen der Freizeilen zwischen
;den Zeilen, deshalb muá hier im 20-Zeilen-Modus die Bitmap gel”scht werden!
	  test	[KC4Port88H],4
	  jz	@@0
	  mov	es,[hDisplay]
	  xor	ax,ax
	  mov	di,ax
	  mov	cx,200*40/2
	  cld
	  rep	stosw		;{Speicher l”schen wegen Freizeilen}
@@0:	  mov	di,offset IRM_Access1
ToUpdZ:
	  mov	cx,40*24
	  test	[KC4Port88H],4
	  jz	@@1
	  mov	cx,40*20	;Anzahl Zeichen
ToUZ1013:
@@1:	  mov	bx,0EC00h	;Zeichenspeicher (auch bei Z1013!)
	  jmp	ToUpdate
endp IRM_Update1

;**************************
proc IRM_Update7
;{PE: -, PA: -, VR: Flags}
;Langsame Variante, jedoch mit Anpassung an 20/24-Zeilen-Modus
	pusha
	 push   es
	  mov	di,offset IRM_Access7
	  jmp	ToUpdZ		;weiter wie bei Update1
endp IRM_Update7

;**************************
;*** Routinen fr Z1013 ***
;**************************

proc IRM_Access9
;{PE: BX=Schreibadresse, (ES:BX bereits geschrieben), AL=Zeichen
; PA: -, VR: Flags}
	pusha
	 mov	ch,al		;{Zeichen retten}
	 sub	bh,0ECh
IFDEF DEBUG
	 cmp	bh,04h
	 jnc	@@e
ENDIF
	 mov	dx,bx
	 shl	dx,3
	 shr	dl,3
	 mov	di,dx
	 xchg	dl,dh		;{DL=Zeile(Y), DH=Spalte(X)}
;{Test auf InUpdate und Aufruf von InvalidateRect}
	 push	es
	  call	InvalChrBox
	  xor	di,1FE0h	;{Zeile strzen fr DIB}
	  mov	es,[hDisplay]	;{ES:DI: fertig ist die DIB-Adresse!}
	  mov	cl,0
	  ror	cx,5		;{Zeichen 'runterholen und *8}
	  push	ds
	   mov	ds,[hCharMap]
	   mov	si,cx		;{und DS:SI zeigt auf Zeichenbildtabelle}
;{Hauptschleife mit: ES:DI=Windows-DIB-Adresse, DS:SI=Zeichenbild,
; CX=Schleifenz„hler}
	   cld
	   mov	cx,8
@@l:	   movsb
	   sub	di,1+32		;{DIB ist "verkehrtherum"}
	   loop	@@l
	  pop	ds
	 pop	es
@@e:	popa
	ret
endp IRM_Access9

;**************************
proc IRM_Update9
;{PE: -, PA: -, VR: Flags}
	pusha
	 push   es
	  mov	di,offset IRM_Access9
	  mov	cx,32*32
	  jmp	ToUZ1013
endp IRM_Update9

	END
Detected encoding: UTF-80