// F E D I T U T I L (PREPRESS)
//
//Bcpl/f FEditUtil.bcpl
//
// FEDIT -- font editor for low resolution fonts.

//Last modified September 28, 1980 3:28 PM by Lyle Ramshaw, PARC
// Added check in FlipGrid to eliminate a call to BitBlt with
// a negative value of topy. This means that Area now works even
// when Grid is on and DotSize divides 400.

//Modified September 17, 1980 12:04 PM by Kerry LaPrade, XEOS
// "Improved" handling when dotsize eq 1.

//Modified March 11, 1980 10:26 AM (by LaPrade)
//Modified January 24, 1980 11:33 AM (by LaPrade)
// PaintString uses rounded rather than truncated widths.
// Background tick-marks off screem warning messages removed.
//Modified January 8, 1980 10:16 AM (by LaPrade)
// Moved FEditMemoryAlloc, FindBoundingBox procedures to other files
//Modified August 28, 1978 5:05 PM by (by LaPrade)
//

get "AuxiliaryMenuDefs.d"
//get "BitBlt.d"
get "FEdit.DFS"
get "FeditNames.d"
//get "GoodFoo.d"
//get "IX.DFS"

// outgoing procedures
external
[
//FEditMemoryAlloc - Moved to FEdit.bcpl
// FindBoundingBox - Moved to FEditFile.bcpl
FlipGrid
PaintString
PaintWidthMarker
ReadCharBit
SetUpBBT
TurnGridOff
WriteCharBit
]

// outgoing statics
external
[
@gridIsDesired
@gridIsOn
]
static
[
@gridIsDesired = true //True if user wants grid to be displayed.
@gridIsOn //True if grid is displayed
]

// incoming procedures
external
[
//FEditFile
EditFindChar
//PauseForCR
WindowRead
WindowReadBlock

//PrepressUtil
RoundDp
]

// incoming statics
external
[
@backgroundView
@bits
@editBox
@editBoxXSize
@editBoxYSize
@FEditMenu
@foregroundView
@readBBT
@readBit
@showBox
@showBoxXSize
@showBoxYSize
@updateBox
@WidthMarker

//PrepressMenu1
@selectedButton
]

// internal statics
//static
// [
// ]

// File-wide structure and manifest declarations.

manifest
[
infinity = 1000 //Close enuf
]

// Procedures

//*********************************************************
let WriteCharBit(view, x, y, xExtent, yExtent; numargs na) = valof
//*********************************************************
[
DefaultArgs(lv na, 1, -1, -1, 1, 1)
let bbt, itFits = view>>VIEW.BBT, true
test na eq 1
ifso //Erase view.
[
if view eq foregroundView then FillBox(updateBox, white, 0)
TurnGridOff()

let eraseBBT = vec (size BBT/16 + 1)
eraseBBT = (eraseBBT + 1) & not 1
//SetUpBBT(BBT, sourceType, operation, dbca, dbmr, dlx, dty, dw, dh, sbca, sbmr, slx, sty, gray0, gray1, gray2, gray3)
SetUpBBT(eraseBBT, sGrayBlock, opErase, 0, 0, 0, 0, 606, 808, 0, 0, 0, 0, bbt>> BBT.gray↑0, bbt>> BBT.gray↑1)

BoxBitBlt(eraseBBT, editBox)
]

ifnot
[
// if x ls 0 % y ls 0 % x + xExtent gr view>>VIEW.nDotsX % y + yExtent gr view>>VIEW.nDotsY then return
if x ls 0 % y ls 0 % x + xExtent gr view>>VIEW.nDotsX % y + yExtent gr view>>VIEW.nDotsY then
[
itFits = false
if x gr view>>VIEW.nDotsX % y gr view>>VIEW.nDotsY % x + xExtent ls 0 % y + yExtent ls 0 then resultis itFits
]
if view eq foregroundView & view>>VIEW.dotSize ge 3 then
PartialFillBox(updateBox, flip, x, view>>VIEW.nDotsY - y - yExtent, xExtent, yExtent)
let temp = editBoxYSize - (y + yExtent) * (view>>VIEW.dotSize)
bbt>> BBT.dlx = x * (view>>VIEW.dotSize)
bbt>> BBT.dty = temp
bbt>> BBT.dw = xExtent * (view>>VIEW.dotSize)
bbt>> BBT.dh = yExtent * (view>>VIEW.dotSize)
temp = temp & 1
if temp then FixBBTGrayBlock(bbt)
BoxBitBlt(bbt, editBox, 0)
if temp then FixBBTGrayBlock(bbt)
]
resultis itFits
]

//Read a "bit" of a character.

//*********************************************************
and ReadCharBit(view, x, y) = valof
//*********************************************************
[
//Idea here is to bitblt a sample of the "bit" to a test area.

if x ls 0 % y ls 0 % x ge view>>VIEW.nDotsX % y ge view>>VIEW.nDotsY then resultis false

Zero(readBit, 2)
//Get appropriate gray block
//Note: BBT + 12 = beginning of gray block
MoveBlock(lv (readBBT!12), lv ((view>>VIEW.BBT)!12), 4)

let viewSpacing = view>>VIEW.dotSize
let temp1 = x * view>>VIEW.dotSize
let temp2 = editBoxYSize - (y + 1) * view>>VIEW.dotSize
readBBT>> BBT.slx = temp1
readBBT>> BBT.sty = temp2

temp1 = temp1 & 1
if temp1 then
for I = 12 to 15 do
// readBBT!I = (readBBT!I rshift 1) % (readBBT!I rshift 1)
readBBT!I = (readBBT!I lshift 1) % (readBBT!I rshift 1)

temp2 = temp2 & 1
if temp2 then FixBBTGrayBlock(readBBT)

BoxBitBlt(readBBT, 0, editBox)

resultis (readBit!0 ne 0) % (readBit!1 ne 0)
]

//*********************************************************
and FixBBTGrayBlock(BBT) be
//*********************************************************
//Important: assumes gray pattern repeats mod 2 in y direction.
[
MoveBlock(lv (BBT!12), lv (BBT!13), 2)
MoveBlock(lv (BBT!14), lv (BBT!12), 2)
]

//*********************************************************
and PaintWidthMarker(border,val; numargs na) be
//*********************************************************
[
// Set width markers in the margins of the edit area. First argument is
// border number to deal with. Second argument is value of marker.
// For borders 5 & 6, these are the markers that mark the point of the
//unsampled widths; in this case, value is in Alto units.

if border eq 0 then return
let color = nil
test na eq 2
ifso
[
PaintWidthMarker(border)//erase old one.
let otherBorder = selecton border into
[
case left: 5
case bottom: 6
default:0
]
PaintWidthMarker(otherBorder)//erase it.
color = black//Write
WidthMarker!border = val//Save new value
PaintWidthMarker(otherBorder, WidthMarker!otherBorder)
]
ifnot
[
color = white
val = WidthMarker!border//Turn off old value.
]
let Altoval = selecton border into
[
case left:
case right:
case bottom:
case top:
val * foregroundView>> VIEW.dotSize
case 5:
val + (WidthMarker!1 * foregroundView>>VIEW.dotSize)
case 6:
val + (WidthMarker!3 * foregroundView>>VIEW.dotSize)
]

let w, h = nil, nil
switchon border into
[
case left:
case right:
w = borderWidth
h = 1
endcase

case bottom:
case top:
w = 1
h = borderWidth
endcase

default:
w = 2
h = 2
endcase
]

if (border le 4) % backgroundView do
[
let x,y = 0,0
test valof
[
if Altoval ls 0 then resultis false
switchon border into
[
case left:
case right:
case 5:
if Altoval ge editBoxYSize then resultis false
y = 2 + editBoxYSize - Altoval
endcase

case 6:
y = borderWidth - 2
case bottom:
case top:
if Altoval ge editBoxXSize then resultis false
x = 3 + Altoval
endcase
]
resultis true
]
ifso
[
let box = selecton border into
[
case left: FEditMenu!bLeftBorder
case right:
case 5: FEditMenu!bRightBorder
case bottom: FEditMenu!bBottomBorder
case top:
case 6: FEditMenu!bTopBorder
default: 0
]
PartialFillBox(box, color, x, y, w, h)
]
ifnot
[
if na ls 2 then return
if border ge 5 then return
Ws("Warning: ")
switchon border into
[
case left: Ws("left-hand")
endcase

case right: Ws("right-hand")
endcase

// case 5: Ws("right-hand background")
// endcase

case bottom: Ws("bottom")
endcase

case top:Ws("top")
endcase

// case 6: Ws("top background")
]
Wl(" tick mark lies off screen!")
]
]
]

//*********************************************************
and FlipGrid() be
//*********************************************************
[
//First create one scan-line worth of grid, then bitblt it in a line
// at a time.
test foregroundView>>VIEW.dotSize gr 2
ifso
[
let squareSize = foregroundView>>VIEW.dotSize
let sourceBlock = vec 38 //Screen width in words
sourceBlock = (sourceBlock + 1) & not 1
Zero(sourceBlock, 38)
let indexBit = 0
for I = 0 to foregroundView>>VIEW.nDotsX do
[
let index = indexBit rshift 4
sourceBlock!index = (sourceBlock!index) % (bits!(indexBit & 17b))
indexBit = indexBit + squareSize
]

let gridBBT = vec (size BBT / 16)
gridBBT = (gridBBT + 1) & not 1
//SetUpBBT(BBT, sourceType, operation, dbca, dbmr, dlx, dty, dw, dh, sbca, sbmr, slx, sty, gray0, gray1, gray2, gray3)
SetUpBBT(gridBBT, sBitMap, opInvert, 0, 0, 0, editBoxYSize - 1, 606, 1, sourceBlock, 38)

for I = 0 to foregroundView>>VIEW.nDotsY do
[
if gridBBT>>BBT.dty ge 0 then BoxBitBlt(gridBBT, editBox)
gridBBT>> BBT.dty = gridBBT>> BBT.dty - squareSize
]
gridIsOn = not gridIsOn
]
ifnot
[
Wl("Dot size too small for grid.")
gridIsDesired = false
]
]

//*********************************************************
and TurnGridOff() be if gridIsOn then FlipGrid()
//*********************************************************


//*********************************************************
and PaintString(string) be
//*********************************************************
[
 //Paint a string on the display, using the edited character font
// as a source of characters.

let numCharactersShown = 0
let startXY = vec 1

until Endofs(keys) do Gets(keys)

until numCharactersShown eq string>>STRING.length do
[
let endIndex = ClipString(string, numCharactersShown + 1, startXY)
PaintClippedString(string, numCharactersShown + 1, endIndex, startXY)
if endIndex ge string>>STRING.length then break
numCharactersShown = endIndex - 1
unless (selectedButton eq 2) & GetConfirmation("Show more?") do break
]
]


//*********************************************************
and ClipString(string, beginIndex, startXY) = valof
//*********************************************************
[
//Compute width of string
let w = vec (size CharWidth / 16)
let widths = vec 1
let offsets = vec 1
let boundingBox = vec 1
let startPosition = vec 1; Zero(startPosition, 2)
let minStart = vec 1; Zero(minStart, 2)
let maxStart = vec 1; Zero(maxStart, 2)
let firstGoddamBit = vec 1; SetBlock(firstGoddamBit, infinity, 2)
let lastGoddamBit = vec 1; SetBlock(lastGoddamBit, -infinity, 2)
let stringIndex = nil //string>> STRING.length + 1

for I = beginIndex to string>> STRING.length do
[
let c = string>> STRING.char↑I
let s = EditFindChar(c, w, 1) //Look on scratch file
unless s do s = EditFindChar(c, w, 2) //Look on original file
if s then
[
offsets!0 = w>>CharWidth.XL
offsets!1 = w>>CharWidth.YB
boundingBox!0 = w>>CharWidth.W
boundingBox!1 = w>>CharWidth.H
for J = 0 to 1 do //0 for X, 1 for Y
[
let temp = nil
temp = startPosition!J + offsets!J
if temp ls firstGoddamBit!J then firstGoddamBit!J = temp
temp = temp + boundingBox!J
if temp gr lastGoddamBit!J then lastGoddamBit!J = temp

startXY!J = -firstGoddamBit!J + 1
]

if lastGoddamBit!1 - firstGoddamBit!1 ls showBoxYSize - 2 then
startXY!1 = (showBoxYSize - (lastGoddamBit!1 - firstGoddamBit!1)) / 2
if lastGoddamBit!0 - firstGoddamBit!0 gr showBoxXSize - 2 then resultis I

// widths!0 = @(lv w>>CharWidth.WX)
// widths!1 = @(lv w>>CharWidth.WY)
widths!0 = RoundDp(lv w>>CharWidth.WX)
widths!1 = RoundDp(lv w>>CharWidth.WY)
for J = 0 to 1 do //0 for X, 1 for Y
[
startPosition!J = startPosition!J + widths!J
if startPosition!J ls minStart!J then minStart!J = startPosition!J
if startPosition!J gr maxStart!J then maxStart!J = startPosition!J
]

//if maxStart!0 - minStart!0 gr showBoxXSize - 2 then resultis I
if maxStart!1 - minStart!1 gr showBoxYSize - 2 then resultis I
]
]
startXY!0 = (showBoxXSize - (lastGoddamBit!0 - firstGoddamBit!0)) / 2
resultis string>> STRING.length
]

//*********************************************************
and PaintClippedString(string, beginIndex, endIndex, startXY) be
//*********************************************************
[
FillBox(showBox, white, 0) //Erase showBox
let x = startXY!0
let y = startXY!1
let outline = showBox>>BOX.bits
let Xo = showBox>>BOX.xorigin + outline
//let Xc = showBox>>BOX.xcorner - outline
let Yc = showBox>>BOX.ycorner - outline
//Get dcb
let dcb = showBox>>BOX.dcb
let map = dcb>>DCB.bitmap
let width = dcb>>DCB.width

let p = vec 100
let w = vec CharWidthsize
for i = beginIndex to endIndex do
[
let c = string>> STRING.char↑i
let s = EditFindChar(c, w, 1)//Look on scratch file
unless s do s = EditFindChar(c, w, 2) //Look on original file
if s then
[
let xl = Xo + x + w>>CharWidth.XL
let yb = y + w>>CharWidth.YB
let adr = map + (Yc - yb) * width + xl / 16
let testdp = map + (outline + 2)* width
xl = xl rem 16
let b = WindowRead(s)//FHEAD
let hw = b<<FHEAD.hw//Words high.
let ns = b<<FHEAD.ns//Number of scan lines.
for i = 1 to ns do
[
if (x + w>>CharWidth.XL + i) ge showBoxXSize then break
let dp = adr
WindowReadBlock(s, p, hw)
for pc = 0 to hw - 1 do
for j = 0 to 15 do
[
if dp le testdp then break
if ((p!pc) & (bits!j)) ne 0 then
@dp = @dp % (bits!xl)
dp = dp - width
]
xl = xl + 1
if xl eq 16 then
[
xl = 0
adr = adr + 1
]
]
// x = x + @(lv w>>CharWidth.WX)
// y = y + @(lv w>>CharWidth.WY)
x = x + RoundDp(lv w>> CharWidth.WX)
y = y + RoundDp(lv w>> CharWidth.WY)
]
]
]