text:
Oberon/ETH Oberon/2.3.7/VGA.Display.Mod

(* ETH Oberon, Copyright 1990-2003 Computer Systems Institute, ETH Zurich, CH-8092 Zurich. Refer to the license.txt file provided with this distribution. *) MODULE Display;	(* Ott Hans-Werner, ard, pjm *) IMPORT Kernel, SYSTEM, Objects; CONST BG* = 0; FG* = 15; (*background, foreground*) replace* = 0; paint* = 1; invert* = 2; (*operation modes*) remove* = 0; suspend* = 1; restore* = 2; newprinter* = 3; (*ControlMsg id*) reduce* = 0; extend* = 1; move* = 2; (*ModifyMsg id*) display* = 0; state* = 1; (*ModifyMsg mode*) screen* = 0; printer* = 1; (* DisplayMsg device *) full* = 0; area* = 1; contents* = 2; (* DisplayMsg id. *) get* = 0; set* = 1; reset* = 2; (*SelectMsg id*) drop* = 0; integrate* = 1; (*ConsumeMsg id*) unknown* = 0; index8* = 8; color555* = 16; color565* = 17; color664* = 18; color888* = 24; color8888* = 32; TYPE Color* = LONGINT; Pattern* = LONGINT; PatternPtr = POINTER TO RECORD w, h: CHAR; pixmap: ARRAY 8192 OF CHAR END; List = POINTER TO ListDesc; ListDesc = RECORD next: List; pat: PatternPtr END; Frame* = POINTER TO FrameDesc; FrameDesc* = RECORD (Objects.ObjDesc) next*, dsc*: Frame; X*, Y*, W*, H*: INTEGER END; FrameMsg* = RECORD (Objects.ObjMsg) F*: Frame; (*target*) x*, y*, res*: INTEGER END; ControlMsg* = RECORD (FrameMsg) id*: INTEGER END; ModifyMsg* = RECORD (FrameMsg) id*, mode*: INTEGER; dX*, dY*, dW*, dH*: INTEGER; X*, Y*, W*, H*: INTEGER END; DisplayMsg* = RECORD (FrameMsg) device*: INTEGER; id*: INTEGER; u*, v*, w*, h*: INTEGER END; LocateMsg* = RECORD (FrameMsg) loc*: Frame; X*, Y*, u*, v*: INTEGER END; SelectMsg* = RECORD (FrameMsg) id*: INTEGER; time*: LONGINT; sel*: Frame; obj*: Objects.Object END; ConsumeMsg* = RECORD (FrameMsg) id*: INTEGER; u*, v*: INTEGER; obj*: Objects.Object END; MsgProc* = PROCEDURE (VAR M: FrameMsg); VAR Unit*: LONGINT; (* RasterUnit = Unit/36000 mm *) Left*, (* left margin of black-and-white maps *) ColLeft*, (* left margin of color maps *) Bottom*, (* bottom of primary map *) UBottom*, (* bottom of secondary map *) Width*, (* map width *) Height*: (* map hight*) INTEGER; arrow*, star*, cross*, downArrow*, hook*, grey0*, grey1*, grey2*, ticks*, solid*: Pattern; Broadcast*: MsgProc; pattern: List; clipx, clipy, clipright, cliptop, height, width: INTEGER;	(* clipping variables *) width3: LONGINT; mask, imask: ARRAY 9 OF CHAR; rev: ARRAY 256 OF CHAR; depth: INTEGER; palette: ARRAY 256 OF LONGINT; PROCEDURE max (i, j: INTEGER): INTEGER; BEGIN IF i >= j THEN RETURN i ELSE RETURN j END END max; PROCEDURE min (i, j: LONGINT): INTEGER; BEGIN IF i >= j THEN RETURN SHORT(j) ELSE RETURN SHORT(i) END END min; PROCEDURE Map*(x: LONGINT): LONGINT; BEGIN RETURN 0A0000H END Map; PROCEDURE AdjustClip*(x, y, w, h: LONGINT); VAR right, top: INTEGER; BEGIN right := SHORT(x + w); top := SHORT(y + h); clipx := max(clipx, SHORT(x)); clipy := max(clipy, SHORT(y)); clipright := min(right, clipright); cliptop := min(top, cliptop) END AdjustClip; PROCEDURE GetDim*(pat: Pattern; VAR w, h: INTEGER); VAR ch: CHAR; BEGIN SYSTEM.GET(pat, ch); w := ORD(ch); SYSTEM.GET(pat+1, ch); h := ORD(ch) END GetDim; PROCEDURE ResetClip*; BEGIN clipx := 0; clipy := UBottom; clipright := width; cliptop := height END ResetClip; PROCEDURE SetClip*(x, y, w, h: LONGINT); BEGIN clipright := SHORT(x+w); cliptop := SHORT(y+h); clipy := SHORT(y); clipx := SHORT(x) END SetClip; PROCEDURE GetClip*(VAR x, y, w, h: INTEGER); BEGIN x := clipx; y := clipy; w := clipright - clipx; h := cliptop - clipy END GetClip; PROCEDURE SetColor*(col: Color; red, green, blue: LONGINT);	(* 0 <= col, red, green, blue < 256 *) VAR ch: CHAR; BEGIN palette[col] := ASH(ASH(red, 8) + green, 8) + blue; col := col MOD 16; (* see table 8.11 of Ferraro, 3rd edition *) IF col = 6 THEN col := 14H ELSIF col > 7 THEN INC(col, 30H) END; red := (red + 4) DIV 4 -1; green := (green + 4) DIV 4 -1; blue := (blue + 4) DIV 4 -1; SYSTEM.PORTOUT(3C8H, CHR(col)); SYSTEM.PORTOUT(3C9H, CHR(red)); SYSTEM.PORTOUT(3C9H, CHR(green)); SYSTEM.PORTOUT(3C9H, CHR(blue)) END SetColor; PROCEDURE GetColor*(col: Color; VAR red, green, blue: INTEGER); BEGIN IF col >= 0 THEN col := palette[col] END; red := SHORT(ASH(col, -16) MOD 256); green := SHORT(ASH(col, -8) MOD 256); blue := SHORT(col MOD 256) END GetColor; PROCEDURE RGB*(red, green, blue: LONGINT): Color; BEGIN RETURN MIN(LONGINT) + ASH(red, 16) + ASH(green, 8) + blue END RGB; PROCEDURE Dot*(col: Color; x, y, mode: LONGINT); CODE {SYSTEM.i386} MOV AX, clipy CMP WORD y[EBP], AX 		JL ret MOV AX, cliptop CMP WORD y[EBP], AX 		JGE ret MOV AX, clipx CMP WORD x[EBP], AX 		JL ret MOV AX, clipright CMP WORD x[EBP], AX 		JGE ret MOV AX, 1803H	; AL = Data/Rotate; AH = Modus; DX = Graphic-Controller MOV DX, 03CEH CMP mode[EBP],invert JE smode MOV AX,3 CMP mode[EBP],replace JE smode MOV AX, 1003H	; paint smode: OUT DX, AX 		MOV DX, 03C4H	; AX = Default map mask; DX = Sequencer MOV AX, 0F02H OUT DX, AX 		MOV DX, 03CEH	; AL = Gaphics mode; AH = Read-Mode = 0/Write-Mode = 2 (bits 0,1) MOV AX, 0205H OUT DX, AX 		MOV AX, Height SUB AX, WORD y[EBP] DEC AX 		MOVSX EAX,AX IMUL EAX,width3 MOV ESI, x[EBP] SHR ESI, 3 ADD ESI, EAX AND ESI, 0FFFFH ADD ESI, 0A0000H MOV DX, 03CEH MOV CL, BYTE x[EBP] AND CL, 7 MOV AH, 128 SHR AH, CL 		MOV AL, 8 OUT DX, AX 		MOV AL, [ESI]	; latch bytes MOV AL, BYTE col[EBP] MOV [ESI], AL ret: END Dot; PROCEDURE CopyBlock*(sx, sy, w, h, dx, dy, mode: LONGINT); VAR top, right: INTEGER; x1, x2, x3, x4, x5, x6, x7, x8: LONGINT; help, help2, diff, start, end, msk, imsk, lh: LONGINT; leftmask, rightmask: CHAR; plane, count: SHORTINT; CODE {SYSTEM.i386} MOV EDX, dx[EBP] MOV AX,DX ADD AX, WORD w[EBP] MOV right[EBP], AX	; right := DX + W 		MOV AX, WORD dy[EBP] ADD AX, WORD h[EBP] MOV top[EBP], AX	; top := DY + H 			; IF DX < clipx THEN W := W - (clipx - DX); DX := clipx END CMP DX, clipx JGE ok0 MOV AX, clipx SUB AX, DX 		SUB WORD w[EBP], AX 		MOV DX, clipx ok0: ; IF DY < clipy THEN H := H - (clipy - DY); DY := clipy END MOV AX, WORD dy[EBP] CMP AX, clipy JGE ok1 MOV AX, clipy SUB AX, WORD dy[EBP] SUB WORD h[EBP], AX 		MOV AX, clipy MOV WORD dy[EBP], AX ok1: ; IF clipright < right THEN  W :=  clipright - DX END MOV AX, clipright CMP AX, right[EBP] JGE ok2 MOV AX, clipright SUB AX, DX 		MOV WORD w[EBP], AX ok2: ; IF cliptop < top THEN H := cliptop - DY END MOV AX, cliptop CMP AX, top[EBP] JGE ok3 MOV AX, cliptop SUB AX, WORD dy[EBP] MOV WORD h[EBP], AX ok3: ;	IF (W <= 0) OR (H <= 0) THEN RETURN END; CMP WORD w[EBP], 0 JLE ret CMP WORD h[EBP], 0 JLE ret LEA EAX, mask MOV msk[EBP], EAX	; msk := SYSTEM.ADR(mask[0]) LEA EAX, imask MOV imsk[EBP], EAX	; imsk := SYSTEM.ADR(imask[0]) MOV AX, height DEC AX 		MOVSX EAX,AX MOV lh[EBP], EAX	; h := height-1 MOV dx[EBP], EDX	; DX := DX 		MOV	EAX, lh[EBP] MOV	EBX, EAX SUB	EAX, sy[EBP]	; EAX := height - sy 		MOV	sy[EBP], EAX SUB	EBX, dy[EBP]	; EBX := height - dy 		MOV	dy[EBP], EBX MOV	EAX, sx[EBP]	; EAX := sx 		MOV	ECX, EAX MOV	EBX, EAX MOV	EDX, EAX SHR	EAX, 3	; EAX := sx DIV 8 AND	ECX, 7	; ECX := sx MOD 8 ADD	EBX, w[EBP] ADD	EDX, w[EBP] SHR	EBX, 3	; EBX := (sx+w) DIV 8 AND	EDX, 7	; EDX := (sx+w) MOD 8 MOV	x1[EBP], EAX	; x1 := sx DIV 8 MOV	x2[EBP], EBX	; x2 := (sx+w) DIV 8 MOV	x3[EBP], ECX	; x3 := sx MOD 8 INC	EDX MOV	x4[EBP], EDX	; x4 := (sx+w) MOD 8 (+1) MOV	EAX, dx[EBP]	; EAX := dx 		MOV	ECX, EAX MOV	EBX, EAX MOV	EDX, EAX SHR	EAX, 3	; EAX := dx DIV 8 AND	ECX, 7	; ECX := dx MOD 8 ADD	EBX, w[EBP]	; EBX := dx +w ADD	EDX, w[EBP] SHR	EBX, 3	; EBX := (dx+w) DIV 8 AND	EDX, 7	; EDX := (dx+w) MOD 8 MOV	x5[EBP], EAX	; x5 := dx DIV 8 MOV	x6[EBP], EBX	; x6 := (dx+w) DIV 8 MOV	x7[EBP], ECX	; x7 := dx MOD 8 INC	EDX MOV	x8[EBP], EDX	; x8 := (dx+w) MOD 8 MOV	ESI, sy[EBP] IMUL	ESI, width3	; w3[EBP] ADD	ESI, x1[EBP]	; ESI := startbyte source bottomleft AND ESI, 0FFFFH ADD ESI, 0A0000H	; offset of screen MOV	EDI, dy[EBP] IMUL	EDI, width3	; w3[EBP] ADD	EDI, EAX AND EDI, 0FFFFH ADD EDI, 0A0000H	; offset of screen MOV	start[EBP], ESI	; starbyte source bottom left MOV	end[EBP], EDI	; startbyte dest bottom left MOV	DX, 03CEH MOV	AX, 0005 OUT	DX, AX	; read/writemode = 0 MOV	AX, 0001 OUT	DX, AX	; enable/reset = 0000b MOV	AH, 0 MOV	AL, 3 OUT	DX, AX	; replacemode MOV	EBX, x8[EBP] DEC	EBX MOV	EDX, msk[EBP] MOV	AH, [EDX][EBX] ;			MOV	AH, mask[EBX] MOV	rightmask[EBP], AH 		MOV	EBX, x7[EBP] MOV	EDX, imsk[EBP] MOV	AH, [EDX][EBX] ;			MOV	AH, imask[EBX] MOV	leftmask[EBP], AH 		MOV	EBX, x6[EBP] SUB	EBX, x5[EBP]	; EBX := difference in bytes dx/dx+w DEC	EBX MOV	diff[EBP], EBX JGE	inmorebytes MOV	DH, rightmask[EBP]	; EBX = 0 /only one byte AND	DH, leftmask[EBP] MOV	leftmask[EBP], DH 		MOV	rightmask[EBP], DH inmorebytes: MOV	EDX, h[EBP]	; EDX := h 		MOV	EAX, sx[EBP]	; EAX := sx 		MOV	EBX, sy[EBP]	; EBX := sy CMP	EAX, dx[EBP]	; sx < dx ? JGE	CB1	; no -> goto CB1 MOV	ECX, x8[EBP]	; sx < dx ! SUB	ECX, x4[EBP]	; ECX := difference between s/dest x 		ADD	ECX, 32 AND	CL, 1FH	; CL := rotate shift count CMP	BX, WORD dy[EBP]	; sy < dy ? was EBX JL	CB10	; yes goto CB10 JMP	CB13	; else goto CB13 CB1: SUB	ECX, x3[EBP]	; sx >= dx 		ADD	ECX, 32 AND	CL, 1FH	; CL:= rotate shift count CMP	BX, WORD dy[EBP]	; sy >= dy? JGE	CB12	; yes goto CB12 CB11: MOV	help[EBP], EDX	; (sx >= dx) & (sy < dy) / save linecounter MOV	EBX, diff[EBP] CMP	EBX, 1 JLE	byte11	; in 1 Byte => normal CopyBlock CMP	CL, 0	; rotateoffset = 0 ? JE	qCB11	; QuickCopy byte11: MOV	count[EBP], 3	; there are 4 Bitplanes MOV	plane[EBP], 8	; begin with plane 4 CB11h: MOV	DX, 03CEH MOV	AH, count[EBP] MOV	AL, 4 OUT	DX, AX	; select plane to read MOV	AH, leftmask[EBP]	; bitmask select MOV	AL, 8 OUT	DX, AX	; set mask at destination MOV	DX, 03C4H MOV	AH, plane[EBP]	; set bitplanemask MOV	AL, 2 OUT	DX, AX	; set sequencer XOR	EAX, EAX MOV	AH, [ESI] MOV	AL, 1[ESI] ADD	ESI, 2 ROR	EAX, CL CMP	EBX, 0	; in one byte ? JL	cbl31 cbl6i: MOV	DL, [EDI]	; latch bytes MOV	[EDI], AH 		INC	EDI ROL	EAX, 8 CMP	EBX, 0	; in 2 bytes ? JE	cbl3 ;** MOV	help2[EBP], EAX MOV	DX, 03CEH MOV	AX, 0FF08H	; all maskbits OUT	DX, AX 		MOV	EAX, help2[EBP] cbl6: ROL	EAX, CL 		MOV	AL, [ESI] INC	ESI ROR	EAX, CL 		MOV	[EDI], AH 		INC	EDI ROL	EAX, 8 DEC	BX JG	cbl6 cbl3: MOV	EBX, x6[EBP] SUB	EBX, x5[EBP] MOV	help2[EBP], EBX MOV	EBX, x2[EBP] SUB	EBX, x1[EBP] CMP	EBX, help2[EBP] JE	cbl31 ROL	EAX, CL 		MOV	AL, [ESI] ROR	EAX, CL cbl31: PUSH	EAX MOV	DX, 03CEH MOV	AH, rightmask[EBP] MOV	AL, 8 OUT	DX, AX	; set right dest bitmask POP	EAX MOV	DL, [EDI] MOV	[EDI], AH 		MOV	ESI, start[EBP] MOV	EDI, end[EBP] SHR	plane[EBP], 1 MOV	EBX, diff[EBP] DEC	count[EBP] JGE	CB11h MOV	EDX, help[EBP]	; next line / get linecounter SUB	start[EBP], 80 SUB	end[EBP], 80 MOV	ESI, start[EBP] MOV	EDI, end[EBP] MOV	count[EBP], 3 MOV	plane[EBP], 8 DEC	EDX MOV	help[EBP], EDX	; save new linecounter CMP	EDX, 0 JG	CB11h JMP	resetgrafCB CB12: MOV	EAX, h[EBP]	; (sx >= dx) & (sy >= dy) DEC	EAX IMUL	EAX, width3	; w3[EBP]	; (Note: EDX is not modified) SUB	ESI, EAX SUB	EDI, EAX MOV	start[EBP], ESI MOV	end[EBP], EDI MOV	help[EBP], EDX	; save linecounter MOV	EBX, diff[EBP] CMP	EBX, 1 JLE	byte12 CMP	CL, 0	; rotate shift = 0 ? JE	qCB12	; quick CopyBlock byte12: MOV	count[EBP], 3	; there are 4 Bitplanes MOV	plane[EBP], 8 cbl1: MOV	DX, 03CEH MOV	AH, count[EBP] MOV	AL, 4 OUT	DX, AX	; select plane to read MOV	AH, leftmask[EBP]	; bitmask select MOV	AL, 8 OUT	DX, AX	; set mask at destination MOV	DX, 03C4H MOV	AH, plane[EBP] MOV	AL, 2 OUT	DX, AX	; set sequencer XOR	EAX, EAX MOV	AH, [ESI] MOV	AL, 1[ESI] ADD	ESI, 2 ROR	EAX, CL 		CMP	EBX, 0 JL	cbl41 cbl7i: MOV	DL, [EDI]	; latch bytes MOV	[EDI], AH 		INC	EDI ROL	EAX, 8	; ready for new out CMP	EBX, 0	; in 2 bytes ? JE	cbl4 ;** MOV	help2[EBP], EAX MOV	DX, 03CEH MOV	AX, 0FF08H	; all maskbits OUT	DX, AX 		MOV	EAX, help2[EBP] cbl7: ROL	EAX, CL 		MOV	AL, [ESI] INC	ESI ROR	EAX, CL 		MOV	[EDI], AH 		INC	EDI ROL	EAX, 8 DEC	BX JG	cbl7 cbl4: MOV	EBX, x6[EBP] SUB	EBX, x5[EBP] MOV	help2[EBP], EBX MOV	EBX, x2[EBP] SUB	EBX, x1[EBP] CMP	EBX, help2[EBP] JE	cbl41 ROL	EAX, CL 		MOV	AL, [ESI] ROR	EAX, CL cbl41: PUSH	EAX MOV	DX, 03CEH MOV	AH, rightmask[EBP] MOV	AL, 8 OUT	DX, AX	; set right dest bitmask POP	EAX MOV	DL, [EDI] MOV	[EDI], AH 		MOV	ESI, start[EBP] MOV	EDI, end[EBP] SHR	plane[EBP], 1 MOV	EBX, diff[EBP] DEC	count[EBP] JGE	cbl1 MOV	EDX, help[EBP]	; next line / get linecounter ADD	start[EBP], 80 ADD	end[EBP], 80 MOV	ESI, start[EBP] MOV	EDI, end[EBP] MOV	plane[EBP], 8 MOV	count[EBP], 3 DEC	EDX MOV	help[EBP], EDX	; save new linecounter CMP	EDX, 0 JG	cbl1 JMP	resetgrafCB CB10: MOV	EAX, x2[EBP]	; (sx < dx) & (sy < dy) SUB	EAX, x1[EBP] ADD	ESI, EAX MOV	EAX, x6[EBP] SUB	EAX, x5[EBP] ADD	EDI, EAX MOV	start[EBP], ESI	; startbyte source bottom right MOV	end[EBP], EDI	; starbyte dest bottom right MOV	help[EBP], EDX	; save linecounter MOV	EBX, diff[EBP] CMP	EBX, 1 JLE	byte10 CMP	CL, 0 JE	qCB10	; Quick CopyBlock byte10: MOV	count[EBP], 3	; there are 4 Bitplanes MOV	plane[EBP], 8 cbl10: MOV	DX, 03CEH MOV	AH, count[EBP] MOV	AL, 4 OUT	DX, AX	; select plane to read MOV	AH, rightmask[EBP]	; bitmask select MOV	AL, 8 OUT	DX, AX	; set mask at destination MOV	DX, 03C4H MOV	AH, plane[EBP] MOV	AL, 2 OUT	DX, AX	; set sequencer XOR	EAX, EAX MOV	AL, [ESI] MOV	AH, -1[ESI] SUB	ESI, 2 ROR	EAX, CL CMP	EBX, 0	; in one byte ? JGE	cbl11i MOV	DL, rightmask[EBP]	; xchg masks MOV	leftmask[EBP], DL 		JMP	cbl121 cbl11i: MOV	DL, [EDI]	; latch bytes MOV	[EDI], AL 		DEC	EDI ROR	EAX, 8 CMP	EBX, 0 JE	cbl12 ;** MOV	help2[EBP], EAX MOV	DX, 03CEH MOV	AX, 0FF08H	; all maskbits OUT	DX, AX 		MOV	EAX, help2[EBP] cbl11: ROL	EAX, CL 		MOV	AH, [ESI] DEC	ESI ROR	EAX, CL 		MOV	[EDI], AL 		DEC	EDI ROR	EAX, 8 DEC	BX JG	cbl11 cbl12: MOV	EBX, x6[EBP] SUB	EBX, x5[EBP] MOV	help2[EBP], EBX MOV	EBX, x2[EBP] SUB	EBX, x1[EBP] CMP	EBX, help2[EBP] JE	cbl121 ROL	EAX, CL 		MOV	AH, [ESI] ROR	EAX, CL cbl121: PUSH	EAX MOV	DX, 03CEH MOV	AH, leftmask[EBP] MOV	AL, 8 OUT	DX, AX	; set left dest bitmask POP	EAX MOV	DL, [EDI] MOV	[EDI], AL 		MOV	ESI, start[EBP] MOV	EDI, end[EBP] SHR	plane[EBP], 1 MOV	EBX, diff[EBP] DEC	count[EBP] JGE	cbl10 MOV	EDX, help[EBP]	; next line / get linecounter SUB	start[EBP], 80 SUB	end[EBP], 80 MOV	ESI, start[EBP] MOV	EDI, end[EBP] MOV	plane[EBP], 8 MOV	count[EBP], 3 DEC	EDX MOV	help[EBP], EDX	; save new linecounter CMP	EDX, 0 JG	cbl10 JMP	resetgrafCB CB13: MOV	EAX, h[EBP]	; (sx < dx) & (sy >= dy) DEC	EAX IMUL	EAX, width3	; w3[EBP] SUB	ESI, EAX SUB	EDI, EAX MOV	EAX, x2[EBP] SUB	EAX, x1[EBP] ADD	ESI, EAX MOV	EAX, x6[EBP] SUB	EAX, x5[EBP] ADD	EDI, EAX MOV	start[EBP], ESI MOV	end[EBP], EDI MOV	help[EBP], EDX	; save linecounter MOV	EBX, diff[EBP] CMP	EBX, 1 JLE	byte13 CMP	CL, 0 JE	qCB13 byte13: MOV	count[EBP], 3	; there are 4 Bitplanes MOV	plane[EBP], 8 cbl13: MOV	DX, 03CEH MOV	AH, count[EBP] MOV	AL, 4 OUT	DX, AX	; select plane to read MOV	AH, rightmask[EBP]	; bitmask select MOV	AL, 8 OUT	DX, AX	; set mask at destination MOV	DX, 03C4H MOV	AH, plane[EBP] MOV	AL, 2 OUT	DX, AX	; set sequencer XOR	EAX, EAX MOV	AL, [ESI] MOV	AH, -1[ESI] SUB	ESI, 2 ROR	EAX, CL 		CMP	EBX, 0 JGE	cbl14i MOV	DL, rightmask[EBP] MOV	leftmask[EBP], DL 		JMP	cbl151 cbl14i: MOV	DL, [EDI]	; latch bytes MOV	[EDI], AL 		DEC	EDI ROR	EAX, 8 CMP	EBX, 0	; in 2 bytes ? JE	cbl15 ;** MOV	help2[EBP], EAX MOV	DX, 03CEH MOV	AX, 0FF08H	; all maskbits OUT	DX, AX 		MOV	EAX, help2[EBP] cbl14: ROL	EAX, CL 		MOV	AH, [ESI] DEC	ESI ROR	EAX, CL 		MOV	[EDI], AL 		DEC	EDI ROR	EAX, 8 DEC	BX JG	cbl14 cbl15: MOV	EBX, x6[EBP] SUB	EBX, x5[EBP] MOV	help2[EBP], EBX MOV	EBX, x2[EBP] SUB	EBX, x1[EBP] CMP	EBX, help2[EBP] JE	cbl151 ROL	EAX, CL 		MOV	AH, [ESI] ROR	EAX, CL cbl151: PUSH	EAX MOV	DX, 03CEH MOV	AH, leftmask[EBP] MOV	AL, 8 OUT	DX, AX	; set left dest bitmask POP	EAX MOV	DL, [EDI] MOV	[EDI], AL 		MOV	ESI, start[EBP] MOV	EDI, end[EBP] SHR	plane[EBP], 1 MOV	EBX, diff[EBP] DEC	count[EBP] JGE	cbl13 MOV	EDX, help[EBP]	; next line / get linecounter ADD	start[EBP], 80 ADD	end[EBP], 80 MOV	ESI, start[EBP] MOV	EDI, end[EBP] MOV	count[EBP], 3 MOV	plane[EBP], 8 DEC	EDX MOV	help[EBP], EDX	; save new linecounter CMP	EDX, 0 JG	cbl13 JMP	resetgrafCB qCB12: MOV	DX, 03CEH	; Quick CopyBlock begin MOV	AH, leftmask[EBP]	; bitmask select MOV	AL, 8 OUT	DX, AX	; set mask at destination MOV	count[EBP], 3 MOV	plane[EBP], 8 q12lloop: MOV	DX, 03CEH MOV	AH, count[EBP] MOV	AL, 4 OUT	DX, AX 		MOV	DX, 03C4H MOV	AH, plane[EBP] MOV	AL, 2 OUT	DX, AX 		MOV	CL, [ESI]	; fetch source MOV	AL, [EDI]	; latch at destiation MOV	[EDI], CL	; set source ; 		MOV	DX, 03CEH SHR	plane[EBP], 1 DEC	count[EBP] JGE	q12lloop	; next plane MOV	DX, 03C4H MOV	AH, 00FH MOV	AL, 2 OUT	DX, AX	; all planes again MOV	DX, 03CEH INC	ESI INC	EDI MOV	AX, 0105H	; writemode 1 OUT	DX, AX qcbl1: MOV	AL, [ESI] INC	ESI MOV	[EDI], AH 		INC	EDI DEC	BX JG	qcbl1 qcbl7: MOV	DX, 03CEH MOV	AH, rightmask[EBP] MOV	AL, 8 OUT	DX, AX	; set right dest bitmask MOV	AX, 0005	; writemode 0 OUT	DX, AX 		MOV	count[EBP], 3 MOV	plane[EBP], 8 q12rloop: MOV	DX, 03CEH MOV	AH, count[EBP] MOV	AL, 4 OUT	DX, AX 		MOV	DX, 03C4H MOV	AH, plane[EBP] MOV	AL, 2 OUT	DX, AX 		MOV	CL, [ESI]	; fetch source MOV	AL, [EDI]	; latch at destiation MOV	[EDI], CL	; set source ; 		MOV	DX, 03CEH SHR	plane[EBP], 1 DEC	count[EBP] JGE	q12rloop	; next plane MOV	EBX, diff[EBP] ADD	start[EBP], 80 ADD	end[EBP], 80 MOV	ESI, start[EBP] MOV	EDI, end[EBP] DEC	help[EBP]	; dec linecounter JG	qCB12 JMP	resetgrafCB qCB11: MOV	DX, 03CEH MOV	AH, leftmask[EBP]	; bitmask select MOV	AL, 8 OUT	DX, AX	; set mask at destination MOV	count[EBP], 3 MOV	plane[EBP], 8 q11lloop: MOV	DX, 03CEH MOV	AH, count[EBP] MOV	AL, 4 OUT	DX, AX 		MOV	DX, 03C4H MOV	AH, plane[EBP] MOV	AL, 2 OUT	DX, AX 		MOV	CL, [ESI]	; fetch source MOV	AL, [EDI]	; latch at destiation MOV	[EDI], CL	; set source ; 		MOV	DX, 03CEH SHR	plane[EBP], 1 DEC	count[EBP] JGE	q11lloop	; next plane MOV	DX, 03C4H MOV	AH, 00FH MOV	AL, 2 OUT	DX, AX	; all panes again MOV	DX, 03CEH INC	ESI INC	EDI MOV	AX, 0105H	; writemode 1 OUT	DX, AX qcbl6: MOV	AL, [ESI] INC	ESI MOV	[EDI], AH 		INC	EDI DEC	BX JG	qcbl6 qcbl3: MOV	DX, 03CEH MOV	AH, rightmask[EBP] MOV	AL, 8 OUT	DX, AX	; set right dest bitmask MOV	AX, 0005	; writemode 0 OUT	DX, AX 		MOV	count[EBP], 3 MOV	plane[EBP], 8 q11rloop: MOV	DX, 03CEH MOV	AH, count[EBP] MOV	AL, 4 OUT	DX, AX 		MOV	DX, 03C4H MOV	AH, plane[EBP] MOV	AL, 2 OUT	DX, AX 		MOV	CL, [ESI]	; fetch source MOV	AL, [EDI]	; latch at destiation MOV	[EDI], CL	; set source ; 		MOV	DX, 03CEH SHR	plane[EBP], 1 DEC	count[EBP] JGE	q11rloop	; next plane MOV	EBX, diff[EBP] SUB	start[EBP], 80 SUB	end[EBP], 80 MOV	ESI, start[EBP] MOV	EDI, end[EBP] DEC	help[EBP]	; dec linecounter JG	qCB11 JMP	resetgrafCB qCB10: MOV	DX, 03CEH MOV	AH, rightmask[EBP]	; bitmask select MOV	AL, 8 OUT	DX, AX	; set mask at destination MOV	count[EBP], 3 MOV	plane[EBP], 8 q10rloop: MOV	DX, 03CEH MOV	AH, count[EBP] MOV	AL, 4 OUT	DX, AX 		MOV	DX, 03C4H MOV	AH, plane[EBP] MOV	AL, 2 OUT	DX, AX 		MOV	CL, [ESI]	; fetch source MOV	AL, [EDI]	; latch at destiation MOV	[EDI], CL	; set source ; 		MOV	DX, 03CEH SHR	plane[EBP], 1 DEC	count[EBP] JGE	q10rloop	; next plane MOV	DX, 03C4H MOV	AH, 00FH MOV	AL, 2 OUT	DX, AX	; all panes again MOV	DX, 03CEH DEC	ESI DEC	EDI MOV	AX, 0105H	; writemode 1 OUT	DX, AX qcbl10: MOV	AL, [ESI] DEC	ESI MOV	[EDI], AH 		DEC	EDI DEC	BX JG	qcbl10 qcbl12: MOV	DX, 03CEH MOV	AX, 0005	; writemode 0 OUT	DX, AX 		MOV	AH, leftmask[EBP] MOV	AL, 8 OUT	DX, AX	; set left dest bitmask MOV	count[EBP], 3 MOV	plane[EBP], 8 q10lloop: MOV	DX, 03CEH MOV	AH, count[EBP] MOV	AL, 4 OUT	DX, AX 		MOV	DX, 03C4H MOV	AH, plane[EBP] MOV	AL, 2 OUT	DX, AX 		MOV	CL, [ESI]	; fetch source MOV	AL, [EDI]	; latch at destiation MOV	[EDI], CL	; set source ; 		MOV	DX, 03CEH SHR	plane[EBP], 1 DEC	count[EBP] JGE	q10lloop	; next plane MOV	EBX, diff[EBP] SUB	start[EBP], 80 SUB	end[EBP], 80 MOV	ESI, start[EBP] MOV	EDI, end[EBP] DEC	help[EBP]	; dec linecounter JG	qCB10 JMP	resetgrafCB qCB13: MOV	DX, 03CEH MOV	AH, rightmask[EBP]	; bitmask select MOV	AL, 8 OUT	DX, AX	; set mask at destination MOV	AH, 0 MOV	AL, 3 OUT	DX, AX 		MOV	count[EBP], 3 MOV	plane[EBP], 8 q13rloop: MOV	DX, 03CEH MOV	AH, count[EBP] MOV	AL, 4 OUT	DX, AX 		MOV	DX, 03C4H MOV	AH, plane[EBP] MOV	AL, 2 OUT	DX, AX 		MOV	CL, [ESI]	; fetch source MOV	AL, [EDI]	; latch at destiation MOV	[EDI], CL	; set source ; 		MOV	DX, 03CEH SHR	plane[EBP], 1 DEC	count[EBP] JGE	q13rloop	; next plane MOV	DX, 03C4H MOV	AH, 00FH MOV	AL, 2 OUT	DX, AX	; all panes again MOV	DX, 03CEH DEC	ESI DEC	EDI MOV	AX, 0105H	; writemode 1 OUT	DX, AX qcbl13: MOV	AL, [ESI] DEC	ESI MOV	[EDI], AH 		DEC	EDI DEC	BX JG	qcbl13 qcbl14: MOV	DX, 03CEH MOV	AX, 0005	; writemode 0 OUT	DX, AX 		MOV	AH, leftmask[EBP] MOV	AL, 8 OUT	DX, AX	; set left dest bitmask MOV	count[EBP], 3 MOV	plane[EBP], 8 q13lloop: MOV	DX, 03CEH MOV	AH, BYTE count[EBP] MOV	AL, 4 OUT	DX, AX 		MOV	DX, 03C4H MOV	AH, plane[EBP] MOV	AL, 2 OUT	DX, AX 		MOV	CL, [ESI]	; fetch source MOV	AL, [EDI]	; latch at destiation MOV	[EDI], CL	; set source ; 		MOV	DX, 03CEH SHR	plane[EBP], 1 DEC	count[EBP] JGE	q13lloop	; next plane MOV	EBX, diff[EBP] ADD	start[EBP], 80 ADD	end[EBP], 80 MOV	ESI, start[EBP] MOV	EDI, end[EBP] DEC	help[EBP]	; dec linecounter JG	qCB13 JMP	resetgrafCB resetgrafCB: MOV	DX, 03CEH MOV	AX, 0FF08H	; default bitmask OUT	DX, AX 		MOV	AX, 0005	; default mode-reg OUT	DX, AX 		MOV	AX, 0003	; default Function-Select OUT	DX, AX 		MOV	AX, 0001	; default enable set/reset OUT	DX, AX 		MOV	DX, 03C4H MOV	AX, 0F02H	; default map mask OUT	DX, AX endCB: ret: END CopyBlock; PROCEDURE SetMode*(x: LONGINT; s: SET); BEGIN END SetMode; PROCEDURE CPTranslate(pat: LONGINT; cpX, cpY, cpW, cpH: INTEGER;  VAR buf: ARRAY OF INTEGER); VAR cpw, cph, cpsw: SHORTINT; CODE {SYSTEM.i386} MOV BX,cpW[EBP] ADD BX,7 SHR BX,3 MOV cpw[EBP],BL				 ; cpw := cpW DIV 8 MOV ESI,pat[EBP] XOR EAX,EAX MOV AL,[ESI] ADD AX,7 SHR AX,3 MOV cpsw[EBP],AL				 ; cpsw := p.w DIV 8 MOV EDI,buf[EBP] MOV AX,cpW[EBP] MOV [EDI],AL				 ; new p.w 		INC EDI MOV AX,cpH[EBP]				 ; new p.h 		MOV [EDI],AL INC EDI MOVSX BX,cpsw[EBP] MOV AX,cpY[EBP] IMUL AX,BX MOVSX EAX,AX ADD ESI,EAX MOV CX,cpX[EBP] SHR CX,3 MOVSX ECX,CX ADD ESI,ECX ADD ESI,2					; ESI := Sourcepos for Copyloop MOV cph[EBP],0					; init loop variables MOV DH, 0 MOV DL,cph[EBP] MOV CX,cpX[EBP] AND CX,7					 ; cpX MOD 8 loopcp: CMP cpH[EBP],DX JLE l7cp					 ; height reached ? MOV EAX,[ESI] SHR EAX,CL				 ; in proper position PUSH ECX MOV EBX,-2 MOV CX,cpW[EBP] SHL EBX,CL SHR EBX, 1 NOT EBX AND EAX,EBX POP ECX MOV [EDI],EAX				; copy for a new pattern MOVSX EAX,cpsw[EBP] ADD ESI,EAX				 ; one line in source up 		MOVSX EAX,cpw[EBP] ADD EDI,EAX				 ; one line at destination up 		INC DX 		JMP loopcp l7cp: END CPTranslate; PROCEDURE CP1(col: CHAR; dest, pat, X: LONGINT;  h: SHORTINT); CODE {SYSTEM.i386} MOV EDI, dest[EBP] MOV ESI, pat[EBP]	; patternaddress ADD ESI, 2 MOV ECX, X[EBP]	; X MOD 8 AND ECX, 7 MOV EDX, 03C4H	; AL = Plane select; AH = Bitplanemask; DX = Sequencer MOV AH, col[EBP] MOV AL, 2 OUT DX, AX 		LEA EAX, rev	; MOV EAX, reverse[EBP] MOV DL, h[EBP] XOR EBX, EBX cploop2: MOV BL, [ESI] INC ESI SHL BL, CL 		MOV BL, [EAX][EBX] MOV DH, [EDI]	; latch byte MOV [EDI], BL	; set pattern SUB EDI, width3	; w3[EBP] DEC DL 		JG cploop2 END CP1; PROCEDURE CP2(col: CHAR; dest, pat, X: LONGINT;  h: SHORTINT); CODE {SYSTEM.i386} MOV EDI, dest[EBP] MOV ESI, pat[EBP]	; patternaddress ADD ESI, 2 MOV ECX, X[EBP]	; X MOD 8 AND ECX, 7 MOV EDX, 03C4H	; AL = Plane select; AH = Bitplanemask; DX = Sequencer MOV AH, col[EBP] MOV AL, 2 OUT DX, AX 		LEA EAX, rev	; MOV EAX, reverse[EBP] cploop3: XOR EBX, EBX MOV BL, [ESI] INC ESI SHL BX, CL 		MOV DX, BX 		AND BX, 0FFH MOV DL, [EAX][EBX] MOV BL, DH 		MOV DH, [EAX][EBX] MOV BL, [EDI]	; latch byte MOV [EDI], DL	; set pattern MOV BL, 1[EDI]	; latch byte MOV 1[EDI], DH	; set pattern SUB EDI, width3 DEC h[EBP] JG cploop3 END CP2; PROCEDURE CP3(col: CHAR; dest, pat, X: LONGINT;  h: SHORTINT); CODE {SYSTEM.i386} MOV EDI, dest[EBP] MOV ESI, pat[EBP]	; patternaddress ADD ESI, 2 MOV ECX, X[EBP]	; X MOD 8 AND ECX, 7 MOV EDX, 03C4H	; AL = Plane select; AH = Bitplanemask; DX = Sequencer MOV AH, col[EBP] MOV AL, 2 OUT DX, AX 		LEA EAX, rev	; MOV EAX, reverse[EBP] cploop5: XOR EBX, EBX MOV BX, [ESI] ADD ESI, 2 SHL BX, CL 		MOV DX, BX 		AND BX, 0FFH MOV DL, [EAX][EBX] MOV BL, DH 		MOV DH, [EAX][EBX] MOV BL, [EDI]	; latch byte MOV [EDI], DL	; set pattern MOV BL, 1[EDI]	; latch byte MOV 1[EDI], DH	; set pattern SUB EDI, width3 DEC h[EBP] JG cploop5 END CP3; PROCEDURE CP4(col: CHAR; dest, pat, X: LONGINT;  h: SHORTINT); CODE {SYSTEM.i386} MOV EDI, dest[EBP] MOV ESI, pat[EBP]	; patternaddress ADD ESI, 2 MOV ECX, X[EBP]	; X MOD 8 AND ECX, 7 MOV EDX, 03C4H	; AL = Plane select; AH = Bitplanemask; DX = Sequencer MOV AH, col[EBP] MOV AL, 2 OUT DX, AX 		LEA EAX, rev	; MOV EAX, reverse[EBP] cploop7: XOR EBX, EBX MOV BX, [ESI] ADD ESI, 2 SHL EBX, CL 		MOV DX, BX 		SHR EBX, 16 AND BX, 0FFH MOV CH, [EAX][EBX] MOV BL, DL 		MOV DL, [EAX][EBX] MOV BL, DH 		MOV DH, [EAX][EBX] MOV BL, [EDI]	; latch byte MOV [EDI], DL	; set pattern MOV BL, 1[EDI]	; latch byte MOV 1[EDI], DH	; set pattern MOV BL, 2[EDI]	; latch byte MOV 2[EDI], CH	; set pattern SUB EDI, width3 DEC h[EBP] JG cploop7 END CP4; PROCEDURE CP5(col: CHAR; dest, pat, X: LONGINT;  h: SHORTINT); CODE {SYSTEM.i386} MOV EDI, dest[EBP] MOV ESI, pat[EBP]	; patternaddress ADD ESI, 2 MOV ECX, X[EBP]	; X MOD 8 AND ECX, 7 MOV EDX, 03C4H	; AL = Plane select; AH = Bitplanemask; DX = Sequencer MOV AH, col[EBP] MOV AL, 2 OUT DX, AX 		LEA EAX, rev	; MOV EAX, reverse[EBP] cploop9: MOV EBX, [ESI] ADD ESI, 3 AND EBX, 0FFFFFFH SHL EBX, CL 		PUSH ECX MOV DX, BX 		SHR EBX, 16 MOV CX, BX 		AND BX, 0FFH MOV CL, [EAX][EBX] MOV BL, CH 		MOV CH, [EAX][EBX] MOV BL, DL 		MOV DL, [EAX][EBX] MOV BL, DH 		MOV DH, [EAX][EBX] MOV BL, [EDI]	; latch byte MOV [EDI], DL	; set pattern MOV BL, 1[EDI]	; latch byte MOV 1[EDI], DH	; set pattern MOV BL, 2[EDI]	; latch byte MOV 2[EDI], CL	; set pattern MOV BL, 3[EDI]	; latch byte MOV 3[EDI], CH	; set pattern POP ECX SUB EDI, width3 DEC h[EBP] JG cploop9 END CP5; PROCEDURE CP6(col: CHAR; dest, pat, X: LONGINT;  h: SHORTINT); CODE {SYSTEM.i386} MOV EDI, dest[EBP] MOV ESI, pat[EBP]	; patternaddress ADD ESI, 2 MOV ECX, X[EBP]	; X MOD 8 AND ECX, 7 MOV EDX, 03C4H	; AL = Plane select; AH = Bitplanemask; DX = Sequencer MOV AH, col[EBP] MOV AL, 2 OUT DX, AX 		LEA EAX, rev	; MOV EAX, reverse[EBP] cploop11: MOV EBX, [ESI] ADD ESI, 4 PUSH ESI XOR ESI, ESI SHLD ESI, EBX, CL 		SHL EBX, CL 		PUSH ECX MOV DX, BX 		SHR EBX, 16 MOV CX, BX 		AND BX, 0FFH MOV CL, [EAX][EBX] MOV BL, CH 		MOV CH, [EAX][EBX] MOV BL, DL 		MOV DL, [EAX][EBX] MOV BL, DH 		MOV DH, [EAX][EBX] MOV BH, [EAX][ESI] MOV BL, [EDI]	; latch byte MOV [EDI], DL	; set pattern MOV BL, 1[EDI]	; latch byte MOV 1[EDI], DH	; set pattern MOV BL, 2[EDI]	; latch byte MOV 2[EDI], CL	; set pattern MOV BL, 3[EDI]	; latch byte MOV 3[EDI], CH	; set pattern MOV BL, 4[EDI]	; latch byte MOV 4[EDI], BH	; set pattern POP ECX POP ESI SUB EDI, width3 DEC h[EBP] JG cploop11 END CP6; PROCEDURE CP7(col: CHAR; dest, pat, X: LONGINT;  h: SHORTINT); CODE {SYSTEM.i386} MOV EDI, dest[EBP] MOV ESI, pat[EBP]	; patternaddress ADD ESI, 2 MOV ECX, X[EBP]	; X MOD 8 AND ECX, 7 MOV EDX, 03C4H	; AL = Plane select; AH = Bitplanemask; DX = Sequencer cploop1: MOV AX, 0F02H OUT DX, AX 		MOV EDX, 03CEH	; AL = Data/Rotate; AH = Modus; DX = Graphic-Controller MOV AX, 0803H OUT DX, AX 		XOR EBX, EBX MOV BL, [ESI] INC ESI SHL BL, CL 		LEA EDX, rev MOV BL, [EDX][EBX] MOV BH, [EDI]	; latch byte NOT BL 		MOV [EDI], BL	; clear pattern NOT BL 		MOV EDX, 03CEH	; AL = Data/Rotate; AH = Modus; DX = Graphic-Controller MOV AX, 1003H OUT DX, AX 		MOV EDX, 03C4H	; AL = Plane select; AH = Bitplanemask; DX = Sequencer MOV AL, 2 MOV AH, col[EBP] OUT DX, AX 		MOV BH, [EDI]	; latch byte MOV [EDI], BL	; set pattern SUB EDI, width3 DEC h[EBP] JG cploop1 END CP7; PROCEDURE CP8(col: CHAR; dest, pat, X: LONGINT;  h: SHORTINT); CODE {SYSTEM.i386} MOV EDI, dest[EBP] MOV ESI, pat[EBP]	; patternaddress ADD ESI, 2 MOV ECX, X[EBP]	; X MOD 8 AND ECX, 7 MOV EDX, 03C4H	; AL = Plane select; AH = Bitplanemask; DX = Sequencer cploop4: MOV AX, 0F02H OUT DX, AX 		MOV EDX, 03CEH	; AL = Data/Rotate; AH = Modus; DX = Graphic-Controller MOV AX, 0803H OUT DX, AX 		XOR EBX, EBX MOV BL, [ESI] INC ESI SHL BX, CL 		LEA EDX, rev MOV AX, BX 		AND BX, 0FFH MOV AL, [EDX][EBX] MOV BL, AH 		MOV AH, [EDX][EBX] NOT AX 		MOV BH, [EDI]	; latch byte MOV [EDI], AL	; clear pattern MOV BH, 1[EDI]	; latch byte MOV 1[EDI], AH	; clear pattern NOT AX 		MOV BX, AX 		MOV EDX, 03CEH	; AL = Data/Rotate; AH = Modus; DX = Graphic-Controller MOV AX, 1003H OUT DX, AX 		MOV EDX, 03C4H	; AL = Plane select; AH = Bitplanemask; DX = Sequencer MOV AL, 2 MOV AH, col[EBP] OUT DX, AX 		MOV CH, [EDI]	; latch byte MOV [EDI], BL	; set pattern MOV CH, 1[EDI]	; latch byte MOV 1[EDI], BH	; set pattern SUB EDI, width3 DEC h[EBP] JG cploop4 END CP8; PROCEDURE CP9(col: CHAR; dest, pat, X: LONGINT;  h: SHORTINT); CODE {SYSTEM.i386} MOV EDI, dest[EBP] MOV ESI, pat[EBP]	; patternaddress ADD ESI, 2 MOV ECX, X[EBP]	; X MOD 8 AND ECX, 7 MOV EDX, 03C4H	; AL = Plane select; AH = Bitplanemask; DX = Sequencer cploop6: MOV AX, 0F02H OUT DX, AX 		MOV EDX, 03CEH	; AL = Data/Rotate; AH = Modus; DX = Graphic-Controller MOV AX, 0803H OUT DX, AX 		XOR EBX, EBX MOV BX, [ESI] ADD ESI, 2 SHL BX, CL 		LEA EDX, rev MOV AX, BX 		AND BX, 0FFH MOV AL, [EDX][EBX] MOV BL, AH 		MOV AH, [EDX][EBX] NOT AX 		MOV BH, [EDI]	; latch byte MOV [EDI], AL	; clear pattern MOV BH, 1[EDI]	; latch byte MOV 1[EDI], AH	; clear pattern NOT AX 		MOV BX, AX 		MOV EDX, 03CEH	; AL = Data/Rotate; AH = Modus; DX = Graphic-Controller MOV AX, 1003H OUT DX, AX 		MOV EDX, 03C4H	; AL = Plane select; AH = Bitplanemask; DX = Sequencer MOV AL, 2 MOV AH, col[EBP] OUT DX, AX 		MOV CH, [EDI]	; latch byte MOV [EDI], BL	; set pattern MOV CH, 1[EDI]	; latch byte MOV 1[EDI], BH	; set pattern SUB EDI, width3 DEC h[EBP] JG cploop6 END CP9; PROCEDURE CP10(col: CHAR; dest, pat, X: LONGINT;  h: SHORTINT); CODE {SYSTEM.i386} MOV EDI, dest[EBP] MOV ESI, pat[EBP]	; patternaddress ADD ESI, 2 MOV ECX, X[EBP]	; X MOD 8 AND ECX, 7 cploop8: MOV EDX, 03C4H	; AL = Plane select; AH = Bitplanemask; DX = Sequencer MOV AX, 0F02H OUT DX, AX 		MOV EDX, 03CEH	; AL = Data/Rotate; AH = Modus; DX = Graphic-Controller MOV AX, 0803H OUT DX, AX 		XOR EBX, EBX MOV BX, [ESI] ADD ESI, 2 SHL EBX, CL 		LEA EDX, rev MOV AX, BX 		SHR EBX, 16 AND BX, 0FFH MOV CH, [EDX][EBX] MOV BL, AL 		MOV AL, [EDX][EBX] MOV BL, AH 		MOV AH, [EDX][EBX] NOT AX 		NOT CH 		MOV BH, [EDI]	; latch byte MOV [EDI], AL	; clear pattern MOV BH, 1[EDI]	; latch byte MOV 1[EDI], AH	; clear pattern MOV BH, 2[EDI]	; latch byte MOV 2[EDI], CH	; clear pattern NOT CH 		NOT AX 		MOV BX, AX 		MOV EDX, 03CEH	; AL = Data/Rotate; AH = Modus; DX = Graphic-Controller MOV AX, 1003H OUT DX, AX 		MOV EDX, 03C4H	; AL = Plane select; AH = Bitplanemask; DX = Sequencer MOV AL, 2 MOV AH, col[EBP] OUT DX, AX 		MOV DH, [EDI]	; latch byte MOV [EDI], BL	; set pattern MOV DH, 1[EDI]	; latch byte MOV 1[EDI], BH	; set pattern MOV DH, 2[EDI]	; latch byte MOV 2[EDI], CH	; set pattern SUB EDI, width3 DEC h[EBP] JG cploop8 END CP10; PROCEDURE CP11(col: CHAR; dest, pat, X: LONGINT;  h: SHORTINT); CODE {SYSTEM.i386} MOV EDI, dest[EBP] MOV ESI, pat[EBP]	; patternaddress ADD ESI, 2 MOV ECX, X[EBP]	; X MOD 8 AND ECX, 7 cploop10: MOV EDX, 03C4H	; AL = Plane select; AH = Bitplanemask; DX = Sequencer MOV AX, 0F02H OUT DX, AX 		MOV EDX, 03CEH	; AL = Data/Rotate; AH = Modus; DX = Graphic-Controller MOV AX, 0803H OUT DX, AX 		MOV EBX, [ESI] AND EBX, 0FFFFFFH ADD ESI, 3 SHL EBX, CL 		PUSH ECX LEA EDX, rev MOV AX, BX 		SHR EBX, 16 MOV CX, BX 		AND BX, 0FFH MOV CL, [EDX][EBX] MOV BL, CH 		MOV CH, [EDX][EBX] MOV BL, AL 		MOV AL, [EDX][EBX] MOV BL, AH 		MOV AH, [EDX][EBX] NOT AX 		NOT CX 		MOV BH, [EDI]	; latch byte MOV [EDI], AL	; clear pattern MOV BH, 1[EDI]	; latch byte MOV 1[EDI], AH	; clear pattern MOV BH, 2[EDI]	; latch byte MOV 2[EDI], CL	; clear pattern MOV BH, 3[EDI]	; latch byte MOV 3[EDI], CH	; clear pattern NOT CX 		NOT AX 		MOV BX, AX 		MOV EDX, 03CEH	; AL = Data/Rotate; AH = Modus; DX = Graphic-Controller MOV AX, 1003H OUT DX, AX 		MOV EDX, 03C4H	; AL = Plane select; AH = Bitplanemask; DX = Sequencer MOV AL, 2 MOV AH, col[EBP] OUT DX, AX 		MOV DH, [EDI]	; latch byte MOV [EDI], BL	; set pattern MOV DH, 1[EDI]	; latch byte MOV 1[EDI], BH	; set pattern MOV DH, 2[EDI]	; latch byte MOV 2[EDI], CL	; set pattern MOV DH, 3[EDI]	; latch byte MOV 3[EDI], CH	; set pattern POP ECX SUB EDI, width3 DEC h[EBP] JG cploop10 END CP11; PROCEDURE CP12(col: CHAR; dest, pat, X: LONGINT;  h: SHORTINT); CODE {SYSTEM.i386} MOV EDI, dest[EBP] MOV ESI, pat[EBP]	; patternaddress ADD ESI, 2 MOV ECX, X[EBP]	; X MOD 8 AND ECX, 7 cploop12: MOV EDX, 03C4H	; AL = Plane select; AH = Bitplanemask; DX = Sequencer MOV AX, 0F02H OUT DX, AX 		MOV EDX, 03CEH	; AL = Data/Rotate; AH = Modus; DX = Graphic-Controller MOV AX, 0803H OUT DX, AX 		MOV EBX, [ESI] ADD ESI, 4 PUSH ESI XOR ESI, ESI SHLD ESI, EBX, CL 		SHL EBX, CL 		PUSH ECX LEA EDX, rev MOV AX, BX 		SHR EBX, 16 MOV CX, BX 		AND BX, 0FFH MOV CL, [EDX][EBX] MOV BL, CH 		MOV CH, [EDX][EBX] MOV BL, AL 		MOV AL, [EDX][EBX] MOV BL, AH 		MOV AH, [EDX][EBX] MOV BL, [EDX][ESI] NOT AX 		NOT CX 		NOT BL 		MOV BH, [EDI]	; latch byte MOV [EDI], AL	; clear pattern MOV BH, 1[EDI]	; latch byte MOV 1[EDI], AH	; clear pattern MOV BH, 2[EDI]	; latch byte MOV 2[EDI], CL	; clear pattern MOV BH, 3[EDI]	; latch byte MOV 3[EDI], CH	; clear pattern MOV BH, 4[EDI]	; latch byte MOV 4[EDI], BL	; clear pattern NOT BL 		NOT CX 		NOT AX 		MOV DX, BX 		MOV BX, AX 		PUSH EDX MOV EDX, 03CEH	; AL = Data/Rotate; AH = Modus; DX = Graphic-Controller MOV AX, 1003H OUT DX, AX 		MOV EDX, 03C4H	; AL = Plane select; AH = Bitplanemask; DX = Sequencer MOV AL, 2 MOV AH, col[EBP] OUT DX, AX 		POP EDX MOV DH, [EDI]	; latch byte MOV [EDI], BL	; set pattern MOV DH, 1[EDI]	; latch byte MOV 1[EDI], BH	; set pattern MOV DH, 2[EDI]	; latch byte MOV 2[EDI], CL	; set pattern MOV DH, 3[EDI]	; latch byte MOV 3[EDI], CH	; set pattern MOV DH, 4[EDI]	; latch byte MOV 4[EDI], DL	; set pattern POP ECX POP ESI SUB EDI, width3 DEC h[EBP] JG cploop12 END CP12; PROCEDURE CopyPattern*(col: Color; pat: Pattern; x, y, mode: LONGINT); VAR dest, i, diff: LONGINT; w, h: SHORTINT; x1, y1, cpX, cpY, cpW, cpH, nofbytes: INTEGER; buf: ARRAY 256 OF INTEGER; lm, rm: CHAR; BEGIN SYSTEM.GET(pat, w); SYSTEM.GET(pat+1, h); cpW := SHORT(w + x); cpH := SHORT(h + y); x1 := SHORT(x); y1 := SHORT(y); IF x1 < clipx THEN x := clipx END; IF y1 < clipy THEN y := clipy END; IF cpW > clipright THEN cpW :=  clipright END; IF cpH > cliptop THEN cpH := cliptop END; cpW := cpW - SHORT(x); cpH := cpH - SHORT(y); cpX := SHORT(x) - x1; cpY := SHORT(y) - y1; IF (cpW <= 0) OR (cpH <= 0) OR (cpX < 0) OR (cpY < 0) THEN RETURN END; IF (cpW # w) OR (cpH # h) THEN CPTranslate(pat, cpX, cpY, cpW, cpH, buf); pat := SYSTEM.ADR(buf[0]) END; SYSTEM.GET(pat, w); SYSTEM.GET(pat+1, h); dest := ((Height-SHORT(y)-1) * width3 + SHORT(x) DIV 8) MOD 10000H; INC(dest, 0A0000H);	(* display offset *) (*help1 := (SHORT(x) + w-1) MOD 8;*) diff := (SHORT(x) + w-1) DIV 8 - (SHORT(x) DIV 8); SYSTEM.PORTOUT(03CEH, SYSTEM.VAL(INTEGER, 0FF08H));	(* AX = Default bitmask; DX = Graphic-Controller *) SYSTEM.PORTOUT(03CEH, SYSTEM.VAL(INTEGER, 5));	(* AL = Graphics mode; AH = Read-Mode = 0/Write-Mode = 0 (bits 0,1) *) IF mode = invert THEN SYSTEM.PORTOUT(03CEH, SYSTEM.VAL(INTEGER, 1803H));	(* AX = invert mode; DX = Graphic-Controller *) IF w <= 8 THEN IF diff = 0 THEN CP1(CHR(col), dest, pat, SHORT(x), h) 				ELSE CP2(CHR(col), dest, pat, SHORT(x), h) 				END ELSIF w <= 16 THEN IF diff = 1 THEN CP3(CHR(col), dest, pat, SHORT(x), h) 				ELSE CP4(CHR(col), dest, pat, SHORT(x), h) 				END ELSIF w <= 24 THEN CP5(CHR(col), dest, pat, SHORT(x), h) 			ELSE CP6(CHR(col), dest, pat, SHORT(x), h) 			END ELSE (* paint & replace *) IF w <= 8 THEN IF diff = 0 THEN CP7(CHR(col), dest, pat, SHORT(x), h) 				ELSE CP8(CHR(col), dest, pat, SHORT(x), h) 				END ELSIF w <= 16 THEN IF diff = 1 THEN CP9(CHR(col), dest, pat, SHORT(x), h) 				ELSE CP10(CHR(col), dest, pat, SHORT(x), h) 				END ELSIF w <= 24 THEN CP11(CHR(col), dest, pat, SHORT(x), h) 			ELSE CP12(CHR(col), dest, pat, SHORT(x), h) 			END END END CopyPattern; PROCEDURE ReplConst1(col: CHAR; H, start: LONGINT;  rm, lm: CHAR); CODE {SYSTEM.i386} MOV AH, lm[EBP] AND AH, rm[EBP] MOV AL, 8 MOV EDX, 03CEH OUT DX, AX	; Bitmask MOV AH, col[EBP] MOV ECX, H[EBP] MOV ESI, start[EBP] rcloop1: MOV AL, [ESI]	; latch bytes MOV [ESI], AH 		SUB ESI, width3	;w3[EBP] LOOP rcloop1 END ReplConst1; PROCEDURE ReplConst2(col: CHAR; H: INTEGER;  start, end: LONGINT;  rm, lm: CHAR); VAR temp: LONGINT; CODE {SYSTEM.i386} MOV ESI, start[EBP] MOV BH, col[EBP] MOV EDI, end[EBP] SUB EDI, ESI	; difference beween start and end MOV temp[EBP], EDI	; save difference beween start and end MOV EDX, 03CEH		; set Graphic controller rcloop2: MOV AH, lm[EBP]	; prepare left mask MOV AL, 8 OUT DX, AX	; set left Bitmask MOV AL, [ESI]	; latch byte MOV [ESI], BH	; set byte MOV AX, 0FF08H	; prepare full mask OUT DX, AX	; set full mask MOV ECX,ESI INC ECX rclabel2: CMP EDI, 1 JLE rclabel1 MOV AL, [ECX]	; latch bytes MOV [ECX], BH	; set bytes DEC EDI INC ECX JMP rclabel2 rclabel1: MOV AH, rm[EBP]	; prepare right mask MOV AL, 8 OUT DX, AX	; set right Bitmask MOV AL, [ECX]	; latch byte MOV [ECX], BH	; set byte SUB ESI, width3;	w3[EBP]	; next line DEC H[EBP] MOV EDI, temp[EBP] JG rcloop2 END ReplConst2; PROCEDURE ReplConst*(col: Color; x, y, w, h, mode: LONGINT); VAR right, top, X, Y, W, H: INTEGER; addr, start, end: LONGINT; rm, lm: CHAR; BEGIN X := SHORT(x); Y := SHORT(y);  W := SHORT(w);  H := SHORT(h); top := Y + H; right := X + W; 		IF X < clipx THEN X := clipx END; IF Y < clipy THEN Y := clipy END; IF clipright < right THEN right :=  clipright END; IF cliptop < top THEN top := cliptop END; W := right - X; H := top - Y; 		IF (W <= 0) OR (H <= 0) OR (X < 0) OR (Y < 0) THEN RETURN END; IF mode = invert THEN SYSTEM.PORTOUT(03CEH, SYSTEM.VAL(INTEGER, 1803H))	(* AL = Data/Rotate; AH = Modus; DX = Graphic-Controller *) ELSE	(* was replace only *) SYSTEM.PORTOUT(03CEH, SYSTEM.VAL(INTEGER, 03H)) (*ELSE (* mode = paint *) SYSTEM.PORTOUT(03CEH, SYSTEM.VAL(INTEGER, 1003H))*) END; SYSTEM.PORTOUT(03CEH, 205H);	(* AL = Gaphics mode; AH = Read-Mode = 0/Write-Mode = 2 (bits 0,1) *) SYSTEM.PORTOUT(03C4H, 0F02H);	(* AL = Plane select; AH = Bitplanemask; DX = Sequencer *) addr := ((Height - Y - 1) * width3) MOD 10000H; INC(addr, 0A0000H); start := addr + X DIV 8; end := addr + (X + W) DIV 8; lm := imask[X MOD 8]; rm := mask[(X + W) MOD 8]; IF start = end THEN ReplConst1(CHR(col), H, start, rm, lm) ELSE ReplConst2(CHR(col), H, start, end, rm, lm) END; END ReplConst; PROCEDURE FillPattern1(col: CHAR; pat: Pattern; pX, pY, X, Y, W, H, mode: LONGINT); VAR leftmask, rightmask, flag, color, help3: CHAR; topleft, help, help1, help2: LONGINT; CODE {SYSTEM.i386} MOV	EAX, mode[EBP]	; get mode and set local AH 		CMP	AX, 0 JNE	Inv4 MOV	AH, 0 JMP	setGC4 Inv4: CMP	AX, 2 JNE	Paint4 MOV	AH, 18H JMP	setGC4 Paint4: MOV	AH, 10H	; with wrong mode => ;		; automatically paint mode ; Set graphic-controller-registers setGC4: MOV	DX, 03CEH	; Graphic-Controller MOV	AL, 3	; AL = Data/Rotate / AH = Modus OUT	DX, AX 		MOV	AX, 0005H	; AL = Read-Mode = 0 ;		; Write-Mode = 0 (bits 0, 1) OUT	DX, AX	; Set ; Get params x, y getxy4: MOVSX EBX, height DEC EBX	; MOV	EBX, hgt[EBP] SUB	EBX, Y[EBP]	; (0, 0) in bottom left corner MOV	EAX, Y[EBP] MOV	Y[EBP], EBX	; y:= height -1 - y 		XOR	EDX, EDX SUB	EAX, pY[EBP] MOV	ECX, pat[EBP] MOVSX	ECX, BYTE 1[ECX] IDIV	EAX,ECX MOV	help2[EBP], EDX MOV	EBX, X[EBP]	; EBX := x 		MOV	ECX, EBX MOV	EDX, EBX MOV	ESI, EBX SHR	EBX, 3	; EBX := X DIV 8 ADD	EDX, W[EBP]	; EDX := x + w 		DEC	EDX SHR	EDX, 3	; EDX := (x + w-1) DIV 8 AND	ECX, 7	; ECX := x mod 8 ADD	ESI, W[EBP] DEC	ESI AND	ESI, 7	; ESI := (x+w-1) MOD 8 LEA EDI, imask	; MOV	EDI, imsk[EBP] MOV	AL, [EDI][ECX] ;		MOV	AL, imask[ECX] MOV	leftmask[EBP], AL 		INC	ESI	; *$* LEA EDI, mask	; MOV	EDI, msk[EBP] MOV	AL, [EDI][ESI] ;		MOV	AL, mask[ESI] MOV	rightmask[EBP], AL 		MOV	EDI, width3	; w3[EBP] IMUL	EDI, Y[EBP] AND EDI, 0FFFFH ADD	EDI,0A0000H ADD	EDI, EBX	; EDI := START-Adr SUB	EDX, EBX	; Diff in bytes MOV	help[EBP], EDX MOV	help1[EBP], EDI MOV	EBX, H[EBP] IMUL	EBX, width3	; w3[EBP] SUB	EDI, EBX MOV	topleft[EBP], EDI MOV	EDI, help1[EBP] MOV	ESI, pat[EBP]	; get addr of pat MOV	EAX, X[EBP]	; EAX := x 		XOR	EDX, EDX MOVSX	EBX, BYTE [ESI] IDIV	EAX,EBX MOV	help3[EBP], DL	;help3 := x MOD p.w 		MOV	DX, 03CEH MOV	AH, leftmask[EBP] MOV	AL, 8 OUT	DX, AX 		MOV	DX, 03C4H MOV	AH, col[EBP] MOV	AL, 2 OUT	DX, AX 		MOV	EBX, help2[EBP] MOV	flag[EBP], 0 MOV	EDX, help[EBP] CMP	EDX, 0	; in one byte ? JE	onebyte CMP	BYTE [ESI], 16	; width = 16 ? JNE	RP32 RP16: CMP	mode[EBP], 0	; replacemode ? JE	R16 CMP	mode[EBP], 1	; paintmode ? JE	P16left IP16left: MOV	AX, 2[ESI][EBX*2]	; invert/paint p.w = 16 CMP	help3[EBP], 8 JGE	label ROR	AX, 8 label: MOV	CL, BYTE pX[EBP] ROL	AX, CL 		XOR	EDX, EDX PUSH EBX LEA EBX, rev	; MOV EBX, reverse[EBP] MOV	DL, AL 		MOV	AL, [EBX][EDX] ;		MOV	AL, rev[EDX] MOV	DL, AH 		MOV	AH, [EBX][EDX] ;		MOV	AH, rev[EDX] POP EBX MOV	CH, [EDI]	; latch MOV	[EDI], AH 		ROL	AX, 8 MOV	EDX, 1 CMP	EDX, help[EBP] JE	IP16right MOV	help2[EBP], EAX MOV	DX, 03CEH MOV	AX, 0FF08H OUT	DX, AX 		MOV	EAX, help2[EBP] MOV	EDX, 1 IP16mid: MOV	CH, [EDI][EDX]	; latch MOV	[EDI][EDX], AH 		ROL	AX, 8 INC	EDX CMP	EDX, help[EBP] JL	IP16mid IP16right: MOV	help1[EBP], EDX MOV	help2[EBP], EAX MOV	DX, 03CEH MOV	AH, rightmask[EBP] MOV	AL, 8 OUT	DX, AX 		MOV	EAX, help2[EBP] MOV	EDX, help1[EBP] MOV	CH, [EDI][EDX] MOV	[EDI][EDX], AH 		SUB	EDI, width3	; w3[EBP] CMP	EDI, topleft[EBP] JLE	resetgrafRP MOV	DX, 03CEH MOV	AH, leftmask[EBP]	; prepare rightmask again MOV	AL, 8 OUT	DX, AX 		XOR	EDX, EDX INC	EBX CMP	BL, 1[ESI]	; height of pattern reached? JNE	IP16left XOR	EBX, EBX	; yes, then reset counter JMP	IP16left P16left: MOV	AX, 2[ESI][EBX*2]	; invert/paint p.w = 16 CMP	help3[EBP], 8 JGE	plabel ROR	AX, 8 plabel: MOV	CL, BYTE pX[EBP] ROL	AX, CL 		XOR	EDX, EDX MOV	DL, AL 		PUSH EBX LEA EBX, rev	; MOV EBX, reverse[EBP] MOV	AL, [EBX][EDX] ;		MOV	AL, rev[EDX] MOV	DL, AH 		MOV	AH, [EBX][EDX] ;		MOV	AH, rev[EDX] POP EBX MOV	CH, [EDI]	; latch PUSH	EDX PUSH	EAX MOV	DX, 03C4H MOV	AX, 0F02H	; set all planes OUT	DX, AX	; set color/sequencer planemap MOV	AH, 8	; set mode to AND MOV	AL, 3 MOV	DX, 03CEH OUT	DX, AX 		POP	EAX NOT	AH	; negate AH 		MOV	[EDI], AH	; clear pattern NOT	AH	; negate AH 		PUSH	EAX MOV	AH, 10H	; set mode to OR 		MOV	AL, 3 MOV	DX, 03CEH OUT	DX, AX 		MOV	AH, col[EBP]	; get color and set bitplanes MOV	AL, 2 MOV	DX, 03C4H OUT	DX, AX 		POP	EAX POP	EDX MOV	[EDI], AH 		ROL	AX, 8 MOV	EDX, 1 CMP	EDX, help[EBP] JE	P16right MOV	help2[EBP], EAX MOV	DX, 03CEH MOV	AX, 0FF08H OUT	DX, AX 		MOV	EAX, help2[EBP] MOV	EDX, 1 P16mid: MOV	CH, [EDI][EDX]	; latch PUSH	EDX PUSH	EAX MOV	DX, 03C4H MOV	AX, 0F02H	; set all planes OUT	DX, AX	; set color/sequencer planemap MOV	AH, 8	; set mode to AND MOV	AL, 3 MOV	DX, 03CEH OUT	DX, AX 		POP	EAX POP	EDX NOT	AH	; negate AH 		MOV	[EDI][EDX], AH	; clear pattern NOT	AH	; negate AH 		PUSH	EDX PUSH	EAX MOV	AH, 10H	; set mode to OR 		MOV	AL, 3 MOV	DX, 03CEH OUT	DX, AX 		MOV	AH, col[EBP]	; get color and set bitplanes MOV	AL, 2 MOV	DX, 03C4H OUT	DX, AX 		POP	EAX POP	EDX MOV	[EDI][EDX], AH 		ROL	AX, 8 INC	EDX CMP	EDX, help[EBP] JL	P16mid P16right: MOV	help1[EBP], EDX MOV	help2[EBP], EAX MOV	DX, 03CEH MOV	AH, rightmask[EBP] MOV	AL, 8 OUT	DX, AX 		MOV	EAX, help2[EBP] MOV	EDX, help1[EBP] MOV	CH, [EDI][EDX] PUSH	EDX PUSH	EAX MOV	DX, 03C4H MOV	AX, 0F02H	; set all planes OUT	DX, AX	; set color/sequencer planemap MOV	AH, 8	; set mode to AND MOV	AL, 3 MOV	DX, 03CEH OUT	DX, AX 		POP	EAX POP	EDX NOT	AH	; negate AH 		MOV	[EDI][EDX], AH	; clear pattern NOT	AH	; negate AH 		PUSH	EDX PUSH	EAX MOV	AH, 10H	; set mode to OR 		MOV	AL, 3 MOV	DX, 03CEH OUT	DX, AX 		MOV	AH, col[EBP]	; get color and set bitplanes MOV	AL, 2 MOV	DX, 03C4H OUT	DX, AX 		POP	EAX POP	EDX MOV	[EDI][EDX], AH 		SUB	EDI, width3	; w3[EBP] CMP	EDI, topleft[EBP] JLE	resetgrafRP MOV	DX, 03CEH MOV	AH, leftmask[EBP]	; prepare rightmask again MOV	AL, 8 OUT	DX, AX 		XOR	EDX, EDX INC	EBX CMP	BL, 1[ESI]	; height of pattern reached? JNE	P16left XOR	EBX, EBX	; yes, then reset counter JMP	P16left R16: MOV	AH, col[EBP] MOV	color[EBP], AH R16left: MOV	AX, 2[ESI][EBX*2]	; replace p.w = 16 CMP	help3[EBP], 8 JGE	label1 ROR	AX, 8 label1: MOV	CL, BYTE pX[EBP] ROL	AX, CL 		XOR	DX, DX 		MOV	DL, AL 		PUSH EBX LEA EBX, rev	; MOV EBX, reverse[EBP] MOV	AL, [EBX][EDX] ;		MOV	AL, rev[EDX] MOV	DL, AH ;		MOV	AH, rev[EDX] MOV	AH, [EBX][EDX] POP EBX MOV	help2[EBP], EAX MOV	DX, 03C4H MOV	AX, 0F02H OUT	DX, AX 		MOV	CH, [EDI]	; latch MOV	BYTE [EDI], 0 MOV	AH, color[EBP] MOV	AL, 2 OUT	DX, AX	; set color MOV	EAX, help2[EBP] MOV	[EDI], AH 		ROL	AX, 8 MOV	EDX, 1 CMP	EDX, help[EBP] JE	R16right MOV	help2[EBP], EAX MOV	DX, 03CEH MOV	AX, 0FF08H OUT	DX, AX 		MOV	EDX, 1 MOV	EAX, help2[EBP] R16mid: MOV	help1[EBP], EDX MOV	help2[EBP], EAX MOV	DX, 03C4H MOV	AX, 0F02H OUT	DX, AX 		XCHG	help1[EBP], EDX MOV	BYTE [EDI][EDX], 0 XCHG	help1[EBP], EDX MOV	AH, color[EBP] MOV	AL, 2 OUT	DX, AX	; set color XCHG	help1[EBP], EDX XCHG	help2[EBP], EAX MOV	[EDI][EDX], AH 		ROL	AX, 8 INC	EDX CMP	EDX, help[EBP] JL	R16mid R16right: MOV	help1[EBP], EDX MOV	help2[EBP], EAX MOV	DX, 03CEH MOV	AH, rightmask[EBP] MOV	AL, 8 OUT	DX, AX 		MOV	DX, 03C4H MOV	AX, 0F02H OUT	DX, AX 		XCHG	help1[EBP], EDX MOV	CH, [EDI][EDX]	; latch MOV	BYTE [EDI][EDX], 0 XCHG	help1[EBP], EDX MOV	AH, color[EBP] MOV	AL, 2 OUT	DX, AX	; set color MOV	EAX, help2[EBP] MOV	EDX, help1[EBP] MOV	[EDI][EDX], AH 		SUB	EDI, width3	; w3[EBP] CMP	EDI, topleft[EBP] JLE	resetgrafRP MOV	DX, 03CEH MOV	AH, leftmask[EBP]	; prepare rightmask again MOV	AL, 8 OUT	DX, AX 		XOR	EDX, EDX INC	EBX CMP	BL, 1[ESI]	; height of pattern reached? JNE	R16left XOR	EBX, EBX	; yes, then reset counter JMP	R16left onebyte: CMP	BYTE [ESI], 16	; width = 16 ? SETE	flag[EBP]	; flag = 1 if p.w=16 CMP	mode[EBP], 0	; replace ? JE	onebyteR CMP	mode[EBP], 1	; paint ? JE	onebyteP IPonebyte: CMP	flag[EBP], 1 JNE	p32 MOV	AX, 2[ESI][EBX*2]	; p.w = 16 CMP	help3[EBP], 8 JGE	label2 ROR	AX, 8 label2: MOV	CL, BYTE pX[EBP] ROL	AX, CL 		JMP	down p32: MOV	EAX, 2[ESI][EBX*4]	; p.w = 32 CMP	help3[EBP], 24 JL	labela ROR	EAX, 24 JMP	labelc labela: CMP	help3[EBP], 16 JL	labelb ROR	EAX, 16 JMP	labelc labelb: CMP	help3[EBP], 8 JL	labelc ROR	EAX, 8 labelc: MOV	CL, BYTE pX[EBP] ROL	EAX, CL down: XOR	DX, DX 		MOV	DL, AL 		PUSH EBX LEA EBX, rev	; MOV EBX, reverse[EBP] MOV	DL, [EBX][EDX] ;		MOV	DL, rev[EDX] POP EBX AND	AL, rightmask[EBP] MOV	CH, [EDI]	; latch MOV	[EDI], AL 		SUB	EDI, width3	; w3[EBP] CMP	EDI, topleft[EBP] JLE	resetgrafRP INC	EBX CMP	BL, 1[ESI] JNE	IPonebyte XOR	EBX, EBX JMP	IPonebyte onebyteP: CMP	flag[EBP], 1 JNE	pp32 MOV	AX, 2[ESI][EBX*2]	; p.w = 16 CMP	help3[EBP], 8 JGE	plabel2 ROR	AX, 8 plabel2: MOV	CL, BYTE pX[EBP] ROL	AX, CL 		JMP	pdown pp32: MOV	EAX, 2[ESI][EBX*4]	; p.w = 32 CMP	help3[EBP], 24 JL	plabela ROR	EAX, 24 JMP	plabelc plabela: CMP	help3[EBP], 16 JL	plabelb ROR	EAX, 16 JMP	plabelc plabelb: CMP	help3[EBP], 8 JL	plabelc ROR	EAX, 8 plabelc: MOV	CL, BYTE pX[EBP] ROL	EAX, CL pdown: XOR	DX, DX 		MOV	DL, AL 		PUSH EBX LEA EBX, rev	; MOV EBX, reverse[EBP] MOV	DL, [EBX][EDX] ;		MOV	DL, rev[EDX] POP EBX AND	AL, rightmask[EBP] MOV	CH, [EDI]	; latch PUSH	EDX PUSH	EAX MOV	DX, 03C4H MOV	AX, 0F02H	; set all planes OUT	DX, AX	; set color/sequencer planemap MOV	AH, 8	; set mode to AND MOV	AL, 3 MOV	DX, 03CEH OUT	DX, AX 		POP	EAX NOT	AL	; negate AL 		MOV	[EDI], AL	; clear pattern NOT	AL	; negate AL 		PUSH	EAX MOV	AH, 10H	; set mode to OR 		MOV	AL, 3 MOV	DX, 03CEH OUT	DX, AX 		MOV	AH, col[EBP]	; get color and set bitplanes MOV	AL, 2 MOV	DX, 03C4H OUT	DX, AX 		POP	EAX POP	EDX MOV	[EDI], AL 		SUB	EDI, width3	; w3[EBP] CMP	EDI, topleft[EBP] JLE	resetgrafRP INC	EBX CMP	BL, 1[ESI] JNE	onebyteP XOR	EBX, EBX JMP	onebyteP onebyteR: MOV	AH, col[EBP]	; replace in 1 byte MOV	color[EBP], AH Ronebyte: CMP	flag[EBP], 1 JNE	p32r MOV	AX, 2[ESI][EBX*2]	; p.w = 16 CMP	help3[EBP], 8 JGE	label3 ROR	AX, 8 label3: MOV	CL, BYTE pX[EBP] ROL	AX, CL 		JMP	downr p32r: MOV	EAX, 2[ESI][EBX*4]	; p.w = 32 CMP	help3[EBP], 24 JL	labelc1 ROR	EAX, 24 JMP	labelc1 labela1: CMP	help3[EBP], 16 JL	labelb1 ROR	EAX, 16 JMP	labelc1 labelb1: CMP	help3[EBP], 8 JL	labelc1 ROR	EAX, 8 labelc1: MOV	CL, BYTE pX[EBP] ROL	EAX, CL downr: XOR	EDX, EDX MOV	DL, AL 		PUSH EBX LEA EBX, rev	; MOV EBX, reverse[EBP] MOV	AL, [EBX][EDX] ;		MOV	AL, rev[EDX] POP EBX MOV	help1[EBP], EAX MOV	AH, leftmask[EBP] AND	AH, rightmask[EBP] MOV	DX, 03CEH MOV	AL, 8 OUT	DX, AX 		MOV	DX, 03C4H MOV	AX, 0F02H OUT	DX, AX 		MOV	CH, [EDI]	; latch MOV	BYTE [EDI], 0 MOV	AH, color[EBP] MOV	AL, 2 OUT	DX, AX	; set color MOV	EAX, help1[EBP] MOV	[EDI], AL 		SUB	EDI, width3	; w3[EBP] CMP	EDI, topleft[EBP] JLE	resetgrafRP INC	EBX CMP	BL, 1[ESI] JNE	Ronebyte XOR	EBX, EBX JMP	Ronebyte RP32: CMP	BYTE [ESI], 32	; p.w = 32 ? JNE	endRP	; only p.w = 16 OR 32 allowed CMP	mode[EBP], 0 JE	R32 CMP	mode[EBP], 1 JE	P32left IP32left: MOV	EAX, 2[ESI][EBX*4]	;invert/paint p.w = 32 CMP	help3[EBP], 24 JL	labela2 ROR	EAX, 24 JMP	labelc2 labela2: CMP	help3[EBP], 16 JL	labelb2 ROR	EAX, 16 JMP	labelc2 labelb2: CMP	help3[EBP], 8 JL	labelc2 ROR	EAX, 8 labelc2: MOV	CL, BYTE pX[EBP] ROL	EAX, CL 		XOR	EDX, EDX PUSH	ECX MOV	CX, 4 iloop: MOV	DL, AL 		PUSH EBX LEA EBX, rev	; MOV EBX, reverse[EBP] MOV	AL, [EBX][EDX] ;		MOV	AL, rev[EDX] POP EBX ROR	EAX, 8 LOOP	iloop POP	ECX MOV	CH, [EDI]	; latch MOV	[EDI], AL 		ROR	EAX, 8 MOV	EDX, 1 CMP	EDX, help[EBP] JE	IP32right MOV	help2[EBP], EAX MOV	DX, 03CEH MOV	AX, 0FF08H OUT	DX, AX 		MOV	EAX, help2[EBP] MOV	EDX, 1 IP32mid: MOV	CH, [EDI][EDX]	; latch MOV	[EDI][EDX], AL 		ROR	EAX, 8 INC	EDX CMP	EDX, help[EBP] JL	IP32mid IP32right: MOV	help2[EBP], EAX MOV	help1[EBP], EDX MOV	DX, 03CEH MOV	AH, rightmask[EBP] MOV	AL, 8 OUT	DX, AX 		MOV	EAX, help2[EBP] MOV	EDX, help1[EBP] MOV	CH, [EDI][EDX] MOV	[EDI][EDX], AL 		SUB	EDI, width3	; w3[EBP] CMP	EDI, topleft[EBP] JLE	resetgrafRP MOV	DX, 03CEH MOV	AH, leftmask[EBP]	; prepare leftmask again MOV	AL, 8 OUT	DX, AX 		XOR	EDX, EDX INC	EBX CMP	BL, 1[ESI]	; height of pattern reached? JNE	IP32left XOR	EBX, EBX	; yes, then reset counter JMP	IP32left P32left: MOV	EAX, 2[ESI][EBX*4]	;invert/paint p.w = 32 CMP	help3[EBP], 24 JL	plabela2 ROR	EAX, 24 JMP	plabelc2 plabela2: CMP	help3[EBP], 16 JL	plabelb2 ROR	EAX, 16 JMP	plabelc2 plabelb2: CMP	help3[EBP], 8 JL	plabelc2 ROR	EAX, 8 plabelc2: MOV	CL, BYTE pX[EBP] ROL	EAX, CL 		XOR	EDX, EDX PUSH	ECX MOV	CX, 4 piloop: MOV	DL, AL 		PUSH EBX LEA EBX, rev	; MOV EBX, reverse[EBP] MOV	AL, [EBX][EDX] ;		MOV	AL, rev[EDX] POP EBX ROR	EAX, 8 LOOP	piloop POP	ECX MOV	CH, [EDI]	; latch PUSH	EDX PUSH	EAX MOV	DX, 03C4H MOV	AX, 0F02H	; set all planes OUT	DX, AX	; set color/sequencer planemap MOV	AH, 8	; set mode to AND MOV	AL, 3 MOV	DX, 03CEH OUT	DX, AX 		POP	EAX NOT	AL	; negate AL 		MOV	[EDI], AL	; clear pattern NOT	AL	; negate AL 		PUSH	EAX MOV	AH, 10H	; set mode to OR 		MOV	AL, 3 MOV	DX, 03CEH OUT	DX, AX 		MOV	AH, col[EBP]	; get color and set bitplanes MOV	AL, 2 MOV	DX, 03C4H OUT	DX, AX 		POP	EAX POP	EDX MOV	[EDI], AL 		ROR	EAX, 8 MOV	EDX, 1 CMP	EDX, help[EBP] JE	P32right MOV	help2[EBP], EAX MOV	DX, 03CEH MOV	AX, 0FF08H OUT	DX, AX 		MOV	EAX, help2[EBP] MOV	EDX, 1 P32mid: MOV	CH, [EDI][EDX]	; latch PUSH	EDX PUSH	EAX MOV	DX, 03C4H MOV	AX, 0F02H	; set all planes OUT	DX, AX	; set color/sequencer planemap MOV	AH, 8	; set mode to AND MOV	AL, 3 MOV	DX, 03CEH OUT	DX, AX 		POP	EAX POP	EDX NOT	AL	; negate AL 		MOV	[EDI][EDX], AL	; clear pattern NOT	AL	; negate AL 		PUSH	EDX PUSH	EAX MOV	AH, 10H	; set mode to OR 		MOV	AL, 3 MOV	DX, 03CEH OUT	DX, AX 		MOV	AH, col[EBP]	; get color and set bitplanes MOV	AL, 2 MOV	DX, 03C4H OUT	DX, AX 		POP	EAX POP	EDX MOV	[EDI][EDX], AL 		ROR	EAX, 8 INC	EDX CMP	EDX, help[EBP] JL	P32mid P32right: MOV	help2[EBP], EAX MOV	help1[EBP], EDX MOV	DX, 03CEH MOV	AH, rightmask[EBP] MOV	AL, 8 OUT	DX, AX 		MOV	EAX, help2[EBP] MOV	EDX, help1[EBP] MOV	CH, [EDI][EDX] PUSH	EDX PUSH	EAX MOV	DX, 03C4H MOV	AX, 0F02H	; set all planes OUT	DX, AX	; set color/sequencer planemap MOV	AH, 8	; set mode to AND MOV	AL, 3 MOV	DX, 03CEH OUT	DX, AX 		POP	EAX POP	EDX NOT	AL	; negate AL 		MOV	[EDI][EDX], AL	; clear pattern NOT	AL	; negate AL 		PUSH	EDX PUSH	EAX MOV	AH, 10H	; set mode to OR 		MOV	AL, 3 MOV	DX, 03CEH OUT	DX, AX 		MOV	AH, col[EBP]	; get color and set bitplanes MOV	AL, 2 MOV	DX, 03C4H OUT	DX, AX 		POP	EAX POP	EDX MOV	[EDI][EDX], AL 		SUB	EDI, width3	; w3[EBP] CMP	EDI, topleft[EBP] JLE	resetgrafRP MOV	DX, 03CEH MOV	AH, leftmask[EBP]	; prepare leftmask again MOV	AL, 8 OUT	DX, AX 		XOR	EDX, EDX INC	EBX CMP	BL, 1[ESI]	; height of pattern reached? JNE	IP32left XOR	EBX, EBX	; yes, then reset counter JMP	P32left R32: MOV	AH, col[EBP] MOV	color[EBP], AH R32left: MOV	EAX, 2[ESI][EBX*4]	; replace p.w = 32 CMP	help3[EBP], 24 JL	labela3 ROR	EAX, 24 JMP	labelc3 labela3: CMP	help3[EBP], 16 JL	labelb3 ROR	EAX, 16 JMP	labelc3 labelb3: CMP	help3[EBP], 8 JL	labelc3 ROR	EAX, 8 labelc3: MOV	CL, BYTE pX[EBP] ROL	EAX, CL 		XOR	EDX, EDX PUSH	ECX MOV	CX, 4 i2loop: MOV	DL, AL 		PUSH EBX LEA EBX, rev	; MOV EBX, reverse[EBP] MOV	AL, [EBX][EDX] ;		MOV	AL, rev[EDX] POP EBX ROR	EAX, 8 LOOP	i2loop POP	ECX MOV	help2[EBP], EAX MOV	DX, 03C4H MOV	AX, 0F02H OUT	DX, AX 		MOV	CH, [EDI]	; latch MOV	BYTE [EDI], 0 MOV	AH, color[EBP] MOV	AL, 2 OUT	DX, AX	; set color MOV	EAX, help2[EBP] MOV	[EDI], AL 		ROR	EAX, 8 MOV	EDX, 1 CMP	EDX, help[EBP] JE	R32right MOV	help2[EBP], EAX MOV	DX, 03CEH MOV	AX, 0FF08H OUT	DX, AX 		MOV	EDX, 1 MOV	EAX, help2[EBP] R32mid: MOV	help1[EBP], EDX MOV	help2[EBP], EAX MOV	DX, 03C4H MOV	AX, 0F02H OUT	DX, AX 		XCHG	help1[EBP], EDX MOV	BYTE [EDI][EDX], 0 XCHG	help1[EBP], EDX MOV	AH, color[EBP] MOV	AL, 2 OUT	DX, AX	; set color XCHG	help1[EBP], EDX XCHG	help2[EBP], EAX MOV	[EDI][EDX], AL 		ROR	EAX, 8 INC	EDX CMP	EDX, help[EBP] JL	R32mid R32right: MOV	help2[EBP], EAX MOV	help1[EBP], EDX MOV	DX, 03CEH MOV	AH, rightmask[EBP] MOV	AL, 8 OUT	DX, AX 		MOV	DX, 03C4H MOV	AX, 0F02H OUT	DX, AX 		XCHG	help1[EBP], EDX MOV	CH, [EDI][EDX]	; latch MOV	BYTE [EDI][EDX], 0 XCHG	help1[EBP], EDX MOV	AH, color[EBP] MOV	AL, 2 OUT	DX, AX	; set color MOV	EAX, help2[EBP] MOV	EDX, help1[EBP] MOV	[EDI][EDX], AL 		SUB	EDI, width3	; w3[EBP] CMP	EDI, topleft[EBP] JLE	resetgrafRP MOV	DX, 03CEH MOV	AH, leftmask[EBP]	; prepare leftmask again MOV	AL, 8 OUT	DX, AX 		XOR	EDX, EDX INC	EBX CMP	BL, 1[ESI]	; height of pattern reached? JNE	R32left XOR	EBX, EBX	; yes, then reset counter JMP	R32left JMP	endRP resetgrafRP: MOV	DX, 03CEH MOV	AX, 0FF08H	; default bit mask OUT	DX, AX 		MOV	AX, 0005	; default mode-reg OUT	DX, AX 		MOV	AX, 0003	; default function OUT	DX, AX 		MOV	DX, 03C4H MOV	AX, 0F02H	; default map mask OUT	DX, AX endRP: END FillPattern1; PROCEDURE FillPattern*(col: Color; pat: Pattern; px, py, x, y, w, h, mode: LONGINT); VAR pw: SHORTINT; right, top: INTEGER; BEGIN SYSTEM.GET(pat, pw); IF (pw # 16) & (pw # 32) THEN RETURN END; top := SHORT(y + h); right := SHORT(x + w); IF x < clipx THEN x := clipx END; IF y < clipy THEN y := clipy END; IF clipright < right THEN right :=  clipright END; IF cliptop < top THEN top := cliptop END; IF (w <= 0) OR (h <= 0) OR (x < 0) OR (y < 0) THEN RETURN END; FillPattern1(CHR(col), pat, px, py, x, y, w, h, mode) END FillPattern; PROCEDURE ReplPattern*(col: Color; pat: Pattern; x, y, w, h, mode: LONGINT); BEGIN FillPattern(col, pat, 0, 0, x, y, w, h, mode) END ReplPattern; PROCEDURE NewPattern*(w, h: LONGINT; VAR image: ARRAY OF SET): Pattern; VAR len, src, dest, i: LONGINT; p: PatternPtr;  pl: List; BEGIN len := (w+7) DIV 8; SYSTEM.NEW(p, 4+len*h); p.w := CHR(w);  p.h := CHR(h); src := SYSTEM.ADR(image[0]); dest := SYSTEM.ADR(p.pixmap[0]); i := 0; WHILE i < h DO SYSTEM.MOVE(src, dest, len); INC(src, 4);  INC(dest, len);  INC(i) END; NEW(pl); pl.pat := p;  pl.next := pattern;  pattern := pl;	(* put in list to avoid GC *) RETURN SYSTEM.ADR(p.w) 	END NewPattern; PROCEDURE CreatePatterns; VAR image: ARRAY 16 OF SET; BEGIN image[0] := {13}; image[1] := {12..14}; image[2] := {11..13}; image[3] := {10..12}; image[4] := {9..11}; image[5] := {8..10}; image[6] := {7..9}; image[7] := {0, 6..8}; image[8] := {0, 1, 5..7}; image[9] := {0..2, 4..6}; image[10] := {0..5}; image[11] := {0..4}; image[12] := {0..5}; image[13] := {0..6}; image[14] := {0..7}; arrow := NewPattern(15, 15, image); image[0] := {0, 10}; image[1] := {1, 9}; image[2] := {2, 8}; image[3] := {3, 7}; image[4] := {4, 6}; image[5] := {}; image[6] := {4, 6}; image[7] := {3, 7}; image[8] := {2, 8}; image[9] := {1, 9}; image[10] := {0, 10}; cross := NewPattern(11, 11, image); image[0] := {6}; image[1] := {5..7}; image[2] := {4..8}; image[3] := {3..9}; image[4] := {2..10}; image[5] := {5..7}; image[6] := {5..7}; image[7] := {5..7}; image[8] := {5..7}; image[9] := {5..7}; image[10] := {5..7}; image[11] := {5..7}; image[12] := {5..7}; image[13] := {5..7}; image[14] := {}; downArrow := NewPattern(15, 15, image); image[0] := {0, 4, 8, 12}; image[1] := {}; image[2] := {2, 6, 10, 14}; image[3] := {}; image[4] := {0, 4, 8, 12}; image[5] := {}; image[6] := {2, 6, 10, 14}; image[7] := {}; image[8] := {0, 4, 8, 12}; image[9] := {}; image[10] := {2, 6, 10, 14}; image[11] := {}; image[12] := {0, 4, 8, 12}; image[13] := {}; image[14] := {2, 6, 10, 14}; image[15] := {}; grey0 := NewPattern(16, 16, image); image[0] := {0, 2, 4, 6, 8, 10, 12, 14}; image[1] := {1, 3, 5, 7, 9, 11, 13, 15}; image[2] := {0, 2, 4, 6, 8, 10, 12, 14}; image[3] := {1, 3, 5, 7, 9, 11, 13, 15}; image[4] := {0, 2, 4, 6, 8, 10, 12, 14}; image[5] := {1, 3, 5, 7, 9, 11, 13, 15}; image[6] := {0, 2, 4, 6, 8, 10, 12, 14}; image[7] := {1, 3, 5, 7, 9, 11, 13, 15}; image[8] := {0, 2, 4, 6, 8, 10, 12, 14}; image[9] := {1, 3, 5, 7, 9, 11, 13, 15}; image[10] := {0, 2, 4, 6, 8, 10, 12, 14}; image[11] := {1, 3, 5, 7, 9, 11, 13, 15}; image[12] := {0, 2, 4, 6, 8, 10, 12, 14}; image[13] := {1, 3, 5, 7, 9, 11, 13, 15}; image[14] := {0, 2, 4, 6, 8, 10, 12, 14}; image[15] := {1, 3, 5, 7, 9, 11, 13, 15}; grey1 := NewPattern(16, 16, image); image[0] := {0, 1, 4, 5, 8, 9, 12, 13}; image[1] := {0, 1, 4, 5, 8, 9, 12, 13}; image[2] := {2, 3, 6, 7, 10, 11, 14, 15}; image[3] := {2, 3, 6, 7, 10, 11, 14, 15}; image[4] := {0, 1, 4, 5, 8, 9, 12, 13}; image[5] := {0, 1, 4, 5, 8, 9, 12, 13}; image[6] := {2, 3, 6, 7, 10, 11, 14, 15}; image[7] := {2, 3, 6, 7, 10, 11, 14, 15}; image[8] := {0, 1, 4, 5, 8, 9, 12, 13}; image[9] := {0, 1, 4, 5, 8, 9, 12, 13}; image[10] := {2, 3, 6, 7, 10, 11, 14, 15}; image[11] := {2, 3, 6, 7, 10, 11, 14, 15}; image[12] := {0, 1, 4, 5, 8, 9, 12, 13}; image[13] := {0, 1, 4, 5, 8, 9, 12, 13}; image[14] := {2, 3, 6, 7, 10, 11, 14, 15}; image[15] := {2, 3, 6, 7, 10, 11, 14, 15}; grey2 := NewPattern(16, 16, image); image[0] := {0..2, 8..11}; image[1] := {0..2, 7..10}; image[2] := {0..2, 6..9}; image[3] := {0..2, 5..8}; image[4] := {0..2, 4..7}; image[5] := {0..6}; image[6] := {0..5}; image[7] := {0..4}; image[8] := {0..3}; image[9] := {0..2}; image[10] := {0, 1}; image[11] := {0}; hook := NewPattern(12, 12, image); image[0] := {7}; image[1] := {7}; image[2] := {2, 7, 12}; image[3] := {3, 7, 11}; image[4] := {4, 7, 10}; image[5] := {5, 7, 9}; image[6] := {6..8}; image[7] := {0..6, 8..14}; image[8] := {6..8}; image[9] := {5, 7, 9}; image[10] := {4, 7, 10}; image[11] := {3, 7, 11}; image[12] := {2, 7, 12}; image[13] := {7}; image[14] := {7}; star := NewPattern(15, 15, image); image[0] := {}; image[1] := {}; image[2] := {0}; image[3] := {}; image[4] := {}; image[5] := {}; image[6] := {}; image[7] := {}; image[8] := {}; image[9] := {}; image[10] := {}; image[11] := {}; image[12] := {}; image[13] := {}; image[14] := {}; image[15] := {}; ticks := NewPattern(16, 16, image); image[0] := -{}; image[1] := -{}; image[2] := -{}; image[3] := -{}; image[4] := -{}; image[5] := -{}; image[6] := -{}; image[7] := -{}; solid := NewPattern(16, 8, image) END CreatePatterns; PROCEDURE Depth*(x: LONGINT): INTEGER; BEGIN RETURN depth END Depth; PROCEDURE TrueColor*(x: LONGINT): BOOLEAN; BEGIN RETURN FALSE END TrueColor; PROCEDURE DisplayBlock*(adr, dx, dy, w, h, sx, sy, mode: LONGINT); VAR BitmapWth, locW, locH, SourceAdr, DestAdr, AreaHeight: LONGINT; CODE {SYSTEM.i386} MOVSX EAX, Width SHR EAX,3 MOV locW[EBP], EAX	; locW := Width DIV 8 MOVSX EAX, Height DEC EAX MOV locH[EBP], EAX	; locH := Height-1 CLI MOV ESI, adr[EBP]		; address of bitmap descriptor MOV EDI, 12[ESI] MOV EAX, 8[ESI] MOV BitmapWth[EBP], EAX MOV ECX, dy[EBP] IMUL EAX,ECX MOV EBX, dx[EBP] ADD EAX, EBX ADD EAX, EDI		; source address MOV SourceAdr[EBP], EAX MOV ESI, EAX		; esi = source index register MOV EAX, locW[EBP] MOV EBX, locH[EBP] SUB EBX, sy[EBP] IMUL EAX,EBX MOV EBX, sx[EBP] SHR EBX,3 ADD EAX, EBX AND EAX, 0FFFFH ADD EAX, 0A0000H		; destination address MOV DestAdr[EBP], EAX MOV EDI, EAX		; edi = destination index register MOV DX, 03C4H	; AX = Default map mask; DX = Sequencer MOV AX, 0F02H OUT DX, AX 		MOV DX, 03CEH MOV AL, 3 MOV BX, WORD mode[EBP] CMP BX, 1 JE DispPMode JG DispIMode DispRMode: MOV AH,00 JMP DispSetMode DispPMode: MOV AH, 10H JMP DispSetMode DispIMode: MOV AH, 18H DispSetMode: OUT DX, AX	; set rotate and function select MOV AX, 0205H OUT DX, AX		 ; set writemode 2, readmode 0 XOR AX, AX 		OUT DX, AX	; disable set/reset MOV CL, BYTE sx[EBP] AND CL, 7		; ?DX MOD 8 MOV AX, 8008H SHR AH,CL		 ; prepare bitmask MOV DestAdr[EBP], EDI MOV ECX, h[EBP] IMUL ECX, BitmapWth[EBP] ADD ECX, ESI MOV EBX, w[EBP] MOV AreaHeight[EBP], EBX DispRowLoop: JE DispEnd OUT DX, AX		; set bitmask register MOV SourceAdr[EBP], ESI DispColLoop: CMP ESI, ECX JGE DispColEnd MOV BL, [EDI] MOV BL, [ESI]		; get PEL from bitmap MOV [EDI], BL		; write PEL to VGA ADD ESI, BitmapWth[EBP] SUB EDI, locW[EBP] JMP DispColLoop DispColEnd: MOV ESI, SourceAdr[EBP] INC ESI INC ECX MOV EDI, DestAdr[EBP] ROR AH,1 JNB NextCol INC EDI MOV DestAdr[EBP], EDI NextCol: DEC AreaHeight[EBP]		 	; next row JMP DispRowLoop DispEnd: MOV AL, 3		; restore invert mode MOV AH, 18H OUT DX, AX 		MOV AX, 0FF08H		; enable all latches OUT DX, AX 		MOV AX, 05H		; restore read/write mode 0 OUT DX, AX 		STI END DisplayBlock; PROCEDURE TransferFormat*(x: LONGINT): LONGINT;	(** non-portable *) BEGIN RETURN unknown END TransferFormat; PROCEDURE TransferBlock*(VAR buf: ARRAY OF CHAR; ofs, stride, x, y, w, h, mode: LONGINT);	(** non-portable *) BEGIN HALT(99) END TransferBlock; PROCEDURE SetBorder; VAR ch: CHAR; BEGIN SYSTEM.PORTIN(3DAH, ch); SYSTEM.PORTOUT(3C0H, 11X); SYSTEM.PORTOUT(3C0H, 0FFX); SYSTEM.PORTOUT(3C0H, 020X) END SetBorder; PROCEDURE Init; VAR s: ARRAY 10 OF CHAR; BEGIN Kernel.GetConfig("Color", s); IF s = "0" THEN depth := 1 ELSE depth := 4 END END Init; PROCEDURE InitRev; VAR i, j, x: LONGINT; BEGIN FOR i := 0 TO 255 DO 			x := 0; FOR j := 0 TO 7 DO 				x := ASH(x, 1); IF ODD(ASH(i, -j)) THEN INC(x) END END; rev[i] := CHR(x) END END InitRev; BEGIN Init; Width := 640; Height := 480; Left:= 0; ColLeft:= 0; Bottom:= 0; UBottom:= -330; pattern := NIL; width := Width; height := Height; clipx := 0; clipy := UBottom; clipright := width; cliptop := height; width3 := width DIV 8; mask[0] := 0X; mask[1] := 80X; mask[2] := 0C0X; mask[3] := 0E0X; mask[4] := 0F0X; mask[5] := 0F8X; mask[6] := 0FCX; mask[7] := 0FEX; mask[8] := 0FFX; imask[0] := 0FFX; imask[1] := 7FX; imask[2] := 3FX; imask[3] := 1FX; imask[4] := 0FX; imask[5] := 7X; imask[6] := 3X; imask[7] := 1X; imask[8] := 0X; InitRev; CreatePatterns; SetBorder; Unit := 10000 END Display. Compiler.Compile VGA.Display.Mod\X ~

title: Oberon/ETH Oberon/2.3.7/VGA.Display.Mod


text:
Oberon/ETH Oberon/2.3.7/W32.Display.Mod

(* ETH Oberon, Copyright 1990-2003 Computer Systems Institute, ETH Zurich, CH-8092 Zurich. Refer to the license.txt file provided with this distribution. *) MODULE Display;	(* ET4000W32 ARD/pjm *) IMPORT Kernel, SYSTEM, Objects; CONST BG* = 0; FG* = 15; (*background, foreground*) replace* = 0; paint* = 1; invert* = 2; (*operation modes*) remove* = 0; suspend* = 1; restore* = 2; newprinter* = 3; (*ControlMsg id*) reduce* = 0; extend* = 1; move* = 2; (*ModifyMsg id*) display* = 0; state* = 1; (*ModifyMsg mode*) screen* = 0; printer* = 1; (* DisplayMsg device *) full* = 0; area* = 1; contents* = 2; (* DisplayMsg id. *) get* = 0; set* = 1; reset* = 2; (*SelectMsg id*) drop* = 0; integrate* = 1; (*ConsumeMsg id*) unknown* = 0; index8* = 8; color555* = 16; color565* = 17; color664* = 18; color888* = 24; color8888* = 32; (* ACL Registers, queued *) PatAdr = 80H; SrcAdr = 84H; PatYOff = 88H; SrcYOff = 8AH; DestYOff = 8CH; BusSize = 8EH; XYDir = 8FH; PatWrap = 90H; SrcWrap = 92H; XPos = 94H; YPos = 96H; XCnt = 98H; YCnt = 9AH; RoutCtrl = 9CH; RelCtrl = 9DH; BgRop = 9EH; FgRop = 9FH; DestAdr = 0A0H; (* ACL Registers, non-queued *) SusTerm = 30H; OpState = 31H; SyncEn = 32H; IntMask = 34H; IntStat = 35H; AccStat = 36H; Base = 0BFF00H; MMU = 0B8000H; TYPE Color* = LONGINT; Pattern* = LONGINT; PatternPtr = POINTER TO RECORD w, h: CHAR; pixmap: ARRAY 8192 OF CHAR END; List = POINTER TO ListDesc; ListDesc = RECORD next: List; pat: PatternPtr END; Frame* = POINTER TO FrameDesc; FrameDesc* = RECORD (Objects.ObjDesc) next*, dsc*: Frame; X*, Y*, W*, H*: INTEGER END; FrameMsg* = RECORD (Objects.ObjMsg) F*: Frame; (*target*) x*, y*, res*: INTEGER END; ControlMsg* = RECORD (FrameMsg) id*: INTEGER END; ModifyMsg* = RECORD (FrameMsg) id*, mode*: INTEGER; dX*, dY*, dW*, dH*: INTEGER; X*, Y*, W*, H*: INTEGER END; DisplayMsg* = RECORD (FrameMsg) device*: INTEGER; id*: INTEGER; u*, v*, w*, h*: INTEGER END; LocateMsg* = RECORD (FrameMsg) loc*: Frame; X*, Y*, u*, v*: INTEGER END; SelectMsg* = RECORD (FrameMsg) id*: INTEGER; time*: LONGINT; sel*: Frame; obj*: Objects.Object END; ConsumeMsg* = RECORD (FrameMsg) id*: INTEGER; u*, v*: INTEGER; obj*: Objects.Object END; MsgProc* = PROCEDURE (VAR M: FrameMsg); VAR Unit*: LONGINT; (* RasterUnit = Unit/36000 mm *) Left*, (* left margin of black-and-white maps *) ColLeft*, (* left margin of color maps *) Bottom*, (* bottom of primary map *) UBottom*, (* bottom of secondary map *) Width*, (* map width *) Height*: INTEGER; (* map hight*) arrow*, star*, cross*, downArrow*, hook*, grey0*, grey1*, grey2*, ticks*, solid*: Pattern; Broadcast*: MsgProc; dmem, lasty: LONGINT; pattern: List; palette: ARRAY 256 OF LONGINT; clipx, clipy, clipright, cliptop, height, width: LONGINT;	(* clipping variables *) depth: INTEGER; PROCEDURE max (i, j: LONGINT): LONGINT; BEGIN IF i >= j THEN RETURN i ELSE RETURN j END END max; PROCEDURE min (i, j: LONGINT): LONGINT; BEGIN IF i >= j THEN RETURN j ELSE RETURN i END END min; PROCEDURE Wait; VAR i: SHORTINT; BEGIN REPEAT SYSTEM.GET(Base+AccStat, i) UNTIL ~ODD(i) & ~ODD(i DIV 2); END Wait; PROCEDURE Map*(x: LONGINT): LONGINT; BEGIN RETURN 0A0000H END Map; PROCEDURE AdjustClip*(x, y, w, h: LONGINT); VAR right, top: LONGINT; BEGIN right := x + w; top := y + h; clipx := max(clipx, x); clipy := max(clipy, y); clipright := min(right, clipright); cliptop := min(top, cliptop) END AdjustClip; PROCEDURE GetDim*(pat: Pattern; VAR w, h: INTEGER); VAR s: CHAR; BEGIN SYSTEM.GET(pat, s); w := ORD(s); SYSTEM.GET(pat+1, s); h := ORD(s) END GetDim; PROCEDURE ResetClip*; BEGIN clipx := 0; clipy := UBottom; clipright := width; cliptop := height END ResetClip; PROCEDURE SetClip*(x, y, w, h: LONGINT); BEGIN clipright := x+w; cliptop := y+h; clipy := y; clipx := x 	END SetClip; PROCEDURE GetClip*(VAR x, y, w, h: INTEGER); BEGIN x := SHORT(clipx); y := SHORT(clipy); w := SHORT(clipright - clipx); h := SHORT(cliptop - clipy) END GetClip; PROCEDURE SetColor*(col: Color; red, green, blue: LONGINT);	(* 0 <= col, red, green, blue < 256 *) VAR ch: CHAR; BEGIN palette[col] := ASH(ASH(red, 8) + green, 8) + blue; IF (col = 0) OR (col = 15) THEN	(* either 0 or 15 must be black. set the border to black. *) (* note: use the palette for the border colour too *) SYSTEM.PORTIN(3DAH, ch); SYSTEM.PORTOUT(3C0H, 11X); IF (red = 0) & (green = 0) & (blue = 0) THEN SYSTEM.PORTOUT(3C0H, CHR(col)) ELSE SYSTEM.PORTOUT(3C0H, CHR(15-col)) END; SYSTEM.PORTOUT(3C0H, 20X) END; SYSTEM.PORTOUT(3C8H, CHR(col)); SYSTEM.PORTOUT(3C9H, CHR(red DIV 4)); SYSTEM.PORTOUT(3C9H, CHR(green DIV 4)); SYSTEM.PORTOUT(3C9H, CHR(blue DIV 4)) END SetColor; PROCEDURE GetColor*(col: Color; VAR red, green, blue: INTEGER); BEGIN IF col >= 0 THEN col := palette[col] END; red := SHORT(ASH(col, -16) MOD 256); green := SHORT(ASH(col, -8) MOD 256); blue := SHORT(col MOD 256) END GetColor; PROCEDURE RGB*(red, green, blue: LONGINT): Color; BEGIN RETURN MIN(LONGINT) + ASH(red, 16) + ASH(green, 8) + blue END RGB; PROCEDURE Dot*(col: Color; x, y, mode: LONGINT); VAR dest: LONGINT; BEGIN IF (y >= clipy) & (y < cliptop) & (x >= clipx) & (x < clipright) THEN dest := (LONG(Height)-1 - y) * Width + x; 			IF mode = invert THEN SYSTEM.PUT(Base+FgRop, 066X) ELSE SYSTEM.PUT(Base+FgRop, 0CCX) END; Wait; SYSTEM.PUT(Base+XCnt, LONG(0)); SYSTEM.PUT(Base+YCnt, LONG(0)); SYSTEM.PUT(Base+RoutCtrl, 1X); SYSTEM.PUT(Base, dest); SYSTEM.PUT(MMU, col) END END Dot; PROCEDURE CopyBlock*(sx, sy, w, h, dx, dy, mode: LONGINT); VAR src, dst, top, right, dX, dY: LONGINT; BEGIN right := dx + w; top := dy + h; dX := dx; dY := dy; IF dx < clipx THEN w := w - (clipx - dx); dx := clipx END; IF dy < clipy THEN h := h - (clipy - dy); dy := clipy END; IF clipright < right THEN w :=  clipright - dx END; IF cliptop < top THEN h := cliptop - dy END; IF (w > 0) & (h > 0) THEN sx := sx - (dX - dx); sy := sy - (dY - dy); src := (LONG(Height) - sy - h) * Width + sx; dst := (LONG(Height) - dy - h) * Width + dx; IF src # dst THEN Wait; SYSTEM.PUT(Base+XCnt, LONG(0)); SYSTEM.PUT(Base+YCnt, LONG(0)); SYSTEM.PUT(Base+RoutCtrl, 0X); SYSTEM.PUT(Base+XYDir, 0X); SYSTEM.PUT(Base+FgRop, 0AAX); SYSTEM.PUT(Base+SrcAdr, dst); SYSTEM.PUT(Base+DestAdr, dst); SYSTEM.PUT(Base+OpState, 9X); Wait; SYSTEM.PUT(Base+XCnt, SHORT(w-1)); SYSTEM.PUT(Base+YCnt, SHORT(h-1)); IF dst > src THEN src := src + w-1 + Width * (h-1); dst := dst + w-1 + Width * (h-1); SYSTEM.PUT(Base+XYDir, 3X) ELSE SYSTEM.PUT(Base+XYDir, 0X) END; SYSTEM.PUT(Base+FgRop, 0CCX); SYSTEM.PUT(Base+RoutCtrl, 0X); SYSTEM.PUT(Base+DestAdr, dst); SYSTEM.PUT(Base+SrcAdr, src); SYSTEM.PUT(Base+OpState, 9X); SYSTEM.PUT(Base+XYDir, 0X) END END END CopyBlock; PROCEDURE SetMode*(x: LONGINT; s: SET); BEGIN END SetMode; PROCEDURE CopyPatternAsm(cpX, cpY, cpW, cpH, pat: LONGINT; VAR buf: ARRAY OF INTEGER); VAR cpw, cpsw, cph: LONGINT; CODE {SYSTEM.i386} MOV EBX,cpW[EBP] ADD EBX,7 SHR EBX,3 MOV cpw[EBP],EBX	; cpw := cpW DIV 8 MOV ESI,pat[EBP] XOR EAX,EAX MOV AL,[ESI] ADD EAX,7 SHR EAX,3 MOV cpsw[EBP],EAX	; cpsw := p.w DIV 8 MOV EDI,buf[EBP] MOV EAX,cpW[EBP] MOV [EDI],AL	; new p.w 		INC EDI MOV EAX,cpH[EBP]	; new p.h 		MOV [EDI],AL INC EDI MOV EBX,cpsw[EBP] MOV EAX,cpY[EBP] IMUL EAX,EBX ADD ESI,EAX MOV ECX,cpX[EBP] SHR ECX,3 ADD ESI,ECX ADD ESI,2	; ESI := Sourcepos for Copyloop MOV cph[EBP],0	; init loop variables MOV EDX,cph[EBP] MOV ECX,cpX[EBP] AND ECX,7	; cpX MOD 8 loopcp: CMP  cpH[EBP],EDX JLE l7cp	; height reached ? MOV  EAX,[ESI] SHR EAX,CL	; in proper position PUSH ECX MOV EBX,-2 MOV ECX,cpW[EBP] SHL EBX,CL SHR EBX, 1 NOT EBX AND EAX,EBX POP ECX MOV [EDI],EAX	; copy for a new pattern MOV EAX,cpsw[EBP] ADD ESI,EAX	; one line in source up 		MOV EAX,cpw[EBP] ADD EDI,EAX	; one line at destination up 		INC EDX JMP loopcp l7cp: END CopyPatternAsm; PROCEDURE CopyPattern*(col: Color; pat: Pattern; x, y, mode: LONGINT); VAR dest, i: LONGINT; w, h: CHAR; lx, ly, cpX, cpY, cpW, cpH, nofbytes: LONGINT; buf: ARRAY 256 OF INTEGER; onebyte: CHAR; doublefill: ARRAY 4 OF CHAR; BEGIN SYSTEM.GET(pat, w); SYSTEM.GET(pat+1, h); cpW := ORD(w) + x; cpH := ORD(h) + y; 		lx := x; ly := y; 		IF x < clipx THEN x := clipx END; IF y < clipy THEN y := clipy END; IF cpW > clipright THEN cpW := clipright END; IF cpH > cliptop THEN cpH := cliptop END; cpW := cpW - x; cpH := cpH - y; 		cpX := x - lx; cpY := y - ly; IF (cpW <= 0) OR (cpH <= 0) OR (cpX < 0) OR (cpY < 0) THEN RETURN END; IF (cpW # ORD(w)) OR (cpH # ORD(h)) THEN CopyPatternAsm(cpX, cpY, cpW, cpH, pat, buf); pat := SYSTEM.ADR(buf[0]) END; dest := (LONG(Height)-1-y) * Width + x; 		doublefill[0] := CHR(col); doublefill[1] := CHR(col); doublefill[2] := CHR(col); doublefill[3] := CHR(col); SYSTEM.GET(pat, w); SYSTEM.GET(pat+1, h); INC(pat, 2); nofbytes := (ORD(w)+7) DIV 8; Wait; SYSTEM.PUT(Base+FgRop, 0CCX); SYSTEM.PUT(Base+XCnt, LONG(3)); SYSTEM.PUT(Base+YCnt, LONG(0)); SYSTEM.PUT(Base, lasty); SYSTEM.PUT(Base+RoutCtrl, 1X); SYSTEM.PUT(MMU, SYSTEM.VAL(SET, doublefill)); Wait; IF mode = invert THEN SYSTEM.PUT(Base+FgRop, 05AX); SYSTEM.PUT(Base+BgRop, 0AAX) ELSE SYSTEM.PUT(Base+FgRop, 0F0X); SYSTEM.PUT(Base+BgRop, 0AAX) END; SYSTEM.PUT(Base+PatAdr, lasty); SYSTEM.PUT(Base+PatWrap, 2X); SYSTEM.PUT(Base+XYDir, 2X); SYSTEM.PUT(Base+YCnt, SHORT(ORD(h)-1)); SYSTEM.PUT(Base+XCnt, SHORT(ORD(w)-1)); SYSTEM.PUT(Base+RoutCtrl, 2X); SYSTEM.PUT(Base, dest); SYSTEM.PUT(Base+BusSize, 0X); FOR i := 0 TO nofbytes*ORD(h)-1 DO SYSTEM.GET(pat+i, onebyte); SYSTEM.PUT(MMU, onebyte) END; SYSTEM.PUT(Base+BusSize, 2X); END CopyPattern; PROCEDURE ReplConst*(col: Color; x, y, w, h, mode: LONGINT); VAR dest, right, top: LONGINT; doublefill: ARRAY 4 OF CHAR; BEGIN top := y + h; right := x + w; 		IF x < clipx THEN x := clipx END; IF y < clipy THEN y := clipy END; IF clipright < right THEN right := clipright END; IF cliptop < top THEN top := cliptop END; w := right - x; h := top - y; 		IF (w <= 0) OR (h <= 0) OR (x < 0) OR (y < 0) THEN RETURN END; dest := (Height - y - h) * Width + x; 		doublefill[0] := CHR(col); doublefill[1] := CHR(col); doublefill[2] := CHR(col); doublefill[3] := CHR(col); Wait; SYSTEM.PUT(Base+FgRop, 0CCX); SYSTEM.PUT(Base+XCnt, LONG(3)); SYSTEM.PUT(Base+YCnt, LONG(0)); SYSTEM.PUT(Base, lasty); SYSTEM.PUT(Base+RoutCtrl, 1X); SYSTEM.PUT(MMU, SYSTEM.VAL(SET, doublefill)); Wait; IF mode = invert THEN SYSTEM.PUT(Base+FgRop, 066X) ELSE SYSTEM.PUT(Base+FgRop, 0CCX) END; SYSTEM.PUT(Base+SrcWrap, 2X); SYSTEM.PUT(Base+SrcAdr, lasty); SYSTEM.PUT(Base+DestAdr, dest); SYSTEM.PUT(Base+XYDir, 0X); SYSTEM.PUT(Base+XCnt, SHORT(w-1)); SYSTEM.PUT(Base+YCnt, SHORT(h-1)); SYSTEM.PUT(Base+RoutCtrl, 0X); SYSTEM.PUT(Base+OpState, 9X); SYSTEM.PUT(Base+SrcWrap, 0FFX) END ReplConst; PROCEDURE FillPattern*(col: Color; pat: Pattern; px, py, x, y, w, h, mode: LONGINT); VAR dest, vertoff, fourbytes, mod, pw, ph, origh, off, right, top: LONGINT; ch: CHAR; doublefill: ARRAY 4 OF CHAR; BEGIN doublefill[0] := CHR(col); doublefill[1] := CHR(col); doublefill[2] := CHR(col); doublefill[3] := CHR(col); SYSTEM.GET(pat, ch); pw := ORD(ch); SYSTEM.GET(pat+1, ch); ph := ORD(ch); origh := ph; INC(pat, 2); IF (pw # 16) & (pw # 32) THEN RETURN END; top := y + h; right := x + w; 		IF x < clipx THEN x := clipx END; IF y < clipy THEN y := clipy END; IF clipright < right THEN right := clipright END; IF cliptop < top THEN top := cliptop END; w := right - x; h := top - y; 		IF (w <= 0) OR (h <= 0) OR (x < 0) OR (y < 0) THEN RETURN END; dest := (LONG(Height)-1 - y) * Width + x; 		off := (x - px) MOD 32; vertoff := ((y - py) MOD h) * (w DIV 8); Wait;	(* Foreground color *) SYSTEM.PUT(Base+FgRop, 0CCX); SYSTEM.PUT(Base+XCnt, LONG(31)); SYSTEM.PUT(Base+YCnt, LONG(0)); SYSTEM.PUT(Base, lasty); SYSTEM.PUT(Base+RoutCtrl, 1X); SYSTEM.PUT(MMU, SYSTEM.VAL(SET, SYSTEM.VAL(SET, doublefill))); SYSTEM.PUT(MMU, SYSTEM.VAL(SET, SYSTEM.VAL(SET, doublefill))); SYSTEM.PUT(MMU, SYSTEM.VAL(SET, SYSTEM.VAL(SET, doublefill))); SYSTEM.PUT(MMU, SYSTEM.VAL(SET, SYSTEM.VAL(SET, doublefill))); SYSTEM.PUT(MMU, SYSTEM.VAL(SET, SYSTEM.VAL(SET, doublefill))); SYSTEM.PUT(MMU, SYSTEM.VAL(SET, SYSTEM.VAL(SET, doublefill))); SYSTEM.PUT(MMU, SYSTEM.VAL(SET, SYSTEM.VAL(SET, doublefill))); SYSTEM.PUT(MMU, SYSTEM.VAL(SET, SYSTEM.VAL(SET, doublefill))); mod := (w DIV 8)*origh; Wait; SYSTEM.PUT(Base+SrcWrap, 5X); SYSTEM.PUT(Base+PatWrap, 5X); SYSTEM.PUT(Base+YCnt, LONG(0)); SYSTEM.PUT(Base+XYDir, 2X); SYSTEM.PUT(Base+BgRop, 0CCX); WHILE h > 0 DO 			SYSTEM.GET(pat+vertoff, fourbytes); IF pw = 16 THEN vertoff := (vertoff + 2) MOD mod; fourbytes := fourbytes*10000H + fourbytes MOD 10000H; ELSE vertoff := (vertoff + 4) MOD mod END; fourbytes := SYSTEM.ROT(fourbytes, -off); Wait; SYSTEM.PUT(Base+FgRop, 0F0X); SYSTEM.PUT(Base+SrcAdr, lasty+32); SYSTEM.PUT(Base+PatAdr, lasty); SYSTEM.PUT(Base+XCnt, LONG(31)); SYSTEM.PUT(Base+RoutCtrl, 2X); SYSTEM.PUT(Base, lasty + 96); SYSTEM.PUT(MMU, fourbytes); IF mode = paint THEN Wait;	(* clear color *) SYSTEM.PUT(Base+FgRop, 0FFX); SYSTEM.PUT(Base, lasty+64); SYSTEM.PUT(MMU, fourbytes) END; Wait; IF mode = invert THEN SYSTEM.PUT(Base+FgRop, 066X) ELSIF mode = replace THEN SYSTEM.PUT(Base+FgRop, 0CCX) ELSE SYSTEM.PUT(Base+PatAdr, lasty+64); SYSTEM.PUT(Base+FgRop, 0CEX) END; SYSTEM.PUT(Base+SrcAdr, lasty+96); SYSTEM.PUT(Base+XCnt, SHORT(w-1)); SYSTEM.PUT(Base+RoutCtrl, 0X); SYSTEM.PUT(Base+DestAdr, dest); SYSTEM.PUT(Base+OpState, 9X); DEC(h); DEC(dest, LONG(Width)) END; SYSTEM.PUT(Base+SrcWrap, 0FFX) END FillPattern; PROCEDURE ReplPattern*(col: Color; pat: Pattern; x, y, w, h, mode: LONGINT); BEGIN FillPattern(col, pat, 0, 0, x, y, w, h, mode) END ReplPattern; PROCEDURE NewPattern*(w, h: LONGINT; VAR image: ARRAY OF SET): Pattern; VAR len, src, dest, i: LONGINT; p: PatternPtr;  pl: List; BEGIN len := (w+7) DIV 8; SYSTEM.NEW(p, 4+len*h); p.w := CHR(w);  p.h := CHR(h); src := SYSTEM.ADR(image[0]); dest := SYSTEM.ADR(p.pixmap[0]); i := 0; WHILE i < h DO SYSTEM.MOVE(src, dest, len); INC(src, 4);  INC(dest, len);  INC(i) END; NEW(pl); pl.pat := p;  pl.next := pattern;  pattern := pl;	(* put in list to avoid GC *) RETURN SYSTEM.ADR(p.w) 	END NewPattern; PROCEDURE CreatePatterns; VAR image: ARRAY 16 OF SET; BEGIN image[0] := {13}; image[1] := {12..14}; image[2] := {11..13}; image[3] := {10..12}; image[4] := {9..11}; image[5] := {8..10}; image[6] := {7..9}; image[7] := {0, 6..8}; image[8] := {0, 1, 5..7}; image[9] := {0..2, 4..6}; image[10] := {0..5}; image[11] := {0..4}; image[12] := {0..5}; image[13] := {0..6}; image[14] := {0..7}; arrow := NewPattern(15, 15, image); image[0] := {0, 10}; image[1] := {1, 9}; image[2] := {2, 8}; image[3] := {3, 7}; image[4] := {4, 6}; image[5] := {}; image[6] := {4, 6}; image[7] := {3, 7}; image[8] := {2, 8}; image[9] := {1, 9}; image[10] := {0, 10}; cross := NewPattern(11, 11, image); image[0] := {6}; image[1] := {5..7}; image[2] := {4..8}; image[3] := {3..9}; image[4] := {2..10}; image[5] := {5..7}; image[6] := {5..7}; image[7] := {5..7}; image[8] := {5..7}; image[9] := {5..7}; image[10] := {5..7}; image[11] := {5..7}; image[12] := {5..7}; image[13] := {5..7}; image[14] := {}; downArrow := NewPattern(11, 15, image); image[0] := {0, 4, 8, 12}; image[1] := {}; image[2] := {2, 6, 10, 14}; image[3] := {}; image[4] := {0, 4, 8, 12}; image[5] := {}; image[6] := {2, 6, 10, 14}; image[7] := {}; image[8] := {0, 4, 8, 12}; image[9] := {}; image[10] := {2, 6, 10, 14}; image[11] := {}; image[12] := {0, 4, 8, 12}; image[13] := {}; image[14] := {2, 6, 10, 14}; image[15] := {}; grey0 := NewPattern(16, 16, image); image[0] := {0, 2, 4, 6, 8, 10, 12, 14}; image[1] := {1, 3, 5, 7, 9, 11, 13, 15}; image[2] := {0, 2, 4, 6, 8, 10, 12, 14}; image[3] := {1, 3, 5, 7, 9, 11, 13, 15}; image[4] := {0, 2, 4, 6, 8, 10, 12, 14}; image[5] := {1, 3, 5, 7, 9, 11, 13, 15}; image[6] := {0, 2, 4, 6, 8, 10, 12, 14}; image[7] := {1, 3, 5, 7, 9, 11, 13, 15}; image[8] := {0, 2, 4, 6, 8, 10, 12, 14}; image[9] := {1, 3, 5, 7, 9, 11, 13, 15}; image[10] := {0, 2, 4, 6, 8, 10, 12, 14}; image[11] := {1, 3, 5, 7, 9, 11, 13, 15}; image[12] := {0, 2, 4, 6, 8, 10, 12, 14}; image[13] := {1, 3, 5, 7, 9, 11, 13, 15}; image[14] := {0, 2, 4, 6, 8, 10, 12, 14}; image[15] := {1, 3, 5, 7, 9, 11, 13, 15}; grey1 := NewPattern(16, 16, image); image[0] := {0, 1, 4, 5, 8, 9, 12, 13}; image[1] := {0, 1, 4, 5, 8, 9, 12, 13}; image[2] := {2, 3, 6, 7, 10, 11, 14, 15}; image[3] := {2, 3, 6, 7, 10, 11, 14, 15}; image[4] := {0, 1, 4, 5, 8, 9, 12, 13}; image[5] := {0, 1, 4, 5, 8, 9, 12, 13}; image[6] := {2, 3, 6, 7, 10, 11, 14, 15}; image[7] := {2, 3, 6, 7, 10, 11, 14, 15}; image[8] := {0, 1, 4, 5, 8, 9, 12, 13}; image[9] := {0, 1, 4, 5, 8, 9, 12, 13}; image[10] := {2, 3, 6, 7, 10, 11, 14, 15}; image[11] := {2, 3, 6, 7, 10, 11, 14, 15}; image[12] := {0, 1, 4, 5, 8, 9, 12, 13}; image[13] := {0, 1, 4, 5, 8, 9, 12, 13}; image[14] := {2, 3, 6, 7, 10, 11, 14, 15}; image[15] := {2, 3, 6, 7, 10, 11, 14, 15}; grey2 := NewPattern(16, 16, image); image[0] := {0..2, 8..11}; image[1] := {0..2, 7..10}; image[2] := {0..2, 6..9}; image[3] := {0..2, 5..8}; image[4] := {0..2, 4..7}; image[5] := {0..6}; image[6] := {0..5}; image[7] := {0..4}; image[8] := {0..3}; image[9] := {0..2}; image[10] := {0, 1}; image[11] := {0}; hook := NewPattern(12, 12, image); image[0] := {7}; image[1] := {7}; image[2] := {2, 7, 12}; image[3] := {3, 7, 11}; image[4] := {4, 7, 10}; image[5] := {5, 7, 9}; image[6] := {6..8}; image[7] := {0..6, 8..14}; image[8] := {6..8}; image[9] := {5, 7, 9}; image[10] := {4, 7, 10}; image[11] := {3, 7, 11}; image[12] := {2, 7, 12}; image[13] := {7}; image[14] := {7}; star := NewPattern(15, 15, image); image[0] := {}; image[1] := {}; image[2] := {0}; image[3] := {}; image[4] := {}; image[5] := {}; image[6] := {}; image[7] := {}; image[8] := {}; image[9] := {}; image[10] := {}; image[11] := {}; image[12] := {}; image[13] := {}; image[14] := {}; image[15] := {}; ticks := NewPattern(16, 16, image); image[0] := -{}; image[1] := -{}; image[2] := -{}; image[3] := -{}; image[4] := -{}; image[5] := -{}; image[6] := -{}; image[7] := -{}; solid := NewPattern(16, 8, image) END CreatePatterns; PROCEDURE Depth*(x: LONGINT): INTEGER; BEGIN RETURN depth END Depth; PROCEDURE TrueColor*(x: LONGINT): BOOLEAN; BEGIN RETURN FALSE END TrueColor; PROCEDURE DisplayBlock*(adr, dx, dy, w, h, sx, sy, mode: LONGINT); VAR src, dst, width, i, base: LONGINT; data: CHAR; mmu: LONGINT; BEGIN dst := Width*(LONG(Height)-1-sy) + sx; SYSTEM.GET(adr+8, width); SYSTEM.GET(adr+12, base); src := base + width * dy + dx; Wait; SYSTEM.PUT(Base+XCnt, SHORT(w-1)); SYSTEM.PUT(Base+YCnt, LONG(0)); SYSTEM.PUT(Base+RoutCtrl, 1X); SYSTEM.PUT(Base+XYDir, 0X); SYSTEM.PUT(Base+BusSize, 0X); IF mode = invert THEN SYSTEM.PUT(Base+FgRop, 066X) ELSE SYSTEM.PUT(Base+FgRop, 0CCX) END; mmu := MMU; WHILE h > 0 DO 			Wait; SYSTEM.PUT(Base, dst); SYSTEM.MOVE(src,mmu,w); DEC(dst, LONG(Width)); INC(src, width); DEC(h) END; SYSTEM.PUT(Base+BusSize, 2X) END DisplayBlock; PROCEDURE TransferFormat*(x: LONGINT): LONGINT; BEGIN RETURN unknown END TransferFormat; PROCEDURE TransferBlock*(VAR buf: ARRAY OF CHAR; ofs, stride, x, y, w, h, mode: LONGINT); BEGIN HALT(99) END TransferBlock; PROCEDURE Init; BEGIN Wait; SYSTEM.PUT(Base+13H, 71X); SYSTEM.PUT(Base+SyncEn, 1X); SYSTEM.PUT(Base+IntMask, 0X); SYSTEM.PUT(Base+BusSize, 2X); SYSTEM.PUT(Base+SrcWrap, 0FFX); SYSTEM.PUT(Base+RelCtrl, LONG(0)); SYSTEM.PUT(Base+XPos, LONG(0)); SYSTEM.PUT(Base+YPos, LONG(0)); SYSTEM.PUT(Base+SrcYOff, Width-1); SYSTEM.PUT(Base+DestYOff, Width-1); SYSTEM.PUT(Base+PatYOff, Width-1); (* Background color *) SYSTEM.PUT(Base+FgRop, 0CCX); SYSTEM.PUT(Base+XCnt, LONG(31)); SYSTEM.PUT(Base+YCnt, LONG(0)); SYSTEM.PUT(Base, lasty+32); SYSTEM.PUT(Base+RoutCtrl, 1X); SYSTEM.PUT(MMU, LONG(LONG(BG))); SYSTEM.PUT(MMU, LONG(LONG(BG))); SYSTEM.PUT(MMU, LONG(LONG(BG))); SYSTEM.PUT(MMU, LONG(LONG(BG))); SYSTEM.PUT(MMU, LONG(LONG(BG))); SYSTEM.PUT(MMU, LONG(LONG(BG))); SYSTEM.PUT(MMU, LONG(LONG(BG))); SYSTEM.PUT(MMU, LONG(LONG(BG))); END Init; PROCEDURE GetVal(str: ARRAY OF CHAR; default: LONGINT): LONGINT; VAR i: SHORTINT; v, sgn: LONGINT;  s: ARRAY 10 OF CHAR; BEGIN Kernel.GetConfig(str, s); IF s[0] = 0X THEN v := default ELSE v := 0; i := 0; WHILE s[i] # 0X DO v := v*10+(ORD(s[i])-48); INC(i) END END; RETURN v 	END GetVal; BEGIN depth := SHORT(GetVal("Color", 1));	(* assume 1 if not specified *) IF depth = 0 THEN depth := 1 ELSE depth := 8 END; Width := SHORT(GetVal("DWidth", 1024));	(* assume 1024 if not specified *) Height := SHORT(GetVal("DHeight", 768));	(* assume 768 if not specified *) dmem := GetVal("DMem", 1024)*1024;	(* assume 1Mb if not specified *) UBottom := Height - SHORT(dmem DIV Width) + 1; Left:= 0; ColLeft:= 0; Bottom:= 0; lasty := LONG(Height-UBottom)*Width; pattern := NIL; Init; width := Width; height := Height; clipx := 0; clipy := UBottom; clipright := width; cliptop := height; CreatePatterns; Unit := 10000 END Display.

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

title: Oberon/ETH Oberon/2.3.7/W32.Display.Mod