--	File CIFUtilities.Mesa
-- August 1980 by MN
--	Last changed: June 10, 1981  11:26 PM

DIRECTORY

AltoDevice: FROM "AltoDevice" USING [Bitmap, ScreenBitmap, NewAltoDevice, ScreenOrigin],
BitBltDefs: FROM "BitBltDefs" USING [BBTable, BITBLT],
CIFUtilitiesDefs: FROM "CIFUtilitiesDefs" USING [Rectangle],
Graphics: FROM "Graphics" USING [DisplayContext, BoundingBox, StartAreaPath, EnterPoint,
	DestroyPath, SetClipArea, NewContext, Translate, Scale, Map, MoveTo, DrawTo,
	PushClipBox, PopClipBox, ScreenToUser, UserToScreen, CopyContext, PushContext, PopContext,
	SetPaint, SetTexture, black, DrawScreenArea, SetFont, MakeFont],
InlineDefs: FROM "InlineDefs" USING [HighHalf, LowHalf],
IODefs: FROM "IODefs" USING [WriteLine],
JaMFnsDefs: FROM "JaMFnsDefs" USING [SetMouseProc, JaMStream, PushReal],
KeyDefs: FROM "KeyDefs" USING [MouseButton, Mouse],
Memory: FROM "Memory" USING [long],
Real: FROM "Real" USING [FixI],
Vector: FROM "Vector" USING [Vec];

CIFUtilities: PROGRAM
IMPORTS AltoDevice, BitBltDefs, Graphics, InlineDefs, IODefs, JaMFnsDefs, Memory, Real
EXPORTS CIFUtilitiesDefs =

BEGIN OPEN AltoDevice, BitBltDefs, CIFUtilitiesDefs, Graphics, InlineDefs, IODefs, JaMFnsDefs, KeyDefs, Real, Vector;

InitCedarGraphics: PUBLIC PROCEDURE =
	BEGIN
	screenbitmap _ ScreenBitmap[];
	ScreenBaseContext _ NewContext[AltoDevice.NewAltoDevice[screenbitmap]];
	ScreenBaseClipRectangle _
		[llx:1, lly:1, urx:screenbitmap.raster*16-1, ury:screenbitmap.height-1];
	SetFont[ScreenBaseContext, MakeFont["Helvetica"], 10];
	ScreenContext _ CurrentDisplayContext _ CopyContext[ScreenBaseContext];
	CurrentClipRectangle _ ScreenBaseClipRectangle; --This is always held in Base Coordinates
	ClippingOn _ TRUE;

	SetClipRect[ScreenBaseContext, ScreenBaseClipRectangle];
	SetMouseProc[JaMStream[], MouseToUser];
	END;

SetDisplayContext: PUBLIC PROCEDURE[dc: DisplayContext] =
	BEGIN
	IF ~ClippingOn THEN EnableClipping[];
	CurrentDisplayContext _ dc;
	END;

GetDisplayContext: PUBLIC PROCEDURE RETURNS[dc: DisplayContext] =
	BEGIN
	RETURN[CurrentDisplayContext];
	END;

GetBaseContext: PUBLIC PROCEDURE RETURNS[dc: DisplayContext] =
	BEGIN
	RETURN[ScreenBaseContext];
	END;

SetClipRectangle: PUBLIC PROCEDURE[cr: Rectangle] =
--set clip rectangle in current context
	BEGIN
	SetClipRect[CurrentDisplayContext, cr];
	CurrentClipRectangle _ MapRectangle[cr, CurrentDisplayContext,ScreenBaseContext];
	END;

SetClipRect: PROCEDURE[dc: DisplayContext, cr: Rectangle] =
--set clip rectangle in dc context
	BEGIN
	StartAreaPath[dc,FALSE];
	EnterPoint[dc,[cr.llx,cr.lly]];
	EnterPoint[dc,[cr.urx,cr.lly]];
	EnterPoint[dc,[cr.urx,cr.ury]];
	EnterPoint[dc,[cr.llx,cr.ury]];
	SetClipArea[dc];
	DestroyPath[dc];
	END;

GetClipRectangle: PUBLIC PROCEDURE RETURNS[cr: Rectangle] =
	BEGIN
	RETURN[MapRectangle[CurrentClipRectangle, ScreenBaseContext,CurrentDisplayContext]];
	END;

GetBaseClipRectangle: PUBLIC PROCEDURE RETURNS[cr: Rectangle] =
	BEGIN
	RETURN[MapRectangle[ScreenBaseClipRectangle, ScreenBaseContext,CurrentDisplayContext]];
	END;

DrawClipRectangle: PUBLIC PROCEDURE =
	BEGIN
	DrawRectOutline[ScreenBaseContext, CurrentClipRectangle];
	END;

ClearClipRectangle: PUBLIC PROCEDURE =
	BEGIN
	PushContext[CurrentDisplayContext];
		SetPaint[CurrentDisplayContext, erase];
		SetTexture[CurrentDisplayContext, black];
		DrawScreenArea[CurrentDisplayContext];
	PopContext[CurrentDisplayContext];
	END;

DrawRectangleOutline: PUBLIC PROCEDURE[cr: Rectangle] =
	BEGIN --draw it in BaseContext to get uniform thin lines
	SetClipRect[ScreenBaseContext, CurrentClipRectangle];
	DrawRectOutline[ScreenBaseContext,
		MapRectangle[cr, CurrentDisplayContext,ScreenBaseContext]];
	SetClipRect[ScreenBaseContext, ScreenBaseClipRectangle];
	END;

DrawRectOutline: PROCEDURE[dc: DisplayContext, cr: Rectangle] =
	BEGIN --draw cr in dc
	Graphics.MoveTo[dc, [cr.llx,cr.lly]];
	Graphics.DrawTo[dc, [cr.urx,cr.lly]];
	Graphics.DrawTo[dc, [cr.urx,cr.ury]];
	Graphics.DrawTo[dc, [cr.llx,cr.ury]];
	Graphics.DrawTo[dc, [cr.llx,cr.lly]];
	END;

MoveTo: PUBLIC PROCEDURE[x,y: REAL] =
	BEGIN
	SetClipRect[ScreenBaseContext, CurrentClipRectangle];
	Graphics.MoveTo[ScreenBaseContext,
		Map[CurrentDisplayContext, ScreenBaseContext, [x,y]]];
	SetClipRect[ScreenBaseContext, ScreenBaseClipRectangle];
--	Graphics.MoveTo[CurrentDisplayContext, [x,y]];
	END;

DrawTo: PUBLIC PROCEDURE[x,y: REAL] =
	BEGIN --draw it in BaseContext to get uniform thin lines
	SetClipRect[ScreenBaseContext, CurrentClipRectangle];
	Graphics.DrawTo[ScreenBaseContext,
		Map[CurrentDisplayContext, ScreenBaseContext, [x,y]]];
	SetClipRect[ScreenBaseContext, ScreenBaseClipRectangle];
	END;

Debugging: BOOLEAN _ TRUE;

EnableClipping: PUBLIC PROCEDURE =
	BEGIN
	IF Debugging THEN RETURN; --***Temporary
	IF ClippingOn THEN RETURN
	ELSE
	{	PopClipBox[CurrentDisplayContext];
		ClippingOn _ TRUE;
	};
	END;

DisableClipping: PUBLIC PROCEDURE =
--big kludge to turn off clipping -
-- PushClipBox with zero size box at center of clipping region
	BEGIN
	IF Debugging THEN RETURN; --***Temporary
	IF ~ClippingOn THEN RETURN
	ELSE
	{	cr: Rectangle _ GetClipRectangle[];
		c: Vec _ [(cr.llx + cr.urx)/2,
					(cr.lly + cr.ury)/2];
		box: BoundingBox _ [c,c,c,c];
		PushClipBox[CurrentDisplayContext, @box];
		ClippingOn _ FALSE;
	};
	END;

MapRectangle: PUBLIC PROCEDURE[rect1: Rectangle, cntxt1,cntxt2: DisplayContext]
		RETURNS[rect2: Rectangle] =
	BEGIN
--return rectangle which in cntxt2 generates same as rect1 does in cntxt1
	v0,v1: Vec;
	v0 _ Map[cntxt1,cntxt2, [rect1.llx,rect1.lly]];
	v1 _ Map[cntxt1,cntxt2, [rect1.urx,rect1.ury]];
	RETURN[[llx:MIN[v0.x,v1.x],lly:MIN[v0.y,v1.y], urx:MAX[v0.x,v1.x],ury:MAX[v0.y,v1.y]]];
	END;

--GetBaseContextRecord: PUBLIC PROCEDURE RETURNS[baseContext: DisplayContext] =
--	BEGIN
--get the base context RECORD
--	PushBaseContext[];
--	baseContext _ GetDisplayContext[]^;
--	PopDisplayContext[];
--	END;

SetUniformView: PUBLIC PROCEDURE[rfrom, rto: Rectangle] =
--Set up transform to map rectangles, but without introducing differential scaling
--Minimum scale factor is used, and centers will correspond
	BEGIN
	sx,sy,scale: REAL;
	dxfrom: REAL _ rfrom.urx-rfrom.llx;
	dyfrom: REAL _ rfrom.ury-rfrom.lly;
	dxto: REAL _ rto.urx-rto.llx;
	dyto: REAL _ rto.ury-rto.lly;
	IF dxfrom=0 OR dyfrom=0 OR dxto=0 OR dyto=0 THEN
		BEGIN
		WriteLine["Invalid scale factor"];
		RETURN;
		END;
	sx _ dxto/dxfrom;
	sy _ dyto/dyfrom;
	scale _ IF ABS[sx]<ABS[sy] THEN sx ELSE sy;
	Translate[CurrentDisplayContext, [(rto.urx+rto.llx)/2, (rto.ury+rto.lly)/2]];
	Scale[CurrentDisplayContext, [scale,scale]];
	Translate[CurrentDisplayContext, [-(rfrom.urx+rfrom.llx)/2, -(rfrom.ury+rfrom.lly)/2]];
	END;

ScreenParams: PUBLIC PROCEDURE
		RETURNS[base: LONG POINTER, widthWords, heightLines: CARDINAL] =
	BEGIN OPEN screenbitmap;
	RETURN[base, raster, height];
	END;

mousex: POINTER TO INTEGER = LOOPHOLE[424B];
mousey: POINTER TO INTEGER = LOOPHOLE[425B];

TrackBox: PUBLIC PROCEDURE[x,y: REAL, mouseButtons: KeyDefs.MouseButton] =
	BEGIN
	x0,y0: INTEGER;
	xs,ys: REAL;
	xori,yori,xold,yold,xnew,ynew: INTEGER;
	left,bottom,right,top: INTEGER;
	cr: Rectangle _ MapRectangle[GetClipRectangle[], CurrentDisplayContext,
			ScreenBaseContext];
	p: Vec;

	[x0,y0] _ ScreenOrigin[];
	left _ FixI[cr.llx];
	top _ FixI[screenbitmap.height - cr.lly]; --top means bigger y value in screen coords
	right _ FixI[cr.urx];
	bottom _ FixI[screenbitmap.height - cr.ury];
	IF Memory.long THEN
		BEGIN --D*
		bbt.ptrs _ long;
		bbt.dlbca _ screenbitmap.base;
		END
	ELSE
		BEGIN --Alto
		bbt.ptrs _ short;
		bbt.destalt _ HighHalf[screenbitmap.base]#0;
		bbt.unused _ HighHalf[screenbitmap.base];
		bbt.dbca _ LowHalf[screenbitmap.base];
		END;
	bbt.dbmr _ screenbitmap.raster;
	p _ Map[CurrentDisplayContext, ScreenBaseContext, [x,y]];
	xs _ p.x;
	ys _ screenbitmap.height - p.y;
	xold _ xori _ MAX[left,MIN[right,FixI[xs]]];
	yold _ yori _ MAX[bottom,MIN[top,FixI[ys]]];
	WHILE Mouse.buttons = mouseButtons DO
		xnew _ MAX[left,MIN[right,mousex^-x0]];
		ynew _ MAX[bottom,MIN[top,mousey^-y0]];
		InvertBox[xold,yori,xnew,yold];
		InvertBox[xori,yold,xnew,ynew];
		xold _ xnew; yold _ ynew;
	ENDLOOP;
	InvertBox[xori,yori,xold,yold];
	END;

InvertBox: PROCEDURE[x0,y0,x1,y1: INTEGER] =
	BEGIN
	dx,dy: INTEGER;
	IF (dx _ x1-x0)=0 OR (dy _ y1-y0)=0 THEN RETURN;
	bbt.dlx _ MIN[x0,x1];
	bbt.dty _ MIN[y0,y1];
	bbt.dw _ ABS[dx];
	bbt.dh _ ABS[dy];
	BitBltDefs.BITBLT[bbt];
	END;

MoveCursorTo: PUBLIC PROCEDURE[x,y: REAL] =
	BEGIN
	s: Vec _ ScreenToUser[CurrentDisplayContext, [x,y]];
	p: Vec _ UserToScreen[ScreenContext, s];
	x0,y0: REAL;
	[x0,y0] _ ScreenOrigin[];
	mousex^ _ FixI[p.x];
	mousey^ _ FixI[p.y + y0];
	END;

MouseToUser: PROCEDURE[x,y:INTEGER] =
	BEGIN
	x0,y0: INTEGER;
	p,p1: Vec;
	[x0,y0]_AltoDevice.ScreenOrigin[];
	p_[(x-x0)+0.5,(y-y0)+0.5]; -- the center of the pixel
	p1 _ Graphics.ScreenToUser[CurrentDisplayContext,p];
	PushReal[p1.x];
	PushReal[p1.y];
	END;

screenbitmap: AltoDevice.Bitmap;
ScreenContext: DisplayContext;
ScreenBaseContext: DisplayContext;
ScreenBaseClipRectangle: Rectangle;
CurrentDisplayContext: DisplayContext;
CurrentClipRectangle: Rectangle; --This is always held in Base Coordinates
ClippingOn: BOOLEAN _ TRUE;

bb:ARRAY [0..SIZE[BitBltDefs.BBTable]] OF UNSPECIFIED;
bbt:POINTER TO BitBltDefs.BBTable _ @bb[LOOPHOLE[@bb,CARDINAL] MOD 2];

bbt^ _ BitBltDefs.BBTable[
	ptrs: ,
	pad: 0,
	sourcealt: FALSE,
	destalt: ,
	sourcetype: gray,
	function: invert,
	unused: ,
	dbca: ,
	dbmr: ,
	dlx: ,	-- destination left x
	dty: ,	-- destination top y
	dw: ,
	dh: ,
	sbca: NIL,
	sbmr: 0,
	slx: 0,
	sty: 0,
	gray0: 177777B,
	gray1: 177777B,
	gray2: 177777B,
	gray3: 177777B,
	slbca: NIL,
	dlbca: NIL
];



END.
(635)\89b9B1115b17B582b17B123b17B95b14B91b16B214b11B292b16B144b20B147b17B94b18B235b20B312b15B274b6B302b6B331b14B173b15B411b12B388b20B191b14B766b12B241b8B787f1 6f0 466b9B226b74B21b33B13b102B1b11B