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

//Last modified September 16, 1980  5:13 PM by Kerry LaPrade:
//  "Improved" handling when dotsize eq 1.

//Modified June 13, 1980  10:13 PM by Lyle Ramshaw:
//  Added explicit dependence on dsp to call on ShowDisplayStream,
//  because of Junta

//Modified: March 26, 1980  11:48 AM (by LaPrade)

//Modified: December 18, 1979  1:58 PM (by LaPrade)
//  Stripped out loop stuff to FEditLoop.bcpl

//Date: December 18, 1979  1:29 PM (by LaPrade)

get "AuxiliaryMenuDefs.d"
get "FEdit.DFS"
get "FEditNames.d"

// outgoing procedure
external
   [
   FEdit
   ]

// incoming procedures
external
   [
   CompareIX
   GetPosRelative
   ReadIXTempFile
   WriteIXTempFile
   SetPosRelative
   
//FEDITFILE
   EditCharExists
   EditFindChar
   IndexACFile

//FEDITLOOP
   ClearEditWindow
   FEditLoop
   WriteCharCodes

//FEDITUTIL
   DPAD
   SetUpBBT

//PREPRESS
   PrePressWindowInit

//PREPRESSUTIL
   FSGetX
   FSPut
   IllCommand

//PREPRESSWINDOW
   WindowClose
   WindowCopy
   WindowGetPosition
   WindowRead
   WindowReadBlock
   WindowWriteBlock
   WindowSetPosition

//SCAN
   StrEq
   TypeForm
   ]

// incoming statics
external
   [
   @BackgroundFileName
   @bigfilename
   @dotsize
   @InputFileName

//FEDITFILE
   @DPzero		//Double-precision zero.
   @EbackgroundFile
   @EeditFile
   @EscratchFile	//EFILE structures for the files.
   @LastCharCodeWritten //State of the scratch file.
   @LastPos		//File pos where char began.
   @PreviousWPos	//File pos of current char previous to this edit
   @PreviousBPos
   @TrailerPos	//Position of -1 trailer in file.

//FEDITLOOP
   @backgroundOn
   @backgroundView
   @bits
   @currentCharacterWidths
   @currentCharacterCode
   @editBox
   @editBoxXSize
   @editBoxYSize
   @EFactorX
   @EFactorY
   @FEditMenu
   @foregroundView
   @readBBT
   @readBit
   @showBox
   @showBoxXSize
   @showBoxYSize
   @showTypeInString
   @UnsampledWX
   @UnsampledWY
   @updateBox
   @WidthMarker
   ]


manifest
   [
   memorySpaceNeeded =
      3 * (size BBT/16) + 2 + 2 * (size VIEW/16) + 1 + 128 + size CharWidth / 16
   ]

//Procedures

//*********************************************************
//let FEdit(noBackground,inputFile;numargs na) be
let FEdit() be
//*********************************************************
   [
   let FEditMenuBuffer = nil
   let FEditMenuStream = nil

//   FEditStart(noBackground,inputFile, na, lv FEditMenuBuffer, lv FEditMenuStream)
   FEditStart(lv FEditMenuBuffer, lv FEditMenuStream)
//   FEditLoop()
   EraseMenu(lv FEditMenuBuffer, lv FEditMenuStream)

   EFileFinish()			//Go finish off files.
   ]

//*********************************************************
//and FEditStart(noBackground,inputFile, na, lvFEditMenuBuffer, lvFEditMenuStream) be
and FEditStart(lvFEditMenuBuffer, lvFEditMenuStream) be
//*********************************************************
   [FEditStart
   until Endofs(keys) do Gets(keys)
   bits =
      (table
         [ 0;
         #100000; #40000; #20000;  #10000;
           #4000;  #2000;  #1000;    #400;
            #200;   #100;    #40;     #20;
             #10;     #4;     #2;      #1;    0
         ]
      ) + 1

//Initialize files.
//   let u = dotsize
//   if na ls 2 then
//      [
//      if bigfilename!0 eq 0 then IllCommand()
//         inputFile = 2	//Big file
//         BackgroundFileName = -1	//ACtemp
////         if (params&gotresolution) ne 0 then u = resolutionx		
//         if (params & gotresolution) ne 0 then
//            dotsize = resolutiony
////If /D or /E switch was read from command line, then
////  set dotsize accordingly
////Software sleuths: gotresolution comes from ix.dfs.  K.L.
//      ]

      let inputFile =
         (InputFileName>> STRING.length eq 0) ? -1, InputFileName
      //-1 means "ACtemp" in PrepressWindowInit()

//   let factor = EFileStart(noBackground, inputFile)
   let factor = EFileStart(BackgroundFileName>> STRING.length eq 0, inputFile)
//Initialize view parameters.
   EFactorX = factor
   EFactorY = factor

   test factor eq 0
   ifso factor = 10000
   ifnot
      [
      if (dotsize rem factor) ne 0 then
         [
         Wl("Background enlargement factor does not divide dotsize.")
         EFileFinish(); return
         ]
      if dotsize/factor ls 2 then
         [
         Wl("Dotsize too small or background enlargement too large")
         EFileFinish(); return
         ]
      ]

//Misc.
   WidthMarker = table [ 0; 2;2;2;2;0;0 ]  //Why in the hell these are the initial values is beyond me.  K.L.

//   let v = vec 127; v!0=0
//   previousShowString = v
//   let v = vec 127; v!0=0
//   showTypeInString = v
//   let v = vec (size CharWidth / 16)
//   currentCharacterWidths = v
//   widthsMode = false

//Get Menu
//   let FEditMenuBuffer = nil
//   let FEditMenuStream = nil
   GetMenu(lvFEditMenuBuffer, lvFEditMenuStream)
   FEditMenu = MenuData>>DATA.menu
   editBox = FEditMenu!bEditBox
   showBox = FEditMenu!bShowBox
   updateBox = FEditMenu!bUpdateBox
   FillBox(FEditMenu!bSymbolStrip, flip, 0)
   FillBox(FEditMenu!bOctalStrip, flip, 0)
   FillBox(FEditMenu!bFileStrip, flip, 0)
   FillBox(FEditMenu!bEditStrip, flip, 0)
   //FillBox(FEditMenu!bShowStrip, flip, 0)

   editBoxXSize = BoxDimensionX(editBox)
   editBoxYSize = BoxDimensionY(editBox)

   showBoxXSize = BoxDimensionX(showBox)
   showBoxYSize = BoxDimensionY(showBox)

//Get memory space for odds and ends.
//   let v = vec memorySpaceNeeded + 1
//   FEditMemoryAlloc(v, memorySpaceNeeded)
   let memory = FEditMemoryAlloc(memorySpaceNeeded)

//   SetUpView(foregroundView, dotsize, 052525b, 125252b)
//   SetUpView(backgroundView, dotsize/factor, 0, 52525b)
//   SetUpBBT(readBBT, sBitMapAndGrayBlock, opReplace, readBit, 1, 0, 0, 2, 2)
   
   let temp1, temp2, temp3 = 052525b, 125252b, 2
   if dotsize ls 2 then
      temp1, temp2, temp3 = -1, -1, 1

   SetUpView(foregroundView, dotsize, temp1, temp2)
   SetUpView(backgroundView, dotsize/factor, 0, not temp2)
 //SetUpBBT(BBT, sourcetype, operation, dbca, dbmr, dlx, dty, dw, dh)
   SetUpBBT(readBBT, sBitMapAndGrayBlock, opReplace, readBit, 1, 0, 0, temp3, temp3)

   if foregroundView>>VIEW.dotSize gr 3 then
      [
//      let magicXnum = (BoxDimensionX(updateBox) - foregroundView>>VIEW.nDotsX) / 2
//      let magicYnum = (BoxDimensionY(updateBox) - foregroundView>>VIEW.nDotsY) / 2

      //updateBox>>BOX.bits = 0
      updateBox>>BOX.xorigin = updateBox>>BOX.xorigin + (BoxDimensionX(updateBox) - foregroundView>>VIEW.nDotsX) / 2
      updateBox>>BOX.yorigin = updateBox>>BOX.yorigin + (BoxDimensionY(updateBox) - foregroundView>>VIEW.nDotsY) / 2
      updateBox>>BOX.xcorner = updateBox>>BOX.xorigin + foregroundView>>VIEW.nDotsX + 2 * updateBox>>BOX.bits - 1
      updateBox>>BOX.ycorner = updateBox>>BOX.yorigin + foregroundView>>VIEW.nDotsY + 2 * updateBox>>BOX.bits - 1

      //OutlineBox(updateBox, updateBox>>BOX.bits - 1)
      ]

   WriteCharCodes(currentCharacterCode)
//   changes = false
//   changesPending = false
//   gridIsOn = false
//   backgroundOn = true
//   WidthChanged = false
   ClearEditWindow()

//   ShowGrid()

//   EditLoop()
   FEditLoop()

   Free(sysZone, memory)

   ]FEditStart

//*********************************************************
and GetMenu(lvbuffer, lvstream) be
//*********************************************************
   [
   MenuData = 0	//Avoid conflicts with menu in other overlay
   let length = MenuSize() + 1
   //Ws("length = "); Wos(dsp, length); Wl("")
   @lvbuffer = FSGetX(length)
   @lvstream = CreateMenuDisplayStream(@lvbuffer, length - 1)
   ShowDisplayStream(@lvstream,DSbelow,dsp)
   ]

//*********************************************************
and SetUpView(view, squareSize, g0, g1) be
//*********************************************************
   [
   view>>VIEW.dotSize = squareSize
   view>>VIEW.nDotsX = editBoxXSize/squareSize
   view>>VIEW.nDotsY = editBoxYSize/squareSize

 //SetUpBBT(BBT, sourcetype, operation, dbca, dbmr, dlx, dty, dw, dh, sbca, sbmr, slx, sty, g0, g1)
   SetUpBBT(view>>VIEW.BBT, sGrayBlock, opInvert, 0, 0, 0, 0, squareSize, squareSize, 0, 0, 0, 0, g0, g1)
   ]

//*********************************************************
and EraseMenu(lvbuffer, lvstream) be
//*********************************************************
   [
   ShowDisplayStream(@lvstream, DSdelete)
   FSPut(@lvbuffer)
   ]

//Comments about the format of the ACedits file.  First comes the usual preamble
// stuff to an ACtemp file (i.e. read and written with ReadIXTempFile,...).  Then
// comes a collection of characters, followed by a -1 (end of the update file).
// Each character is the CharWidth structure (containing width goodies) followed
// by the bit map (in ACtemp format, i.e. FHEAD is first).
// The CharWidth structure may have H=HNonExCode, in which case
// we are to delete the character from the font.

//Start up all file aspects of the edit.
// NoBackground is true if we are not to use background.
// There are three files involved:
//	xxxx/B		Edit file.
//	ACedits		File of changes, deleted at end normally.
//	ACtemp		Background file.
// Returns reduction factor for background (0 if no background).

//*********************************************************
and EFileStart(NoBackground,inputFile) = valof [
//*********************************************************
   DPzero=table [ 0;0 ]

//Set up edit file.
//CROCK CROCK having to do with window stuff -- need better opening control
//Open read-only to be sure it exists:
   let s=PrePressWindowInit(inputFile, false)
   Closes(s)
//Now open read-write:
   s=PrePressWindowInit(inputFile)
   let fn=vec IXLName
   let ix=vec IXLMax
   ReadIXTempFile(s, fn, ix)      //Get info.
   EeditFile=IndexACFile(s, 3)

//Set up scratch file.
   let sc=nil
   [
      sc=PrePressWindowInit("ACedits", true)
//      if WindowEnd(sc) then break   //No previous version!
      if Endofs(sc) then break   //No previous version!
      unless GetConfirmation("Edits recorded during the last use of the EDIT command appear not to *nhave been merged into the edit file.  Do you wish to merge them?") do break
      Closes(sc)
      MergeEdits()         //Assumes editfile indexed.
      FSPut(EeditFile)      //No longer indexed
      EeditFile=IndexACFile(s, 2)   // so redo it
      TypeForm("Merge finished.*N")
   ] repeat
   EscratchFile=IndexACFile(sc,1)      //Index it.
   LastPos=table [ 0;0 ]   
   TrailerPos=table [ 0;0 ]
   PreviousWPos=table [ 0;0 ]
   PreviousBPos=table [ 0;0 ]
   LastCharCodeWritten=-1
   WriteIXTempFile(sc, fn, ix)      //Write header.
   WindowGetPosition(sc, TrailerPos)
//   WindowWrite(sc,-1)      //Write trailer.
   Puts(sc,-1)      //Write trailer.
//   WindowFlush(sc)         // and make sure on disk.
   CleanupDiskStream(sc)         // and make sure on disk.
	
//Set up ACtemp (background) file.
   EbackgroundFile = 0
   let factor = 0
//   unless NoBackground do
   unless NoBackground % dotsize ls 2 do
      [
      let cd = PrePressWindowInit(BackgroundFileName)
      let fnb = vec IXLName
      let ixb = vec IXLMax
      ReadIXTempFile(cd, fnb, ixb)
      test
         ix>>IX.resolutionx eq ixb>>IX.resolutionx &
             ix>>IX.resolutiony eq ixb>>IX.resolutiony &
             StrEq(lv fn>>IXN.Name, lv fnb>>IXN.Name)
      ifso
//         factor=(ixb>>IX.siz+1)/ix>>IX.siz
         factor = (ixb>> IX.siz + 5) / ix>> IX.siz
      ifnot
         [
         TypeForm("Illegal background file*N")
         factor = 1
         ]
      EbackgroundFile=IndexACFile(cd, 2)   //Index it.
      ]
   resultis factor
]

//*********************************************************
and EFileFinish() be [
//*********************************************************
	Closes(EscratchFile>>EFILE.window)
	MergeEdits()
	let s=EeditFile>>EFILE.window
	WindowSetPosition(s, DPzero)
	let fn=vec IXLName
	let ix=vec IXLMax
	ReadIXTempFile(s, fn, ix)
	DPAD(lv ix>>IX.sa, lv ix>>IX.len)
//	DoubleAdd(lv ix>>IX.sa, lv ix>>IX.len)
	WindowClose(s, lv ix>>IX.sa)
	]

and

//MergeEdits -- merge the edited characters recorded in the scratch (ACedits) file
// with the original version in the edit file.  Save the results on a
// new edit file; delete the ACedits file.
// Assumes edit file is open and indexed. Leaves edit file open,
// but index will have been destroyed.


//*********************************************************
MergeEdits() be [
//*********************************************************
	let exists=vec 256
	Zero(exists, 256)	//0 => not mentioned
	let scd=EeditFile>>EFILE.window
	WindowSetPosition(scd, DPzero)
	let fn=vec IXLName
	let ix=vec IXLMax
	ReadIXTempFile(scd, fn, ix)

	let scr=PrePressWindowInit("ACedits", false)
	unless scr do return
//Build an index for the ACedits file.
	let a=IndexACFile(scr, 1)		//Just get dummy entries.
	let fne=vec IXLName
	let ixe=vec IXLMax
	ReadIXTempFile(scr, fne, ixe)		//Read header.
	unless StrEq(lv fn>>IXN.Name, lv fne>>IXN.Name) &
		CompareIX(ix, ixe) then
		[
		TypeForm("ACedits and ",bigfilename," do not match! Update aborted.*N")
		finish
		]

	let edited=false
		[
		let c = Gets(scr)		//Char code.
		if c eq -1 then break
	         unless edited do
			Wl("Merging ACEdits file into original file.")
		edited=true
//	         Wl("Merging ACEdits file into original file.")
		let n=c-a>>EFILE.bc
		WindowGetPosition(scr, n*2+a>>EFILE.wp) //Width pos.
		let w=vec CharWidthsize
		WindowReadBlock(scr, w, CharWidthsize)
		exists!c=(w>>CharWidth.H eq HNonExCode)? -1,1
		WindowGetPosition(scr, n*2+a>>EFILE.bp)
		let b=WindowRead(scr)
		let d=vec 1; d!0=0; d!1=b<<FHEAD.ns*b<<FHEAD.hw+1
		SetPosRelative(scr, d, n*2+a>>EFILE.bp)
		] repeat
	EscratchFile=a

if edited then [			//Some edited chars!
	let bc,ec=255,-1
	for c=0 to 255 do
		[
		if (exists!c eq 0 & EditCharExists(c, 2)) %
			exists!c eq 1 then
		   [
		   if c ls bc then bc=c
		   if c gr ec then ec=c
		   ]
		]
	ixe>>IX.bc=bc		//Update char ranges.
	ixe>>IX.ec=ec
	
//Now build new edit file.
	let nc=ec-bc+1
	let AC=FSGetX(nc*2)
	SetBlock(AC, -1, nc*2)
	let WD=FSGetX(nc*CharWidthsize)
	Zero(WD, nc*CharWidthsize)
	let p=WD
	for i=1 to nc do [ p>>CharWidth.H=HNonExCode; p=p+CharWidthsize ]

	let sout=PrePressWindowInit(0)	//Scratch file!
	WriteIXTempFile(sout, fne, ixe)
	WindowGetPosition(sout, lv ixe>>IX.sa)
	WindowWriteBlock(sout, WD, nc*CharWidthsize)	//dummy
	let off=vec 1
	WindowGetPosition(sout, off)		//Offset
	WindowWriteBlock(sout, AC, nc*2)

	for c=bc to ec do
		[
		let w=vec CharWidthsize
		let a=EditFindChar(c, w, 1)		//Look on scratch file.
		if a eq 0 then
			a=EditFindChar(c, w, 2)	//Look on original ACtemp file.
		if a then
			[			//Write it out!
			MoveBlock(WD+(c-bc)*CharWidthsize,w,CharWidthsize)
			if w>>CharWidth.H ne HNonExCode then
			[
			GetPosRelative(sout, off, AC+(c-bc)*2)
			let b=WindowRead(a) //FHEAD
//			WindowWrite(sout, b)
			Puts(sout, b)
			let d=vec 1; d!0=0; d!1=b<<FHEAD.ns*b<<FHEAD.hw
			WindowCopy(a, sout, d)	//Copy encoding.
			]
			]
		]

	Closes(scr)		//ACedits.
	FSPut(EscratchFile)

	let tl=vec 1
	WindowGetPosition(sout, tl)		//Total length
	GetPosRelative(sout, lv ixe>>IX.sa, lv ixe>>IX.len) //get length
	WindowSetPosition(sout, DPzero)
	WriteIXTempFile(sout, fne, ixe)
	WindowWriteBlock(sout, WD, nc*CharWidthsize)
	WindowWriteBlock(sout, AC, nc*2)
	FSPut(AC); FSPut(WD)
	WindowSetPosition(sout, DPzero)
	WindowSetPosition(scd, DPzero)
//Critical section:::::
	WindowCopy(sout, scd, tl)		//Copy entire scratch
					// file to new edit file.
]					//Some edited chars.
	DeleteFile("ACedits")
//Done :::::

]

//Utilities....

//*********************************************************
and FEditMemoryAlloc(memorySpaceNeeded) = valof
//*********************************************************
   [
   let memory = Allocate(sysZone, memorySpaceNeeded)
   let memorySpace = memory
   Zero(memorySpace, memorySpaceNeeded)

   foregroundView = memorySpace
   memorySpace = memorySpace + (size VIEW/16)

   backgroundView = memorySpace
   memorySpace = memorySpace + (size VIEW/16)

//Make even
   memorySpace = (memorySpace + 1) & not 1

   foregroundView>>VIEW.BBT = memorySpace
   memorySpace = memorySpace + (size BBT/16)	//Still even

   backgroundView>>VIEW.BBT = memorySpace
   memorySpace = memorySpace + (size BBT/16)	//Still even

   readBBT = memorySpace
   memorySpace = memorySpace + (size BBT/16)	//Still even

   readBit = memorySpace
   memorySpace = memorySpace + 2	//Still even

   showTypeInString = memorySpace
   memorySpace = memorySpace + 128

   currentCharacterWidths = memorySpace
   memorySpace = memorySpace + size CharWidth / 16

   resultis memory  //So that it can be Free()ed later.
   ]