/*
	Character editor for Epson graphic fonts
			Greg Lee, Nov '83.
*/

#include <bdscio.h>
#include <hardware.h>

#define WYSE	0

#define FF 0x0c		/* formfeed character, or zero if not supported */
#define	FTSIZE 	9984	/* was 7936 = 62 recs * 128 */
#define MAXLINE 137
#define PICA 24


/* masks for mode bits */
#define ELITE	 0x01
#define PRPTNL	 0x02
#define CMPRSSD  0x04
#define EMPHSZD  0x08
#define DBLSTRK  0x10
#define EXPNDD	 0x20
#define UNDRLN	 0x40
#define ITALIC	 0x80
/*	So that's b0-b7; b8,b9,b10 are used for the
	current graphics font, which is 'fo'-1.		*/
#define SUPSCRPT 0x0800
#define SUBSCRPT 0x1000
#define BENT	 0x2000
#define TALL	 0x4000
#define IGNORE	 0x8000
/*	All bits are committed				*/


#define TOPROW  0
#define	BOTROW  23
#define	LEFTCOL  0
#define	RIGHTCOL  79

#if WYSE
#define BLACK	'1'
#define BLUE	'2'
#define GREEN	'3'
#define CYAN	'4'
#define RED	'5'
#define MAGENTA '6'
#define YELLOW	'7'
#define WHITE	'8'

#define UPPRDOT	','
#define LOWRDOT	'-'
#define BOTHDOT '7'
#define NODOT	' '
#endif

struct _ini
{	char fill1[72];	/* 200-247H	*/
	char hite, wid;
	char clead1[9], clead2[5], ctrail[5];
	char cb4lfg, linoff, coloff, ascur;	/* 25DH-260H	*/
	char fill2[12];	/* 261H-26CH	*/
	char erascr[7];	/* 26DH-273H	*/
	char fill3[12]; /* 274H-27FH	*/
};
struct _ini ei;

char	cmd, currch, edfnum, cch, cbyte, cbyteo, screen, mxflag;
int	col, row, currlen, currfont;

char	ckeep[6][80], gxoff, gyoff, ib;

int gcnt, glen;	char gbuf[2000];
int colno;	char sbuf[MAXLINE];

int i, fd;
char ftname[30], ftname2[30], *fname;
char *gets(), *strcat();


char  duplflag, ovlflag, ftlen[128];
int fix[128];
char  ft[FTSIZE];

char  ftlen2[128];
int fix2[128];
char ft2[FTSIZE];


main(argc,argv)
char **argv;
{
	setup();

	if (argc-1)
	 {
		fname = *++argv;
		argc--;
		strcpy(ftname, fname);
		strcat(ftname,".FN2");
	 }
	if (argc-1)
	 {
		fname = *++argv;
		argc--;
		strcpy(ftname2, fname);
		strcat(ftname2,".FN2");
	 }

	clrscrn();
	openwork();
	tokeep();
	scinit();
	cmd = '\\';
  While (cmd != 'x')
     { 
	switch (cmd) {
	case 'e': tokeep();
		  edscr();
		  fromkeep();
		  clrscrn();
		  scinit();
		  break;
	case 's': savefnt(); break;
	case 'g': message("Get character: ");
		  currch = conin();
#if WYSE
		  chkdupl();
#endif
		  if (currch > ' ') conout(currch);
		  edfnum = currch;
		  tokeep();
		  scinit();
		  break;
	case 't': gstr();
		  break;
	case 'T': mxflag = TRUE;
		  gstr();
		  mxflag = FALSE;
		  break;
	case 'z': setmem(ckeep, 6*80, 0);
		  /* currlen = 0; */
		  fromkeep();
		  break;

	case 'c': message("Copy to character: ");
		  cch = currch;
		  currch = conin();	conout(currch);
		  fromkeep();
		  currch = cch;
		  scinit();
		  break;
	case 'w': message("New Width:  ");
		  scanf("%d", &currlen);
		  if (currlen < 0) currlen = 0;
		  fromkeep();
		  scinit();
		  break;
	case 'p': message("Test phrase: ");
#if WYSE
		  color(GREEN,WHITE); gets(sbuf); color(BLACK,WHITE);
#else
		  gets(sbuf);
#endif
		  scinit();
		  break;
	case 'n': if (currfont)
		  {	message("New font 2 name: ");
		  	gets(ftname2); /* to upper */
		  	strcat(ftname2,".fn2");
		  }
		  else
		  {	message("New font 1 name: ");
		  	gets(ftname); /* to upper */
		  	strcat(ftname,".fn2");
		  }
		  scinit();
		  break;
	case 'o': loadft();
		  tokeep();
		  scinit();
		  break;
	case 'q': screen = !screen;
		  break;
	case '1': currfont = FALSE;
		  chkdupl();
		  prompt();
		  break;
	case '2': if (!ovlflag)
		  {	currfont = TRUE;
			prompt();
		  }
		  chkdupl();
		  break;
	case 'r': rdedf();
		  break;
	case 'd': wtedf(TRUE);
		  break;
	case 'D': wtedf(FALSE);
		  break;
	case 'm': modeset();
		  clrscrn();
		  scinit();
		  break;

	default:  break;
	} /* End Switch */

   gxy(0, 11);
   cmd = key();
   } /* End while */


	gxy(0,19);

}  /* End main */


message(say)
char *say;
{
	if (!screen) return;
	gxy(2,20);
#if WYSE
	color(CYAN,WHITE); puts(say); color(BLACK,WHITE);
#else
	puts(say);
#endif
}

dstrans(upper)
char upper;
{	char c;
	int i;

	for (i = 0; c = sbuf[i]; i++) sbuf[i] = dtrans(c,upper);
}

gstr()
{	int i;

	if (!*sbuf) return;

	chkdupl();

	if (duplflag) dstrans(TRUE);

	eschr('@');
	eschr('U'); echr('1');
/*	eschr('s'); echr('1');	*/
/*	eschr('3'); echr(1);	*/

	gpass(0); gpass(1); gpass(2);

	if (duplflag)
	{	dstrans(FALSE);
		ecrl216(24-3);
		gpass(0); gpass(1); gpass(2);
		dstrans(TRUE);
	}

	ecrl216( 3*(7+2) );
	colno = 0;
	glen = 0;
}



gpass(pass)
int pass;
{	int i;

	gcnt = 0;
	setmem(gbuf, 2000, 0);

	for (i = 0; sbuf[i]; i++) gchr(i, pass);
	gcnt += 7;	/* kern for italic in last col */

	if (mxflag)
	{
		eschr('L'); echr((gcnt/2) % 256); echr((gcnt/2)/256);
		for (i = 0; i < gcnt; i++)
		 if (!(i % 2)) echr(gbuf[i] | gbuf[i+1]);
		ecrl216(1);
		return;
	}

	eschr('Z'); echr(gcnt % 256); echr(gcnt/256);
	for (i = 0; i < gcnt; i++)
	 if (i % 2) echr ('\0');	else echr(gbuf[i]);
	ecrl216(0);

	eschr('Z'); echr(gcnt % 256); echr(gcnt/256);
	for (i = 0; i < gcnt; i++)
	 if (i % 2) echr(gbuf[i]);	else echr('\0');
	ecrl216(1);
}




gchr(ix,pass)
int ix, pass;
{	int len, i, cbase;
	char c;

	if (gcnt > 1920) return;

	c = sbuf[ix];

	if (currfont)
	{
		len = ftlen2[c];
		cbase = fix2[c] + pass*len;
	}
	else
	{
		len = ftlen[c];
		cbase = fix[c] + pass*len;
	}

	for (i = cbase; i < cbase + len; i++)
		if (currfont)
			gbuf[gcnt++] = ft2[i];
		else	gbuf[gcnt++] =  ft[i];
	gcnt += 3; /* CS */
}



ecrl216(n)
int n;
{	echr('\r');
	if (!n) return;

	eschr('J'); echr(n);

	/* while(n--) echr(10);*/
}


eschr(c)
char c;
{	echr(ESC);	echr(c);
}


echr(c)
char c;
{
	bios(5,c);
}


loadft()
{	int fdft, i, ftrecs;

  if (currfont)
  {
	if ((fdft = open(ftname2,0)) == ERROR)
		{message("no font"); return;}
	if (read(fdft, fix2, 2) != 2)
		{message("bad font"); return;}

	/* only read enough of the font to get info for char's
		up to ascii nul (which is not used)		*/
	ftrecs = (fix2[127]+127)/128;

	if (read(fdft, ft2, ftrecs) != ftrecs)
		{message("bad font"); return;}
	fabort(fdft);
	for (i = 1; i < 127; i++)
		ftlen2[i] = (fix2[i+1] - fix2[i])/3;
  }
  else
  {
	if ((fdft = open(ftname,0)) == ERROR)
		{message("no font"); return;}
	if (read(fdft, fix, 2) != 2)
		{message("bad font"); return;}

	/* only read enough of the font to get info for char's
		up to ascii nul (which is not used)		*/
	ftrecs = (fix[127]+127)/128;

	if (read(fdft, ft, ftrecs) != ftrecs)
		{message("bad font"); return;}
	fabort(fdft);
		if (ftrecs > FTSIZE/128) ovlflag = TRUE;
	for (i = 1; i < 127; i++)
		ftlen[i] = (fix[i+1] - fix[i])/3;
  }
	chkdupl();

}



openwork()
{	int fdft, i, ftrecs;

	setmem(ft, FTSIZE, 0);
	setmem(fix, 128, 0);
	setmem(ft2, FTSIZE, 0);
	setmem(fix2, 128, 0);

	if ((fdft = open(ftname,0)) != ERROR)
	{
		if (read(fdft, fix, 2) != 2)
		{puts("bad font"); exit(ERROR);}

	/* only read enough of the font to get info for char's
		up to ascii nul (which is not used)		*/
	ftrecs = (fix[127]+127)/128;

		if (read(fdft, ft, ftrecs) != ftrecs)
		{puts("bad font"); exit(ERROR);}
		fabort(fdft);
		if (ftrecs > FTSIZE/128) ovlflag = TRUE;
	}
	for (i = 1; i < 127; i++)
		ftlen[i] = (fix[i+1] - fix[i])/3;
	if (ovlflag) return;

	if ((fdft = open(ftname2,0)) != ERROR)
	{
		if (read(fdft, fix2, 2) != 2)
		{puts("bad font"); exit(ERROR);}

	/* only read enough of the font to get info for char's
		up to ascii nul (which is not used)		*/
	ftrecs = (fix2[127]+127)/128;

		if (read(fdft, ft2, ftrecs) != ftrecs)
		{puts("bad font"); exit(ERROR);}
		fabort(fdft);
	}
	for (i = 1; i < 127; i++)
		ftlen2[i] = (fix2[i+1] - fix2[i])/3;
	chkdupl();
}

savefnt()
{	int fdft, i, ftrecs;

  if (currfont)
  {
	if ((fdft = creat(ftname2)) == ERROR)
		{message("can't save"); return;}
	if (write(fdft, fix2, 2) != 2)
		{message("save error"); return;}

	/* only write enough of the font to get info for char's
		up to ascii nul (which is not used)		*/
	ftrecs = (fix2[127]+127)/128;

	if (write(fdft, ft2, ftrecs) != ftrecs)
		{message("save error"); return;}
	if (close(fdft) == ERROR)
		message("can't close");
  }
  else
  {
	if ((fdft = creat(ftname)) == ERROR)
		{message("can't save"); return;}
	if (write(fdft, fix, 2) != 2)
		{message("save error"); return;}

	/* only write enough of the font to get info for char's
		up to ascii nul (which is not used)		*/
	ftrecs = (fix[127]+127)/128;

	if (write(fdft, ft, ftrecs) != ftrecs)
		{message("save error"); return;}
	if (close(fdft) == ERROR)
		message("can't close");
  }


}


setup()
{
	ei.hite = 24;
	ei.wid  = 80;
	ei.clead1[0] = 2;
	ei.clead1[1] = ESC;
	ei.clead1[2] = '=';
	ei.clead2[0] = 0;
	ei.ctrail[0] = 0;
	ei.cb4lfg = 0;
	ei.linoff = ei.coloff = ' ';
	ei.ascur = 0;
	ei.erascr[0] = 1;
	ei.erascr[1] = 'Z' & 31;

	loadi();

	strcpy(ftname, "work.fn2");
	strcpy(ftname2,"work2.fn2");
	screen = TRUE;
	mxflag = FALSE;
	ovlflag = FALSE;
	currch = 'A';
	edfnum = currch;
	currlen = 0;
	currfont = FALSE;

	ib = 0;
#if WYSE
	gxoff = 4;
	gyoff = 6;
#endif

	strcpy(sbuf,
	"abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ");
}

char conin()
{	return (bios(3));
}

conout(c)
char c;
{	if (screen) bios(4, c);
}

#if WYSE
tokeep()
{
	tokepp(0, currch);
	if (duplflag) tokepp(3, dtrans(currch, FALSE));
}

tokepp(ib, currch)
char ib, currch;
#else
tokeep()
#endif
{	int i, j, cbase;

	if (currfont)
	{
		cbase = fix2[currch];
		currlen = (fix2[currch+1] - cbase) / 3;
	}
	else
	{
		cbase = fix[currch];
		currlen = (fix[currch+1] - cbase) / 3;
	}

	if (currlen > 80) currlen = 80;
	for (i = 0; i < 3; i++)
	 for (j = 0; j < 80; j++)
	  if (j >= currlen) ckeep[ib+i][j] = 0;
	   else if (currfont) ckeep[ib+i][j] = ft2[cbase + j + i*currlen];
	   		else  ckeep[ib+i][j] =  ft[cbase + j + i*currlen];
}


#if WYSE
fromkeep()
{
	frommkeep(0,currch);
	if (duplflag) frommkeep(3, dtrans(currch, FALSE));
}

frommkeep(ib, currch)
char ib, currch;
#else
fromkeep()
#endif
{	int i, j, cend, cbase, cnext, mlen;

	if (currfont)
	{
		cbase = fix2[currch];
		cnext = fix2[currch+1];
	}
	else
	{
		cbase = fix[currch];
		cnext = fix[currch+1];
	}

	cend = cbase + currlen * 3;
	mlen = (cend-cnext) ? (ovlflag?
				 (2*FTSIZE):FTSIZE)
				- 1 - max(cnext,cend)
			      : 0;

	if (mlen)
	if (currfont)
	{	movmem(ft2+cnext, ft2+cend, mlen); 
	 	for (i = currch+1; i < 128; i++)
			fix2[i] = fix2[i] + cend - cnext;
		for (i = 0; i < 127; i++)
			ftlen2[i] = (fix2[i+1] - fix2[i])/3;
	}
	else
	{	movmem(ft+cnext, ft+cend, mlen); 
	 	for (i = currch+1; i < 128; i++)
			fix[i] = fix[i] + cend - cnext;
		for (i = 0; i < 127; i++)
			ftlen[i] = (fix[i+1] - fix[i])/3;
		if (fix[127] >= FTSIZE) ovlflag = TRUE;
	}

	if (currlen)
	for (i = 0; i < 3; i++)
	 for (j = 0; j < currlen; j++)
		if (currfont)
			ft2[cbase + j + i*currlen] = ckeep[ib+i][j];
		else	 ft[cbase + j + i*currlen] = ckeep[ib+i][j];
}

constring(spt)
char *spt;
{	char len;
	len = *spt++;
	while (len--) conout(*spt++);
}

connum(n)
char n;
{	char dstr[4];

	if (!ei.ascur) { conout(n); return; }
	sprintf(dstr, "%3d", n);
	if (ei.ascur == 3 && *dstr != ' ') conout(*dstr);
	if (dstr[1] != ' ') conout(dstr[1]);
	conout(dstr[2]);
}


gxy(x, y)
char x, y;
{
	constring(ei.clead1);
	if (ei.cb4lfg) connum(x + ei.coloff);
		else connum(y + ei.linoff);
	constring(ei.clead2);
	if (ei.cb4lfg) connum(y + ei.linoff);
		else connum(x + ei.coloff);
	constring(ei.ctrail);
}

clrscrn()
{
#if WYSE
	color(BLACK,WHITE);
#endif
	constring(ei.erascr);
	if (screen) sleep(1);
}

char key()
{	char c;

	c = conin();
	if (c < ' ') c += '@';
		else if (c >='A' && c <= 'Z')
		c += ' ';
	return(c);
}

info(ic)
int ic;
{
	if (!screen) return;

	if (ic < 15)
	{
#if WYSE
		color(BLUE,WHITE);
#endif
		gxy(1,5); puts("E");
		gxy(1,6); puts("D");
		gxy(1,7); puts("I");
		gxy(1,8); puts("T");
#if WYSE
		color(BLACK,WHITE);
#endif
	}

	gxy(ic+5, 4); puts("^E cursor up     ^R up 8");
	gxy(ic+5, 5); puts("^S cursor left   ^A left 8");
	gxy(ic+5, 6); puts("^D cursor right  ^F right 8");
	gxy(ic+5, 7); puts("^X cursor down   ^C down 8");
	gxy(ic+5, 8); puts(",  dot on        SP dot off");

	if (ic > 15)
	{
	gxy(ic+5, 9); puts("w  widen         n  narrow");
	gxy(ic+5,10); puts("+  add column    -  delete column");
	gxy(ic+5,11); puts("0  add blank column");
	gxy(ic+5,12); puts("u  up scroll     d  down scroll");
	gxy(ic+5,13); puts("p  plus row      m  minus row");
	gxy(ic+5,14); puts("r  right row     l  left row");
	gxy(ic+5,15); puts("q  quit edit");
		return;
	}

	gxy(ic+5, 9); puts("?  for info on: w n u d p m 0 r l x");

	gxy(ic,11); puts("Width change             Edit");
	gxy(ic,12); puts("Zero character           Xit to CPM");
	gxy(ic,13); puts("Get character");
	gxy(ic,14); puts("Copy to character        Name font");
	gxy(ic,15); puts("Phrase for test print    Open font");
	gxy(ic,16); puts("Test print               Save font");
	gxy(ic,17); puts("Quiet console tog        Read EDF");
	gxy(ic,18); puts("1st font                 Disk write EDF");
	gxy(ic,19); puts("2nd font                 Mode change");
}

prompt()
{	int i;

	if (!screen) return;

	gxy(0,0);
	puts("ECHED ");

	if (currfont) puts("(F1="); else puts("F1=");
	puts(ftname);
	if (currfont) puts(") F2="); else puts(" (F2=");
	if (ovlflag) puts("..none.."); else puts(ftname2);
	if (!currfont) puts(")");

	puts(" Character=");
	if (currch < ' ')
	{	conout('^');
		conout(currch + 64);
	}
	else
	{
		conout(currch);
	}

	printf(" W=%2d ", currlen);

	if (currfont)
	printf("Room=%xH  ", FTSIZE-fix2[127]);
	else
	printf("Room=%xH  ", (ovlflag? (2*FTSIZE) : FTSIZE) - fix[127]);

	gxy(3,1);
#if WYSE
	printf("Test phrase is ");
	color(GREEN,WHITE);
	printf("%-65s", sbuf);
	color(BLACK,WHITE);
#else
	printf("Test phrase is %-77s", sbuf);
#endif
}

dtrans(c, upper)
char c, upper;
{	if (c == 0x20 || c == 0x5F) return(c);

	if (c >= 0x60) c -= 0x20;
	else if (c < 0x20) c += 0x20;

	if (upper) return(c);

	if (c < 0x40) c -= 0x20;
	else c += 0x20;

	return(c);
}

chkdupl()
{
	duplflag = (currfont ? fix2[0] : fix[0]) & PRPTNL;
#if WYSE
	if (duplflag) currch = dtrans(currch, TRUE);
#endif
}

rdedf()
{	char edname[11], edbuf[BUFSIZ], eds[80];
	char c;
	int lbear, ytop, rbear;
	int i, dcurrlen;

	duplflag = (currfont ? fix2[0] : fix[0]) & PRPTNL;

	if  (duplflag)	edfnum = dtrans(edfnum, TRUE);

	currch = edfnum;

	sprintf(edname, "A%d.EDF", edfnum);

	if (fopen(edname, edbuf) == ERROR)
	{	message("no edf file");	return;	}

	fscanf(edbuf, "%d %d %d", &lbear, &rbear, &ytop);

	if (lbear) lbear--; if (rbear) rbear--;

	setmem(ckeep, 3*80, 0);
	currlen = 0; dcurrlen = 10000;


	row = (duplflag ? 47 : 23) - ytop;

	if (row < 0)
	{	message("YTOP of ");
		printf("%d is too large", ytop);
	}

	for ( ; fgets(eds, edbuf); row++)
	{
		if (row > 23)
		{	row = 0;
			fromkeep();
			setmem(ckeep, 3*80, 0);
			dcurrlen = currlen;
			currch = dtrans(currch, FALSE);
		}
		else if (row < 0) continue;

		for (i = 0, col = lbear; c = eds[i++]; col++)
		 if (c == '*') chngbit(TRUE);

		if (currlen < col + rbear)
			currlen = col + rbear;
	}


	fclose(edbuf);

	fromkeep();

	if (duplflag)
	{	if (dcurrlen == 10000)
		{	setmem(ckeep, 3*80, 0);
			currch = dtrans(currch, FALSE);
			fromkeep();
		}

		currch = edfnum;

		if (currlen > dcurrlen)
		{	dcurrlen = currlen;
			tokeep();
			currlen = dcurrlen;
			fromkeep();
		}
	}

	edfnum++;
	prompt();
}


wtedf(cndns)
char cndns;
{	char edname[11], edbuf[BUFSIZ], eds[80];
	char c, lbear, ytop, rbear;
	char i, j, bit, mask;

	duplflag = (currfont ? fix2[0] : fix[0]) & PRPTNL;

	if (duplflag) edfnum = dtrans(edfnum, TRUE);

	currch = edfnum;

	tokeep();

if (currlen)
{
	sprintf(edname, "A%d.EDF", edfnum);

	if (fcreat(edname, edbuf) == ERROR)
	{	gxy(2, 20);
		puts("can't open edf file");
		return;
	}

	for (i = ytop = 0, lbear = rbear = currlen; i < 3; i++)
	 for (j = 0; j < currlen; j++)
	  {	cbyte = ckeep[i][j];
		mask = 128;
		for (bit = 0; bit < 8; bit++, mask >>= 1)
		 if (mask & cbyte)
		{	  /* j is col; i + bit*3 is row */
			if (lbear > j) lbear = j;
			if (rbear >= currlen - j)
				rbear = currlen - j - 1;
			if (ytop < 23 - (i + bit*3))
				ytop = 23 - (i + bit*3);
		}
	  }
	if (lbear == currlen) lbear = rbear = currlen / (cndns? 2:1);
	if (duplflag) lbear = rbear = 0;

	fprintf(edbuf, "%d %d %d\n", lbear/(cndns? 2:1) + 1,
				 rbear/(cndns? 2:1) + 1,
			 ytop + (duplflag? 24:0) );


	for (row = 23 - ytop; row < 24; row++)
	{	for (i = 0; i < currlen; i++) eds[i] = ' ';

		for (i = 0, col = lbear; col < currlen - rbear; col++,i++)
			if (testbit())	eds[i/(cndns? 2:1)] = '*';

		i = currlen;
		while (i && eds[i-1] == ' ') i--;

		eds[i] = '\0';
		fprintf(edbuf, "%s\n", eds);
		if (duplflag && row == 23 && currch == edfnum)
		{	currch = dtrans(currch, FALSE);
			if (currch != edfnum)
			{ row = 0;	tokeep(); }
		}
	}

	currch = edfnum;

	fprintf(edbuf, "%c", CPMEOF);
	fclose(edbuf);
}
	edfnum++;
	prompt();
}

#if WYSE
testbit()
{	if (duplflag && row > 23) ttestbit(3, row-24);
	else ttestbit(0, row);
}
ttestbit(ib, row)
char ib; int row;
#else
testbit()
#endif
{	char bit, mask;
	
	bit = row / 3;
	mask = 128 >> bit; 
	cbyte = ckeep[ib+(row % 3)][col];

	if (cbyte & mask) return(TRUE);

	return(FALSE);
}

#if WYSE
showbits()
{	if (duplflag) gyoff = 0; else gyoff = 6;
	sshowbits(0);
	if (duplflag)
	{	gyoff = 12;
		sshowbits(3);
		gyoff = 0;
	}
	ongcurs();
}

sshowbits(ib)
char ib;
#else
showbits()
#endif
{	char i, j, bit, mask, r;

	if (!screen) return;

#if WYSE
	if (gyoff <= 6)
#endif
	clrscrn();

	If (currlen > 0)
#if WYSE
     {
	color(RED,WHITE);
	if (gyoff == 6)
	{	gxy(gxoff-1,gyoff-1);
		conout('2');
		for (i = 0; i < currlen; i++)
			conout(':');
		conout('3');
	}
	for (i = gyoff; i < (gyoff+12); i++)
	  {
		gxy(gxoff-1,i); conout('6');
		gxy(currlen+gxoff,i); conout('6');
	  }
	if (gyoff == 6)
	{	gxy(gxoff-1,gyoff+12);
		conout('1');
		for (i = 0; i < currlen; i++)
			conout(':');
		conout('5');
	}
	color(BLACK,WHITE);
     }

	for (i = 0; i < 3; i++)
	 for (j = 0; j < currlen; j++)
	  {	cbyte = ckeep[ib+i][j];
		cbyteo = ckeep[ib + ((i+1) % 3)][j];
		mask = 128;
		for (bit = 0; bit < 8; bit++, mask >>= 1)
		 if (
			 /* if row is even */
			!((r = i + bit*3) & 1)
			 /* and there is a dot in this row or the next */
		     && ((mask & cbyte) | ((i==2 ? mask>>1: mask) & cbyteo))
		    )
		 {	gxy(j+gxoff, r/2+gyoff);
			 /* both dots? */
			if ((mask & cbyte)&& ((i==2 ? mask>>1: mask) & cbyteo))
				conout(BOTHDOT);
			/* dot in this row only? */
			else if (mask & cbyte)
				conout(UPPRDOT);
			else conout(LOWRDOT);	/* must be dot in next row */
		 }
	  }
#else
	 for (i = 0; i < 24; i++)
	  { gxy(currlen,i); conout('|'); }

	for (i = 0; i < 3; i++)
	 for (j = 0; j < 80; j++)
	  {	cbyte = ckeep[i][j];
		mask = 128;
		for (bit = 0; bit < 8; bit++, mask >>= 1)
		 if (mask & cbyte)
		  { gxy(j, i + bit*3); conout('*'); }
	  }
#endif
}

scinit()
{
	col = LEFTCOL; row = TOPROW;

	if (!screen) return;

	prompt();
	gxy(2,20);
	printf("%-78s"," ");
	info(10);
	gxy(col,row);
}

nextcol()
{	if (col < RIGHTCOL) col++;
	else	{	col = LEFTCOL;
#if WYSE
			if (duplflag && row < 47)
			  { row++; return;}
#endif
			if (row < BOTROW) row++;
		}
}

#if WYSE
chngbit(biton)
char biton;
{	if (duplflag && row > 23) cchngbit(3, row - 24, biton);
	else cchngbit(0, row, biton);
}

cchngbit(ib, row, biton)
char ib, row;
#else
chngbit(biton)
#endif
char biton;
{	char bit, mask;
	
	bit = row / 3;
	mask = 128 >> bit; 
	cbyte = ckeep[ib + (row % 3)][col];
	if (biton) cbyte |= mask;
		else cbyte &= ~mask;
	ckeep[ib + (row % 3)][col] = cbyte;
}

dirow(del)
char del;
{	char i, j, ps, psnx, bit, mask, masknx, cnext;

	for (j = 0; j < currlen; j++)
	if (del)
#if WYSE
	for (i = row; i < (duplflag? 47 : 23); i++)
#else
	for (i = row; i < 23; i++)
#endif
	{
		bit = (i / 3) % 8;
		mask = 128 >> bit;
		ps = i % 3;
		masknx = (ps == 2)? mask >> 1: mask;
		psnx = (ps == 2)? 0: ps + 1;
#if WYSE
		if (duplflag)
		 if (i == 23) { psnx += 3; masknx = 128; }
		 else if (i > 23) { ps += 3; psnx += 3; }
#endif
		cbyte = ckeep[ps][j];
		cnext = ckeep[psnx][j];
		if (cnext & masknx) cbyte |= mask;
			else cbyte &= ~mask;
		ckeep[ps][j] = cbyte;
	}
	else
#if WYSE
	for (i = (duplflag? 47 : 23); i > row; i--)
#else
	for (i = 23; i > row; i--)
#endif
	{
		bit = (i / 3) % 8;
		mask = 128 >> bit;
		ps = i % 3;
		masknx = (ps)? mask: mask << 1;
		psnx = (ps)? ps - 1: 2;
#if WYSE
		if (duplflag)
		 if (i == 24) { ps += 3; masknx = 1; }
		 else if (i > 24) { ps += 3; psnx += 3; }
#endif

		cbyte = ckeep[ps][j];
		cnext = ckeep[psnx][j];
		if (cnext & masknx) cbyte |= mask;
			else cbyte &= ~mask;
		ckeep[ps][j] = cbyte;
	}

	showbits();
}

#if WYSE
rotate(left)
char left;
{	if (duplflag && row > 23) rrotate(3, row - 24, left);
	else rrotate(0, row, left);
}

rrotate(ib, row, left)
char ib, row;
#else
rotate(left)
#endif
char left;
{	char j, cl, bit, mask, cnext;
	
	for (j = 0; j < 80; j++)
	{
		cl = left ? j : 79 - j;
		bit = row / 3;
		mask = 128 >> bit; 
		cbyte = ckeep[ib + (row % 3)][cl];
		cnext = (j==79)? 0 : ckeep[ib+(row % 3)][left? cl+1:cl-1];
		if (cnext & mask) cbyte |= mask;
			else cbyte &= ~mask;
		ckeep[ib + (row % 3)][cl] = cbyte;
	}
	showbits();
}

#if WYSE
dicol(opt)
char opt;
{	if (duplflag) ddicol(3, row - 24, opt);
	ddicol(0, row, opt);
	showbits();
}

ddicol(ib, row, opt)
char ib, row;
#else
dicol(opt)
#endif
char opt;
{	char i, j;

	for (i = 0; i < 3; i++)
	{	if (!opt)	/* delete a column */
			for (j = col; j < 79; j++)
	  			ckeep[ib+i][j] = ckeep[ib+i][j+1];
		else		/* insert a column */
		{
	 		for (j = 79; j > col; j--)
	   			ckeep[ib+i][j] = ckeep[ib+i][j-1];
			if (opt == 1) ckeep[ib+i][col] = 0;
		}
	}
#if !WYSE
	showbits();
#endif
}

#if WYSE
scroll(up)
char up;
{	sscroll(0, up);
	if (duplflag) sscroll(3, up);
	showbits();
}

sscroll(ib, up)
char ib;
#else
scroll(up)
#endif
char up;
{	char i, j, temp;

	if (up)
	 for (j = 0; j < currlen; j++)
	 {	temp = ckeep[ib+0][j];
		ckeep[ib+0][j] = ckeep[ib+1][j];
		ckeep[ib+1][j] = ckeep[ib+2][j];
		ckeep[ib+2][j] = temp << 1;
#if WYSE
		if (duplflag && !ib)
		ckeep[2][j] |= ckeep[3][j] >> 7;
#endif
	 }
	else
	 for (j = 0; j < currlen; j++)
	 {
		temp = ckeep[ib+2][j];
		ckeep[ib+2][j] = ckeep[ib+1][j];
		ckeep[ib+1][j] = ckeep[ib+0][j];
		ckeep[ib+0][j] = temp >> 1;
#if WYSE
/* when ib = 0, save b0 -- when i = 3 put this for b7 */
		if (ib) ckeep[ib][j] |= ckeep[2][j] << 7;
#endif
	 }
#if !WYSE
	showbits();
#endif
}

#if WYSE

#define BLACK	'1'
#define BLUE	'2'
#define CYAN	'4'
#define WHITE	'8'

graph(yes)
char yes;
{	conout(ESC);	conout('H');
	if (yes) conout(2); else conout(3);
	conout(ESC);	conout('`');	/* cursor off/on	*/
	if (yes) conout('0'); else conout('1');
	if (!yes) color(BLACK, WHITE);
}

color(fc, bc)
char fc, bc;
{	conout(ESC);	conout('g');
	conout(fc);	conout(bc);
}


char oldgc, newgc, ogcol, ogrow;

offgcurs()
{	gxy(ogcol+gxoff, ogrow/2+gyoff);
	color(BLACK, WHITE);
	conout(oldgc);
}

ongcurs()
{	char fc, bc;

	gxy(col+gxoff, row/2+gyoff);
	conout(ESC);	conout('M'); /* get char at cursor */
	oldgc = conin();
	newgc = oldgc;
	switch(oldgc + ((row & 1)? 2 : 0))
	{	case 0:
		case NODOT: fc = CYAN; bc = WHITE; newgc = UPPRDOT;
			break;
		case 2:
		case NODOT+2: fc = CYAN; bc = WHITE; newgc = LOWRDOT;
			break;
		case BOTHDOT:   fc = BLUE; bc = BLACK; newgc = UPPRDOT;
			break;
		case BOTHDOT+2: fc = BLUE; bc = BLACK; newgc = LOWRDOT;
			break;
		case UPPRDOT:   fc = BLUE; bc = WHITE;
			break;
		case UPPRDOT+2: fc = BLACK; bc = CYAN;
			break;
		case LOWRDOT:   fc = BLACK; bc = CYAN;
			break;
		case LOWRDOT+2: fc = BLUE; bc = WHITE;
			break;
		default:	return;	break;
	}
	color(fc, bc);
	conout(newgc);
}

pixel(on)
char on;
{
	switch(oldgc + ((row & 1)? 2 : 0))
	{	case 0:
		case NODOT: if (on) oldgc = UPPRDOT;
			break;
		case 2:
		case NODOT+2: if (on) oldgc = LOWRDOT;
			break;
		case BOTHDOT:   if (!on) oldgc = LOWRDOT;
			break;
		case BOTHDOT+2: if (!on) oldgc = UPPRDOT;
			break;
		case UPPRDOT:
		case LOWRDOT+2: if (!on) oldgc = NODOT;
			break;
		case UPPRDOT+2:
		case LOWRDOT:   if (on) oldgc = BOTHDOT;
			break;
		default:	return;	break;
	}

}

#endif



edscr()
{
#if WYSE
	graph(TRUE);
#endif
	col = 0; row = 23 - 5;
	showbits();
	cmd = 'E';
	while (cmd != 'q')
	{
#if WYSE
		ogcol = col;	ogrow = row;
#endif
		switch (cmd) {
	  	case 'S': if (col>0) col = (col + 79) % 80; break;
		case 'D': if (col<79)col = (col + 81) % 80; break;
#if WYSE
		case 'E': row = duplflag? (row+47)%48 :(row+23)%24;
			 break;
		case 'X': row = duplflag? (row+49)%48 :(row+25)%24;
			 break;
		case 'R': row = duplflag? (row+40)%48 :(row+16)%24;
			 break;
		case 'C': row = duplflag? (row+56)%48 :(row+32)%24;
			 break;
#else
		case 'E': row = (row + 23) % 24; break;
		case 'X': row = (row + 25) % 24; break;
		case 'R': row = (row + 16) % 24; break;
		case 'C': row = (row + 32) % 24; break;
#endif

	  	case 'A': if (col>7) col = (col + 72) % 80; break;
		case 'F': if (col<67)col = (col + 88) % 80; break;
		case ',':
#if WYSE
			  pixel(TRUE);
#else
			  conout('*');
#endif
			  chngbit(TRUE);
			  nextcol();
			  break;
		case '.':
		case ' ':
#if WYSE
			  pixel(FALSE);
#else
			  conout(' ');
#endif
			  chngbit(FALSE);
			  nextcol();
			  break;
		case '-': dicol(FALSE); 	break;
		case '0': dicol(TRUE);  	break;
		case '+': dicol(TRUE+1);  	break;
		case 'p': dirow(FALSE);		break;
		case 'm': dirow(TRUE);		break;
		case 'r': rotate(FALSE);	break;
		case 'l': rotate(TRUE);		break;
		case 'Z':
		case 'd': scroll(FALSE); 	break;
		case 'W':
		case 'u': scroll(TRUE);  	break;
		case 'w': currlen++;
		  	  showbits();
		  	  break;
		case 'n': currlen--;
		  	  showbits();
		  	  break;
		case '?':
#if WYSE
			  graph(FALSE);
#endif
			  info(40);
#if WYSE
			  graph(TRUE);
#endif
			  break;
		case '\n':break;
		default:  showbits();
		}
#if WYSE
		offgcurs();	;ongcurs();
#else
		gxy(col, row);
#endif
		cmd = key();
	}
#if WYSE
	graph(FALSE);
#endif
}


/* masks for mode bits */
/* ELITE 0x01, PRPTNL	 0x02, CMPRSSD  0x04, EMPHSZD  0x08
DBLSTRK  0x10, EXPNDD	 0x20, UNDRLN	 0x40, ITALIC	 0x80
*/

mvalue(choice, toggle)
char choice, toggle;
{	int cmode, bit, kernval;

	if (choice < 10 || choice > 18) return;

	if (choice == 18) bit = 0;
	else bit = 0x80 >> (17 - choice);

	cmode = currfont ? fix2[0] : fix[0];
	kernval = cmode >> 8;
	if (cmode < 0) kernval |= 0xFF00;
	if (toggle)
	{	if (choice == 18)
		{	puts(">");
			scanf("%d", &kernval);
			gxy(0,18);
			puts("     ");
			cmode |= kernval << 8;
		}
		else
		{	if (cmode & bit) cmode &= ~bit;
			else cmode |= bit;
		}
	}

	gxy(20, choice);
	if (choice == 18) printf("%4d", kernval);
	else if (cmode & bit)
		  puts(" ON");
	     else puts("OFF");

	if (currfont) fix2[0] = cmode; else fix[0] = cmode;
	chkdupl();
}

modeset()
{	int i;

	clrscrn();
	gxy(10,3); puts("Font Mode");

	gxy(5,10); puts("Elite");
	gxy(5,11); puts("Duplex");
	gxy(5,12); puts("Compressed");
	gxy(5,13); puts("Emphasized");
	gxy(5,14); puts("Double Strike");
	gxy(5,15); puts("Expanded");
	gxy(5,16); puts("Underlined");
	gxy(5,17); puts("Italic");
	gxy(5,18); puts("Kerning");

	for (i = 10; i < 19; i++) mvalue(i, FALSE);

	col = 0; row = 10;
	gxy(col, row);
	cmd = key();

	while (cmd != 'x' && cmd != 'q')
	{	switch (cmd)
		{
		case 'E': row = (row + 23) % 24; break;
		case 'X': row = (row + 25) % 24; break;
		case 'R': row = (row + 16) % 24; break;
		case 'C': row = (row + 32) % 24; break;

		default:  break;
		}

		if (!isupper(cmd)) mvalue(row, TRUE);

		gxy(col, row);
		cmd = key();
	}
}
	

/************************************************/
/* Load initialization data			*/
/************************************************/
loadi()
{	int fd;
	char *iname;

	iname = "eched.ini";

	if ((fd = open(iname,0)) != ERROR)
	  if ((seek(fd, 2, 0) == ERROR) || (read(fd, ei, 1) != 1))
	  {	printf("\n%s", "Bad file ECHED.INI"); return(ERROR); }
	fabort(fd);

}