// diablofinfo.sr

// Last modified October 25, 1979  6:45 PM by Taft


get "BRAVO1.DF"
get "CHAR.DF"
get "ST.DF"
get "MSG.DF"
get "DIABLO.DF"
get "COM.DF"
get "HARDCOPY.DF"


// Outgoing Procedures

external	[
	FinfoToDiablo
	MoveX
	PositionYd
	]


// Outgoing Statics

external	[
	vxwChuldiablo
	vxDiablo
	]


// Incoming Procedures

external	[
	ratio
	DiabloMoveXd
	errhlta
	DiabloMoveYd
	DiabloPrintChar
	]


// Incoming Statics

external	[
	vxdDiablo
	vydDiablo
	rgfinfo
	vmaccr
	rgxw
	msgtbl
	look1std
	look2std
	]


// Local Statics

static	[
	vxDiablo
	vyDiablo
	vxwChuldiablo
	]


// Local Structures

// structure


// Local Manifests

manifest	[
	chulDiablo = #137		// get from font width description
	dydItalic = 2
	cprintBold = 3
	]


// D X D   F R O M   D X   M I C A S

let DxdFromDxMicas(dx) = valof
[
let fsign = dx ls 0
let dxd = (ratio((fsign ? -dx, dx), 2 * mictodmlt, mictoddiv) + 1) rshift 1
resultis (fsign ? -dxd, dxd)
] // end DxdFromDxMicas


// D Y D   F R O M   D Y   P O I N T S

and DydFromDyPoints(dy) = valof
[
let fsign = dy ls 0
let dyd = (ratio((fsign ? -dy, dy), 2 * pttodmlt, pttoddiv) + 1) rshift 1
resultis (fsign ? -dyd, dyd)
] // end DydFromDyPoints


// M O V E   X

and MoveX(dx) be
[
vxDiablo = vxDiablo + dx
// if vxDiablo ls 0 % vxDiablo ge vxEdgeofpage then errhlt("mxb")
DiabloMoveXd(DxdFromDxMicas(vxDiablo) - vxdDiablo)
] // end MoveX


// P O S I T I O N   Y D

and PositionYd(yd) be
[
if yd ls 0 % yd ge ydMax then errhlta(203)
DiabloMoveYd(yd - vydDiablo)
] // end PositionYd


// F I N F O   T O   D I A B L O

and FinfoToDiablo(fm, cp, xFirst, xLast, yd) = valof
[
let cchPgbrk = 0
if (rgfinfo ! (vmaccr-1))<<FINFO.char eq chcr then
	[
	vmaccr = vmaccr-1
	xLast = xLast - rgxw ! vmaccr
	]
PositionYd(yd)
if vmaccr eq 0 then resultis 0
let ofsetd = 0
let fBackwards = vxDiablo gr (xFirst + xLast+1) rshift 1

let tfmsg = msgtbl
// let fOvstrikePrev = false
// let crFirstOvstrike = nil
// let xwOvstrike = nil
for tcr = 0 to vmaccr-1 do
	[
	let tfinfo = rgfinfo ! tcr
	if tfinfo<<FINFO.newmsg then
		tfmsg = tfmsg + 2
//	let fOvstrike = (tfmsg>>FMSG.look1)<<LOOK1.ovstrike ne 0
//	test fOvstrike ifso
//		test fOvstrikePrev ifnot
//			[
//			crFirstOvstrike = tcr
//			xwOvstrike = rgxw ! tcr
//			]
//		ifso	xwOvstrike = xwOvstrike + rgxw ! tcr
//	ifnot	if fOvstrikePrev then
//			[
//			xwOvstrike = xwOvstrike + rgxw ! tcr
//			for ttcr = crFirstOvstrike to tcr do
//				rgxw ! ttcr = xwOvstrike
//			]
//	fOvstrikePrev = fOvstrike
	]
let tfmsgCrMinus1 = tfmsg		// msg belonging to cr = vmaccr - 1
tfmsg = msgtbl			// msg belonging to cr = 0 - 1
let tfmsgdefault = vec 1; tfmsgdefault!0 = look1std; tfmsgdefault!1 = look2std

let cr = (fBackwards ? vmaccr-1, 0)
MoveX((fBackwards ? xLast+1, xFirst) - vxDiablo)
let fNewmsg = true
let finfoOld = 0
let look1Old = 0
let cprint = 1
let ch = nil
let xw = nil
let xwLeftHalf = nil
let xwRightHalf = nil
let xwResidue = 0
let dxMove = nil
let look1 = nil
let look2 = nil
while cr ge 0 & cr ls vmaccr do
	[
	let finfo = rgfinfo ! cr
	let finfoTrans = nil

	test fBackwards ifso
		[
// this really needs a few words:
// assume tfmsgCrMinus1 is good, i.e. really was the msg belonging to the cr 1 less than previous iteration -- then it must be the right msg for this iteration (since we're going backwards) -- so use it
		if tfmsg ne tfmsgCrMinus1 then
			[
			tfmsg = tfmsgCrMinus1
			fNewmsg = true
			]
// now, if this cr has a different msg than the cr one less than it (newmsg bit set), then what we want to do is find that other msg for tfmsgCrMinus1
		if finfo<<FINFO.newmsg then
			tfmsgCrMinus1 = tfmsgCrMinus1 - 2
		]
	ifnot	[
// forward case is straightforward (by comparison anyway) -- remember old msg, inc if necessary for new
		tfmsgCrMinus1 = tfmsg
		if finfo<<FINFO.newmsg then
			[
			tfmsg = tfmsg + 2
			fNewmsg = true
			]
		]
// one last tweak:
	if tfmsgCrMinus1 eq msgtbl then
		tfmsgCrMinus1 = tfmsgdefault

	if fNewmsg then
		[
		finfoOld = 0
		look1 = tfmsg>>FMSG.look1
		look2 = tfmsg>>FMSG.look2
		let look1Trans = not look1Old & look1
		look1Old = look1
		if look1<<LOOK1.vanish then
			goto nextcr
		let ofsetNew = look2<<LOOK2.ofset
		let ofsetdNew = DydFromDyPoints(look2<<LOOK2.ofsetsgn ?
			ofsetNew % ofsetsgnext, ofsetNew)
		if ofsetdNew ne ofsetd then
			[
			DiabloMoveYd(ofsetdNew-ofsetd)
			ofsetd = ofsetdNew
			]
		if look1Trans<<LOOK1.italic then
			[
			let look1mask = 0
			look1mask<<LOOK1.italic = true
			look1mask<<LOOK1.ovstrike = true
			let look2mask = 0
			look2mask<<LOOK2.ofset = true
			let txw = XwLookAhead(cr, tfmsg, fBackwards, 0, look1mask, look2mask)
			MoveX((fBackwards ? -xwResidue, xwResidue))
			xwResidue = 0
			DrawLine(txw, fBackwards)
			DiabloMoveYd(-dydItalic)
			DrawLine(txw, not fBackwards)
			DiabloMoveYd(dydItalic)
			]
		cprint = (look1<<LOOK1.boldface ? cprintBold, 1)
		if look2<<LOOK2.fun ne 0 then
			cprint = 0
		fNewmsg = false
		]
	finfoTrans = not finfoOld & finfo
	finfoOld = finfo
	if finfoTrans<<FINFO.lowbar then
		[
		MoveX((fBackwards ? -xwResidue, xwResidue))
		xwResidue = 0
		let xOld = vxDiablo
		let finfomask = 0
		finfomask<<FINFO.lowbar = true
//		finfomask<<FINFO.ovstrike = true
		let look2mask = 0
		look2mask<<LOOK2.ofset = true
		DrawLine(XwLookAhead(cr, tfmsg, fBackwards, finfomask, 0, look2mask), fBackwards)
		MoveX(xOld - vxDiablo)
		]
//	handle other bars bits in similar fashion

	ch = finfo<<FINFO.char
	if ch eq chpgbrk then cchPgbrk = cchPgbrk + 1

	xw = rgxw ! cr
	xwLeftHalf = xw rshift 1
	xwRightHalf = xw - xwLeftHalf
//	if (tfmsgCrMinus1>>FMSG.look1)<<LOOK1.ovstrike then
//		xwLeftHalf = 0
//	if look1<<LOOK1.ovstrike then
//		xwRightHalf = 0
	dxMove = xwResidue + (fBackwards ? xwRightHalf, xwLeftHalf)
	MoveX((fBackwards ? -dxMove, dxMove))
	xwResidue = (fBackwards ? xwLeftHalf, xwRightHalf)

	if (finfo<<FINFO.space eq 0) & ch ne chsp & ch ne chpgbrk then
		for i = 1 to cprint do
			[
			test ch eq $_ ifso
				[
//			kluge for missing backarrow character
				DiabloPrintChar($-)
				DiabloPrintChar($<)
				]
			ifnot
				DiabloPrintChar(ch)
			]

nextcr:
	cr = cr + (fBackwards ? -1, 1)
	]
if ofsetd ne 0 then DiabloMoveYd(-ofsetd)
resultis cchPgbrk
] // end FinfoToDiablo


// X W   L O O K   A H E A D

and XwLookAhead(cr, fmsg, fBackwards, finfomask, look1mask, look2mask) = valof
[
let xw = 0
let finfo = rgfinfo ! cr
let finfoFirst = finfo & finfomask
let look1First = fmsg>>FMSG.look1 & look1mask
let look2First = fmsg>>FMSG.look2 & look2mask
while (finfo & finfomask) eq finfoFirst &
	(fmsg>>FMSG.look1 & look1mask) eq look1First &
	(fmsg>>FMSG.look2 & look2mask) eq look2First do
	[
	xw = xw + rgxw ! cr
	if fBackwards & finfo<<FINFO.newmsg then
		fmsg = fmsg - 2
	cr = cr + (fBackwards ? -1, 1)
	if cr ls 0 % cr ge vmaccr then break
	finfo = rgfinfo ! cr
	if not fBackwards & finfo<<FINFO.newmsg then
		fmsg = fmsg + 2
	]
resultis xw
] // end XwLookAhead


// D R A W   L I N E

and DrawLine(xwToFill, fBackwards) be
[
// if xwToFill ls vxwChuldiablo then errhlt("drl")
let dxMove = vxwChuldiablo rshift 1
let dxMoveLast = vxwChuldiablo - dxMove
while xwToFill ge vxwChuldiablo do
	[
	MoveX((fBackwards ? -dxMove, dxMove))
	DiabloPrintChar(chulDiablo)
	dxMove = vxwChuldiablo
	xwToFill = xwToFill - vxwChuldiablo
	]
if xwToFill gr 0 then
	[
	MoveX((fBackwards ? -xwToFill, xwToFill))
	DiabloPrintChar(chulDiablo)
	]
MoveX((fBackwards ? -dxMoveLast, dxMoveLast))
] // end DrawLine